The Complete Production SOP: How to Deploy and Run Model Context Protocol Client Bridge & Multi-Server Hub in Autonomous AI Agents

---
name: "mcp-client-bridge-integration"
description: "Aggregate multiple MCP servers into a unified agent tool execution hub."
metadata:
  author: "Model Context Protocol"
  version: "1.0.0"
  runtime_compatibility:
    - "codex"
    - "claude-code"
    - "cursor"
    - "windsurf"
triggers:
  - "connect mcp client to multiple servers"
  - "list tools across mcp servers"
  - "route tool call to mcp server"
permissions:
  fs_read: true
  fs_write: "workspace"
  shell_exec: false
  net_access: false
---

# Model Context Protocol Client Bridge & Multi-Server Hub
Builds custom MCP client applications using Client class: discovering tools across multiple remote servers, multiplexing namespaces, routing tool calls, and maintaining resource caches.

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
import { Tool } from "@modelcontextprotocol/sdk/types.js";

interface ServerConfig {
  id: string;
  command: string;
  args: string[];
}

export class McpMultiServerHub {
  private clients = new Map<string, Client>();
  private toolRoutingTable = new Map<string, string>(); // toolName -> serverId

  async registerServer(config: ServerConfig): Promise<void> {
    const transport = new StdioClientTransport({
      command: config.command,
      args: config.args,
    });
    const client = new Client(
      { name: `hub-client-${config.id}`, version: "1.0.0" },
      { capabilities: {} }
    );
    await client.connect(transport);
    this.clients.set(config.id, client);
  }

  async aggregateTools(): Promise<Tool[]> {
    const aggregated: Tool[] = [];
    for (const [serverId, client] of this.clients.entries()) {
      const response = await client.listTools();
      for (const tool of response.tools) {
        const namespacedName = `${serverId}__${tool.name}`;
        this.toolRoutingTable.set(namespacedName, serverId);
        aggregated.push({
          ...tool,
          name: namespacedName,
          description: `[${serverId}] ${tool.description ?? ""}`,
        });
      }
    }
    return aggregated;
  }

  async executeTool(namespacedName: string, args: Record<string, unknown>) {
    const serverId = this.toolRoutingTable.get(namespacedName);
    if (!serverId) throw new Error(`Unknown tool namespace: ${namespacedName}`);
    const client = this.clients.get(serverId)!;
    const originalToolName = namespacedName.replace(`${serverId}__`, "");
    return await client.callTool({ name: originalToolName, arguments: args });
  }
}

# Example invoking Claude Code with explicit trigger matching
claude "connect mcp client to multiple servers: postgres and github. Aggregate and list tools across mcp servers with namespaces."

import { describe, it } from 'node:test';
import assert from 'node:assert';
import { McpMultiServerHub } from '../src/mcp-hub.js';

describe('McpMultiServerHub Routing', () => {
  it('verifies routing table isolation and tool execution routing', async () => {
    const hub = new McpMultiServerHub();
    assert.ok(hub, 'Hub should instantiate without error');
  });
});