Magg
sitbon144 स्टार
Magg: The MCP Aggregator
{ "mcpServers": { "sitbon-magg": { "command": "uvx", "args": [ "magg==1.2.1" ] } }}.cursor/mcp.jsonMCP सर्वर
- ट्रांसपोर्ट
- stdio
- स्थिति
- लोकल
Power your agent
पब्लिशर की अपनी कमांड। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
uvx magg==1.2.1Claude Code में लोकल कमांड के लिए इंस्टॉल लिंक नहीं है। नीचे दी गई कमांड कॉपी करें और टर्मिनल में चलाएँ।
claude mcp add sitbon-magg -- uvx magg==1.2.1टर्मिनल में चलाएँ।
{ "mcpServers": { "sitbon-magg": { "command": "uvx", "args": [ "magg==1.2.1" ] } }}claude_desktop_config.json
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
PlugMCP पर चलाएँ
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
लॉन्चA Model Context Protocol server that manages, aggregates, and proxies other MCP servers, enabling LLMs to dynamically extend their own capabilities.
Magg is a meta-MCP server that acts as a central hub for managing multiple MCP servers. It provides tools that allow LLMs to:
Think of Magg as a "package manager for LLM tools" - it lets AI assistants install and manage their own capabilities at runtime.
.magg/config.json.magg_status and magg_check tools for server health checks.uv (recommended) - Install from astral.sh/uvThe 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
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
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
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
Magg uses a multi-stage Docker build with three target stages:
pro (Production): Minimal image with WARNING log level, suitable for production deploymentspre (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 troubleshootingImages are automatically published to GitHub Container Registry with the following tags:
1.2.3, 1.2, dev, 1.2-dev, 1.2-dev-py3.12, etc.beta, beta-devbeta-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.
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.
Magg can run in three modes:
Stdio Mode (default) - For integration with Claude Desktop, Cline, Cursor, etc.:
magg serve
HTTP Mode - For system-wide access or web integrations:
magg serve --http --port 8000
Hybrid Mode - Both stdio and HTTP simultaneously:
magg serve --hybrid
magg serve --hybrid --port 8080 # Custom port
This is particularly useful when you want to use Magg through an MCP client while also allowing HTTP access. For example:
With Claude Code:
# Configure Claude Code to use Magg in hybrid mode
claude mcp add magg -- magg serve --hybrid --port 42000
With mbro:
# mbro hosts Magg and connects via stdio
mbro connect magg "magg serve --hybrid --port 8080"
# Other mbro instances can connect via HTTP
mbro connect magg http://localhost:8080
Once Magg is running, it exposes the following tools to LLMs:
magg_list_servers - List all configured MCP serversmagg_add_server - Add a new MCP servermagg_remove_server - Remove a servermagg_enable_server / magg_disable_server - Toggle server availabilitymagg_search_servers - Search for MCP servers onlinemagg_list_tools - List all available tools from all serversmagg_smart_configure - Intelligently configure a server from a URLmagg_analyze_servers - Analyze configured servers and suggest improvementsmagg_status - Get server and tool statisticsmagg_check - Health check servers with repair actions (report/remount/unmount/disable)magg_reload_config - Reload configuration from disk and apply changesmagg_load_kit - Load a kit and its servers into the configurationmagg_unload_kit - Unload a kit and optionally its servers from the configurationmagg_list_kits - List all available kits with their statusmagg_kit_info - Get detailed information about a specific kitMagg 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:
# Connect mbro to a Magg instance via stdio (no HTTP server needed)
mbro connect local-magg magg serve
# Now inspect your Magg setup from the MCP client perspective
mbro:local-magg> call magg_status
mbro:local-magg> call magg_list_servers
MBro also supports:
.mbro files with commands for automationkey=value syntax instead of JSONSee the MBro Documentation for details.
Magg supports optional bearer token authentication to secure access:
Initialize authentication (creates RSA keypair):
magg auth init
Generate a JWT token for clients:
# Generate token (displays on screen)
magg auth token
# Export as environment variable
export MAGG_JWT=$(magg auth token -q)
Connect with authentication:
MaggClient (auto-loads from MAGG_JWT):
from magg.client import MaggClient
async def main():
async with MaggClient("http://localhost:8000/mcp") as client:
tools = await client.list_tools()
from fastmcp import Client
from fastmcp.client import BearerAuth
jwt_token = "your-jwt-token-here"
async with Client("http://localhost:8000/mcp", auth=BearerAuth(jwt_token)) as client:
tools = await client.list_tools()
~/.ssh/magg/ by defaultMAGG_PRIVATE_KEY environment variablekey_path in .magg/auth.jsonmagg auth init - Initialize authentication (generates RSA keypair)magg auth status - Check authentication configurationmagg auth token - Generate JWT tokenmagg auth public-key - Display public key (for verification)magg auth private-key - Display private key (for backup)See examples/authentication.py for more usage patterns.
Magg stores its configuration in .magg/config.json in your current working directory. This allows for project-specific tool configurations.
Magg supports automatic configuration reloading without requiring a restart:
config.json and reloads automatically (uses watchdog when available)kill -HUP <pid> to trigger immediate reload (Unix-like systems)magg_reload_config tool from any MCP clientConfiguration reload is enabled by default. You can control it with:
MAGG_AUTO_RELOAD=false - Disable automatic reloadingMAGG_RELOAD_POLL_INTERVAL=5.0 - Set polling interval in seconds (when watchdog unavailable)See Configuration Reload Documentation for detailed information.
Magg supports several environment variables for configuration:
MAGG_CONFIG_PATH - Path to config file (default: .magg/config.json)MAGG_LOG_LEVEL - Logging level: DEBUG, INFO, WARNING, ERROR, CRITICAL (default: INFO)MAGG_STDERR_SHOW=1 - Show stderr output from subprocess MCP servers (default: suppressed)MAGG_AUTO_RELOAD - Enable/disable config auto-reload (default: true)MAGG_RELOAD_POLL_INTERVAL - Config polling interval in seconds (default: 1.0)MAGG_READ_ONLY=true - Run in read-only modeMAGG_SELF_PREFIX - Prefix for Magg tools (default: "magg"). Tools will be named as {prefix}{sep}{tool} (e.g., magg_list_servers)MAGG_PREFIX_SEP - Separator between Magg's prefix and its tool names (default: "_"). Backend server tools always use _MAGG_BACKEND_INIT_TIMEOUT - Seconds to wait for a backend server to start before giving up on it (default: 30, 0 waits forever)Example configuration:
{
"servers": {
"calculator": {
"name": "calculator",
"source": "https://github.com/executeautomation/calculator-mcp",
"command": "npx @executeautomation/calculator-mcp",
"prefix": "calc",
"enabled": true
}
}
}
Servers can be added in several ways:
Using the LLM (recommended):
"Add the Playwright MCP server"
"Search for and add a calculator tool"
Manual configuration via magg_add_server:
name: playwright
url: https://github.com/microsoft/playwright-mcp
command: npx @playwright/mcp@latest
prefix: pw
The magg server CLI (see below)
Direct config editing: Edit .magg/config.json directly
Server and kit configuration can be managed entirely from the command line — no MCP client
or running server required. The CLI edits .magg/config.json directly, and a running Magg
instance picks up the changes automatically via config reload.
(Tools that require a live server, like magg_search_servers, magg_check, and
magg_smart_configure, remain available through any MCP client such as mbro.)
# List servers (human-readable, or JSON on stdout for scripting)
magg server list
magg server list --json
# Add a server
magg server add playwright https://github.com/microsoft/playwright-mcp \
--command "npx @playwright/mcp@latest" --prefix pw
# Add a server without enabling it, with transport options
magg server add web https://example.com/web --uri http://localhost:9000/mcp \
--transport '{"keep_alive": false}' --disable
# Update an existing server (pass '' to clear an optional field)
magg server update playwright --prefix play --notes "Browser automation"
magg server update playwright --command "npx @playwright/mcp@next"
magg server update playwright --notes ""
# Enable / disable / inspect / remove
magg server enable playwright
magg server disable playwright
magg server info playwright --json
magg server remove playwright
The MaggClient now supports real-time notifications from backend MCP servers:
from magg import MaggClient, MaggMessageHandler
# Using callbacks
handler = MaggMessageHandler(
on_tool_list_changed=lambda n: print("Tools changed!"),
on_progress=lambda n: print(f"Progress: {n.params.progress}")
)
async with MaggClient("http://localhost:8000/mcp", message_handler=handler) as client:
# Client will receive notifications while connected
tools = await client.list_tools()
See Messaging Documentation for advanced usage including custom message handlers.
Magg supports organizing related MCP servers into "kits" - bundles that can be loaded and unloaded as a group:
# List available kits
magg kit list
# Load a kit (adds all its servers)
magg kit load web-tools
# Unload a kit (removes servers only in that kit)
magg kit unload web-tools
# Get information about a kit
magg kit info web-tools
# Export the current configuration (or a loaded kit) as a kit file
magg kit export --name my-kit --output my-kit.json
When unloading a kit, servers that belong only to that kit are removed, while servers shared with other kits are kept.
You can also manage kits programmatically through Magg's tools when connected via an MCP client:
magg_list_kits - List all available kitsmagg_load_kit - Load a kit and its serversmagg_unload_kit - Unload a kitmagg_kit_info - Get detailed kit informationKits are JSON files stored in ~/.magg/kit.d/ or .magg/kit.d/ that define a collection of related servers. See Kit Documentation for details on creating and managing kits.
Automate common workflows with MBro scripts:
# Create a setup script
cat > setup.mbro <<EOF
# Connect to Magg and check status
connect magg magg serve
call magg_status
call magg_list_servers
# Add a new server if needed
call magg_add_server name=calculator source="npx -y @modelcontextprotocol/server-calculator"
EOF
# Run the script
mbro -x setup.mbro
The MCP 2026-07-28 spec moves the protocol to a stateless request/response core. Magg's take: something still has to own long-lived stdio subprocesses, backend connections, and tool-list caching — and that's exactly the layer an aggregator provides. See Magg and the Stateless MCP Spec for the impact analysis and migration plan, including how Magg bridges pre-2026 (stateful) backends to stateless-era clients and how hierarchical Magg deployments fit in.
For more documentation, see docs/.
Magg appears in multiple locations. Please feel free to submit a PR to add more appearances below in alphabetical order.
Magg ships a server.json manifest for the
official MCP Registry (as io.github.sitbon/magg),
and magg_search_servers queries the registry as a first-class discovery source alongside
Glama, GitHub, and npm. See MCP Registry Documentation for publishing
instructions.
mcp-name: io.github.sitbon/magg
Magg: The MCP Aggregator
{ "mcpServers": { "sitbon-magg": { "command": "uvx", "args": [ "magg==1.2.1" ] } }}टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Magg stdio पर लोकल चलता है।
पिछली जाँच 2026-10-26 को हुई। Magg: The MCP Aggregator