One MCP Server Added 372 Tools and 84,000 Tokens of Schema

We added one MCP server to Claude Code with a single line of config. It is our hosting provider's, installed the ordinary way with npx, and it looked like a small thing.

Then we asked it what it exposes. 372 tools. 335,954 bytes of JSON schema. Roughly 84,000 tokens. That is 42% of a 200K context window from one entry in a config file, before you type anything.

It does not actually cost that today, because Claude Code defers MCP tools by default and searches for them on demand. But that default is the only thing standing between you and a context window that is nearly half spent on a hosting API you use twice a month. Here is how to measure yours and what the switches do.

What you will end up with

A reproducible measurement of every MCP server you have installed, the tool count and schema size for each, and the settings that decide whether that cost is paid upfront or on demand. About 25 minutes, and all of it is read-only.

Start with what is actually configured

Most people have more MCP servers than they remember. The CLI will tell you, and it health-checks each one:

claude mcp list

Ours came back with 27 servers. Five connected, twenty-two sitting there needing authentication:

Status	Count
Connected	5
Needs authentication	22
Failed	0

Twenty-two servers configured and unusable is its own small lesson. Every one was added deliberately at some point, none were removed, and the list is now mostly archaeology.

They come from three scopes, and knowing which is which tells you where to go to remove one:

Scope	Applies to	Stored in
Local	Current project, private	~/.claude.json under the project path
Project	Current project, shared via git	.mcp.json in the repo root
User	All your projects	~/.claude.json at the root

When the same server is defined more than once, precedence runs local, then project, then user, then plugin-provided, then claude.ai connectors, and Claude Code connects exactly once.

Measure what a server actually costs

This is the part nobody does, and it takes one command. MCP is JSON-RPC over stdio, so you can talk to a server yourself without Claude Code in the loop. Send an initialize, an initialized notification, then tools/list:

printf '%s\n' \
'{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"probe","version":"1.0"}}}' \
'{"jsonrpc":"2.0","method":"notifications/initialized"}' \
'{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' \
| npx -y your-mcp-server@latest 2>/dev/null > out.json

Then measure the response. Bytes divided by four is a serviceable token estimate:

python3 - <<'EOF'
import json
tools = None
for line in open('out.json'):
    line = line.strip()
    if not line: continue
    try: m = json.loads(line)
    except: continue
    if m.get('id') == 2 and 'result' in m:
        tools = m['result'].get('tools', [])
blob = json.dumps(tools)
print(f"tools: {len(tools)}")
print(f"schema bytes: {len(blob):,}  (~{len(blob)//4:,} tokens)")
EOF

Our result, from the one server:

tools exposed: 372
raw JSON schema bytes: 335,954  (~83,988 tokens)
names: 10,747 chars   descriptions: 101,222 chars
median tool definition: 774 bytes
largest: agency-hosting_createANewWebsiteV1 at 3,584 bytes

The descriptions alone are 101,222 characters. The median tool is 774 bytes, so this is not a few monsters dragging up an average, it is 372 ordinary tool definitions that add up.

How big is big? We probed the reference servers

372 tools only means something next to a baseline, so we ran the same probe against the official reference servers. Same command, just a different package name:

Server	Tools	Schema bytes	Approx tokens
server-sequential-thinking	1	4,764	~1,191
server-memory	9	11,503	~2,875
server-filesystem	14	13,663	~3,415
Our hosting provider	372	335,954	~83,988

A typical, well-scoped MCP server is one to fifteen tools and costs one to four thousand tokens. Ours is 25 times the filesystem server and 70 times sequential-thinking. That is the difference between a tool and a whole vendor API surface pasted into your session, and both are installed the same way.

The floor is interesting too. Sequential-thinking exposes a single tool and still costs 4,764 bytes, because one thorough description and JSON schema is not free. There is no such thing as a zero-cost server, only a proportionate one.

Why it does not actually cost that

Tool search. It is on by default, and instead of sending every server's complete tool list upfront, Claude Code searches for relevant tools when they are needed. The 372 definitions exist, they are discoverable, and they are not sitting in your context window.

There is a discovery cache too, from v2.1.221, which caches server tool lists between sessions so a server connects only on first tool use. Control it with MCP_DISCOVERY_CACHE=1 to enable or 0 to keep it off.

The important thing is the exceptions, because tool search is not always active. It is off with a custom ANTHROPIC_BASE_URL, off if you set ENABLE_TOOL_SEARCH=false, and off on older Claude models. Any of those three and the full 84,000 tokens go in upfront.

The default is doing all the work. Change your base URL for a proxy and a config line you forgot about becomes 42% of your context window.

What broke

Our first probe returned nothing. We sent initialize and tools/list and got no result. MCP requires the notifications/initialized message between them, and a compliant server will not answer tools/list until it has seen it. Adding that one line fixed it. If your probe comes back empty, that is almost always why.

We assumed 27 configured servers meant 27 servers' worth of tools. It does not. Twenty-two need authentication and expose nothing until they get it. The number that matters is the tool count from the servers that actually connect, which is why claude mcp list is the wrong place to stop and the probe is the right place to continue.

We looked for a setting to turn tool search on. There is not one in the documented settings; it is the default behaviour, and what exists is the environment variable to turn it off. If you have been searching for how to enable it, it is already enabled.

The other budget: tool output

Tool definitions are what a server costs before you call it. Output is what it costs after. Claude Code warns at 10,000 tokens of MCP tool output and limits at 25,000 by default, adjustable with MAX_MCP_OUTPUT_TOKENS, up to 500,000 for specific tools.

A server can also declare its own ceiling per tool in its tools/list response, using anthropic/maxResultSizeChars in the tool's _meta. That is worth knowing when you write a server: a schema-dump tool that legitimately returns 200,000 characters can say so rather than being truncated.

Common mistakes

• Installing a server for one tool. You get all 372. Permission rules can deny specific MCP tools by name, which narrows what Claude will call but does not change what a non-deferred client would load.
• Leaving dead servers configured. Twenty-two of ours needed auth. They cost nothing in tokens, but they turn claude mcp list into noise and make a genuinely broken server hard to spot.
• Adding servers at user scope by reflex. A hosting provider's API does not belong in every project. Local scope is the default for a reason.
• Committing .mcp.json without thinking about it. Project scope is shared through git, so everyone on the team gets the server and its tool surface.
• Assuming tool search is universal. A custom ANTHROPIC_BASE_URL for a proxy or gateway silently turns it off, and that is exactly the setup where a large server hurts most.
• Never measuring. The install is one line and the cost is five figures of tokens. Nothing in between tells you.

What we would not do yet

We are not removing the twenty-two unauthenticated servers. They cost no context, and each one is a note about something someone meant to set up. We will prune them when the list stops being scannable, not on principle.

We are also not setting ENABLE_TOOL_SEARCH=false to "make tools more reliable," which is a tempting trade when Claude cannot find a tool you know exists. On a 372-tool server that trade costs 42% of a 200K context window. Fix the discovery problem instead by narrowing which servers are enabled for the project.

The rollback

Every change here is reversible and none of it touches a running system:

claude mcp remove <name>
claude mcp remove <name> --scope project
claude mcp remove <name> --scope user

Toggling in /mcp is gentler still, since it disables without deleting the config. The probe itself starts a server, lists its tools and exits, so it changes nothing at all.

The number worth carrying away is 372 tools from one line of config. Go and run the probe against whatever you installed last month.