众所周知，大模型的核心原理是『文字接龙』，通过概率计算输出下一个 Token，这种机制天然存在幻觉问题，导致模型会一本正经的胡说八道。

当要求大模型输出 JSON 格式时，也常因为幻觉问题遇到各种格式灾难：

• 附带冗余话术：比如前后夹带“好的，这是你要的结果”、“以下是符合要求的JSON”。
• Markdown 标签包裹：带有 ```json 标签，导致无法直接解析。
• 非法格式：用单引号替代双引号、转义字符使用错误等。
• 语法漏洞：尾部缺失反括号、字段后多添逗号等。

显然，这种不合规的 JSON 输出无法正常被 json.load()正确解析，直接导致业务代码报错。

为了解决这个问题，我们需要在调用大模型的前、中、后三个阶段，分别采取一些处理措施（事前引导、事中约束、事后补救），全方位确保大模型能够输出稳定、纯净的 JSON。

下面我们以『判断用户输入的内容，是否违规？违规类型是什么？违规词是什么？』这个需求为例，详细介绍下具体处理手段。

一、事前引导：提示词优化

提示词优化是最基础、最通用的解决方案，核心是通过明确严谨的指令，引导大模型输出符合要求的 JSON。

这种方式属于『软约束』，依赖模型对指令的理解和执行能力，无法从源头强制合规，但胜在简单易用、适配所有大模型。

常见的优化方式为：

1. 明确字段要求：详细说明每个字段的输出类型、取值范围，而非简单要求输出 JSON；
2. 提供 Few-Shot 示例：借助大模型的上下文学习能力，给出输入输出配对示例，让模型直观掌握格式；
3. 添加校验指令：要求大模型输出前自动校验 JSON 语法及内容合规性，确保无冗余、无错误。

💡 提示词模板示例如下：

# 角色
你是一个严格的用户输入违规判断助手，负责对用户输入内容进行违规判定，并严格按预设规则输出合规JSON结果。
# 技能
- **核心违规类型**：用户输入含「色情」「暴力」「辱骂」类词汇，或违法、广告推广等其他明确违规内容 → 违规；否则不违规。
- **违规词提取**：仅提取用户输入中明确出现的核心违规词汇，不新增、不推断。
# 输出格式
**严格按以下格式生成JSON**：
{
    "is_illegal": <boolean>,
    "illegal_type": <string>,
    "illegal_words": <list>
}
# 限制
- **输出唯一**：仅输出符合规则的JSON，禁止任何非JSON内容，并且 JSON 中的 key 名不可修改，禁止新增/遗漏key。
- **输出内容**：
  - `is_illegal`：小写`true`/`false`。
  - `illegal_type`：仅允许`"色情"/"暴力"/"辱骂"/"其他"/""`。
  - `illegal_words`：无违规词则为`[]`，否则为原始输入词汇列表。
- **边界规则**：仅提取用户明确输入的核心违规词，不拆分/扩展/推断词汇。
# 核心要求
- 严格遵循上述规则，输出前自动校验JSON语法及内容合规性，确保无冗余、无错误。
# 示例
## 示例1输入：今天天气不错，适合去公园散步。 
## 示例1输出：
   {
       "is_illegal": false,
       "illegal_type": "",
       "illegal_words": []
   }
## 示例2输入：你这个蠢货，滚远点！”  
## 示例2输出：
   {
       "is_illegal": true,
       "illegal_type": "辱骂",
       "illegal_words": ["蠢货", "滚远点"]
   }
## 示例3输入：本产品能治百病，点击链接购买享8折！
## 示例3输出：
   {
       "is_illegal": true,
       "illegal_type": "其他",
       "illegal_words":  ["本产品能治百病", "点击链接购买"]
   }

二、事中约束：编码管控

提示词优化是一种『软约束』手段，存在局限性，即使指令再明确，大模型仍然可能因为幻觉、随机性出现格式偏差。为此，主流大模型厂商推出了原生『硬约束』能力，可在模型生成结果过程中强制输出合规 JSON。

其核心原理简单来说：系统会将 JSON 规则转换为状态机，在模型生成每个 Token 前过滤非法内容，仅允许合法Token 参与概率计算，从底层确保输出完全符合 JSON 规范和字段要求（例如：生成冒号后，下一个 Token 绝不可能是逗号）。

⚠️ 注意：并非所有大模型都支持这类硬约束功能，多数轻量模型、小众模型暂不支持，仅适配OpenAI系列、Anthropic Claude 等主流模型。

1. JSON Mode：基础格式硬约束

JSON Mode 是基础硬约束功能，通过 API 参数约束模型输出编码逻辑，强制生成符合 JSON 语法规范的文本，从源头杜绝冗余话术、代码块包裹等问题。

核心操作：调用接口时新增response_format={"type": "json_object"}参数，且提示词中需明确提及“JSON”（否则模型报错）。

⚠️ 注意：JSON Mode 仅保证输出格式为合规 JSON，不支持在 response_format 中输入具体 schema，无法锁定字段规则，仍可能出现字段遗漏，key 名写错问题；

📝 代码示例如下（以 OpenAI SDK 为例）：

import json
from openai import OpenAI

client = OpenAI(
    api_key="your_api_key",
    base_url="https://api.openai.com/v1"
)
MODEL ="gpt-4o-mini"

if __name__ == "__main__":
    system_prompt = """
# 角色
你是一个...
"""
    user_prompt = "真是一头猪"
    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
    response = client.chat.completions.create(model=MODEL, messages= messages,  response_format={"type": "json_object"})
    result = json.loads(response.choices[0].message.content)
    print(result)

2. Structured Outputs：格式+字段双维度强制

JSON Mode 仅能保证输出的格式为 JSON，但并不能保证字段是否准确、是否完整等。

为了解决这个问题，诞生了 Structured Outputs（结构化输出）功能，可通过定义完整的 JSON Schema，强制模型输出指定字段及类型，彻底杜绝 key 名错误和字段遗漏问题。

核心操作：调用接口时在 response_format 中传入具体 JSON Schema，实现格式与字段的双重硬约束，确保模型输出完全匹配预设的字段规则，合规率 100%，这也是官方主推的结构化输出方案。

📝 代码示例如下（以 OpenAI SDK 为例）：

import json
from openai import OpenAI

client = OpenAI(
    api_key="your_api_key",
    base_url="https://api.openai.com/v1"
)
MODEL ="gpt-4o-mini"

if __name__ == "__main__":
    system_prompt = """
# 角色
你是一个...
"""
    user_prompt = "真是一头猪"
    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
    response = client.chat.completions.create(model=MODEL, messages= messages,    response_format = {
        "type": "json_schema",
        "json_schema": {
            "name": "illegal_judge_result",
            "strict": True,  # 严格遵循schema，杜绝字段遗漏、类型错误
            "schema": {
                "type": "object",
                "properties": {
                    "is_illegal": {
                        "type": "boolean",
                        "description": "是否违规，仅true/false（小写）"
                    },
                    "illegal_type": {
                        "type": "string",
                        "description": "违规类型，仅允许'色情'/'暴力'/'辱骂'/'其他'/''"
                    },
                    "illegal_words": {
                        "type": "array",
                        "description": "违规词列表，无违规则为[]，仅含用户输入的核心词汇"
                    }
                },
                "required": ["is_illegal", "illegal_type", "illegal_words"],
                "additionalProperties": False  # 禁止新增额外字段
            }
        }
    })
    result = json.loads(response.choices[0].message.content)
    print(result)

3. Function Calling 工具调用

Function Calling（工具调用）同样能间接实现稳定 JSON 输出，并且支持格式与字段的双约束。

我们在调用大模型接口时，通过tools参数定义完整的工具 JSON Schema（明确字段名、类型、必填项等规则），并要求模型调用该工具。模型为确保工具正常调用，会严格按照预设 Schema 输出合规的函数参数，而这些参数本身就是一段合规 JSON。

核心操作：调用接口时，用tools定义 Schema 规则，通过tool_choice强制模型调用函数，直接提取参数即可获得合规 JSON，无需额外处理。

📝 代码示例如下（以 OpenAI SDK 为例）：

import json
from openai import OpenAI

client = OpenAI(
    api_key="your_api_key",
    base_url="https://api.openai.com/v1"
)
MODEL ="gpt-4o-mini"

if __name__ == "__main__":
    system_prompt = """
# 角色
你是一个...
"""
    user_prompt = "真是一头猪"
    tools = [{
        "type": "function",
        "function": {
            "name": "process_illegal_judge",
            "strict": True, # 开启严格模式，必须返回JSON格式
            "description": "对用户输入进行违规判定，返回结构化JSON结果",
            "parameters": {
                "type": "object",
                "properties": {
                    "is_illegal": {
                        "type": "boolean",
                        "description": "是否违规，仅true/false（小写）"
                    },
                    "illegal_type": {
                        "type": "string",
                        "description": "违规类型，仅允许'色情'/'暴力'/'辱骂'/'其他'/''"
                    },
                    "illegal_words": {
                        "type": "array",
                        "description": "违规词列表，无违规则为[]，仅含用户输入的核心词汇"
                    }
                },
                "required": ["is_illegal", "illegal_type", "illegal_words"],
                "additionalProperties": False  # 禁止新增任何额外字段
            }
        }
    }]

    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": f"判定用户输入是否违规：{user_prompt}"}]
    response = client.chat.completions.create(
        model=MODEL, 
        messages= messages,    
        tools = tools,
        tool_choice={  # 强制调用，锁死输出格式
            "type": "function", 
            "function": {"name": "process_illegal_judge"}
        }
    )
    if response.choices[0].message.tool_calls:
        result = json.loads(response.choices[0].message.tool_calls[0].function.arguments)
        print(result)
    else:
        raise ValueError("模型未调用工具")

三、事后补救：JSON 修复

当软约束偶尔失效，且模型不支持硬约束时，事后补救就是保障业务不挂的最后一道防线。

核心是通过轻量技术修复 JSON 异常、应对 API 问题，适配所有大模型，弥补软约束偏差和硬约束适配局限，即便 JSON 格式有误，也能尽力修复、重试，保障服务可用。

1. 正则提取：清除冗余内容

核心功能：剔除 ```json包裹、前后冗余话术，提取纯 JSON 文本。

优势：成本极低、速度极快，实现简单，是后处理的基础步骤。

局限性：仅提取文本，无法修复 JSON 本身的语法错误（如括号缺失、逗号多余）。

import re
def extract_json_from_text(text: str):
    """从大模型输出文本中提取纯JSON内容"""
    # 优先匹配markdown json代码块
    json_pattern1 = r'```json\s*(\{[\s\S]*?\})\s*```'
    match1 = re.search(json_pattern1, text, re.DOTALL)
    if match1:
        return match1.group(1).strip()
    
    # 兜底匹配最外层的{}，应对所有前后带废话的场景
    json_pattern2 = r'(\{[\s\S]*\})'
    match2 = re.search(json_pattern2, text, re.DOTALL)
    return match2.group(1).strip() if match2 else text

2. json_repair：修复语法错误

核心功能：自动修复 JSON 轻微语法错误，如末尾多逗号、引号未闭合、缺少括号等。

优势：本地修复，无需重新调用模型，速度快，有效弥补正则提取的不足。

局限性：仅修复语法错误，无法解决字段缺失、key 名错误等字段相关问题。

import json_repair
import json
def repair_invalid_json(invalid_json_str: str):
    """修复JSON语法错误，如括号缺失、逗号多余等"""
    try:
        json_str = json_repair.repair_json(invalid_json_str)
        return json.loads(json_str)
    except Exception as e:
        print(f"JSON修复失败：{e}，大模型原始输出：{invalid_json_str}")
        return None

3. pydantic：字段规则校验

核心功能：通过 Python 类定义 JSON 字段规则（格式、类型、取值范围等），全量校验 JSON 合规性。

优势：可发现所有合规问题（语法、字段、类型），避免因数据不合规导致的线上崩溃。

局限性：需编写校验模型，增加少量代码复杂度。

from pydantic import BaseModel, Field, ValidationError
from typing import Literal
class IllegalJudgeResult(BaseModel, extra="forbid"):
    is_illegal: bool = Field(description="是否违规，仅true/false（小写）")
    illegal_type: Literal["色情", "暴力", "辱骂", "其他", ""] = Field(description="违规类型，仅允许'色情'/'暴力'/'辱骂'/'其他'/''")
    illegal_words: list = Field(description="违规词列表，无违规则为[]")

def validate_json(raw_json: str):
	"""全量校验JSON，贴合违规判断需求""" 
    try:
        data = json.loads(raw_json)
        return IllegalJudgeResult(**data).model_dump()
    except (json.JSONDecodeError, ValidationError) as e:
        print(f"JSON校验失败：{e}")
        return None

4. 重试机制：保障服务可用性

核心功能：API 调用失败后按 1s/2s/4s 指数退避重试。

优势：对超时、限流、格式错误等异常，大幅提升服务可用性。

局限性：增加代码复杂度，重试会延长接口调用耗时；

四、总结

大模型 JSON 输出异常，本质是模型幻觉与业务确定性需求的矛盾。通过「事前引导→事中约束→事后补救」的全链路解决方案，可实现 JSON 输出稳定合规，适配不同场景、不同类型大模型。

• 事前引导：通过明确字段规则、提供 Few-Shot 示例、添加校验指令，低成本引导模型输出合规 JSON；
• 事中约束：借助 JSON Mode、Structured Outputs、Function Calling，实现硬约束，从源头杜绝异常；
• 事后补救：通过正则提取、json_repair 修复、pydantic 校验、指数重试，兜底解决各类异常，保障服务可用。

如果这篇文章对你有帮助，不要忘了一键三连哦！