JSON Toolkit

JSON मरम्मत गाइड: टूटा LLM आउटपुट बिना भरोसे खोए बचाना

मुख्य बात: markdown फ़ेंस में लिपटे, अनुगामी कॉमा और Python लिटरल वाले LLM आउटपुट को सख़्त पार्सर पूरी तरह अस्वीकार करता है — बिना उद्धरण चिह्न के हाथ से संपादित कॉन्फ़िग भी। यह गाइड नौ तरह की त्रुटियों, जो मरम्मतकर्ता सच में ठीक करता है, और चार तरह की त्रुटियों, जो कभी नहीं ठीक करेगा, की वास्तविक सीमा खींचता है, समझाता है कि स्टेट मशीन regex क्यों हराती है, और jsonrepair व json-repair के साथ प्रोडक्शन-रेडी पार्स श्रृंखला देता है।

मध्यम~6 मिनट पढ़ें2026-11-08 को प्रकाशित2026-11-08 को अपडेट किया गया
JSON मरम्मत पाइपलाइन का चित्र: फ़ेंस हटाना, उद्धरण चिह्न सामान्य करना, कोष्ठक संतुलन और अंतिम सत्यापन

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

एक: टूटा JSON कहाँ से आता है

मरम्मत जादू नहीं है — पहले इनपुट देखिए। वास्तविक परियोजनाओं में गैर-मानक JSON तीन संकेंद्रित स्रोतों से आता है:

  1. LLM आउटपुट. भाषा मॉडल टेक्स्ट टोकन-दर-टोकन उत्पन्न करते हैं; वे कोई JSON सीरियलाइज़र नहीं चलाते। "सिर्फ़ JSON" माँगने पर भी मॉडल उत्तर को ```json फ़ेंस में लपेट देता है, आगे "ये रहा आपका डेटा" जोड़ता है, अनुगामी कॉमा छोड़ देता है, या टोकन सीमा से टकराकर ऑब्जेक्ट के बीच में रुक जाता है।
  2. दूसरी भाषाओं से प्रतिलिपि. console.log से छपा JavaScript ऑब्जेक्ट एकल उद्धरण चिह्न और बिना उद्धरण वाले कुंजियाँ ले आता है; Python शब्दकोश True/False/None रूप में छपता है। ये "JSON जैसे दिखने वाले" स्ट्रिंग JSON.parse के पहले संपर्क पर धड़ाम करते हैं।
  3. JSON5/JSONC कॉन्फ़िग. tsconfig जैसी फ़ाइलें टिप्पणियाँ और अनुगामी कॉमा विधिवत अनुमति देती हैं। ऐसी फ़ाइल सख़्त पार्सर में चिपकाइए — पूरी फ़ाइल अस्वीकृत।

तीनों स्रोतों के उपचार भिन्न हैं, पर मरम्मतकर्ता सब कवर करते हैं — बशर्ते त्रुटि उनकी घोषित सुधार-योग्य सूची में हो।

दो: मरम्मतकर्ता जिन नौ तरह की त्रुटियों को सच में ठीक करता है

jsonrepair लाइब्रेरी के दस्तावेज़ और उपकरण विक्रेताओं की प्रकाशित क्षमता सूचियों को मिलाकर देखें तो स्वतः सुधार-योग्य त्रुटियाँ नौ श्रेणियों में बँटती हैं:

श्रेणी टूटा इनपुट मरम्मत के बाद
अनुगामी कॉमा [1, 2, 3,] [1, 2, 3]
एकल / घुमावदार उद्धरण {'a': 'b'}、{"a": "b"} {"a": "b"}
बिना उद्धरण कुंजियाँ {name: 'Ada'} {"name": "Ada"}
टिप्पणियाँ {"a": 1 /* टिप्पणी */} {"a": 1}
Python लिटरल {"ok": True, "v": None} {"ok": true, "v": null}
markdown फ़ेंस ```json {...} ``` {...}
ग़ायब कॉमा [1 2] [1, 2]
खुले कोष्ठक / उद्धरण {"a": [1, 2 {"a": [1, 2]}
JSONP / स्ट्रिंग जोड़ cb({...})、"x" + "y" {...}、"xy"

इन नौ का साझा लक्षण: डेटा पूरा मौजूद है; टूटा सिर्फ़ वाक्य-विन्यास है। मरम्मतकर्ता विराम-चिह्न और लिफ़ाफ़े ठीक करता है, एक भी मान नहीं छूता। कुछ ब्योरे अलग याद रखने लायक़ हैं:

  • शून्य से शुरू होने वाले अंक स्ट्रिंग बन जाते हैं। 007 को "007" में मरम्मत होता है, 7 में नहीं, ताकि अंक न खोएँ। अगर फ़ील्ड वाक़ई टेक्स्ट कोड है तो यह सही है; असली संख्या है तो निर्णय आपका।
  • खाली शब्द स्ट्रिंग बन जाते हैं। NaN को संख्या में मरम्मत नहीं किया जा सकता — कुछ लागूकरण "NaN" देते हैं, कुछ null। लाइब्रेरियों में व्यवहार भिन्न है; पाइपलाइन में जोड़ने से पहले अपने वाले की परीक्षा कीजिए।
  • वैध इनपुट अछूता गुज़रता है। हर गंभीर मरम्मतकर्ता पहले सख़्त पार्सिंग का तेज़ मार्ग चलाता है। वैध JSON मरम्मत तर्क में कभी नहीं घुसता, इसलिए "अच्छे दस्तावेज़ की मरम्मत करके खराब करना" असंभव है।

तीन: चार चीज़ें जो मरम्मतकर्ता नहीं ठीक करता

दूसरी ओर की सीमा भी उतनी ही स्पष्ट है। इनकी मरम्मत की उम्मीद न करें:

  1. HTML त्रुटि पृष्ठ या शुद्ध गद्य. इनपुट में कोई JSON संरचना है ही नहीं, और कोई उपकरण शून्य से डेटा नहीं बना सकता।
  2. वाक्य-विन्यास से सही पर तथ्य से ग़लत डेटा. ग़लत वर्तनी वाली कुंजी, ग़लत जगह का मान, स्ट्रिंग के रूप में सहेजा अंक — ये अर्थ-स्तर की समस्याएँ हैं जिन्हें कोई भी पार्सर, मरम्मतकर्ता समेत, बिना चिल्लाए पार कर देता है।
  3. कटने से खोया डेटा. पूर्णता {"items": [{"id": 1}, {"na को वैध JSON में बदल सकती है, पर name फ़ील्ड का मान कभी लौटेगा नहीं। मिलता है "वैध पर अधूरा" ऑब्जेक्ट। प्रोडक्शन में पूर्णता या पुनःप्रयास तय करने से पहले stopReason === "max_tokens" जाँचें।
  4. दोहरी कुंजियाँ और अस्पष्ट संरचनाएँ. दो समान कुंजियों में से कौन जीतेगा, यह पार्सर के लागूकरण पर निर्भर करता है। ज़िम्मेदार मरम्मतकर्ता strict मोड देते हैं जो चुपचाप एक चुनने के बजाय त्रुटि फेंकता है।

सीमा एक पंक्ति में: मरम्मत "सर्वोत्तम अनुमान" है, "सही होने की गारंटी" नहीं। असत्यापित मरम्मत-परिणाम को आगे बहाव में छोड़ना चीख़ता हुआ वाक्य-विन्यास दोष चुपचाप डेटा दोष से अदलना है।

चार: लागूकरण के दो घराने — एक URL बहस तय कर देता है

बाज़ार के मरम्मतकर्ता दो रूपों में आते हैं, और अंतर एक विशेष इनपुट पर तुरंत दिखता है।

regex प्रतिस्थापन घराना टूटे पैटर्न पर वैश्विक खोज-और-बदल लगाता है। यह इनपुट देखिए:

{"url": "http://example.com", 'note': 'fine'}

एकल उद्धरण दोहरे में बदलने वाला regex URL के अंदर के भी पिसेगा; हर // मिटाने वाला टिप्पणी-सफ़ाई regex http:// को दो टुकड़ों में काट देगा। स्ट्रिंग के भीतर और संरचना के बाहर अक्षर एक जैसे दिखते हैं — regex उन्हें अलग नहीं कर सकता।

अक्षर-दर-अक्षर स्टेट मशीन घराना पार्स की अवस्था ट्रैक करता है: दोहरे उद्धरण स्ट्रिंग के भीतर, एकल के भीतर, पंक्ति-टिप्पणी के भीतर, ब्लॉक-टिप्पणी के भीतर, या मान की प्रतीक्षा में। ' देखते ही पहले पूछता है "क्या मैं स्ट्रिंग के भीतर हूँ?", फिर तय करता है उद्धरण बदलना है या छोड़ना। http://example.com दोहरे उद्धरण स्ट्रिंग के भीतर है, इसलिए स्टेट मशीन जानती है वहाँ का // टिप्पणी नहीं, डेटा है, और उसे अक्षुण्ण रखती है। jsonrepair और json-healer इसी घराने के हैं, और समुदाय का वाक्य "मरम्मतकर्ता खोज-और-बदल नहीं है" ठीक इसी की ओर इशारा करता है।

मरम्मत पाइपलाइन की पूरी क्रमविन्यास (devkits लागूकरण की प्रकाशित विवरणी) भी देखने लायक़ है: फ़ेंस हटाओ → घुमावदार उद्धरण सामान्य करो → पहला संतुलित खंड निकालो → टिप्पणियाँ हटाओ → खाली कुंजियों को उद्धरण दो → अनुगामी कॉमा हटाओ → लिटरल बदलो → अंत में JSON.stringify से दोबारा क्रमबद्ध करो। यही अंतिम दोबारा क्रमबद्धता कुंजी-चरण है: पूर्व चरण जो करें, आउटपुट पार्स-परिणाम से फिर से उत्पन्न होता है, इसलिए नीचे का कोई भी सख़्त पार्सर उसे निगल लेता है।

पाँच: कोड में जोड़ना — क्रमबद्ध पार्स श्रृंखला

कोड में मरम्मत जोड़ते समय क्रम लाइब्रेरी चुनने से ज़्यादा अहम है। json2toon और aijsonmedic के प्रकाशित पैटर्न के अनुसार क्रम यह होना चाहिए: कटने की जाँच → JSON खंड निकालना → सख़्त parse → मरम्मत सहारे के रूप में → स्कीमा सत्यापन.

import { jsonrepair } from "jsonrepair";

export function parseModelJson(text, stopReason) {
  if (stopReason === "max_tokens") {
    // कटा आउटपुट मरम्मत करने पर भी डेटा अधूरा रहेगा — फिर से आज़माओ
    throw new Error("Truncated output: retry with a higher max_tokens");
  }
  // JSON खंड निकालो: LLM आगे-पीछे बकवास कर सकता है
  const start = text.search(/[[{]/);
  const end = Math.max(text.lastIndexOf("}"), text.lastIndexOf("]"));
  const candidate = start >= 0 && end > start ? text.slice(start, end + 1) : text;
  try {
    return JSON.parse(candidate);   // वैध इनपुट का तेज़ मार्ग
  } catch {
    return JSON.parse(jsonrepair(candidate));  // मरम्मत सहारे के रूप में
  }
}

Python पक्ष में json-repair पैकेज (4,700+ स्टार) loads() देता है जो सीधे ऑब्जेक्ट लौटाता है:

from json_repair import repair_json
import json

broken = "{name: 'Ada', tags: ['x',], active: True}"
data = json.loads(repair_json(broken))
# {'name': 'Ada', 'tags': ['x'], 'active': True}

दो अभियांत्रिकी ब्योरे:

  • स्टैक तालमेल. अगर फ़्रंटएंड और बैकएंड दोनों मरम्मत करते हैं, तो साझा अर्थ वाले लागूकरण चुनिए — Python json-repair और उसका TypeScript पोर्ट @yarmu/json-repair, या jsonmend, जिसके Python और JS संस्करण एक ही 485-केस अनुरूपता निकाय पास करते हैं। वरना वही आउटपुट क्लाइंट पर A और सर्वर पर B मरम्मत होगा और डिबगिंग दुःस्वप्न बनेगा।
  • मरम्मत लॉग चालू करो. @yarmu/json-repair का logging: true हर मरम्मत कार्रवाई की सरणी लौटाता है। मरम्मत दर में अचानक उछाल आमतौर पर प्रॉम्प्ट या मॉडल संस्करण बदलने का संकेत है — किसी भी त्रुटि रिपोर्ट से पहले का संकेत।

मरम्मत के बाद एक चरण अनिवार्य है: स्कीमा सत्यापन. वाक्य-विन्यास सही का मतलब उपयोग-योग्य नहीं। ग़ायब फ़ील्ड, ग़लत प्रकार, अनचाही कुंजियाँ — स्कीमा सब पकड़ता है। अनुबंध-परीक्षण का दृष्टिकोण यहाँ सीधे लागू होता है; हमारी JSON Schema अनुबंध-परीक्षण गाइड देखिए।

छह: निवारण सूची — सबसे सस्ती मरम्मत वह है जिसकी ज़रूरत ही नहीं

मरम्मत सहारा है। स्रोत पर कम टूटा JSON बनना ही असली जीत है, प्राथमिकता क्रम में:

  1. Structured Outputs (json_schema मोड): डिकोडिंग स्कीमा से बंधी होती है, अनुगामी कॉमा पैदा हो ही नहीं सकता। OpenAI का strict मोड लगभग 0.1% में नाकाम होता है — मेहनताना additionalProperties: false जैसी कठोर अपेक्षाएँ।
  2. JSON मोड (json_object): केवल वाक्य-विन्यास की वैधता देता है — आकार नहीं — और टोकन सीमा का कटना फिर भी होता है।
  3. स्पष्ट निर्देश: JSON मोड न देने वाले एंडपॉइंट पर "फ़ेंस नहीं, टिप्पणी नहीं, अनुगामी कॉमा नहीं, सिर्फ़ ऑब्जेक्ट आउटपुट" लिखना त्रुटि दर 70–80% घटा देता है।
  4. temperature घटाओ, टोकन सीमा बढ़ाओ: पहला गद्य में बहना घटाता है; दूसरा कटना घटाता है।
  5. त्रुटि सहित पुनःप्रयास: सत्यापन विफल हो तो टूटा आउटपुट और "JSON path + त्रुटि संदेश" बातचीत में जोड़कर दोबारा माँगो। सटीक त्रुटि मिलने पर मॉडल आमतौर पर स्वयं सुधर जाता है।

व्यवहार में "structured outputs + मरम्मत सहारा + स्कीमा सत्यापन" की तीन परतें एक साथ रखने पर हर परिदृश्य ढक जाता है।

सात: काम का बँटवारा — बोली रूपांतरण मरम्मत नहीं है

इस साइट के औज़ार-बक्स में इस पाइपलाइन के दो अलग हिस्सों के लिए दो गंतव्य हैं:

  • बोली समस्याएँ (टिप्पणी, एकल उद्धरण, अनुगामी कॉमा) सीधे JSON5 रूपांतरक पर जाती हैं। JSON5 ↔ मानक JSON रूपांतरण बिलकुल यही तीन श्रेणियाँ कवर करता है, स्पष्ट अर्थ के साथ, बिना अंदाज़ा। पूरा इनपुट JSONC/JSON5 फ़ाइल हो तो मरम्मत से रूपांतरण अधिक भरोसेमंद है। बोलियों के अपने समझौतों के लिए JSON5 और JSONC गाइड देखिए।
  • मरम्मत के बाद परिणाम को JSON पार्सर औज़ार से गुज़ारिए — सत्यापन और सुशोभित करने के लिए, त्रुटियाँ पंक्ति-स्तंभ पर निशाने पर, यह पुष्टि करते हुए कि सख़्त पार्सर आउटपुट सच में स्वीकारता है।
  • लाइब्रेरी-स्तर की समस्याएँ (Python लिटरल, कटने की पूर्णता, JSONP लिफ़ाफ़े, markdown फ़ेंस) अभी कोड-पक्ष के jsonrepair / json-repair की माँग करती हैं — ब्राउज़र में समतुल्य एक-क्लिक मरम्मत नहीं है, क्योंकि ये मरम्मतें इरादा अनुमान करती हैं, और स्थानीय लाइब्रेरी उसके लिए सर्वव्यापी रूपांतरक से अधिक सुरक्षित घर है।

अगर हाथ में टूटा डेटा नहीं, त्रुटि संदेश है, तो पहले JSON पार्स त्रुटि सुधार गाइड से संदेश को निर्देशांक में अनुवाद करें, फिर तय करें: हाथ से संपादन या मरम्मत।

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

JSON मरम्मत मेरा डेटा खराब कर देगी?

सुधार-योग्य नौ श्रेणियों में सिर्फ़ विराम-चिह्न और लिफ़ाफ़े बदलते हैं — मान अछूते रहते हैं, और स्ट्रिंग के भीतर के //, कॉमा, धनु-कोष्ठक स्टेट मशीन पहचानकर सुरक्षित रखती है। पर कटने की पूर्णता अधूरे ऑब्जेक्ट देती है, शून्ययुक्त अंक स्ट्रिंग बनते हैं, और NaN का व्यवहार लाइब्रेरी-दर-लाइब्रेरी भिन्न है। मरम्मत के बाद मुख्य फ़ील्ड जाँच अनिवार्य है।

मरम्मत और सत्यापन का संबंध क्या है?

सत्यापन बताता है इनपुट कहाँ अवैध है; मरम्मत हाथ में एक वैध दस्तावेज़ देता है। भरोसेमंद प्रक्रिया दोनों करती है: पहले मरम्मत, फिर सत्यापन — स्कीमा प्रकार और अनिवार्य फ़ील्ड पकड़ता है, वाक्य-विन्यास जाँच पुष्टि करती है कि सख़्त पार्सर परिणाम स्वीकारता है। सत्यापन के बिना मरम्मत करना चीख़ते वाक्य-विन्यास दोष को चुपचाप डेटा दोष से अदलना है।

LLM आउटपुट हमेशा ```json फ़ेंस में लिपटा रहता है — क्या करें?

अल्पावधि में: निकालो. पहले { या [ से अंतिम } या ] तक का टेक्स्ट लेकर parse करो; फ़ेंस हटाने वाला मरम्मतकर्ता पूरा संदेश भी निगल लेता है। दीर्घावधि में structured outputs या स्पष्ट निर्देश "markdown फ़ेंस नहीं" अपनाओ ताकि फ़ेंस पैदा ही न हो।

jsonrepair या json-repair — कौन चुनें?

JavaScript के लिए npm का jsonrepair (स्ट्रीमिंग transform समर्थन करता है); Python के लिए PyPI का json-repair। दोनों छोर पर मरम्मत हो तो अर्थ-तालमेल वाला जोड़ा चुनिए — जैसे json-repair और उसका TS पोर्ट — ताकि वही इनपुट दोनों पक्षों में एक समान मरम्मत हो।

मरम्मतकर्ता हिंदी और घुमावदार उद्धरण सँभाल लेते हैं?

हाँ। हिंदी कीबोर्ड के टाइपोग्राफ़िक उद्धरण (“ ”), पूर्ण-चौड़ाई स्पेस और फ़ाइल आरंभ का BOM — सब मानक मरम्मत सूची में हैं; घुमावदार उद्धरण सीधे उद्धरण में सामान्य होते हैं। परिणाम एक बार सत्यापनकर्ता से गुज़ारें और काम पूरा।