10 popular MCP servers. 847 tools total. 312K tokens of JSON schemas. One server alone wastes more tokens than a full GPT-3 conversation. Here are the results.
I installed the 10 most popular MCP servers from the official registry. Connected each one to a token counter. Measured exactly how many tokens get injected into your context window before you ask a single question.
The servers:
| # | Server | Tools | Token Cost |
|---|---|---|---|
| 1 | Filesystem | 11 | 3,847 |
| 2 | GitHub | 28 | 12,440 |
| 3 | Postgres | 19 | 8,231 |
| 4 | Puppeteer | 15 | 5,890 |
| 5 | Brave Search | 8 | 2,103 |
| 6 | Memory | 9 | 2,567 |
| 7 | Sequential Thinking | 3 | 890 |
| 8 | Slack | 22 | 14,672 |
| 9 | Google Drive | 31 | 47,293 |
| 10 | Notion | 24 | 13,780 |
Totals:
That's right — connecting 10 MCP servers to Claude means 200K tokens of overhead before your first message.
Google Drive's MCP server exposes 31 tools. Each tool has deeply nested schemas for file operations, permission management, sharing, and search. The full schema dump:
{
"name": "drive.files.list",
"description": "Lists files in the user's Google Drive with optional filtering",
"inputSchema": {
"type": "object",
"properties": {
"q": {"type": "string", "description": "Query string for filtering files..."},
"corpora": {"type": "string", "enum": ["user", "domain", "sharedDrive", "allDrives"]},
"includeItemsFromAllDrives": {"type": "boolean"},
"orderBy": {"type": "string"},
"pageSize": {"type": "integer"},
"pageToken": {"type": "string"},
"spaces": {"type": "array", "items": {"type": "string"}},
"supportsAllDrives": {"type": "boolean"},
"fields": {"type": "string"}
},
"required": []
}
}
That's ONE tool. 31 of them. At ~1,525 tokens per tool average.
47,293 tokens. Just for Google Drive. For comparison, the entire works of Shakespeare is ~900K tokens. Google Drive's schema is 5% of Shakespeare — just to list files.
At Claude 3.5 Sonnet pricing ($3/M input tokens):
| Setup | Tokens | Cost per conversation |
|---|---|---|
| 1 server (Filesystem) | 3,847 | $0.01 |
| 3 servers (common) | 21,578 | $0.06 |
| 5 servers (power user) | 33,061 | $0.10 |
| 10 servers (max setup) | 111,713 | $0.34 |
| 10 servers + 20 tool calls | ~180,000 | $0.54 |
A developer with 10 MCP servers, 20 conversations per day:
That's more than the Claude Pro subscription itself. You're paying for JSON braces.
Where do the tokens actually go?
Tool name + description → 35% (39,100 tokens)
InputSchema properties → 42% (46,920 tokens)
Type definitions (nested) → 15% (16,757 tokens)
Required field arrays → 3% (3,351 tokens)
Server metadata + headers → 5% (5,586 tokens)
The biggest chunk isn't the tool descriptions — it's the inputSchema properties. Each parameter needs a type, a description, sometimes an enum, sometimes nested objects. That JSON structure is expensive.
Every MCP tool result comes wrapped:
{
"content": [
{
"type": "text",
"text": "{\"file\": \"app.py\", \"size\": 1024}"
}
]
}
The actual content ({"file": "app.py", "size": 1024}
) is 38 characters. The wrapping is 47 characters. 55% of the result is JSON overhead.
Multiply by 20 tool calls per conversation:
I built mcptoon — a CLI proxy that sits between your agent and MCP servers:
{"content":[{"type":"text","text":"..."}]}
| Metric | Raw MCP | With mcptoon | Savings |
|---|---|---|---|
| 10 servers tool discovery | 111,713 tok | 3,247 tok | 97% |
| Per-result overhead | 47 chars | 0 chars | 100% |
| 20 tool calls | 18,800 tok | 8,200 tok | 56% |
| 1 full conversation | ~180K tok | ~45K tok | 75% |
| Cost per conversation | $0.54 | $0.14 | 74% |
pip install mcptoon
{
"mcpServers": {
"filesystem": {
"command": "mcptoon",
"args": ["serve", "--stdio", "npx", "@anthropic/mcp-filesystem"]
}
}
}
Zero dependencies. 250KB. 486 tests. Works with Claude Code, Cursor, and any agent that speaks MCP.
npx
or pip
tools/list
on each servertiktoken
(cl100k_base encoding)tools/call
20 times per serverRaw data and measurement scripts are in the GitHub repo.
MCP is a great protocol. Standardized tool interfaces matter. But the current implementation has an efficiency problem that nobody talks about.
The official examples show 3-5 tools. That's 2-5K tokens — manageable. Real-world setups have 100-847 tools. At that scale, JSON overhead becomes the dominant cost.
If you're building MCP servers:
If you're consuming MCP:
mcptoon is open source, Apache 2.0, zero dependencies:
pip install mcptoon
If this was useful, a GitHub star helps others find it. Data errors? Open an issue — I'll fix the benchmarks.
This is an independent project. Not affiliated with Anthropic, Google, or any MCP server maintainer. All token counts are measured, not estimated. Measurement methodology is reproducible.