สอนใช้งาน GPT สร้างข้อมูล JSON แบบมีโครงสร้าง ง่ายๆ สำหรับมือใหม่

ทำความรู้จักกับ JSON แบบมีโครงสร้าง ทำไมต้องเรียนรู้ตั้งแต่วันนี้

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

วันนี้ผมจะมาสอนเทคนิคที่ผมใช้มาตลอดในการทำงานจริง นั่นคือการสั่งให้ AI ตอบกลับมาเป็น JSON ที่มีโครงสร้างชัดเจน เวลาเอาไปใช้งานจริง ดึงข้อมูลได้ทันทีโดยไม่ต้องมานั่ง parse เอง จากประสบการณ์ที่ใช้มา เทคนิคนี้ช่วยประหยัดเวลาการทำงานได้มากกว่า 70% เลยทีเดียว

สำหรับผู้ที่ยังไม่มี API Key ของ AI ผมแนะนำให้ลองใช้ สมัครที่นี่ เพราะราคาถูกมากๆ เมื่อเทียบกับที่อื่น ราคาเริ่มต้นเพียง $0.42 ต่อล้านตัวอักษร ประหยัดได้มากกว่า 85% เลยครับ

JSON คืออะไร ทำไม AI ถึงต้องสร้างข้อมูลแบบนี้

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

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

เตรียมพร้อมก่อนเริ่มต้น สิ่งที่ต้องมี

ก่อนจะเริ่มเรียนรู้เทคนิคนี้ ผมอยากให้ทุกคนเตรียมสิ่งเหล่านี้ให้พร้อมก่อน จะได้ทำตามได้เลยไม่ติดขัด

• API Key — ถ้ายังไม่มี ไปสมัครได้ที่ สมัครที่นี่ ได้เลยครับ ระบบจะให้เครดิตฟรีเมื่อลงทะเบียน ใช้ทดลองได้ก่อนโดยไม่ต้องเติมเงิน
• Python — ภาษาโปรแกรมที่ผมจะใช้สอนในบทความนี้ ถ้ายังไม่เคยติดตั้ง ไปดาวน์โหลดได้ที่ python.org ได้เลยครับ ติดตั้งง่ายมาก
• โปรแกรม Text Editor — ใช้ VS Code หรือ Notepad++ ก็ได้ เพื่อเขียนโค้ดของเรา
• โมเดล AI — ผมจะใช้ GPT-4.1 ซึ่งมีค่าใช้จ่ายเพียง $8 ต่อล้านตัวอักษร หรือจะเลือก Gemini 2.5 Flash ก็ได้ ราคาถูกกว่าคือ $2.50 ต่อล้านตัวอักษร

ขั้นตอนที่ 1 ติดตั้ง library ที่จำเป็น

ขั้นตอนแรกเราต้องติดตั้ง library ที่ชื่อ openai ก่อนครับ library นี้จะเป็นตัวเชื่อมต่อกับ API ของ AI ให้เรา วิธีติดตั้งก็ง่ายมาก เปิดหน้าต่าง command line ขึ้นมา แล้วพิมพ์คำสั่งนี้ลงไป

pip install openai

รอสักครู่ให้ระบบดาวน์โหลดและติดตั้งเสร็จ ถ้าขึ้นข้อความ Successfully installed แสดงว่าติดตั้งสำเร็จแล้วครับ สำหรับใครที่ใช้ Python เวอร์ชันเก่า อาจจะต้องใช้คำสั่ง pip3 แทน pip นะครับ แต่สำหรับ Python 3.4 ขึ้นไปใช้ pip ได้เลย

ขั้นตอนที่ 2 เขียนโค้ดเชื่อมต่อ API ครั้งแรก

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

from openai import OpenAI

สร้าง client เพื่อเชื่อมต่อกับ API
client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

ลองส่งข้อความง่ายๆ ไปถาม AI
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "user", "content": "ทักทาย AI สั้นๆ หน่อยได้ไหม"}
    ]
)

แสดงผลลัพธ์ที่ได้รับ
print(response.choices[0].message.content)

ถ้าทุกอย่างถูกต้อง คุณจะเห็นข้อความตอบกลับจาก AI ปรากฏขึ้นมาบนหน้าจอครับ จากประสบการณ์ที่ใช้งาน HolySheep API ความเร็วในการตอบกลับอยู่ที่น้อยกว่า 50 มิลลิวินาทีเท่านั้น เร็วมากๆ เลยครับ

ขั้นตอนที่ 3 สร้าง JSON Schema กำหนดโครงสร้างข้อมูลที่ต้องการ

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

import json

กำหนดโครงสร้างข้อมูลที่ต้องการ
json_schema = {
    "type": "object",
    "properties": {
        "sentiment": {
            "type": "string",
            "description": "ความรู้สึกโดยรวม เช่น ดีใจ พอใจ ไม่พอใจ เฉยๆ",
            "enum": ["ดีใจมาก", "พอใจ", "เฉยๆ", "ไม่พอใจ", "ไม่พอใจมาก"]
        },
        "rating": {
            "type": "number",
            "description": "คะแนนจาก 1 ถึง 5",
            "minimum": 1,
            "maximum": 5
        },
        "pros": {
            "type": "array",
            "description": "ข้อดีที่พบ",
            "items": {"type": "string"}
        },
        "cons": {
            "type": "array",
            "description": "ข้อเสียที่พบ",
            "items": {"type": "string"}
        },
        "summary": {
            "type": "string",
            "description": "สรุปรีวิวแบบสั้นไม่เกิน 50 ตัวอักษร"
        }
    },
    "required": ["sentiment", "rating", "summary"]
}

แปลงเป็นข้อความสำหรับส่งให้ AI
schema_text = json.dumps(json_schema, ensure_ascii=False, indent=2)
print(schema_text)

อธิบายเพิ่มนิดหน่อยนะครับ ส่วน type บอกว่าข้อมูลนั้นเป็นประเภทอะไร object คือกลุ่มข้อมูล string คือตัวอักษร number คือตัวเลข array คือรายการ ส่วน required คือช่องที่บังคับว่าต้องมี ถ้าไม่ใส่ใน required จะเป็นช่องที่มีก็ได้ไม่มีก็ได้ ส่วน description จะเป็นคำอธิบายสำหรับ AI ให้เข้าใจว่าเราต้องการข้อมูลอะไร

ขั้นตอนที่ 4 นำ Schema ไปใช้กับ API

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

from openai import OpenAI
import json

client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

กำหนดโครงสร้างข้อมูลที่ต้องการ
json_schema = {
    "type": "object",
    "properties": {
        "product_name": {"type": "string", "description": "ชื่อสินค้า"},
        "price": {"type": "number", "description": "ราคาเป็นตัวเลข"},
        "in_stock": {"type": "boolean", "description": "สินค้ามีใน stock หรือไม่"},
        "categories": {"type": "array", "items": {"type": "string"}, "description": "หมวดหมู่สินค้า"}
    },
    "required": ["product_name", "price", "in_stock"]
}

ข้อความที่จะถาม AI
user_question = "สินค้า: โทรศัพท์มือถือรุ่น Pro Max ราคา 25000 บาท มีใน stock อยู่ 5 เครื่อง หมวดหมู่: อิเล็กทรอนิกส์, มือถือ, สื่อสาร"

ส่งคำถามพร้อม Schema ไปให้ AI
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {
            "role": "system",
            "content": f"คุณเป็นผู้ช่วยที่ตอบกลับเป็น JSON ที่มีโครงสร้างเท่านั้น ใช้ Schema นี้: {json.dumps(json_schema, ensure_ascii=False)}"
        },
        {
            "role": "user", 
            "content": user_question
        }
    ],
    temperature=0.1
)

รับผลลัพธ์และแปลงเป็น Dictionary
result_text = response.choices[0].message.content
result_dict = json.loads(result_text)

แสดงผลลัพธ์เป็นระเบียบ
print("ผลลัพธ์ที่ได้รับ:")
print(f"ชื่อสินค้า: {result_dict['product_name']}")
print(f"ราคา: {result_dict['price']} บาท")
print(f"มีใน stock: {'ใช่' if result_dict['in_stock'] else 'ไม่ใช่'}")
print(f"หมวดหมู่: {', '.join(result_dict.get('categories', []))}")

จากโค้ดด้านบน มีจุดสำคัญที่ต้องสังเกตตรง temperature ผมตั้งไว้ที่ 0.1 ซึ่งต่ำมาก เหตุผลคือยิ่งค่า temperature สูง AI จะยิ่งตอบแบบสร้างสรรค์มากขึ้น ซึ่งอาจทำให้ JSON ที่ได้ออกมาไม่ตรงตาม Schema ที่กำหนด การตั้งค่าต่ำๆ จะทำให้ได้ผลลัพธ์ที่ตรงไปตรงมากว่า เหมาะกับงานที่ต้องการข้อมูลที่แม่นยำครับ

ตัวอย่างการประยุกต์ใช้ในงานจริง

ต่อไปผมจะมายกตัวอย่างการนำเทคนิคนี้ไปใช้ในงานจริงหลายๆ แบบครับ จะได้เห็นภาพว่าใช้ประโยชน์ได้หลากหลายแค่ไหน

ตัวอย่างที่ 1 วิเคราะห์ข่าว ถ้าเราต้องการให้ AI อ่านข่าวแล้วสรุปออกมาเป็นข้อมูลที่จัดเก็บได้ ผมจะใช้ Schema แบบนี้ครับ

news_schema = {
    "type": "object",
    "properties": {
        "headline": {"type": "string", "description": "หัวข้อข่าว"},
        "date": {"type": "string", "description": "วันที่ในรูปแบบ YYYY-MM-DD"},
        "source": {"type": "string", "description": "แหล่งที่มาของข่าว"},
        "category": {"type": "string", "description": "หมวดหมู่ข่าว เช่น เศรษฐกิจ กีฬา เทคโนโลยี"},
        "summary": {"type": "string", "description": "สรุปข่าวไม่เกิน 200 ตัวอักษร"},
        "key_people": {"type": "array", "items": {"type": "string"}, "description": "บุคคลสำคัญที่เกี่ยวข้อง"},
        "locations": {"type": "array", "items": {"type": "string"}, "description": "สถานที่ที่เกี่ยวข้อง"}
    },
    "required": ["headline", "date", "category", "summary"]
}

ตัวอย่างที่ 2 จัดการข้อมูลลูกค้า สมมติว่าเราต้องการให้ AI ช่วยจัดกลุ่มลูกค้าตามพฤติกรรมการซื้อ ผมจะใช้ Schema แบบนี้ครับ

customer_schema = {
    "type": "object",
    "properties": {
        "customer_id": {"type": "string", "description": "รหัสลูกค้า"},
        "segment": {"type": "string", "description": "กลุ่มลูกค้า VIP, ประจำ, ทั่วไป, ใหม่"},
        "total_spent": {"type": "number", "description": "ยอดซื้อรวมเป็นตัวเลข"},
        "order_count": {"type": "integer", "description": "จำนวนคำสั่งซื้อ"},
        "preferred_categories": {"type": "array", "items": {"type": "string"}},
        "churn_risk": {"type": "string", "enum": ["สูง", "กลาง", "ต่ำ"], "description": "ความเสี่ยงที่ลูกค้าจะหายไป"},
        "recommendations": {"type": "array", "items": {"type": "string"}, "description": "สินค้าแนะนำ"}
    },
    "required": ["customer_id", "segment", "total_spent", "churn_risk"]
}

การจัดการข้อผิดพลาดและการตรวจสอบข้อมูล

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

import json
from jsonschema import validate, ValidationError

def get_structured_data(client, user_input, schema):
    """ฟังก์ชันสำหรับดึงข้อมูล JSON พร้อมตรวจสอบ Schema"""
    
    try:
        # ส่ง request ไปยัง API
        response = client.chat.completions.create(
            model="gpt-4.1",
            messages=[
                {
                    "role": "system",
                    "content": f"ตอบกลับเป็น JSON ที่มีโครงสร้างตาม Schema นี้เท่านั้น ห้ามมีข้อความอื่น: {json.dumps(schema, ensure_ascii=False)}"
                },
                {"role": "user", "content": user_input}
            ],
            temperature=0.1
        )
        
        # แปลงข้อความตอบกลับเป็น Dictionary
        result = json.loads(response.choices[0].message.content)
        
        # ตรวจสอบว่าข้อมูลตรงกับ Schema หรือไม่
        validate(instance=result, schema=schema)
        
        return {"success": True, "data": result}
        
    except json.JSONDecodeError:
        return {"success": False, "error": "รูปแบบ JSON ไม่ถูกต้อง"}
    except ValidationError as e:
        return {"success": False, "error": f"ข้อมูลไม่ตรง Schema: {e.message}"}
    except Exception as e:
        return {"success": False, "error": f"เกิดข้อผิดพลาด: {str(e)}"}

วิธีใช้งาน
result = get_structured_data(client, "วิเคราะห์ข่าวนี้: วันนี้ตลาดหุ้นไทยปิดบวก 50 จุด", news_schema)

if result["success"]:
    print("ข้อมูลที่ได้:", json.dumps(result["data"], ensure_ascii=False, indent=2))
else:
    print("เกิดข้อผิดพลาด:", result["error"])

สำหรับ library jsonschema ถ้ายังไม่มีก็ติ