6 मार्च 2026

एजेंट लागत अनुकूलन: API खर्च कम करने की व्यावहारिक गाइड

एजेंट लागत अनुकूलन: API खर्च कम करने की व्यावहारिक गाइड

आपका एजेंट बढ़िया काम करता है। वह प्रतिदिन 200 अनुरोध संभालता है और उपयोगकर्ता खुश हैं। फिर आप API का बिल देखते हैं: इस महीने $3,400। जब आप संख्याओं को खंगालते हैं, तो पता चलता है कि एजेंट प्रति अनुरोध औसतन 12 API कॉल करता है, जिनमें से प्रत्येक में 4,000-टोकन का सिस्टम प्रॉम्प्ट होता है। यानी केवल सिस्टम प्रॉम्प्ट के लिए प्रतिदिन 9.6 मिलियन इनपुट टोकन। $3 प्रति मिलियन टोकन की दर से, यह केवल बार-बार दोहराई जाने वाली सामग्री पर $864/महीना है।

प्रोडक्शन एजेंट डिप्लॉयमेंट को वापस लेने या पूरी तरह बंद करने का सबसे बड़ा कारण लागत है। अनुकूलन समय से पहले नहीं — यह अस्तित्व का सवाल है। अच्छी खबर यह है: अधिकांश एजेंट डिप्लॉयमेंट में 50–80% लागत कम करने की संभावना होती है — सीधे-सादे बदलावों के ज़रिए, जिनके लिए पूरे सिस्टम को नए सिरे से बनाने की ज़रूरत नहीं।

इस गाइड में आप सात लागत कमी रणनीतियाँ सीखेंगे, जो ROI (Return on Investment) के क्रम में हैं। ऊपर से शुरू करें और नीचे की ओर बढ़ते जाएं जब तक आप अपने बजट लक्ष्य तक न पहुँच जाएं। हर अनुभाग में ठोस संख्याएं हैं ताकि आप एक भी कोड लिखने से पहले बचत का अनुमान लगा सकें।

1. टोकन लेखांकन: जानें आपका पैसा कहाँ जाता है

आप उसे अनुकूलित नहीं कर सकते जिसे आप मापते नहीं। कुछ भी बदलने से पहले, अपने एजेंट वर्कफ़्लो में हर डॉलर के जाने की पूरी तस्वीर बनाएं।

इनपुट टोकन का विश्लेषण

Claude को हर API कॉल में इनपुट पक्ष पर कई टोकन श्रेणियाँ शामिल होती हैं:

सिस्टम प्रॉम्प्ट — निर्देश, व्यक्तित्व, प्रतिबंध। अक्सर 1,000–5,000 टोकन और हर कॉल पर दोहराए जाते हैं।
टूल परिभाषाएं — एजेंट जिन टूल का उपयोग कर सकता है उनके JSON स्कीमा। 10 टूल आसानी से 2,000–3,000 टोकन खा जाते हैं।
बातचीत का इतिहास — बातचीत के सभी पुराने संदेश। हर चरण के साथ बढ़ता है।
टूल परिणाम — पिछले टूल कॉल के आउटपुट जो संदर्भ में वापस इंजेक्ट किए जाते हैं। ये बहुत बड़े हो सकते हैं (पूरे वेब पेज, डेटाबेस परिणाम)।

आउटपुट टोकन का विश्लेषण

आउटपुट टोकन इनपुट टोकन से 3–5 गुना अधिक महंगे होते हैं, जो उन्हें एक महत्वपूर्ण अनुकूलन लक्ष्य बनाता है:

एजेंट तर्क — आंतरिक चेन-ऑफ-थॉट (विशेष रूप से विस्तारित सोच के साथ)।
टूल कॉल जेनरेशन — टूल आह्वान के लिए JSON।
अंतिम प्रतिक्रिया — उपयोगकर्ता के लिए उत्तर।

प्रति-कार्य लागत गणना

एक एजेंट कार्य की कुल लागत इस प्रकार है:

कुल लागत = Σ (input_tokens × input_price + output_tokens × output_price)
             कार्य में प्रत्येक API कॉल के लिए

लागत विश्लेषण उदाहरण

Claude Sonnet ($3/M इनपुट, $15/M आउटपुट) का उपयोग करते हुए 10-चरण वाले रिसर्च एजेंट कार्य का एक यथार्थवादी विश्लेषण:

चरण	घटक	इनपुट टोकन	आउटपुट टोकन	इनपुट लागत	आउटपुट लागत	कुल
1	प्रारंभिक योजना	4,200	800	$0.0126	$0.0120	$0.025
2	वेब सर्च कॉल	4,800	200	$0.0144	$0.0030	$0.017
3	सर्च परिणाम प्रोसेस	8,500	600	$0.0255	$0.0090	$0.035
4	गहरी पठन (पेज 1)	12,000	500	$0.0360	$0.0075	$0.044
5	गहरी पठन (पेज 2)	15,200	500	$0.0456	$0.0075	$0.053
6	फॉलो-अप सर्च	16,800	200	$0.0504	$0.0030	$0.053
7	परिणाम प्रोसेस	20,100	600	$0.0603	$0.0090	$0.069
8	संश्लेषण	22,500	1,200	$0.0675	$0.0180	$0.086
9	सत्यापन	24,000	400	$0.0720	$0.0060	$0.078
10	अंतिम प्रतिक्रिया	25,500	1,500	$0.0765	$0.0225	$0.099
कुल		1,53,600	6,500	$0.461	$0.098	$0.558

ध्यान दें कि इनपुट लागत कैसे हावी होती है, और हर चरण के साथ बातचीत का इतिहास जमा होने पर यह कैसे बढ़ती है। चरण 8–10 कुल लागत का 47% हिस्सा लेते हैं, जबकि वे केवल 30% चरण हैं।

लागत ट्रैकिंग कोड

पहले दिन से एक ट्रैकिंग रैपर लागू करें:

import anthropic
import time
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class CostRecord:
    step: int
    model: str
    input_tokens: int
    output_tokens: int
    cache_read_tokens: int = 0
    cache_creation_tokens: int = 0
    input_cost: float = 0.0
    output_cost: float = 0.0
    total_cost: float = 0.0
    duration_ms: float = 0.0

# Pricing per million tokens (as of early 2026)
MODEL_PRICING = {
    "claude-haiku": {"input": 0.25, "output": 1.25, "cache_read": 0.025, "cache_write": 0.30},
    "claude-sonnet": {"input": 3.00, "output": 15.00, "cache_read": 0.30, "cache_write": 3.75},
    "claude-opus": {"input": 15.00, "output": 75.00, "cache_read": 1.50, "cache_write": 18.75},
}

@dataclass
class TaskCostTracker:
    task_id: str
    budget_limit: Optional[float] = None
    records: list = field(default_factory=list)
    total_cost: float = 0.0

    def record_call(self, step: int, model: str, usage) -> CostRecord:
        pricing = MODEL_PRICING.get(model, MODEL_PRICING["claude-sonnet"])

        input_cost = (usage.input_tokens / 1_000_000) * pricing["input"]
        output_cost = (usage.output_tokens / 1_000_000) * pricing["output"]
        cache_read_cost = (getattr(usage, 'cache_read_input_tokens', 0) / 1_000_000) * pricing["cache_read"]
        cache_write_cost = (getattr(usage, 'cache_creation_input_tokens', 0) / 1_000_000) * pricing["cache_write"]

        total = input_cost + output_cost + cache_read_cost + cache_write_cost

        record = CostRecord(

---

## संबंधित लेख

- [AI एजेंट्स के लिए कैशिंग रणनीतियाँ: गुणवत्ता से समझौता किए बिना लागत कम करें](/hi/blog/caching-strategies-for-ai-agents-cutting-costs-without-cutting-corners/)
- [एजेंट वर्कफ़्लो में रीज़निंग मॉडल: एक्सटेंडेड थिंकिंग कब फायदेमंद होती है](/hi/blog/reasoning-models-in-agent-workflows-when-extended-thinking-pays-off/)
- [मल्टी-एजेंट पैटर्न: ऑर्केस्ट्रेटर, Workers और पाइपलाइन](/hi/blog/multi-agent-patterns/)
- [स्वायत्त एजेंट सिस्टम में डिबगिंग और ऑब्जर्वेबिलिटी](/hi/blog/debugging-agent-observability/)