Skip to content
Back to search

magg

Magg: The MCP Aggregator

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/sitbon--magg/badge.svg)](/listings/sitbon--magg)

HTML

<a href="/listings/sitbon--magg"><img src="/api/listings/sitbon--magg/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

- Python 3.12 or higher (3.13+ recommended) - `uv` (recommended) - Install from [astral.sh/uv](https://astral.sh/uv)

Quick Install (Recommended)

The easiest way to install Magg is as a tool using `uv`:

# Install Magg as a tool
uv tool install magg

# Run with stdio transport (for Claude Desktop, Cline, etc.)
magg serve

# Run with HTTP transport (for system-wide access)
magg serve --http

Alternative: Run Directly from GitHub

You can also run Magg directly from GitHub without installing:

# Run with stdio transport
uvx --from git+https://github.com/sitbon/magg.git magg

# Run with HTTP transport
uvx --from git+https://github.com/sitbon/magg.git magg serve --http

Local Development

For development, clone the repository and install in editable mode:

# Clone the repository
git clone https://github.com/sitbon/magg.git
cd magg

# Install in development mode with dev dependencies
uv sync --dev

# Or with poetry
poetry install --with dev

# Run the CLI
magg --help

Docker

Magg is available as pre-built Docker images from GitHub Container Registry:

# Run production image (WARNING log level)
docker run -p 8000:8000 ghcr.io/sitbon/magg:latest

# Run with authentication (mount or set private key)
docker run -p 8000:8000 \
  -v ~/.ssh/magg:/home/magg/.ssh/magg:ro \
  ghcr.io/sitbon/magg:latest

# Or with environment variable
docker run -p 8000:8000 \
  -e MAGG_PRIVATE_KEY="$(cat ~/.ssh/magg/magg.key)" \
  ghcr.io/sitbon/magg:latest

# Run beta image (INFO log level)
docker run -p 8000:8000 ghcr.io/sitbon/magg:beta

# Run with custom config directory
docker run -p 8000:8000 \
  -v /path/to/config:/home/magg/.magg \
  ghcr.io/sitbon/magg:latest

Docker Image Strategy

Magg uses a multi-stage Docker build with three target stages:

- **`pro` (Production)**: Minimal image with WARNING log level, suitable for production deployments - **`pre` (Pre-production)**: Same as production but with INFO log level for staging/testing (available but not published) - **`dev` (Development)**: Includes development dependencies and DEBUG logging for troubleshooting

Images are automatically published to GitHub Container Registry with the following tags:

- **Version tags** (from main branch): `1.2.3`, `1.2`, `dev`, `1.2-dev`, `1.2-dev-py3.12`, etc. - **Branch tags** (from beta branch): `beta`, `beta-dev` - **Python-specific dev tags**: `beta-dev-py3.12`, `beta-dev-py3.13`, etc.

Pull requests build and test images but do not publish them unless a maintainer adds the `push-image` label, which publishes ephemeral `pr-NN` / `pr-NN-dev` tags (same-repo PRs only). Ephemeral `pr-*` tags and untagged manifests are cleaned up weekly; version tags are kept forever, so pinned deployments are never affected.

Docker Compose

For easier management, use Docker Compose:

# Clone the repository
git clone https://github.com/sitbon/magg.git
cd magg

# Run production version
docker compose up magg

# Run staging version (on port 8001)
docker compose up magg-beta

# Run development version (on port 8008)
# This uses ./.magg/config.json for configuration
docker compose up magg-dev

# Build and run with custom registry
REGISTRY=my.registry.com docker compose build
REGISTRY=my.registry.com docker compose push

See `compose.yaml` and `.env.example` for configuration options.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

readme.md · README · 512 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # 🧲 **Magg** - *The MCP Aggregator*
  2. [//]: # ([![Tests]&#40;https://img.shields.io/github/actions/workflow/status/sitbon/magg/test.yml?style=flat-square&label=tests&#41;]&#40;https://github.com/sitbon/magg/actions/workflows/test.yml&#41;)
  3. [![Python Version](https://img.shields.io/pypi/pyversions/magg?style=flat-square&logo=python&logoColor=white)](https://pypi.org/project/magg/)
  4. [![PyPI Version](https://img.shields.io/pypi/v/magg?style=flat-square&logo=pypi&logoColor=white)](https://pypi.org/project/magg/)
  5. [![GitHub Release](https://img.shields.io/github/v/release/sitbon/magg?style=flat-square&logo=github)](https://github.com/sitbon/magg/releases)
  6. [![DeepWiki](https://img.shields.io/badge/DeepWiki-sitbon%2Fmagg-blue.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACwAAAAyCAYAAAAnWDnqAAAAAXNSR0IArs4c6QAAA05JREFUaEPtmUtyEzEQhtWTQyQLHNak2AB7ZnyXZMEjXMGeK/AIi+QuHrMnbChYY7MIh8g01fJoopFb0uhhEqqcbWTp06/uv1saEDv4O3n3dV60RfP947Mm9/SQc0ICFQgzfc4CYZoTPAswgSJCCUJUnAAoRHOAUOcATwbmVLWdGoH//PB8mnKqScAhsD0kYP3j/Yt5LPQe2KvcXmGvRHcDnpxfL2zOYJ1mFwrryWTz0advv1Ut4CJgf5uhDuDj5eUcAUoahrdY/56ebRWeraTjMt/00Sh3UDtjgHtQNHwcRGOC98BJEAEymycmYcWwOprTgcB6VZ5JK5TAJ+fXGLBm3FDAmn6oPPjR4rKCAoJCal2eAiQp2x0vxTPB3ALO2CRkwmDy5WohzBDwSEFKRwPbknEggCPB/imwrycgxX2NzoMCHhPkDwqYMr9tRcP5qNrMZHkVnOjRMWwLCcr8ohBVb1OMjxLwGCvjTikrsBOiA6fNyCrm8V1rP93iVPpwaE+gO0SsWmPiXB+jikdf6SizrT5qKasx5j8ABbHpFTx+vFXp9EnYQmLx02h1QTTrl6eDqxLnGjporxl3NL3agEvXdT0WmEost648sQOYAeJS9Q7bfUVoMGnjo4AZdUMQku50McDcMWcBPvr0SzbTAFDfvJqwLzgxwATnCgnp4wDl6Aa+Ax283gghmj+vj7feE2KBBRMW3FzOpLOADl0Isb5587h/U4gGvkt5v60Z1VLG8BhYjbzRwyQZemwAd6cCR5/XFWLYZRIMpX39AR0tjaGGiGzLVyhse5C9RKC6ai42ppWPKiBagOvaYk8lO7DajerabOZP46Lby5wKjw1HCRx7p9sVMOWGzb/vA1hwiWc6jm3MvQDTogQkiqIhJV0nBQBTU+3okKCFDy9WwferkHjtxib7t3xIUQtHxnIwtx4mpg26/HfwVNVDb4oI9RHmx5WGelRVlrtiw43zboCLaxv46AZeB3IlTkwouebTr1y2NjSpHz68WNFjHvupy3q8TFn3Hos2IAk4Ju5dCo8B3wP7VPr/FGaKiG+T+v+TQqIrOqMTL1VdWV1DdmcbO8KXBz6esmYWYKPwDL5b5FA1a0hwapHiom0r/cKaoqr+27/XcrS5UwSMbQAAAABJRU5ErkJggg==)](https://deepwiki.com/sitbon/magg)
  7. [![Downloads](https://img.shields.io/pypi/dm/magg?style=flat-square)](https://pypistats.org/packages/magg)
  8. <!-- DeepWiki badge generated by https://deepwiki.ryoppippi.com/ -->
  9. [![Tests](https://github.com/sitbon/magg/actions/workflows/test.yml/badge.svg)](https://github.com/sitbon/magg/actions/workflows/test.yml)
  10. [![Docker](https://github.com/sitbon/magg/actions/workflows/docker-publish.yml/badge.svg)](https://github.com/sitbon/magg/actions/workflows/docker-publish.yml)
  11. A *[Model Context Protocol](https://modelcontextprotocol.io/)* server that manages, aggregates, and proxies other MCP servers, enabling LLMs to dynamically extend their own capabilities.
  12. ## What is Magg?
  13. Magg is a meta-MCP server that acts as a central hub for managing multiple MCP servers. It provides tools that allow LLMs to:
  14. - Search for new MCP servers and discover setup instructions
  15. - Add and configure MCP servers dynamically
  16. - Enable/disable servers on demand
  17. - Aggregate tools from multiple servers under unified prefixes
  18. - Persist configurations across sessions
  19. Think of Magg as a "package manager for LLM tools" - it lets AI assistants install and manage their own capabilities at runtime.
  20. ## Features
  21. - **Self-Service Tool Management**: LLMs can search for and add new MCP servers without human intervention.
  22. - **Dynamic Configuration Reloading**: Automatically detects and applies config changes without restarting.
  23. - **Automatic Tool Proxying**: Tools from added servers are automatically exposed with configurable prefixes.
  24. - **ProxyMCP Tool**: A built-in tool that proxies the MCP protocol to itself, for clients that don't support notifications or dynamic tool updates (which is most of them currently).
  25. - **Smart Configuration**: Uses MCP sampling to intelligently configure servers from just a URL.
  26. - **Persistent Configuration**: Maintains server configurations in `.magg/config.json`.
  27. - **Multiple Transport Support**: Works with stdio, HTTP, and in-memory transports.
  28. - **Bearer Token Authentication**: Optional RSA-based JWT authentication for secure HTTP access.
  29. - **Docker Support**: Pre-built images for production, staging, and development workflows.
  30. - **Health Monitoring**: Built-in `magg_status` and `magg_check` tools for server health checks.
  31. - **Real-time Messaging**: Full support for MCP notifications and messages - receive tool/resource updates and progress notifications from backend servers.
  32. - **Python 3.12+ Support**: Fully compatible with Python 3.12 and 3.13.
  33. - **Kit Management**: Bundle related MCP servers into kits for easy loading/unloading as a group.
  34. - **MBro CLI**: Included [MCP Browser](docs/mbro.md) for interactive exploration and management of MCP servers, with script support for automation.
  35. ## Installation
  36. ### Prerequisites
  37. - Python 3.12 or higher (3.13+ recommended)
  38. - `uv` (recommended) - Install from [astral.sh/uv](https://astral.sh/uv)
  39. ### Quick Install (Recommended)
  40. The easiest way to install Magg is as a tool using `uv`:
  41. ```bash
  42. # Install Magg as a tool
  43. uv tool install magg
  44. # Run with stdio transport (for Claude Desktop, Cline, etc.)
  45. magg serve
  46. # Run with HTTP transport (for system-wide access)
  47. magg serve --http
  48. ```
  49. ### Alternative: Run Directly from GitHub
  50. You can also run Magg directly from GitHub without installing:
  51. ```bash
  52. # Run with stdio transport
  53. uvx --from git+https://github.com/sitbon/magg.git magg
  54. # Run with HTTP transport
  55. uvx --from git+https://github.com/sitbon/magg.git magg serve --http
  56. ```
  57. ### Local Development
  58. For development, clone the repository and install in editable mode:
  59. ```bash
  60. # Clone the repository
  61. git clone https://github.com/sitbon/magg.git
  62. cd magg
  63. # Install in development mode with dev dependencies
  64. uv sync --dev
  65. # Or with poetry
  66. poetry install --with dev
  67. # Run the CLI
  68. magg --help
  69. ```
  70. ### Docker
  71. Magg is available as pre-built Docker images from GitHub Container Registry:
  72. ```bash
  73. # Run production image (WARNING log level)
  74. docker run -p 8000:8000 ghcr.io/sitbon/magg:latest
  75. # Run with authentication (mount or set private key)
  76. docker run -p 8000:8000 \
  77. -v ~/.ssh/magg:/home/magg/.ssh/magg:ro \
  78. ghcr.io/sitbon/magg:latest
  79. # Or with environment variable
  80. docker run -p 8000:8000 \
  81. -e MAGG_PRIVATE_KEY="$(cat ~/.ssh/magg/magg.key)" \
  82. ghcr.io/sitbon/magg:latest
  83. # Run beta image (INFO log level)
  84. docker run -p 8000:8000 ghcr.io/sitbon/magg:beta
  85. # Run with custom config directory
  86. docker run -p 8000:8000 \
  87. -v /path/to/config:/home/magg/.magg \
  88. ghcr.io/sitbon/magg:latest
  89. ```
  90. #### Docker Image Strategy
  91. Magg uses a multi-stage Docker build with three target stages:
  92. - **`pro` (Production)**: Minimal image with WARNING log level, suitable for production deployments
  93. - **`pre` (Pre-production)**: Same as production but with INFO log level for staging/testing (available but not published)
  94. - **`dev` (Development)**: Includes development dependencies and DEBUG logging for troubleshooting
  95. Images are automatically published to GitHub Container Registry with the following tags:
  96. - **Version tags** (from main branch): `1.2.3`, `1.2`, `dev`, `1.2-dev`, `1.2-dev-py3.12`, etc.
  97. - **Branch tags** (from beta branch): `beta`, `beta-dev`
  98. - **Python-specific dev tags**: `beta-dev-py3.12`, `beta-dev-py3.13`, etc.
  99. Pull requests build and test images but do not publish them unless a maintainer adds the
  100. `push-image` label, which publishes ephemeral `pr-NN` / `pr-NN-dev` tags (same-repo PRs
  101. only). Ephemeral `pr-*` tags and untagged manifests are cleaned up weekly; version tags
  102. are kept forever, so pinned deployments are never affected.
  103. #### Docker Compose
  104. For easier management, use Docker Compose:
  105. ```bash
  106. # Clone the repository
  107. git clone https://github.com/sitbon/magg.git
  108. cd magg
  109. # Run production version
  110. docker compose up magg
  111. # Run staging version (on port 8001)
  112. docker compose up magg-beta
  113. # Run development version (on port 8008)
  114. # This uses ./.magg/config.json for configuration
  115. docker compose up magg-dev
  116. # Build and run with custom registry
  117. REGISTRY=my.registry.com docker compose build
  118. REGISTRY=my.registry.com docker compose push
  119. ```
  120. See `compose.yaml` and `.env.example` for configuration options.
  121. ## Usage
  122. ### Running Magg
  123. Magg can run in three modes:
  124. 1. **Stdio Mode** (default) - For integration with Claude Desktop, Cline, Cursor, etc.:
  125. ```bash
  126. magg serve
  127. ```
  128. 2. **HTTP Mode** - For system-wide access or web integrations:
  129. ```bash
  130. magg serve --http --port 8000
  131. ```
  132. 3. **Hybrid Mode** - Both stdio and HTTP simultaneously:
  133. ```bash
  134. magg serve --hybrid
  135. magg serve --hybrid --port 8080 # Custom port
  136. ```
  137. This is particularly useful when you want to use Magg through an MCP client while also allowing HTTP access. For example:
  138. **With Claude Code:**
  139. ```bash
  140. # Configure Claude Code to use Magg in hybrid mode
  141. claude mcp add magg -- magg serve --hybrid --port 42000
  142. ```
  143. **With mbro:**
  144. ```bash
  145. # mbro hosts Magg and connects via stdio
  146. mbro connect magg "magg serve --hybrid --port 8080"
  147. # Other mbro instances can connect via HTTP
  148. mbro connect magg http://localhost:8080
  149. ```
  150. ### Available Tools
  151. Once Magg is running, it exposes the following tools to LLMs:
  152. - `magg_list_servers` - List all configured MCP servers
  153. - `magg_add_server` - Add a new MCP server
  154. - `magg_remove_server` - Remove a server
  155. - `magg_enable_server` / `magg_disable_server` - Toggle server availability
  156. - `magg_search_servers` - Search for MCP servers online
  157. - `magg_list_tools` - List all available tools from all servers
  158. - `magg_smart_configure` - Intelligently configure a server from a URL
  159. - `magg_analyze_servers` - Analyze configured servers and suggest improvements
  160. - `magg_status` - Get server and tool statistics
  161. - `magg_check` - Health check servers with repair actions (report/remount/unmount/disable)
  162. - `magg_reload_config` - Reload configuration from disk and apply changes
  163. - `magg_load_kit` - Load a kit and its servers into the configuration
  164. - `magg_unload_kit` - Unload a kit and optionally its servers from the configuration
  165. - `magg_list_kits` - List all available kits with their status
  166. - `magg_kit_info` - Get detailed information about a specific kit
  167. ### Quick Inspection with MBro
  168. Magg includes the `mbro` (MCP Browser) CLI tool for interactive exploration. A unique feature is the ability to connect to Magg in stdio mode for quick inspection:
  169. ```bash
  170. # Connect mbro to a Magg instance via stdio (no HTTP server needed)
  171. mbro connect local-magg magg serve
  172. # Now inspect your Magg setup from the MCP client perspective
  173. mbro:local-magg> call magg_status
  174. mbro:local-magg> call magg_list_servers
  175. ```
  176. MBro also supports:
  177. - **Scripts**: Create `.mbro` files with commands for automation
  178. - **Shell-style arguments**: Use `key=value` syntax instead of JSON
  179. - **Tab completion**: Rich parameter hints after connecting
  180. See the [MBro Documentation](docs/mbro.md) for details.
  181. ### Authentication
  182. Magg supports optional bearer token authentication to secure access:
  183. #### Quick Start
  184. 1. **Initialize authentication** (creates RSA keypair):
  185. ```bash
  186. magg auth init
  187. ```
  188. 2. **Generate a JWT token** for clients:
  189. ```bash
  190. # Generate token (displays on screen)
  191. magg auth token
  192. # Export as environment variable
  193. export MAGG_JWT=$(magg auth token -q)
  194. ```
  195. 3. **Connect with authentication**:
  196. - Using `MaggClient` (auto-loads from MAGG_JWT):
  197. ```python
  198. from magg.client import MaggClient
  199. async def main():
  200. async with MaggClient("http://localhost:8000/mcp") as client:
  201. tools = await client.list_tools()
  202. ```
  203. - Using FastMCP with explicit token:
  204. ```python
  205. from fastmcp import Client
  206. from fastmcp.client import BearerAuth
  207. jwt_token = "your-jwt-token-here"
  208. async with Client("http://localhost:8000/mcp", auth=BearerAuth(jwt_token)) as client:
  209. tools = await client.list_tools()
  210. ```
  211. #### Key Management
  212. - Keys are stored in `~/.ssh/magg/` by default
  213. - Private key can be set via `MAGG_PRIVATE_KEY` environment variable
  214. - To disable auth, remove keys or set non-existent `key_path` in `.magg/auth.json`
  215. #### Authentication Commands
  216. - `magg auth init` - Initialize authentication (generates RSA keypair)
  217. - `magg auth status` - Check authentication configuration
  218. - `magg auth token` - Generate JWT token
  219. - `magg auth public-key` - Display public key (for verification)
  220. - `magg auth private-key` - Display private key (for backup)
  221. See [examples/authentication.py](examples/authentication.py) for more usage patterns.
  222. ### Configuration
  223. Magg stores its configuration in `.magg/config.json` in your current working directory. This allows for project-specific tool configurations.
  224. #### Dynamic Configuration Reloading
  225. Magg supports automatic configuration reloading without requiring a restart:
  226. - **Automatic file watching**: Detects changes to `config.json` and reloads automatically (uses watchdog when available)
  227. - **SIGHUP signal**: Send `kill -HUP <pid>` to trigger immediate reload (Unix-like systems)
  228. - **MCP tool**: Use `magg_reload_config` tool from any MCP client
  229. - **Smart transitions**: Only affected servers are restarted during reload
  230. Configuration reload is enabled by default. You can control it with:
  231. - `MAGG_AUTO_RELOAD=false` - Disable automatic reloading
  232. - `MAGG_RELOAD_POLL_INTERVAL=5.0` - Set polling interval in seconds (when watchdog unavailable)
  233. See [Configuration Reload Documentation](docs/config-reload.md) for detailed information.
  234. #### Environment Variables
  235. Magg supports several environment variables for configuration:
  236. - `MAGG_CONFIG_PATH` - Path to config file (default: `.magg/config.json`)
  237. - `MAGG_LOG_LEVEL` - Logging level: DEBUG, INFO, WARNING, ERROR, CRITICAL (default: INFO)
  238. - `MAGG_STDERR_SHOW=1` - Show stderr output from subprocess MCP servers (default: suppressed)
  239. - `MAGG_AUTO_RELOAD` - Enable/disable config auto-reload (default: true)
  240. - `MAGG_RELOAD_POLL_INTERVAL` - Config polling interval in seconds (default: 1.0)
  241. - `MAGG_READ_ONLY=true` - Run in read-only mode
  242. - `MAGG_SELF_PREFIX` - Prefix for Magg tools (default: "magg"). Tools will be named as `{prefix}{sep}{tool}` (e.g., `magg_list_servers`)
  243. - `MAGG_PREFIX_SEP` - Separator between Magg's prefix and its tool names (default: "_"). Backend server tools always use `_`
  244. - `MAGG_BACKEND_INIT_TIMEOUT` - Seconds to wait for a backend server to start before giving up on it (default: 30, `0` waits forever)
  245. Example configuration:
  246. ```json
  247. {
  248. "servers": {
  249. "calculator": {
  250. "name": "calculator",
  251. "source": "https://github.com/executeautomation/calculator-mcp",
  252. "command": "npx @executeautomation/calculator-mcp",
  253. "prefix": "calc",
  254. "enabled": true
  255. }
  256. }
  257. }
  258. ```
  259. ### Adding Servers
  260. Servers can be added in several ways:
  261. 1. **Using the LLM** (recommended):
  262. ```
  263. "Add the Playwright MCP server"
  264. "Search for and add a calculator tool"
  265. ```
  266. 2. **Manual configuration** via `magg_add_server`:
  267. ```
  268. name: playwright
  269. url: https://github.com/microsoft/playwright-mcp
  270. command: npx @playwright/mcp@latest
  271. prefix: pw
  272. ```
  273. 3. **The `magg server` CLI** (see below)
  274. 4. **Direct config editing**: Edit `.magg/config.json` directly
  275. ### Managing Servers from the CLI
  276. Server and kit configuration can be managed entirely from the command line — no MCP client
  277. or running server required. The CLI edits `.magg/config.json` directly, and a running Magg
  278. instance picks up the changes automatically via [config reload](docs/config-reload.md).
  279. (Tools that require a live server, like `magg_search_servers`, `magg_check`, and
  280. `magg_smart_configure`, remain available through any MCP client such as `mbro`.)
  281. ```bash
  282. # List servers (human-readable, or JSON on stdout for scripting)
  283. magg server list
  284. magg server list --json
  285. # Add a server
  286. magg server add playwright https://github.com/microsoft/playwright-mcp \
  287. --command "npx @playwright/mcp@latest" --prefix pw
  288. # Add a server without enabling it, with transport options
  289. magg server add web https://example.com/web --uri http://localhost:9000/mcp \
  290. --transport '{"keep_alive": false}' --disable
  291. # Update an existing server (pass '' to clear an optional field)
  292. magg server update playwright --prefix play --notes "Browser automation"
  293. magg server update playwright --command "npx @playwright/mcp@next"
  294. magg server update playwright --notes ""
  295. # Enable / disable / inspect / remove
  296. magg server enable playwright
  297. magg server disable playwright
  298. magg server info playwright --json
  299. magg server remove playwright
  300. ```
  301. ### Real-time Notifications with MaggClient
  302. The `MaggClient` now supports real-time notifications from backend MCP servers:
  303. ```python
  304. from magg import MaggClient, MaggMessageHandler
  305. # Using callbacks
  306. handler = MaggMessageHandler(
  307. on_tool_list_changed=lambda n: print("Tools changed!"),
  308. on_progress=lambda n: print(f"Progress: {n.params.progress}")
  309. )
  310. async with MaggClient("http://localhost:8000/mcp", message_handler=handler) as client:
  311. # Client will receive notifications while connected
  312. tools = await client.list_tools()
  313. ```
  314. See [Messaging Documentation](docs/messaging.md) for advanced usage including custom message handlers.
  315. ### Kit Management
  316. Magg supports organizing related MCP servers into "kits" - bundles that can be loaded and unloaded as a group:
  317. ```bash
  318. # List available kits
  319. magg kit list
  320. # Load a kit (adds all its servers)
  321. magg kit load web-tools
  322. # Unload a kit (removes servers only in that kit)
  323. magg kit unload web-tools
  324. # Get information about a kit
  325. magg kit info web-tools
  326. # Export the current configuration (or a loaded kit) as a kit file
  327. magg kit export --name my-kit --output my-kit.json
  328. ```
  329. When unloading a kit, servers that belong only to that kit are removed, while servers
  330. shared with other kits are kept.
  331. You can also manage kits programmatically through Magg's tools when connected via an MCP client:
  332. - `magg_list_kits` - List all available kits
  333. - `magg_load_kit` - Load a kit and its servers
  334. - `magg_unload_kit` - Unload a kit
  335. - `magg_kit_info` - Get detailed kit information
  336. Kits are JSON files stored in `~/.magg/kit.d/` or `.magg/kit.d/` that define a collection of related servers. See [Kit Documentation](docs/kits.md) for details on creating and managing kits.
  337. ### MBro Scripts
  338. Automate common workflows with MBro scripts:
  339. ```bash
  340. # Create a setup script
  341. cat > setup.mbro <<EOF
  342. # Connect to Magg and check status
  343. connect magg magg serve
  344. call magg_status
  345. call magg_list_servers
  346. # Add a new server if needed
  347. call magg_add_server name=calculator source="npx -y @modelcontextprotocol/server-calculator"
  348. EOF
  349. # Run the script
  350. mbro -x setup.mbro
  351. ```
  352. ## MCP 2026-07-28 (Stateless Spec)
  353. The MCP 2026-07-28 spec moves the protocol to a stateless request/response core. Magg's take:
  354. something still has to own long-lived stdio subprocesses, backend connections, and tool-list
  355. caching — and that's exactly the layer an aggregator provides. See
  356. [Magg and the Stateless MCP Spec](docs/mcp-stateless.md) for the impact analysis and migration
  357. plan, including how Magg bridges pre-2026 (stateful) backends to stateless-era clients and how
  358. hierarchical Magg deployments fit in.
  359. ## Documentation
  360. For more documentation, see [docs/](docs/index.md).
  361. ## Appearances
  362. Magg appears in multiple locations. Please feel free to submit a PR to add more appearances below in alphabetical order.
  363. ### Listing, Index, and other MCP Sites
  364. * [DeepWiki](https://deepwiki.com/sitbon/magg) - AI-generated documentation
  365. * [Glama.ai](https://glama.ai/mcp/servers/@sitbon/magg) - MCP server listing and hosting
  366. Magg ships a [`server.json`](server.json) manifest for the
  367. [official MCP Registry](https://registry.modelcontextprotocol.io) (as `io.github.sitbon/magg`),
  368. and `magg_search_servers` queries the registry as a first-class discovery source alongside
  369. Glama, GitHub, and npm. See [MCP Registry Documentation](docs/mcp-registry.md) for publishing
  370. instructions.
  371. mcp-name: io.github.sitbon/magg
  372. ### Awesome GitHub MCP Lists
  373. * [@modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers)
  374. * [@punkpeye/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)
  375. * [@wong2/awesome-mcp-servers](https://github.com/wong2/awesome-mcp-servers)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.