---
title: "LLM का टूटा JSON ठीक करें: कारण, रिपेयर और रीट्राई | BroadRouter"
description: "LLM टूटा JSON क्यों लौटाते हैं (कोड फ़ेंस, गद्य, max_tokens पर कटाव, ट्रेलिंग कॉमा), और टेस्ट किया Python फ़ंक्शन जो सुरक्षित चीज़ें ठीक करे, बाक़ी ठुकराए।"
url: https://broadrouter.com/hi/blog/fix-invalid-json-from-llm/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/fix-invalid-json-from-llm/) (2026-11-16 को अपडेट किया गया).

# LLM का अमान्य JSON कैसे ठीक करें: कारण, रिपेयर, रीट्राई

BroadNet Inference टीम · 7 मिनट में पढ़ें · प्रकाशित 2026-11-15 · अपडेट किया गया 2026-11-16

पहले finish\_reason जाँचें: max\_tokens पर कटा जवाब सुरक्षित रूप से ठीक नहीं हो सकता, इसलिए सीमा बढ़ाकर दोबारा भेजें। वरना कोड फ़ेंस और आसपास का गद्य हटाएँ, पहली JSON वैल्यू डिकोड करें, फिर सिर्फ़ ट्रेलिंग कॉमा जैसी साफ़ ग़लतियाँ ठीक करें। स्कीमा से वैलिडेट करें, और फ़ेल हो तो सटीक एरर एक-दो बार वापस भेजें। जहाँ सपोर्ट हो, स्ट्रक्चर्ड आउटपुट इनमें से ज़्यादातर रोकता है।

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

-   ज़्यादातर टूटा JSON असल में ग़लत JSON नहीं, बल्कि लपेटन है: कोड फ़ेंस, पहले या बाद में एक वाक्य, या रीज़निंग ब्लॉक। Python का raw\_decode पहली वैल्यू पढ़ता है और बाक़ी को अनदेखा करता है।
-   finish\_reason "length" का मतलब है JSON कट गया। ब्रैकेट बंद करने से वह पार्स तो हो जाता है, लेकिन डेटा चुपचाप खो जाता है, इसलिए ज़्यादा जगह देकर दोबारा भेजें।
-   सिर्फ़ वही ठीक करें जिसका एक ही मतलब हो: ट्रेलिंग कॉमा, Python-स्टाइल True/None और सिंगल कोट। बाक़ी सब ठुकराएँ और दोबारा माँगें।
-   Python का json मॉड्यूल डिफ़ॉल्ट रूप से NaN और Infinity स्वीकार करता है; RFC 8259 नहीं करता। इन्हें ठुकराएँ, वरना आगे के दूसरे पार्सर फ़ेल होंगे।
-   BroadNet Inference पर सिर्फ़ GLM 5.3 और Qwen3.8 27B स्ट्रक्चर्ड आउटपुट दर्ज करते हैं। बाक़ी मॉडल पर सिर्फ़-प्रॉम्प्ट JSON के साथ यह रिपेयर और वैलिडेशन इस्तेमाल करें।

**इस पेज पर**

1.  LLM अमान्य JSON क्यों लौटाते हैं?
2.  कटे हुए JSON को रिपेयर क्यों न करें?
3.  एक रिपेयर फ़ंक्शन जो सिर्फ़ सुरक्षित मामले ठीक करता है
4.  रिपेयर फ़ेल होने के बाद रीट्राई कैसे करें?
5.  क्या स्ट्रक्चर्ड आउटपुट से यह सब बेकार हो जाता है?
6.  BroadNet Inference कहाँ फ़िट होता है

आपका कोड मॉडल के जवाब पर `json.loads()` चलाता है और `JSONDecodeError: Expecting value: line 1 column 1` मिलता है। या वह पार्स हो जाता है, लेकिन जहाँ आपको नंबर चाहिए था वहाँ एक फ़ील्ड स्ट्रिंग है। यह पोस्ट कारणों को इस हिसाब से छाँटती है कि हर एक के साथ आप सुरक्षित रूप से क्या कर सकते हैं, एक टेस्ट किया हुआ Python फ़ंक्शन देती है जो सिर्फ़ साफ़ मामलों को ठीक करता है, और एक रीट्राई लूप दिखाती है जो जानता है कि कब रीट्राई से कुछ नहीं होगा।

[JSON mode](https://broadrouter.com/hi/glossary/json-mode/) और `json_schema` में से चुनना [JSON mode बनाम json\_schema](https://broadrouter.com/hi/blog/structured-output-json-schema/) में है। यह पोस्ट उस जवाब के बारे में है जो आपको असल में मिला।

## LLM अमान्य JSON क्यों लौटाते हैं?

मॉडल एक-एक टोकन करके टेक्स्ट लिखता है। जब तक सर्वर डिकोडिंग को बाँधता नहीं, तब तक उसे एक दोस्ताना वाक्य जोड़ने या जगह ख़त्म होने से कोई नहीं रोकता। आम गड़बड़ियाँ:

| आपको क्या दिखता है | कारण | क्या कोड में ठीक करना सुरक्षित है? |
| --- | --- | --- |
| ` ```json ` … ` ``` ` ऑब्जेक्ट के चारों ओर | चैट फ़ॉर्मैटिंग की आदत | हाँ: फ़ेंस हटाएँ |
| पहले “Here is the JSON:”, बाद में “Let me know…” | वही आदत | हाँ: सिर्फ़ पहली वैल्यू पढ़ें |
| ऑब्जेक्ट से पहले `<think>...</think>` | कुछ सर्वर पर content फ़ील्ड में रीज़निंग टेक्स्ट | हाँ: ब्लॉक हटाएँ |
| स्ट्रिंग के बीच में ख़त्म, ब्रैकेट खुले | `max_tokens` तक पहुँचा | नहीं: ज़्यादा जगह के साथ दोबारा भेजें |
| ख़ाली content | रीज़निंग ने पूरा बजट ले लिया | नहीं: ज़्यादा जगह के साथ दोबारा भेजें |
| `{"a": 1,}` | ट्रेलिंग कॉमा; JavaScript इसकी अनुमति देता है, [RFC 8259](https://www.rfc-editor.org/rfc/rfc8259) नहीं | हाँ: एक ही मतलब |
| `{'a': True, 'b': None}` | Python सिंटैक्स | हाँ: `ast.literal_eval` इसे सुरक्षित पढ़ता है |
| `NaN`, `Infinity` | JSON नहीं; Python डिफ़ॉल्ट रूप से स्वीकार करता है | नहीं: ठुकराएँ |
| वैध JSON, ग़लत टाइप या ग़ायब फ़ील्ड | स्कीमा लागू नहीं | नहीं: एरर के साथ दोबारा माँगें |

बँटवारे की लकीर अस्पष्टता है। अगर मॉडल का मतलब बिल्कुल एक ही हो सकता था, तो उसे कोड में ठीक करें और लॉग करें कि आपने ठीक किया। अगर अंदाज़ा लगाना पड़े, तो जवाब ठुकरा दें।

## कटे हुए JSON को रिपेयर क्यों न करें?

क्योंकि रिपेयर किया हुआ वर्ज़न सही दिखता है, पर होता नहीं। हमने [json\_repair](https://github.com/mangiucugna/json_repair) 0.64.9, एक लोकप्रिय MIT-लाइसेंस वाली लाइब्रेरी, एक ऐसे जवाब पर चलाई जो शब्द के बीच में कटा था:

```text
'{"name": "Omar", "city": "Jed'  ->  {'name': 'Omar', 'city': 'Jed'}
```

इसने शहर “Jed” के साथ वैध JSON लौटाया। इसका README यह खुलकर कहता है: यह “automatically completes missing values in JSON fields with reasonable defaults” (अनुवाद: JSON फ़ील्ड में ग़ायब वैल्यू को अपने-आप उचित डिफ़ॉल्ट से पूरा करता है)। लॉग पढ़ने के लिए यह काम का है। जिस डेटा को आप सहेजते हैं या जिस पर कार्रवाई करते हैं, उसके लिए यह दिखने वाली गड़बड़ी को छिपी गड़बड़ी बना देता है।

पार्स करने से पहले `finish_reason` जाँचें। `"length"` का मतलब है कि जवाब [`max_tokens`](https://broadrouter.com/hi/glossary/max-tokens/) तक पहुँच गया। वही अनुरोध उसी सीमा के साथ दोबारा भेजने पर वैसे ही फ़ेल होगा, इसलिए सीमा दोगुनी करें या हर कॉल में कम माँगें। रीज़निंग मॉडल से यह और आम हो जाता है: BroadNet का [API रेफ़रंस](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-fix-invalid-json-from-llm&utm_content=body) कहता है कि DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब देने से पहले रीज़निंग करते हैं, और रीज़निंग `max_tokens` में गिनी जाती है। छोटी सीमा पर जवाब ख़ाली आ सकता है। 1,000 या ज़्यादा टोकन छोड़ें, या `reasoning_effort` को `low` करें; संख्याएँ [रीज़निंग बजट वाली पोस्ट](https://broadrouter.com/hi/blog/reasoning-model-max-tokens-budget/) में हैं।

## एक रिपेयर फ़ंक्शन जो सिर्फ़ सुरक्षित मामले ठीक करता है

यह सिर्फ़ स्टैंडर्ड लाइब्रेरी इस्तेमाल करता है। यह पार्स की गई वैल्यू और किए गए रिपेयर की सूची लौटाता है, ताकि आप उन्हें गिन सकें।

```python
import ast, json, re

class Truncated(Exception): pass
class NotJSON(Exception): pass

FENCE = re.compile(r"```(?:json|JSON)?\s*\n(.*?)```", re.S)
THINK = re.compile(r"<think>.*?</think>", re.S)

def _reject_constant(name):                 # NaN, Infinity: Python accepts them, JSON does not
    raise NotJSON(f"non-standard constant {name}")

_decoder = json.JSONDecoder(parse_constant=_reject_constant)

def _first_value(s):
    """Decode the first JSON object or array in s, ignoring prose before and after it."""
    for i, ch in enumerate(s):
        if ch in "{[":
            try:
                return _decoder.raw_decode(s, i)[0]
            except json.JSONDecodeError:
                continue                    # a stray brace in prose; try the next one
    raise NotJSON("no JSON object or array found")

def _scan(s):
    """Drop commas before } or ] outside strings; report brackets left open."""
    out, stack, in_str, esc = [], [], False, False
    for i, ch in enumerate(s):
        if in_str:
            if esc:
                esc = False
            elif ch == "\\":
                esc = True
            elif ch == '"':
                in_str = False
        elif ch == '"':
            in_str = True
        elif ch in "{[":
            stack.append(ch)
        elif ch in "}]" and stack:
            stack.pop()
        elif ch == ",":
            rest = s[i + 1:].lstrip()
            if rest[:1] in ("}", "]"):
                continue                    # trailing comma: skip it
        out.append(ch)
    return "".join(out), len(stack) + (1 if in_str else 0)

def _python_literal(s):
    """Output in Python syntax: single quotes, True/False/None, trailing commas."""
    start = min((i for i in (s.find("{"), s.find("[")) if i >= 0), default=-1)
    end = max(s.rfind("}"), s.rfind("]"))
    if start < 0 or end <= start:
        raise NotJSON("no braces")
    value = ast.literal_eval(s[start:end + 1])       # literals only; never runs code
    if not isinstance(value, (dict, list)):
        raise NotJSON("not an object or array")
    json.dumps(value, allow_nan=False)               # must round-trip as strict JSON
    return value

def parse_llm_json(content, finish_reason=None):
    """Return (value, repairs). Raises Truncated or NotJSON."""
    if finish_reason == "length":
        raise Truncated("hit max_tokens; raise the limit or shorten the output")
    if not content or not content.strip():
        raise NotJSON("empty content (reasoning may have used the whole budget)")
    repairs = []
    s = content.strip().lstrip("\ufeff")
    if THINK.search(s):
        s = THINK.sub("", s).strip(); repairs.append("removed <think> block")
    m = FENCE.search(s)
    if m:
        s = m.group(1).strip(); repairs.append("removed code fence")
    try:
        value = _decoder.decode(s)
        return value, repairs
    except json.JSONDecodeError:
        pass
    try:
        value = _first_value(s); repairs.append("ignored text around JSON")
        return value, repairs
    except NotJSON:
        pass
    fixed, open_count = _scan(s)
    if open_count:
        raise NotJSON(f"incomplete JSON, {open_count} bracket(s) or string left open: treat as truncated")
    if fixed != s:
        try:
            value = _first_value(fixed); repairs.append("removed trailing commas")
            return value, repairs
        except NotJSON:
            pass
    try:
        value = _python_literal(s); repairs.append("parsed Python-style literal")
        return value, repairs
    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError, NotJSON) as e:
        raise NotJSON(f"unrepairable: {e}") from None
```

हर चरण कैसे काम करता है:

1.  **कटे और ख़ाली जवाब** पार्सिंग से पहले ही एरर उठाते हैं, इसलिए वे कभी डेटा नहीं बनते।
2.  **फ़ेंस और रीज़निंग ब्लॉक** दो रेगुलर एक्सप्रेशन से हटाए जाते हैं।
3.  **`raw_decode`** मुख्य औज़ार है। Python की डॉक्स कहती हैं कि यह डॉक्यूमेंट को “from a string that may have extraneous data at the end” (अनुवाद: ऐसी स्ट्रिंग से जिसके अंत में फ़ालतू डेटा हो सकता है) डिकोड करता है, और बताता है कि कहाँ रुका। पहले `{` या `[` से शुरू करके यह ऑब्जेक्ट से पहले का गद्य छोड़ देता है और बाद का अनदेखा करता है। अगर गद्य में कोई ब्रेस डिकोड नहीं होता, तो यह अगला आज़माता है।
4.  **ब्रैकेट स्कैन** स्ट्रिंग और एस्केप पर नज़र रखते हुए टेक्स्ट से गुज़रता है। खुले रह गए ब्रैकेट का मतलब है कि जवाब कटा था, भले `finish_reason` ने ऐसा न कहा हो; इस पर एरर उठता है। स्ट्रिंग के बाहर `}` या `]` से ठीक पहले वाले कॉमा हटा दिए जाते हैं।
5.  **`ast.literal_eval`** सिंगल कोट, `True` और `None` वाला Python-स्टाइल आउटपुट पढ़ता है। यह सिर्फ़ लिटरल का मूल्यांकन करता है और कभी कोड नहीं चलाता। फिर नतीजे को सख़्त JSON के रूप में सीरियलाइज़ होना ज़रूरी है।
6.  **`NaN` और `Infinity`** `parse_constant` के ज़रिए एरर उठाते हैं। Python का `json` इन्हें डिफ़ॉल्ट रूप से स्वीकार करता है; RFC 8259 कहता है कि ये “are not permitted” (अनुवाद: अनुमति नहीं है), और JavaScript का `JSON.parse` इन्हें ठुकराता है।

हमने इसे 17 टेस्ट स्ट्रिंग पर चलाया: साफ़ JSON, फ़ेंस वाला JSON, फ़ेंस में अरबी key और वैल्यू, पहले और बाद में गद्य, ऑब्जेक्ट से पहले गद्य में `{name}` प्लेसहोल्डर, एक `<think>` ब्लॉक, ऑब्जेक्ट और ऐरे में ट्रेलिंग कॉमा, स्ट्रिंग के अंदर कॉमा और ब्रैकेट, एस्केप किए गए कोट, बैकस्लैश पर ख़त्म होने वाला Windows पाथ, Python लिटरल, `NaN`, ख़ाली जवाब, `finish_reason: "length"` के साथ और उसके बिना कटा जवाब, और लगातार दो ऑब्जेक्ट। सबने ऊपर की टेबल के मुताबिक़ व्यवहार किया। एक टेस्ट ने असली बग पकड़ा: एक शुरुआती वर्ज़न बंद होने वाले कोट की जाँच से पहले अपना एस्केप फ़्लैग पलट देता था, इसलिए `"he said \"hi,]\""` का कॉमा खो जाता था। अपने रिपेयर कोड को एस्केप किए गए कोट पर ज़रूर टेस्ट करें।

दो सीमाएँ जान लें। लगातार दो ऑब्जेक्ट मिलें, तो यह पहला लौटाता है; अगर आपको कई आइटम चाहिए, तो एक JSON ऐरे माँगें। और सिंगल कोट वाला Python आउटपुट, जिसकी किसी स्ट्रिंग में डबल कोट हो, ब्रैकेट स्कैन में ग़लत पढ़ा जाकर ठुकराया जा सकता है। ठुकराना सुरक्षित तरह की नाकामी है।

## रिपेयर फ़ेल होने के बाद रीट्राई कैसे करें?

रिपेयर फ़ॉर्मैट सँभालता है। वैलिडेशन कंटेंट सँभालता है: सही फ़ील्ड, सही टाइप, समझदार वैल्यू। यह लूप `jsonschema` पैकेज से वैलिडेट करता है और कारण के हिसाब से रीट्राई चुनता है:

```python
import json, os
from jsonschema import Draft202012Validator
from openai import OpenAI
from llm_json import parse_llm_json, Truncated, NotJSON

client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                api_key=os.environ["BROADNET_API_KEY"])
SCHEMA = {"type": "object", "additionalProperties": False,
          "required": ["name", "city", "amount"],
          "properties": {"name": {"type": "string", "minLength": 1},
                         "city": {"type": ["string", "null"]},
                         "amount": {"type": "number", "minimum": 0}}}
validator = Draft202012Validator(SCHEMA)

def extract(text, model="broadnet/qwen3.8-27b", max_tokens=1500, attempts=3, log=print):
    messages = [{"role": "system", "content": "Extract name, city and amount. Reply with one JSON object only, no code fence. "
                                              "Schema: " + json.dumps(SCHEMA)},
                {"role": "user", "content": text}]
    for attempt in range(1, attempts + 1):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens,
                                           reasoning_effort="low", temperature=0)
        c = r.choices[0]
        try:
            value, repairs = parse_llm_json(c.message.content, c.finish_reason)
            errors = [f"{'/'.join(map(str, e.path)) or '(root)'}: {e.message}" for e in validator.iter_errors(value)]
            if not errors:
                log({"attempt": attempt, "repairs": repairs, "ok": True})
                return value
            problem = "The JSON does not match the schema: " + "; ".join(errors)
        except Truncated:
            log({"attempt": attempt, "ok": False, "why": "truncated"})
            max_tokens *= 2                 # same prompt, more room; a re-ask would be cut off too
            continue
        except NotJSON as e:
            problem = f"That reply was not valid JSON ({e})."
        log({"attempt": attempt, "ok": False, "why": problem})
        messages += [{"role": "assistant", "content": c.message.content or ""},
                     {"role": "user", "content": problem + " Return the corrected JSON object only."}]
    raise RuntimeError(f"no valid JSON after {attempts} attempts")
```

उस लूप के नियम:

-   **कटा हुआ: वही मैसेज दोगुनी सीमा के साथ दोबारा भेजें।** “please fix” वाला मैसेज जोड़ने से प्रॉम्प्ट लंबा होगा और आउटपुट छोटा नहीं होगा।
-   **JSON नहीं, या ग़लत ढाँचा: सटीक एरर वापस भेजें।** “amount: ‘1200’ is not of type ‘number’” मॉडल को ठीक करने के लिए कुछ ठोस देता है। ख़ाली रीट्राई अक्सर वही ग़लती दोहराता है।
-   **कोशिशें तीन तक सीमित रखें।** हर रीट्राई पूरी बातचीत को [इनपुट टोकन](https://broadrouter.com/hi/glossary/input-and-output-tokens/) के रूप में दोबारा भेजता है। तीन के बाद इनपुट लॉग करें और उसे कहीं और भेजें।
-   **रिपेयर की सूची लॉग करें।** प्रॉम्प्ट बदलने के बाद “removed code fence” की बढ़ती गिनती बताती है कि प्रॉम्प्ट बिगड़ गया, भले कुछ फ़ेल न हुआ हो।

हमने यह लूप एक लोकल मॉक सर्वर पर चलाया, जो तय किए हुए जवाब लौटाता था। ट्रेलिंग कॉमा और स्ट्रिंग के रूप में `"amount": "1200"` वाला फ़ेंस्ड जवाब रिपेयर हुआ, वैलिडेशन में फ़ेल हुआ, और एरर वापस भेजने पर दूसरी कॉल में ठीक हो गया। `finish_reason: "length"` के साथ कटा जवाब `max_tokens` को 1,500 से 3,000 करके दोबारा भेजा गया और सफल रहा। मॉक ने हर बार अनुरोध रिकॉर्ड किया, जिससे पुष्टि हुई कि लूप ने कितने मैसेज और कौन सी सीमा भेजी। असली मॉडल अलग तरह से फ़ेल हो सकता है, इसलिए संख्याओं पर भरोसा करने से पहले इसे अपने 100 इनपुट पर चलाएँ।

## क्या स्ट्रक्चर्ड आउटपुट से यह सब बेकार हो जाता है?

यह ज़्यादातर हटा देता है। जो सर्वर डिकोडिंग को आपके स्कीमा से बाँधता है, वह फ़ेंस, ट्रेलिंग कॉमा या ग़ायब फ़ील्ड नहीं निकाल सकता। vLLM, ओपन मॉडल का एक आम सर्वर, यह xgrammar या guidance बैकएंड से करता है। फिर भी दो गड़बड़ियाँ बचती हैं: `max_tokens` पर कटाव, और इनकार। OpenAI बताता है कि JSON mode का आउटपुट वैध होता है “except for in some edge cases” (अनुवाद: कुछ ख़ास स्थितियों को छोड़कर) और आपके ऐप्लिकेशन को ऐसा आउटपुट जो पूरा ऑब्जेक्ट नहीं है, “must detect and handle” (अनुवाद: पहचानना और सँभालना होगा)। इसलिए `json_schema` के साथ भी `finish_reason` की जाँच और वैलिडेटर रखें।

हर तरीक़ा क्या रोकता है:

| तरीक़ा | फ़ेंस और गद्य | सिंटैक्स एरर | ग़लत ढाँचा | कटाव |
| --- | --- | --- | --- | --- |
| सिर्फ़ प्रॉम्प्ट (“JSON में जवाब दें”) | कम | कम | कम | नहीं |
| JSON mode (`json_object`) | हाँ | हाँ | नहीं | नहीं |
| स्ट्रक्चर्ड आउटपुट (`json_schema`, लागू) | हाँ | हाँ | हाँ | नहीं |

JSON mode के साथ OpenAI यह भी कहता है कि आपको किसी मैसेज में “must always instruct the model to produce JSON” (अनुवाद: मॉडल को हमेशा JSON बनाने का निर्देश देना होगा); वरना वह टोकन सीमा तक व्हाइटस्पेस निकाल सकता है। दूसरे OpenAI-कम्पैटिबल सर्वर अलग-अलग हैं, इसलिए जो मॉडल आप शिप करते हैं उस पर मोड टेस्ट करें। टेस्ट [स्ट्रक्चर्ड आउटपुट वाली पोस्ट](https://broadrouter.com/hi/blog/structured-output-json-schema/) में है।

किसी जवाब को हाथ से जाँचने के लिए उसे [LLM JSON आउटपुट वैलिडेटर](https://broadrouter.com/tools/llm-json-output-validator/) में पेस्ट करें, या [JSON schema जनरेटर](https://broadrouter.com/tools/json-schema-generator/) से एक सैंपल ऑब्जेक्ट से सख़्त स्कीमा बनाएँ।

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

BroadRouter, BroadNet की साइट है। BroadNet का API रेफ़रंस स्ट्रक्चर्ड आउटपुट सिर्फ़ [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) और [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) के लिए दिखाता है, और अनुरोध पैरामीटर का नाम नहीं बताता, इसलिए उस पर निर्भर होने से पहले मॉडल पर `json_schema` टेस्ट करें। [DeepSeek V4.1 Flash](https://broadrouter.com/hi/models/deepseek-v4.1-flash/) और [Gemma 4 VL 26B](https://broadrouter.com/hi/models/gemma-4-vl-26b/) पर ऊपर के रिपेयर फ़ंक्शन और वैलिडेटर के साथ सिर्फ़-प्रॉम्प्ट JSON इस्तेमाल करें। चार में से तीन मॉडल जवाब से पहले रीज़निंग करते हैं, इसलिए `max_tokens` में उसका बजट रखें। बड़ी मात्रा में एक्सट्रैक्शन के लिए [बैच रनर वाली पोस्ट](https://broadrouter.com/hi/blog/llm-batch-processing-without-batch-api/) दिखाती है कि हर आइटम का `finish_reason` कैसे लॉग करें। हर अनुरोध के बाद प्रॉम्प्ट और जवाब रखे नहीं जाते।

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

-   [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/)

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

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

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

[JSON मोड (JSON mode)](https://broadrouter.com/hi/glossary/json-mode/)

JSON मोड, LLM API की एक सेटिंग है, OpenAI जैसे API में response\_format {"type": "json\_object"}, जो मॉडल के जवाब को वैलिड और पार्स होने लायक़ JSON बनाती है। JSON Schema वाले स्ट्रक्चर्ड आउटपुट के उलट, यह गारंटी नहीं देती कि ऑब्जेक्ट में कौन-सी keys, टाइप या वैल्यू होंगी।

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

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

[Prefill और decode](https://broadrouter.com/hi/glossary/prefill-and-decode/)

Prefill और decode LLM इन्फ़रेंस के दो चरण हैं। Prefill में मॉडल पूरा प्रॉम्प्ट समानांतर रूप से प्रोसेस करके अपना KV cache भरता है; decode में वह उसी cache को दोबारा इस्तेमाल करते हुए जवाब एक-एक टोकन करके बनाता है। Prefill मुख्य रूप से पहले टोकन तक का समय तय करता है; decode आउटपुट की रफ़्तार।

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

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

[JSON Schema (JSON स्कीमा)](https://broadrouter.com/hi/glossary/json-schema/)

JSON Schema, JSON में लिखी एक शब्दावली है, जो JSON डेटा की बनावट बताती और जाँचती है: टाइप, ज़रूरी फ़ील्ड, स्वीकार्य वैल्यू और नेस्टिंग। मौजूदा वर्ज़न 2020-12 है। LLM API इससे टूल पैरामीटर तय करते हैं, और वह सटीक आकार भी जिसका स्ट्रक्चर्ड आउटपुट को पालन करना है।

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

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

[ओपन-वेट मॉडल (open-weight model)](https://broadrouter.com/hi/glossary/open-weight-model/)

ओपन-वेट मॉडल ऐसा मशीन लर्निंग मॉडल है जिसके ट्रेन किए weights सबके डाउनलोड करने और चलाने के लिए प्रकाशित होते हैं, आम तौर पर शर्तों वाले लाइसेंस के साथ। यह पूरी तरह ओपन-सोर्स AI से अलग है, जो ट्रेनिंग कोड और ट्रेनिंग डेटा की विस्तृत जानकारी भी जारी करता है, ताकि दूसरे मॉडल को समझ और दोबारा बना सकें।

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

### मेरा LLM मार्कडाउन कोड ब्लॉक के अंदर JSON क्यों लौटाता है?

चैट मॉडल आम तौर पर कोड को इंसानों के लिए फ़ॉर्मैट करते हैं, और चैट इंटरफ़ेस कोड फ़ेंस से ही कोड दिखाते हैं। “सिर्फ़ JSON, कोड फ़ेंस नहीं” माँगें, लेकिन कोड में फ़ेंस फिर भी हटाएँ: निर्देश से ऐसा कम होता है, ख़त्म नहीं होता।

### LLM आउटपुट पर JSONDecodeError कैसे ठीक करें?

पहले finish\_reason देखें। अगर वह "length" है, तो जवाब कट गया: max\_tokens बढ़ाएँ और दोबारा भेजें। नहीं तो कोड फ़ेंस हटाएँ और raw\_decode से पहली JSON वैल्यू डिकोड करें, जो उसके बाद के टेक्स्ट को अनदेखा करता है। ट्रेलिंग कॉमा ठीक करें, फिर वैलिडेट करें। फिर भी फ़ेल हो तो एरर के साथ दोबारा माँगें।

### क्या JSON रिपेयर लाइब्रेरी इस्तेमाल करनी चाहिए?

लॉग और डिबगिंग के लिए, हाँ। जिस डेटा पर आप कार्रवाई करते हैं, उसके लिए सावधान रहें। json\_repair जैसी लाइब्रेरी ग़ायब वैल्यू डिफ़ॉल्ट से पूरी करती हैं, इसलिए कटा हुआ शहर "Jed" एक वैध "Jed" बनकर लौटता है। कटे आउटपुट को ठुकराएँ और दोबारा भेजें।

### मेरा LLM JSON आउटपुट बीच में क्यों कट जाता है?

जवाब max\_tokens तक पहुँच गया। DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जैसे रीज़निंग मॉडल पर रीज़निंग उसी सीमा में गिनी जाती है, इसलिए लंबी थिंकिंग के बाद बहुत कम जगह बच सकती है। सीमा बढ़ाएँ, reasoning\_effort low करें, या हर कॉल में कम आउटपुट माँगें।

### क्या JSON mode वैध JSON की गारंटी देता है?

लगभग। OpenAI कहता है कि JSON mode का आउटपुट वैध JSON होता है "except for in some edge cases" (अनुवाद: कुछ ख़ास स्थितियों को छोड़कर), जैसे टोकन सीमा तक पहुँचना, और यह आपका स्कीमा लागू नहीं करता। json\_schema वाला स्ट्रक्चर्ड आउटपुट स्कीमा का पालन जोड़ता है, जहाँ प्रोवाइडर उसे लागू करता है। दोनों में वैलिडेट करें।

### BroadNet के कौन से मॉडल स्ट्रक्चर्ड आउटपुट सपोर्ट करते हैं?

BroadNet का API रेफ़रंस GLM 5.3 और Qwen3.8 27B के लिए स्ट्रक्चर्ड आउटपुट दिखाता है, 15 नवंबर 2026 को जाँचा गया। DeepSeek V4.1 Flash या Gemma 4 VL 26B के लिए यह नहीं दिखता, इसलिए उन पर रिपेयर और वैलिडेशन के साथ सिर्फ़-प्रॉम्प्ट JSON इस्तेमाल करें।

## आगे पढ़ें

-   [JSON mode बनाम json\_schema: भरोसेमंद स्ट्रक्चर्ड आउटपुट](https://broadrouter.com/hi/blog/structured-output-json-schema/)
-   [ओपन मॉडल के साथ टूल कॉलिंग: स्कीमा, पैरेलल कॉल, रीट्राई](https://broadrouter.com/hi/blog/tool-calling-open-models/)
-   [रीज़निंग मॉडल के लिए max\_tokens कैसे तय करें: बजट का तरीक़ा](https://broadrouter.com/hi/blog/reasoning-model-max-tokens-budget/)
-   [LLM से अरबी टेक्स्ट classification: sentiment, intent, triage](https://broadrouter.com/hi/blog/arabic-text-classification-llm/)
-   [Batch API के बिना LLM बैच प्रोसेसिंग: दोबारा शुरू होने वाला runner](https://broadrouter.com/hi/blog/llm-batch-processing-without-batch-api/)
-   [LLM से ऐप strings का अरबी अनुवाद: placeholders और plurals](https://broadrouter.com/hi/blog/translate-app-strings-to-arabic-llm/)
-   [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/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)
-   [गाइड: विज़न मॉडल से अरबी इनवॉइस और रसीदें पढ़ें](https://broadrouter.com/hi/guides/read-arabic-invoices-with-vision/)

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

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-fix-invalid-json-from-llm&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस: टूल और स्ट्रक्चर्ड आउटपुट सिर्फ़ GLM 5.3 और Qwen3.8 27B के लिए सूचीबद्ध; DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B रीज़निंग करते हैं, और रीज़निंग max\_tokens में गिनी जाती है (2026-11-16 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-fix-invalid-json-from-llm&utm_content=sources)
-   [OpenAI Structured Outputs गाइड: JSON mode बनाम स्कीमा का पालन, मॉडल को JSON बनाने का निर्देश, टोकन सीमा तक व्हाइटस्पेस, अधूरा आउटपुट, इनकार (2026-11-15 को जाँचा गया)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [IETF RFC 8259, The JSON Data Interchange Format: ऑब्जेक्ट व्याकरण, डबल-कोट स्ट्रिंग, Infinity और NaN की अनुमति नहीं (2026-11-15 को जाँचा गया)](https://www.rfc-editor.org/rfc/rfc8259)
-   [Python डॉक्यूमेंटेशन, json मॉड्यूल: JSONDecoder.raw\_decode, NaN और Infinity डिफ़ॉल्ट रूप से स्वीकार, parse\_constant (2026-11-15 को जाँचा गया)](https://docs.python.org/3/library/json.html)
-   [GitHub पर json\_repair (MIT): ख़राब JSON ठीक करता है और ग़ायब वैल्यू डिफ़ॉल्ट से भरता है (वर्ज़न 0.64.9 टेस्ट किया; 2026-11-15 को जाँचा गया)](https://github.com/mangiucugna/json_repair)
-   [vLLM डॉक्यूमेंटेशन, स्ट्रक्चर्ड आउटपुट: xgrammar या guidance बैकएंड के साथ json\_schema, regex, choice और grammar (2026-11-15 को जाँचा गया)](https://docs.vllm.ai/en/latest/features/structured_outputs.html)
