रीज़निंग मॉडल जवाब देने से पहले सोचता है, और ज़्यादातर OpenAI-compatible API पर दोनों एक ही बजट से निकलते हैं: max_tokens। इसे वैसे सेट करें जैसे बिना रीज़निंग वाले मॉडल के लिए करते, यानी छोटे जवाब के लिए कुछ सौ टोकन, तो कुछ जवाब finish_reason: "length" के साथ ख़ाली लौटते हैं। जल्दी वाला हल रीज़निंग मॉडल ख़ाली जवाब क्यों देता है में है। यह पोस्ट उस बजट के पीछे का तरीक़ा है जिस पर आप भरोसा कर सकें: नापें, percentile से साइज़ तय करें, कॉन्टेक्स्ट विंडो का ध्यान रखें, और फिर भी कटने वाले जवाबों को संभालें।
रीज़निंग की लागत और उसे घटाने के लिए देखें रीज़निंग टोकन: जितना दिखता है उससे ज़्यादा आउटपुट का भुगतान क्यों।
जवाब से पहले बजट ख़त्म क्यों हो जाता है?
मॉडल क्रम से टेक्स्ट बनाता है: पहले अपनी रीज़निंग, फिर दिखने वाला जवाब। दोनों का हर टोकन max_tokens में गिना जाता है। BroadNet के डॉक्स DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B के लिए यही कहते हैं: “the reasoning counts toward max_tokens” (अनुवाद: रीज़निंग max_tokens में गिनी जाती है), और छोटी सीमा पर “the answer comes back empty” (अनुवाद: जवाब ख़ाली लौटता है)। OpenAI का Chat Completions रेफ़रंस max_completion_tokens को इसी तरह परिभाषित करता है, एक ऊपरी सीमा के रूप में “including visible output tokens and reasoning tokens” (अनुवाद: दिखने वाले आउटपुट टोकन और रीज़निंग टोकन समेत)।
इसलिए पूछने वाला सवाल “मेरा जवाब कितना लंबा है?” नहीं है। सवाल है: “इस टास्क पर, इस effort पर, रीज़निंग और जवाब मिलाकर कितने लंबे हैं?” यह लोगों की उम्मीद से ज़्यादा बदलता है। OpenAI की गाइड कहती है कि समस्या के हिसाब से उसके मॉडल “anywhere from a few hundred to tens of thousands of reasoning tokens” (अनुवाद: कुछ सौ से लेकर दसियों हज़ार तक रीज़निंग टोकन) बना सकते हैं।
क्या बड़ा max_tokens ज़्यादा महँगा पड़ता है?
नहीं। बजट बहुत तंग रखने की यही सबसे आम वजह है। max_tokens एक सीमा है। बिल असल में बने टोकन का बनता है। जिस जवाब को 1,800 टोकन चाहिए, उसकी लागत 4,000 की सीमा पर भी उतनी ही है और 40,000 पर भी।
तंग सीमा का ख़र्च यह है:
| सीमा बनाम ज़रूरत | आप क्या भुगतान करते हैं | आपको क्या मिलता है |
|---|---|---|
| सीमा ज़रूरत से ऊपर | बने हुए टोकन | जवाब |
| सीमा ज़रूरत से नीचे | पूरी सीमा, सारी रीज़निंग में | कुछ भी काम का नहीं, ऊपर से एक retry |
एक उदाहरण लें। मान लीजिए आपकी एक-चौथाई कॉल को 1,000 से ज़्यादा टोकन चाहिए। max_tokens=1000 पर ऐसी हर कॉल 1,000 आउटपुट टोकन की सोच का बिल बनाती है, कुछ नहीं लौटाती और दोबारा भेजी जाती है। इससे सभी कॉल पर औसतन प्रति कॉल 250 बेकार आउटपुट टोकन जुड़ते हैं, retry के ख़र्च से पहले, और ऊपर से दूसरे अनुरोध की देरी। 4,000 की सीमा पर कुछ बर्बाद नहीं होता। Qwen3.8 27B पर आउटपुट की लागत $2.17 प्रति 1M टोकन है, इसलिए बड़ी मात्रा में यह बर्बादी जुड़ती जाती है।
ऊँची सीमा का असली जोखिम बेक़ाबू जवाब है: ऐसा मॉडल जो लूप में फँस जाए या ज़रूरत से कहीं ज़्यादा सोचे और कहीं ज़्यादा टोकन बनाए। एक पक्की सीमा इसे बाँध देती है। वह सीमा डेटा से चुनें, जैसा नीचे बताया गया है।
किसी टास्क को कितना चाहिए, यह कैसे नापें?
एक टास्क टाइप के असली prompt ऊँची सीमा के साथ चलाएँ, और completion टोकन और रीज़निंग का हिस्सा दर्ज करें। जब मॉडल इसे रिपोर्ट करता है, तो usage.completion_tokens_details.reasoning_tokens रीज़निंग वाला हिस्सा देता है; BroadNet के डॉक्स इस फ़ील्ड को लिस्ट करते हैं।
import os
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"
def measure(prompts, ceiling=16_000, **kw):
"""Run real prompts with a generous ceiling and return per-call token counts."""
rows = []
for p in prompts:
r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
messages=[{"role": "user", "content": p}], **kw)
u, d = r.usage, r.usage.completion_tokens_details
reasoning = (d.reasoning_tokens or 0) if d else 0
rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
"finish": r.choices[0].finish_reason})
return rows
def pct(values, q):
values = sorted(values)
return values[min(len(values) - 1, int(q * len(values)))]
def recommend(rows, margin=1.2):
total = [r["reasoning"] + r["answer"] for r in rows]
return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
"max_tokens": int(pct(total, 0.95) * margin),
"cut_off": sum(r["finish"] == "length" for r in rows)}
# print(recommend(measure(my_prompts))) # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))
भरोसे लायक़ नंबर के नियम:
- हर रन में एक टास्क टाइप। classification, extraction, code review और planning के distribution बहुत अलग होते हैं। एक global
max_tokensया तो retry पर पैसा बर्बाद करता है या बेक़ाबू जवाबों को निकल जाने देता है। - 50 या ज़्यादा असली prompt। दस सैंपल का 95वाँ percentile बस सबसे बड़ा सैंपल होता है।
- हर उस effort पर चलाएँ जो आप इस्तेमाल करते हैं।
reasoning_effort="low"distribution बदल देता है। BroadNetlowडॉक्युमेंट करता है; दूसरी वैल्यू पर भरोसा करने से पहले उन्हें टेस्ट करें। - अगर
cut_offशून्य नहीं है, तो सीमा बढ़ाकर फिर चलाएँ। कटा हुआ सैंपल अपनी असली लंबाई छिपा लेता है। - मॉडल या prompt बदलने पर फिर चलाएँ। नया मॉडल वर्शन कम या ज़्यादा सोच सकता है।
फिर recommend() से हर टास्क का max_tokens तय करें। 95वाँ percentile और 20% ज़्यादातर कॉल को सीमा से काफ़ी नीचे रखता है और सिर्फ़ कभी-कभार आने वाली लंबी कॉल को नीचे दिए retry रास्ते पर भेजता है। मुफ़्त रीज़निंग टोकन बजट टूल आपके नंबर मिलने के बाद यह हिसाब आपके ब्राउज़र में कर देता है।
कॉन्टेक्स्ट विंडो बजट को कैसे सीमित करती है?
कॉन्टेक्स्ट विंडो में prompt और जवाब, दोनों साथ आते हैं। BroadNet की प्राइस फ़ीड context_length को “the most tokens one request can hold, prompt and answer together” (अनुवाद: एक अनुरोध में ज़्यादा से ज़्यादा जितने टोकन आ सकते हैं, prompt और जवाब मिलाकर) बताती है। इसलिए:
max_tokens ≤ context length − prompt tokens
| मॉडल | कॉन्टेक्स्ट | 200,000 टोकन के prompt के साथ max_tokens की जगह |
|---|---|---|
| GLM 5.3 | 1,048,576 | 848,576 |
| DeepSeek V4.1 Flash | 1,048,576 | 848,576 |
| Qwen3.8 27B | 262,144 | 62,144 |
लंबे कॉन्टेक्स्ट वाले काम में यह मायने रखता है। जिस एजेंट की हिस्ट्री Qwen3.8 27B पर 250,000 टोकन तक पहुँच गई है, उसके पास सोच और जवाब के लिए सिर्फ़ लगभग 12,000 टोकन बचे हैं। लंबे कॉन्टेक्स्ट वाले टास्क को आम तौर पर ज़्यादा रीज़निंग भी चाहिए, इसलिए बची जगह कॉल के समय जाँचें, सिर्फ़ शुरुआत में एक बार नहीं। कॉन्टेक्स्ट विंडो और कॉन्टेक्स्ट विंडो कैलकुलेटर यह हिसाब समझाते हैं।
अगर जवाब फिर भी कट जाए तो क्या करें?
हर कॉल पर finish_reason जाँचें। अगर वह length है, तो जवाब ग़ायब या अधूरा है, भले ही content में कुछ टेक्स्ट हो। उसे पूरा मानकर parse न करें; कटा हुआ JSON ऑब्जेक्ट आगे के एरर की आम वजह है (structured output)।
कॉन्टेक्स्ट जितनी जगह दे, उसके अंदर, एक पक्की सीमा तक, दोगुने बजट से दोबारा कोशिश करें:
import json, urllib.request
FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}
def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
"""Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
while True:
r = client.chat.completions.create(model=model, messages=messages,
max_tokens=budget, **kw)
if r.choices[0].finish_reason != "length":
return r
room = CONTEXT[model] - r.usage.prompt_tokens # context holds prompt + answer
nxt = min(budget * 2, hard_cap, room)
if nxt <= budget:
raise RuntimeError(f"still cut off at max_tokens={budget}")
print(f"cut off at {budget}, retrying with {nxt}")
budget = nxt
टास्क के हिसाब से, दोगुना करने के दो विकल्प:
- उसी बजट के साथ
reasoning_effort="low"पर retry करें। आसान टास्क पर मॉडल अक्सर ज़रूरत से ज़्यादा सोचता है, और कम effort बड़ी सीमा के बिना इसे ठीक कर देता है। - टास्क को बाँट दें। अगर कोई जवाब बार-बार ऊँची सीमा से टकराता है, तो आम तौर पर अनुरोध एक साथ बहुत ज़्यादा माँग रहा होता है।
हर कटे जवाब को टास्क टाइप के साथ लॉग करें। बढ़ती दर का मतलब है कि prompt, मॉडल या इनपुट डेटा बदल गया है, और बजट फिर से नापना होगा। retry नए inference हैं और उनका बिल फिर बनता है, इसलिए कोशिशों की गिनती सीमित रखें, जैसा लंबे चलने वाले एजेंट: timeout और retry में है।
स्ट्रीमिंग से तस्वीर कैसे बदलती है?
stream=True के साथ रीज़निंग पहले दिखने वाले टोकन से पहले होती है, इसलिए शुरुआत में रीज़निंग मॉडल अटका हुआ लग सकता है। चैट UI में content आने तक “thinking” वाली स्थिति दिखाएँ, और क्लाइंट के timeout सोचने के समय के हिसाब से रखें, सिर्फ़ जवाब के हिसाब से नहीं।
कुछ सर्वर रीज़निंग का टेक्स्ट भी एक अलग फ़ील्ड में स्ट्रीम करते हैं। इसका नाम मानक नहीं है: DeepSeek का अपना API reasoning_content इस्तेमाल करता है, और vLLM ने अपने फ़ील्ड का नाम reasoning_content से बदलकर reasoning कर दिया, यह चेतावनी देते हुए कि पुराना क्लाइंट कोड “could silently read an empty” (अनुवाद: चुपचाप एक ख़ाली) फ़ील्ड पढ़ सकता है। BroadNet के डॉक्स किसी रीज़निंग टेक्स्ट फ़ील्ड को डॉक्युमेंट नहीं करते, इसलिए अपने मॉडल का कच्चा रिस्पॉन्स जाँचे बिना ऐसे फ़ील्ड पर फ़ीचर न बनाएँ। अगर पढ़ें, तो सावधानी से पढ़ें:
for chunk in stream:
if chunk.choices:
delta = chunk.choices[0].delta
thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
# log or display `thinking` only if your provider actually sends it
if delta.content:
print(delta.content, end="")
elif chunk.usage: # last chunk, with include_usage
print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))
आख़िरी chunk में usage के लिए stream_options={"include_usage": True} चाहिए, जिसे BroadNet डॉक्युमेंट करता है। स्ट्रीम के बारे में और जानकारी स्ट्रीमिंग गाइड और SSE की व्याख्या में है।
कौन-सा पैरामीटर नाम भेजें?
| API | पैरामीटर | रीज़निंग शामिल |
|---|---|---|
| OpenAI Chat Completions | max_completion_tokens (max_tokens deprecated) |
हाँ |
| OpenAI Responses | max_output_tokens |
हाँ |
| BroadNet Inference (Chat Completions) | max_tokens, जैसा डॉक्युमेंट किया गया है |
हाँ |
| vLLM सर्वर | max_tokens, साथ में वैकल्पिक thinking_token_budget |
हाँ |
प्रोवाइडर बदलते समय कोड में वही नाम भेजें जो प्रोवाइडर डॉक्युमेंट करता है, और एक टेस्ट कॉल से पक्का करें कि सीमा लागू होती है। चुपचाप नज़रअंदाज़ की गई सीमा तब तक ठीक लगती है जब तक कोई बेक़ाबू जवाब नहीं आता। बदलने वाले बाक़ी पैरामीटर माइग्रेशन चेकलिस्ट में हैं।
BroadNet Inference कहाँ फ़िट होता है
BroadNet के तीनों रीज़निंग मॉडल, जब मॉडल देता है, usage में रीज़निंग टोकन रिपोर्ट करते हैं, इसलिए ऊपर वाला नाप जैसा लिखा है वैसा ही काम करता है। DeepSeek V4.1 Flash और GLM 5.3 सबसे ज़्यादा जगह देते हैं, 1,048,576 टोकन के कॉन्टेक्स्ट के साथ। Qwen3.8 27B में 262,144 है। अगर किसी टास्क के लिए रीज़निंग नहीं चाहिए, तो Gemma 4 VL 26B रीज़निंग मॉडल के रूप में लिस्ट नहीं है और बजट का सवाल ही नहीं उठता। फ़्लैट DeepSeek V4.1 Flash प्लान पर सोच वाले टोकन का प्रति-टोकन शुल्क नहीं लगता, लेकिन कटे जवाब फिर भी समय लेते हैं, इसलिए वही बजटिंग लागू होती है। BroadNet अलग रीज़निंग सीमा डॉक्युमेंट नहीं करता; अगर आपको चाहिए, तो ऐसा प्रोवाइडर या self-hosted सर्वर इस्तेमाल करें जो यह देता हो।
