MCP సర్వర్లు Claude Code కోసం ఇప్పుడు బాగా ప్రాచుర్యం పొందుతున్న కొత్త అనుసంధాన వ్యవస్థ (plumbing) వంటివి. ఒక GitHub సర్వర్‌ను జోడిస్తే, మీ ఏజెంట్ పుల్ రిక్వెస్ట్‌లను (pull requests) ఓపెన్ చేయగలదు. ఒక filesystem సర్వర్‌ను జోడిస్తే, అది మీ రిపో (repo) నిర్మాణాన్ని చదువుతుంది. డెమోలు అద్భుతంగా కనిపిస్తాయి. కానీ ఎవరూ చూపించనిది ఆ ఖర్చుల బిల్లు (receipt).

ఖర్చు అనేది టూల్స్ చేసే API కాల్స్‌లో లేదు. అది ఆ టూల్స్‌లోనే ఉంది.

మీరు ప్రతిసారి ఒక MCP సర్వర్‌ను రిజిస్టర్ చేసినప్పుడు, కేవలం ఒక సామర్థ్యాన్ని మాత్రమే జోడించడం లేదు. మీరు మీ కాంటెక్స్ట్ విండోకు (context window) ఒక టెక్స్ట్ బ్లాక్‌ను జోడిస్తున్నారు, మరియు ఆ బ్లాక్ ప్రతి టర్న్ (turn) కి బిల్లు చేయబడుతుంది. ఏజెంట్ ఆ టూల్‌ను ఉపయోగించినా లేకపోయినా, దాని ఉనికి కోసం మీరు చెల్లించాల్సి ఉంటుంది. సర్వర్ కనెక్ట్ అయిన క్షణం నుండే ఖర్చు మొదలవుతుంది.

మీరు ఎప్పుడూ ఉపయోగించని టూల్స్‌కు అద్దె చెల్లించడం

ఇక్కడ ఎవరూ పట్టించుకోని ఒక విషయం ఉంది. MCP సర్వర్‌లోని ప్రతి టూల్ డెఫినిషన్ (tool definition) ఒక పేరు, వివరణ మరియు టూల్‌కు ఎలాంటి ఆర్గ్యుమెంట్స్ (arguments) అవసరమో తెలిపే JSON స్కీమాతో వస్తుంది. ఆ మొత్తం పేలోడ్ (payload) ప్రతి టర్న్ ప్రారంభంలో సిస్టమ్ కాంటెక్స్ట్‌లోకి ఇంజెక్ట్ చేయబడుతుంది. టూల్‌ను పిలవాలా వద్దా అని నిర్ణయించుకోవడానికి మోడల్ ఆ పూర్తి క్యాటలాగ్‌ను చూడాలి, కానీ ఆ దృశ్యమానత (visibility) కోసం బిల్లు చెల్లించేది మీరే.

ప్రతి టూల్ వల్ల కలిగే ఓవర్‌హెడ్ (overhead) తక్కువ కాదు. వాస్తవానికి, ఒకే ఒక టూల్ డెఫినిషన్ 80 నుండి 150 టోకెన్ల వరకు వినియోగిస్తుంది. అంటే, పది టూల్స్‌ను ప్రదర్శించే ఒక సాధారణ సర్వర్, మీరు ఒక్క వాక్యం కూడా టైప్ చేయకముందే నిశ్శబ్దంగా 800 నుండి 1,500 టోకెన్లను ఖర్చు చేస్తుంది. మీరు కంప్యూట్ (compute) కోసం చెల్లించడం లేదు. కేవలం ఆ ఆప్షన్ ఉండటం అనే సౌకర్యం కోసం చెల్లిస్తున్నారు.

ఇది ఎలా పెరుగుతుందో చూడటానికి నేను ఒక ప్రామాణిక 20-టర్న్ సెషన్‌ను విశ్లేషించాను.

ఎటువంటి MCP సర్వర్లు లోడ్ చేయనప్పుడు, ఓవర్‌హెడ్ సున్నా. కాంటెక్స్ట్ విండోలో మీ సంభాషణ మాత్రమే ఉంటుంది.

మూడు టూల్స్‌తో కూడిన ఒక చిన్న సర్వర్‌ను లోడ్ చేస్తే, ప్రతి టర్న్‌కు 180 టోకెన్ల పన్ను (tax) పడుతుంది. 20 టర్న్ల కాలంలో, అది 3,600 టోకెన్లు అవుతుంది. ఇది పెద్ద నష్టం కాకపోయినా, ఖచ్చితంగా డబ్బు ఖర్చవుతుంది.

ఏడు టూల్స్‌ను ప్రదర్శించే ప్రసిద్ధ filesystem సర్వర్, దీనిని ప్రతి టర్న్‌కు 640 టోకెన్లకు పెంచుతుంది. అదే సెషన్‌లో, కేవలం కనెక్షన్‌ను కొనసాగించడం కోసమే మీరు 12,800 టోకెన్లను వృథా చేశారు. మీరు ఇంకా ఏ ఫైల్‌ను చదవలేదు, డైరెక్టరీని కూడా చూడలేదు. మీరు కేవలం ఆ సర్వర్‌ను మెనూలో ఉంచారు అంతే.

ఇక GitHub సర్వర్ విషయానికి వస్తే, 26 టూల్స్ రిజిస్టర్ అయి ఉండటం వల్ల, ప్రతి టర్న్‌కు 3,100 టోకెన్లు పడుతుంది. 20 సందేశాల తర్వాత, మొత్తం ఓవర్‌హెడ్ 62,000 టోకెన్లు అవుతుంది. Sonnet 4 ధరల ప్రకారం, ఇది కేవలం కాంటెక్స్ట్ పన్ను రూపంలో $0.19 అవుతుంది. ఏజెంట్ ఒక ఇష్యూ (issue) క్రియేట్ చేయడం గురించి ఆలోచించకముందే, మీరు ఓవర్‌హెడ్ కోసం 19 సెంట్లు చెల్లించారు.

విడిగా చూస్తే ఈ మొత్తం చిన్నదిగా అనిపించవచ్చు. కానీ అది నిజం కాదు.

ఓవర్‌నైట్ ఏజెంట్ సమస్య

ఇది నిజంగా ఇబ్బంది పెట్టేది లాంగ్-రన్నింగ్ ఆటోనమస్ లూప్స్ (long-running autonomous loops) లో. మీరు Claude Codeను స్వయంగా పనిచేసే ఏజెంట్‌గా ఉపయోగిస్తుంటే, ఆ ప్రతి-టర్న్ పన్ను విపరీతంగా పెరుగుతుంది. GitHub సర్వర్‌తో రాత్రంతా 2,000 టర్న్‌ల పాటు నడిచే ఏజెంట్, 62,000 టోకెన్ల ఓవర్‌హెడ్‌ను మాత్రమే కాదు, 6.2 మిలియన్ టోకెన్లను చెల్లిస్తుంది.

అంటే ఎటువంటి ఉపయోగం లేని పని కోసం $18.60 ఖర్చు చేసినట్లు అవుతుంది. ఏజెంట్ ఒక్క GitHub టూల్‌ను కూడా తాకకుండా రాత్రంతా నిద్రపోవచ్చు లేదా కేవలం లోకల్ ఫైల్స్‌లోనే పనిచేయవచ్చు. అయినప్పటికీ, ఆ 2,000 టర్న్‌ల సమయంలో ప్రతిసారీ ఆ 26 GitHub టూల్ డెఫినిషన్ల కోసం మీరు ఛార్జ్ చేయబడతారు, ఎందుకంటే అవి సెషన్‌లో రిజిస్టర్ చేయబడ్డాయి.

ఇక్కడ గుర్తుంచుకోవాల్సిన ముఖ్యమైన విషయం ఏమిటంటే, మీరు పిలిచిన టూల్స్‌కు కాదు, రిజిస్టర్ చేసిన టూల్స్‌కు చెల్లిస్తారు. మోడల్ తాను ఏ టూల్స్‌ను ఉపయోగిస్తుందో తనిఖీ చేసి, మీ బిల్లును తగ్గించదు. సర్వర్ కనెక్ట్ అయి ఉంటే, ప్రతి సైకిల్‌లో దాని పూర్తి మేనిఫెస్టే (manifest) కాంటెక్స్ట్‌లోకి మళ్ళీ మళ్ళీ వస్తుంది. ఇది చర్య (action) మీద కాదు, సామర్థ్యం (potential) మీద పడే ప్రతి-టర్న్ పన్ను.

ఇటరేటివ్ కోడింగ్ ఏజెంట్లు, టెస్ట్ హార్నెస్సులు లేదా బ్యాచ్ రివ్యూ జాబ్స్ నడిపే డెవలపర్లకు, ఇది నిశ్శబ్దంగా బడ్జెట్‌ను దెబ్బతీసే అంశం. 20 టర్న్‌ల మానవ సంభాషణ తేలికైనది. కానీ 200 లేదా 2,000 టర్న్‌ల ఏజెంటిక్ లూప్‌లో ఈ లెక్కలు చాలా భారంగా మారుతాయి.

ఖర్చులను ఎలా నియంత్రించాలి

MCP నిజంగా ఉపయోగకరమైనది. మీరు దానిని ఉపయోగించాలి. కానీ దానిని ప్రతి సెషన్‌కు శాశ్వతంగా అమర్చుకునే వస్తువులా కాకుండా, అవసరమైన పని కోసం మాత్రమే ఆన్ చేసే ఒక యుటిలిటీ (utility) లాగా చూడండి.

కాన్ఫిగరేషన్లను ప్రాజెక్ట్ మరియు టాస్క్‌కు పరిమితం చేయండి

డిఫాల్ట్‌గా ప్రతి సర్వర్‌ను మీ గ్లోబల్ Claude Code కాన్ఫిగరేషన్‌లో లోడ్ చేయకండి. మీరు చేస్తున్న పనికి తగినట్లుగా ప్రాజెక్ట్-స్కోప్డ్ (project-scoped) MCP కాన్ఫిగరేషన్‌లను రూపొందించుకోండి. మీరు ఒక లోకల్ మాడ్యూల్‌ను రీఫ్యాక్టర్ (refactoring) చేస్తుంటే, మీకు filesystem సర్వర్ మాత్రమే అవసరం కావచ్చు. మీరు ఇష్యూలను పరిష్కరిస్తుంటే (triaging issues), ఆ నిర్దిష్ట పని కోసం GitHub సర్వర్‌ను లోడ్ చేయండి మరియు తిరిగి లోకల్ డెవలప్‌మెంట్‌కు మారినప్పుడు దానిని డిస్‌కనెక్ట్ చేయండి.

ఇది మీ ఫోన్‌లో యాప్‌లను ఓపెన్ చేసి ఉంచడం లాంటిది. ఒకటి లేదా రెండు ఉంటే పర్వాలేదు. ఇరవై యాప్‌లు బ్యాక్‌గ్రౌండ్‌లో నడుస్తుంటే కారణం లేకుండానే బ్యాటరీ ఖర్చవుతుంది.

తక్కువ టూల్స్ ఉన్న సర్వర్లను ఎంచుకోండి

అన్ని MCP సర్వర్లు ఒకే విధమైన క్రమశిక్షణతో రూపొందించబడలేదు. కొన్ని రెండు లేదా మూడు కేంద్రీకృత చర్యలతో కూడిన సరళమైన ఇంటర్‌ఫేస్‌ను అందిస్తాయి. మరికొన్ని 25 లేదా 30 టూల్స్ ఉన్న భారీ జాబితాను అందిస్తాయి, వాటిలో చాలా వరకు మీరు ఎప్పటికీ ఉపయోగించకపోవచ్చు. మూడు టూల్స్ ఉన్న సర్వర్ ప్రతి టర్న్‌కు మీకు 180 టోకెన్ల ఖర్చు చేయవచ్చు. 26 టూల్స్ ఉన్న సర్వర్ 3,100 టోకెన్ల వరకు ఖర్చు చేయవచ్చు. మీకు పెద్దగా అవసరం లేని సామర్థ్యం కోసం, ఇది 17 రెట్లు ఎక్కువ ఓవర్‌హెడ్ పెంచుతుంది.

ఒక సర్వర్‌ను ఇన్‌స్టాల్ చేసే ముందు, దాని టూల్ మేనిఫెస్ట్‌ను చూడండి. ఒకవేళ అది డజన్ల కొద్దీ ఒకదానికొకటి సంబంధం ఉన్న ఆపరేషన్లను కలిగి ఉండి, మీకు కేవలం ఒకటి మాత్రమే అవసరమైతే, దానిని తగ్గించవచ్చా (configure down), ఫోర్క్ (fork) చేయవచ్చా లేదా మరింత సరళమైన రాపర్‌ను (slimmer wrapper) వ్రాయవచ్చా అని ఆలోచించండి. మీరు తొలగించగలిగే ప్రతి టూల్ డెఫినిషన్, భవిష్యత్తులో ప్రతి టర్న్‌లో నేరుగా మరియు శాశ్వతంగా టోకెన్లను ఆదా చేస్తుంది.

టూల్ వివరణలను తగ్గించండి

ప్రతి టూల్‌కు 80 నుండి 150 టోకెన్ల పరిధి అనేది ప్రకృతి నియమం కాదు. ఇది వివరణలు మరియు స్కీమాలు (schemas) ఎంత వివరంగా ఉన్నాయనే దానిపై ఆధారపడి ఉంటుంది. 400 టోకెన్ల భారీ వివరణ, 80 టోకెన్ల వివరణ కంటే ఐదు రెట్లు ఎక్కువ కాంటెక్స్ట్‌ను తీసుకుంటుంది, మరియు ఆ ఐదు రెట్ల నష్టం ప్రతి టర్న్‌లోనూ వర్తిస్తుంది.

మీరు నమ్ముతున్న సర్వర్లను ఆడిట్ చేయండి. ఒకవేళ టూల్ వివరణ మార్కెటింగ్ కాపీలా అనిపిస్తే, దానిని తిరిగి వ్రాయండి. విశేషణాలను (adjectives) తగ్గించండి. స్కీమాను స్పష్టం చేయని ఉదాహరణలను తొలగించండి. JSONను మరింత క్లుప్తంగా ఉంచండి. టూల్ ఏం చేస్తుందో మోడల్‌కు అర్థం కావాలి, కానీ దానికి పెద్ద పీఠిక (preamble) అవసరం లేదు. టూల్ డెఫినిషన్లను కోడ్‌లా పరిగణించండి: అవి ఎంత చిన్నగా, స్పష్టంగా ఉంటే అంత మంచిది.

అసలైన సారాంశం

MCP అనేది Claude Code యొక్క పరిధిని పెంచుతుంది. కానీ ఇది మీ కాంటెక్స్ట్ విండోను ఉచితంగా పెంచదు. ఈ ఓవర్‌హెడ్ అనేది నిర్ణీతమైనది, పునరావృతమయ్యేది మరియు టూల్స్ వాడబడుతున్నాయా లేదా అనే దానితో సంబంధం లేకుండా ఉంటుంది.

మీ ప్రస్తుత పనికి అవసరమైన సర్వర్లను మాత్రమే లోడ్ చేయండి. పని పూర్తయిన తర్వాత వాటిని డిస్‌కనెక్ట్ చేయండి. ఇతర డిపెండెన్సీలను (dependencies) ఎలా ఆడిట్ చేస్తారో, అలాగే టూల్ సంఖ్యలను మరియు వివరణల పొడవును కూడా ఆడిట్ చేయండి. నియమం సరళమైనది: ఒకవేళ ఆ టూల్ ఈ నిర్దిష్ట సెషన్‌లో విలువను జోడించకపోతే, అది మీ బిల్లుకు టోకెన్లను జోడించకూడదు.

మూల కొలతలు మరియు పద్ధతి: I added MCP servers to Claude Code — here’s what they cost in tokens

మరిన్ని ఇంజనీరింగ్ విశ్లేషణల కోసం GyaanSetu AI లెర్నింగ్ కమ్యూనిటీలో చేరండి: t.me/GyaanSetuAi