૧૨ પ્રશ્નોના એક રન દરમિયાન, Bash wrappers એ સાત-સ્કીમા ધરાવતા Model Context Protocol (MCP) કરતા વધુ ટોકન્સનો ઉપયોગ કર્યો, જે દર્શાવે છે કે શેલ (shell) એ સસ્તો શોર્ટકટ નથી જેવું ઘણા એન્જિનિયરો વિચારે છે. ટોકનનો વપરાશ સીધો જ મોટા લેંગ્વેજ મોડલ (LLM) એજન્ટ્સ માટેના ખર્ચમાં પરિણમે છે જે મોટા પાયે ચાલે છે.

એ પ્રયોગ જેણે પરિસ્થિતિ બદલી નાખી

એક ડેવલપરે LLM એજન્ટ દ્વારા વેસલ (vessel) ડેટા મેળવવા માટેના ચાર રસ્તાઓ માપ્યા:

  • MCP – Model Context Protocol દ્વારા હોસ્ટ કરવામાં આવેલા સાત ટૂલ સ્કીમા (tool schemas).
  • Bash + curl (cold) – કોઈ વધારાના પ્રોમ્પ્ટિંગ વગરનું એક રો (raw) શેલ કોલ.
  • Bash + curl (warm) – એ જ શેલ કોલ વત્તા સુરક્ષિત ઉપયોગ માટે માર્ગદર્શન આપતા સિસ્ટમ પ્રોમ્પ્ટ્સ.
  • Dedicated CLI tool – ખાસ હેતુ માટે બનાવેલ કમાન્ડ-લાઇન ઇન્ટરફેસ.

આ ચારેય પદ્ધતિઓ ૧૨ પ્રશ્નોની વાતચીત દ્વારા ચલાવવામાં આવી હતી. ટોકન વપરાશ, જે API બિલ નક્કી કરે છે, તે નીચે મુજબ હતો:

  • MCP: ૧૦૯,૭૭૯ ટોકન્સ
  • Bash + curl (cold): ૧૫૮,૦૨૧ ટોકન્સ
  • Bash + curl (warm): ૧૭૮,૫૭૭ ટોકન્સ

ડેડિકેટેડ CLI ટૂલના આંકડા જાહેર કરવામાં આવ્યા ન હતા, પરંતુ બે Bash વેરિઅન્ટ્સ પહેલેથી જ MCP કરતા વધુ ખર્ચાળ સાબિત થયા હતા.

શા માટે શેલ પ્રોટોકોલ કરતા વધુ ખર્ચાળ હતો

દરેક Bash ટૂલ માટે અંદાજે ૨,૭૦૦ ટોકન્સના “harness prompts” ની જરૂર હતી – એવા નિર્દેશો જે એજન્ટને જણાવે છે કે શેલને સુરક્ષિત રીતે કેવી રીતે ઇનવોક (invoke) કરવું, આઉટપુટનું વિશ્લેષણ (parse) કરવું અને ભૂલોને કેવી રીતે હેન્ડલ કરવી. માત્ર આ પ્રોમ્પ્ટ્સ જ સાતેય MCP સ્કીમાના કુલ ટોકન વજન કરતા પણ વધુ છે.

ખર્ચ માત્ર શરૂઆતના કોલ પૂરતો મર્યાદિત નથી. પ્રોડક્શનમાં, એ જ એજન્ટે સ્ટાર્ટઅપ વખતે ૧૧ MCP સર્વર્સ પ્રી-લોડ કર્યા હતા, જેના કારણે પ્રથમ યુઝર ક્વેરી આવતા પહેલા જ ૧૯,૮૦૦ ટોકન્સ વપરાઈ ગયા હતા. ત્યારબાદ, દરેક ટર્ન પર, એજન્ટ દરેક સર્વર પરથી દરેક સ્કીમા ફરીથી વાંચતો હતો, તેથી "અત્યારે કેટલા વાગ્યા છે?" જેવી સામાન્ય વિનંતી માટે પણ અન્ય તમામ ટૂલના વર્ણનનો ટોકન ખર્ચ ચૂકવવો પડતો હતો.

ઈગર લોડિંગ (eager loading) નો છુપો નુકસાન

જ્યારે LLM એજન્ટ દરેક ટર્ન પર દરેક ટૂલ સર્વરને ઈગર લોડ (eagerly load) કરે છે, ત્યારે ટોકનનું બિલ આકસ્મિક રીતે વધી જાય છે. પ્રયોગે દર્શાવ્યું કે Bash નો ઉપયોગ કરવાનો "સાચો" ખર્ચ શેલ કમાન્ડ નથી, પરંતુ તેની આસપાસનો સંદર્ભ (context) છે જે દર વખતે મોડેલને મોકલવો પડે છે.

  • ફિક્સ્ડ-કોસ્ટ ટૂલ્સ (MCP સ્કીમા) દરેક ટર્ન દીઠ અનુમાનિત ટોકન ઓવરહેડ ઉમેરે છે.
  • ડાયનેમિક પેલોડ્સ (curl પ્રતિસાદો) વધતું દેવું ઉમેરે છે જે વાતચીતની લંબાઈ અને ડેટાના કદ સાથે વધતું જાય છે.

આમ, સપાટી પર "મફત" દેખાતું શેલ વાસ્તવમાં મોટો અને બદલાતો ટોકન ટેક્સ લાદે છે.

AI એન્જિનિયરોએ હવે શું કરવું જોઈએ

  • લેઝી લોડિંગ (lazy loading) અપનાવો. ટૂલ સર્વર ત્યારે જ લોડ કરો જ્યારે તેની સ્કીમા ખરેખર જરૂરી હોય, અને તેને દર વખતે ફરીથી વાંચવાને બદલે ટર્ન્સ દરમિયાન મેમરીમાં રાખો.
  • ટૂલ સ્કીમાને દરેક ટર્ન દીઠ ફિક્સ્ડ ખર્ચ તરીકે ગણો. શેલ કમાન્ડ્સ મફત છે તેમ માની લેવાને બદલે MCP વ્યાખ્યાઓના જાણીતા કદના આધારે ટોકન બજેટનું આયોજન કરો.
  • "શેલ = સસ્તું" એવા ધારણાઓની પુનઃમૂલ્યાંકન કરો. કોઈપણ ડિઝાઇનમાં કટિબદ્ધ થતા પહેલા દરેક ટૂલ પાથ માટે ટોકન વપરાશનું પ્રોફાઇલિંગ કરો.
  • નાના મોડેલ્સ માટે શેપ્ડ (shaped) ટૂલ્સનો ઉપયોગ કરો. મર્યાદિત કોન્ટેક્સ્ટ વિન્ડો હોવા છતાં, સારી રીતે વ્યાખ્યાયિત સ્કીમા તર્ક (reasoning), યુનિટ કન્વર્ઝન અને ભૂલ હેન્ડલિંગમાં સુધારો કરે છે.

મુખ્ય વાત: પ્રોટોકોલ ડિઝાઇન નહીં, પણ ટોકન ઇકોનોમિક્સ ખર્ચ નક્કી કરે છે. ટૂલ સર્વર્સ ક્યારે અને કેવી રીતે લોડ થાય છે તેનું સંચાલન કરવાથી વાતચીતમાંથી હજારો ટોકન્સ બચાવી શકાય છે, જે સીધી રીતે ઓપરેશનલ ખર્ચ ઘટાડે છે.

સ્ત્રોત: https://dev.to/clarkbw--/enabling-bash-costs-more-context-than-seven-mcp-tool-schemas-2h82