पाँच मिनट चलने वाला एजेंट विफलता को नज़रअंदाज़ कर सकता है। पाँच घंटे चलने वाला एजेंट 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 नहीं देख सकता, जैसे अधूरी स्ट्रीम:
- Retry करें: कनेक्शन एरर, 429, 5xx, अधूरी स्ट्रीम। jitter और ऊपरी सीमा के साथ exponential backoff इस्तेमाल करें, उदाहरण के लिए 4 प्रयास।
- Retry नहीं, ठीक करें: 400, 401, 402, 403, 413, 422। ये हर बार एक ही तरह फ़ेल होते हैं। एरर कोड और कब retry करें देखें।
- retry का बजट हर टास्क पर रखें, सिर्फ़ हर कॉल पर नहीं। दस चरण, हर एक चार बार retry, यानी चालीस अतिरिक्त कॉल।
- 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 टोकन पर भी।
रात भर के रन से पहले की चेकलिस्ट
- क्लाइंट पर timeout और
max_retriesसाफ़-साफ़ सेट। - स्ट्रीमिंग चालू,
include_usageके साथ, और अधूरी स्ट्रीम retry होती है। - हर टास्क पर retry बजट और wall-clock सीमा।
- लिखने, भेजने या भुगतान करने वाले हर tool पर idempotency key।
- हर चरण के बाद checkpoint, atomic तरीक़े से लिखा हुआ।
- चरण संख्या, अवधि, टोकन और
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 पर हैं।
