BroadRouter

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

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

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

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

JSON mode और json_schema में से चुनना JSON mode बनाम json_schema में है। यह पोस्ट उस जवाब के बारे में है जो आपको असल में मिला।

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

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

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

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

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

क्योंकि रिपेयर किया हुआ वर्ज़न सही दिखता है, पर होता नहीं। हमने json_repair 0.64.9, एक लोकप्रिय MIT-लाइसेंस वाली लाइब्रेरी, एक ऐसे जवाब पर चलाई जो शब्द के बीच में कटा था:

'{"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 तक पहुँच गया। वही अनुरोध उसी सीमा के साथ दोबारा भेजने पर वैसे ही फ़ेल होगा, इसलिए सीमा दोगुनी करें या हर कॉल में कम माँगें। रीज़निंग मॉडल से यह और आम हो जाता है: BroadNet का API रेफ़रंस कहता है कि DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब देने से पहले रीज़निंग करते हैं, और रीज़निंग max_tokens में गिनी जाती है। छोटी सीमा पर जवाब ख़ाली आ सकता है। 1,000 या ज़्यादा टोकन छोड़ें, या reasoning_effort को low करें; संख्याएँ रीज़निंग बजट वाली पोस्ट में हैं।

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

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

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 पैकेज से वैलिडेट करता है और कारण के हिसाब से रीट्राई चुनता है:

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’” मॉडल को ठीक करने के लिए कुछ ठोस देता है। ख़ाली रीट्राई अक्सर वही ग़लती दोहराता है।
  • कोशिशें तीन तक सीमित रखें। हर रीट्राई पूरी बातचीत को इनपुट टोकन के रूप में दोबारा भेजता है। तीन के बाद इनपुट लॉग करें और उसे कहीं और भेजें।
  • रिपेयर की सूची लॉग करें। प्रॉम्प्ट बदलने के बाद “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-कम्पैटिबल सर्वर अलग-अलग हैं, इसलिए जो मॉडल आप शिप करते हैं उस पर मोड टेस्ट करें। टेस्ट स्ट्रक्चर्ड आउटपुट वाली पोस्ट में है।

किसी जवाब को हाथ से जाँचने के लिए उसे LLM JSON आउटपुट वैलिडेटर में पेस्ट करें, या JSON schema जनरेटर से एक सैंपल ऑब्जेक्ट से सख़्त स्कीमा बनाएँ।

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

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

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

मेरा 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 इस्तेमाल करें।

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

स्रोत