Langchain 教程四（OutputParser）

作为程序开发者，在构建 LLM 的应用时，我们经常会遇到这样一个问题：模型返回的内容是自然语言格式，也就是字符串，但我们的应用需要结构化的数据，比如 JSON、字典、列表，甚至是 Python 的数据类对象。那么这个时候，LangChain 中的 OutputParser 就派上用场了。

OutputParser 是什么？

其实我们在之前的学习中已经见过OutputParser了， 它是 LangChain 中专门用于 对 LLM 返回结果进行结构化解析 的组件。它能帮助我们将模型输出从字符串转换为特定的数据结构（如 JSON、Dict、Pydantic 模型等），方便后续业务逻辑处理。

LangChain 提供了一系列常用的 OutputParser

具体的你可以查看官网地址：https://python.langchain.com/api_reference/core/output_parsers.html

这里我们列举一些常见的

我们之前只见过StrOutputParser，但是 LangChain 其实还给我们提供了其他的不同的 Parser，这些Parser支持不同格式的输出，有些支持流式处理（Stream），有些要求格式严格，有些可以直接输出 Python 对象或模型实例。

StrOutputParser

StrOutputParser 用于获取纯文本输出，我们直接复用之前的代码，大家一看就明白了。

from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

template = "请将以下内容翻译成{language}：{input}"
prompt = PromptTemplate.from_template(template)

llm = ChatOpenAI(
    model="Qwen/Qwen3-32B",
    openai_api_key="your_key",
    base_url="https://api.siliconflow.cn/v1",
    temperature=0
)

parser = StrOutputParser()

chain = prompt | llm | parser

result = chain.invoke({
    "language": "日文",
    "input": "我是一个中国人"
})

print(result)

JsonOutputParser

Json可能是日常对开发者最友好的格式了，我们来看看使用

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个中文翻译助手，请根据用户的要求翻译内容，请将内容的信息以 JSON 格式返回：original:xxx,translation:xxx"),
    ("user", "请翻译以下内容为英文：{text}")
])

llm = ChatOpenAI(
    model="Qwen/Qwen3-32B",
    openai_api_key="your_key",
    base_url="https://api.siliconflow.cn/v1",
    temperature=0
)

parser = JsonOutputParser()

chain = prompt | llm | parser

result = chain.invoke({
    "text": "我是一名中国人"
})

print(result)

输出结果将是一个标准的 dict：

{
'original': '我是一名中国人', 
'translation': 'I am a Chinese person.'
}

ok，看起来还不错，眼尖的同学可能发现我们上面的提示词中有一句 请将内容的信息以 JSON 格式返回：original:xxx,translation:xxx"，那么我们可不可以不写这段提示词呢

我先说答案，上面的例子中不行

首先我们要知道 JsonOutputParser 背后的实现逻辑其实很简单： 它只是尝试对 LLM 的 完整输出 调用 json.loads()。

所以，只要输出满足 JSON 格式：

{
  "original": "你好",
  "translation": "Hello"
}

就能成功解析。

但是，如果你不给模型提示明确的格式要求，它可能会输出这种自然语言风格的内容：

I am a Chinese

这会直接导致 json.loads() 报错。

Pydantic

那么上面的例子中我们需要在提示词中每次写帮我按照 JSON 格式返回...看起来很不优雅，而且每个都这么写，扩展性啥的也不好，那还有什么其他办法吗？

答案是有的，再讲具体操作之前，我们先说一下Pydantic

Pydantic = TypeScript + Yup + 自动校验 + 智能提示 + 更高级的 Python 数据模型系统。

对于前端开发者，你可能用过的：

• TypeScript（用类型约束结构）；
• Yup / Zod（用 schema 做数据校验）；

那么 Pydantic 就是 Python 里的这些功能的结合体，而且更强大。

咱们写 React / Vue 组件时可能会定义 props 类型，类似这样（TS）：

type User = {
  name: string;
  age: number;
}

在 Python 中，用 Pydantic 就是这样写的：

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

然后就可以：

user = User(name="张三", age="18")  # 自动把 "18" 转成 int

user = User(name="张三", age="abc")  # ❌ 会抛异常：age 不是数字

那么在 LangChain 中，它最常用在：

1. 描述结构化输出数据格式
2. 配合 OutputParser 解析 LLM 返回的数据成 Python 对象
3. 在 FastAPI / Backend 中定义请求 / 响应的 schema

比如上面的 demo，咱们想让 LLM 返回一个翻译对象：

{
  "original": "你好",
  "translation": "Hello"
}

就可以用 Pydantic 先定义数据结构：

class Translation(BaseModel):
    original: str
    translation: str

完整代码如下

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field

# 核心调整 START
class Translation(BaseModel):
    original: str = Field(description="用户输入的原文")
    translation: str = Field(description="翻译后的译文")

parser = JsonOutputParser(pydantic_object=Translation)
format_instructions = parser.get_format_instructions()

# 核心调整 END

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个中文翻译助手，请将用户提供的中文翻译成英文。\n {format_instructions}"),
    ("user", "请翻译以下内容为英文：{text}")
])

llm = ChatOpenAI(
    model="Qwen/Qwen3-32B",
    openai_api_key="your_key",
    base_url="https://api.siliconflow.cn/v1",
    temperature=0
)

chain = prompt | llm | parser

result = chain.invoke({
    "text": "我是一名中国人",
    "format_instructions": format_instructions
})

print(result, result.get("translation"))

这样子我们就可以更好的去指定我们的输出格式了

那么这儿format_instructions到底注入的是什么东西呢。我们打印看一下

The output should be formatted as a JSON instance that conforms to the JSON schema below.

As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.

Here is the output schema:

{"properties": {
"original": {"description": "用户输入的原文", "title": "Original", "type": "string"}, 
"translation": {"description": "翻译后的译文", "title": "Translation", "type": "string"}
}, "required": ["original", "translation"]}

可以看到，就是相当于帮我们书写了一大段关于返回内容格式的提示词，并且把我们定义的 schema 结构也给注入了进去，这样子大模型就能更加理解我们想要的格式了

JSON格式的流式输出

那么有人可能要问了，这种情况下还能支持流式返回吗？答案是支持

result = chain.stream({
    "text": "我是一名中国人",
    "format_instructions": format_instructions
})

for s in result:
    print(s)
    

我们只需要将上面 demo 调用的地方改成如上代码就行了，我们看看效果

{}
{'original': ''}
{'original': '我'}
{'original': '我是一名'}
{'original': '我是一名中国人'}
{'original': '我是一名中国人', 'translation': ''}
{'original': '我是一名中国人', 'translation': 'I'}
{'original': '我是一名中国人', 'translation': 'I am'}
{'original': '我是一名中国人', 'translation': 'I am a'}
{'original': '我是一名中国人', 'translation': 'I am a Chinese'}
{'original': '我是一名中国人', 'translation': 'I am a Chinese person'}
{'original': '我是一名中国人', 'translation': 'I am a Chinese person.'}

可以看到 LangChain 在保证格式的同时，也做到了流式返回

重试和修复

官方文档：https://python.langchain.com/docs/how_to/output_parser_retry/

当我们告诉大模型：“请返回 JSON 格式”，可能 99 次都是正确的，但估计有那么一次，它会返回这些奇奇怪怪的东西，比如

这是翻译结果：
{
  "original": "你好",
  "translation": "Hello"
}

或者是

{ "original": "你好", "translation": Hello }  # 缺双引号，JSON 无效

这些都会让后续 JsonOutputParser 或 PydanticOutputParser 解析失败，抛 JSONDecodeError 或 ValidationError。

于是：LangChain 提供了 RetryOutputParser 和 OutputFixingParser 来自动处理这类问题。

它们是 LangChain 中两个非常实用的「输出容错解析器」，我们来逐一看一下

RetryOutputParser

如果解析失败，它会自动重试 LLM 调用一次，提示模型“你刚才输出错格式了，请重新按照这个格式输出”。

比较适用于

• 要求模型输出严格格式（JSON、CSV、Pydantic）
• 容易格式不一致时做兜底重试

使用方式：

from langchain.output_parsers import RetryOutputParser, PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from pydantic import BaseModel

class Translation(BaseModel):
    original: str
    translation: str

# 原始的解析器
base_parser = PydanticOutputParser(pydantic_object=Translation)

# 包一层 RetryOutputParser：失败就自动再走一轮 LLM + parser
parser = RetryOutputParser.from_llm(parser=base_parser, llm=ChatOpenAI())

OutputFixingParser

如果解析失败，它会尝试让另一个LLM 来“修复”输出，而不是重跑整个流程。

它的提示词大概是：“这是用户需要的格式，这是刚才输出的错误结果，请修复它。”

适合的场景：

• 你不想让主模型重新跑 prompt，只是修复输出
• 尤其适合慢模型 / 成本敏感场景

使用方式：

from langchain.output_parsers import OutputFixingParser, PydanticOutputParser
from langchain_openai import ChatOpenAI
from pydantic import BaseModel

class Translation(BaseModel):
    original: str
    translation: str

base_parser = PydanticOutputParser(pydantic_object=Translation)

# 用另一个 LLM 尝试修复格式错误
parser = OutputFixingParser.from_llm(parser=base_parser, llm=ChatOpenAI())

区别对比

总结起来就是

RetryOutputParser 是“原 prompt 再跑一遍”，OutputFixingParser 是“找个助手帮我修一下”。

当然我们也可以这样组合：

parser = RetryOutputParser.from_llm(
    parser=OutputFixingParser.from_llm(base_parser, repair_llm),
    llm=main_llm
)

意思是：

如果主解析器失败 → 先修复试试 → 修不动 → 再全量重跑 prompt。

总结

OutputParser 是 LangChain 构建高质量、可控输出的关键工具。它帮助我们从模型的自然语言输出中提取出机器可理解的数据结构，是连接 LLM 与业务逻辑之间的重要桥梁。