Claude Architect · บทเรียน

การออกแบบสคีมา JSON

กำหนดรูปร่างผลลัพธ์ให้ตรงกับสิ่งที่ต้องการอย่างแม่นยำ

บทเรียน 2 จาก 413 ขั้นตอน

การออกแบบสคีมา JSON เป็นบทเรียน Claude Architect ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Claude Architect และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Claude Architect มีบทเรียนทั้งหมด 4 บทเรียน

เหตุใดเอาต์พุตตามรูปแบบสคีมาจึงมีความสำคัญ

เมื่อคุณต้องการคำตอบจาก Claude ในโครงสร้างที่ชัดเจน อย่าพยายามแยกวิเคราะห์ข้อความอิสระแล้วหวังว่าจะได้ผลลัพธ์ที่ถูกต้อง ให้ใช้ tool_use คู่กับ สคีมา JSON: Claude จะเติมข้อมูลลงใน input_schema ของเครื่องมือ และ API จะรับประกันว่าได้ JSON ที่ถูกต้องพร้อมฟิลด์ที่คุณกำหนดไว้

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

เครื่องมือคือสคีมา

"เครื่องมือ" สำหรับผลลัพธ์แบบมีโครงสร้างไม่จำเป็นต้องเรียกใช้งานสิ่งใด แต่เป็นเพียงภาชนะที่มีชื่อ ซึ่ง input_schema อธิบายโครงสร้างที่คุณต้องการให้ส่งกลับมา คุณเป็นผู้กำหนดเครื่องมือนี้ จากนั้นจึงอ่านข้อมูลที่ Claude ใส่ไว้ในการเรียกใช้เครื่องมือ

ตั้ง ชื่อ และ คำอธิบาย ของเครื่องมือให้ชัดเจน — ทั้งสองอย่างยังคงมีผลต่อการเลือก — แต่ส่วนสำคัญจริง ๆ อยู่ที่ properties และรายการ required ของสคีมา

extract_invoice = {
    "name": "extract_invoice",
    "description": "Record the structured fields parsed from an invoice document.",
    "input_schema": {
        "type": "object",
        "properties": {
            "invoice_number": {"type": "string"},
            "total": {"type": "number"},
        },
        "required": ["invoice_number", "total"],
    },
}

บังคับใช้โครงสร้างด้วย tool_choice

หากคุณต้องการผลลัพธ์แบบมีโครงสร้างที่รับประกันได้ อย่าปล่อยให้เป็นเรื่องของโอกาส ให้ตั้งค่า tool_choice เพื่อบังคับการเรียกใช้เครื่องมือ:

"auto" — โมเดลเลือกว่าจะส่งข้อความหรือใช้เครื่องมือ
"any" — โมเดล MUST เรียกใช้เครื่องมือบางรายการ (รับประกันว่าจะได้ผลลัพธ์แบบมีโครงสร้าง)
{"type":"tool","name":"X"} — บังคับใช้เครื่องมือเฉพาะรายการหนึ่ง

สำหรับการดึงข้อมูลด้วยสคีมาเดียว การบังคับใช้เครื่องมือที่ระบุชื่อไว้อย่างชัดเจนเป็นวิธีที่สะอาดที่สุดในการได้โครงสร้างที่แน่นอน

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=[extract_invoice],
    tool_choice={"type": "tool", "name": "extract_invoice"},
    messages=[{"role": "user", "content": invoice_text}],
)

คำว่า Required หมายถึงต้องมีอยู่เสมอ

กฎของสคีมาที่สำคัญที่สุดคือ ให้กำหนดฟิลด์เป็น required ONLY เมื่อฟิลด์นั้นมีอยู่ในแหล่งข้อมูล เสมอ อย่ากำหนดให้ฟิลด์เป็นฟิลด์บังคับหากฟิลด์นั้นอาจไม่มีอยู่

เพราะเหตุใด ฟิลด์บังคับจะทำให้โมเดลต้องส่งค่าออกมา หากไม่มีข้อมูลนั้น Claude จะ แต่งข้อมูลขึ้นมา เพื่อให้เป็นไปตามข้อตกลง ฟิลด์ที่เป็นตัวเลือกและไม่มีข้อมูลนั้นเป็นความซื่อตรง ส่วนฟิลด์บังคับที่ไม่มีข้อมูลจะก่อให้เกิดภาพหลอน

การจัดการฟิลด์ที่เป็นตัวเลือกอย่างถูกต้อง

สำหรับฟิลด์ที่อาจปรากฏหรือไม่ปรากฏก็ได้ — เช่น รายการส่วนลด ผู้ติดต่อสำรอง หรือวันครบกำหนด — ให้เว้นฟิลด์เหล่านั้น OUT จาก required อธิบายฟิลด์เหล่านั้นให้ชัดเจน เพื่อให้ Claude เติมค่าเฉพาะเมื่อมีข้อมูลอยู่จริง

คำอธิบายที่ดีจะบอกโมเดลถึงรูปแบบข้อมูลนำเข้าและกฎเมื่อไม่มีข้อมูล ทำให้โมเดลละเว้นฟิลด์แทนที่จะสร้างข้อมูลขึ้นมาเอง

"properties": {
    "invoice_number": {"type": "string"},
    "total": {"type": "number"},
    "due_date": {
        "type": "string",
        "description": "ISO 8601 date (YYYY-MM-DD). Omit entirely if no due date is stated."
    },
},
"required": ["invoice_number", "total"]

ค่าแจกแจงช่วยจำกัดผลลัพธ์

เมื่อฟิลด์มีชุดคำศัพท์ที่กำหนดไว้ตายตัว — เช่น สถานะ หมวดหมู่ หรือลำดับความสำคัญ — ให้ใช้ enum วิธีนี้จะรวมข้อความอิสระที่ยุ่งเหยิง (เช่น "paid", "PAID", "settled") ให้เป็นค่าเดียวที่เป็นมาตรฐาน ซึ่งโค้ดของคุณสามารถใช้ตรวจสอบเงื่อนไขได้

ค่าแจกแจงยังช่วยลดภาพหลอนด้วย เพราะโมเดลต้องเลือกจากชุดค่าที่ระบุไว้ แทนที่จะสร้างป้ายกำกับขึ้นมาเอง

"status": {
    "type": "string",
    "enum": ["draft", "sent", "paid", "overdue", "void"],
    "description": "Current invoice status."
}

การออกแบบค่าแจกแจงให้รองรับการขยาย

ค่าแจกแจงที่ตายตัวจะใช้ไม่ได้เมื่อความเป็นจริงมีกรณีใหม่เพิ่มขึ้น รูปแบบที่สถาปนิกนิยมใช้คือ เพิ่มค่า "other" ลงในค่าแจกแจง AND เพิ่มฟิลด์ รายละเอียด แบบข้อความอิสระเพื่อบันทึกว่า "อื่น ๆ" นั้นคืออะไร

ด้วยวิธีนี้ สคีมาของคุณยังคงใช้ได้กับข้อมูลนำเข้าที่คาดไม่ถึง คุณไม่สูญเสียข้อมูล และยังสามารถวิเคราะห์ฟิลด์รายละเอียดเพื่อพิจารณาว่าควรเพิ่มค่าแจกแจงใหม่หรือไม่

"category": {
    "type": "string",
    "enum": ["hardware", "software", "services", "other"]
},
"category_detail": {
    "type": "string",
    "description": "If category is 'other', describe it here. Omit otherwise."
}

คำอธิบายทำหน้าที่สอน

คำอธิบายของฟิลด์คือคำสั่งขนาดย่อม คีย์ที่คลุมเครือย่อมให้ผลลัพธ์ที่คลุมเครือ ระบุ รูปแบบ ให้ชัดเจน ให้ ตัวอย่าง และบอกวิธีจัดการ กรณีขอบ ไว้ในสคีมาโดยตรง

นี่คือสิ่งที่เทียบเท่ากับผลลัพธ์แบบมีโครงสร้างของหลักการที่ว่าเกณฑ์ชัดเจนย่อมดีกว่าคำสั่งคลุมเครือ: "วันที่ตาม ISO 8601 ให้ละเว้นหากไม่มีข้อมูล" ย่อมดีกว่า due_date: string ที่ไม่มีคำอธิบายเสมอ

"line_items": {
    "type": "array",
    "description": "One object per billed line. Empty array if none.",
    "items": {
        "type": "object",
        "properties": {
            "sku": {"type": "string", "description": "e.g. 'ABC-1024'"},
            "qty": {"type": "integer"},
            "unit_price": {"type": "number"}
        },
        "required": ["qty", "unit_price"]
    }
}

สร้างการตรวจสอบตัวเองไว้ในระบบ

สคีมาที่ดีช่วยให้คุณตรวจพบข้อผิดพลาดได้ หากต้องการตรวจสอบการคำนวณ ให้ดึงทั้งค่า ที่คำนวณได้ AND ค่า ที่ระบุไว้ จากนั้นจึงเปรียบเทียบค่าทั้งสองในโค้ด

ตัวอย่างเช่น ให้เก็บ stated_total (ยอดรวมที่พิมพ์อยู่ในเอกสาร) ไว้พร้อมกับรายการแต่ละบรรทัดที่คุณสามารถนำมาบวกเองได้ หากค่าไม่ตรงกัน ก็จะแจ้งความคลาดเคลื่อนในการดึงข้อมูลหรือในเอกสารก่อนที่ปัญหาจะส่งต่อไปยังระบบถัดไป

"stated_total": {
    "type": "number",
    "description": "The grand total exactly as printed on the invoice."
}
# In code:
# calc = sum(li['qty'] * li['unit_price'] for li in items)
# if abs(calc - data['stated_total']) > 0.01: flag_discrepancy()

ตรวจสอบก่อน แล้วลองใหม่พร้อมข้อมูลป้อนกลับ

สคีมารับประกันรูปแบบของ JSON แต่ไม่ได้รับประกันความถูกต้องทางธุรกิจ ให้เพิ่มการตรวจสอบในรูปแบบ Pydantic เข้าไป เมื่อการตรวจสอบล้มเหลวเนื่องจาก ข้อผิดพลาดด้านรูปแบบ / โครงสร้าง / การคำนวณ ให้ลองใหม่ — แต่ต้องส่งข้อมูลว่าข้อผิดพลาดเกิดขึ้นอย่างไรให้โมเดลด้วย

ส่งเอกสารต้นฉบับ ผลลัพธ์ที่ผิด และข้อผิดพลาดจากการตรวจสอบที่เกิดขึ้นอย่างชัดเจน นี่คือการลองใหม่พร้อมข้อมูลป้อนกลับ โปรดทราบว่า การลองใหม่ NOT ช่วยเมื่อข้อมูลนั้น ไม่มีอยู่ ในแหล่งข้อมูลตั้งแต่แรก — การถามซ้ำกี่ครั้งก็ไม่สามารถสร้างข้อมูลที่หายไปขึ้นมาได้

messages = [
    {"role": "user", "content": original_doc},
    {"role": "assistant", "content": wrong_output},
    {"role": "user", "content":
        f"Validation failed: {error}. Re-emit corrected JSON."},
]
# Retry fixes format/arithmetic bugs, not missing facts.

บันทึกแหล่งที่มาของข้อมูลไว้ในสคีมา

สำหรับการดึงข้อมูลที่คุณต้องอธิบายหรือยืนยันในภายหลัง ให้ออกแบบฟิลด์ที่เก็บรักษา แหล่งที่มา ไว้ว่าแต่ละข้ออ้างอิงมาจากที่ใด เก็บการจับคู่ระหว่างข้ออ้างอิงกับแหล่งที่มาไว้ เช่น ชื่อแหล่งที่มา คำพูดอ้างอิง หน้า หรือวันที่

วิธีนี้เปลี่ยนการดึงข้อมูลจากกล่องดำให้เป็นกระบวนการที่ตรวจสอบได้ และช่วยให้คุณใส่คำอธิบายกับค่าที่ขัดแย้งกันได้ (มักเป็นวันที่ต่างกัน) แทนที่จะเลือกค่าใดค่าหนึ่งไปโดยไม่แจ้งให้ทราบ

"items": {
    "type": "array",
    "items": {
        "type": "object",
        "properties": {
            "value": {"type": "string"},
            "source_quote": {"type": "string",
                "description": "Verbatim text supporting this value."},
            "source_page": {"type": "integer"}
        },
        "required": ["value", "source_quote"]
    }
}

ตรวจสอบอย่างรวดเร็ว: ฟิลด์ที่เป็นตัวเลือก

คุณกำลังดึงข้อมูลใบสั่งซื้อ ใบสั่งซื้อบางรายการมี discount_code แต่ส่วนใหญ่ไม่มี สคีมาควรจัดการกับ discount_code อย่างไร

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุป: การกำหนดรูปทรงของผลลัพธ์

ประเด็นสำคัญสำหรับการออกแบบสคีมา JSON:

tool_use + สคีมา JSON กำจัดข้อผิดพลาดทางไวยากรณ์และบังคับให้มีฟิลด์ที่กำหนด
บังคับรูปทรงด้วย tool_choice: ใช้ "any" สำหรับเครื่องมือใดก็ได้ และใช้ {"type":"tool","name":"X"} สำหรับเครื่องมือที่ระบุ
กำหนด required ONLY ให้กับฟิลด์ที่มีอยู่เสมอ — การบังคับฟิลด์ที่ไม่มีข้อมูลจะทำให้เกิดการแต่งข้อมูลขึ้นมา
ใช้ ค่าแจกแจง สำหรับชุดคำศัพท์ที่ตายตัว และเพิ่ม "other" + ฟิลด์รายละเอียดเพื่อรองรับการขยาย
คำอธิบายช่วยสอนรูปแบบ ตัวอย่าง และกรณีขอบ
ดึงทั้งค่าที่คำนวณได้ AND ค่าที่ระบุไว้เพื่อตรวจสอบตัวเอง ตรวจสอบก่อน แล้วจึงลองใหม่พร้อมข้อมูลป้อนกลับสำหรับข้อผิดพลาดด้านรูปแบบ (ไม่ใช่กรณีที่ข้อมูลไม่มีอยู่)
บันทึกแหล่งที่มาเพื่อให้การดึงข้อมูลตรวจสอบและปกป้องเหตุผลได้

เริ่มต้นได้ฟรี

เรียนรู้ Python ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 26
บทเรียน: 104

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “การออกแบบสคีมา JSON” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การออกแบบสคีมา JSON” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Claude Architect ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Claude Architect มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การออกแบบสคีมา JSON”

กำหนดรูปร่างผลลัพธ์ให้ตรงกับสิ่งที่ต้องการอย่างแม่นยำ คุณปฏิบัติ Claude Architect ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Claude Architect หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Claude Architect บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “การออกแบบสคีมา JSON” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Claude Architect นี้ได้ไหม

ได้ บทเรียน Claude Architect ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Claude Architect