LLM का JSON बीच में कट जाए तो: पहले रुकने की वजह देखें, फिर मरम्मत की बात करें
मुख्य बात: मॉडल किसी मान के बीच में JSON काट देता है और पार्सर सिर्फ़ कॉलम नंबर देता है। ब्रैकेट बंद करने से वह फिर पार्स होने लगता है, पर तब हर खोया हुआ फ़ील्ड डेटा के अंदर छिप जाता है। यह लेख वह सीमा खींचता है कि ट्रंकेशन मरम्मत ईमानदारी से क्या लौटा सकती है और क्या दोबारा माँगना ही पड़ेगा।

कट जाना कोई सिंटैक्स एरर नहीं, खोया हुआ डेटा है। सिंटैक्स ठीक हो सकता है, कटाव सिर्फ़ आंशिक रूप से लौटाया जा सकता है। जिस पल टूल खाली जगह भर देता है, उसी पल बाक़ी खाली जगह पार्सिंग एरर होना बंद कर देती है और ऐसी चीज़ बन जाती है जिसके बारे में किसी को पता नहीं।
कटाव कैसा दिखता है: एक कॉलम नंबर काफ़ी नहीं
मॉडल आपकी स्कीमा के हिसाब से JSON लिखता है, आउटपुट की सीमा पर पहुँचता है, और टेक्स्ट रुक जाता है। इसे Python 3.11 के json मॉड्यूल को दें:
{"scores": {"clarity": 8, "depth": 7}, "items": [{"name": "a", "qty": 2}, {"name": "b", "qty"
json.loads फेंकता है Expecting ':' delimiter, col 94। कॉलम उस "qty" कुंजी की ओर इशारा करता है जिसका कोई मान नहीं, पर असली वजह यह है कि दस्तावेज़ का कोई अंत ही नहीं। "} जोड़ने वाला लालची रेगुलर एक्सप्रेशन फ़ेल होता है; स्ट्रिंग-सजग स्टैक क्लोज़िंग (छठा भाग) पार्स करा देती है, पर items में दो ही रिकॉर्ड बचते हैं और आधा लिखा तीसरा रिकॉर्ड खो जाता है। कॉलम नंबर बताता है टेक्स्ट कहाँ रुका। यह कभी नहीं बताता कि कितना खोया।
यही सामान्य JSON एरर से पहला असली फ़र्क़ है। ज़्यादा कॉमा की एक साफ़ अंतिम अवस्था है: हटाओ और दस्तावेज़ पूरा। कटाव में वह अवस्था नहीं है। ठीक करने पर भी वह टुकड़ा ही रहता है।
कटाव सिंटैक्स की ख़राबी नहीं: मरम्मत टूल का अंधा कोना
jsonrepair जैसे टूल सिंटैक्स से टूटे JSON को मान्य JSON बना देते हैं: markdown फ़ेंस हटाना, आख़िरी कॉमा, सिंगल कोट बदलना। वहाँ इरादा पूरा होता है और मरम्मत सिर्फ़ सफ़ाई है। कटा हुआ इनपुट उसी टूल को टूटे JSON जैसा दिखता है, इसलिए वह खुली स्ट्रिंग, ऐरे और ऑब्जेक्ट बंद कर के कुछ पार्स होने लायक लौटा देता है। Claude की 83 कटी रिपोर्टों में टूल ने 79 "ठीक" कीं, सिर्फ़ 4 ज़ोर से फ़ेल हुईं। एरर मॉनिटरिंग ने असलियत से बीस गुना कम दर देखी।
मरम्मत के बाद आउटपुट कैसा दिखता है? सवाल 6 का फ़ीडबैक आधे वाक्य पर रुका, सवाल 7 से 9 मौजूद ही नहीं, next_steps ऐरे ग़ायब। Pydantic फिर भी वैलिडेशन पास कर देता है, क्योंकि next_steps का डिफ़ॉल्ट [] है और लिस्ट पर कोई लंबाई-सीमा नहीं। हर परत अपना काम ठीक कर रही है। प्रोडक्ट एक भरोसेमंद पर ग़लत रिपोर्ट निकाल रहा है।
कटाव के रास्ते पर सिंटैक्स मरम्मत रखिए और वह चुपचाप सफ़ाई से गढ़ने में बदल जाती है। इसलिए सीमा पहले: मरम्मत टूल सिर्फ़ पूरे जवाब की फ़ॉर्मैट गंदगी संभालता है; कटा हुआ जवाब उस तक पहुँचना ही नहीं चाहिए। फ़ॉर्मैट गंदगी के लिए देखें JSON मरम्मत गाइड।
पहला कदम हमेशा रुकने की वजह
सभी बड़े API मेटाडेटा में बताते हैं कि जनरेशन क्यों रुका, मुफ़्त में। यह LLM इंटीग्रेशन की सबसे अनदेखी कोड लाइन भी है। Anthropic stop_reason देता है, OpenAI का चैट API finish_reason: max_tokens मतलब कट गया, end_turn या stop मतलब मॉडल ने ख़ुद पूरा किया।
resp = client.messages.create(model=MODEL, max_tokens=4096, ...)
if resp.stop_reason != "end_turn":
raise TruncatedOutput(
f"stop_reason={resp.stop_reason}, "
f"output_tokens={resp.usage.output_tokens}"
)
data = json.loads(resp.content[0].text)
जब कटाव स्पष्ट अपवाद बन जाता है, तो रीट्राई रास्ते का ट्रिगर और मॉनिटरिंग का अलर्ट स्रोत दोनों मिल जाते हैं। वे 83 रिपोर्टें बाद में लॉग में stop_reason फ़ील्ड पर एक क्वेरी से मिलीं — जो लॉग हमेशा सहेजे जाते थे पर कभी पढ़े नहीं गए। Gemini length और incomplete से यही बताता है; नया प्रोवाइडर जोड़ते समय मैपिंग टेबल देखें, अंदाज़ा न लगाएँ।
max_tokens सुरक्षा घेरा है, बजट नहीं
सीधी वजह आम तौर पर पुराने प्रोडक्ट वर्ज़न के लिए रखी गई सीमा होती है: 1500 टोकन, जो लंबे सेशन आते ही लंबी रिपोर्टों का 39% काट देती थी। वह सीमा बढ़ाना मुफ़्त है। बिलिंग असल में बने टोकन पर होती है, इसलिए 1100 टोकन की रिपोर्ट पर 4096 की सीमा 1500 जितनी ही लागत लेती है। सीमा बेलगाम आउटपुट रोकने के लिए है, पैसा बचाने के लिए नहीं।
डेटा से तय करें: एक हफ़्ते का असली वितरण देखें, p99 लें और कुछ जगह छोड़ें। उस घटना की टीम ने 4096 चुना क्योंकि मरम्मत के बाद p99 2350 था। दूसरी दिशा है आउटपुट को ही छोटा करना। समरूप ऐरे में दोहराई गई कुंजियाँ बहुत टोकन खाती हैं; कॉल से पहले टेबुलर एन्कोडिंग (देखें TOON फ़ॉर्मैट गाइड) उस मात्रा को घटा देती है जो सीमा के नीचे आनी है।
स्कीमा का फ़ील्ड क्रम तय करता है क्या कटेगा
मॉडल JSON ऊपर से नीचे लिखता है। बजट ख़त्म होने पर properties सूची का आख़िरी सदस्य पहले जाता है। summary, per_question_feedback, scores, next_steps क्रम वाली स्कीमा पहले scores खोती है, ठीक वही हिस्सा जिसका लोग हर हफ़्ते स्क्रीनशॉट लेकर तुलना करते हैं। सुधार है पुनर्व्यवस्था: छोटे ज़रूरी फ़ील्ड आगे, लंबा दोबारा बनने वाला विवरण बाद में, मुक्त टेक्स्ट सबसे आख़िर में।
प्रोवाइडर का व्यवहार भी उसी कटाव का नतीजा बदल देता है:
| प्रोवाइडर | संरचित आउटपुट की व्यवस्था | कटने पर व्यवहार |
|---|---|---|
| OpenAI | response_format के साथ strict: true |
सैंपलिंग स्तर पर गारंटी, पर सबसे सँकरी बोली; अक्सर जनरेट करने से मना कर देता है |
| Anthropic | tool use में input_schema |
डिकोडिंग के दौरान कोई गारंटी नहीं; अधूरे ब्रैकेट लौटा सकता है |
| Gemini | MIME JSON के साथ responseSchema |
डिकोडर सिर्फ़ enum और टाइप थोपता है; कटाव फिर भी संभव |
"संरचित आउटपुट चालू है, वैलिडेशन की ज़रूरत नहीं" एक भ्रम है। प्रोवाइडर की गारंटी जितनी ढीली, आपको अपनी स्कीमा वैलिडेशन और रीट्राई लूप उतना ही ज़्यादा चाहिए। वह कॉन्ट्रैक्ट टेस्ट कैसे बनाएँ, यह JSON Schema कॉन्ट्रैक्ट टेस्टिंग में है।
जब आंशिक बचाव सचमुच ज़रूरी हो: स्ट्रिंग-सजग स्टैक क्लोज़िंग
कुछ मामले टुकड़े से कुछ निकालने पर मजबूर करते हैं: स्ट्रीमिंग प्रीव्यू, डिग्रेडेड रिस्पॉन्स, इंसानी समीक्षा की कतार। वहाँ क्लोज़िंग मरम्मत की सीढ़ी की आख़िरी पायदान है और उसकी दो शर्तें हैं। पहली, ब्रैकेट स्कैन स्ट्रिंग-सजग हो: कोट और escape की स्थिति अक्षर दर अक्षर ट्रैक करें, वरना मान के अंदर का { स्टैक बिगाड़ देता है। दूसरी, बंद करने से पहले अधूरी कुंजी-मान जोड़ी हटाएँ। बिना मान वाली "qty" कुंजी को {"qty"} बना कर बंद नहीं कर सकते; पूरी जोड़ी हटानी होगी।
def close_truncated(s: str) -> str:
# 1) स्ट्रिंग-सजग स्कैन; पहले खुली स्ट्रिंग बंद करें
out, in_str, esc = [], False, False
for ch in s:
out.append(ch)
if esc: esc = False; continue
if ch == '\\' and in_str: esc = True; continue
if ch == '"': in_str = not in_str
text = ''.join(out) + ('"' if in_str else '')
# 2) अधूरी जोड़ी और लटकते कोलन या कॉमा हटाएँ
text = re.sub(r',\s*"[^"]*"\s*$', '', text)
text = re.sub(r'[{,]\s*"[^"]*"\s*:\s*$', '}', text)
text = re.sub(r':\s*$', '', text)
text = re.sub(r',\s*$', '', text)
# 3) स्टैक फिर स्कैन करें और LIFO से बंद करें
stack, in_str, esc = [], False, False
for ch in text:
if esc: esc = False; continue
if ch == '\\' and in_str: esc = True; continue
if ch == '"': in_str = not in_str; continue
if not in_str:
if ch in '{[': stack.append(ch)
elif ch in '}]' and stack: stack.pop()
return text + ''.join('}' if c == '{' else ']' for c in reversed(stack))
लेख के शुरू के इनपुट पर यह कोड Python 3.11 और सिर्फ़ स्टैंडर्ड लाइब्रेरी से लौटाता है {"scores": {...}, "items": [{"name": "a", "qty": 2}, {"name": "b"}]}। यह पार्स होता है, और तीसरा रिकॉर्ड खोया हुआ है। लोकल मॉडल की ओर partial-json-parser जैसी ख़ास लाइब्रेरी वही करती हैं: स्टैक से बंद करो, पूर्णता के हिसाब से काटो।
असली बात खुलासा है। क्लोज़िंग फ़ंक्शन को बताना चाहिए कि नतीजा किस पायदान से आया; truncation पायदान से निकली हर चीज़ आंशिक नतीजा है और उसे लेबल करना ही होगा: खोया हिस्सा दोबारा माँगें, बड़ी सीमा से फिर कोशिश करें, या उपयोगकर्ता को बताएँ कि डेटा अधूरा है। कुछ नहीं हुआ ऐसा दिखावा करना डिटर्मिनिस्टिक कोड से भ्रम पैदा करना है।
मरम्मत या रीट्राई: सीमा की तालिका
| इनपुट का रूप | सही कदम | वजह |
|---|---|---|
| फ़ेंस, आख़िरी कॉमा, सिंगल कोट | मरम्मत टूल | इरादा पूरा, सिर्फ़ सिंटैक्स गंदा |
| स्ट्रिंग के बीच कटा | रीट्राई या खुलासे के साथ आंशिक बचाव | मान ख़ुद खो गया |
| ढाँचे के बीच कटा | खुलासे के साथ आंशिक बचाव | पूरे फ़ील्ड रहते हैं, आधी जोड़ी हटानी पड़ती है |
| पार्स होता है पर ग़लत लगता है | बिज़नेस वैलिडेशन | कटाव नहीं, पर अक्सर साथ आता है |
एक फ़ाइनांस टीम ने लागत नापी। लंबा इनवॉइस कटा, ब्रैकेट बंद करने से मान्य JSON बना, खोए total फ़ील्ड ने डिफ़ॉल्ट 0 ले लिया, और 98.2% फ़ॉर्मैट अनुपालन वाला सिस्टम महीने में क़रीब 200 ग़लत इनवॉइस निकालने लगा। कटाव को हार्ड डिग्रेडेशन मानने और पहचान जाँच (total == पंक्तियों का योग) जोड़ने के बाद पैसे की ग़लती 0.8% से 0.02% पर आई, जबकि फ़ॉर्मैट अनुपालन सिर्फ़ 99.1% तक गया। तीन महीने "फ़ॉर्मैट अनुपालन" सुधारना ग़लत मीट्रिक पर निशाना था। पार्सर पास होना बिज़नेस पास होना नहीं है।
चार बातों की सूची: पार्स से पहले रुकने की वजह देखें; सीमा p99 से तय करें, बजट की तरह नहीं; स्कीमा के ज़रूरी फ़ील्ड आगे रखें; मरम्मत टूल को सिर्फ़ पूरे जवाब की फ़ॉर्मैट गंदगी दें। इन चारों के साथ कटाव चुपचाप डेटा-नुक़सान से फिर शोर मचाने वाली, रीट्राई-योग्य विफलता बन जाता है।
क्या सिर्फ़ ब्रैकेट बंद कर के नतीजा इस्तेमाल कर सकते हैं
नहीं। बंद करना सिर्फ़ सिंटैक्स की वैधता देता है; डेटा अब भी टुकड़ा है जिसमें आधा वाक्य, खोया आख़िरी रिकॉर्ड और असली मानों की जगह डिफ़ॉल्ट हैं। आंशिक चिह्नित करें, रीट्राई या डिग्रेडेशन चलाएँ, और बचाव दर लॉग करें।
कटाव और असली सिंटैक्स एरर में फ़र्क़ कैसे करें
मेटाडेटा में रुकने की वजह पढ़ें: max_tokens, length या incomplete मतलब कटाव; end_turn या stop के साथ पार्सिंग फ़ेल का मतलब असली सिंटैक्स ख़राबी। मेटाडेटा न हो तो अंत देखें: कोट या ब्रैकेट के अंदर रुकना जबकि बाहरी ढाँचा अभी बंद नहीं हुआ, लगभग हमेशा कटाव है।
मरम्मत किया कटाव शोर मचाने वाली विफलता से ज़्यादा ख़तरनाक क्यों है
मरम्मत टूल "पार्स होने लायक" बनाना सुधारता है, और बंद किया कटाव सचमुच पार्स होता है, इसलिए मॉनिटरिंग चुप हो जाती है और डिफ़ॉल्ट मानों के कारण डाउनस्ट्रीम वैलिडेशन पास हो जाता है। इसीलिए 83 कटी रिपोर्टों से सिर्फ़ 4 एरर बने। टूल के पास इरादे की धारणा नहीं है और वह नहीं जानता क्या खोया, इसलिए कटाव ऊपर ही रोकना पड़ता है।
max_tokens बढ़ाने से ख़र्च बढ़ता है क्या
नहीं। बिलिंग असल में बने टोकन पर है; सीमा सिर्फ़ घेरा है। 1100 बने टोकन पर 4096 या 1500 — लागत एक ही। असली p99 के हिसाब से जगह छोड़कर तय करें, और मेहनत बेलगाम आउटपुट रोकने में लगाएँ।