BroadRouter

लंबे चलने वाले एजेंट: टिकाऊ timeout, retry और checkpoint

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

हर मॉडल कॉल को फेंकने योग्य और एजेंट की स्थिति को टिकाऊ मानें। हर कॉल पर timeout लगाएँ, अटकने का पता लगाने के लिए स्ट्रीम करें, 429, 5xx और टूटी स्ट्रीम को सीमित backoff के साथ retry करें, और side effect वाले हर tool को idempotency key दें। हर चरण के बाद मैसेज लिस्ट सेव करें, ताकि क्रैश के बाद एजेंट शुरू से नहीं, आख़िरी checkpoint से चले।

पाँच मिनट चलने वाला एजेंट विफलता को नज़रअंदाज़ कर सकता है। पाँच घंटे चलने वाला एजेंट timeout, 429, टूटी स्ट्रीम और शायद एक restart, सब देखेगा। लंबे चलने वाले एजेंट पर ज़्यादातर गाइड कोई workflow engine बेचती हैं। हो सकता है आपको उसकी ज़रूरत न हो। यह पोस्ट उन पाँच आदतों के बारे में है जो एक सादे एजेंट लूप को घंटों ज़िंदा रखती हैं, OpenAI Python SDK के कोड के साथ।

एजेंट घंटों चले तो क्या टूटता है?

विफलता कैसी दिखती है कौन-सी आदत इसे संभालती है
अटकी या धीमी कॉल मिनटों तक कोई जवाब नहीं हर कॉल पर timeout, स्ट्रीमिंग
रेट लिमिट या ओवरलोड 429, 5xx backoff के साथ सीमित retry
टूटी स्ट्रीम [DONE] से पहले कनेक्शन ख़त्म अधूरा मानें, कॉल retry करें
दोहराया गया side effect retry के बाद tool दो बार चलता है Idempotency key
प्रोसेस क्रैश या डिप्लॉय एजेंट चरण 1 से दोबारा शुरू होता है हर चरण पर checkpoint

1. एक कॉल को कितना समय लेने दें?

OpenAI Python SDK का README कहता है कि अनुरोध डिफ़ॉल्ट रूप से 10 मिनट बाद timeout होते हैं और कुछ एरर दो बार retry किए जाते हैं। एजेंट के लिए दोनों ख़ुद सेट करें, ताकि व्यवहार आपकी जानकारी के बिना न बदले:

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"],
                timeout=300, max_retries=4)

timeout डेटा से चुनें। एक दिन तक हर कॉल की अवधि लॉग करें; timeout को सबसे धीमी सफल कॉल से काफ़ी ऊपर रखें। बड़े प्रॉम्प्ट शुरू होने में ज़्यादा समय लेते हैं, और reasoning मॉडल लिखने से पहले सोचते हैं। लगभग 100 टोकन प्रति सेकंड पर 8,000 आउटपुट टोकन अकेले ही एक मिनट से ज़्यादा लेते हैं। हर टास्क के लिए एक अलग wall-clock बजट जोड़ें, ताकि चलता रहने वाला लूप पूरी रात न चले।

2. लंबे चलने वाले एजेंट में स्ट्रीम क्यों करें?

स्ट्रीमिंग मॉडल के काम करते समय आपको संकेत देती है। इसके बिना धीमी कॉल और मरा हुआ कनेक्शन timeout होने तक एक जैसे दिखते हैं। इसके साथ आप chunks आते देख सकते हैं और आख़िरी chunk में टोकन usage भी पाते हैं।

BroadNet के स्ट्रीमिंग नियम: शाब्दिक data: [DONE] पंक्ति तक पढ़ें। अगर कनेक्शन उससे पहले बंद हो जाए, तो जवाब अधूरा है। X-Request-ID रिकॉर्ड करें, फिर तय करें कि नया अनुरोध करना है या नहीं। पूरी स्ट्रीमिंग गाइड।

def call_streaming(messages, tools=None):
    parts, done = [], False
    stream = client.chat.completions.create(
        model="broadnet/glm-5.3", messages=messages, tools=tools, stream=True,
        stream_options={"include_usage": True}, max_tokens=8000)
    for chunk in stream:
        if chunk.choices and chunk.choices[0].finish_reason:
            done = True
        if chunk.choices and chunk.choices[0].delta.content:
            parts.append(chunk.choices[0].delta.content)
    if not done:
        raise IncompleteStream()   # retry the whole call
    return "".join(parts)

यह स्केच सिर्फ़ टेक्स्ट इकट्ठा करता है। अगर आप tool calls स्ट्रीम करते हैं, तो delta.tool_calls को भी index के हिसाब से जोड़ें।

3. क्या retry करना चाहिए?

SDK पहले से कनेक्शन एरर, 408, 409, 429 और 5xx retry करता है। उसके ऊपर अपना retry सिर्फ़ उसके लिए लगाएँ जो SDK नहीं देख सकता, जैसे अधूरी स्ट्रीम:

  1. Retry करें: कनेक्शन एरर, 429, 5xx, अधूरी स्ट्रीम। jitter और ऊपरी सीमा के साथ exponential backoff इस्तेमाल करें, उदाहरण के लिए 4 प्रयास।
  2. Retry नहीं, ठीक करें: 400, 401, 402, 403, 413, 422। ये हर बार एक ही तरह फ़ेल होते हैं। एरर कोड और कब retry करें देखें।
  3. retry का बजट हर टास्क पर रखें, सिर्फ़ हर कॉल पर नहीं। दस चरण, हर एक चार बार retry, यानी चालीस अतिरिक्त कॉल।
  4. retry ख़त्म होने पर failover करें। अगर रन को प्रोवाइडर के आउटेज में भी बचना है, तो कनेक्शन एरर, 5xx और रेट-लिमिट वाले 429 को दूसरे प्रोवाइडर पर भेजें। LLM API failover में क्लाइंट कोड और circuit breaker है।

उपयोग के अनुसार भुगतान में हर retry एक नया inference है, जिसका फिर से बिल बनता है। उपयोग के अनुसार भुगतान वाली key प्रति मिनट 30 अनुरोध और एक साथ 4 अनुरोध की अनुमति देती है, इसलिए retry की बौछार जल्दी ही रेट लिमिट से टकराती है; रेट लिमिट कैलकुलेटर दिखाता है कि आपके एजेंट के पास कितनी गुंजाइश है। backoff का विस्तार 429 संभालने वाली पोस्ट में है। अनलिमिटेड प्लान पर retry का कोई अतिरिक्त ख़र्च नहीं, लेकिन चलते समय वे सेशन का एकमात्र अनुरोध स्लॉट घेरते हैं।

4. tool calls को idempotent कैसे बनाएँ?

मॉडल कॉल का कोई side effect नहीं होता। tool कॉल का हो सकता है। अगर send_invoice चलने के बाद पर चरण सेव होने से पहले एजेंट क्रैश हो जाए, तो दोबारा शुरू हुआ एजेंट उसे फिर भेज देगा।

side effect वाली हर कॉल को टास्क और चरण से बनी एक idempotency key दें, एक्शन से पहले उसे जाँचें, और अगर वह पहले से रिकॉर्ड है तो कॉल छोड़ दें:

def run_side_effect(task_id, step, call, store):
    key = f"{task_id}:{step}:{call.id}"
    if store.done(key):
        return store.result(key)       # already ran: return the saved result
    result = execute(call)             # pass key to the API if it supports one
    store.save(key, result)
    return result

कई पेमेंट और मैसेजिंग API idempotency key हेडर स्वीकार करते हैं। जहाँ स्वीकार करें, अपनी key आगे भेज दें।

5. एजेंट का checkpoint कैसे बनाएँ?

हर पूरे हुए चरण के बाद सेव करें: मैसेज लिस्ट, चरण संख्या और side effect की keys। शुरू होते समय, अगर आख़िरी checkpoint मौजूद हो, तो उसे लोड करें।

def save_checkpoint(path, step, messages):
    tmp = path + ".tmp"
    with open(tmp, "w") as f:
        json.dump({"step": step, "messages": messages}, f)
    os.replace(tmp, path)   # atomic on the same filesystem

temp फ़ाइल में लिखकर rename करने का मतलब है कि लिखते-लिखते क्रैश होने पर भी कभी आधा checkpoint नहीं बचता। बहुत लंबे सेशन के लिए एक सारांश का भी checkpoint बनाएँ: पुराने turns को छोटे सारांश से बदल दें, ताकि दोबारा शुरू हुआ एजेंट बहुत बड़ा इतिहास फिर से लोड न करे। इससे आप कॉन्टेक्स्ट विंडो के भीतर रहते हैं, DeepSeek V4.1 Flash के 1,048,576 टोकन पर भी।

रात भर के रन से पहले की चेकलिस्ट

  1. क्लाइंट पर timeout और max_retries साफ़-साफ़ सेट।
  2. स्ट्रीमिंग चालू, include_usage के साथ, और अधूरी स्ट्रीम retry होती है।
  3. हर टास्क पर retry बजट और wall-clock सीमा।
  4. लिखने, भेजने या भुगतान करने वाले हर tool पर idempotency key।
  5. हर चरण के बाद checkpoint, atomic तरीक़े से लिखा हुआ।
  6. चरण संख्या, अवधि, टोकन और X-Request-ID वाले लॉग।

अगर आप कई एजेंट साथ-साथ चलाते हैं, तो फ़्लैट रेट पर समानांतर कोडिंग एजेंट चलाना और मल्टी-एजेंट सेटअप का ख़र्च पढ़ें।

BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference मानक chat-completions स्ट्रीमिंग इस्तेमाल करता है, लॉग करने लायक X-Request-ID हेडर लौटाता है, और डॉक्यूमेंट करता है कि कौन-से एरर retry करने हैं, इसलिए ऊपर के पैटर्न जैसे लिखे हैं वैसे ही काम करते हैं। दिन भर चलने वाले एजेंट के लिए अनलिमिटेड प्लान DeepSeek V4.1 Flash पर टोकन मीटर हटा देते हैं, $60 प्रति महीना प्रति सेशन, जिससे retry मुफ़्त हो जाते हैं। ध्यान रखें कि Meteor का घंटा ख़रीदने के एक घंटे बाद और Orbit का हफ़्ता सात दिन बाद ख़त्म होता है, इसलिए लंबे काम को उस अवधि के भीतर पूरा होना चाहिए या रिन्यू होने वाले Full Moon सेशन पर जाना चाहिए। प्लान inference.broadnet.ai/plans पर हैं।

अक्सर पूछे जाने वाले सवाल

एजेंट में LLM API कॉल के लिए कितना timeout रखना चाहिए?

इतना लंबा कि सबसे धीमी जायज़ कॉल पूरी हो जाए, और इतना छोटा कि अटकी हुई कॉल पकड़ी जाए। OpenAI Python SDK का डिफ़ॉल्ट 10 मिनट है। कई एजेंट स्ट्रीमिंग के साथ हर कॉल पर 2 से 5 मिनट रखते हैं, और हर टास्क के लिए अलग wall-clock सीमा।

एजेंट को कौन-से LLM API एरर retry करने चाहिए?

कनेक्शन एरर, 429 और 5xx को सीमित exponential backoff और jitter के साथ retry करें। 400, 401, 402, 403, 413 और 422 को retry करने के बजाय ठीक करें। BroadNet पर हर विफलता के लिए X-Request-ID हेडर भी लॉग करें।

क्या chat completion को retry करना सुरक्षित है?

मॉडल कॉल का अपना कोई side effect नहीं होता, इसलिए हाँ, लेकिन यह नया inference है और उपयोग के अनुसार भुगतान में इसका फिर से बिल बनता है। ख़तरा tools में है। retry किया गया चरण ईमेल दो बार भेज सकता है, जब तक tool idempotency key इस्तेमाल न करे।

क्रैश के बाद एजेंट को दोबारा कैसे शुरू करूँ?

हर पूरे हुए चरण के बाद मैसेज लिस्ट और चरण संख्या सेव करें, कोई एक्शन लेने से पहले side effect के ID लिखें, और शुरू होते समय उन्हें लोड करें। एजेंट आख़िरी सेव किए गए चरण से आगे चलता है।

क्या लंबे चलने वाले एजेंट के लिए अनलिमिटेड प्लान ज़रूरी है?

नहीं, लेकिन उपयोग के अनुसार भुगतान में retry और लंबे कॉन्टेक्स्ट का ख़र्च जुड़ता जाता है। BroadNet के अनलिमिटेड प्लान पर DeepSeek V4.1 Flash में टोकन मीटर नहीं है, इसलिए retry का अतिरिक्त ख़र्च नहीं, हालाँकि हर सेशन फिर भी एक समय में एक अनुरोध चलाता है।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें