MCP of MCPs

A meta-server that aggregates multiple MCP servers and enables efficient code execution for AI agents. Reduces token usage, improving speed and reliability.

The Problem

When AI agents connect to multiple MCP servers, they face three critical issues:

1. 🔥 Burns Tokens

Every tool definition and intermediate result consumes valuable context window space. With hundreds of tools across multiple servers, agents can waste 150,000+ tokens on a single workflow.

2. ⏱️ Slows Everything Down

The model must process and reason about all tool definitions upfront, even for tools it won't use. This adds significant latency before the agent can even start working.

3. 🤯 Increases Hallucinations

When models see too much irrelevant information, they're more likely to get confused and make mistakes. Loading all tools upfront reduces accuracy.

The Solution

MCP of MCPs is a meta-server that provides three powerful tools for efficient agent orchestration:

Tool 1: get_mcps_servers_overview

Discovery Tool - This tool returns only tool names without full schemas, giving agents a lightweight overview in seconds instead of loading hundreds of detailed definitions upfront. By showing just what's available without overwhelming details, it prevents confusion and hallucinations while eliminating loading delays.

// Returns:
// google_drive/download_file
// google_drive/upload_file
// slack/send_message
// database/execute_query
// ...

Tool 2: get_tools_overview

Introspection Tool - Load only the tools you actually need instead of all 30+ tools, saving thousands of tokens through selective loading. This on-demand approach provides faster responses and focused context that reduces confusion and improves accuracy.

// Input: ["google_drive/download_file", "slack/send_message"]
// Returns: Full tool definitions with:
// - Parameter schemas
// - Required vs optional fields
// - Example usage code

Tool 3: run_functions_code

Execution Tool - Data flows directly between tools without round-trips through the model, so a 2MB file transfer uses ~100 tokens instead of 50,000+. The model only sees clean final results instead of noisy intermediate data, executing complex workflows in one shot without processing delays.

// Write code that:
// - Calls multiple tools in sequence or parallel
// - Processes and transforms data
// - Implements complex logic and error handling
// - Returns only final results to the model

How The Full Flow Solves All Problems

The three tools work together through progressive disclosure: first, get_mcps_servers_overview returns just tool names (not full schemas), so the model scans a simple list instead of parsing 500KB of definitions. Next, get_tools_overview loads only the 2-3 tools you need instead of all 30+, reducing tokens and giving the model focused context without confusing irrelevant options. Finally, run_functions_code executes workflows where data flows directly between tools in memory—intermediate results not get serialized into tokens, they stay as native objects passing from one tool to another while the model only sees the final result. This pattern cuts token usage, speeds up execution by avoiding unnecessary model processing, and eliminates hallucinations by showing only relevant information at each step.

Real-World Example

Traditional Approach:

TOOL CALL: gdrive.getDocument(documentId: "abc123")
  → returns full transcript text (loads into context: 50,000 tokens)
  
TOOL CALL: salesforce.updateRecord(...)
  → model writes entire transcript again (doubles the tokens: +50,000 tokens)

Total: 100,000+ tokens processed, slow response time

With MCP of MCPs:

const transcript = (await gdrive.getDocument({ documentId: 'abc123' })).content;
await salesforce.updateRecord({
  objectType: 'SalesMeeting',
  data: { Notes: transcript }
});

The code executes in one operation. Data flows directly between tools. Only the final result returns to the model.

Total: 2,000 tokens processed (98.7% reduction) ⚡

Key Benefits

✅ Faster Response Time - No need to load all tools upfront
✅ Reduced Hallucinations - Model sees only relevant information
✅ Progressive Disclosure - Load tools on-demand as needed
✅ Code Composition - Orchestrate complex workflows with familiar JavaScript

Setup

Prerequisites

• Node.js
• npm or yarn
• Configured MCP servers you want to aggregate

Installation

1. Clone the repository

git clone https://github.com/eliavamar/mcp-of-mcps.git
cd mcp-of-mcps

2. Install dependencies

npm install

3. Build the project

npm run build

Add to Cline

Add this to your Cline MCP settings file:

Option 1: Using inline configuration (recommended)

{
  "mcpServers": {
    "mcp-of-mcps": {
      "autoApprove": [],
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "node",
      "args": [
        "/absolute/path/to/mcp-of-mcps/build/index.js",
        "--config",
        "[{\"name\":\"weather\",\"command\":\"npx\",\"args\":[\"-y\",\"@h1deya/mcp-server-weather\"]},{\"name\":\"time\",\"command\":\"uvx\",\"args\":[\"mcp-server-time\"]}]"
      ]
    }
  }
}

Option 2: Using a config file

First, create a config.json file that specifies which MCP servers to connect to:

[
  {
    "name": "weather",
    "command": "npx",
    "args": ["-y", "@h1deya/mcp-server-weather"]
  },
  {
    "name": "time",
    "command": "uvx",
    "args": ["mcp-server-time"]
  }
]

Then reference this file in your Cline settings:

{
  "mcpServers": {
    "mcp-of-mcps": {
      "autoApprove": [],
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "node",
      "args": [
        "/absolute/path/to/mcp-of-mcps/build/index.js",
        "/absolute/path/to/your/config.json"
      ]
    }
  }
}

Configuration Options:

• autoApprove: Array of tool names that don't require approval (e.g., ["get_mcps_servers_overview"])
• disabled: Set to false to enable the server
• timeout: Timeout in seconds for tool execution (default: 60)
• type: Connection type, always "stdio" for MCP servers

Learn More

This implementation follows the patterns described in Anthropic's article on code execution with MCP:
📖 Code execution with MCP: Building more efficient agents

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

ISC