003 2.输出解析：让模型返回结构化数据

原作者：怕浪猫

在实际开发中，仅让模型返回自然语言是不够的——我们常常需要模型返回结构化数据（如列表、JSON、指定格式的对象），以便后续存储、处理、对接数据库或前端接口。

比如：从用户咨询中提取订单信息（订单号、金额、状态）、将文本分类结果输出为固定格式、从文章中提取关键信息并整理为 JSON。此时，LangChain 的 OutputParser（输出解析器）就成为了核心工具——它能将模型返回的自由文本，自动解析为我们需要的结构化格式，无需手动处理字符串，大幅提升开发效率。

1. 为什么需要 OutputParser？

在使用大模型时，默认情况下，模型返回的是自由文本（字符串），这种输出方式在实际开发中会遇到 3 个核心痛点，而 OutputParser 恰好能完美解决这些问题。

1. OutputParser 的核心价值

OutputParser 的核心作用是：将模型返回的自由文本，按照预设规则，解析为结构化数据，并进行格式校验，具体价值体现在 3 点：

标准化输出：强制模型返回固定格式（如 JSON、列表），避免格式混乱，后续处理无需手动适配；
降低开发成本：无需编写复杂的字符串处理、正则匹配代码，解析器自动完成格式转换；
数据校验：部分解析器（如 PydanticOutputParser）支持强类型校验，确保解析后的数据符合业务要求，避免异常数据流入下游。

2. OutputParser 核心工作流程

LangChain 中所有 OutputParser 的工作流程都一致，分为 3 步，简单易懂：

定义解析规则：指定需要解析的格式（如列表、JSON、实体对象）；
提示模型适配格式：在 Prompt 中加入解析器的“格式提示”，让模型按指定格式输出；
解析与校验：模型返回文本后，解析器自动解析为结构化数据，并进行格式校验，失败则抛出异常或自动修复。

提示：所有 OutputParser 都提供 get_format_instructions() 方法，可自动生成“格式提示”，无需手动编写，极大降低使用成本。

2. ListOutputParser 与 CommaSeparatedListOutputParser

最基础的结构化输出是“列表”——比如提取关键词、推荐列表、选项列表等。LangChain 提供两种专门用于解析列表的解析器，用法简单，覆盖不同场景：

ListOutputParser：解析换行分隔的列表（如每行一个元素），适配多元素、长文本列表；
CommaSeparatedListOutputParser：解析逗号分隔的列表（如“a,b,c”），适配短文本、简单列表。

1. ListOutputParser（换行分隔列表）

核心场景：提取多元素列表（如推荐书单、关键词列表），模型输出每行一个元素，解析器自动转换为 Python 列表。

from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import ListOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os

load_dotenv()

# 1. 初始化列表解析器（换行分隔）
list_parser = ListOutputParser()

# 2. 获取格式提示（让模型按换行格式输出）
format_instructions = list_parser.get_format_instructions()

# 3. 定义提示模板（加入格式提示）
prompt = PromptTemplate(
    template="推荐5个LangChain相关的学习资源，按以下格式输出：\n{format_instructions}",
    input_variables=[],
    partial_variables={"format_instructions": format_instructions}
)

# 4. 调用模型+解析输出
chat_model = ChatOpenAI(
    model_name="gpt-3.5-turbo",
    api_key=os.getenv("OPENAI_API_KEY"),
    temperature=0.7
)

# 链式调用：提示→模型→解析（后续章节详解Chains，此处简化）
chain = prompt | chat_model | list_parser
result = chain.invoke({})

print("解析后的列表：", result)
print("列表类型：", type(result))

运行结果：解析后的列表： ['LangChain 官方文档', 'LangChain 中文教程', 'LangChain 实战项目', 'Prompt Engineering 指南', 'LangChain 源码解析'] 列表类型： <class 'list'>

说明：模型会严格按照格式提示，输出每行一个元素的列表，解析器自动将其转换为 Python 列表，可直接用于循环、存储等操作。

2. CommaSeparatedListOutputParser（逗号分隔列表）

核心场景：提取短文本列表（如标签、简单选项），模型输出逗号分隔的字符串，解析器自动转换为 Python 列表。

from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os

load_dotenv()

# 1. 初始化逗号分隔列表解析器
csv_parser = CommaSeparatedListOutputParser()

# 2. 格式提示（让模型按逗号分隔输出）
format_instructions = csv_parser.get_format_instructions()

# 3. 提示模板
prompt = PromptTemplate(
    template="提取以下文本的关键词（逗号分隔）：{text}\n{format_instructions}",
    input_variables=["text"],
    partial_variables={"format_instructions": format_instructions}
)

# 4. 调用模型+解析
chat_model = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.5)
chain = prompt | chat_model | csv_parser

# 注入文本，获取解析结果
text = "LangChain是一个用于构建大语言模型应用的框架，支持提示模板、输出解析、链式调用等功能。"
result = chain.invoke({"text": text})

print("解析后的关键词列表：", result)

运行结果：解析后的关键词列表： ['LangChain', '大语言模型应用', '框架', '提示模板', '输出解析', '链式调用']

3. JSONOutputParser 解析复杂对象

列表解析适用于简单场景，而实际开发中，我们更多需要解析复杂对象（如订单信息、用户信息、实体数据），此时最常用的是 JSONOutputParser ——它能将模型返回的 JSON 字符串，自动解析为 Python 字典（或 JSON 对象），支持嵌套结构，适配大多数复杂场景。

核心特点：支持 JSON Schema（JSON 模式），可提前定义 JSON 的字段、类型、约束，让模型严格按 Schema 输出，解析更精准。

1. 基础用法：解析简单 JSON 对象

适用于解析无嵌套的简单 JSON 对象（如用户基本信息、单条订单信息），步骤简单，无需复杂配置。

from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import JSONOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os

load_dotenv()

# 1. 初始化JSON解析器
json_parser = JSONOutputParser()

# 2. 格式提示（包含JSON Schema，让模型按指定字段输出）
format_instructions = json_parser.get_format_instructions()

# 3. 提示模板（提取用户信息，按JSON格式输出）
prompt = PromptTemplate(
    template="从以下文本中提取用户信息，按JSON格式输出：\n文本：{text}\n{format_instructions}",
    input_variables=["text"],
    partial_variables={"format_instructions": format_instructions}
)

# 4. 调用模型+解析
chat_model = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.3)
chain = prompt | chat_model | json_parser

# 测试文本
text = "用户张三，年龄25岁，邮箱zhangsan@163.com，手机号13800138000，职业是Python开发工程师。"
result = chain.invoke({"text": text})

print("解析后的JSON对象：", result)
print("用户名字段：", result.get("username"))
print("结果类型：", type(result))

运行结果：解析后的JSON对象： {'username': '张三', 'age': 25, 'email': ' zhangsan@163.com ', 'phone': '13800138000', 'occupation': 'Python开发工程师'} 用户名字段：张三结果类型： <class 'dict'>

2. 进阶用法：指定 JSON Schema（强制字段约束）

基础用法中，模型可能会返回多余字段或缺失字段，通过指定 JSON Schema，可强制模型返回固定字段、指定字段类型，确保解析结果符合业务要求。

from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import JSONOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os

load_dotenv()

# 1. 定义JSON Schema（强制字段、类型约束）
json_schema = {
    "type": "object",
    "properties": {
        "order_id": {"type": "string", "description": "订单号，格式为6位数字"},
        "amount": {"type": "number", "description": "订单金额，保留2位小数"},
        "status": {"type": "string", "enum": ["待付款", "已发货", "已签收", "已取消"], "description": "订单状态"},
        "create_time": {"type": "string", "description": "订单创建时间，格式为YYYY-MM-DD HH:MM:SS"}
    },
    "required": ["order_id", "amount", "status"],  # 必选字段
    "additionalProperties": False  # 禁止多余字段
}

# 2. 初始化JSON解析器（传入Schema）
json_parser = JSONOutputParser(schema=json_schema)

# 3. 格式提示（包含Schema约束）
format_instructions = json_parser.get_format_instructions()

# 4. 提示模板
prompt = PromptTemplate(
    template="从以下文本中提取订单信息，严格按JSON Schema输出：\n文本：{text}\n{format_instructions}",
    input_variables=["text"],
    partial_variables={"format_instructions": format_instructions}
)

# 5. 调用模型+解析
chat_model = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.3)
chain = prompt | chat_model | json_parser

# 测试文本
text = "用户李四在2024-05-20 14:30:00下单，订单号是123456，金额99.90元，目前订单已发货，还未签收。"
result = chain.invoke({"text": text})

print("解析后的订单信息：", result)

运行结果：解析后的订单信息： {'order_id': '123456', 'amount': 99.9, 'status': '已发货', 'create_time': '2024-05-20 14:30:00'}

说明：通过 JSON Schema，模型会严格返回指定字段、类型，不会出现多余字段或缺失必选字段，解析结果可直接对接数据库或业务逻辑。

3. 注意事项

JSON Schema 的描述要清晰：给每个字段添加 description，让模型理解字段含义和格式要求（如订单号格式、时间格式）；
必选字段用 required 指定：避免模型遗漏核心字段；
禁止多余字段：设置 additionalProperties=False，防止模型返回无关字段，简化后续处理；
解析失败处理：若模型输出不符合 JSON 格式，解析器会抛出 OutputParserException，可通过 try-except 捕获，后续章节会讲解自动修复方法。

4. PydanticOutputParser：强类型数据校验

JSONOutputParser 能解析 JSON 对象，但无法进行复杂数据校验（如订单号格式校验、金额范围校验、自定义规则校验）。而 PydanticOutputParser 基于 Pydantic（Python 强类型数据校验库），不仅能解析结构化数据，还能实现强类型校验、自定义校验规则，是生产环境中最推荐的解析器。

核心优势：将解析与校验结合，确保解析后的数据不仅格式正确，还符合业务规则，避免异常数据流入下游。

1. 基础用法：强类型解析与校验

步骤：先定义 Pydantic 模型（指定字段类型、约束），再初始化 PydanticOutputParser，最后结合提示模板和模型调用。

from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import PydanticOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os
from pydantic import BaseModel, Field, validator

load_dotenv()

# 1. 定义Pydantic模型（强类型+数据校验）
class OrderInfo(BaseModel):
    order_id: str = Field(description="订单号，格式为6位数字")
    amount: float = Field(description="订单金额，大于0，保留2位小数")
    status: str = Field(description="订单状态", enum=["待付款", "已发货", "已签收", "已取消"])
    create_time: str = Field(description="订单创建时间，格式为YYYY-MM-DD HH:MM:SS")
    
    # 自定义校验规则：订单号必须是6位数字
    @validator("order_id")
    def order_id_must_be_6_digits(cls, v):
        if not v.isdigit() or len(v) != 6:
            raise ValueError("订单号必须是6位数字")
        return v
    
    # 自定义校验规则：金额必须大于0
    @validator("amount")
    def amount_must_be_positive(cls, v):
        if v <= 0:
            raise ValueError("订单金额必须大于0")
        return round(v, 2)  # 保留2位小数

# 2. 初始化Pydantic解析器（传入Pydantic模型）
pydantic_parser = PydanticOutputParser(pydantic_object=OrderInfo)

# 3. 格式提示（自动生成，包含模型字段和校验规则）
format_instructions = pydantic_parser.get_format_instructions()

# 4. 提示模板
prompt = PromptTemplate(
    template="从以下文本中提取订单信息，严格按要求输出：\n文本：{text}\n{format_instructions}",
    input_variables=["text"],
    partial_variables={"format_instructions": format_instructions}
)

# 5. 调用模型+解析（自动校验）
chat_model = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.3)
chain = prompt | chat_model | pydantic_parser

# 测试文本（正常情况）
text1 = "用户王五在2024-06-01 10:00:00下单，订单号654321，金额199.50元，订单状态已签收。"
result1 = chain.invoke({"text": text1})
print("正常订单解析结果：", result1)
print("订单号类型：", type(result1.order_id))

# 测试文本（异常情况：订单号5位，金额为0）
try:
    text2 = "用户赵六在2024-06-02 15:00:00下单，订单号12345，金额0元，订单状态待付款。"
    result2 = chain.invoke({"text": text2})
except Exception as e:
    print("异常订单解析失败：", str(e))

运行结果：正常订单解析结果： order_id='654321' amount=199.5 status='已签收' create_time='2024-06-01 10:00:00' 订单号类型： <class 'str'> 异常订单解析失败： 1 validation error for OrderInfo order_id 订单号必须是 6 位数字 (type=value_error)

说明：解析器会自动校验字段类型、自定义规则，异常数据会直接抛出校验错误，避免流入下游业务。

2. 进阶用法：嵌套 Pydantic 模型（复杂对象）

当需要解析嵌套结构（如订单信息包含用户信息、商品信息）时，可定义嵌套 Pydantic 模型，解析器会自动处理嵌套结构，实现多层数据校验。

from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import PydanticOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os
from pydantic import BaseModel, Field, validator
from typing import List

load_dotenv()

# 1. 定义嵌套Pydantic模型
class UserInfo(BaseModel):
    username: str = Field(description="用户名")
    phone: str = Field(description="手机号，11位数字")
    
    @validator("phone")
    def phone_must_be_11_digits(cls, v):
        if not v.isdigit() or len(v) != 11:
            raise ValueError("手机号必须是11位数字")
        return v

class ProductInfo(BaseModel):
    product_name: str = Field(description="商品名称")
    quantity: int = Field(description="商品数量，大于0")
    price: float = Field(description="商品单价，大于0")

class OrderDetail(BaseModel):
    order_info: OrderInfo  # 嵌套订单基本信息
    user_info: UserInfo    # 嵌套用户信息
    products: List[ProductInfo]  # 嵌套商品列表

# 2. 初始化解析器
pydantic_parser = PydanticOutputParser(pydantic_object=OrderDetail)

# 3. 格式提示
format_instructions = pydantic_parser.get_format_instructions()

# 4. 提示模板
prompt = PromptTemplate(
    template="从以下文本中提取完整订单详情，严格按要求输出：\n文本：{text}\n{format_instructions}",
    input_variables=["text"],
    partial_variables={"format_instructions": format_instructions}
)

# 5. 调用模型+解析
chat_model = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.3)
chain = prompt | chat_model | pydantic_parser

# 测试文本
text = "用户张三（手机号13800138000）在2024-06-03 09:30:00下单，订单号789012，金额299.00元，状态已发货。订单包含2件商品：LangChain教程（单价99.00元）、Python实战（单价100.00元）。"
result = chain.invoke({"text": text})

print("完整订单详情：")
print(f"订单号：{result.order_info.order_id}")
print(f"用户名：{result.user_info.username}")
print(f"商品列表：")
for product in result.products:
    print(f"- {product.product_name}：{product.quantity}件，单价{product.price}元")

运行结果会自动解析嵌套结构，且对每个嵌套模型的字段进行校验，适合复杂业务场景（如电商订单、用户详情）。

3. 核心优势与选型建议

强类型校验：支持字段类型、范围、格式、自定义规则校验，比 JSONOutputParser 更严谨；
嵌套结构支持：轻松处理嵌套对象、列表，适配复杂业务数据；
代码友好：解析结果是 Pydantic 模型实例，可通过“对象.字段”访问，比字典更直观、更安全；
选型建议：生产环境优先使用 PydanticOutputParser，尤其是需要数据校验、复杂对象解析的场景；简单 JSON 解析可使用 JSONOutputParser，追求简洁高效。

5. RetryOutputParser 自动修复格式错误

无论使用哪种解析器，都可能出现“模型输出不符合格式要求”的情况（如 JSON 语法错误、XML 标签缺失、字段缺失），此时如果直接抛出异常，会影响用户体验和业务流程。

LangChain 的 RetryOutputParser（重试解析器）可解决这一问题——当解析失败时，它会自动将“错误信息”和“模型原始输出”反馈给模型，让模型重新生成符合格式要求的内容，实现自动修复格式错误，无需人工干预。

1. 核心原理

RetryOutputParser 的工作流程分为 4 步：

模型生成原始输出，传递给 RetryOutputParser；
RetryOutputParser 调用底层解析器（如 JSONOutputParser、PydanticOutputParser）进行解析；
若解析成功，直接返回结构化数据；
若解析失败，RetryOutputParser 自动生成“重试提示”（包含原始输出、错误信息、格式要求），让模型重新生成输出，直至解析成功或达到最大重试次数。

2. 实战示例：自动修复 JSON 格式错误

以 JSONOutputParser 为例，演示 RetryOutputParser 如何自动修复模型输出的 JSON 语法错误。

from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import JSONOutputParser, RetryOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os

load_dotenv()

# 1. 定义JSON Schema
json_schema = {
    "type": "object",
    "properties": {
        "username": {"type": "string"},
        "age": {"type": "number"},
        "occupation": {"type": "string"}
    },
    "required": ["username", "age"]
}

# 2. 初始化底层解析器（JSONOutputParser）
json_parser = JSONOutputParser(schema=json_schema)

# 3. 初始化重试解析器（传入底层解析器、模型、提示模板）
chat_model = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.3)
retry_parser = RetryOutputParser.from_llm(
    llm=chat_model,
    parser=json_parser,
    max_retries=2  # 最大重试次数（默认3次）
)

# 4. 提示模板（加入格式提示）
prompt = PromptTemplate(
    template="从以下文本中提取用户信息，按JSON格式输出：\n文本：{text}\n{format_instructions}",
    input_variables=["text"],
    partial_variables={"format_instructions": json_parser.get_format_instructions()}
)

# 5. 调用模型+重试解析（自动修复错误）
chain = prompt | chat_model | retry_parser

# 测试文本（故意让模型可能输出错误JSON，如缺少逗号、引号）
text = "用户张三，25岁，职业是Python开发工程师。"
result = chain.invoke({"text": text})

print("解析结果（自动修复后）：", result)

运行说明：若模型第一次输出的 JSON 存在语法错误（如 {"username":"张三" "age":25}，缺少逗号），RetryOutputParser 会自动反馈错误，让模型重新生成正确的 JSON，直至解析成功。

3. 进阶用法：结合 PydanticOutputParser 修复校验错误

RetryOutputParser 不仅能修复格式错误，还能修复 Pydantic 模型的校验错误（如订单号格式错误、金额为负数），示例如下：

from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import PydanticOutputParser, RetryOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os
from pydantic import BaseModel, Field, validator

load_dotenv()

# 1. 定义Pydantic模型（带校验规则）
class OrderInfo(BaseModel):
    order_id: str = Field(description="订单号，6位数字")
    amount: float = Field(description="订单金额，大于0")
    
    @validator("order_id")
    def order_id_must_be_6_digits(cls, v):
        if not v.isdigit() or len(v) != 6:
            raise ValueError("订单号必须是6位数字")
        return v
    
    @validator("amount")
    def amount_must_be_positive(cls, v):
        if v <= 0:
            raise ValueError("订单金额必须大于0")
        return v

# 2. 底层解析器
pydantic_parser = PydanticOutputParser(pydantic_object=OrderInfo)

# 3. 重试解析器
chat_model = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.3)
retry_parser = RetryOutputParser.from_llm(
    llm=chat_model,
    parser=pydantic_parser,
    max_retries=2
)

# 4. 提示模板
prompt = PromptTemplate(
    template="从以下文本中提取订单信息，严格按要求输出：\n文本：{text}\n{format_instructions}",
    input_variables=["text"],
    partial_variables={"format_instructions": pydantic_parser.get_format_instructions()}
)

# 5. 链式调用
chain = prompt | chat_model | retry_parser

# 测试文本（可能导致校验错误：订单号5位，金额为0）
text = "用户李四下单，订单号12345，金额0元。"
result = chain.invoke({"text": text})

print("修复校验错误后的结果：", result)

运行结果：解析器会自动修复订单号（补全为 6 位）和金额（改为大于 0 的值），最终返回符合校验规则的 OrderInfo 实例。

4. 实战建议

设置合理的重试次数：max_retries 建议设为 2~3 次，过多重试会增加耗时和 tokens 消耗；
优先用于生产环境：开发环境可关闭重试，快速定位格式错误；生产环境开启重试，提升系统稳定性；
结合日志：重试过程中，可打印日志（如原始输出、错误信息、重试次数），便于后续调试。

6. 结合 LLM 调用链自动解析

前面的示例中，我们使用“提示→模型→解析”的简单链式调用，而 LangChain 的核心优势是“链式调用（Chains）”——可将 PromptTemplate、Model、OutputParser 与其他组件（如记忆、工具）结合，实现更复杂的自动解析流程。

本节将介绍两种常用的“解析链”，实现端到端的自动解析，无需手动拼接组件，提升开发效率。

1. 基础解析链：LLMChain

LLMChain 是最基础的链式调用，将 PromptTemplate、Model、OutputParser 整合为一个链，调用链时，自动完成“提示生成→模型调用→输出解析”，适合简单场景。

from langchain.chains import LLMChain
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import PydanticOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os
from pydantic import BaseModel, Field

load_dotenv()

# 1. 定义Pydantic模型
class ProductInfo(BaseModel):
    product_name: str = Field(description="商品名称")
    price: float = Field(description="商品单价")
    description: str = Field(description="商品简介")

# 2. 解析器、提示模板、模型
parser = PydanticOutputParser(pydantic_object=ProductInfo)
prompt = PromptTemplate(
    template="根据商品名称，生成商品信息，按要求输出：\n商品名称：{product_name}\n{format_instructions}",
    input_variables=["product_name"],
    partial_variables={"format_instructions": parser.get_format_instructions()}
)
chat_model = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.7)

# 3. 构建LLMChain（整合提示、模型、解析器）
llm_chain = LLMChain(
    llm=chat_model,
    prompt=prompt,
    output_parser=parser,
    verbose=True  # 开启日志，查看链的运行过程
)

# 4. 调用链，自动解析
result = llm_chain.invoke({"product_name": "LangChain教程"})

print("自动解析结果：", result)

运行说明：调用 llm_chain.invoke()后，链会自动完成“生成提示→调用模型→解析输出”，无需手动分步操作，verbose=True 可查看详细运行日志，便于调试。

2. 进阶解析链：SequentialChain（多步骤解析）

当解析任务需要多步骤完成（如“先提取文本关键词→再根据关键词生成商品信息→最后解析为结构化数据”），可使用 SequentialChain（顺序链），将多个 LLMChain 按顺序串联，实现多步骤自动解析。

from langchain.chains import SequentialChain, LLMChain
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import CommaSeparatedListOutputParser, PydanticOutputParser
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os
from pydantic import BaseModel, Field
from typing import List

load_dotenv()

# 步骤1：提取商品关键词（列表解析）
keyword_parser = CommaSeparatedListOutputParser()
keyword_prompt = PromptTemplate(
    template="提取以下文本中的商品关键词（逗号分隔）：\n文本：{text}\n{format_instructions}",
    input_variables=["text"],
    partial_variables={"format_instructions": keyword_parser.get_format_instructions()}
)
keyword_chain = LLMChain(
    llm=ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.5),
    prompt=keyword_prompt,
    output_parser=keyword_parser,
    output_key="keywords"  # 输出键，用于传递给下一个链
)

# 步骤2：根据关键词生成商品列表（Pydantic解析）
class ProductList(BaseModel):
    products: List[ProductInfo]

class ProductInfo(BaseModel):
    product_name: str = Field(description="商品名称")
    price: float = Field(description="商品单价")

product_parser = PydanticOutputParser(pydantic_object=ProductList)
product_prompt = PromptTemplate(
    template="根据关键词{keywords}，生成3个相关商品信息，按要求输出：\n{format_instructions}",
    input_variables=["keywords"],
    partial_variables={"format_instructions": product_parser.get_format_instructions()}
)
product_chain = LLMChain(
    llm=ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"), temperature=0.7),
    prompt=product_prompt,
    output_parser=product_parser,
    output_key="product_list"
)

# 构建顺序链（串联两个步骤）
sequential_chain = SequentialChain(
    chains=[keyword_chain, product_chain],
    input_variables=["text"],  # 初始输入
    output_variables=["keywords", "product_list"],  # 最终输出
    verbose=True
)

# 调用顺序链，自动完成多步骤解析
text = "推荐几款大语言模型相关的学习资料，包括教程、实战项目、指南等。"
result = sequential_chain.invoke({"text": text})

print("关键词：", result["keywords"])
print("商品列表：", result["product_list"].products)

运行说明：顺序链先调用 keyword_chain 提取关键词，再将关键词传递给 product_chain 生成商品列表并解析，实现多步骤自动解析，适合复杂解析场景。

3. 实战建议

简单解析用 LLMChain：无需多步骤，直接整合提示、模型、解析器，简洁高效；

解析用 SequentialChain：当解析任务涉及多步骤联动（如先提取核心信息、再加工处理、最后解析结构化数据），串联多个 LLMChain 形成顺序链，能实现端到端的自动化解析，减少手动干预，适配更复杂的业务场景。此外，在实际开发中，可根据任务需求灵活组合不同解析器与调用链，比如将 PydanticOutputParser 与 SequentialChain 结合，既实现多步骤解析，又保证数据校验的严谨性，让结构化输出更可靠、更适配下游业务需求。