第 19 期 | 结构化数据输出：用 Pydantic 约束 LLM

🎯 本期学习目标

嘿，各位未来的 AI 大师们！欢迎回到我们的《LangChain 全栈大师课》。上一期我们聊了 LLM 的基本调用和 Prompt Engineering 的艺术，是不是感觉已经能和 AI 愉快地“对话”了？但只停留在单次对话，就像你拿到了一把瑞士军刀，却只会用它削苹果。我们的目标是打造一个智能客服知识库，它可不是只会削苹果那么简单，它需要处理复杂的、多步骤的用户请求。

所以，本期，我们将深入 LangChain 的核心概念之一——“链” (Chains)。这可是让你的 AI 应用从“单细胞生物”进化到“多器官系统”的关键！

学完本期，你将：

1. 彻底理解 LangChain 中“链”的核心概念和它在复杂任务中的不可替代性。 告别单次 LLM 调用，迈向多步骤智能编排。
2. 掌握不同类型链（特别是 LLMChain 和 SequentialChain）的适用场景与构建方法。 知道何时用什么“链”来解决客服助手中的具体问题。
3. 学会在我们的智能客服助手中构建多步处理逻辑，显著提升其理解和解决复杂问题的能力。 比如，如何让它先理解问题，再查找信息，最后给出解决方案。
4. 学会如何高效地串联不同的 LangChain 组件（LLM、Prompt、Parser 等），实现生产级的复杂任务自动化。 让你的客服助手真正“活”起来！

准备好了吗？让我们一起进入“链”的世界，释放 LangChain 的真正威力！

📖 原理解析

链：LLM 应用的“脊梁骨”

设想一下，你正在构建智能客服，用户问：“我的订单号是 #XYZ123，为什么还没发货？”

一个简单的 LLM 调用可能会尝试直接回答，但它并不知道“订单号 #XYZ123”是什么，也没有权限去查询。它可能只会说：“我无法查询具体订单信息，请联系人工客服。” 这显然不是我们想要的“智能”客服。

为了解决这个问题，我们需要：

1. 识别意图和关键信息： 用户想查订单状态，订单号是 #XYZ123。
2. 执行外部操作： 调用我们内部的订单查询 API，传入订单号。
3. 处理 API 结果： 解析 API 返回的发货状态、预计送达时间等。
4. 生成友好回复： 将查询到的信息整理成用户能懂的语言。

这一系列步骤，需要一个有组织的流程来协调。在 LangChain 中，这个“有组织的流程”就是**“链” (Chain)**。

链的核心思想是：将多个 LLM 调用或其他工具（如数据查询、API 调用、代码执行）组合起来，形成一个有序的、多步骤的逻辑流，以完成更复杂的任务。它就像一条生产线，每个环节负责特定的加工，前一个环节的产出是后一个环节的输入。

为什么需要链？

• 克服 LLM 的局限性： LLM 本身是无状态的，一次只处理一个请求。链赋予了 LLM 应用“记忆”和“多步思考”的能力。
• 任务分解与编排： 将一个复杂的大任务分解成一系列小任务，每个小任务由一个链或链中的一个组件完成。
• 集成外部能力： 让 LLM 不仅仅是“聊天机器人”，还能与你的业务系统、数据库、API 等无缝集成，获取实时数据并执行实际操作。
• 提高可维护性与可扩展性： 模块化设计，方便修改、调试和扩展功能。

链的种类与结构

LangChain 提供了多种内置链，但最基础、最常用的有两种：

1. LLMChain： 这是所有链的基石。它将一个 PromptTemplate 和一个 BaseLLM (或 BaseChatModel) 组合起来。它的作用就是根据模板和输入，向 LLM 发送请求并获取输出。你可以把它看作是“一个带模板的 LLM 调用”。

   • 输入： 模板变量所需的数据。
   • 输出： LLM 生成的文本。

2. SequentialChain (及其简化版 SimpleSequentialChain)： 这是将多个链串联起来的关键。

   • SimpleSequentialChain： 最简单的串联方式，上一个链的完整输出作为下一个链的完整输入。适用于线性、无分支的简单流程。
   • SequentialChain： 更强大、更灵活。它允许你定义每个链的输入变量和输出变量，可以有多个输入和多个输出，并且能够将中间结果传递给后续的特定链。这对于复杂的流程控制至关重要。

智能客服知识库中的链式工作流

想象一下我们的智能客服助手，当用户提出一个复杂问题时，它可能需要经历以下链式处理：

graph TD
    A[用户提问: "我的订单#12345为什么还没发货？"] --> B(意图识别与关键信息提取)
    B --> C{LLMChain: 识别订单号和意图}
    C -- 提取: 订单号="12345", 意图="查询发货" --> D(业务数据查询)
    D --> E{Tool/Function: 调用订单查询API}
    E -- 返回: 状态="已发货", 快递="顺丰", 预计送达="明天" --> F(结果分析与回复生成)
    F --> G{LLMChain: 总结信息并生成友好回复}
    G -- 回复: "您的订单#12345已于今天发货，预计明天送达，快递公司顺丰。" --> H[回复用户]

    subgraph "LangChain 链式处理"
        C
        E
        G
    end

图解：智能客服助手的链式处理流程

在这个图中，我们看到一个复杂的请求是如何被分解成多个步骤，并由不同的组件（包括 LLMChain 和未来我们将学习的 Tool/Function）协同完成的。本期我们主要关注如何使用 LLMChain 和 SequentialChain 来编排纯文本处理逻辑。

例如，一个基础的文本处理链可以是：

1. LLMChain (问题分类器)： 输入用户问题，输出问题类型（如“退货”、“技术支持”、“订单查询”）。
2. LLMChain (信息提取器)： 输入用户问题和问题类型，输出关键实体（如订单号、产品名称、故障描述）。
3. LLMChain (初步回复生成器)： 输入问题类型和提取到的信息，生成一个初步的回复草稿。

这些 LLMChain 可以通过 SequentialChain 串联起来，实现一个更智能的客服交互。

💻 实战代码演练

好了，理论说得再多，不如撸起袖子干一场！现在，让我们为我们的“智能客服知识库”构建一个实际的链式处理逻辑。

场景设定： 我们的客服助手需要处理用户关于产品故障的咨询。它不仅要识别产品和故障类型，还要根据这些信息，给出一个初步的、个性化的故障排除建议或指引。

核心挑战： 这需要两步甚至多步 LLM 思考：

1. 理解用户意图并提取关键信息： 用户说了什么产品坏了？是什么类型的故障？
2. 根据信息生成建议： 针对特定产品和故障，给出合适的下一步行动。

我们将使用 SequentialChain 来优雅地解决这个问题。

准备工作 (Python)

首先，确保你安装了必要的库：

pip install langchain openai python-dotenv

然后，设置你的 OpenAI API Key。我们通常会通过环境变量来管理敏感信息：

# .env 文件内容示例
# OPENAI_API_KEY="sk-your_openai_api_key_here"

import os
from dotenv import load_dotenv

load_dotenv() # 加载 .env 文件中的环境变量

from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, SequentialChain

# 初始化一个聊天模型实例
# temperature 控制模型的创造性，0 表示更确定性
llm = ChatOpenAI(temperature=0.7, model="gpt-4o") # 推荐使用更强大的模型，如 gpt-4o 或 gpt-3.5-turbo

步骤一：构建第一个链 - 问题分类与信息提取

这个链负责从用户输入中识别产品和故障类型。

# 1. 定义第一个 Prompt Template: 问题分类与信息提取
# input_variables: 用户原始问题 (customer_query)
# output_variables: 提取出的产品名称 (product_name) 和故障类型 (issue_type)
prompt_template_1 = PromptTemplate(
    input_variables=["customer_query"],
    template="""你是一个专业的客服助手。请仔细阅读以下用户的问题，并尝试从中提取出用户提到的产品名称和故障类型。如果无法确定，请注明“未知”。
    请以 JSON 格式返回结果，例如：{{"product": "产品名称", "issue_type": "故障类型"}}

    用户问题: {customer_query}
    """
)

# 2. 创建第一个 LLMChain 实例
# output_key: 这个链的输出将存储在名为 "extracted_info" 的变量中
chain_1 = LLMChain(
    llm=llm,
    prompt=prompt_template_1,
    output_key="extracted_info", # 关键！这个output_key将作为下一个链的输入
    verbose=True # 开启verbose可以看到链的中间步骤
)

步骤二：构建第二个链 - 故障排除建议生成

这个链将接收上一个链提取出的产品和故障信息，然后生成具体的建议。

# 3. 定义第二个 Prompt Template: 故障排除建议
# input_variables: 需要接收上一个链的输出 (product_name, issue_type)
prompt_template_2 = PromptTemplate(
    input_variables=["extracted_info"], # 注意，这里接收的是上一个链的 output_key 的内容
    template="""你是一个经验丰富的技术支持专家。你收到用户关于产品故障的信息：
    {extracted_info}

    根据这些信息，请为用户提供一个初步的故障排除建议或下一步的指引。如果产品或故障类型未知，请提供通用建议。
    请注意语气要友好、专业，并给出明确的行动步骤。
    """
)

# 4. 创建第二个 LLMChain 实例
# output_key: 这个链的输出将存储在名为 "final_suggestion" 的变量中
chain_2 = LLMChain(
    llm=llm,
    prompt=prompt_template_2,
    output_key="final_suggestion",
    verbose=True
)

步骤三：串联所有链 - 使用 SequentialChain

现在，我们将这两个 LLMChain 串联起来，形成一个完整的处理流程。

# 5. 创建 SequentialChain
# chains: 按照执行顺序排列的链列表
# input_variables: 整个 SequentialChain 的初始输入。这里是用户原始问题 (customer_query)
# output_variables: 整个 SequentialChain 的最终输出。这里我们想要最终的建议 (final_suggestion)
overall_chain = SequentialChain(
    chains=[chain_1, chain_2],
    input_variables=["customer_query"],
    output_variables=["final_suggestion"],
    verbose=True # 开启verbose可以看到整个 SequentialChain 的执行过程
)

# 6. 运行我们的智能客服助手！
customer_query_1 = "我的小米扫地机器人好像充不进电了，是不是电池坏了？"
response_1 = overall_chain.invoke({"customer_query": customer_query_1})
print("\n--- 客户问题 1 ---")
print(f"用户: {customer_query_1}")
print(f"客服助手建议:\n{response_1['final_suggestion']}")

print("\n" + "="*50 + "\n")

customer_query_2 = "我的联想笔记本电脑开机黑屏，怎么办啊？"
response_2 = overall_chain.invoke({"customer_query": customer_query_2})
print("\n--- 客户问题 2 ---")
print(f"用户: {customer_query_2}")
print(f"客服助手建议:\n{response_2['final_suggestion']}")

print("\n" + "="*50 + "\n")

customer_query_3 = "我的手机屏幕碎了，能修吗？"
response_3 = overall_chain.invoke({"customer_query": customer_query_3})
print("\n--- 客户问题 3 ---")
print(f"用户: {customer_query_3}")
print(f"客服助手建议:\n{response_3['final_suggestion']}")

print("\n" + "="*50 + "\n")

customer_query_4 = "我不知道我的设备出了什么问题。"
response_4 = overall_chain.invoke({"customer_query": customer_query_4})
print("\n--- 客户问题 4 ---")
print(f"用户: {customer_query_4}")
print(f"客服助手建议:\n{response_4['final_suggestion']}")

代码解析：

• LLMChain 的 output_key： 这是 SequentialChain 能够正确传递变量的关键！chain_1 的输出被命名为 "extracted_info"，这个名字必须与 chain_2 的 prompt_template_2 中 input_variables 期望的变量名匹配。
• SequentialChain 的 input_variables 和 output_variables：
  • input_variables 定义了整个 SequentialChain 运行时需要接收的初始输入。
  • output_variables 定义了整个 SequentialChain 最终会返回哪些变量。
• verbose=True： 这个参数是调试链的神器！它会打印出每个链的输入、输出以及 LLM 的调用过程，帮助你理解数据是如何在链中流转的。强烈建议在开发调试阶段始终开启。

通过这个实战，你已经看到如何将复杂的客服问题分解成逻辑清晰的步骤，并用 LangChain 的链机制将它们串联起来，让我们的智能客服助手拥有了更强大的“多步思考”能力！

坑与避坑指南

链机制虽然强大，但在实际应用中也有些“坑”需要我们提前知道，避免踩雷。作为你的高级导师，我可不想你走弯路！

1. 输入/输出变量名称不匹配 (The Naming Game)

   • 坑： 这是 SequentialChain 最常见的错误！一个链的 output_key 必须与下一个链的 PromptTemplate 中 input_variables 期望的变量名完全匹配。大小写、拼写错误都会导致链无法正确执行，报错 KeyError。
   • 避坑指南：
     • 命名规范化： 从一开始就对 output_key 和 input_variables 采用清晰、一致的命名规则。
     • verbose=True 是你的好朋友： 调试时务必开启 verbose=True。它会清晰地打印出每个链的输入和输出，你可以一眼看出变量传递是否正确。
     • 逐步测试： 如果链很长，先独立测试每个 LLMChain，确保它们各自工作正常，再逐步组合。

2. 过度链化与性能问题 (The Chain Reaction Overload)

   • 坑： 理论上你可以无限地串联链，但每次 LLM 调用都意味着延迟和成本。如果一个任务可以通过一个更复杂的 Prompt 完成，却被拆成了七八个简单的 LLMChain，那你就浪费了资源，降低了用户体验。
   • 避坑指南：
     • 任务粒度适中： 权衡是关键。将任务分解到足够小，以便 LLM 可以可靠地处理，但不要过度分解。一个 LLMChain 能完成的事，就别用两个。
     • 并行化思考： 有些步骤不一定需要严格的顺序，未来我们会学到如何并行执行任务。
     • 缓存策略： 对于重复的 LLM 调用，考虑使用 LangChain 的缓存机制来减少实际的 API 调用。

3. 上下文丢失与信息传递不全 (The Amnesia Effect)

   • 坑： 在多步链中，如果中间链没有将关键信息完整地传递给后续链，LLM 可能会“忘记”重要的上下文，导致回复质量下降或逻辑错误。例如，第一步提取了订单号，但第二步的 Prompt 模板中没有包含这个订单号，那它就无法使用。
   • 避坑指南：
     • 显式传递： 确保每个 PromptTemplate 都包含了它所需的所有上下文信息。
     • output_variables 精心设计： 在 SequentialChain 中，仔细定义 output_variables，确保所有后续链需要的变量都被正确地从中间链导出。
     • Prompt 工程： 设计能够总结和保留关键信息的 Prompt，例如在回复中显式引用之前提取的信息。

4. 错误处理与鲁棒性 (The Fragile Chain)

   • 坑： 如果链中的某个 LLM 调用失败（例如，API 限流、网络错误、LLM 返回格式错误），整个链的执行就会中断。生产环境下的应用必须能够优雅地处理这些异常。
   • 避坑指南：
     • try-except 包裹： 在调用 chain.invoke() 时，使用 Python 的 try-except 块来捕获潜在的异常。
     • Prompt 韧性： 设计 Prompt 时，考虑 LLM 可能会返回非预期格式的情况，并提示它在失败时返回特定的错误信息，或者使用输出解析器来增加健壮性。
     • 重试机制： 对于临时的 API 错误，可以考虑实现简单的重试逻辑。

记住，构建 AI 应用是一个迭代的过程。勇敢地尝试，细心地调试，你就能掌握这些高级技巧！

📝 本期小结

各位未来的 AI 架构师们，恭喜你们！本期我们深入探索了 LangChain 中至关重要的**“链” (Chains)** 机制。

我们从理论上理解了链为何是构建复杂 LLM 应用的“脊梁骨”，它如何赋予我们的智能客服助手“多步思考”和“任务编排”的能力。我们重点学习了 LLMChain 这个基础构件，以及如何使用 SequentialChain 将多个 LLMChain 优雅地串联起来，完成从用户问题分类、信息提取到最终建议生成的复杂流程。

通过实战代码，你亲手构建了一个能够处理产品故障咨询的客服助手原型，它不再是简单的问答机器，而是能够根据上下文进行多步推理的智能体。

最后，我们还一起预习了在链式开发中可能遇到的“坑”以及如何巧妙避开它们，这些高阶的经验将是你未来开发道路上的宝贵财富。

掌握了链，你才算真正踏入了 LangChain 的核心世界。接下来，我们将在此基础上，继续为我们的智能客服知识库增添更多超能力，比如如何让它与外部工具（Tools）交互，获取实时数据，甚至自主决定行动路径！

继续加油，我们下期再见！