Structured Prompting 2026: XML, JSON Schema, Output Types và Chain-of-Thought

Unstructured prompts sinh unstructured output. Structured prompts sinh output predictable, parseable, testable.

Trong production systems, bạn không thể parse free-text responses. Bạn cần guaranteed fields, typed values và machine-readable output. Structured prompting giải quyết việc này — và năm 2026 có 4 patterns chính.

Bốn Patterns#

Pattern	Input Style	Output Style	Best For
XML Tags	`<tag>content</tag>`	Structured text	System prompts, tool calls
JSON Schemas	JSON definition	JSON output	API integration, validation
Output Types	Pydantic/Zod model	Typed object	Type-safe applications
Chain-of-Thought	Reasoning traces	Step-by-step + answer	Complex reasoning

1. XML Tags#

1
<task>Viết PostgreSQL query tìm users chưa login 90 ngày</task>
2
<schema>users table: id (UUID), email (text), last_login (timestamp)</schema>
3
<constraints>
4
- Dùng parameterized queries
5
- Return only user_id và email
6
</constraints>
7
<output_format>Return ONLY SQL query. Không giải thích.</output_format>

Best Practices#

Tag names ngắn, descriptive: <task>, <context>, <output>
Nest sparingly — deep nesting confuses models
Consistent casing — <tag> every time
Đóng mọi tag
Để blank lines giữa các tags

2. JSON Schemas#

1
schema = {
2
    "type": "object",
3
    "properties": {
4
        "severity": {
5
            "type": "string",
6
            "enum": ["critical", "high", "medium", "low"]
7
        },
8
        "root_cause": {"type": "string"},
9
        "action_items": {
10
            "type": "array",
11
            "items": {"type": "string"}
12
        }
13
    },
14
    "required": ["severity", "root_cause", "action_items"]
15
}

Tại sao JSON schemas thắng trong production:#

Validatable — jsonschema hoặc pydantic validate output
Parseable — json.loads() là xong
Type-safe — Boolean là boolean, number là number
Auto-retry — Output invalid JSON → frameworks retry với error message
API-ready — Pass output trực tiếp vào downstream systems

3. Output Types#

1
# Pydantic
2
class CodeReview(BaseModel):
3
    file_path: str
4
    issues: list[dict]
5
    score: int = Field(ge=1, le=10)
6
    verdict: Literal["approve", "changes_requested", "blocked"]

1
// Zod
2
const CodeReviewSchema = z.object({
3
  filePath: z.string(),
4
  score: z.number().min(1).max(10),
5
  verdict: z.enum(["approve", "changes_requested", "blocked"]),
6
});

Output types thắng unstructured nhờ: parse errors ít, type safety, self-documenting, IDE support, testability.

4. Chain-of-Thought#

CoT prompting buộc model reasoning step-by-step trước khi trả lời:

1
prompt = """Solve step by step, then output JSON.
2

3
Problem: Payment $156.78, fee 2.9% + $0.30. Net amount?
4

5
Step by step:
6
1. Percentage fee: $156.78 × 0.029 = $4.55
7
2. Fixed fee: $0.30
8
3. Total fee: $4.85
9
4. Net: $156.78 - $4.85 = $151.93
10

11
JSON output:
12
{
13
    "gross_amount": 156.78,
14
    "net_amount": 151.93,
15
    "total_fee": 4.85
16
}
17
"""

Kết Hợp Cả Bốn Patterns#

1
prompt = """
2
<task>Phân tích incident deployment dưới đây</task>
3
<context>Service: payment-api, Time: 02:15 UTC, Error: Connection pool exhaustion</context>
4

5
<reasoning>Suy luận step-by-step trước khi trả lời</reasoning>
6

7
<output_format>
8
Return JSON matching schema: { "root_cause": "string", "severity": "critical|high|medium|low", "prevention": ["string"] }
9
</output_format>
10
"""

XML tags — Tách context khỏi instructions
Chain-of-thought — Buộc reasoning trước output
JSON schema — Constrain output structure
Pydantic validation — Đảm bảo response dùng được programmatically

Anti-Patterns#

Mix formats — JSON trong XML trong YAML → Pick one format
Over-specifying — 20+ fields → Giữ schema dưới 8 fields
No fallback for parse failures — Luôn có try/except + regex fallback

Production Checklist#

Output format specified BEFORE user input
JSON schemas include field descriptions
Schemas validated with Pydantic/Zod pre-deployment
Parse failures có fallback strategy
CoT tách biệt khỏi final output
XML tags consistent (case, nesting, closing)
Schema complexity matches task complexity

Tiếp Theo#

Bài	Chủ đề
1	System Prompts vs Steering Files vs Agent Instructions
2	MCP Tools as Prompts
3	Structured Prompting (bài này)
4	Prompt Testing & Evaluation
5	Production Patterns & Anti-Patterns

Series: Prompt Engineering 2026 — Production Patterns. Bài 3: Structured Prompting.