LLM के स्ट्रक्चर्ड आउटपुट जो टूट जाते हैं: strict मोड के लिए असली Schema कैसे लिखें
मुख्य बात: किसी भी JSON Schema पर strict चालू करना लगभग हमेशा 400 लौटाता है: सभी फील्ड required, हर ऑब्जेक्ट पर additionalProperties:false, और $ref व allOf तुरंत रिजेक्ट। यह गाइड दिखाती है कि खुले स्कीमा को strict-संगत वर्शन में कैसे दोबारा लिखें — nullable यूनियन, कठोर सीमाएं और refusal चेकलिस्ट के साथ।

मूल बात: strict: true कोई "थोड़ा और गंभीर रहो" वाला स्विच नहीं है — यह एक अनुबंध है जो JSON Schema का सिर्फ एक उपसमुच्चय मानता है। सभी फील्ड required, हर ऑब्जेक्ट पर additionalProperties: false, और $ref व allOf तुरंत प्रतिबंधित। स्कीमा को बिना फिर से लिखे strict मोड में भेजेंगे तो जवाब होगा 400, भरोसेमंद आउटपुट नहीं।
रोज़मर्रा के काम में यह दृश्य बिल्कुल वैसा ही दोहराया जाता है: टीम के पास एक अच्छी तरह बनी स्कीमा है, जिसमें ऑप्शनल फील्ड हैं, फिर से इस्तेमाल होने वाले $defs हैं, और कंपैटिबिलिटी के लिए additionalProperties खुला है। फिर कोई API कॉल में "strict": true जोड़ता है, यकीन के साथ कि अब मॉडल स्कीमा का "सम्मान करेगा"। तुरंत नतीजा एक लंबे संदेश वाला 400 है, या इससे बदतर — स्कीमा स्वीकार हो जाती है पर अप्रत्याशित आउटपुट देती है। strict मोड स्कीमा की उदार व्याख्या नहीं करता: वह स्कीमा को शुरू से उस व्याकरण में फिर से लिखता है जिसे जनरेशन इंजन शब्दशः फॉलो कर सके, और जो कुछ उस व्याकरण में नहीं समाता वह रिजेक्ट हो जाता है या चुपचाप नज़रअंदाज़ होता है। असल में कौन-से नियम लागू होते हैं, यह अनुरोध भेजने से पहले समझ लेना, स्थिर पाइपलाइन और डिबगिंग के एक हफ्ते के बीच का फर्क है।
strict मोड = आपकी JSON Schema उस व्याकरण में कंपाइल होती है जिसे मॉडल को शब्द-दर-शब्द मानना पड़ता है। जो कुछ व्याकरण व्यक्त नहीं कर सकता, वह भेजते समय रिजेक्ट होता है या चुपचाप नज़रअंदाज़ होता है — और दोनों ही स्थितियों में समस्या तब सामने आती है जब यूज़र उसे पहले ही देख चुका होता है।
strict मोड का इंजन असल में कैसे काम करता है
मॉडल आपकी JSON Schema को किसी सामान्य वैलिडेटर की तरह नहीं पढ़ते। जब strict: true चालू होता है, स्कीमा एक प्रतिबंधित व्याकरण में बदल जाती है — एक फाइनाइट स्टेट मशीन जो टोकन-दर-टोकन तय करती है कि कौन-से क्रम वैध हैं। मॉडल सिर्फ मशीन द्वारा अनुमत संक्रमण पैदा करता है; जनरेशन के बाद कोई नियंत्रण आउटपुट को ठीक नहीं करता — सही होना संरचनात्मक है।
यह आर्किटेक्चर उन सभी व्यवहारों की व्याख्या करता है जो रहस्यमयी लगते हैं। अगर कोई फील्ड required में नहीं है, तो मशीन को तय करना पड़ता है कि कहां रुकना है: एकमात्र सुरक्षित समाधान है मॉडल को null पैदा करने की स्वतंत्रता देना, इसलिए इंजन को मिलने वाली प्रभावी स्कीमा में वह फील्ड हमेशा मौजूद रहेगा। अगर कोई ऑब्जेक्ट अतिरिक्त प्रॉपर्टीज़ स्वीकार करता है, तो मशीन पहले से नहीं जान सकती कि कौन-सी कीज़ आएंगी, इसलिए हर ऑब्जेक्ट को कठोरता से बंद होना पड़ता है। दस्तावेज़ में हर "प्रतिबंधित" इस मशीन की एक ठोस सीमा से उपजता है, OpenAI की स्टाइलिश पसंद से नहीं।
दूसरा परिणाम ज्यादा पेचीदा है: JSON Schema के कुछ कीवर्ड (जैसे pattern, minLength, maximum) स्कीमा के लिए वैध हैं लेकिन व्याकरण उन्हें लागू नहीं करता। स्कीमा स्वीकार हो जाती है, जवाब साफ आता है, लेकिन पाबंदी कभी मानी ही नहीं जाती। यह पाइपलाइन तोड़ने का सबसे खामोश तरीका है: आगे का वैलिडेशन प्रोडक्शन में फेल होता है और कोई लॉग स्कीमा की गड़बड़ी नहीं दिखाता।
तीन नियम जिन पर कोई समझौता नहीं
अगर सिर्फ एक चीज़ ठीक करने का वक्त है, तो ये तीन ठीक करें। ये 400 की बहुसंख्यक घटनाएं सुलझा देती हैं।
1. सभी फील्ड required में, हमेशा। strict मोड में properties में घोषित हर की required में भी दिखनी चाहिए — ऑप्शनल समेत। "ऑप्शनल" कहने का आधिकारिक तरीका nullable यूनियन है:
{
"type": "object",
"properties": {
"couponCode": { "type": ["string", "null"] }
},
"required": ["couponCode"],
"additionalProperties": false
}
इससे मशीन ठीक-ठाक जानती है कि की कब वैध है, और मॉडल "कूपन नहीं है" को की छोड़ने की बजाय null से व्यक्त करता है।
2. हर ऑब्जेक्ट पर additionalProperties: false। सिर्फ रूट ऑब्जेक्ट पर नहीं: हर नेस्टेड ऑब्जेक्ट पर, बिना अपवाद। एक ही खुला स्तर पूरी स्कीमा को गैर-अनुरूप बना देता है।
3. $ref और allOf प्रतिबंधित हैं। कोई रेफरेंस नहीं, कोई $defs नहीं, कोई कंपोज़िशन नहीं। स्कीमा पूरी तरह विस्तारित होनी चाहिए — एक अकेला स्वयंनिर्भर ट्री। रूट पर if/then/else और oneOf का वही हश्र है।
प्रतिबंधित और बेअसर शब्दों की तालिका
| कीवर्ड | strict मोड में परिणाम | सुझाया विकल्प |
|---|---|---|
$ref, $defs |
400 के साथ रिजेक्ट | स्कीमा का पूर्ण विस्तार |
allOf |
400 के साथ रिजेक्ट | प्रॉपर्टीज़ का मैन्युअल मिलान |
if/then/else |
400 के साथ रिजेक्ट | enum + क्लाइंट-साइड हैंडलिंग |
रूट पर oneOf |
समस्याएं / गैर-अनुरूप जवाब | केवल एक रूट ऑब्जेक्ट |
required से बाहर का फील्ड |
हमेशा अनिवार्य बन जाता है | nullable यूनियन ["string", "null"] |
pattern, minLength |
स्कीमा स्वीकार पर पाबंदी नज़रअंदाज़ | जवाब के बाद स्पष्ट वैलिडेशन |
maximum, format |
स्कीमा स्वीकार पर पाबंदी नज़रअंदाज़ | ऐप्लिकेशन-साइट जांच |
सबसे खतरनाक आखिरी जोड़ी है: स्कीमा वैलिडेशन पास करती है पर पाबंदी मौजूद नहीं। अगर आपका लॉजिक pattern पर भरोसा करता है, तो आप रेत पर बना रहे हैं।
वे कठोर सीमाएं जिन्हें कोई नहीं पढ़ता
स्कीमा लिखने से पहले, जांच लें कि आप इन सीमाओं के भीतर हैं — इन्हें लांघने से सामान्य, डायग्नोज़ करने में कठिन गड़बड़ियां बनती हैं:
| सीमा | अधिकतम |
|---|---|
| स्कीमा की कुल प्रॉपर्टीज़ | 5000 |
| नेस्टिंग की गहराई | 10 स्तर |
| स्कीमा स्ट्रिंग का आकार | 120,000 वर्ण |
| कुल enum मान | 1000 |
फ्रेमवर्क या OpenAPI परिभाषाओं से ऑटो-जनरेट हुई स्कीमा अक्सर बिना किसी के ध्यान गए इन सीमाओं को लांघ जाती हैं: कुल 6000 प्रॉपर्टीज़, 12 स्तर नेस्टिंग, बिखरे हुए 1500 enum मान। API का एरर मैसेज किस सीमा को पार किया गया, यह बताने में कमजोर होता है, इसलिए भेजने से पहले स्वयं जांच करना बेहतर है।
स्वचालित पुनर्लेखन: make_strict स्क्रिप्ट
बड़ी स्कीमा के लिए मैन्युअल पुनर्लेखन अव्यावहारिक है। यह पाइथन स्क्रिप्ट ट्री पर जाती है और तीन नियम पुनरावर्ती रूप से लागू करती है:
import json
def make_strict(node):
if isinstance(node, dict):
if node.get("type") == "object":
props = node.get("properties", {})
# हर प्रॉपर्टी required बन जाती है
node["required"] = list(props.keys())
node["additionalProperties"] = False
# "ऑप्शनल" फील्ड को खुद nullable मार्क करना होगा, पहले से
# वह हटाएं जो strict स्वीकार नहीं करता
for k in ("$ref", "$defs", "allOf", "if", "then", "else"):
node.pop(k, None)
return {k: make_strict(v) for k, v in node.items()}
if isinstance(node, list):
return [make_strict(v) for v in node]
return node
schema = json.load(open("schema.json"))
print(json.dumps(make_strict(schema), indent=2))
दो चेतावनियां। पहली: स्क्रिप्ट अनुमान नहीं लगाती कि कौन-से फील्ड ऑप्शनल थे — nullable यूनियन खुद मार्क करनी होंगी, बेहतर हो कि स्कीमा के स्रोत में करें, परिणाम में नहीं। दूसरी: रूपांतरण के बाद हमेशा एक परीक्षण अनुरोध चलाएं: विस्तार उन आकार या प्रॉपर्टी सीमाओं को लांघ सकता है जिनका पहले पालन हो रहा था।
Anthropic में समतुल्य रास्ता
Anthropic strict फ्लैग नहीं देता, पर वही नतीजा tool मंकीज़म से हासिल करता है: टूल परिभाषा स्कीमा की भूमिका निभाती है, और मॉडल उसके आकार से बंधा रहता है। दृष्टिकोण व्यावहारिक रूप से समान है:
const tool = {
name: "extract_invoice",
description: "टेक्स्ट से इनवॉइस का डेटा निकालता है",
input_schema: {
type: "object",
properties: {
invoiceNumber: { type: "string" },
totalAmount: { type: ["number", "null"] },
lineItems: {
type: "array",
items: {
type: "object",
properties: {
description: { type: "string" },
quantity: { type: "number" }
},
required: ["description", "quantity"],
additionalProperties: false
}
}
},
required: ["invoiceNumber", "totalAmount", "lineItems"],
additionalProperties: false
}
};
// मॉडल अनुरूप tool कॉल से जवाब देता है
const response = await anthropic.messages.create({
model: "claude-sonnet-4-5",
max_tokens: 1024,
tools: [tool],
tool_choice: { type: "tool", name: "extract_invoice" },
messages: [{ role: "user", content: invoiceText }]
});
व्यावहारिक नियम वही है: Anthropic में भी हर ऑब्जेक्ट को पूरा required और additionalProperties: false चाहिए। फर्क जवाब के चैनल में है — टेक्स्ट कंटेंट की बजाय tool_use — और इसमें कि refusal फील्ड OpenAI-विशिष्ट है।
refusal, कटाव और टूटा आकार: तीन दोष, तीन उपाय
बेहतरीन स्कीमा के साथ भी आउटपुट तीन अलग कारणों से फेल हो सकता है, और उन्हें मिलाना एक दिन गंवाने का सबसे तेज रास्ता है:
1. गैर-खाली refusal। OpenAI strict मोड में refusal फील्ड अनुरोध ठुकराने के कारण के साथ लौटा सकता है। यह स्कीमा की गड़बड़ी नहीं — मॉडल ने संदर्भगत रूप से काम ठुकराया है। उपाय प्रॉम्प्ट या पॉलिसी की समीक्षा है, स्कीमा नहीं।
2. max_tokens से कटाव। जनरेशन स्ट्रिंग के बीच में रुक जाती है और JSON बंद नहीं होता। strict मोड में अगर जवाब आता है तो अनुरूप होता है — पर टोकन बजट खत्म हो जाए तो कटा हुआ आता है। max_tokens बढ़ाएं या अपेक्षित आउटपुट का आकार घटाएं। बार-बार होने वाले परिदृश्यों के लिए कटे हुए JSON की ऑटो मरम्मत के पास तैयार पैटर्न हैं।
3. टूटा गैर-अनुरूप आकार। स्कीमा खुली थी (अतिरिक्त प्रॉपर्टीज़ अनुमत, फील्ड required से बाहर) और strict चालू नहीं था: मॉडल वैध JSON बनाता है जो अनुबंध का पालन नहीं करता। उपाय स्कीमा को इस गाइड की तरह फिर से लिखना है, जनरेशन-के-बाद नियंत्रण जोड़ना नहीं।
सही निदान हमेशा इन तीन मामलों को अलग करने से शुरू होता है: finish_reason फील्ड देखना, refusal की मौजूदगी देखना, और जवाब की तुलना उस स्कीमा से करना जो वास्तव में भेजी गई थी।
प्रोडक्शन में जाने से पहले का अंतिम चेकलिस्ट
| जांच बिंदु | क्या जांचें |
|---|---|
पूरा required |
हर घोषित प्रॉपर्टी required में है |
| स्पष्ट nullable | ऑप्शनल फील्ड ["...", "null"] यूनियन हैं |
additionalProperties: false |
हर ऑब्जेक्ट पर, सिर्फ रूट पर नहीं |
शून्य $ref / allOf / if-then-else |
स्कीमा पूर्ण विस्तारित |
| सीमाओं का पालन | ≤ 5000 प्रॉपर्टीज़, ≤ 10 स्तर, ≤ 120k वर्ण |
| बेअसर पाबंदियां हटा दी गईं | pattern/format ऐप्लिकेशन-साइट जांचे जाते हैं |
refusal का प्रबंधन |
कोड स्कीमा-एरर से इनकार को अलग करता है |
| वास्तविक अनुरोध से परीक्षण | परीक्षण जवाब deploy से पहले वैलिडेट हो चुका |
अगर आप समझना चाहते हैं कि additionalProperties: false इतना केंद्रीय क्यों है, तो additionalProperties कीवर्ड का गहन विश्लेषण दिखाता है कि हर खुला ऑब्जेक्ट जनरेशन स्पेस कैसे फैलाता है। स्कीमा को स्वचालित कॉन्ट्रैक्ट टेस्ट वाली CI पाइपलाइन में शामिल करने के लिए, JSON Schema contract testing में बताया गया फ्लो चुपचाप होने वाली रिग्रेशन बंद करता है। और अगर मौजूदा JSON उदाहरणों से स्कीमा बनानी हो, तो प्लेटफॉर्म का JSON Schema में रूपांतरण टूल आपको असली डेटा से शुरुआत देता है — हालांकि strict मोड के लिए इस गाइड का पुनर्लेखन फिर भी लागू करना होगा।
FAQ
दस्तावेज़ क्यों कहता है कि सभी फील्ड required हों, ऑप्शनल समेत?
क्योंकि फाइनाइट स्टेट मशीन को पहले से तय करना पड़ता है कि हर की कब वैध है। "ऑप्शनल होना" null से व्यक्त होता है, की की अनुपस्थिति से नहीं: nullable यूनियन इसे कहने का आधिकारिक तरीका है।
स्कीमा स्वीकार हो गई पर pattern काम नहीं करता। यह बग है?
नहीं। strict मोड में pattern, minLength, maximum और format जनरेशन व्याकरण लागू नहीं करता। स्कीमा वाक्यरचनात्मक रूप से वैध है पर पाबंदी मौजूद नहीं: ऐप्लिकेशन-साइट जांचें।
$defs भी घोषित करूं तो $ref इस्तेमाल कर सकता हूं?
नहीं, दोनों ही स्थितियों में प्रतिबंधित है। स्कीमा एक अकेला ट्री होनी चाहिए, पूर्ण विस्तारित। ऑटो-पुनर्लेखन स्क्रिप्ट विस्तार का काम करती हैं।
refusal और स्कीमा-एरर में फर्क क्या है? refusal वह अनुरूप जवाब है जिसमें मॉडल संदर्भगत रूप से घोषणा करता है कि वह काम करना नहीं चाहता। स्कीमा-एरर भेजते समय का 400 या गैर-अनुरूप आउटपुट है। ये अलग समस्याएं हैं, उपाय भी अलग।
ऑब्जेक्ट कितना गहरा नेस्ट कर सकता हूं? अधिकतम 10 स्तर नेस्टिंग और प्रति स्कीमा कुल 5000 प्रॉपर्टीज़। ऑटो-जनरेट स्कीमा अक्सर इन सीमाओं को लांघती हैं: भेजने से पहले जांचें।
निष्कर्ष
strict मोड कोई दिखावटी विकल्प नहीं है: यह "उम्मीद है मॉडल स्कीमा का सम्मान करेगा" से "व्याकरण गैर-अनुरूप आउटपुट को भौतिक रूप से रोकता है" की ओर का कदम है। इसकी कीमत JSON Schema का कठोर उपसमुच्चय है — पूरा required, बंद ऑब्जेक्ट, कोई रेफरेंस नहीं — और कुछ पाबंदियां जो बिना ध्यान निकल जाती हैं पर लागू नहीं होतीं। आधा घंटा make_strict स्क्रिप्ट से पुनर्लेखन में लगाएं, nullable यूनियन को विवेक से मार्क करें, और deploy से पहले हमेशा वास्तविक अनुरोध से परीक्षण करें: इससे बना पाइपलाइन retry और बाद-में-सुधार वाली पाइपलाइन से गुणवत्ता में बिल्कुल अलग होती है।