BroadRouter

रीज़निंग मॉडल के लिए max_tokens कैसे तय करें: बजट का तरीक़ा

BroadNet Inference टीम · 6 मिनट में पढ़ें · प्रकाशित

रीज़निंग मॉडल पर max_tokens सोच और जवाब, दोनों को मिलाकर सीमित करता है, इसलिए तंग सीमा दिखने वाले टेक्स्ट से पहले ही जवाब ख़त्म कर सकती है। हर टास्क टाइप के कुल completion टोकन नापें, max_tokens को लगभग 95वें percentile से 20% ऊपर रखें, prompt और max_tokens को कॉन्टेक्स्ट विंडो में रखें, और कटे जवाब को दोगुने बजट से एक तय सीमा तक दोबारा भेजें।

रीज़निंग मॉडल जवाब देने से पहले सोचता है, और ज़्यादातर 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")))

भरोसे लायक़ नंबर के नियम:

  1. हर रन में एक टास्क टाइप। classification, extraction, code review और planning के distribution बहुत अलग होते हैं। एक global max_tokens या तो retry पर पैसा बर्बाद करता है या बेक़ाबू जवाबों को निकल जाने देता है।
  2. 50 या ज़्यादा असली prompt। दस सैंपल का 95वाँ percentile बस सबसे बड़ा सैंपल होता है।
  3. हर उस effort पर चलाएँ जो आप इस्तेमाल करते हैं। reasoning_effort="low" distribution बदल देता है। BroadNet low डॉक्युमेंट करता है; दूसरी वैल्यू पर भरोसा करने से पहले उन्हें टेस्ट करें।
  4. अगर cut_off शून्य नहीं है, तो सीमा बढ़ाकर फिर चलाएँ। कटा हुआ सैंपल अपनी असली लंबाई छिपा लेता है।
  5. मॉडल या 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 सर्वर इस्तेमाल करें जो यह देता हो।

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

मेरा रीज़निंग मॉडल ख़ाली जवाब क्यों देता है?

मॉडल ने जवाब लिखने से पहले पूरा max_tokens बजट छिपी हुई रीज़निंग पर ख़र्च कर दिया। तब finish_reason "length" होता है। max_tokens बढ़ाएँ, reasoning_effort घटाएँ, या दोनों करें। जल्दी ठीक करने वाली एक छोटी गाइड का लिंक इस पोस्ट में है।

रीज़निंग मॉडल के लिए max_tokens कितना रखूँ?

पहले नापें। 50 या ज़्यादा असली prompt ऊँची सीमा के साथ चलाएँ, उस टास्क के completion_tokens का 95वाँ percentile लें और लगभग 20% जोड़ें। BroadNet के डॉक्स न्यूनतम 1,000 या ज़्यादा टोकन बताते हैं; OpenAI अपने मॉडल पर शुरुआत में 25,000 रिज़र्व करने का सुझाव देता है।

क्या ज़्यादा max_tokens रखने से ख़र्च बढ़ता है?

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

क्या max_completion_tokens और max_tokens एक ही हैं?

OpenAI पर max_completion_tokens, deprecated max_tokens की जगह लेता है और साफ़ तौर पर रीज़निंग टोकन शामिल करता है। कई OpenAI-compatible प्रोवाइडर इसकी जगह max_tokens डॉक्युमेंट करते हैं। BroadNet के डॉक्स max_tokens इस्तेमाल करते हैं और कहते हैं कि रीज़निंग उसमें गिनी जाती है।

क्या रीज़निंग को जवाब से अलग सीमित किया जा सकता है?

सिर्फ़ वहाँ जहाँ सर्वर इसे सपोर्ट करता हो। vLLM में thinking_token_budget पैरामीटर है, और कुछ प्रोवाइडरों के अपने पैरामीटर हैं। BroadNet low पर सेट reasoning_effort डॉक्युमेंट करता है, अलग रीज़निंग सीमा नहीं, इसलिए दोनों का बजट साथ तय करें।

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