	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > MCP Protocol > MCP Gateway Pattern - Aggregating Multiple Servers

MCP Gateway Pattern - Aggregating Multiple Servers

Author: Venkata Sudhakar

In production systems, tools are spread across many MCP servers - one for databases, one for cloud storage, one for notifications, and so on. Connecting an agent to each server individually creates complex configuration. The MCP Gateway pattern solves this by building a single gateway server that proxies tool calls to the appropriate backend MCP server, giving agents one endpoint for all tools.

ShopMax India runs separate MCP servers for inventory (Spanner), customer data (AlloyDB), notifications (Pub/Sub), and jobs (Cloud Tasks). The MCP Gateway aggregates all of these into one server so the main ShopMax ADK agent has a single connection point and one unified tool list covering all operations.

The below example shows an MCP Gateway that starts multiple child MCP servers as subprocesses and forwards tool calls to the correct backend based on tool name prefixes.

# Install: pip install mcp
import asyncio
import subprocess
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.client.stdio import stdio_client
from mcp import types, ClientSession

# Backend server configs: prefix -> command
BACKENDS = {
    "inventory": ["python", "inventory_mcp.py"],
    "customer":  ["python", "customer_mcp.py"],
    "notify":    ["python", "notify_mcp.py"],
    "jobs":      ["python", "jobs_mcp.py"]
}

app = Server("shopmax-gateway")
sessions = {}   # prefix -> ClientSession
tool_map = {}   # tool_name -> prefix

async def init_backends():
    for prefix, cmd in BACKENDS.items():
        proc = await asyncio.create_subprocess_exec(
            *cmd,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE
        )
        session = await ClientSession(
            *await stdio_client(proc.stdout, proc.stdin).__aenter__()
        ).__aenter__()
        await session.initialize()
        sessions[prefix] = session
        tools = await session.list_tools()
        for tool in tools.tools:
            tool_map[tool.name] = prefix

@app.list_tools()
async def list_tools():
    all_tools = []
    for prefix, session in sessions.items():
        resp = await session.list_tools()
        all_tools.extend(resp.tools)
    return all_tools

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    prefix = tool_map.get(name)
    if not prefix:
        return [types.TextContent(type="text", text="Unknown tool: " + name)]
    session = sessions[prefix]
    result = await session.call_tool(name, arguments)
    return result.content

async def main():
    await init_backends()
    async with stdio_server() as streams:
        await app.run(streams[0], streams[1], app.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

It gives the following output,

# Agent connects to gateway - sees all tools from all backends:
Available tools:
  [inventory]  query_inventory, update_stock
  [customer]   search_customer, log_return_request
  [notify]     send_notification, broadcast_alert
  [jobs]       enqueue_job, check_job_status

# Agent calls inventory tool through gateway:
Tool: query_inventory({city: "Hyderabad", category: "Laptops"})
  -> Gateway routes to inventory backend
  -> Returns: [{"product_id": "LAP005", "name": "Asus VivoBook 15", "stock": 23}]

# Agent calls customer tool through gateway:
Tool: search_customer({query: "Ravi Kumar"})
  -> Gateway routes to customer backend
  -> Returns: [{"customer_id": "C-7731", "name": "Ravi Kumar", "city": "Hyderabad"}]

Deploy the MCP Gateway as a Cloud Run service so backend MCP servers run as sidecar containers in the same pod, keeping inter-server communication local and fast. Add a tool registry with health checks so the gateway can skip unavailable backends and surface partial tool lists rather than failing entirely. Use tool name prefixes consistently across all backend servers to make routing transparent and debuggable.

Send your comments, suggestions or queries regarding this site to [email protected].