📅 Day 20 ⏱ 60 min 🔥 Level 3 — Ascend 🔀 Orchestration

Multi-Server Orchestration
& Composition

Real enterprise MCP deployments don't use one giant server — they compose multiple specialized servers. Learn the router pattern, conflict resolution, meta-server aggregation, and how Claude Code handles 5+ simultaneous MCP connections.

One MCP server per concern is the microservices principle applied to context engineering. Your database team runs the DB server. Your DevOps team runs the AWS server. Your data science team runs the analytics server. A router stitches them together into a single coherent tool namespace.
📋 Today's agenda
🏗️ Architecture

The Multi-Server Architecture Pattern

A single MCP server for everything creates a monolith — hard to maintain, deploy independently, or permission granularly. The better pattern is one server per domain, each owned by a different team, each deployed independently, all orchestrated behind a router that the AI client sees as a single unified interface.

This mirrors how modern cloud architecture works: individual microservices behind an API Gateway. The AI client (Claude) doesn't need to know there are 10 servers behind the scenes — it just sees 50 tools and a set of resources.

Multi-Server MCP Architecture
🤖 Claude / MCP Client
🔀 MCP Router / Meta-Server (single connection point)
🗄️ DB Server
☁️ AWS Server
📊 Analytics
🔔 Slack/Email
🛡️ Security
🔀 Router Pattern

MCP Router / Proxy Pattern

The MCP Router is itself an MCP server that: (1) connects to multiple upstream MCP servers as a client, (2) aggregates their tool and resource lists, (3) forwards tool calls to the correct upstream server, and (4) returns results to the downstream AI client. To the AI, it looks like one server.

from fastmcp import FastMCP, Client from fastmcp.client.transports import SSETransport router = FastMCP("MCPRouter") # Define upstream servers UPSTREAM_SERVERS = { "db": "http://db-mcp.internal:8080", "aws": "http://aws-mcp.internal:8081", "analytics": "http://analytics-mcp.internal:8082", "comms": "http://comms-mcp.internal:8083", } # Cache of upstream clients _clients: dict[str, Client] = {} async def get_client(server_name: str) -> Client: if server_name not in _clients: url = UPSTREAM_SERVERS[server_name] _clients[server_name] = Client(SSETransport(url)) await _clients[server_name].connect() return _clients[server_name] # Register proxied tools with namespace prefix @router.tool() async def db__query_customers(sql: str) -> str: """Proxy: forwards to db MCP server""" client = await get_client("db") return await client.call_tool("query_customers", {"sql": sql}) @router.tool() async def aws__list_s3_buckets() -> str: """Proxy: forwards to aws MCP server""" client = await get_client("aws") return await client.call_tool("list_s3_buckets", {})
🔗 Composition

Composing Tools from Multiple Servers

Beyond simple proxying, the router can create composite tools that orchestrate multiple upstream servers — calling DB server to get data, then Analytics server to analyze it, then Comms server to send the result. This is the "workflow tool" pattern.

@router.tool() async def weekly_sales_report(week_start: str) -> str: """Composite tool: DB → Analytics → Email in one call.""" db = await get_client("db") ana = await get_client("analytics") com = await get_client("comms") # Step 1: Fetch raw data from DB server raw = await db.call_tool("get_sales", {"week": week_start}) # Step 2: Run analytics report = await ana.call_tool("generate_report", {"data": raw}) # Step 3: Send email via Comms server await com.call_tool("send_email", { "to": "sales@company.com", "subject": f"Sales Report {week_start}", "body": report }) return f"✅ Report generated and sent for week {week_start}"
💡
This is agentic workflow via tool composition

When Claude calls weekly_sales_report, it doesn't know it's triggering a multi-server workflow. This is a powerful abstraction: complex multi-step workflows packaged as a single, simple tool call.

🔠 Namespacing

Conflict Resolution & Tool Namespacing

When aggregating tools from multiple servers, name collisions are inevitable. Both your DB server and your Analytics server might have a get_data tool. Namespacing solves this: prefix every tool with its server name, making the source obvious.

async def auto_register_all_tools(router: FastMCP): """Dynamically discover and register all upstream tools with namespacing.""" for server_name, url in UPSTREAM_SERVERS.items(): client = await get_client(server_name) tools = await client.list_tools() for tool in tools: namespaced_name = f"{server_name}__{tool.name}" # Create a closure to capture server_name and tool.name def make_proxy(svc, tname): async def proxy(**kwargs): c = await get_client(svc) return await c.call_tool(tname, kwargs) proxy.__name__ = f"{svc}__{tname}" proxy.__doc__ = f"[{svc}] {tool.description}" return proxy router.add_tool( make_proxy(server_name, tool.name), name=namespaced_name, description=f"[{server_name}] {tool.description}" )
🌐 Real World

Real-World: Claude Code + 5 MCP Servers

Claude Code supports multiple simultaneous MCP server connections natively. Here's a production configuration used by a real AWS team — 5 specialized servers providing a full-stack developer assistant:

// .claude/mcp_servers.json — Claude Code configuration { "mcpServers": { "aws-infra": { "url": "http://aws-mcp.internal:8080", "description": "S3, EC2, Lambda, CloudWatch tools", "headers": { "Authorization": "Bearer ${AWS_MCP_KEY}" } }, "database": { "url": "http://db-mcp.internal:8081", "description": "RDS, DynamoDB query and management tools", "headers": { "Authorization": "Bearer ${DB_MCP_KEY}" } }, "github": { "command": "npx", "args": ["@modelcontextprotocol/server-github"], "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" } }, "slack": { "command": "python", "args": ["-m", "slack_mcp"], "env": { "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}" } }, "analytics": { "url": "http://analytics-mcp.internal:8082", "description": "Query Athena, generate charts, export reports" } } }
💼 Day-in-the-Life with 5 MCP Servers
An engineer opens Claude Code and types: "The Lambda function user-processor is throwing timeout errors. Find the root cause, fix it, deploy, and notify the team."

Claude orchestrates: aws-infra → reads CloudWatch logs → github → reads current code and creates PR → aws-infra → deploys updated Lambda → slack → posts deployment notification. Four servers, zero manual steps.
🧠 Knowledge Check — Day 20
4 questions on multi-server MCP architecture
QUESTION 01 / 04
What is the primary benefit of the MCP Router pattern?
AIt speeds up individual tool calls
BIt presents multiple specialized upstream servers as a single unified tool interface to the AI client
CIt reduces the number of tools available
DIt eliminates the need for authentication
✅ B. The router aggregates tools from multiple upstream servers and presents them as a single namespace to the downstream client. The AI client doesn't need to manage multiple server connections — it connects to one router and gets all tools.
QUESTION 02 / 04
How does namespacing solve the tool name collision problem in multi-server MCP?
ABy deleting duplicate tool names
BBy prefixing each tool with its source server name (e.g., db__get_data vs analytics__get_data)
CBy versioning each tool
DBy requiring unique names at the protocol level
✅ B. Namespacing prefixes each tool name with its source server name (e.g. db__query, analytics__query). This makes the source explicit, prevents collisions, and helps the AI understand which domain each tool belongs to.
QUESTION 03 / 04
A "composite tool" in the router pattern is one that:
ACombines multiple input types into one
BOrchestrates calls to multiple upstream servers in sequence to complete a higher-level workflow
CReturns composite JSON objects
DRuns on multiple threads simultaneously
✅ B. A composite tool orchestrates multiple upstream tool calls to complete a workflow — like the weekly_sales_report tool that calls DB → Analytics → Comms. To the AI, it's a single tool call.
QUESTION 04 / 04
In Claude Code's MCP configuration, how can you connect to both a local stdio server and a remote SSE server simultaneously?
AYou can only connect to one server at a time
BConfigure each server as a separate named entry in mcpServers — Claude Code manages all connections
COnly SSE servers are supported in Claude Code
DUse a MCP bridge adapter
✅ B. Claude Code's mcpServers config supports multiple named entries with mixed transport types. Each entry can use command/args (stdio) or url (SSE). Claude Code manages all connections concurrently.
Up Next — Day 21
AWS Services MCP Integration
Build production MCP tools for S3, DynamoDB, and Lambda with boto3 and IAM least-privilege roles.
Day 21 →