大模型结构化输出控制实战：从Prompt工程到JSON Schema约束

为什么大模型输出需要结构化约束

调用大语言模型API时，最常见的问题不是模型能力不足，而是输出格式不可控。一个本该返回JSON的接口，可能返回带Markdown标记的伪JSON，也可能在JSON外包裹解释性文字。在生产环境中，下游解析器面对这种输出直接报错，整个调用链中断。Prompt工程的核心目标之一，就是让模型输出可被程序直接消费。

结构化输出控制涵盖三个层次：Prompt层面的格式指令、API层面的约束参数、后处理层面的容错解析。三者配合才能构建可靠的LLM应用。

Prompt层：格式指令的写法规范

最基础的控制手段是在Prompt中明确输出格式。但多数人写的格式指令过于模糊，导致模型理解偏差。对比两种写法：

# 模糊写法（效果差）
请以JSON格式返回结果

# 精确写法（效果好）
请严格按以下JSON Schema输出，不要输出任何JSON以外的内容：
{
  "entities": [
    {
      "name": "string，实体名称",
      "type": "string，枚举值：person|org|location",
      "confidence": "number，0到1之间的浮点数"
    }
  ]
}
不要在JSON前后添加Markdown代码块标记或解释文字。

精确写法的关键要素：给出完整Schema示例、约束字段类型和取值范围、明确禁止多余输出。实际测试中，精确格式指令能将JSON解析成功率从60%提升到90%以上。

API层：JSON Mode与Structured Outputs参数

OpenAI从GPT-4o开始支持Structured Outputs功能，这是比JSON Mode更强的约束。两者区别如下：

import openai
from pydantic import BaseModel

# JSON Mode：模型输出合法JSON，但不保证Schema
response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    response_format={"type": "json_object"}
)

# Structured Outputs：模型输出严格符合Pydantic Schema
class Entity(BaseModel):
    name: str
    type: str  # 无枚举约束
    confidence: float

class ExtractionResult(BaseModel):
    entities: list[Entity]

response = openai.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[...],
    response_format=ExtractionResult
)

JSON Mode只保证输出合法JSON，字段名和结构仍可能偏离预期。Structured Outputs通过JSON Schema约束，保证输出的字段名、类型、必填项与定义完全一致，解析成功率接近100%。代价是Schema定义相对严格，不支持动态字段。

多模型场景下的兼容方案

不同模型厂商对结构化输出的支持程度不同。Claude支持tool_use强制JSON输出，Gemini支持response_mime_type参数，国产模型如Qwen、DeepSeek支持JSON Mode但尚不支持Structured Outputs。构建多模型应用时，需要封装兼容层：

def call_llm_with_schema(prompt, schema, model_config):
    """兼容多模型的结构化输出调用"""
    provider = model_config["provider"]
    
    if provider == "openai" and model_config.get("supports_structured_output"):
        return call_openai_structured(prompt, schema)
    elif provider == "anthropic":
        # Claude用tool_use模拟结构化输出
        tool_schema = {
            "name": "structured_output",
            "description": "输出结构化结果",
            "input_schema": schema
        }
        return call_claude_tool_use(prompt, tool_schema)
    else:
        # 通用fallback：Prompt约束 + JSON Mode
        enhanced_prompt = f"{prompt}\n\n请严格按以下Schema输出JSON：\n{json.dumps(schema, indent=2)}"
        return call_llm_json_mode(enhanced_prompt, model_config)

后处理容错：当结构化输出仍然出错

即使启用Structured Outputs，生产环境仍需容错。常见异常场景：模型输出了合法JSON但字段值越界、枚举值不在预期范围内、confidence值超出0-1区间。处理策略：

import json
import re
from pydantic import BaseModel, field_validator

def extract_json_from_response(text: str) -> dict:
    """从模型输出中提取JSON，处理常见格式问题"""
    # 1. 尝试直接解析
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        pass
    
    # 2. 去除Markdown代码块标记
    cleaned = re.sub(r'^```(?:json)?\s*', '', text.strip())
    cleaned = re.sub(r'\s*```$', '', cleaned)
    try:
        return json.loads(cleaned)
    except json.JSONDecodeError:
        pass
    
    # 3. 提取第一个完整JSON对象
    match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', text, re.DOTALL)
    if match:
        try:
            return json.loads(match.group())
        except json.JSONDecodeError:
            pass
    
    raise ValueError(f"无法从输出中提取有效JSON: {text[:200]}")


class SafeEntity(BaseModel):
    name: str
    type: str
    confidence: float
    
    @field_validator("type")
    @classmethod
    def validate_type(cls, v):
        allowed = {"person", "org", "location"}
        if v not in allowed:
            return "unknown"
        return v
    
    @field_validator("confidence")
    @classmethod
    def validate_confidence(cls, v):
        return max(0.0, min(1.0, v))

流式输出场景的结构化处理

流式场景下，模型逐token输出，无法在输出完成前判断JSON是否合法。处理方案是缓冲完整响应后再解析，或采用增量解析：

import json

class StreamingJsonParser:
    """增量解析流式JSON输出"""
    def __init__(self):
        self.buffer = ""
        self.depth = 0
        self.complete = False
    
    def append(self, token: str) -> list[dict]:
        """追加token，返回已完成的顶层对象"""
        self.buffer += token
        results = []
        start = 0
        for i, ch in enumerate(self.buffer):
            if ch == '{':
                self.depth += 1
            elif ch == '}':
                self.depth -= 1
                if self.depth == 0:
                    try:
                        obj = json.loads(self.buffer[start:i+1])
                        results.append(obj)
                        start = i + 1
                    except json.JSONDecodeError:
                        pass
        self.buffer = self.buffer[start:]
        return results

这种增量解析器适用于模型输出JSON数组或多个独立JSON对象的场景，每解析出一个完整对象即推送给下游，减少等待时间。

结构化输出的成本与延迟权衡

Structured Outputs会略微增加推理延迟（约5%-10%），因为模型需要在生成时遵守Schema约束。对于低延迟要求的实时场景，可以用Prompt约束 + JSON Mode + 轻量容错的组合替代Structured Outputs，在解析成功率和延迟间取得平衡。对于高可靠性要求的离线批处理场景，建议直接启用Structured Outputs，省去容错逻辑的开发成本。