MCP servers Claude Code के लिए एक नया और लोकप्रिय प्लंबिंग (infrastructure) की तरह हैं। एक GitHub server जोड़ें और आपका एजेंट pull requests खोल सकता है। एक filesystem server जोड़ें और यह आपके repo structure को पढ़ सकता है। डेमो जादुई लगते हैं। लेकिन कोई भी डेमो में उसका बिल (receipt) नहीं दिखाता।

लागत उन API calls में नहीं है जो tools करते हैं। लागत उन tools में ही है।

हर बार जब आप एक MCP server रजिस्टर करते हैं, तो आप केवल एक क्षमता (capability) नहीं जोड़ रहे होते हैं। आप अपने context window में टेक्स्ट का एक ब्लॉक जोड़ रहे होते हैं, और उस ब्लॉक का शुल्क हर एक turn पर लिया जाता है। चाहे एजेंट उस tool का उपयोग करे या न करे, आपको उसके अस्तित्व के लिए भुगतान करना पड़ता है। जैसे ही server कनेक्ट होता है, मीटर चलना शुरू हो जाता है।

उन Tools का किराया देना जिन्हें आप कभी छूते भी नहीं

यहाँ वह प्रक्रिया (mechanic) है जिसे अक्सर अनदेखा कर दिया जाता है। MCP server में प्रत्येक tool definition के साथ एक नाम, एक विवरण (description), और एक JSON schema आता है जो model को बताता है कि tool को किन arguments की आवश्यकता है। वह पूरा payload हर turn की शुरुआत में system context में डाल दिया जाता है। Model को पूरा कैटलॉग देखने की आवश्यकता होती है ताकि वह तय कर सके कि tool को कॉल करना है या नहीं, लेकिन उस दृश्यता (visibility) का बिल आपको भरना पड़ता है।

प्रति tool overhead मामूली नहीं है। व्यवहार में, एक single tool definition 80 से 150 tokens के बीच खर्च करता है। इसका मतलब है कि दस tools वाला एक साधारण server आपके एक वाक्य टाइप करने से पहले ही चुपचाप 800 से 1,500 tokens खा जाता है। आप compute के लिए भुगतान नहीं कर रहे हैं। आप केवल विकल्प होने के विशेषाधिकार (privilege) के लिए भुगतान कर रहे हैं।

मैंने यह देखने के लिए कि यह कैसे बढ़ता है, एक मानक 20-turn session में गणना की।

बिना किसी MCP server के, overhead शून्य है। Context window में केवल आपकी बातचीत होती है।

तीन सीमित (tightly scoped) tools वाले एक custom minimal server को लोड करें, तो प्रति turn 180 tokens का टैक्स लगता है। 20 turns में, यह 3,600 tokens की बर्बादी है। यह कोई बड़ी आपदा नहीं है, लेकिन यह वास्तविक पैसा है।

लोकप्रिय filesystem server, जो सात tools प्रदान करता है, इसे प्रति turn 640 tokens तक ले जाता है। उसी session में, आपने केवल connection बनाए रखने के लिए 12,800 tokens खर्च कर दिए हैं। आपने अभी तक कोई file नहीं पढ़ी है। आपने कोई directory list नहीं की है। आपने केवल menu में server को बनाए रखा है।

फिर GitHub server आता है। 26 tools रजिस्टर होने के साथ, यह हर turn में 3,100 tokens डाल देता है। 20 संदेशों के आदान-प्रदान के बाद, कुल overhead 62,000 tokens हो जाता है। Sonnet 4 की कीमत पर, यह $0.19 का शुद्ध context tax है। एजेंट द्वारा issue बनाने पर विचार करने से पहले ही आपने overhead के लिए उन्नीस सेंट का भुगतान कर दिया।

अलग से देखने पर यह आंकड़ा छोटा लगता है। लेकिन ऐसा नहीं है।

Overnight Agent की समस्या

जहाँ यह समस्या गंभीर हो जाती है, वह है लंबे समय तक चलने वाले autonomous loops। यदि आप Claude Code का उपयोग एक ऐसे एजेंट के रूप में कर रहे हैं जो अपने आप काम करता है, तो वह प्रति-turn टैक्स बहुत तेजी से बढ़ता है। GitHub server लोड होने के साथ रात भर 2,000 turns तक चलने वाला एजेंट 62,000 tokens का overhead नहीं देता। वह 6.2 million tokens देता है।

यह शाब्दिक रूप से किसी भी उत्पादक (productive) काम के बिना खर्च किए गए $18.60 हैं। हो सकता है कि एजेंट ने एक भी GitHub tool को छुए बिना पूरी रात बिता दी हो। हो सकता है कि उसने पूरी तरह से local files के अंदर काम किया हो। फिर भी, उन 2,000 turns में से हर एक पर आपसे सभी 26 GitHub tool definitions के लिए शुल्क लिया जाता है क्योंकि वे session में रजिस्टर थे।

समझने वाली महत्वपूर्ण बात यह है कि आप registered tools के लिए भुगतान करते हैं, न कि केवल called tools के लिए। Model यह जाँच नहीं करता कि वह वास्तव में किन tools का उपयोग करता है और फिर आपके बिल में छूट देता है। यदि server कनेक्टेड है, तो उसका पूरा manifest हर cycle में context में फिर से डाल दिया जाता है। यह क्षमता (potential) पर लगने वाला प्रति-turn टैक्स है, न कि कार्य (action) पर।

Iterative coding agents, test harnesses, या batch review jobs चलाने वाले डेवलपर्स के लिए, यह बजट का एक गुप्त हत्यारा (silent killer) है। 20 turns की मानवीय बातचीत बहुत कम है। लेकिन 200 या 2,000 turns का agentic loop वह जगह है जहाँ गणित बहुत महंगा साबित होता है।

लागत को नियंत्रण में कैसे रखें

MCP वास्तव में उपयोगी है। आपको इसका उपयोग करना चाहिए। लेकिन इसे एक ऐसी utility की तरह समझें जिसे आप केवल वर्तमान कार्य के लिए चालू करते हैं, न कि किसी ऐसी स्थायी चीज़ की तरह जिसे आप हर session में जोड़ देते हैं।

Configs को Project और Task तक सीमित रखें

डिफ़ॉल्ट रूप से अपने global Claude Code configuration में हर server को लोड न करें। Project-scoped MCP configs बनाएँ जो आपके वास्तविक कार्य से मेल खाते हों। यदि आप किसी local module को refactor कर रहे हैं, तो आपको शायद केवल filesystem server की आवश्यकता होगी। यदि आप issues का triage कर रहे हैं, तो उस विशिष्ट कार्य के लिए GitHub server लोड करें और जब आप वापस local development पर जाएँ, तो उसे डिस्कनेक्ट कर दें।

इसे अपने फोन पर ऐप्स खुले रखने की तरह समझें। एक या दो ठीक हैं। बैकग्राउंड में बीस ऐप्स चलना बिना किसी कारण के बैटरी खत्म कर देता है।

कम Tools वाले Servers को प्राथमिकता दें

Not all MCP servers are designed with the same discipline. Some expose a lean interface of two or three focused actions. Others ship a sprawling catalog of 25 or 30 tools, many of which you will never invoke. A server with three tools might cost you 180 tokens per turn. One with 26 tools can cost 3,100. That is a 17x jump in overhead for a capability gap that may not matter to you.

Before installing a server, look at its tool manifest. If it registers a dozen overlapping operations and you only need one, consider whether you can configure it down, fork it, or write a slimmer wrapper. Every tool definition you can strip out is a direct and permanent token saving on every future turn.

Trim Tool Descriptions

The 80 to 150 token range per tool is not a law of nature. It is a function of how verbose the descriptions and schemas are. A bloated 400-token description eats five times the context of an 80-token description, and that fivefold penalty applies on every single turn.

Audit the servers you rely on. If a tool description reads like marketing copy, rewrite it. Cut adjectives. Cut examples that do not clarify the schema. Tighten the JSON. The model needs to understand what the tool does, but it does not need a paragraph of preamble. Treat tool definitions like code: the shorter and clearer, the better.

The Real Takeaway

MCP extends what Claude Code can reach. It does not extend your context window for free. The overhead is deterministic, recurring, and entirely disconnected from whether the tools see action.

Load only the servers your current task demands. Disconnect them when you are done. Audit tool counts and description lengths like you would audit any other dependency. The rule is simple: if the tool is not adding value in this specific session, it should not be adding tokens to your bill.

Source measurements and methodology: I added MCP servers to Claude Code — here’s what they cost in tokens

Join the GyaanSetu AI learning community for more engineering breakdowns: t.me/GyaanSetuAi