Which integrations are available for this server?

Allows installation of MCP servers directly from git repositories, enabling dynamic loading of servers from version control sources. Supports installing MCP servers from GitHub repositories using the install_mcp_server_from_git and install_and_load_mcp_server tools. Used as an example integration in multi-server orchestration workflows for processing payments and charges.

How do I use MCP Proxy?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Proxy load the GitHub MCP server so I can check my pull requests" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

MCP Proxy - Dynamic MCP Server Loading

Hot-reload MCP servers without restarting Claude Code.

One-Click Install

Cursor

Install MCP Server

VS Code

Claude Code

# Clone the repo first
git clone https://github.com/lizTheDeveloper/mcp_proxy.git
cd mcp_proxy
pip install -r requirements.txt

# Then add to Claude Code (run from parent directory of mcp_proxy)
claude mcp add mcp-proxy -- python -m mcp_proxy.servers.proxy_server

Step 1: Clone the repository

git clone https://github.com/lizTheDeveloper/mcp_proxy.git
pip install -r mcp_proxy/requirements.txt

Step 2: Add to your MCP config

Claude Code (~/.claude.json or project .mcp.json):

{
  "mcpServers": {
    "mcp-proxy": {
      "command": "python",
      "args": ["-m", "mcp_proxy.servers.proxy_server"],
      "cwd": "/path/to/mcp_proxy",
      "env": {
        "PYTHONPATH": "/path/to/parent/of/mcp_proxy"
      }
    }
  }
}

Cursor (~/.cursor/mcp.json):

{
  "mcpServers": {
    "mcp-proxy": {
      "command": "python",
      "args": ["-m", "mcp_proxy.servers.proxy_server"],
      "cwd": "/path/to/mcp_proxy",
      "env": {
        "PYTHONPATH": "/path/to/parent/of/mcp_proxy"
      }
    }
  }
}

Note: Replace /path/to/parent/of/mcp_proxy with the actual parent directory. For example, if you cloned to /Users/me/src/mcp_proxy, use /Users/me/src.

Features

Hot-Reload: Load and reload MCP servers without restart
Dynamic Installation: Install servers from git repositories
Programmatic Orchestration: Call tools dynamically in loops and workflows
Context Savings: Load only the tools you need

Quick Start

1. Install

git clone https://github.com/lizTheDeveloper/mcp_proxy.git
cd mcp_proxy
pip install -r requirements.txt

2. Configure

Add to your project's .mcp.json:

{
  "mcpServers": {
    "mcp-proxy": {
      "command": "python",
      "args": ["-m", "mcp_proxy.servers.proxy_server"],
      "cwd": "/path/to/mcp_proxy",
      "env": {
        "PYTHONPATH": "/path/to/parent/of/mcp_proxy"
      }
    }
  }
}

Important: PYTHONPATH should point to the parent directory of where you cloned mcp_proxy, not the mcp_proxy directory itself. For example, if you cloned to /Users/me/src/mcp_proxy, set PYTHONPATH to /Users/me/src.

3. Use

After restarting Claude Code once to load the proxy, you can:

# Load any MCP server dynamically (no restart!)
load_mcp_server_dynamically("my-server")

# Call tools on loaded servers
call_dynamic_server_tool("my-server", "tool_name", {"param": "value"})

# Install and load from git in one step
install_and_load_mcp_server("https://github.com/user/mcp-server")

Available Tools (13 total)

Tool	Description
Dynamic Loading
`load_mcp_server_dynamically`	Load a server from .mcp.json
`call_dynamic_server_tool`	Call any tool on a loaded server
`get_loaded_servers`	List currently loaded servers
`reload_mcp_server`	Reload a server to pick up changes
`unload_mcp_server`	Stop and unload a server
`list_available_servers`	List all configured servers
Installation
`install_mcp_server_from_git`	Install from git repository
`install_and_load_mcp_server`	Install and load in one step
`list_installed_mcp_servers`	List all installed servers
`uninstall_mcp_server`	Remove a server
Tool Search
`search_tools`	Natural language search across loaded servers
`list_all_tools`	List all tools from all loaded servers
`get_tool_info`	Get detailed info about a specific tool

How It Works

Claude Code
    |
    v
MCP Proxy Server (meta-tools)
    |
    v
Dynamic Server Loader (subprocess manager)
    |
    v
Individual MCP Servers (spawned on-demand)

The proxy spawns MCP servers as subprocesses and communicates with them using the MCP JSON-RPC protocol over stdin/stdout.

Usage Patterns

Hot-Reload During Development

# Load your server
load_mcp_server_dynamically("my-dev-server")

# Test it
call_dynamic_server_tool("my-dev-server", "my_feature", {})

# Make code changes...

# Reload with new code
reload_mcp_server("my-dev-server")

# Test again - no restart needed!
call_dynamic_server_tool("my-dev-server", "my_feature", {})

Programmatic Workflows

# Load the server
load_mcp_server_dynamically("user-management")

# Programmatic workflow
users = call_dynamic_server_tool("user-management", "list_users", {"limit": 100})

for user in users["data"]:
    if user["needs_activation"]:
        call_dynamic_server_tool("user-management", "activate_user", {
            "user_id": user["id"]
        })

Multi-Server Orchestration

# Load multiple servers
for server in ["database", "stripe", "email"]:
    load_mcp_server_dynamically(server)

# Orchestrate across servers
customer = call_dynamic_server_tool("database", "get_customer", {"id": 123})
payment = call_dynamic_server_tool("stripe", "charge", {"amount": 2999})
call_dynamic_server_tool("email", "send_receipt", {"to": customer["email"]})

Creating Custom Servers

Create a FastMCP server and add it to .mcp.json:

# my_server.py
from fastmcp import FastMCP

mcp = FastMCP("my-server")

@mcp.tool()
def my_tool(param: str) -> dict:
    """Tool description"""
    return {"success": True, "result": param}

if __name__ == "__main__":
    mcp.run()

{
  "mcpServers": {
    "my-server": {
      "command": "python",
      "args": ["my_server.py"],
      "cwd": "/path/to/server"
    }
  }
}

Then load it dynamically:

load_mcp_server_dynamically("my-server")
call_dynamic_server_tool("my-server", "my_tool", {"param": "hello"})

License

MIT

MCP Proxy