# Outlines & Instructor: คู่มือ Structured Output LLM ด้วย Python สำหรับ SME ไทย 2026
ปัญหาที่นักพัฒนาทุกคนเจอเมื่อใช้ LLM ในระบบจริงคือ โมเดลตอบกลับเป็นข้อความที่มนุษย์อ่านได้ แต่แอปพลิเคชันต้องการ JSON หรือ Object ที่ schema คงเส้นคงวา หากปล่อยให้ LLM "พิมพ์ JSON" เอง ก็ยังเสี่ยงต่อ key หาย, ใส่ comma เกิน, หรือใส่ field ที่เราไม่ต้องการ ทำให้ระบบ Crash หรือ data corrupt
Structured Output คือเทคนิคที่บังคับให้ LLM "ห้ามตอบนอกกรอบ" — ไม่ว่าจะใช้ Constrained Decoding ระดับ token หรือ retry ผ่าน Pydantic validation ทั้งหมดนี้ทำให้นำ LLM มาเชื่อมต่อกับฐานข้อมูล, ระบบ ERP, หรือ workflow อัตโนมัติได้อย่างมั่นใจ
ในคู่มือนี้คุณจะได้เรียนรู้สองไลบรารี Python ที่ครองตลาดปี 2026: Outlines (จาก dottxt-ai) และ Instructor (จาก jxnl) ทั้งสองตัวต่างกันอย่างไร เลือกใช้แบบไหน และจะนำมาใช้กับระบบของ SME ไทยได้ทันทีอย่างไร
Outlines คืออะไร?
Outlines เป็นไลบรารีของ dottxt-ai ที่ใช้แนวทาง Constrained Generation ระดับ token แก้ที่ต้นเหตุ ไม่ปล่อยให้ LLM พิมพ์ token ที่ออกนอก schema ตั้งแต่แรก โดยใช้ Finite-State Machine (FSM) ที่ compile มาจาก JSON Schema, Regex หรือ Pydantic Model
จุดเด่นของ Outlines:
ตัวอย่างการใช้งาน Outlines:
```python
import outlines
from pydantic import BaseModel
class Customer(BaseModel):
name: str
age: int
email: str
model = outlines.models.transformers("Qwen/Qwen2.5-7B-Instruct")
generator = outlines.generate.json(model, Customer)
result = generator("ดึงข้อมูลลูกค้า: คุณสมชาย อายุ 35 ปี email somchai@example.com")
```
ผลลัพธ์ที่ได้คือ Pydantic object ที่ถูก validate แล้ว ไม่มีทาง parse error
Instructor คืออะไร?
Instructor (เขียนโดย Jason Liu) ใช้คนละวิธี เป็น wrapper บน OpenAI SDK, Anthropic SDK, Gemini, Cohere ที่ใช้ Pydantic เป็นภาษากลาง พร้อม retry loop อัตโนมัติเมื่อ JSON ไม่ผ่าน validation
จุดเด่นของ Instructor:
ตัวอย่างการใช้งาน Instructor:
```python
import instructor
from openai import OpenAI
from pydantic import BaseModel
class Invoice(BaseModel):
invoice_number: str
total_thb: float
vat_thb: float
client = instructor.from_openai(OpenAI())
invoice = client.chat.completions.create(
model="gpt-4o-mini",
response_model=Invoice,
messages=[{"role": "user", "content": "อ่านใบกำกับภาษี เลขที่ INV-2026-001 ยอด 10,700 บาท VAT 700 บาท"}],
)
```
Instructor จะ retry ให้อัตโนมัติถ้า GPT ตอบ JSON ผิดรูป โดยส่ง error message กลับให้ LLM แก้ไข
เปรียบเทียบ Outlines vs Instructor
| หัวข้อ | Outlines | Instructor |
|---|---|---|
| Approach | Constrained Decoding (FSM ระดับ token) | Pydantic + Retry Validation |
| ใช้กับ | Open-Source LLM (Local/Self-Host) | Cloud API (GPT, Claude, Gemini) |
| รับประกัน Schema | 100% ตั้งแต่ generation | ขึ้นกับ retry attempts |
| Latency | ต่ำ (single pass) | สูงขึ้นเมื่อ retry |
| Streaming | รองรับ | Partial + Iterable |
| Cost | Compute on-prem | API token cost x retries |
| Learning curve | กลาง (ต้องรู้ vLLM/Transformers) | ต่ำ (เพิ่ม wrapper บรรทัดเดียว) |
สรุปการเลือก:
How-to: ติดตั้ง Instructor ใน 5 ขั้นตอน
ตัวอย่าง Use Case: ดึงข้อมูลออเดอร์จากข้อความแชทลูกค้าใส่ระบบ ERP
ขั้นตอนที่ 1 ติดตั้ง dependency
```bash
pip install instructor openai pydantic
```
ขั้นตอนที่ 2 กำหนด Pydantic Model
```python
from pydantic import BaseModel, Field
from typing import List
class OrderItem(BaseModel):
sku: str = Field(description="รหัสสินค้า")
qty: int = Field(gt=0)
price_thb: float
class Order(BaseModel):
customer_name: str
delivery_address: str
items: List[OrderItem]
total_thb: float
```
ขั้นตอนที่ 3 สร้าง client
```python
import instructor
from openai import OpenAI
client = instructor.from_openai(OpenAI(api_key="..."))
```
ขั้นตอนที่ 4 ส่งข้อความและรับ Pydantic object
```python
chat_text = "ลูกค้าคุณวิภา ขอ 2 ชิ้น SKU A001 ราคา 250 บาท ส่งบางนา"
order = client.chat.completions.create(
model="gpt-4o-mini",
response_model=Order,
messages=[{"role": "user", "content": chat_text}],
max_retries=3,
)
```
ขั้นตอนที่ 5 บันทึกลง ERP
```python
erp_api.create_order(order.model_dump())
```
เสร็จสิ้น ไม่ต้อง Regex, ไม่ต้อง JSON.parse ลด bug ได้ ~80%
How-to: Self-Host LLM ด้วย Outlines + vLLM
ขั้นตอนที่ 1 ตั้ง vLLM Server
```bash
pip install vllm outlines
python -m vllm.entrypoints.openai.api_server \
--model Qwen/Qwen2.5-7B-Instruct \
--port 8000
```
ขั้นตอนที่ 2 ใช้ Outlines เรียกผ่าน vLLM
```python
from outlines.models.vllm import VLLMOpenAI
import outlines
model = VLLMOpenAI("http://localhost:8000/v1", "Qwen/Qwen2.5-7B-Instruct")
generator = outlines.generate.json(model, Order)
order = generator("ลูกค้าคุณวิภา ขอ 2 ชิ้น SKU A001 ...")
```
ขั้นตอนที่ 3 บังคับ Format ระดับ token จึงไม่มีทาง parse fail
Best Practices สำหรับ Production
ใช้ Pydantic v2 เสมอเพื่อรองรับ Field constraints ที่ครบถ้วน ตั้ง Field descriptions ให้ละเอียด เพราะ LLM ใช้ description เป็น hint ส่ง JSON Schema ที่ "เข้มงวดเกินจำเป็น" จะทำให้โมเดลผิดบ่อย ค่อย ๆ ลดข้อจำกัดทีละนิด
ติดตั้ง observability เช่น Logfire หรือ Langfuse เพื่อนับ retry rate ถ้า retry > 5% แสดงว่า prompt ต้องแก้
ทดสอบด้วย Adversarial Inputs เช่น ภาษาผสมไทย-อังกฤษ, อิโมจิ, ตัวเลขในรูปแบบ "หมื่น/แสน" เพื่อให้แน่ใจว่า schema robust
สรุปและขั้นตอนถัดไป
Outlines และ Instructor คือเครื่องมือสำคัญที่ทำให้ LLM กลายเป็นส่วนหนึ่งของ production system ได้อย่างจริงจัง ทั้งสองตัวมี jurisdiction ต่างกัน Outlines เก่งกับ Local LLM ส่วน Instructor เก่งกับ Cloud API การเลือกใช้ขึ้นกับ infrastructure และงบประมาณของคุณ
สำหรับ SME ไทยที่กำลังจะเริ่ม แนะนำให้ลอง Instructor ก่อน ติดตั้งง่าย ใช้กับ GPT-4o-mini ราคาถูก มี ROI สูงเมื่อใช้กับงาน Form Extraction, OCR Post-processing, Chatbot Intent Routing
ต้องการคำปรึกษาเรื่อง LLM Integration, RAG Pipeline หรือ AI Workflow Automation? ติดต่อทีม ADS FIT เพื่อ Audit ระบบและออกแบบสถาปัตยกรรมที่เหมาะกับธุรกิจของคุณ
อ่านต่อ: [Cline AI Coding Agent](/blog/cline-open-source-ai-coding-agent-vscode-byok-guide-sme-thailand-2026), [Qwen LLM 2026](/blog/qwen-alibaba-open-source-llm-guide-sme-thailand-2026), [Gemma Google Open-Source LLM](/blog/gemma-google-open-source-llm-on-device-ai-guide-sme-thailand-2026)