Claude Code-ന് വേണ്ടിയുള്ള പുതിയൊരു പ്രധാന അടിസ്ഥാന സംവിധാനമാണ് (plumbing) MCP servers. ഒരു GitHub server ചേർച്ചാൽ നിങ്ങളുടെ ഏജന്റിന് pull requests തുറക്കാൻ സാധിക്കും. ഒരു filesystem server ചേർച്ചാൽ അത് നിങ്ങളുടെ റെപ്പോസിറ്ററി ഘടന (repo structure) വായിച്ചെടുക്കും. ഇവയുടെ ഡെമോകൾ കാണാൻ അത്ഭുതകരമാണ്. എന്നാൽ ആരും കാണിക്കാത്തത് അതിന്റെ ബില്ലാണ്.

ചിലവ് എന്നത് ടൂളുകൾ നടത്തുന്ന API കോളുകളിലല്ല, മറിച്ച് ആ ടൂളുകളിൽ തന്നെയാണ്.

ഓരോ തവണ നിങ്ങൾ ഒരു MCP server രജിസ്റ്റർ ചെയ്യുമ്പോഴും, നിങ്ങൾ ഒരു പുതിയ കഴിവ് മാത്രമല്ല ചേർക്കുന്നത്; പകരം നിങ്ങളുടെ context window-ലേക്ക് ഒരു കൂട്ടം ടെക്സ്റ്റുകൾ കൂടി ചേർക്കുകയാണ് ചെയ്യുന്നത്. ഓരോ ടേണിലും (turn) ഈ ടെക്സ്റ്റ് ഉപയോഗിച്ചതിന് നിങ്ങൾക്ക് ബില്ല് വരും. ഏജന്റ് ആ ടൂൾ ഉപയോഗിച്ചാലും ഇല്ലെങ്കിലും, അതിന്റെ സാന്നിധ്യത്തിന് നിങ്ങൾ പണം നൽകണം. സെർവർ കണക്ട് ചെയ്യുന്ന നിമിഷം മുതൽ ബില്ല് കണക്കാക്കപ്പെടാൻ തുടങ്ങുന്നു.

നിങ്ങൾ ഉപയോഗിക്കാത്ത ടൂളുകൾക്കായി വാടക നൽകുന്നു

ഇവിടെ പലരും ശ്രദ്ധിക്കാതെ പോകുന്ന ഒരു കാര്യമുണ്ട്. ഓരോ MCP server-ലെയും ഓരോ ടൂൾ ഡെഫനിഷനും ഒരു പേര്, വിവരണം (description), ടൂളിന് ആവശ്യമായ ആർഗ്യുമെന്റുകൾ എന്താണെന്ന് വ്യക്തമാക്കുന്ന ഒരു JSON schema എന്നിവ ഉൾക്കൊള്ളുന്നു. ഈ മുഴുവൻ വിവരങ്ങളും ഓരോ ടേണിന്റെയും തുടക്കത്തിൽ സിസ്റ്റം കോൺടെക്സ്റ്റിലേക്ക് (system context) ചേർക്കപ്പെടുന്നു. ഒരു ടൂൾ വിളിക്കണോ വേണ്ടയോ എന്ന് തീരുമാനിക്കാൻ മോഡലിന് ഈ മുഴുവൻ വിവരങ്ങളും കാണേണ്ടതുണ്ട്, എന്നാൽ ആ വിവരങ്ങൾ ലഭ്യമാക്കുന്നതിന് നിങ്ങൾ പണം നൽകണം.

ഓരോ ടൂളിന്റെയും അധിക ചിലവ് (overhead) കുറഞ്ഞതല്ല. പ്രായോഗികമായി, ഒരു ടൂൾ ഡെഫനിഷൻ 80 മുതൽ 150 ടോക്കണുകൾ വരെ ഉപയോഗിക്കുന്നു. അതായത്, പത്ത് ടൂളുകൾ മാത്രമുള്ള ഒരു ചെറിയ സെർവർ, നിങ്ങൾ ഒരു വാചകം പോലും ടൈപ്പ് ചെയ്യുന്നതിന് മുമ്പ് തന്നെ 800 മുതൽ 1,500 വരെ ടോക്കണുകൾ ഉപയോഗിച്ചു കഴിഞ്ഞു. നിങ്ങൾ കമ്പ്യൂട്ടിന് വേണ്ടിയല്ല പണം നൽകുന്നത്, മറിച്ച് ആ ഓപ്ഷൻ ലഭ്യമാകുന്നതിനുള്ള ആനുകൂല്യത്തിന് വേണ്ടിയാണ്.

ഇത് എത്രത്തോളം വർദ്ധിക്കുന്നു എന്ന് മനസ്സിലാക്കാൻ ഞാൻ ഒരു സാധാരണ 20-ടേൺ സെഷനിൽ കണക്കുകൾ പരിശോധിച്ചു.

ഒരു MCP server-ഉം ലോഡ് ചെയ്തിട്ടില്ലെങ്കിൽ, അധിക ചിലവ് പൂജ്യമാണ്. നിങ്ങളുടെ സംഭാഷണം മാത്രമായിരിക്കും context window-യിൽ ഉണ്ടാവുക.

മൂന്ന് ടൂളുകൾ മാത്രമുള്ള ഒരു മിനിമൽ സെർവർ ലോഡ് ചെയ്താൽ, ഓരോ ടേണിലും 180 ടോക്കണുകൾ അധികമായി വരും. 20 ടേണുകളിലായി ഇത് 3,600 ടോക്കണുകളായി മാറും. ഇത് വലിയൊരു നഷ്ടമല്ലെങ്കിലും, യഥാർത്ഥത്തിൽ പണം നഷ്ടപ്പെടുന്ന കാര്യമാണ്.

ഏഴ് ടൂളുകൾ ഉള്ള പ്രശസ്തമായ filesystem server ഉപയോഗിക്കുമ്പോൾ, ഇത് ഓരോ ടേണിലും 640 ടോക്കണുകളായി ഉയരുന്നു. ഇതേ സെഷനിൽ, കണക്ഷൻ നിലനിർത്താൻ വേണ്ടി മാത്രം നിങ്ങൾ 12,800 ടോക്കണുകൾ ഉപയോഗിച്ചു കഴിഞ്ഞു. നിങ്ങൾ ഒരു ഫയൽ പോലും വായിച്ചിട്ടില്ല, ഒരു ഡയറക്ടറിയുടെ ലിസ്റ്റ് പോലും എടുത്തിട്ടില്ല. നിങ്ങൾ വെറുതെ ആ സെർവർ മെനുവിൽ നിലനിർത്തുക മാത്രമാണ് ചെയ്തത്.

പിന്നീട് GitHub server-ന്റെ കാര്യമുണ്ട്. 26 ടൂളുകൾ രജിസ്റ്റർ ചെയ്തിട്ടുള്ള ഇതിൽ, ഓരോ ടേണിലും 3,100 ടോക്കണുകൾ വീതം വരുന്നു. 20 സന്ദേശങ്ങൾ കൈമാറിയ ശേഷം, ആകെ അധിക ചിലവ് 62,000 ടോക്കണുകളായി ഉയരുന്നു. Sonnet 4-ന്റെ നിരക്ക് അനുസരിച്ച്, ഇത് വെറും കോൺടെക്സ്റ്റ് ടാക്സ് (context tax) ആയി $0.19 ആണ്. ഏജന്റ് ഒരു ഇഷ്യൂ (issue) പോലും നിർമ്മിക്കാൻ ശ്രമിക്കുന്നതിന് മുമ്പ് തന്നെ, അധിക ചിലവിനായി നിങ്ങൾ 19 സെന്റ് നൽകി കഴിഞ്ഞു.

ഈ തുക ഒറ്റനോട്ടത്തിൽ ചെറുതായി തോന്നാം. എന്നാൽ അങ്ങനെയല്ല.

ഓവർനൈറ്റ് ഏജന്റ് പ്രശ്നം (The Overnight Agent Problem)

ദീർഘനേരം പ്രവർത്തിക്കുന്ന ഓട്ടോണമസ് ലൂപ്പുകളിലാണ് (autonomous loops) ഇത് വലിയ തിരിച്ചടിയാകുന്നത്. Claude Code ഒരു ഏജന്റായി സ്വയം പ്രവർത്തിക്കുന്ന രീതിയിലാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, ഓരോ ടേണിലും വരുന്ന ഈ അധിക ചിലവ് ഭീകരമായി വർദ്ധിക്കും. GitHub server ലോഡ് ചെയ്തുകൊണ്ട് 2,000 ടേണുകളിലായി രാത്രി മുഴുവൻ പ്രവർത്തിക്കുന്ന ഒരു ഏജന്റ് 62,000 ടോക്കണുകളല്ല, മറിച്ച് 6.2 മില്യൺ ടോക്കണുകളാണ് അധിക ചിലവായി നൽകുന്നത്.

ഇത് യാതൊരു പ്രയോജനവുമില്ലാതെ ചെലവാക്കുന്ന $18.60 ആണ്. ഒരു GitHub ടൂളും ഉപയോഗിക്കാതെ ആ ഏജന്റ് രാത്രി മുഴുവൻ വിശ്രമിച്ചിട്ടുണ്ടാകാം, അല്ലെങ്കിൽ ലോക്കൽ ഫയലുകളിൽ മാത്രം ജോലി ചെയ്തിട്ടുണ്ടാകാം. എന്നിരുന്നാലും, ആ 2,000 ടേണുകളിലും നിങ്ങൾ 26 GitHub ടൂൾ ഡെഫനിഷനുകൾക്കായി പണം നൽകേണ്ടി വരും, കാരണം അവ സെഷനിൽ രജിസ്റ്റർ ചെയ്തിരിക്കുകയാണ്.

നിങ്ങൾ ശ്രദ്ധിക്കേണ്ട പ്രധാന കാര്യം, നിങ്ങൾ ഉപയോഗിക്കുന്ന ടൂളുകൾക്കല്ല, മറിച്ച് രജിസ്റ്റർ ചെയ്തിട്ടുള്ള ടൂളുകൾക്കാണ് പണം നൽകേണ്ടത് എന്നതാണ്. ഏജന്റ് ഏതൊക്കെ ടൂളുകളാണ് യഥാർത്ഥത്തിൽ ഉപയോഗിച്ചതെന്ന് നോക്കി ബില്ലിൽ ഇളവ് നൽകില്ല. സെർവർ കണക്ട് ചെയ്തിട്ടുണ്ടെങ്കിൽ, അതിന്റെ മുഴുവൻ വിവരങ്ങളും ഓരോ സൈക്കിളിലും കോൺടെക്സ്റ്റിലേക്ക് വീണ്ടും വരും. ഇത് പ്രവർത്തനത്തിനുള്ള (action) ടാക്സ് അല്ല, മറിച്ച് സാധ്യതകൾക്കുള്ള (potential) ടാക്സ് ആണ്.

ഇറ്ററേറ്റീവ് കോഡിംഗ് ഏജന്റുകൾ, ടെസ്റ്റ് ഹാർനെസുകൾ (test harnesses), അല്ലെങ്കിൽ ബാച്ച് റിവ്യൂ ജോലികൾ എന്നിവ ചെയ്യുന്ന ഡെവലപ്പർമാരെ സംബന്ധിച്ചിട

എല്ലാ MCP സെർവറുകളും ഒരേ രീതിയിലല്ല രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ചിലത് രണ്ട് അല്ലെങ്കിൽ മൂന്ന് പ്രധാനപ്പെട്ട ആക്ഷനുകൾ മാത്രമുള്ള ലളിതമായ ഇന്റർഫേസ് ആണ് നൽകുന്നത്. മറ്റു ചിലത് 25 അല്ലെങ്കിൽ 30 ടൂളുകൾ അടങ്ങിയ വലിയൊരു പട്ടികയുമായാണ് വരുന്നത്, ഇതിൽ പലതും നിങ്ങൾ ഒരിക്കലും ഉപയോഗിക്കാനിടയില്ല. മൂന്ന് ടൂളുകളുള്ള ഒരു സെർവർ ഒരു ടേണിന് (turn) 180 ടോക്കണുകൾ ചിലവാക്കിയേക്കാം. എന്നാൽ 26 ടൂളുകളുള്ള ഒന്നിന് 3,100 ടോക്കണുകൾ വരെ ചിലവാകാം. നിങ്ങൾക്ക് ആവശ്യമില്ലാത്ത ഒരു അധിക സൗകര്യത്തിന് വേണ്ടി 17 മടങ്ങ് അധിക ചിലവ് (overhead) വരുന്നു എന്നാണ് ഇതിനർത്ഥം.

ഒരു സെർവർ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന് മുമ്പ് അതിന്റെ ടൂൾ മാനഫെസ്റ്റ് (tool manifest) പരിശോധിക്കുക. ഒരേപോലെയുള്ള ഒരുപാട് ഓപ്പറേഷനുകൾ അതിലുണ്ടാവുകയും നിങ്ങൾക്ക് അതിൽ ഒന്ന് മാത്രം ആവശ്യമുള്ളതാവുകയും ചെയ്താൽ, അത് കുറച്ചുകൂടി ലളിതമായി കോൺഫിഗർ ചെയ്യാനോ, ഫോർക്ക് (fork) ചെയ്യാനോ, അല്ലെങ്കിൽ ഒരു സ്ലിമ്മർ റാപ്പർ (slimmer wrapper) എഴുതാനോ കഴിയുമോ എന്ന് ചിന്തിക്കുക. ഒഴിവാക്കാൻ കഴിയുന്ന ഓരോ ടൂൾ ഡെഫനിഷനും ഭാവിയിലെ ഓരോ ടേണിലും നേരിട്ടുള്ളതും സ്ഥിരവുമായ ടോക്കൺ ലാഭമാണ്.

ടൂൾ വിവരണങ്ങൾ ചുരുക്കുക

ഒരു ടൂളിന് 80 മുതൽ 150 ടോക്കണുകൾ എന്ന പരിധി പ്രകൃതി നിയമമല്ല. വിവരണങ്ങളും സ്കീമകളും (schemas) എത്രത്തോളം വിശദമായതിനെ ആശ്രയിച്ചാണ് ഇത് മാറുന്നത്. 400 ടോക്കണുകളുള്ള ഒരു വലിയ വിവരണം, 80 ടോക്കണുകളുള്ള വിവരണത്തേക്കാൾ അഞ്ചിരട്ടി കൂടുതൽ കോൺടെക്സ്റ്റ് ഉപയോഗിക്കുന്നു, കൂടാതെ ഈ അഞ്ചിരട്ടി അധികഭാരം ഓരോ ടേണിലും ബാധകമാകും.

നിങ്ങൾ ഉപയോഗിക്കുന്ന സെർവറുകൾ ഓഡിറ്റ് ചെയ്യുക. ഒരു ടൂളിന്റെ വിവരണം ഒരു മാർക്കറ്റിംഗ് പരസ്യം പോലെയാണെങ്കിൽ, അത് വീണ്ടും എഴുതുക. വിശേഷണങ്ങൾ (adjectives) ഒഴിവാക്കുക. സ്കീമയെ വ്യക്തമാക്കാത്ത ഉദാഹരണങ്ങൾ ഒഴിവാക്കുക. JSON കൂടുതൽ കൃത്യമാക്കുക. ടൂൾ എന്ത് ചെയ്യുന്നു എന്ന് മോഡലിന് മനസ്സിലാകണം, എന്നാൽ അതിന് ഒരു വലിയ ആമുഖം (preamble) ആവശ്യമില്ല. ടൂൾ ഡെഫനിഷനുകളെ കോഡ് പോലെ കാണുക: അവ എത്രത്തോളം ചെറുതും വ്യക്തവുമാണോ അത്രത്തോളം നല്ലത്.

പ്രധാന പാഠം

Claude Code-ന്റെ പരിധി വർദ്ധിപ്പിക്കാനാണ് MCP സഹായിക്കുന്നത്. എന്നാൽ ഇത് നിങ്ങളുടെ കോൺടെക്സ്റ്റ് വിൻഡോയെ സൗജന്യമായി വർദ്ധിപ്പിക്കില്ല. ഇതിന്റെ അധിക ചിലവ് (overhead) മുൻകൂട്ടി നിശ്ചയിക്കപ്പെട്ടതും ആവർത്തിക്കുന്നതുമാണ്, കൂടാതെ ടൂളുകൾ ഉപയോഗിക്കുന്നുണ്ടോ ഇല്ലയോ എന്നതിനെ ആശ്രയിച്ചല്ല ഇത് മാറുന്നത്.

നിങ്ങളുടെ നിലവിലെ ജോലിക്ക് ആവശ്യമുള്ള സെർവറുകൾ മാത്രം ലോഡ് ചെയ്യുക. ജോലി കഴിഞ്ഞാൽ അവ ഡിസ്കണക്ട് ചെയ്യുക. മറ്റ് ഡിപെൻഡൻസികൾ (dependencies) പരിശോധിക്കുന്നത് പോലെ തന്നെ ടൂളുകളുടെ എണ്ണവും വിവരണങ്ങളുടെ ദൈർഘ്യവും പരിശോധിക്കുക. നിയമം ലളിതമാണ്: ഈ സെഷനിൽ ഒരു ടൂൾ മൂല്യം വർദ്ധിപ്പിക്കുന്നില്ലെങ്കിൽ, അത് നിങ്ങളുടെ ബില്ലിൽ ടോക്കണുകൾ അധികമായി കൂട്ടാൻ പാടില്ല.

സ്രോതസ്സ് അളവുകളും രീതിശാസ്ത്രവും: I added MCP servers to Claude Code — here’s what they cost in tokens

കൂടുതൽ എഞ്ചിനീയറിംഗ് വിശകലനങ്ങൾക്കായി GyaanSetu AI ലേണിംഗ് കമ്മ്യൂണിറ്റിയിൽ ചേരുക: t.me/GyaanSetuAi