MCP टोकन खपत कैसे कम करें: हमने अपनी टूल परिभाषाएँ 60% कैसे घटाईं

27 अक्टूबर को एक पेइंग यूज़र ने अपनी AgentsRoom सदस्यता रद्द कर दी और वजह टोकन बताई। इस पर बहस करने से पहले, हमने मापा कि हमारा ऐप अपने लॉन्च किए हर एजेंट में क्या जोड़ता है।

सबसे बड़ा आंकड़ा वहाँ नहीं था जहाँ हमने सोचा था। हमारे शुरुआती निर्देश छोटे थे। हर एजेंट को हम जो MCP टूल देते हैं (बैकलॉग, प्रोजेक्ट मेमोरी, एजेंटों के बीच मेल, टर्मिनल, SSH, डेटाबेस और बाकी सब), वे 191 टूल और लगभग 380 KB JSON थे। प्रति टोकन लगभग 4 बाइट के हिसाब से, यह टूल परिभाषाओं के लगभग 95,000 टोकन हैं। एक हफ़्ता पहले यह 78,000 था। किसी ने यह तय नहीं किया था: हर नए टूल ने बस अपना एक पैराग्राफ़ जोड़ दिया था।

हम AgentsRoom बनाते हैं, एक डेस्कटॉप ऐप जो Claude Code, Codex और दूसरे कोडिंग CLI को साथ-साथ चलाता है और उन्हें ये टूल देता है। यह लेख बताता है कि हमने क्या मापा, एक भी टूल हटाए बिना क्या काटा, और वह जाँच जो इसे वापस आने से रोकती है। आप यह सब अपने MCP सर्वरों पर लागू कर सकते हैं।

छोटा जवाब

• टूल परिभाषा वह JSON है जिसे मॉडल हर अनुरोध पर पढ़ सकता है: नाम, विवरण, इनपुट स्कीमा। प्रति टोकन लगभग 4 बाइट गिनें।
• आप इसकी कीमत हर टर्न पर चुकाते हैं या नहीं, यह CLI पर निर्भर है। Claude Code डिफॉल्ट रूप से MCP टूल को टालता है और परिभाषा तब लोड करता है जब उसे ज़रूरत हो। कुछ CLI हर अनुरोध के साथ हर स्कीमा भेजते हैं।
• काटने से पहले मापें। Claude Code में /context, या 40 लाइनों की एक स्क्रिप्ट जो किसी भी सर्वर से उसकी टूल सूची माँगती है।
• टेक्स्ट छोटा करें, टूल रखें। विवरण बताता है क्या और कब। इस्तेमाल का पूरा तरीका एक दस्तावेज़ में जाता है जिसे एजेंट ज़रूरत पड़ने पर पढ़ता है। हमारे टूल लगभग 95,000 से लगभग 38,000 टोकन पर आ गए, 2.5 गुना कम।
• बिल्ड में एक सीमा रखें। इसके बिना परिभाषाएँ अपने आप फिर बढ़ जाती हैं।

एक टूल परिभाषा की कीमत क्या है, और उसे कौन चुकाता है

जब कोई MCP क्लाइंट किसी सर्वर से जुड़ता है, तो वह टूल की सूची माँगता है। हर एंट्री में एक नाम, मॉडल के लिए लिखा गया एक विवरण, और पैरामीटर का एक JSON स्कीमा होता है। क्लाइंट इस सूची को टूल परिभाषाओं में बदलकर मॉडल को भेजता है, और इसी से मॉडल जानता है कि टूल मौजूद है और उसे कैसे कॉल करना है।

तो किसी विवरण का हर शब्द वह इनपुट है जिसे मॉडल पढ़ता है। वह इसे कितनी बार पढ़ता है, यह क्लाइंट पर निर्भर है:

• Claude Code डिफॉल्ट रूप से MCP टूल को टालता है। इसका दस्तावेज़, जिसे हमने 3 नवंबर 2026 को Claude Code 2.1.314 इंस्टॉल करके पढ़ा, कहता है कि सत्र शुरू होने पर सिर्फ़ टूल के नाम और सर्वर के निर्देश लोड होते हैं, और कोई परिभाषा टूल खोज के ज़रिए तब लोड होती है जब Claude को उस टूल की ज़रूरत होती है। ENABLE_TOOL_SEARCH=false के साथ, कॉन्टेक्स्ट विंडो के 10% की सीमा से नीचे auto के साथ, Claude Opus 4 और Sonnet 4 से पुराने मॉडलों पर, या alwaysLoad से चिह्नित सर्वर के लिए, परिभाषाएँ शुरू से ही लोड होती हैं।
• दूसरे CLI अलग हैं। 28 अक्टूबर के हमारे अपने टेस्ट में, एक एजेंट से "OK" जवाब देने को कहा गया: Claude Code हमारे टाले गए टूल के साथ 67,500 टोकन पर खुला, Codex CLI 0.164 25,000 टोकन पर खुला और उसने हमारे स्कीमा एक ब्लॉक में नहीं भेजे, और OpenCode ने कनेक्शन पर हमारे 175 टूल और 19 ब्राउज़र टूल लोड किए और उन्हें हर अनुरोध के साथ भेजा। वही सर्वर, बिल्कुल अलग बिल।

जब टूल सूची नहीं बदलती, तो प्रॉम्प्ट कैशिंग कीमत को नरम करती है: पहले अनुरोध के बाद, एक स्थिर शुरुआती हिस्सा इनपुट कीमत के एक छोटे हिस्से पर कैश से पढ़ा जाता है। लेकिन यह जगह वापस नहीं देती। परिभाषाएँ हर अनुरोध पर कॉन्टेक्स्ट विंडो में, आपके कोड और आपकी बातचीत के बगल में, बैठी रहती हैं। और टाले गए मोड की अपनी कीमत है: हर टूल के पहले इस्तेमाल से पहले एक खोज का चरण।

दो मिनट में अपने टूल मापें

Claude Code में, /context चलाएँ। यह विंडो को स्रोत के हिसाब से बाँटता है और टाले गए या माँग पर लोड होने वाले MCP टूल को चिह्नित करता है। इसे अपने प्रोजेक्ट में एक नए सत्र में, कुछ भी टाइप करने से पहले चलाएँ, और आप देखेंगे कि काम शुरू होने से पहले आपका सेटअप कितना खर्च करता है।

किसी भी सर्वर और किसी भी CLI के लिए, सीधे सर्वर से पूछें। stdio पर चलने वाला MCP सर्वर JSON-RPC बोलता है, हर लाइन में एक संदेश: आप initialize भेजते हैं, फिर tools/list, और जो वापस आता है उसे मापते हैं। यह स्क्रिप्ट ठीक यही करती है, Node के साथ और बिना किसी डिपेंडेंसी के:

// Usage: node mcp-tool-cost.mjs <command that starts the server> [args...]
import { spawn } from 'node:child_process';

const [cmd, ...args] = process.argv.slice(2);
const server = spawn(cmd, args, { stdio: ['pipe', 'pipe', 'ignore'], shell: process.platform === 'win32' });
const tools = [];
let buffer = '';

const send = (msg) => server.stdin.write(JSON.stringify({ jsonrpc: '2.0', ...msg }) + '\n');
const listTools = (cursor) => send({ id: 2, method: 'tools/list', params: cursor ? { cursor } : {} });

server.stdout.on('data', (chunk) => {
  buffer += chunk;
  let end;
  while ((end = buffer.indexOf('\n')) >= 0) {
    const line = buffer.slice(0, end).trim();
    buffer = buffer.slice(end + 1);
    if (line) handle(JSON.parse(line));
  }
});

function handle(msg) {
  if (msg.id === 1) {
    send({ method: 'notifications/initialized' });
    listTools();
  } else if (msg.id === 2) {
    tools.push(...msg.result.tools);
    if (msg.result.nextCursor) listTools(msg.result.nextCursor);
    else { report(); server.kill(); }
  }
}

function report() {
  const rows = tools
    .map((tool) => ({ name: tool.name, bytes: Buffer.byteLength(JSON.stringify(tool)) }))
    .sort((a, b) => b.bytes - a.bytes);
  const total = rows.reduce((sum, row) => sum + row.bytes, 0);
  for (const row of rows.slice(0, 10)) {
    console.log(`${String(row.bytes).padStart(7)} bytes  ~${Math.round(row.bytes / 4)} tokens  ${row.name}`);
  }
  console.log(`${rows.length} tools, ${total} bytes, about ${Math.round(total / 4)} tokens`);
}

send({
  id: 1,
  method: 'initialize',
  params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'tool-cost', version: '1.0.0' } },
});

इसे उसी कमांड के साथ चलाएँ जिससे आपका CLI सर्वर शुरू करता है, उदाहरण के लिए node mcp-tool-cost.mjs npx -y @playwright/mcp@latest। यह दस सबसे भारी टूल और कुल योग छापती है। 3 नवंबर 2026 को हमें यह मिला:

प्रति टोकन चार बाइट एक अनुमान है, सर्वरों की तुलना करने और रुझान देखने के लिए काफ़ी, बिल का अंदाज़ा लगाने के लिए नहीं। असली टोकनाइज़र मॉडल और टेक्स्ट के हिसाब से बदलते हैं, जैसा हमने तब पाया जब हमने अपने 3.8 बिलियन टोकन गिने।

ऊपर के फ़ाइल सर्वर ठीक-ठाक हैं। समस्या कुल योग की है: इस आकार के पाँच सर्वर ही 20,000 टोकन हो जाते हैं, हमारे जैसे किसी सर्वर से पहले ही।

हमने क्या काटा, और किसे नहीं छुआ

हमने जो नियम तय किया: कोई टूल नहीं हटेगा, कोई पैरामीटर नहीं हटेगा, कोई अनुमत मान या ज़रूरी फ़ील्ड नहीं हटेगा। एजेंटों की हर क्षमता बनी रहनी थी। सिर्फ़ टेक्स्ट बदल सकता था।

1. टूल का विवरण एक से तीन वाक्यों में बताता है क्या और कब। कैसे नहीं। बाइट तो "कैसे" में ही थे: नियम, डिफॉल्ट, किनारे के मामले, उदाहरण, और वे चेतावनियाँ जो किसी एजेंट के एक बार टूल का गलत इस्तेमाल करने के बाद लिखी गई थीं।
2. किसी पैरामीटर को एक वाक्य मिलता है, या कुछ नहीं जब उसका नाम, टाइप और अनुमत मानों की सूची पहले से सब कह देती है। जो पैरामीटर कई टूल में दोहराए जाते हैं (project, author, टिकट आईडी) उन्हें हर जगह एक ही मानक वाक्य मिला।
3. इस्तेमाल का तरीका दूसरी जगह गया, मिटाया नहीं गया। टूल के हर परिवार की एक निर्देश फ़ाइल है जिसे एजेंट उस परिवार को पहली बार कॉल करने से पहले पढ़ता है। हमारे सबसे बड़े टूल के लिए, जो एजेंटों की एक टीम सहेजता है, फ़ील्ड का पूरा संदर्भ अब एक टूल कॉल से लौटता है जब एजेंट उसे माँगता है, स्कीमा के साथ हमेशा चलने के बजाय।
4. एक दूसरे दौर ने हर तथ्य की जाँच की। किसी विवरण से हटाया गया हर वाक्य निर्देश फ़ाइलों में खोजा गया, और जहाँ वह नहीं था वहाँ जोड़ा गया।

कुछ नतीजे, प्रति टूल JSON के बाइट में:

कुल मिलाकर 380 KB, 152 KB बन गए। तेरह टूल 4 KB से ऊपर थे; चार अभी भी हैं, क्योंकि उनमें बहुत सारे फ़ील्ड हैं। इस पूरे दौर के पीछे का विचार: किसी टूल को चुनने के लिए मॉडल को सिर्फ़ यह जानना होता है कि वह मौजूद है और उसे कब कॉल करना है। ब्योरे उस पल तक इंतज़ार कर सकते हैं जब वह उसे इस्तेमाल करता है।

अगर आप MCP सर्वर लिखते हैं, तो Claude Code आपको एक और वजह देता है। वह शुरू से लोड किए गए टूल विवरण को 4,096 कैरेक्टर पर काट देता है, और जब वह किसी खोज को किसी विवरण से मिलाता है तो सिर्फ़ उस सीमा के भीतर का हिस्सा पढ़ता है। उसके बाद लिखी कोई ज़रूरी बात शायद कभी न देखी जाए।

शुरुआती फ़ाइल के लिए वही तरकीब

टूल स्कीमा अकेली स्थिर लागत नहीं हैं। हमारे एजेंट टूल इस्तेमाल करने से पहले उनके बारे में एक निर्देश फ़ाइल भी पढ़ते हैं, और वह बढ़कर 57.7 KB हो गई थी, लगभग 14,000 टोकन, जो हर शुरुआत और हर रिज़्यूम पर पूरी पढ़ी जाती थी। एक यूज़र ने बताया कि रिज़्यूम किया गया Codex एजेंट कुछ ही मिनटों में अपनी कामकाजी कॉन्टेक्स्ट सीमा तक पहुँच गया।

सुधार उसी विचार से हुआ। फ़ाइल लगभग 11 KB का एक इंडेक्स बन गई: वे नियम जो हर टूल पर लागू होते हैं, और टूल के हर परिवार के लिए एक लाइन जो उसकी अपनी फ़ाइल की ओर इशारा करती है। परिवारों की 31 फ़ाइलें सिर्फ़ उस परिवार को पहली बार कॉल करने से पहले पढ़ी जाती हैं। उनका टेक्स्ट नहीं बदला, शब्दशः। जो एजेंट सिर्फ़ बैकलॉग छूता है, वह डेटाबेस वाला हिस्सा कभी नहीं पढ़ता।

यह किसी भी लंबी CLAUDE.md या AGENTS.md के लिए भी काम करता है: हमेशा लोड होने वाली फ़ाइल में वह रखें जिसकी हर काम को ज़रूरत है, और बाकी के लिए लिंक दें। इसके बारे में हमने AGENTS.md और कॉन्टेक्स्ट फ़ाइलों पर अपनी गाइड में और लिखा है।

ऐसा बजट जो push को फेल कर दे

जिस आंकड़े ने हमें सबसे ज़्यादा चिंतित किया, वह 95,000 नहीं था। वह एक हफ़्ता पहले का 78,000 था। हर टूल ने एक पैराग्राफ़ जोड़ा, हर पैराग्राफ़ वाजिब था, और कुल योग सात दिनों में 20% बढ़ गया।

तो आकार एक बिल्ड जाँच बन गया। एक JSON फ़ाइल बजट रखती है:

{
  "totalBytes": 160000,
  "perToolBytes": 4000,
  "oversized": {
    "teams_save": 9791,
    "triggers_save": 4071,
    "backlog_update": 4253,
    "backlog_create": 4399
  }
}

एक स्क्रिप्ट हमारे MCP सर्वरों को एक सैंडबॉक्स में शुरू करती है, हर एक से उसके टूल माँगती है, JSON.stringify(tool) को बाइट में मापती है, और जब कुल योग totalBytes को पार करता है या कोई टूल perToolBytes को पार करता है तो एरर के साथ बाहर निकलती है। जो चार टूल पहले से बहुत बड़े थे, वे अपने आकार के साथ सूचीबद्ध हैं: एक ऐसा ताला जो सिर्फ़ एक दिशा में घूमता है। वे छोटे हो सकते हैं, बड़े कभी नहीं, और जब कोई छोटा होता है तो स्क्रिप्ट संख्या घटाने को कहती है। यह हर push से पहले और रिलीज़ बिल्ड में चलती है। सीमा बढ़ाना संभव है, लेकिन वह फ़ाइल में लिखा गया एक फ़ैसला है, जाँच पास कराने का तरीका नहीं।

3 नवंबर को, छह दिन बाद, वही जाँच 203 टूल और 159,957 बाइट पढ़ती है: बारह टूल जोड़े गए, सीमा से 43 बाइट नीचे। अगले टूल को अपनी जगह खुद बनानी होगी। जाँच ठीक इसी के लिए है।

जो इस्तेमाल नहीं करते उसे बंद करें

सबसे सस्ता टोकन उस टूल का है जिसे आपका एजेंट कभी देखता ही नहीं।

• सर्वरों को उन्हीं प्रोजेक्ट तक सीमित रखें जिन्हें उनकी ज़रूरत है। यूज़र स्तर पर घोषित सर्वर हर रिपॉजिटरी में आपके साथ चलता है। Claude Code में, प्रोजेक्ट की .mcp.json उसे वहीं रखती है जहाँ वह काम का है।
• alwaysLoad को मुट्ठी भर टूल के लिए रखें। Claude Code का दस्तावेज़ यह साफ़ कहता है: शुरू से लोड हुआ हर टूल वह कॉन्टेक्स्ट खाता है जो वरना आपकी बातचीत के लिए उपलब्ध होता।
• सिर्फ़ परिभाषाओं पर नहीं, टूल के परिणाम क्या जोड़ते हैं उस पर भी नज़र रखें। जो टूल पूरा पेज या पूरी टेबल लौटाता है, वह एक कॉल में उससे ज़्यादा खर्च कर सकता है जितना उसकी परिभाषा पूरे दिन में करती है।

AgentsRoom में, सेटिंग्स > AgentsRoom टूल हमारे टूल के हर परिवार को उसके वज़न के साथ दिखाता है, और आप किसी परिवार या एक अकेले टूल को बंद कर सकते हैं, सभी प्रोजेक्ट के लिए, एक प्रोजेक्ट के लिए, एक फ़ोल्डर के लिए या एक एजेंट के लिए। बंद किया गया टूल एजेंट को दिखाया ही नहीं जाता, इसलिए उसकी कोई कॉन्टेक्स्ट लागत नहीं होती। AgentsRoom MCP पेज टूल के बारे में बताता है, और सत्र ट्रेस दिखाता है कि किसी एजेंट का कॉन्टेक्स्ट किससे भरा, MCP टूल समेत, आकार के क्रम में।

हमने क्या नहीं बदला

उसी माप से दो और लागतें सामने आईं, और हमने उन्हें जानबूझकर वैसे ही छोड़ दिया।

• शुरुआती ब्रीफ़, जो हर एजेंट को उसकी भूमिका और अपनी स्थिति रिपोर्ट करने का तरीका बताता है: Claude के लिए मीडियन लगभग 5,000 टोकन, यानी 200,000 टोकन की विंडो का लगभग 2.5%, और दूसरे अनुरोध से कैश से पढ़ा जाता है।
• वह स्थिति फ़ाइल जो हर एजेंट एक टर्न के अंत में लिखता है: 71 लोकल Claude ट्रांसक्रिप्ट पर मापी गई, कॉन्टेक्स्ट टोकन का लगभग 2.5%।

इनमें से किसी को भी छोटा करने से विंडो का 3% से कम बचता और एजेंटों के काम की गुणवत्ता जोखिम में पड़ती। टूल परिभाषाएँ 95,000 टोकन थीं। हमारा समय वहीं गया।

लोग असल में जो सवाल पूछते हैं

MCP टूल कितने टोकन इस्तेमाल करते हैं?

हर टूल की कीमत उसकी पूरी परिभाषा है: नाम, विवरण और इनपुट स्कीमा, जो JSON के रूप में भेजे जाते हैं। मोटा नियम है प्रति टोकन 4 बाइट। 3 नवंबर 2026 को मापा गया: आधिकारिक filesystem सर्वर 14 टूल दिखाता है जो लगभग 3,100 टोकन के हैं, Playwright MCP 25 टूल जो लगभग 5,300 के हैं। AgentsRoom के टूल छोटे किए जाने से पहले लगभग 95,000 टोकन के थे, आज लगभग 40,000 के हैं।

क्या Claude Code हर MCP टूल को कॉन्टेक्स्ट विंडो में लोड करता है?

डिफॉल्ट रूप से नहीं। Claude Code की टूल खोज (tool search) MCP टूल की परिभाषाओं को टाल देती है: सत्र शुरू होने पर सिर्फ़ टूल के नाम और सर्वर के निर्देश लोड होते हैं, और Claude किसी टूल की परिभाषा तब लोड करता है जब उसे उस टूल की ज़रूरत होती है। ENABLE_TOOL_SEARCH=false सेट करना, Claude Opus 4 और Sonnet 4 से पुराना मॉडल, या alwaysLoad से चिह्नित सर्वर, परिभाषाओं को शुरू से ही कॉन्टेक्स्ट में वापस डाल देते हैं।

क्या MCP सर्वर टोकन की खपत कम करते हैं?

कर सकते हैं, जब कोई टूल किसी ऐसी चीज़ की जगह छोटा जवाब लौटाता है जिसे एजेंट वरना पूरा पढ़ता, जैसे पूरे डंप की जगह डेटाबेस क्वेरी। लेकिन परिभाषाएँ कॉन्टेक्स्ट खर्च करती हैं, और परिणाम भी: Claude Code चेतावनी देता है जब एक MCP परिणाम 10,000 टोकन पार करता है, और डिफॉल्ट रूप से उसे 25,000 पर काट देता है। MCP सर्वर टोकन तभी बचाता है जब उसके परिणाम उस चीज़ से छोटे हों जिसकी जगह वह लेता है।

मैं कैसे देखूँ कि मेरे MCP टूल कितना कॉन्टेक्स्ट लेते हैं?

Claude Code में /context चलाएँ: यह कॉन्टेक्स्ट को स्रोत के हिसाब से बाँटता है और टाले गए MCP टूल को चिह्नित करता है। किसी भी सर्वर और किसी भी CLI के लिए, सर्वर से उसकी टूल सूची माँगें और JSON को मापें, यही इस लेख की 40 लाइनों वाली स्क्रिप्ट करती है।

एक अच्छा MCP टूल विवरण कैसा होता है?

एक से तीन वाक्य जो बताएँ कि टूल क्या करता है और उसे कब कॉल करना है, और जिन शब्दों को एजेंट खोजेगा वे शुरुआत में हों। किसी पैरामीटर को एक वाक्य मिलता है, या कुछ नहीं जब उसका नाम, टाइप और अनुमत मान पहले से सब कह देते हैं। नियम, किनारे के मामले और लंबे उदाहरण एक ऐसे दस्तावेज़ में जाते हैं जिसे एजेंट ज़रूरत पड़ने पर पढ़ता है। वैसे भी, Claude Code शुरू से लोड किए गए विवरण को 4,096 कैरेक्टर पर काट देता है।

टूल परिभाषाओं को फिर से बढ़ने से कैसे रोकें?

उन्हें ऐसा बजट दें जिसे बिल्ड जाँच सके। हम एक JSON फ़ाइल रखते हैं जिसमें कुल सीमा और प्रति टूल सीमा है, एक स्क्रिप्ट जो हमारे MCP सर्वर शुरू करती है, हर टूल को मापती है और किसी भी सीमा के पार होने पर एरर के साथ बाहर निकलती है, और हम इसे हर push से पहले चलाते हैं। जो टूल पहले से बहुत बड़े थे वे छोटे हो सकते हैं, बड़े कभी नहीं।

संक्षेप में

आपके MCP टूल वह टेक्स्ट हैं जिसे मॉडल पढ़ता है, और कोई उस टेक्स्ट की समीक्षा वैसे नहीं करता जैसे कोड की करता है। इसे एक बार मापें: Claude Code में /context, या किसी भी सर्वर के लिए ऊपर की स्क्रिप्ट। फिर हर विवरण से कहलवाएँ क्या और कब, "कैसे" को उस फ़ाइल में ले जाएँ जिसे एजेंट ज़रूरत पड़ने पर पढ़ता है, और अपने बिल्ड में एक संख्या रखें ताकि यह फिर से बढ़ न सके।

हम एक भी टूल हटाए बिना लगभग 95,000 से लगभग 38,000 टोकन पर आ गए। अगर आप एक ही टूल के साथ कई एजेंट चलाते हैं, तो AgentsRoom मुफ़्त में डाउनलोड होता है, और MCP सर्वर पेज दिखाता है कि हर CLI और हर प्रोजेक्ट के लिए एक सर्वर एक ही बार में कैसे घोषित करें।