เอาต์พุตมีโครงสร้างของ LLM ที่พัง: เขียน Schema สำหรับโหมด strict อย่างไรให้ถูกจริง
สรุปสำคัญ: เปิด strict กับ JSON Schema ธรรมดาเกือบทุกครั้งจะได้ 400 กลับมา: ทุกฟิลด์ required, additionalProperties:false ในทุก object, และ $ref กับ allOf ถูกปฏิเสธทันที คู่มือนี้แสดงวิธีเขียน schema แบบหลวมใหม่เป็นเวอร์ชันที่เข้ากันกับ strict — ด้วย union nullable, ขีดจำกัดแบบเข้มงวด และเช็กลิสต์เรื่อง refusal

แก่นสาระ: strict: true ไม่ใช่สวิตช์ "ทำตัวจริงจังขึ้น" — มันคือสัญญาที่ยอมรับเฉพาะส่วนย่อยหนึ่งของ JSON Schema ทุกฟิลด์ต้อง required, additionalProperties: false ในทุก object, ส่วน $ref และ allOf ห้ามใช้ทันที ถ้าส่ง schema เข้าโหมด strict โดยไม่เขียนใหม่ คำตอบคือ 400 ไม่ใช่เอาต์พุตที่เชื่อถือได้
ในการทำงานประจำวัน ฉากนี้เกิดซ้ำแบบเดิม ๆ: ทีมมี schema ที่ออกแบบมาดี มีฟิลด์ทางเลือก มี $defs ที่ใช้ซ้ำได้ และ additionalProperties ที่เปิดกว้างเพื่อความเข้ากันได้ แล้วใครสักคนเพิ่ม "strict": true ลงในการเรียก API ด้วยความเชื่อว่าตอนนี้โมเดล "จะเคารพ" schema ผลทันทีคือข้อผิดพลาด 400 พร้อมข้อความยาวเหยียด หรือแย่กว่านั้น — schema ถูกยอมรับแต่สร้างเอาต์พุตที่ไม่คาดคิด โหมด strict ไม่ได้ตีความ schema อย่างเผื่อใจ: มันเขียน schema ใหม่ตั้งแต่ต้นเป็นไวยากรณ์ที่เอนจินสร้างข้อมูลทำตามได้ทีละตัวอักษร และทุกอย่างที่ไม่ลงตัวกับไวยากรณ์นั้นจะถูกปฏิเสธหรือถูกละเว้นเงียบ ๆ การเข้าใจว่ากฎใดมีผลจริง ก่อนส่งคำขอ คือความต่างระหว่างไปป์ไลน์ที่มั่นคงกับหนึ่งสัปดาห์ของการดีบัก
โหมด strict = JSON Schema ของคุณถูกคอมไพล์เป็นไวยากรณ์ที่โมเดลต้องทำตามคำต่อคำ ทุกอย่างที่ไวยากรณ์แสดงไม่ได้จะถูกปฏิเสธตอนส่งหรือถูกละเว้นเงียบ ๆ — และทั้งสองกรณีปัญหาจะปรากฏหลังจากที่ผู้ใช้เห็นมันไปแล้ว
เอนจินของโหมด strict ทำงานจริงอย่างไร
โมเดลไม่ได้อ่าน JSON Schema ของคุณเหมือนตัวตรวจสอบทั่วไป เมื่อ strict: true เปิดอยู่ schema จะถูกแปลงเป็น ไวยากรณ์ที่ถูกจำกัด — ออโตมาตอนสถานะจำกัดที่ตัดสินทีละ token ว่าการต่อเนื่องใดถูกต้อง โมเดลสร้างเฉพาะการเปลี่ยนสถานะที่ออโตมาตอนอนุญาต; ไม่มีการตรวจสอบหลังการสร้างที่มาแก้ไขเอาต์พุต — ความถูกต้องเป็นเรื่องเชิงโครงสร้าง
สถาปัตยกรรมนี้อธิบายพฤติกรรมที่ดูลึกลับได้ทั้งหมด ถ้าฟิลด์ไม่อยู่ใน required ออโตมาตอนต้องตัดสินว่าจะหยุดตอนไหน: ทางออกที่ปลอดภัยเพียงทางเดียวคือให้โมเดลมีเสรีภาพพ่น null ออกมา ดังนั้น schema ที่มีผลจริงซึ่งเอนจินได้รับจะมีฟิลด์นั้น ปรากฏเสมอ ถ้า object ยอมรับพร็อพเพอร์ตี้เพิ่มเติม ออโตมาตอนทำนายไม่ได้ว่าจะมี key ใดโผล่ จึงต้องปิดทุก object อย่างเข้มงวด ทุกคำ "ห้าม" ในเอกสารเกิดจากข้อจำกัดที่เป็นรูปธรรมของออโตมาตอนนี้ ไม่ใช่การเลือกสไตล์ของ OpenAI
ผลที่ตามมาที่สองลวงกว่า: คำสั่ง JSON Schema บางตัว (เช่น pattern, minLength, maximum) ถูกต้องต่อ schema แต่ไม่ถูกบังคับใช้โดยไวยากรณ์ schema ถูกยอมรับ คำตอบกลับมาสะอาด แต่ข้อจำกัดไม่เคยถูกปฏิบัติเลย นี่คือวิธีทำให้ไปป์ไลน์พังอย่างเงียบที่สุด: การตรวจสอบถัดไปล้มเหลวในโปรดักชันและไม่มี log ใดแสดงข้อผิดพลาดของ schema
สามกฎที่ต่อรองไม่ได้
ถ้ามีเวลาแก้ของเดียว ให้แก้สามข้อนี้ มันแก้ปัญหา 400 ได้เกือบทั้งหมด
1. ทุกฟิลด์ใน required เสมอ ในโหมด strict ทุก key ที่ประกาศใน properties ต้องปรากฏใน required — รวมถึงฟิลด์ทางเลือกด้วย เทคนิคทางการสำหรับบอกว่า "ทางเลือก" คือ union nullable:
{
"type": "object",
"properties": {
"couponCode": { "type": ["string", "null"] }
},
"required": ["couponCode"],
"additionalProperties": false
}
เช่นนี้ออโตมาตอนรู้แน่ชัดว่า key ไหนถูกต้องตอนไหน และโมเดลสื่อ "ไม่มีคูปอง" ด้วย null แทนการละไว้ไม่ใส่ key
2. additionalProperties: false ในทุก object ไม่ใช่แค่ object ราก: ทุก object ที่ซ้อนกัน โดยไม่มีข้อยกเว้น มีชั้นเดียวเปิดไว้ก็ทำให้ schema ทั้งหมดไม่สอดคล้อง
3. $ref และ allOf ห้ามใช้ ไม่มีการอ้างอิง ไม่มี $defs ไม่มีการประกอบ schema ต้องถูกขยายออกทั้งหมด — เป็นต้นไม้เดียวที่ยืนด้วยตัวเอง if/then/else และ oneOf ที่รากก็มีชะตาเดียวกัน
ตารางคำที่ห้ามใช้และคำที่ไร้ผล
| คำสั่ง | ผลในโหมด strict | ทางแทนที่แนะนำ |
|---|---|---|
$ref, $defs |
ถูกปฏิเสธด้วย 400 | ขยาย schema ออกทั้งหมด |
allOf |
ถูกปฏิเสธด้วย 400 | รวมพร็อพเพอร์ตี้ด้วยมือ |
if/then/else |
ถูกปฏิเสธด้วย 400 | enum + จัดการฝั่ง client |
oneOf ที่ราก |
มีปัญหา / คำตอบไม่สอดคล้อง | มี object รากเดียว |
ฟิลด์นอก required |
กลายเป็นบังคับเสมอ | union nullable ["string", "null"] |
pattern, minLength |
schema ผ่านแต่ข้อจำกัดถูกละเว้น | ตรวจสอบอย่างชัดเจนหลังได้คำตอบ |
maximum, format |
schema ผ่านแต่ข้อจำกัดถูกละเว้น | ตรวจที่ฝั่งแอปพลิเคชัน |
แถวที่อันตรายที่สุดคือคู่สุดท้าย: schema ผ่านการตรวจสอบแต่ข้อจำกัดไม่มีอยู่จริง ถ้าตรรกะของคุณเชื่อ pattern คุณกำลังสร้างบนทราย
ขีดจำกัดแบบเข้มงวดที่ไม่มีใครอ่าน
ก่อนเขียน schema ให้เช็กว่าคุณอยู่ในขอบเขตเหล่านี้ — การลืมมันทำให้เกิดข้อผิดพลาดคลุมเครือที่วินิจฉัยยาก:
| ข้อจำกัด | ค่าสูงสุด |
|---|---|
| จำนวนพร็อพเพอร์ตี้รวมต่อ schema | 5000 |
| ความลึกการซ้อน | 10 ระดับ |
| ขนาดสตริง schema | 120,000 อักขระ |
| จำนวนค่า enum รวม | 1000 |
schema ที่สร้างอัตโนมัติจากเฟรมเวิร์กหรือนิยาม OpenAPI มักลืมขีดจำกัดเหล่านี้โดยไม่มีใครสังเกต: พร็อพเพอร์ตี้รวม 6000, ซ้อนกัน 12 ระดับ, ค่า enum กระจัดกระจาย 1500 ข้อความผิดพลาดของ API ไม่ค่อยบอกว่าเกินเกณฑ์ไหน จึงควรตรวจเองก่อนส่ง
เขียนใหม่อัตโนมัติ: สคริปต์ make_strict
สำหรับ schema ขนาดใหญ่ การเขียนใหม่ด้วยมือไม่ใช่เรื่องปฏิบัติ สคริปต์ Python นี้เดินท่องต้นไม้และใช้สามกฎแบบเรียกซ้ำ:
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))
คำเตือนสองข้อ หนึ่ง: สคริปต์เดาไม่ได้ว่าฟิลด์ใดเป็นทางเลือก — คุณต้องทำ union nullable เอง ควรทำที่ต้นทางของ schema ไม่ใช่ที่ผลลัพธ์ สอง: หลังแปลงแล้ว ต้องรันคำขอทดสอบเสมอ: การขยายออกอาจทำให้เกินขีดจำกัดขนาดหรือจำนวนพร็อพเพอร์ตี้ที่เดิมยังอยู่ในเกณฑ์
เส้นทางที่เทียบเท่าใน Anthropic
Anthropic ไม่มีแฟล็ก strict แต่ไปถึงผลเดียวกันด้วยกลไก tool: นิยามเครื่องมือทำหน้าที่เป็น schema และโมเดลถูกมัดให้อยู่ในรูปทรงของมัน แนวทางเหมือนกันแทบทุกอย่าง:
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 ทุก object ก็ต้องการ required เต็มและ additionalProperties: false ต่างกันที่ช่องทางคำตอบ — tool_use แทนเนื้อหาข้อความ — และที่ฟิลด์ refusal เป็นของ OpenAI เท่านั้น
refusal, การถูกตัด และรูปทรงพัง: สามความเสียหาย สามทางแก้
แม้ schema จะสมบูรณ์ เอาต์พุตยังพังได้จากสามเหตุผลที่ต่างกัน และการสับสนระหว่างมันคือวิธีเสียวันที่เร็วที่สุด:
1. refusal ไม่ว่าง OpenAI ในโหมด strict อาจคืนฟิลด์ refusal พร้อมเหตุผลที่ปฏิเสธคำขอ นั่นไม่ใช่ข้อผิดพลาดของ schema — โมเดลปฏิเสธงานในเชิงความหมาย ทางแก้คือทบทวน prompt หรือนโยบาย ไม่ใช่ schema
2. ถูกตัดเพราะ max_tokens การสร้างขาดกลางสตริงและ JSON ไม่ปิด ในโหมด strict ถ้าคำตอบมาจะสอดคล้อง — แต่ถ้าโควตา token หมดก็มาแบบถูกตัด เพิ่ม max_tokens หรือลดขนาดเอาต์พุตที่คาดหวัง สำหรับสถานการณ์ที่เกิดซ้ำ การซ่อม JSON ที่ถูกตัดอัตโนมัติ มีรูปแบบพร้อมใช้
3. รูปทรงพังไม่สอดคล้อง schema เปิดกว้าง (อนุญาตพร็อพเพอร์ตี้เพิ่มเติม ฟิลด์นอก required) และ strict ยังไม่เปิด: โมเดลสร้าง JSON ที่ถูกต้องแต่ไม่เป็นไปตามสัญญา ทางแก้คือเขียน schema ใหม่ตามคู่มือนี้ ไม่ใช่เพิ่มการตรวจสอบหลังการสร้าง
การวินิจฉัยที่ถูกต้องเริ่มจากการแยกสามกรณีนี้เสมอ: ดูฟิลด์ finish_reason, การมีอยู่ของ refusal, และเทียบคำตอบกับ schema ที่ถูกส่งจริง
เช็กลิสต์สุดท้ายก่อนขึ้นโปรดักชัน
| จุดตรวจ | ต้องตรวจอะไร |
|---|---|
required ครบถ้วน |
ทุกพร็อพเพอร์ตี้ที่ประกาศอยู่ใน required |
| nullable ชัดเจน | ฟิลด์ทางเลือกเป็น union ["...", "null"] |
additionalProperties: false |
ในทุก object ไม่ใช่แค่ราก |
ศูนย์ $ref / allOf / if-then-else |
schema ขยายออกครบ |
| ขีดจำกัดเป็นไปตาม | ≤ 5000 พร็อพเพอร์ตี้, ≤ 10 ระดับ, ≤ 120k อักขระ |
| ข้อจำกัดไร้ผลย้ายที่แล้ว | pattern/format ตรวจที่ฝั่งแอปพลิเคชัน |
จัดการ refusal |
โค้ดแยกการปฏิเสธออกจากข้อผิดพลาด schema |
| ทดสอบด้วยคำขอจริง | คำตอบทดสอบถูกตรวจแล้วก่อน deploy |
ถ้าอยากเข้าใจว่าทำไม additionalProperties: false ถึงเป็นแกนกลางขนาดนั้น บทวิเคราะห์เชิงลึกเรื่อง คำสั่ง additionalProperties แสดงให้เห็นว่า object ที่เปิดแต่ละตัวขยายพื้นที่การสร้างอย่างไร หากต้องการนำ schema เข้าไปป์ไลน์ CI พร้อมการทดสอบสัญญาอัตโนมัติ ขั้นตอนที่อธิบายใน JSON Schema contract testing ช่วยปิดการถดถอยแบบเงียบ ๆ และถ้าต้องสร้าง schema จากตัวอย่าง JSON ที่มีอยู่ เครื่องมือ แปลงเป็น JSON Schema บนแพลตฟอร์มช่วยให้เริ่มจากข้อมูลจริงได้ — แต่สำหรับโหมด strict คุณยังต้องเขียนใหม่ตามคู่มือนี้อยู่ดี
คำถามที่พบบ่อย
ทำไมเอกสารถึงบังคับให้ทุกฟิลด์เป็น required แม้แต่ฟิลด์ทางเลือก?
เพราะออโตมาตอนสถานะจำกัดต้องตัดสินล่วงหน้าว่า key ไหนถูกต้องเมื่อไร "ความเป็นทางเลือก" สื่อด้วย null ไม่ใช่ด้วยการไม่ใส่ key: union nullable คือวิธีทางการในการบอกเรื่องนี้
schema ผ่านแล้วแต่ pattern ไม่ทำงาน เป็น bug หรือเปล่า?
ไม่ใช่ ในโหมด strict pattern, minLength, maximum และ format ไม่ถูกบังคับใช้โดยไวยากรณ์การสร้าง schema ถูกต้องเชิงไวยากรณ์แต่ข้อจำกัดไม่มีอยู่จริง: ตรวจที่ฝั่งแอปพลิเคชัน
ใช้ $ref ได้ไหมถ้าประกาศ $defs ด้วย?
ไม่ได้ ทั้งสองแบบห้าม schema ต้องเป็นต้นไม้เดียว ขยายออกครบ สคริปต์เขียนใหม่อัตโนมัติจัดการเรื่องการขยายให้
ความต่างระหว่าง refusal กับข้อผิดพลาด schema คืออะไร? refusal คือคำตอบที่สอดคล้องซึ่งโมเดลประกาศเชิงความหมายว่าไม่ต้องการทำงานนั้น ส่วนข้อผิดพลาด schema คือ 400 ตอนส่งหรือเอาต์พุตที่ไม่สอดคล้อง เป็นปัญหาคนละแบบแก้คนละวิธี
ซ้อน object ได้ลึกแค่ไหน? สูงสุด 10 ระดับการซ้อนและพร็อพเพอร์ตี้รวม 5000 ต่อ schema schema ที่สร้างอัตโนมัติมักเกินขีดจำกัดเหล่านี้: ตรวจก่อนส่ง
สรุป
โหมด strict ไม่ใช่ตัวเลือกเพื่อความสวยงาม: มันคือการเปลี่ยนจาก "หวังว่าโมเดลจะเคารพ schema" ไปสู่ "ไวยากรณ์กันเอาต์พุตที่ไม่สอดคล้องอย่างเป็นรูปธรรม" ราคาที่ต้องจ่ายคือส่วนย่อยที่เข้มงวดของ JSON Schema — required ครบ, object ปิดสนิท, ไม่มีการอ้างอิง — และข้อจำกัดบางตัวที่หลุดรอดไปเงียบ ๆ แต่ไม่เคยถูกบังคับใช้ ลงทุนครึ่งชั่วโมงเขียนใหม่ด้วยสคริปต์ make_strict ทำ union nullable อย่างมีเหตุผล และทดสอบด้วยคำขอจริงเสมอก่อน deploy: ไปป์ไลน์ที่ได้มามีคุณภาพต่างกันโดยสิ้นเชิงกับไปป์ไลน์ที่พึ่ง retry และการแก้ไขหลังเกิดเหตุ