12 ప్రశ్నల పరీక్షలో, ఏడు స్కీమాలు కలిగిన Model Context Protocol (MCP) కంటే Bash wrappers ఎక్కువ టోకెన్లను ఉపయోగించాయి. దీనివల్ల షెల్ (shell) అనేది చాలా మంది ఇంజనీర్లు అనుకున్నంత చౌకైన షార్ట్‌కట్ కాదని తేలింది. టోకెన్ వినియోగం అనేది భారీ స్థాయిలో నడిచే large-language-model (LLM) ఏజెంట్ల ఖర్చుకు నేరుగా సంబంధం కలిగి ఉంటుంది.

ఫలితాలను మార్చిన ప్రయోగం

ఒక డెవలపర్ LLM ఏజెంట్ నౌకల డేటాను (vessel data) సేకరించడానికి ఉన్న నాలుగు మార్గాలను కొలవగా:

  • MCP – Model Context Protocol వెనుక హోస్ట్ చేయబడిన ఏడు టూల్ స్కీమాలు.
  • Bash + curl (cold) – ఎటువంటి అదనపు ప్రాంప్టింగ్ లేకుండా చేసే ఒక రా (raw) షెల్ కాల్.
  • Bash + curl (warm) – అదే షెల్ కాల్, కానీ సురక్షితమైన వినియోగానికి మార్గనిర్దేశం చేసే సిస్టమ్ ప్రాంప్ట్‌లతో కలిపి.
  • Dedicated CLI tool – ఒక ప్రత్యేకంగా రూపొందించబడిన కమాండ్-లైన్ ఇంటర్‌ఫేస్.

ఈ నాలుగు పద్ధతులను 12 ప్రశ్నల సంభాషణ ద్వారా పరీక్షించారు. API బిల్లులను ప్రభావితం చేసే టోకెన్ వినియోగం ఈ క్రింది విధంగా ఉంది:

  • MCP: 109,779 టోకెన్లు
  • Bash + curl (cold): 158,021 టోకెన్లు
  • Bash + curl (warm): 178,577 టోకెన్లు

Dedicated CLI టూల్ యొక్క గణాంకాలు వెల్లడించబడలేదు, కానీ రెండు Bash వెర్షన్లు ఇప్పటికే MCP కంటే ఎక్కువ ఖర్చు చేశాయి.

ప్రోటోకాల్ కంటే షెల్ ఎందుకు ఎక్కువ ఖర్చు అయ్యింది?

ప్రతి Bash టూల్‌కు సుమారుగా 2,700 టోకెన్ల “harness prompts” అవసరమయ్యాయి – అంటే ఏజెంట్ షెల్‌ను సురక్షితంగా ఎలా పిలవాలి (invoke), అవుట్‌పుట్‌ను ఎలా విశ్లేషించాలి (parse) మరియు లోపాలను (errors) ఎలా నిర్వహించాలి అని చెప్పే సూచనలు. ఈ ప్రాంప్ట్‌లు మాత్రమే మొత్తం ఏడు MCP స్కీమాల మొత్తం టోకెన్ బరువు కంటే ఎక్కువగా ఉన్నాయి.

ఖర్చు అనేది కేవలం ప్రారంభ కాల్‌కే పరిమితం కాదు. ప్రొడక్షన్‌లో, అదే ఏజెంట్ స్టార్టప్‌లోనే 11 MCP సర్వర్‌లను ప్రీ-లోడ్ చేసింది, దీనివల్ల మొదటి యూజర్ క్వెరీ రాకముందే 19,800 టోకెన్లు ఖర్చయ్యాయి. ఆ తర్వాత, ప్రతి దశలోనూ (turn), ఏజెంట్ ప్రతి సర్వర్ నుండి ప్రతి స్కీమాను మళ్ళీ చదువుతుంది, కాబట్టి “సమయం ఎంత?” వంటి చిన్న అభ్యర్థన కోసం కూడా మిగిలిన అన్ని టూల్స్ యొక్క వివరణల టోకెన్ ధర చెల్లించాల్సి వస్తుంది.

ఈగర్ లోడింగ్ (eager loading) వల్ల కలిగే రహస్య నష్టం

ఒక LLM ఏజెంట్ ప్రతి దశలోనూ ప్రతి టూల్ సర్వర్‌ను ఈగర్ లోడ్ (eagerly load) చేసినప్పుడు, టోకెన్ బిల్లు విపరీతంగా పెరుగుతుంది. Bash ఉపయోగించడం వల్ల కలిగే “నిజమైన” ఖర్చు షెల్ కమాండ్ కాదు, ప్రతిసారీ మోడల్‌కు పంపాల్సిన చుట్టూ ఉన్న సందర్భం (context) అని ఈ ప్రయోగం చూపింది.

  • Fixed-cost tools (MCP స్కీమాలు) ప్రతి దశలోనూ ఊహించదగిన టోకెన్ ఓవర్‌హెడ్‌ను జోడిస్తాయి.
  • Dynamic payloads (curl రెస్పాన్స్‌లు) సంభాషణ పొడవు మరియు డేటా పరిమాణంతో పాటు పెరిగే అప్పును (debt) పెంచుతాయి.

కాబట్టి, పైకి “ఉచితం” అని కనిపించే షెల్, వాస్తవానికి పెద్ద మొత్తంలో మారుతూ ఉండే టోకెన్ పన్నును (token tax) విధిస్తుంది.

AI ఇంజనీర్లు తదుపరి ఏమి చేయాలి

  • Lazy loadingను అనుసరించండి. ఒక టూల్ స్కీమా నిజంగా అవసరమైనప్పుడు మాత్రమే దాని సర్వర్‌ను లోడ్ చేయండి, మరియు ప్రతిసారీ మళ్ళీ చదవడానికి బదులుగా దానిని మెమరీలో ఉంచుకోండి.
  • టూల్ స్కీమాలను ప్రతి దశకు ఒక స్థిరమైన ఖర్చుగా పరిగణించండి. షెల్ కమాండ్లు ఉచితమని అనుకోవడానికి బదులుగా, MCP నిర్వచనాల 알려బడిన పరిమాణం ఆధారంగా టోకెన్ బడ్జెట్‌లను ప్లాన్ చేయండి.
  • “shell = cheap” అనే ఊహలను పునఃసమీక్షించండి. ఒక డిజైన్‌ను ఖరారు చేసే ముందు ప్రతి టూల్ పాత్ కోసం టోకెన్ వినియోగాన్ని విశ్లేషించండి (profile).
  • చిన్న మోడళ్ల కోసం షేప్డ్ టూల్స్ (shaped tools)ను ఉపయోగించండి. పరిమిత కాంటెక్స్ట్ విండోలు ఉన్నప్పటికీ, స్పష్టంగా నిర్వచించబడిన స్కీమాలు రీజనింగ్, యూనిట్ కన్వర్షన్ మరియు ఎర్రర్ హ్యాండ్లింగ్‌ను మెరుగుపరుస్తాయి.

ముగింపు ఏమిటంటే: ప్రోటోకాల్ డిజైన్ కాదు, టోకెన్ ఎకనామిక్స్ ఖర్చును నిర్ణయిస్తాయి. టూల్ సర్వర్‌లను ఎప్పుడు మరియు ఎలా లోడ్ చేయాలనే అంశాన్ని నిర్వహించడం ద్వారా సంభాషణ నుండి వేల సంఖ్యలో టోకెన్లను తగ్గించవచ్చు, ఇది నేరుగా నిర్వహణ ఖర్చులను (operational spend) తగ్గిస్తుంది.

మూలం: https://dev.to/clarkbw--/enabling-bash-costs-more-context-than-seven-mcp-tool-schemas-2h82