大语言模型稳定输出JSON的工程实践：从提示词到后处理的完整方案

这次我们来看一个在AI开发中非常实际的问题：如何让大语言模型稳定、可靠地输出结构化的JSON数据。无论是构建AI Agent、开发自动化工具，还是处理数据接口，JSON格式的稳定输出都是关键。很多开发者都遇到过模型“胡言乱语”、输出格式飘忽不定或者嵌套错误的问题，这直接影响了后续程序的稳定运行。

本文将聚焦于解决“大模型稳定输出JSON”这一核心痛点。我们会拆解问题根源，从提示词工程、调用参数、到后处理校验，提供一套完整的解决方案。无论你是在调试ChatGPT API、使用国内大模型，还是在本地部署开源模型，这里的思路和代码都能直接复用。

文章会带你完成从问题分析到方案落地的全过程：先理解为什么模型会输出不稳定的JSON，然后通过系统化的方法（包括结构化提示、函数调用、输出约束和格式校验）来根治这个问题，最后给出一个可投入生产的代码框架。如果你正在开发依赖大模型JSON输出的应用，这篇文章值得你仔细阅读。

1. 核心能力速览：解决JSON输出不稳定的工具箱

在深入细节之前，我们先通过一个表格快速了解解决大模型JSON输出不稳定问题的核心方法和工具。这能帮你快速判断哪种方案最适合你的场景。

2. 为什么大模型输出JSON总是不稳定？

在寻找解决方案之前，必须理解问题的根源。大语言模型（LLM）并非为生成严格符合语法的代码或数据格式而设计，其核心能力是基于概率预测下一个词元（token）。这种特性导致了几个典型问题：

1. 括号不匹配与格式错误：模型可能会生成{“name”: “Alice”这样缺少闭合括号的字符串，或者在字符串值中包含了未转义的双引号，如{“quote”: “He said “hello””}，这会导致标准JSON解析器直接失败。
2. 多余的解释性文本：模型倾向于“友好地”在JSON前后添加说明文字，例如：“这是你要的JSON：{...}。希望这对你有帮助！” 这层包裹的文本会让json.loads()解析失败。
3. 键名不一致与类型漂移：即使格式正确，模型也可能在多次调用中改变键名（如user_namevsusername）或将数字值输出为字符串类型（如“age”: “30”），给下游代码带来不确定性。
4. 复杂嵌套结构出错：当JSON结构较深、包含数组或嵌套对象时，模型更容易出现结构混乱，例如数组元素缺失逗号，或嵌套层级错误。

这些不稳定性在构建生产级AI应用时是致命的。一个时好时坏的JSON输出，意味着你的Agent可能无法解析指令，你的数据流水线会频繁中断。

3. 环境准备与前置条件

解决这个问题主要依赖软件环境和正确的API使用方式，对硬件没有特殊要求。

基础开发环境：

• Python 3.8+：这是与大多数AI库和工具链兼容的版本。
• 包管理工具：pip或conda。
• 代码编辑器或IDE：如 VS Code, PyCharm。

核心Python库：你需要安装以下库来处理JSON和调用大模型。

# 基础HTTP请求和JSON处理 pip install requests # 用于类型校验和数据结构定义（强烈推荐） pip install pydantic # 根据你使用的大模型平台选择安装 # OpenAI官方库（用于GPT系列） pip install openai # Anthropic官方库（用于Claude） pip install anthropic # 国内平台，例如DeepSeek（请参考对应官方文档） # pip install openai # 许多国内平台兼容OpenAI SDK格式 # 可选：LangChain，它提供了更高级的输出解析抽象 pip install langchain langchain-openai

大模型API访问权限：

• 你需要拥有目标大模型服务的API Key。
• OpenAI：在 OpenAI平台 创建API Key。
• Anthropic：在 Anthropic控制台 创建API Key。
• 国内大模型：在对应平台（如DeepSeek、智谱AI、月之暗面等）申请。

关键思维准备：请明确一点：不能100%信任模型的原始输出。我们的策略是“引导 + 校验 + 修复”，将模型视为一个需要约束和纠正的“创意伙伴”，而非一个可靠的代码生成器。

4. 方案一：前端约束——通过提示词与API参数引导

这是第一道防线，目标是在模型生成文本之前，就最大限度地引导它输出正确的JSON。

4.1 设计结构化系统提示词

在你的系统提示（system_prompt）或用户消息的开头，明确指令格式。使用清晰、无歧义的语言，并可以提供一个JSON Schema作为示例。

# 一个强大的系统提示词示例 structured_system_prompt = """ 你是一个精确的JSON数据生成器。你必须严格遵循以下规则： 1. 你的输出必须是且仅是一个**完整、有效**的JSON对象。 2. 不要输出任何JSON之外的文本、解释、Markdown代码块标记或开场白。 3. JSON必须符合下面描述的“schema”。 Schema 描述： - 根对象必须包含两个字段：`thought` 和 `action`。 - `thought` (字符串): 简要分析用户请求。 - `action` (对象): 包含 `name` (字符串) 和 `parameters` (对象) 字段。 示例输出（仅作格式参考）： {"thought": “用户想查询天气”, “action”: {“name”: “search_weather”, “parameters”: {“city”: “北京”}}} 现在，请处理用户的请求。 """

4.2 使用少样本示例（Few-Shot Prompting）

在对话历史（messages）中提供几个输入-输出对，让模型通过示例学习。这对于复杂或自定义格式特别有效。

few_shot_messages = [ {"role": "user", "content": “把‘明天下午三点开会’转换成日历事件。”}, {"role": "assistant", "content”: ‘{“thought”: “用户需要创建日历事件”, “action”: {“name”: “create_calendar_event”, “parameters”: {“title”: “开会”, “time”: “明天15:00”}}}’}, {"role": "user", “content”: “用户当前输入...”} # 模型会参考上文的格式 ]

4.3 利用API原生结构化输出功能（最推荐）

这是目前最强大、最稳定的方法。主流API都提供了直接支持。

OpenAI 函数调用 (Function Calling)：虽然名为“函数调用”，但其本质是让模型输出一个符合预定JSON Schema的参数对象，完美解决格式问题。

from openai import OpenAI import json client = OpenAI(api_key=“your-api-key”) response = client.chat.completions.create( model=“gpt-4o”, messages=[{“role”: “user”, “content”: “查询北京今天的天气”}], tools=[{ # 以前是 `functions`，新版本推荐 `tools` “type”: “function”, “function”: { “name”: “get_weather”, # 函数名，模型输出时会引用 “description”: “查询指定城市的天气”, “parameters”: { # 这就是我们定义的JSON Schema “type”: “object”, “properties”: { “city”: {“type”: “string”, “description”: “城市名”}, “date”: {“type”: “string”, “description”: “日期，默认为今天”} }, “required”: [“city”] } } }], tool_choice=“auto”, # 让模型决定是否调用 ) # 模型的输出会严格匹配 `parameters` 中定义的schema if response.choices[0].message.tool_calls: arguments = response.choices[0].message.tool_calls[0].function.arguments # arguments 已经是合法的JSON字符串，如 '{"city": "北京", "date": "2023-10-27"}' params = json.loads(arguments) print(params[“city”]) # 输出：北京

Anthropic Claude 结构化输出：Claude 3及更高版本直接支持response_format参数。

import anthropic from anthropic.types import MessageParam client = anthropic.Anthropic(api_key=“your-api-key”) response = client.messages.create( model=“claude-3-5-sonnet-20241022”, max_tokens=1000, messages=[MessageParam(role=“user”, content=“提取以下文本中的公司名和股价：‘苹果公司股价今日上涨至182美元。’”)], response_format={“type”: “json”, “schema”: { # 直接定义schema “type”: “object”, “properties”: { “company”: {“type”: “string”}, “price”: {“type”: “number”} }, “required”: [“company”, “price”] }}, ) print(response.content[0].text) # 直接输出: {"company": "苹果公司", "price": 182}

国内大模型：许多国内大模型平台（如DeepSeek、智谱GLM）也提供了兼容OpenAI函数调用格式或自定义的类似参数，请查阅对应平台的API文档。

5. 方案二：后端校验与修复——当输出出错时

无论前端约束多好，都必须有后端的兜底方案。我们的代码需要具备“抗脆弱”能力。

5.1 基础：异常捕获与重试

最简单的策略是捕获json.JSONDecodeError并重试请求。

import json import time from openai import OpenAI client = OpenAI(api_key=“your-api-key”) def get_structured_response_with_retry(prompt, max_retries=3): for attempt in range(max_retries): try: response = client.chat.completions.create( model=“gpt-3.5-turbo”, messages=[{“role”: “user”, “content”: prompt}], temperature=0.1, # 降低“创意性”，提高确定性 ) raw_output = response.choices[0].message.content.strip() # 关键步骤：尝试解析 parsed_json = json.loads(raw_output) return parsed_json # 成功则返回 except json.JSONDecodeError as e: print(f“第 {attempt + 1} 次尝试失败，输出无法解析: {raw_output[:100]}...错误: {e}”) if attempt < max_retries - 1: time.sleep(1) # 简单等待后重试 else: # 所有重试都失败，返回None或抛出异常 return None return None

5.2 进阶：使用正则表达式提取JSON

当模型在JSON外包裹了文本时，可以使用正则表达式“挖出”可能的JSON部分。

import re import json def extract_json_from_text(text): """ 从可能包含额外文本的字符串中提取第一个完整的JSON对象或数组。 """ # 匹配以 { 开头，以 } 结尾的字符串（非贪婪匹配，处理嵌套） json_pattern = r‘(\{.*?\})’ # 更健壮的模式：尝试匹配平衡的大括号（简易版，对复杂嵌套可能失效） # 对于生产环境，建议使用更复杂的解析器或状态机 matches = re.findall(json_pattern, text, re.DOTALL) # re.DOTALL 使 . 匹配换行符 for match in matches: try: # 尝试解析匹配到的字符串 return json.loads(match) except json.JSONDecodeError: continue # 如果当前匹配不是有效JSON，尝试下一个 return None # 未找到有效JSON # 测试 text_with_wrapper = “好的，这是你要的数据：\n```json\n{\”name\”: \”Bob\”, \”age\”: 25}\n```\n请查收。” result = extract_json_from_text(text_with_wrapper) print(result) # 输出：{‘name’: ‘Bob’, ‘age’: 25}

5.3 高级：让LLM自我修复（LLM-as-a-Judge）

如果解析失败，我们可以将错误输出和错误信息反馈给同一个模型，让它自己修正。这通常能解决大部分语法错误。

def self_healing_json_parse(raw_output, model=“gpt-3.5-turbo”): """尝试解析，若失败则请求模型自我修复。""" try: return json.loads(raw_output) except json.JSONDecodeError as e: print(“初次解析失败，尝试自我修复...”) repair_prompt = f""" 以下文本本应是一个JSON对象，但包含了语法错误，导致无法被解析。 错误信息：{e} 无效的文本内容：{raw_output} 请你只输出修正后的、完整的、有效的JSON文本，不要有任何其他说明。 """ repair_response = client.chat.completions.create( model=model, messages=[{“role”: “user”, “content”: repair_prompt}], temperature=0, ) repaired_text = repair_response.choices[0].message.content.strip() try: return json.loads(repaired_text) except json.JSONDecodeError: print(“自我修复也失败。”) return None

5.4 使用Pydantic进行强类型校验与清洗

即使得到了合法的JSON字典，其值类型也可能不符合预期。Pydantic库可以强制进行类型转换和校验。

from pydantic import BaseModel, ValidationError, field_validator from typing import List, Optional # 定义我们期望的数据模型 class UserAction(BaseModel): thought: str action: ‘Action’ # 使用前向引用 class Action(BaseModel): name: str parameters: dict # 在类定义后更新前向引用 UserAction.model_rebuild() def validate_with_pydantic(raw_dict): try: validated_data = UserAction.model_validate(raw_dict) # 通过校验，数据是规范的 return validated_data except ValidationError as e: print(f“数据校验失败: {e}”) # 这里可以尝试清洗数据，例如从 raw_dict 中提取必要字段构造新字典 # 或者返回None/默认值 return None # 使用示例 raw_data_from_llm = {“thought”: “用户想搜索”, “action”: {“name”: “search”, “parameters”: {“query”: “Python教程”}}} validated_action = validate_with_pydantic(raw_data_from_llm) if validated_action: print(f“动作名称: {validated_action.action.name}”) # 输出：动作名称: search

6. 整合方案：一个生产可用的稳定JSON输出管道

将上述方法组合起来，构建一个健壮的管道。

import json import re from typing import Any, Dict, Optional from openai import OpenAI from pydantic import BaseModel, ValidationError import logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) class RobustJSONParser: def __init__(self, openai_client: OpenAI, model: str = “gpt-3.5-turbo”): self.client = openai_client self.model = model def generate_with_schema(self, user_query: str, schema_definition: Dict[str, Any]) -> Optional[Dict]: """使用函数调用生成，这是首选方法。""" try: response = self.client.chat.completions.create( model=self.model, messages=[{“role”: “user”, “content”: user_query}], tools=[{ “type”: “function”, “function”: { “name”: “extract_data”, “description”: “根据用户查询提取结构化数据”, “parameters”: schema_definition } }], tool_choice={“type”: “function”, “function”: {“name”: “extract_data”}}, # 强制调用 temperature=0.1, ) msg = response.choices[0].message if msg.tool_calls: args = msg.tool_calls[0].function.arguments return json.loads(args) except Exception as e: logger.error(f“函数调用生成失败: {e}”) return None def generate_with_prompt(self, system_prompt: str, user_query: str) -> Optional[Dict]: """使用强化提示词生成，作为备选。""" try: response = self.client.chat.completions.create( model=self.model, messages=[ {“role”: “system”, “content”: system_prompt}, {“role”: “user”, “content”: user_query} ], temperature=0.1, ) raw_text = response.choices[0].message.content return self._parse_and_heal(raw_text) except Exception as e: logger.error(f“提示词生成失败: {e}”) return None def _parse_and_heal(self, raw_text: str) -> Optional[Dict]: """解析原始文本，包含提取和自修复。""" # 1. 直接解析 try: return json.loads(raw_text) except json.JSONDecodeError: pass # 2. 正则提取 json_match = self._extract_json(raw_text) if json_match: try: return json.loads(json_match) except json.JSONDecodeError: pass # 3. 自我修复 return self._request_repair(raw_text) def _extract_json(self, text: str) -> Optional[str]: """尝试从文本中提取JSON字符串。""" # 简化版正则，匹配被包裹的JSON pattern = r‘```(?:json)?\s*(\{.*?\})\s*```’ match = re.search(pattern, text, re.DOTALL) if match: return match.group(1) # 尝试匹配没有代码块的JSON pattern2 = r‘(\{.*?\})’ matches = re.findall(pattern2, text, re.DOTALL) for m in matches: # 简单验证：大括号是否基本平衡（非精确） if m.count(‘{’) == m.count(‘}’): return m return None def _request_repair(self, broken_text: str) -> Optional[Dict]: """请求模型修复JSON。""" repair_prompt = f”以下内容应该是一个JSON对象，但格式有误。请修正它，只输出有效的JSON，不要其他任何文字。\n\n{broken_text}” try: response = self.client.chat.completions.create( model=self.model, messages=[{“role”: “user”, “content”: repair_prompt}], temperature=0, ) repaired = response.choices[0].message.content.strip() return json.loads(repaired) except Exception as e: logger.error(f“自我修复请求失败: {e}”) return None def validate_with_pydantic(self, data: Dict, model_class: BaseModel): """使用Pydantic模型进行最终校验。""" try: return model_class.model_validate(data) except ValidationError as e: logger.error(f“Pydantic校验失败: {e}”) # 可以尝试从错误中提取信息进行部分数据清洗 return None # 使用示例 if __name__ == “__main__”: client = OpenAI(api_key=“your-api-key”) parser = RobustJSONParser(client) # 定义JSON Schema (符合OpenAI函数调用格式) schema = { “type”: “object”, “properties”: { “location”: {“type”: “string”}, “unit”: {“type”: “string”, “enum”: [“celsius”, “fahrenheit”]} }, “required”: [“location”] } # 方法1：首选，使用函数调用 result = parser.generate_with_schema(“今天上海温度怎么样？”, schema) if result: print(f“通过函数调用获得: {result}”) # 如果方法1失败，使用方法2：强化提示词 if not result: sys_prompt = “你是一个天气查询助手，始终以JSON格式回复，包含’location’和’unit’字段。unit只能是celsius或fahrenheit。” result = parser.generate_with_prompt(sys_prompt, “今天上海温度怎么样？”) if result: print(f“通过提示词获得: {result}”) # 最终校验（示例） if result: class WeatherQuery(BaseModel): location: str unit: str = “celsius” # 默认值 validated = parser.validate_with_pydantic(result, WeatherQuery) if validated: print(f“校验通过的数据: 地点={validated.location}, 单位={validated.unit}”)

7. 性能考量与最佳实践

在实际应用中，除了准确性，还需要考虑效率和成本。

1. 降低Token消耗：在系统提示词中描述格式要简洁。使用函数调用（Function Calling）通常比在提示词中描述Schema更节省Token，且效果更好。
2. 设置合理的Temperature：生成JSON时，将temperature参数设置为较低值（如0.1或0），以减少随机性，提高输出的一致性。
3. 超时与重试策略：网络请求和模型响应可能超时。为API调用设置合理的超时时间，并实现带有退避策略的重试机制（如指数退避）。
4. 缓存结果：对于相同的输入提示，可以考虑缓存模型的输出结果，以避免重复调用和节省成本。
5. 监控与告警：记录JSON解析失败率、重试次数等指标。当失败率超过阈值时触发告警，以便及时检查模型服务或提示词是否出现问题。
6. 备选模型：如果主模型（如GPT-4）调用失败或成本太高，可以准备一个备用的、更轻量的模型（如GPT-3.5-Turbo或Claude Haiku）作为降级方案。

8. 常见问题与排查方法

在实现稳定JSON输出的过程中，你可能会遇到以下典型问题。

9. 总结与下一步

让大模型稳定输出JSON，不是一个“魔法参数”能解决的问题，而是一个需要系统化工程思维的流程。最有效的路径是：

1. 首选API原生方案：尽可能使用OpenAI的函数调用、Anthropic的结构化输出等原生功能。这是最稳定、最省力的方式。
2. 强化提示词设计：如果原生功能不可用，必须精心设计系统提示词，结合JSON Schema描述和少样本示例。
3. 构建健壮的解析管道：永远不要假设模型输出是完美的。你的代码必须包含异常捕获、格式提取、自我修复和最终校验（如Pydantic）的多层防御。
4. 监控与迭代：在生产环境中监控JSON解析的成功率，持续优化提示词和修复逻辑。

下一步你可以探索：

• 框架集成：将上述模式封装成团队内部的SDK或工具函数。
• 流式输出处理：如果需要处理模型流式返回的Token，并实时组装/校验JSON，复杂度会更高，可以研究增量解析的策略。
• 多模型兼容：让你的解析管道能够适配不同供应商（OpenAI、Anthropic、国内大厂、本地模型）的API差异。

通过实施本文介绍的方法，你应该能显著提升AI应用中JSON数据流的可靠性，为构建更复杂的Agent和自动化流程打下坚实基础。建议将核心的RobustJSONParser类代码保存下来，它能在大多数相关项目中直接复用。