---
title: "रीज़निंग मॉडल में max_tokens: बजट कैसे तय करें | BroadRouter"
description: "कम max_tokens पर रीज़निंग मॉडल ख़ाली जवाब क्यों देते हैं, और नापे गए percentile, कॉन्टेक्स्ट विंडो और बढ़ते retry से बजट कैसे तय करें।"
url: https://broadrouter.com/hi/blog/reasoning-model-max-tokens-budget/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/reasoning-model-max-tokens-budget/) (2026-11-15 को अपडेट किया गया).

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

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

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

## मुख्य बातें

-   max\_tokens एक सीमा है, शुल्क नहीं। आप बनाए गए टोकन का भुगतान करते हैं, इसलिए जल्दी पूरे होने वाले जवाबों पर ऊँची सीमा का कोई ख़र्च नहीं।
-   पैसा तंग सीमा पर लगता है: कटे हुए जवाब में सोच का बिल बनता है, जवाब नहीं मिलता, और उसे दोबारा भेजना पड़ता है।
-   अपने लॉग से हर टास्क टाइप का बजट तय करें: completion टोकन का 95वाँ percentile और 20% मार्जिन एक ठोस शुरुआत है।
-   prompt टोकन और max\_tokens कॉन्टेक्स्ट विंडो में आने चाहिए: Qwen3.8 27B पर 262,144 टोकन, GLM 5.3 और DeepSeek V4.1 Flash पर 1,048,576।
-   finish\_reason "length" को संकेत मानें: दोगुने बजट या कम reasoning\_effort के साथ, एक पक्की सीमा तक, दोबारा कोशिश करें।

**इस पेज पर**

1.  जवाब से पहले बजट ख़त्म क्यों हो जाता है?
2.  क्या बड़ा max\_tokens ज़्यादा महँगा पड़ता है?
3.  किसी टास्क को कितना चाहिए, यह कैसे नापें?
4.  कॉन्टेक्स्ट विंडो बजट को कैसे सीमित करती है?
5.  अगर जवाब फिर भी कट जाए तो क्या करें?
6.  स्ट्रीमिंग से तस्वीर कैसे बदलती है?
7.  कौन-सा पैरामीटर नाम भेजें?
8.  BroadNet Inference कहाँ फ़िट होता है

रीज़निंग मॉडल जवाब देने से पहले सोचता है, और ज़्यादातर OpenAI-compatible API पर दोनों एक ही बजट से निकलते हैं: `max_tokens`। इसे वैसे सेट करें जैसे बिना रीज़निंग वाले मॉडल के लिए करते, यानी छोटे जवाब के लिए कुछ सौ टोकन, तो कुछ जवाब `finish_reason: "length"` के साथ ख़ाली लौटते हैं। जल्दी वाला हल [रीज़निंग मॉडल ख़ाली जवाब क्यों देता है](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/) में है। यह पोस्ट उस बजट के पीछे का तरीक़ा है जिस पर आप भरोसा कर सकें: नापें, percentile से साइज़ तय करें, कॉन्टेक्स्ट विंडो का ध्यान रखें, और फिर भी कटने वाले जवाबों को संभालें।

रीज़निंग की लागत और उसे घटाने के लिए देखें [रीज़निंग टोकन: जितना दिखता है उससे ज़्यादा आउटपुट का भुगतान क्यों](https://broadrouter.com/hi/blog/reasoning-tokens-cost/)।

## जवाब से पहले बजट ख़त्म क्यों हो जाता है?

मॉडल क्रम से टेक्स्ट बनाता है: पहले अपनी रीज़निंग, फिर दिखने वाला जवाब। दोनों का हर टोकन `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`](https://broadrouter.com/hi/glossary/max-tokens/) एक सीमा है। बिल असल में बने टोकन का बनता है। जिस जवाब को 1,800 टोकन चाहिए, उसकी लागत 4,000 की सीमा पर भी उतनी ही है और 40,000 पर भी।

तंग सीमा का ख़र्च यह है:

| सीमा बनाम ज़रूरत | आप क्या भुगतान करते हैं | आपको क्या मिलता है |
| --- | --- | --- |
| सीमा ज़रूरत से ऊपर | बने हुए टोकन | जवाब |
| सीमा ज़रूरत से नीचे | पूरी सीमा, सारी रीज़निंग में | कुछ भी काम का नहीं, ऊपर से एक retry |

एक उदाहरण लें। मान लीजिए आपकी एक-चौथाई कॉल को 1,000 से ज़्यादा टोकन चाहिए। `max_tokens=1000` पर ऐसी हर कॉल 1,000 आउटपुट टोकन की सोच का बिल बनाती है, कुछ नहीं लौटाती और दोबारा भेजी जाती है। इससे सभी कॉल पर औसतन प्रति कॉल 250 बेकार आउटपुट टोकन जुड़ते हैं, retry के ख़र्च से पहले, और ऊपर से दूसरे अनुरोध की देरी। 4,000 की सीमा पर कुछ बर्बाद नहीं होता। [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) पर आउटपुट की लागत $2.17 प्रति 1M टोकन है, इसलिए बड़ी मात्रा में यह बर्बादी जुड़ती जाती है।

ऊँची सीमा का असली जोखिम बेक़ाबू जवाब है: ऐसा मॉडल जो लूप में फँस जाए या ज़रूरत से कहीं ज़्यादा सोचे और कहीं ज़्यादा टोकन बनाए। एक पक्की सीमा इसे बाँध देती है। वह सीमा डेटा से चुनें, जैसा नीचे बताया गया है।

## किसी टास्क को कितना चाहिए, यह कैसे नापें?

एक टास्क टाइप के असली prompt ऊँची सीमा के साथ चलाएँ, और completion टोकन और रीज़निंग का हिस्सा दर्ज करें। जब मॉडल इसे रिपोर्ट करता है, तो `usage.completion_tokens_details.reasoning_tokens` रीज़निंग वाला हिस्सा देता है; BroadNet के डॉक्स इस फ़ील्ड को लिस्ट करते हैं।

```python
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 रास्ते पर भेजता है। मुफ़्त [रीज़निंग टोकन बजट टूल](https://broadrouter.com/tools/reasoning-token-budget/) आपके नंबर मिलने के बाद यह हिसाब आपके ब्राउज़र में कर देता है।

## कॉन्टेक्स्ट विंडो बजट को कैसे सीमित करती है?

कॉन्टेक्स्ट विंडो में 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](https://broadrouter.com/hi/models/glm-5.3/) | 1,048,576 | 848,576 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/hi/models/deepseek-v4.1-flash/) | 1,048,576 | 848,576 |
| Qwen3.8 27B | 262,144 | 62,144 |

लंबे कॉन्टेक्स्ट वाले काम में यह मायने रखता है। जिस एजेंट की हिस्ट्री Qwen3.8 27B पर 250,000 टोकन तक पहुँच गई है, उसके पास सोच और जवाब के लिए सिर्फ़ लगभग 12,000 टोकन बचे हैं। लंबे कॉन्टेक्स्ट वाले टास्क को आम तौर पर ज़्यादा रीज़निंग भी चाहिए, इसलिए बची जगह कॉल के समय जाँचें, सिर्फ़ शुरुआत में एक बार नहीं। [कॉन्टेक्स्ट विंडो](https://broadrouter.com/hi/glossary/context-window/) और [कॉन्टेक्स्ट विंडो कैलकुलेटर](https://broadrouter.com/tools/context-window-calculator/) यह हिसाब समझाते हैं।

## अगर जवाब फिर भी कट जाए तो क्या करें?

हर कॉल पर `finish_reason` जाँचें। अगर वह `length` है, तो जवाब ग़ायब या अधूरा है, भले ही `content` में कुछ टेक्स्ट हो। उसे पूरा मानकर parse न करें; कटा हुआ JSON ऑब्जेक्ट आगे के एरर की आम वजह है ([structured output](https://broadrouter.com/hi/blog/structured-output-json-schema/))।

कॉन्टेक्स्ट जितनी जगह दे, उसके अंदर, एक पक्की सीमा तक, दोगुने बजट से दोबारा कोशिश करें:

```python
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](https://broadrouter.com/hi/blog/long-running-agents-timeouts-retries/) में है।

## स्ट्रीमिंग से तस्वीर कैसे बदलती है?

`stream=True` के साथ रीज़निंग पहले दिखने वाले टोकन से पहले होती है, इसलिए शुरुआत में रीज़निंग मॉडल अटका हुआ लग सकता है। चैट UI में content आने तक “thinking” वाली स्थिति दिखाएँ, और क्लाइंट के timeout सोचने के समय के हिसाब से रखें, सिर्फ़ जवाब के हिसाब से नहीं।

कुछ सर्वर रीज़निंग का टेक्स्ट भी एक अलग फ़ील्ड में स्ट्रीम करते हैं। इसका नाम मानक नहीं है: DeepSeek का अपना API `reasoning_content` इस्तेमाल करता है, और vLLM ने अपने फ़ील्ड का नाम `reasoning_content` से बदलकर `reasoning` कर दिया, यह चेतावनी देते हुए कि पुराना क्लाइंट कोड “could silently read an empty” (अनुवाद: चुपचाप एक ख़ाली) फ़ील्ड पढ़ सकता है। BroadNet के डॉक्स किसी रीज़निंग टेक्स्ट फ़ील्ड को डॉक्युमेंट नहीं करते, इसलिए अपने मॉडल का कच्चा रिस्पॉन्स जाँचे बिना ऐसे फ़ील्ड पर फ़ीचर न बनाएँ। अगर पढ़ें, तो सावधानी से पढ़ें:

```python
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 डॉक्युमेंट करता है। स्ट्रीम के बारे में और जानकारी [स्ट्रीमिंग गाइड](https://broadrouter.com/hi/guides/streaming-chat-completions/) और [SSE की व्याख्या](https://broadrouter.com/hi/blog/llm-streaming-sse-explained/) में है।

## कौन-सा पैरामीटर नाम भेजें?

| 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` | हाँ |

प्रोवाइडर बदलते समय कोड में वही नाम भेजें जो प्रोवाइडर डॉक्युमेंट करता है, और एक टेस्ट कॉल से पक्का करें कि सीमा लागू होती है। चुपचाप नज़रअंदाज़ की गई सीमा तब तक ठीक लगती है जब तक कोई बेक़ाबू जवाब नहीं आता। बदलने वाले बाक़ी पैरामीटर [माइग्रेशन चेकलिस्ट](https://broadrouter.com/hi/blog/openai-compatible-api-migration-checklist/) में हैं।

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

BroadNet के तीनों रीज़निंग मॉडल, जब मॉडल देता है, `usage` में रीज़निंग टोकन रिपोर्ट करते हैं, इसलिए ऊपर वाला नाप जैसा लिखा है वैसा ही काम करता है। DeepSeek V4.1 Flash और GLM 5.3 सबसे ज़्यादा जगह देते हैं, 1,048,576 टोकन के कॉन्टेक्स्ट के साथ। Qwen3.8 27B में 262,144 है। अगर किसी टास्क के लिए रीज़निंग नहीं चाहिए, तो [Gemma 4 VL 26B](https://broadrouter.com/hi/models/gemma-4-vl-26b/) रीज़निंग मॉडल के रूप में लिस्ट नहीं है और बजट का सवाल ही नहीं उठता। फ़्लैट [DeepSeek V4.1 Flash प्लान](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/) पर सोच वाले टोकन का प्रति-टोकन शुल्क नहीं लगता, लेकिन कटे जवाब फिर भी समय लेते हैं, इसलिए वही बजटिंग लागू होती है। BroadNet अलग रीज़निंग सीमा डॉक्युमेंट नहीं करता; अगर आपको चाहिए, तो ऐसा प्रोवाइडर या self-hosted सर्वर इस्तेमाल करें जो यह देता हो।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[रीज़निंग टोकन (reasoning tokens)](https://broadrouter.com/hi/glossary/reasoning-tokens/)

रीज़निंग टोकन वे टोकन हैं जो रीज़निंग मॉडल अपना दिखने वाला जवाब लिखने से पहले किसी समस्या को हल करने के लिए बनाता है। इनका बिल आम तौर पर आउटपुट टोकन की तरह बनता है, ये आउटपुट लिमिट और कॉन्टेक्स्ट विंडो में गिने जाते हैं, और API इन्हें छिपा सकता है या इनका सारांश दे सकता है।

[कॉन्टेक्स्ट विंडो (context window)](https://broadrouter.com/hi/glossary/context-window/)

कॉन्टेक्स्ट विंडो टोकन की वह अधिकतम संख्या है जिसके साथ लैंग्वेज मॉडल एक अनुरोध में काम कर सकता है। इसमें प्रॉम्प्ट, बातचीत का इतिहास, टूल डेफ़िनिशन, इमेज और जनरेट हुआ आउटपुट, रीज़निंग टोकन समेत, सब आता है। जो इसमें न समाए, उसे काटना, सारांश बनाना या कई अनुरोधों में बाँटना पड़ता है।

[इनपुट और आउटपुट टोकन (input and output tokens)](https://broadrouter.com/hi/glossary/input-and-output-tokens/)

इनपुट टोकन वे टोकन हैं जिन्हें लैंग्वेज मॉडल किसी अनुरोध में पढ़ता है, जिनमें सिस्टम प्रॉम्प्ट, बातचीत का इतिहास, टूल डेफ़िनिशन और इमेज शामिल हैं। आउटपुट टोकन वे हैं जो वह जवाब में बनाता है, रीज़निंग समेत। LLM API आम तौर पर दोनों की कीमत अलग रखते हैं, और आउटपुट आम तौर पर महँगा होता है।

[max\_tokens (आउटपुट टोकन सीमा)](https://broadrouter.com/hi/glossary/max-tokens/)

max\_tokens एक LLM API पैरामीटर है जो तय करता है कि मॉडल एक जवाब में ज़्यादा से ज़्यादा कितने टोकन जनरेट कर सकता है। सीमा पर पहुँचते ही जनरेशन रुक जाता है और जवाब को कटा हुआ चिह्नित किया जाता है, जैसे finish\_reason को "length" पर सेट करके।

[Chat Completions API](https://broadrouter.com/hi/glossary/chat-completions-api/)

Chat Completions API, OpenAI का HTTP एंडपॉइंट POST /v1/chat/completions है, जो एक मॉडल का नाम और रोल वाले मैसेज की सूची लेता है और मॉडल का अगला मैसेज लौटाता है। इसके अनुरोध और जवाब का ढाँचा वह आम फ़ॉर्मैट बन गया जिसे OpenAI-कम्पैटिबल प्रोवाइडर और SDK अपनाते हैं।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[स्ट्रक्चर्ड आउटपुट (structured output)](https://broadrouter.com/hi/glossary/structured-output/)

स्ट्रक्चर्ड आउटपुट LLM API का एक फ़ीचर है जो मॉडल के जवाब को डेवलपर के तय फ़ॉर्मैट, आम तौर पर JSON Schema, तक सीमित करता है, ताकि कोड उसे भरोसे से पार्स कर सके। यह JSON mode से सख़्त है, जो मान्य JSON की गारंटी देता है, लेकिन किसी ख़ास ढाँचे की नहीं।

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

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

मॉडल ने जवाब लिखने से पहले पूरा 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 डॉक्युमेंट करता है, अलग रीज़निंग सीमा नहीं, इसलिए दोनों का बजट साथ तय करें।

## आगे पढ़ें

-   [रीज़निंग टोकन: दिखने से ज़्यादा आउटपुट का भुगतान क्यों होता है](https://broadrouter.com/hi/blog/reasoning-tokens-cost/)
-   [LLM स्ट्रीमिंग समझें: SSE चंक, डेल्टा, usage और कैंसल](https://broadrouter.com/hi/blog/llm-streaming-sse-explained/)
-   [JSON mode बनाम json\_schema: भरोसेमंद स्ट्रक्चर्ड आउटपुट](https://broadrouter.com/hi/blog/structured-output-json-schema/)
-   [लंबे चलने वाले एजेंट: टिकाऊ timeout, retry और checkpoint](https://broadrouter.com/hi/blog/long-running-agents-timeouts-retries/)
-   [OpenAI-कम्पैटिबल API पर माइग्रेट करना: पूरी चेकलिस्ट](https://broadrouter.com/hi/blog/openai-compatible-api-migration-checklist/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: रीज़निंग मॉडल ख़ाली जवाब क्यों लौटाता है](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)
-   [गाइड: chat completions स्ट्रीम करें और टूटे कनेक्शन सँभालें](https://broadrouter.com/hi/guides/streaming-chat-completions/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-reasoning-model-max-tokens-budget&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस: रीज़निंग max\_tokens में गिनी जाती है, 1,000 या ज़्यादा टोकन, reasoning\_effort low, usage फ़ील्ड (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-reasoning-model-max-tokens-budget&utm_content=sources)
-   [BroadNet pricing.json फ़ील्ड रेफ़रंस: context\_length में prompt और जवाब दोनों आते हैं (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-reasoning-model-max-tokens-budget&utm_content=sources#pricing-json)
-   [OpenAI reasoning गाइड: अधूरे रिस्पॉन्स, शुरुआत में कम से कम 25,000 टोकन रिज़र्व करें (जाँचा गया 2026-11-15)](https://developers.openai.com/api/docs/guides/reasoning)
-   [OpenAI Chat Completions रेफ़रंस: max\_completion\_tokens में रीज़निंग टोकन शामिल हैं; max\_tokens deprecated (जाँचा गया 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [DeepSeek API डॉक्स, thinking mode: reasoning\_content फ़ील्ड, effort लेवल (जाँचा गया 2026-11-15)](https://api-docs.deepseek.com/guides/thinking_mode)
-   [vLLM डॉक्स, reasoning outputs: reasoning फ़ील्ड (पहले reasoning\_content), thinking\_token\_budget (जाँचा गया 2026-11-15)](https://docs.vllm.ai/en/latest/features/reasoning_outputs.html)
