HI ▾
API कुंजी पाएँ

होमगाइड

अपडेट किया गया

AI एजेंट कॉन्टेक्स्ट विंडो: 100k टोकन कैसे उपयोग होते हैं

AI एजेंट कॉन्टेक्स्ट विंडो प्रॉम्प्ट, टूल परिणामों और मॉडल के उत्तर द्वारा साझित कुल टोकन स्थान है। इस API पर वह स्थान 100,000 टोकन है, और लंबे समय तक चलने वाले एजेंट अपेक्षा से तेजी से इसे भर देते हैं।

चमकते हुए ब्लॉकों के साथ एक कांच का पात्र भर रहा है जबकि एक तीर लूप में उसके चारों ओर घूम रहा है, जो एजेंट की कॉन्टेक्स्ट विंडो का चित्रण करता है

मुख्य बिंदु

  1. 100,000 टोकन की विंडो प्रॉम्प्ट और पूर्णता दोनों को कवर करती है, इसलिए आप जो भी टूल रिजल्ट रखते हैं, वह अगले जवाब के लिए जगह कम कर देता है।
  2. एजेंट लूप में हर कदम पर पूरा इतिहास फिर से भेजा जाता है, इसलिए कुल इनपुट कदमों की संख्या के वर्ग के साथ बढ़ता है, रैखिक रूप से नहीं।
  3. पुराने टूल आउटपुट को पहले काटें, सिस्टम प्रॉम्प्ट और नवीनतम टर्न्स को रखें, और उपयोग फ़ील्ड के साथ मापें।
  4. प्रति चरण 1,500 नए टोकन के साथ 20-चरण का लूप कुल मिलाकर लगभग $0.055 का खर्च करता है।

कार्ड की आवश्यकता नहीं है। साइन-अप के बाद, एक क्लिक से $0.50 का मुफ़्त ट्रायल क्रेडिट क्लेम करें (प्रति व्यक्ति एक बार)।

API कुंजी पाएँ

संक्षिप्त उत्तर: 100,000 टोकन का एक साझा बजट

जब लोग AI एजेंट कॉन्टेक्स्ट विंडो खोजते हैं, तो वे आमतौर पर जानना चाहते हैं कि एजेंट टूटने से पहले कितना याद रख सकता है। यहाँ संख्या 100,000 टोकन है, और यह सब गिनती में आती है: सिस्टम प्रॉम्प्ट, टूल परिभाषाएं, हर पिछला संदेश, हर टूल परिणाम, और मॉडल द्वारा लिखा जाने वाला कम्पलीशन। कम्पलीशन जो बचता है उसका उपयोग कर सकता है, और max_tokens वैकल्पिक है।

इससे विंडो एक भंडारण स्थान नहीं, बल्कि एक बजट बन जाती है। एक चैटबॉट सीमा के करीब कभी नहीं आता। एक ऐसा एजेंट जो लूप में टूल कॉल करता है, वह एक दोपहर में उस तक पहुंच सकता है, क्योंकि हर चरण इतिहास में एक मॉडल संदेश और एक टूल परिणाम जोड़ता है, और अगले कॉल पर पूरा इतिहास फिर से भेजा जाता है। मॉडल के पास अनुरोधों के बीच कोई मेमोरी नहीं है। जो मेमोरी जैसा दिखता है वह आपका इतिहास फिर से भेजना है।

एजेंट में विंडो को वास्तव में क्या भरता है

ज्यादातर स्थान उपयोगकर्ता के टेक्स्ट का नहीं होता है। इन पाँच स्रोतों को ट्रैक करें और आप यह भविष्यवाणी कर सकते हैं कि रन कहाँ खत्म हो जाएगा।

  • सिस्टम प्रॉम्प्ट। नियम, पर्सोना और आउटपुट फॉर्मेट। अक्सर 500 से 2,000 टोकन और हर कॉल पर भेजा जाता है।
  • टूल परिभाषाएँ। प्रत्येक फ़ंक्शन का नाम, विवरण और JSON स्कीमा गिना जाता है। लंबे विवरणों वाले दस टूल्स पहले उपयोगकर्ता संदेश से पहले ही कई हजार टोकन ले सकते हैं।
  • टूल रिजल्ट। आम तौर पर यही असली कारण होता है। एक सर्च रिजल्ट, फ़ाइल डंप या डेटाबेस रो सेट हजारों टोकन हो सकता है, और जब तक आप इसे हटा न दें, यह हिस्ट्री में बना रहता है।
  • सहायक संदेश। टेक्स्ट में लिखा गया तर्क और मॉडल द्वारा उत्पन्न tool_calls के आर्गुमेंट।
  • जो उत्तर जनरेट हो रहा है। इसके लिए भी जगह चाहिए। यदि प्रॉम्प्ट 99,000 टोकन है, तो उत्तर के लिए लगभग 1,000 शेष रहते हैं।

API हर रिस्पॉन्स के usage ब्लॉक में सटीक नंबर रिपोर्ट करता है, इसलिए आपको अनुमान लगाने की ज़रूरत नहीं है। हर कदम के बाद prompt_tokens लॉग करें और आप वक्र देख पाएंगे।

एक कार्य उदाहरण: टूल लूप के 20 स्टेप

एक एजेंट लें जिसकी शुरुआत 3,000 टोकन की हो (सिस्टम प्रॉम्प्ट और टूल परिभाषाएँ)। हर कदम पर इतिहास में लगभग 1,500 टोकन जुड़ते हैं: मॉडल का टूल कॉल और टूल का रिजल्ट। यह हर कदम पर लगभग 300 टोकन आउटपुट भी लिखता है। एजेंट 20 कदम चलाता है।

चरण k पर इनपुट 3,000 + 1,500 × (k − 1) है। 20 चरणों के लिए जोड़ने पर:

  • 3,000 × 20 = स्थिर शुरुआत के लिए 60,000 टोकन, हर बार फिर से भेजे गए।
  • 1,500 × (0 + 1 + ... + 19) = 1,500 × 190 = 285,000 टोकन जमा इतिहास के।
  • कुल इनपुट: 345,000 टोकन। कुल आउटपुट: 20 × 300 = 6,000 टोकन।
आइटमटोकनप्रति 1M कीमतलागत
इनपुट345,000$0.15$0.05175
आउटपुट6,000$0.50$0.003
कुललगभग $0.055

दो बातें स्पष्ट हैं। पहला, चरण 20 पर कॉन्टेक्स्ट 3,000 + 1,500 × 19 = 31,500 टोकन है, जो विंडो के भीतर है, फिर भी आपने 345,000 इनपुट टोकन के लिए भुगतान किया, क्योंकि इतिहास हर बार फिर से भेजा गया था। दूसरा, एक पूरी तरह से भरी विंडो (100,000 इनपुट टोकन) के साथ एक कॉल का इनपुट साइड पर खर्च 100,000 × $0.15 / 1M = $0.015 है। लंबे कॉन्टेक्स्ट प्रति कॉल सस्ते हैं; खर्च कई चरणों में उन्हें दोहराने से आता है। दरों और टॉप-अप बोनस के लिए मूल्य निर्धारण पृष्ठ देखें।

विंडो भरी जाने से पहले कितने स्टेप फिट हो सकते हैं

आप कोड लिखने से पहले इसका अनुमान लगा सकते हैं। उत्तर के लिए एक रिजर्व रखें, मान लें 20,000 टोकन, जिससे प्रॉम्प्ट के लिए 80,000 टोकन का बजट शेष रहता है। 3,000 टोकन की शुरुआत और प्रति चरण 1,500 टोकन के जोड़ के साथ, इतिहास (80,000 − 3,000) / 1,500, या लगभग 51 चरणों के बाद उस बजट तक पहुँचता है।

अब उस लंबाई के एक रन की कीमत निकालें। 51 कदमों पर इनपुट 3,000 × 51 + 1,500 × (0 + 1 + ... + 50) = 153,000 + 1,500 × 1,275 = 153,000 + 1,912,500 = 2,065,500 टोकन होता है। 300 टोकन प्रति कदम पर आउटपुट 15,300 टोकन होता है। लागत: 2,065,500 × $0.15 / 1M = $0.30983, जमा 15,300 × $0.50 / 1M = $0.00765, यानी लगभग $0.32।

इसकी तुलना लगभग $0.055 के 20-चरण के रन से करें। वह रन 2.55 गुना लंबा है लेकिन लगभग 5.8 गुना अधिक खर्च करता है, क्योंकि प्रत्येक चरण में एक लंबा इतिहास होता है। यह काटने का व्यावहारिक कारण है: यह प्रति चरण खर्च को सीमित करता है और विंडो की रक्षा भी करता है।

एजेंट को विंडो के भीतर रखना

पहले पुराने टूल आउटपुट को हटाएं

कच्चे टूल परिणाम पुराने इतिहास का सबसे बड़ा और कम उपयोगी हिस्सा हैं। एक बार जब मॉडल फ़ाइल लिस्टिंग पर कार्य कर चुका होता है, तो उसे उस लिस्टिंग की दुबारा आवश्यकता नहीं होती। पुराने परिणामों को "परिणाम हटाया गया, 4,200 टोकन" जैसे एक-पंक्ति वाले स्टब से बदलें, या जोड़े को पूरी तरह हटा दें।

मध्य को सारांशित करें, दोनों सिरों को बनाए रखें

सिस्टम प्रॉम्प्ट और पिछले कुछ टर्न्स को शब्दशः बनाए रखें। बीच के सब कुछ के लिए, मॉडल से लिए गए निर्णयों और पाए गए तथ्यों का एक छोटा सारांश मांगें, और फिर उस सारांश को एक ही संदेश के रूप में स्टोर करें। लिमिट से पहले सारांश कॉल चलाएं, बाद में नहीं।

तथ्यों को ट्रांसक्रिप्ट से बाहर करें

यदि एजेंट कुछ ऐसा सीखता है जिसे उसे घंटों तक रखना है, तो उसे एक टूल के माध्यम से एक फ़ाइल या छोटे डेटाबेस में लिखें, और जब आवश्यक हो तो उसे वापस पढ़ें। हर अनुरोध में इसे ले जाने से यह सस्ता है और रीस्टार्ट्स के बाद भी टिकता है।

टूल स्कीमा को छोटा रखें

वर्णन को उसी तक सीमित रखें जो मॉडल को टूल चुनने के लिए चाहिए। टास्क के वर्तमान चरण से संबंधित टूल ही पास करें।

कोड: टोकन बजट के साथ एक टूल लूप

यह लूप अनुमानित आकार के 80,000 टोकन के बजट को पार करने पर सबसे पुराने संदेशों को काट देता है, जवाब के लिए जगह छोड़ता है। अनुमान अंग्रेजी टेक्स्ट के लिए एक सामान्य सन्निकटन के रूप में वर्णों को चार से भाग देता है; असली गिनती usage में वापस आती है। ट्रिमिंग अकेले रहने वाले tool संदेशों को हटा देती है ताकि रिजल्ट बिना उसके कॉल के न आए।

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.aivideogenapi.com/v1", api_key=os.environ["API_KEY"])
BUDGET = 80_000

tools = [{"type": "function", "function": {
    "name": "get_scene_length",
    "description": "Return the length of a scene in seconds",
    "parameters": {"type": "object",
                   "properties": {"scene": {"type": "integer"}},
                   "required": ["scene"]}}}]

def rough_tokens(messages):
    return sum(len(json.dumps(m)) for m in messages) // 4

def trim(messages):
    system, rest = messages[0], messages[1:]
    while rough_tokens([system] + rest) > BUDGET and len(rest) > 4:
        rest.pop(0)
        while rest and rest[0]["role"] == "tool":
            rest.pop(0)
    return [system] + rest

def run_tool(name, args):
    return json.dumps({"seconds": 4 * args["scene"]})  # stub

messages = [
    {"role": "system", "content": "You plan video scenes. Use tools for lengths."},
    {"role": "user", "content": "Total the length of scenes 1 to 5."},
]

for step in range(20):
    resp = client.chat.completions.create(
        model="uncensored", messages=trim(messages), tools=tools)
    msg = resp.choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    print(step, resp.usage.prompt_tokens)
    if not msg.tool_calls:
        print(msg.content)
        break
    for call in msg.tool_calls:
        result = run_tool(call.function.name, json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": result})

टूल कॉलिंग OpenAI फॉर्मेट का पालन करती है: tools, tool_choice, और role: "tool" के रूप में लौटाए गए परिणाम। दस्तावेज़ उन पैरामीटरों की सूची देता है जो सीधे पास होते हैं।

विंडो के अलावा मायने रखने वाली लिमिटें

विंडो एक सीमा है। एजेंट्स भी रेट लिमिट से टकराते हैं। फुल कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोध की अनुमति देती है; ट्रायल कुंजी 2 और 60 की अनुमति देती है। समानांतर सब-एजेंट्स के साथ एक तेज़ लूप समवर्ती अनुरोध सीमा को जल्दी पार कर सकता है। API HTTP 429 और त्रुटि कोड concurrency या rate_limited के साथ जवाब देता है, और अस्थायी ओवरलोड पर Retry-After: 5 हेडर के साथ। इतना समय प्रतीक्षा करें और पुनः प्रयास करें।

यदि आप स्ट्रीमिंग करते हैं, तो याद रखें कि स्ट्रीम किया गया अनुरोध स्ट्रीम खत्म होने तक अपना समवर्ती अनुरोध स्लॉट पकड़े रखता है। अटका हुआ क्लाइंट जो स्ट्रीम को कभी बंद नहीं करता, एक स्लॉट को व्यस्त रखता है।

मैक्सिमम बॉडी 8 MB है, जो 100,000 टोकन टेक्स्ट से कहीं ज़्यादा है, इसलिए विंडो वह सीमा है जिससे आप पहले मिलेंगे। इस API पर बने टेक्स्ट-ओनली पाइपलाइन के उदाहरण के लिए, वीडियो स्क्रिप्ट गाइड देखें। जब आप इसे चलाने के लिए तैयार हों, API कुंजी बनाएँ; नए उपयोगकर्ता एक क्लिक के साथ $0.50 का ट्रायल क्रेडिट क्लेम कर सकते हैं, जो 7 दिनों के लिए वैध है और जिसमें भुगतान की ज़रूरत नहीं है।

प्रश्न और उत्तर

कॉन्टेक्स्ट विंडो कितनी बड़ी है?

100,000 टोकन, प्रॉम्प्ट और कम्पलीशन को मिलाकर गिना गया। कम्पलीशन प्रॉम्प्ट द्वारा शेष खाली जगह का उपयोग कर सकती है।

क्या मॉडल पिछले अनुरोधों को याद रखता है?

नहीं। हर अनुरोध स्वतंत्र है, इसलिए आपके कोड को वे संदेश फिर से भेजने होंगे जिन्हें आप मॉडल को दिखाना चाहते हैं।

जब मैं सीमा से ऊपर जाता हूँ तो क्या होता है?

अनुरोध फिट नहीं हो पाता, इसलिए भेजने से पहले इतिहास को छोटा या सारांशित करें। विफल अनुरोधों के लिए शुल्क नहीं लगाया जाता।

टोकन की गणना कैसे करें?

हर रिस्पॉन्स के usage ब्लॉक से prompt_tokens और completion_tokens पढ़ें, या भेजने से पहले अंग्रेजी के लिए टोकन प्रति चार वर्ण का एक मोटा अनुमान उपयोग करें।

आपकी कुंजी बस एक फ़ॉर्म दूर है

एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।

API कुंजी पाएँ