JSON Toolkit

เอาต์พุตมีโครงสร้างของ LLM ที่พัง: เขียน Schema สำหรับโหมด strict อย่างไรให้ถูกจริง

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

ระดับกลางอ่านประมาณ 8 นาทีเผยแพร่ 2026-11-19อัปเดต 2026-11-19
แผนภาพกฎการเขียน JSON Schema ใหม่สำหรับโหมด strict ของ LLM

แก่นสาระ: 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 และการแก้ไขหลังเกิดเหตุ

แหล่งอ้างอิง

บทความที่เกี่ยวข้อง

การทดสอบสัญญา JSON Schema: เชื่อมกฎการตรวจสอบเข้ากับ CI

สคีมาไม่จบเมื่อเขียนเสร็จ — ที่ตรงนั้นคือจุดเริ่มเสื่อมสภาพ การพิมพ์ผิดหนึ่งจุดทำให้การตรวจสอบหย่อนลงอย่างเงียบ ๆ การรีแฟกเตอร์หนึ่งครั้งทำลาย fixture ทั้งหมด คู่มือนี้ถอดโครงการทดสอบสัญญาที่ทำได้จริง: fixture บวก ลบ และ snapshot, lint ตัวสคีมาเอง คอมไพล์ครั้งเดียวใช้ซ้ำ และสี่ประตู CI ที่เปลี่ยนสัญญาแตกเป็นบิลด์แดง

ระดับกลางอ่านประมาณ 8 นาทีอัปเดต 2026-11-05

JSON จาก LLM ถูกตัดกลางคัน: ดูเหตุผลที่หยุดก่อน แล้วค่อยพูดถึงการซ่อม

โมเดลคืน JSON ที่ขาดกลางค่า แล้ว parser บอกแค่เลขคอลัมน์ การปิดวงเล็บทำให้ parse ผ่านอีกครั้ง แต่ทุกฟิลด์ที่หายไปตอนนี้ซ่อนอยู่ในข้อมูล บทความนี้ขีดเส้นระหว่างสิ่งที่การซ่อมความตัดขาดกู้คืนได้อย่างซื่อสัตย์ กับสิ่งที่ต้องขอใหม่

สูตรปฏิบัติอ่านประมาณ 5 นาทีอัปเดต 2026-11-14

หากไม่ปิด additionalProperties การตรวจสอบ Schema ก็ไม่ได้ตรวจอะไร

การตรวจสอบผ่านไม่ได้แปลว่าข้อมูลสะอาด Pydantic โดยค่าเริ่มต้นเมินฟิลด์ที่ไม่รู้จัก, Zod ตัดทิ้ง, Ajv ปล่อยผ่าน — พารามิเตอร์ที่โมเดลมั่วและคีย์พิมพ์ผิดลอดผ่านอย่างเงียบงัน บทความนี้แสดงสามรูปแบบของการยอมรับอย่างเงียบและวิธีที่ครบถ้วน: ปิดออบเจ็กต์ ควบคุมการแปลงชนิด และรัดทุกระดับของการซ้อน

Intermediateอ่านประมาณ 8 นาทีอัปเดต 2026-11-02