12 ಪ್ರಶ್ನೆಗಳ ಪ್ರಯೋಗದಲ್ಲಿ, ಏಳು ಸ್ಕೀಮಾಗಳನ್ನು ಹೊಂದಿರುವ Model Context Protocol (MCP) ಗಿಂತ Bash wrappers ಹೆಚ್ಚು ಟೋಕನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡಿವೆ. ಇದು ಶೆಲ್ (shell) ಎನ್ನುವುದು ಅನೇಕ ಎಂಜಿನಿಯರ್‌ಗಳು ಭಾವಿಸುವಂತೆ ಅಗ್ಗದ ಶಾರ್ಟ್‌ಕಟ್ ಅಲ್ಲ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ Large-Language-Model (LLM) ಏಜೆಂಟ್‌ಗಳಿಗೆ ಟೋಕನ್ ಬಳಕೆ ನೇರವಾಗಿ ವೆಚ್ಚಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಕಥೆಯನ್ನು ಬದಲಿಸಿದ ಪ್ರಯೋಗ

ಒಬ್ಬ ಡೆವಲಪರ್, LLM ಏಜೆಂಟ್ ಹಡಗಿನ ಡೇಟಾವನ್ನು (vessel data) ಪಡೆಯಲು ಬಳಸಬಹುದಾದ ನಾಲ್ಕು ವಿಧಾನಗಳನ್ನು ಅಳೆಯました:

  • MCP – Model Context Protocol ಅಡಿಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಏಳು ಟೂಲ್ ಸ್ಕೀಮಾಗಳು.
  • Bash + curl (cold) – ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಪ್ರಾಂಪ್ಟಿಂಗ್ ಇಲ್ಲದ ಕಚ್ಚಾ ಶೆಲ್ ಕಾಲ್.
  • 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" ಅಗತ್ಯವಿತ್ತು – ಅಂದರೆ ಏಜೆಂಟ್ ಶೆಲ್ ಅನ್ನು ಹೇಗೆ ಸುರಕ್ಷಿತವಾಗಿ ಬಳಸಬೇಕು, ಔಟ್‌ಪುಟ್ ಅನ್ನು ಹೇಗೆ ವಿಶ್ಲೇಷಿಸಬೇಕು ಮತ್ತು ದೋಷಗಳನ್ನು (errors) ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು ಎಂದು ತಿಳಿಸುವ ಸೂಚನೆಗಳು. ಈ ಪ್ರಾಂಪ್ಟ್‌ಗಳು ಮಾತ್ರ ಏಳು MCP ಸ್ಕೀಮಾಗಳ ಒಟ್ಟು ಟೋಕನ್ ತೂಕಕ್ಕಿಂತಲೂ ಹೆಚ್ಚಿವೆ.

ವೆಚ್ಚವು ಕೇವಲ ಆರಂಭಿಕ ಕಾಲ್‌ಗೆ ಮಾತ್ರ ಸೀಮಿತವಾಗಿಲ್ಲ. ಪ್ರೊಡಕ್ಷನ್‌ನಲ್ಲಿ, ಅದೇ ಏಜೆಂಟ್ ಪ್ರಾರಂಭದಲ್ಲಿಯೇ 11 MCP ಸರ್ವರ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡಿಕೊಂಡಿತು, ಇದರಿಂದ ಮೊದಲ ಬಳಕೆದಾರರ ಪ್ರಶ್ನೆ ಬರುವ ಮೊದಲೇ 19,800 ಟೋಕನ್‌ಗಳು ಬಳಕೆಯಾದವು. ನಂತರ, ಪ್ರತಿ ಹಂತದಲ್ಲೂ (turn), ಏಜೆಂಟ್ ಪ್ರತಿಯೊಂದು ಸರ್ವರ್‌ನಿಂದ ಪ್ರತಿಯೊಂದು ಸ್ಕೀಮಾವನ್ನು ಮರುಪಠಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ "ಸಮಯ ಎಷ್ಟಾಯಿತು?" ಎಂಬಂತಹ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ವಿನಂತಿಗೂ ಸಹ ಉಳಿದ ಎಲ್ಲಾ ಟೂಲ್ ವಿವರಣೆಗಳ ಟೋಕನ್ ಬೆಲೆಯನ್ನು ಪಾವತಿಸಬೇಕಾಗುತ್ತದೆ.

Eager loading ನಿಂದ ಉಂಟಾಗುವ ಗುಪ್ತ ನಷ್ಟ

ಒಂದು LLM ಏಜೆಂಟ್ ಪ್ರತಿ ಹಂತದಲ್ಲೂ ಪ್ರತಿಯೊಂದು ಟೂಲ್ ಸರ್ವರ್ ಅನ್ನು eagerly load ಮಾಡಿದಾಗ, ಟೋಕನ್ ಬಿಲ್ ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚಾಗುತ್ತದೆ. Bash ಬಳಸುವ "ನಿಜವಾದ" ವೆಚ್ಚವು ಶೆಲ್ ಕಮಾಂಡ್ ಅಲ್ಲ, ಬದಲಾಗಿ ಪ್ರತಿ ಬಾರಿಯೂ ಮಾಡೆಲ್‌ಗೆ ಕಳುಹಿಸಬೇಕಾದ ಸುತ್ತಮುತ್ತಲಿನ ಸಂದರ್ಭ (context) ಎಂಬುದನ್ನು ಪ್ರಯೋಗವು ತೋರಿಸಿದೆ.

  • Fixed-cost tools (MCP ಸ್ಕೀಮಾಗಳು) ಪ್ರತಿ ಹಂತದಲ್ಲಿ ಅಂದಾಜಿಸಬಹುದಾದ ಟೋಕನ್ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತವೆ.
  • Dynamic payloads (curl ಪ್ರತಿಕ್ರಿಯೆಗಳು) ಸಂಭಾಷಣೆಯ ಉದ್ದ ಮತ್ತು ಡೇಟಾ ಗಾತ್ರಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಹೆಚ್ಚಾಗುವ ಸಾಲವನ್ನು (debt) ಸೇರಿಸುತ್ತವೆ.

ಹೀಗಾಗಿ, ಮೇಲ್ನೋಟಕ್ಕೆ "ಉಚಿತ" ಎಂದು ಕಾಣುವ ಶೆಲ್ ವಾಸ್ತವವಾಗಿ ದೊಡ್ಡದಾದ ಮತ್ತು ಬದಲಾಗುವ ಟೋಕನ್ ತೆರಿಗೆಯನ್ನು ವಿಧಿಸುತ್ತದೆ.

AI ಎಂಜಿನಿಯರ್‌ಗಳು ಮುಂದೆ ಏನು ಮಾಡಬೇಕು

  • Lazy loading ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ. ಟೂಲ್ ಸರ್ವರ್‌ನ ಸ್ಕೀಮಾ ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿರುವಾಗ ಮಾತ್ರ ಅದನ್ನು ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಪ್ರತಿ ಬಾರಿಯೂ ಮರುಪಠಿಸುವ ಬದಲು ಅದನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಇರಿಸಿ.
  • ಟೂಲ್ ಸ್ಕೀಮಾಗಳನ್ನು ಪ್ರತಿ ಹಂತದ ಸ್ಥಿರ ವೆಚ್ಚವೆಂದು ಪರಿಗಣಿಸಿ. ಶೆಲ್ ಕಮಾಂಡ್‌ಗಳು ಉಚಿತ ಎಂದು ಭಾವಿಸುವ ಬದಲು, MCP ವ್ಯಾಖ್ಯಾನಗಳ 알려ದ ಗಾತ್ರದ ಆಧಾರದ ಮೇಲೆ ಟೋಕನ್ ಬಜೆಟ್ ಅನ್ನು ಯೋಜಿಸಿ.
  • “shell = ಅಗ್ಗ” ಎಂಬ ಕಲ್ಪನೆಗಳನ್ನು ಮರುಪರಿಶೀಲಿಸಿ. ಯಾವುದೇ ವಿನ್ಯಾಸಕ್ಕೆ ಬದ್ಧರಾಗುವ ಮೊದಲು ಪ್ರತಿ ಟೂಲ್ ಪಾತ್‌ನ ಟೋಕನ್ ಬಳಕೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಿ.
  • ಸಣ್ಣ ಮಾಡೆಲ್‌ಗಳಿಗಾಗಿ well-defined tools ಅನ್ನು ಬಳಸಿ. ಸೀಮಿತ context windows ಇದ್ದರೂ ಸಹ, ಉತ್ತಮವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಸ್ಕೀಮಾಗಳು ತರ್ಕ (reasoning), ಯುನಿಟ್ ಪರಿವರ್ತನೆ ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಸುಧಾರಿಸುತ್ತವೆ.

ಅಂತಿಮವಾಗಿ: ಪ್ರೊಟೊಕॉल ವಿನ್ಯಾಸವಲ್ಲ, ಟೋಕನ್ ಅರ್ಥಶಾಸ್ತ್ರವೇ (token economics) ವೆಚ್ಚವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಟೂಲ್ ಸರ್ವರ್‌ಗಳನ್ನು ಯಾವಾಗ ಮತ್ತು ಹೇಗೆ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನಿರ್ವಹಿಸುವುದರಿಂದ ಸಂಭಾಷಣೆಯಿಂದ ಸಾವಿರಾರು ಟೋಕನ್‌ಗಳನ್ನು ಉಳಿಸಬಹುದು, ಇದು ಕಾರ್ಯಾಚರಣೆಯ ವೆಚ್ಚವನ್ನು ನೇರವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

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