कुछ LLM jobs चैट नहीं होते। आपके पास लेबल करने के लिए 50,000 सपोर्ट टिकट हैं, अनुवाद करने के लिए 200,000 प्रोडक्ट विवरण, या स्कोर करने के लिए दस लाख रिव्यू। OpenAI और Anthropic जैसे प्रोवाइडर इसके लिए Batch API बेचते हैं। कई OpenAI-compatible API, जिनमें BroadNet Inference भी है, ऐसा नहीं करते। यह पोस्ट दिखाती है कि job ख़ुद कैसे चलाएँ: अंदाज़ा लगाएँ कि कितना समय लगेगा, सीमाओं का पालन करने वाला runner लिखें, और उसे रोकने और दोबारा शुरू करने लायक सुरक्षित बनाएँ।
BroadRouter, BroadNet की अपनी साइट है, इसलिए उदाहरण के आँकड़े BroadNet की प्रकाशित सीमाओं पर हैं। यह तरीक़ा किसी भी chat-completions API पर चलता है; अपने प्रोवाइडर के आँकड़े डालें।
क्या BroadNet Inference में Batch API है?
नहीं। 15 नवंबर 2026 को जाँचा गया API रेफ़रंस POST /v1/chat/completions, POST /v1/audio/transcriptions और GET /v1/models (मॉडल लिस्ट) दस्तावेज़ित करता है, साथ में /portal/ के तहत अकाउंट endpoint। कोई बैच या फ़ाइल-अपलोड endpoint नहीं है और कोई बैच छूट नहीं। बड़ा job सामान्य अनुरोधों का एक लूप है।
होस्टेड Batch API आपको क्या देता है, यह रहा, ताकि पता रहे कि आप क्या दोबारा बना रहे हैं:
| OpenAI Batch API | Anthropic Message Batches | आपका अपना runner | |
|---|---|---|---|
| कीमत | synchronous से 50% कम | 50% कम | सामान्य कीमत |
| लौटने का समय | 24 घंटे के भीतर | ज़्यादातर 1 घंटे के भीतर; 24 के बाद समाप्त | आपकी रेट लिमिट से तय |
| प्रति बैच आकार | 50,000 अनुरोध या 200 MB | 100,000 अनुरोध या 256 MB | कोई भी आकार |
| रेट लिमिट | प्रति-मॉडल सीमाओं से अलग | queue में रखे अनुरोधों पर लागू | आपकी key की सीमाएँ |
| नतीजों का क्रम | अलग हो सकता है; custom_id से मिलाएँ |
custom_id से मिलाएँ |
आप नतीजे ID से जोड़ते हैं |
दो सबक़ यहाँ भी लागू होते हैं। दोनों प्रोवाइडर हर अनुरोध पर एक ID लगवाते हैं, क्योंकि नतीजे क्रम में वापस नहीं आते। कोई भी सेकंडों में जवाब का वादा नहीं करता। आपका runner भी ऐसे ही चले: हर चीज़ पर ID, और घंटों में मापी गई योजना।
अगर लौटने के समय से ज़्यादा 50% छूट मायने रखती है, और आपके ज़रूरी मॉडल वहाँ हैं, तो होस्टेड Batch API सस्ता औज़ार हो सकता है। बनाने से पहले दोनों की कीमत LLM API लागत कैलकुलेटर से निकालें।
job में कितना समय लगेगा?
कोड लिखने से पहले यह हिसाब लगाएँ। दो सीमाएँ थ्रूपुट रोकती हैं, और धीमी वाली जीतती है:
- In-flight सीमा ÷ लेटेंसी। 4 अनुरोध in flight और प्रति अनुरोध 2 सेकंड हों, तो आप प्रति सेकंड 2 पूरे कर सकते हैं।
- प्रति मिनट अनुरोध। प्रति मिनट 30 पर आप प्रति सेकंड 0.5 शुरू कर सकते हैं, मॉडल कितना भी तेज़ हो।
BroadNet की उपयोग के अनुसार भुगतान वाली key 4 अनुरोध in flight और 30 प्रति मिनट देती है। जब हमने API रेफ़रंस देखा (2026-11-15), तब के मानों पर (प्रति मिनट 30 और 4 in flight), जब तक हर अनुरोध 8 सेकंड से ज़्यादा न ले, रेट लिमिट ही बाँधती है, और नीचे की टेबल प्रति मिनट 30 मानकर चलती है:
| आइटम | प्रति अनुरोध एक आइटम | प्रति अनुरोध 20 आइटम |
|---|---|---|
| 10,000 | 5.6 घंटे | 17 मिनट |
| 100,000 | 2.3 दिन | 2.8 घंटे |
| 1,000,000 | 23 दिन | 28 घंटे |
प्रति मिनट 30 अनुरोध पर एक key घंटे में 1,800 अनुरोध करती है, यानी दिन में 43,200। retry भी गिने जाते हैं: आपका हर 429 एक स्लॉट ख़र्च करता है।
दूसरा कॉलम सबसे बड़ा लीवर है। छोटे आइटम, जैसे रिव्यू या टिकट के विषय, क्रमांकित लिस्ट के रूप में प्रति अनुरोध 10 से 50 जा सकते हैं, और जवाब में JSON array आता है। जाँचें कि array में हर इनपुट के लिए एक entry है और हर entry पर उसका नंबर है। अरबी टेक्स्ट वर्गीकरण पोस्ट यह पैटर्न दिखाती है। लंबे आइटम पैक नहीं होते: हर अनुरोध को फिर भी मॉडल की कॉन्टेक्स्ट विंडो में समाना होता है, और लिस्ट बढ़ने पर गुणवत्ता गिर सकती है। भरोसा करने से पहले 200 आइटम पर पैकिंग टेस्ट करें।
प्रति-key सीमा को मात देने के लिए बिना पूछे एक job को कई keys में न फैलाएँ। BroadNet की Acceptable Use Policy रेट, concurrency या बजट सीमाओं से बचने की मनाही करती है। ज़्यादा चाहिए, तो BroadNet से पूछें, या नीचे बताए प्लान सेशन इस्तेमाल करें। बैच job प्लानर आपकी आइटम संख्या, लेटेंसी और सीमाओं के लिए यही हिसाब करता है।
दोबारा शुरू होने वाला runner कैसा दिखता है?
यह runner items.jsonl पढ़ता है (हर लाइन में एक {"id", "text"} ऑब्जेक्ट) और हर आइटम के लिए एक नतीजा लाइन results.jsonl में जोड़ता है। इसे सिर्फ़ OpenAI Python SDK चाहिए।
import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError
client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
api_key=os.environ["BROADNET_API_KEY"],
max_retries=0, # we retry ourselves, with a cap we can see
timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4")) # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30")) # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6
class Pacer:
"""Spaces request starts at least 60/RPM seconds apart, across all workers."""
def __init__(self, rpm):
self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
async def wait(self):
async with self.lock:
now = time.monotonic()
delay = max(0.0, self.next - now)
self.next = max(now, self.next) + self.gap
await asyncio.sleep(delay)
def retryable(e):
if isinstance(e, (APIConnectionError, APITimeoutError)):
return True
return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)
async def call(item, pacer):
for attempt in range(MAX_ATTEMPTS):
await pacer.wait() # every attempt counts against the rate limit
try:
r = await client.chat.completions.create(
model=MODEL, max_tokens=1500, reasoning_effort="low",
messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
{"role": "user", "content": item["text"]}])
c = r.choices[0]
return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
"output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
except Exception as e:
if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt))) # full jitter, capped
async def run(in_path, out_path):
done = set()
if os.path.exists(out_path): # resume: skip ids that already succeeded
with open(out_path) as f:
done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
print(f"{len(done)} done, {len(todo)} to go")
pacer, queue = Pacer(RPM), asyncio.Queue()
for it in todo:
queue.put_nowait(it)
with open(out_path, "a") as out:
async def worker():
while True:
try:
it = queue.get_nowait()
except asyncio.QueueEmpty:
return
res = await call(it, pacer)
out.write(json.dumps(res, ensure_ascii=False) + "\n")
out.flush() # one line per finished item = the checkpoint
await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))
if __name__ == "__main__":
import sys
asyncio.run(run(sys.argv[1], sys.argv[2]))
इसे python batch_run.py items.jsonl results.jsonl से चलाएँ। हमने यही फ़ाइल एक लोकल mock सर्वर पर टेस्ट की, जो बेतरतीब 429 (8%) और 500 (5%) लौटाता था और 4 से ज़्यादा in flight या प्रति मिनट 30 से ज़्यादा शुरुआत को अस्वीकार करता था। 25 आइटम 28 अनुरोधों (3 retry) के साथ 55 सेकंड में पूरे हुए, और किसी भी 60 सेकंड की विंडो में 30 से ज़्यादा शुरुआत नहीं हुई। समय बचाने के लिए mock की सीमा प्रति मिनट 300 करने पर, 10 सेकंड बाद रोका गया 120 आइटम का रन 39 सेव किए गए नतीजों से दोबारा शुरू हुआ और 120 अनोखी IDs के साथ, बिना किसी दोहराव के, पूरा हुआ।
asyncio.gather की जगह worker pool क्यों?
429 गाइड asyncio.gather के चारों ओर semaphore इस्तेमाल करती है। कुछ सौ कॉल के लिए यह ठीक है। बड़े job के लिए queue से आइटम लेने वाले workers का तय pool बेहतर है:
- मेमोरी।
gatherशुरू में ही हर आइटम के लिए एक task बनाता है। pool सिर्फ़ in flight आइटम रखता है। - Concurrency ही pool का आकार है। चार workers के कभी पाँच अनुरोध खुले नहीं हो सकते।
- नतीजे डिस्क पर बहते हैं जैसे-जैसे वे पूरे होते हैं, किसी भी क्रम में, ID के साथ।
Pacer दूसरी सीमा संभालता है। अकेला semaphore आपको 4 in flight से आगे जाने से रोकता है, लेकिन अगर अनुरोध एक सेकंड लें, तो चार workers प्रति मिनट 240 शुरू करेंगे और ज़्यादातर पर 429 पाएँगे। pacer सभी workers में, retry समेत, शुरुआत के बीच 2 सेकंड का अंतर रखता है।
retry सुरक्षित कैसे रहते हैं?
सिर्फ़ वही retry करें जो दूसरी कोशिश में सफल हो सकता है:
| जवाब | कार्रवाई |
|---|---|
| 429 | रुकें और retry करें; BroadNet के डॉक्स कहते हैं “use response details and bounded backoff” (अनुवाद: जवाब के ब्योरे और सीमित backoff इस्तेमाल करें) |
| 500, 502, 503, 504, timeout, टूटे कनेक्शन | सीमित exponential backoff के साथ retry करें |
| 400, 422 | अनुरोध ठीक करें; retry वही एरर भेजता है |
| 401, 402, 403 | job रोकें; key, बैलेंस या नीति पर ध्यान चाहिए |
| 413 | आइटम छोटा करें |
runner SDK के अपने retry बंद करता है (max_retries=0), ताकि ठीक एक retry नीति हो, दिखने वाली सीमा के साथ। Backoff फ़ुल jitter के साथ exponential है, 60 सेकंड पर सीमित, ताकि साथ विफल हुए workers साथ retry न करें। छह कोशिशों के बाद आइटम "ok": false के रूप में लिखा जाता है और job आगे बढ़ता है। एक ख़राब आइटम कभी दस लाख को नहीं रोकता।
मॉडल कॉल का कोई side effect नहीं होता, इसलिए यहाँ डिलीवरी कम से कम एक बार है: अगर अनुरोध के बीच प्रोसेस मर जाए, तो वह आइटम दोबारा शुरू होने पर फिर भेजा जाता है, और आप उसके लिए दो बार भुगतान करते हैं। यही एकमात्र बर्बादी है। अगर job किसी दूसरे सिस्टम में भी लिखता है, जैसे टिकट या ईमेल, तो उस लेखन को आइटम ID के आधार पर idempotent बनाएँ और उसे results.jsonl पर एक अलग पास में करें। लंबे चलने वाले एजेंट वाली पोस्ट idempotent side effect विस्तार से बताती है।
checkpointing कैसे काम करती है?
आउटपुट फ़ाइल ही checkpoint है। हर पूरा हुआ आइटम एक flush की गई लाइन है, इसलिए क्रैश, deploy या Ctrl-C के बाद अगला रन फ़ाइल पढ़ता है, "ok": true वाली IDs इकट्ठा करता है और सिर्फ़ बाक़ी को queue में डालता है। पहले विफल हुए आइटम अगले रन में retry होते हैं, और उनकी नई लाइन जुड़ती है। नतीजे पढ़ते समय हर ID की आख़िरी लाइन लें।
तीन आदतें इसे दिनों तक टिकाऊ बनाती हैं:
- स्थिर IDs। डेटाबेस key या इनपुट का hash इस्तेमाल करें, कभी लाइन नंबर नहीं, जो इनपुट फ़ाइल बदलने पर खिसक जाता है।
finish_reasonजाँचें।max_tokensपर कटा जवाब"ok": trueहै, लेकिन बेकार। DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब से पहले reasoning करते हैं, और reasoning max_tokens में गिनी जाती है। runnerreasoning_effort="low"सेट करता है, जिसे BroadNet दस्तावेज़ित करता है, और 1,500 टोकन छोड़ता है।- हर लाइन पर usage लॉग करें।
results.jsonlसेusageजोड़ने पर असली टोकन बिल मिलता है, जिसे आप अपने अनुमान से मिला सकते हैं।
लागत क्या है: उपयोग के अनुसार भुगतान या प्लान सेशन?
उपयोग के अनुसार भुगतान में लागत टोकन है। मान लें 100,000 रिव्यू, 150 टोकन का सिस्टम प्रॉम्प्ट, 150 टोकन का रिव्यू और कम reasoning के साथ 100 आउटपुट टोकन। यह 30 मिलियन इनपुट और 10 मिलियन आउटपुट टोकन हैं। DeepSeek V4.1 Flash पर इसकी लागत 30 × $0.175 + 10 × $0.52 है। सिस्टम प्रॉम्प्ट पहले और byte-दर-byte एक जैसा रखें, तो जहाँ कैश hit होता है वहाँ उसके 15 मिलियन टोकन $0.0055 प्रति 1M की कैश्ड इनपुट दर पर बिल हो सकते हैं। आपकी usage लाइनें दिखाती हैं कि ऐसा कितनी बार हुआ।
प्लान पर टोकन मुफ़्त हैं और लागत समय है। DeepSeek V4.1 Flash का प्लान सेशन “runs one request at a time” (अनुवाद: एक समय में एक अनुरोध चलाता है), इसलिए हर सेशन के लिए IN_FLIGHT=1 रखें। प्रति सेशन थ्रूपुट 86,400 ÷ प्रति आइटम सेकंड है, प्रति दिन। BroadNet सामान्य स्पीड लगभग 100 टोकन प्रति सेकंड बताता है, लेकिन आपकी लेटेंसी प्रॉम्प्ट की लंबाई और reasoning पर निर्भर है, इसलिए 50 आइटम पर मापें। अगर आप प्रति आइटम 3 सेकंड मापते हैं, तो एक सेशन दिन में 28,800 करता है:
| Job | सेशन | 3 s/आइटम पर समय | प्लान |
|---|---|---|---|
| 100,000 आइटम | 1 | लगभग 3.5 दिन | एक Orbit हफ़्ता, प्रति सेशन $15 |
| 100,000 आइटम | 4 | लगभग 21 घंटे | चार Orbit हफ़्ते, हर सेशन के लिए एक; या प्रति सेशन लगभग 21 Meteor घंटे, हर एक $1 पर |
| 1,000,000 आइटम | 6 | लगभग 6 दिन | छह Orbit हफ़्ते |
प्लान “best effort under fair use” (अनुवाद: fair use के तहत best effort) दिए जाते हैं, और BroadNet प्लान keys के लिए प्रति मिनट अनुरोध सीमा प्रकाशित नहीं करता; लागू सीमाएँ आपके अकाउंट में दिखती हैं। RPM अंदाज़े से नहीं, उन्हीं से सेट करें। सेशन प्लानर गाइड बताती है कि सेशन को keys में कैसे बाँटें।
BroadNet Inference कहाँ फ़िट होता है
BroadNet Inference में Batch API नहीं है, इसलिए यह बड़े jobs के लिए तब सही है जब आप runner पर ख़ुद नियंत्रण रखना और सामान्य प्रति-टोकन कीमत देना पसंद करें, या DeepSeek V4.1 Flash प्लान सेशन से लागत तय करना चाहें। बजट वाले छोटे jobs के लिए Gemma 4 VL 26B, प्रति 1M $0.10 इनपुट और $0.22 आउटपुट पर, $5 के शुरुआती क्रेडिट पर चलता है। हर अनुरोध के बाद प्रॉम्प्ट और आउटपुट नहीं रखे जाते। अगर आपका job एक दिन रुक सकता है और आपके ज़रूरी मॉडल 50% बैच छूट वाले प्रोवाइडर पर हैं, तो वह सस्ता पड़ सकता है; तय करने से पहले तुलना करें। प्लान और सीमाएँ inference.broadnet.ai/plans पर हैं।
