Connect Multiple MCP Servers

import os

# Support multiple MCP servers
# Format: "name1=url1,name2=url2" or just "url1,url2"
MCP_SERVERS = {}

def parse_mcp_servers():
    """Parse MCP server configuration from environment."""
    # Keep backward compatibility with single server
    single_url = os.getenv("MCP_SERVER_URL")
    if single_url:
        MCP_SERVERS["local"] = single_url

    # Support additional servers
    extra = os.getenv("MCP_EXTRA_SERVERS", "")
    for entry in extra.split(","):
        entry = entry.strip()
        if not entry:
            continue
        if "=" in entry:
            name, url = entry.split("=", 1)
            MCP_SERVERS[name.strip()] = url.strip()
        else:
            MCP_SERVERS[f"server-{len(MCP_SERVERS)}"] = entry

parse_mcp_servers()

travel-agent:
  environment:
    - MCP_SERVER_URL=http://mcp-server:8000
    - MCP_EXTRA_SERVERS=quests=http://quest-server:8004  # <-- Add this!

# Maps tool_name → server_url (so we know where to send calls)
tool_to_server: Dict[str, str] = {}

# All discovered tools (merged from all servers)
all_tools: list = []

async def discover_all_tools():
    """Discover tools from every configured MCP server."""
    global all_tools, tool_to_server
    all_tools = []
    tool_to_server = {}

    for name, url in MCP_SERVERS.items():
        try:
            logger.info(f"Discovering tools from {name} ({url})...")
            async with httpx.AsyncClient() as client:
                resp = await client.post(
                    f"{url}/message",
                    json={"jsonrpc": "2.0", "id": 1, "method": "tools/list"},
                    timeout=10.0
                )
            tools = resp.json()["result"]["tools"]

            for tool in tools:
                tool_name = tool["name"]
                if tool_name in tool_to_server:
                    logger.warning(f"Duplicate tool '{tool_name}' from {name}, skipping")
                    continue
                tool_to_server[tool_name] = url
                all_tools.append(tool)

            logger.info(f"Found {len(tools)} tools from {name}")
        except Exception as e:
            logger.error(f"Failed to discover tools from {name} ({url}): {e}")

    logger.info(f"Total tools discovered: {len(all_tools)}")

async def call_mcp_tool(tool_name: str, arguments: dict) -> str:
    """Call an MCP tool on the correct server."""
    server_url = tool_to_server.get(tool_name)

    if not server_url:
        return f"Error: Unknown tool '{tool_name}'. Available: {list(tool_to_server.keys())}"

    logger.info(f"Calling {tool_name} on {server_url}")

    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{server_url}/message",
            json={
                "jsonrpc": "2.0",
                "id": 1,
                "method": "tools/call",
                "params": {
                    "name": tool_name,
                    "arguments": arguments
                }
            },
            timeout=30.0
        )

    result = resp.json()["result"]
    return result["content"][0]["text"]

async def call_mcp_tool_safe(tool_name: str, arguments: dict) -> str:
    """Call an MCP tool with error handling."""
    try:
        return await call_mcp_tool(tool_name, arguments)
    except httpx.ConnectError:
        server = tool_to_server.get(tool_name, "unknown")
        return f"The server hosting '{tool_name}' is unreachable. It may be down temporarily."
    except httpx.ReadTimeout:
        return f"The tool '{tool_name}' took too long to respond. Try again shortly."
    except Exception as e:
        logger.error(f"Tool call failed: {tool_name} - {e}")
        return f"Error calling {tool_name}: {str(e)}"

# Rebuild and restart
docker compose build travel-agent && docker compose up -d

# Check the logs — you should see tools from BOTH servers
docker compose logs travel-agent | grep -i "tools\|discover"

# Ask for weather (local MCP server)
curl -X POST "http://localhost:8001/query" \
  -H "Content-Type: application/json" \
  -d '{"query": "What is the weather in Oslo?"}'

# Ask about quests (the quest server!)
curl -X POST "http://localhost:8001/query" \
  -H "Content-Type: application/json" \
  -d '{"query": "Which quests are still unsolved, and who is leading?"}'

# The big test — ask for BOTH in one query
curl -X POST "http://localhost:8001/query" \
  -H "Content-Type: application/json" \
  -d '{"query": "What is the weather in Bergen, and which novice quest should I take next?"}'