MCP servers are the hot new plumbing for Claude Code. Drop in a GitHub server and your agent can open pull requests. Add a filesystem server and it reads your repo structure. The demos look magical. What nobody demos is the receipt.

The cost is not in the API calls the tools make. It is in the tools themselves.

Every time you register an MCP server, you are not just adding a capability. You are adding a block of text to your context window, and that block gets billed on every single turn. Whether the agent uses the tool or not, you pay for its existence. The meter starts running the moment the server connects.

Paying Rent on Tools You Never Touch

Here is the mechanic that gets glossed over. Each tool definition in an MCP server ships with a name, a description, and a JSON schema telling the model what arguments the tool expects. That entire payload gets injected into the system context at the start of every turn. The model needs to see the full catalog so it can decide whether to call a tool, but you are the one footing the bill for that visibility.

The overhead per tool is not trivial. In practice, a single tool definition consumes between 80 and 150 tokens. That means a modest server exposing ten tools quietly eats 800 to 1,500 tokens before you have typed a single sentence. You are not paying for compute. You are paying for the privilege of having the option.

I ran the numbers across a standard 20-turn session to see exactly how this compounds.

With no MCP servers loaded, the overhead is zero. The context window contains only your conversation.

Load a custom minimal server with three tightly scoped tools, and the tax is 180 tokens per turn. Across 20 turns, that is 3,600 tokens gone. Not a disaster, but real money.

The popular filesystem server, which exposes seven tools, pushes that to 640 tokens per turn. Over the same session, you have burned 12,800 tokens just maintaining the connection. You have not read a file yet. You have not listed a directory. You have merely kept the server on the menu.

Then there is the GitHub server. With 26 tools registered, it dumps 3,100 tokens into every turn. After 20 back-and-forth messages, the overhead totals 62,000 tokens. At Sonnet 4 pricing, that is $0.19 in pure context tax. You paid nineteen cents for overhead before the agent even considered creating an issue.

That figure feels small in isolation. It is not.

The Overnight Agent Problem

Where this stings is in long-running autonomous loops. If you are using Claude Code as an agent that iterates on its own, that per-turn tax multiplies brutally. An agent running overnight across 2,000 turns with the GitHub server loaded does not pay 62,000 tokens in overhead. It pays 6.2 million.

That is $18.60 spent on literally nothing productive. The agent might have slept through the night without touching a single GitHub tool. It might have worked entirely inside local files. You still get charged for all 26 GitHub tool definitions on every one of those 2,000 turns because they were registered in the session.

The critical point to internalize is that you pay for registered tools, not called tools. The model does not check which tools it actually uses and then discount your bill. If the server is connected, its full manifest is re-introduced into context each cycle. This is a per-turn tax on potential, not on action.

For developers running iterative coding agents, test harnesses, or batch review jobs, this is a silent budget killer. A human conversation of 20 turns is light. An agentic loop of 200 or 2,000 turns is where the math turns punitive.

How to Keep Costs Under Control

MCP is genuinely useful. You should use it. But treat it like a utility you switch on for the job at hand, not a permanent fixture you bolt onto every session.

Scope Configs to the Project and Task

Do not load every server into your global Claude Code configuration by default. Build project-scoped MCP configs that match the work you are actually doing. If you are refactoring a local module, you probably need the filesystem server and nothing else. If you are triaging issues, load the GitHub server for that specific task and disconnect it when you switch back to local development.

Think of it like leaving apps open on your phone. One or two is fine. Twenty running in the background drains the battery for no reason.

Prefer Servers with Fewer Tools

ಎಲ್ಲಾ MCP ಸರ್ವರ್‌ಗಳನ್ನು ಒಂದೇ ರೀತಿಯ ಶಿಸ್ತಿನೊಂದಿಗೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿಲ್ಲ. ಕೆಲವು ಎರಡು ಅಥವಾ ಮೂರು ಕೇಂದ್ರೀಕೃತ ಕ್ರಿಯೆಗಳ ಸಣ್ಣ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಇನ್ನು ಕೆಲವು 25 ಅಥವಾ 30 ಪರಿಕರಗಳ (tools) ದೊಡ್ಡ ಪಟ್ಟಿಯನ್ನು ನೀಡುತ್ತವೆ, ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನವುಗಳನ್ನು ನೀವು ಎಂದಿಗೂ ಬಳಸುವುದಿಲ್ಲ. ಮೂರು ಪರಿಕರಗಳಿರುವ ಸರ್ವರ್ ಪ್ರತಿ ಟರ್ನ್‌ಗೆ (turn) 180 ಟೋಕನ್‌ಗಳ ವೆಚ್ಚವನ್ನು ಉಂಟುಮಾಡಬಹುದು. 26 ಪರಿಕರಗಳಿರುವ ಸರ್ವರ್ 3,100 ಟೋಕನ್‌ಗಳವರೆಗೆ ವೆಚ್ಚವಾಗಬಹುದು. ಇದು ನಿಮಗೆ ಅಷ್ಟೇನೂ ಅಗತ್ಯವಿಲ್ಲದ ಸಾಮರ್ಥ್ಯಕ್ಕಾಗಿ 17 ಪಟ್ಟು ಹೆಚ್ಚಿನ ಓವರ್‌ಹೆಡ್ (overhead) ವೆಚ್ಚವಾಗಿದೆ.

ಸರ್ವರ್ ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುವ ಮೊದಲು, ಅದರ ಟೂಲ್ ಮ್ಯಾನಿಫೆಸ್ಟ್ (tool manifest) ಅನ್ನು ಗಮನಿಸಿ. ಅದು ಒಂದೇ ರೀತಿಯ ಅನೇಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹೊಂದಿದ್ದು, ನಿಮಗೆ ಕೇವಲ ಒಂದೇ ಅಗತ್ಯವಿದ್ದರೆ, ಅದನ್ನು ಕಡಿಮೆ ಮಾಡಿಕೊಳ್ಳಲು (configure down), ಫೋರ್ಕ್ (fork) ಮಾಡಲು ಅಥವಾ ಸಣ್ಣ ವ್ರ್ಯಾಪ್ಪರ್ (wrapper) ಬರೆಯಲು ಸಾಧ್ಯವೇ ಎಂದು ಯೋಚಿಸಿ. ನೀವು ತೆಗೆದುಹಾಕುವ ಪ್ರತಿಯೊಂದು ಟೂಲ್ ವ್ಯಾಖ್ಯಾನವು (tool definition) ಮುಂದಿನ ಪ್ರತಿಯೊಂದು ಟರ್ನ್‌ಗಳಲ್ಲಿ ನೇರ ಮತ್ತು ಶಾಶ್ವತವಾದ ಟೋಕನ್ ಉಳಿತಾಯಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಟೂಲ್ ವಿವರಣೆಗಳನ್ನು ಕಡಿತಗೊಳಿಸಿ

ಪ್ರತಿ ಟೂಲ್‌ಗೆ 80 ರಿಂದ 150 ಟೋಕನ್‌ಗಳ ವ್ಯಾಪ್ತಿಯು ಪ್ರಕೃತಿಯ ನಿಯಮವಲ್ಲ. ಇದು ವಿವರಣೆಗಳು ಮತ್ತು ಸ್ಕೀಮಾಗಳು (schemas) ಎಷ್ಟು ವಿವರವಾಗಿವೆ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. 400 ಟೋಕನ್‌ಗಳ ದೊಡ್ಡ ವಿವರಣೆಯು 80 ಟೋಕನ್‌ಗಳ ವಿವರಣೆಯಿಗಿಂತ ಐದು ಪಟ್ಟು ಹೆಚ್ಚು ಕಾನ್ಟೆಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತದೆ, ಮತ್ತು ಈ ಐದು ಪಟ್ಟು ಹೆಚ್ಚಿನ ಹೊರೆಯು ಪ್ರತಿ ಟರ್ನ್‌ಗೂ ಅನ್ವಯಿಸುತ್ತದೆ.

ನೀವು ಅವಲಂಬಿಸಿರುವ ಸರ್ವರ್‌ಗಳನ್ನು ಆಡಿಟ್ (audit) ಮಾಡಿ. ಒಂದು ವೇಳೆ ಟೂಲ್ ವಿವರಣೆಯು ಮಾರ್ಕೆಟಿಂಗ್ ಜಾಹೀರಾತಿನಂತೆ ಕಂಡರೆ, ಅದನ್ನು ಮರುಬರೆಯಿರಿ. ವಿಶೇಷಣಗಳನ್ನು (adjectives) ಕಡಿತಗೊಳಿಸಿ. ಸ್ಕೀಮಾವನ್ನು ಸ್ಪಷ್ಟಪಡಿಸದ ಉದಾಹರಣೆಗಳನ್ನು ತೆಗೆದುಹಾಕಿ. JSON ಅನ್ನು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಿ. ಮಾಡೆಲ್‌ಗೆ ಆ ಟೂಲ್ ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದು ಅರ್ಥವಾಗಬೇಕು, ಆದರೆ ಅದಕ್ಕೆ ಸುದೀರ್ಘವಾದ ಪೀಠಿಕೆಯ ಅಗತ್ಯವಿಲ್ಲ. ಟೂಲ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಕೋಡ್‌ನಂತೆ ಪರಿಗಣಿಸಿ: ಅವು ಎಷ್ಟು ಚಿಕ್ಕದಾಗಿ ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿರುತ್ತವೆಯೋ ಅಷ್ಟು ಉತ್ತಮ.

ಮುಖ್ಯವಾದ ಅಂಶ

MCP ಎಂಬುದು Claude Code ನ ವ್ಯಾಪ್ತಿಯನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ. ಆದರೆ ಇದು ನಿಮ್ಮ ಕಾನ್ಟೆಕ್ಸ್ ವಿಂಡೋವನ್ನು (context window) ಉಚಿತವಾಗಿ ವಿಸ್ತರಿಸುವುದಿಲ್ಲ. ಇದರ ಓವರ್‌ಹೆಡ್ ನಿರ್ಧರಿಸಲ್ಪಟ್ಟಿದೆ, ಪುನರಾವರ್ತಿತವಾಗಿದೆ ಮತ್ತು ಪರಿಕರಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದೀರಾ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದಕ್ಕೆ ಸಂಬಂಧಿಸಿಲ್ಲ.

ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಕೆಲಸಕ್ಕೆ ಅಗತ್ಯವಿರುವ ಸರ್ವರ್‌ಗಳನ್ನು ಮಾತ್ರ ಲೋಡ್ ಮಾಡಿ. ಕೆಲಸ ಮುಗಿದ ನಂತರ ಅವುಗಳನ್ನು ಡಿಸ್ಕನೆಕ್ಟ್ ಮಾಡಿ. ಇತರ ಅವಲಂಬನೆಗಳನ್ನು (dependencies) ಆಡಿಟ್ ಮಾಡುವಂತೆ ಟೂಲ್ ಸಂಖ್ಯೆ ಮತ್ತು ವಿವರಣೆಯ ಉದ್ದವನ್ನು ಆಡಿಟ್ ಮಾಡಿ. ನಿಯಮ ಸರಳವಾಗಿದೆ: ಒಂದು ವೇಳೆ ಆ ಟೂಲ್ ಈ ನಿರ್ದಿಷ್ಟ ಸೆಷನ್‌ನಲ್ಲಿ ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ನೀಡುತ್ತಿಲ್ಲದಿದ್ದರೆ, ಅದು ನಿಮ್ಮ ಬಿಲ್‌ಗೆ ಹೆಚ್ಚಿನ ಟೋಕನ್‌ಗಳನ್ನು ಸೇರಿಸಬಾರದು.

ಮೂಲ ಅಳತೆಗಳು ಮತ್ತು ವಿಧಾನ: I added MCP servers to Claude Code — here’s what they cost in tokens

ಹೆಚ್ಚಿನ ಇಂಜಿನಿಯರಿಂಗ್ ವಿಶ್ಲೇಷಣೆಗಳಿಗಾಗಿ GyaanSetu AI ಕಲಿಕಾ ಸಮುದಾಯವನ್ನು ಸೇರಿ: t.me/GyaanSetuAi