企业官网建设流程全解析

一、为什么需要 Chain？

前面学习 LangChain 时，我们已经接触到了：

LLM Prompt Output Parser Memory

如果只是完成一个非常简单的任务，我们可以直接：

用户输入 ↓ Prompt ↓ LLM ↓ Answer

例如：

输入： 大号床单套装 Prompt： 描述制造“大号床单套装”的一个公司的最佳名称是什么？ LLM： 豪华床纺

这种任务非常简单。

但是实际的大模型应用通常不是“一次 Prompt 调用”就结束。

例如我们希望处理一条国外用户评论：

法语评论 ↓ 翻译成英文 ↓ 总结评论 ↓ 识别原始语言 ↓ 根据总结生成回复 ↓ 使用原始语言回复用户

这已经包含多个步骤。

如果全部手写：

result1 = llm(...) result2 = llm(...) result3 = llm(...) result4 = llm(...)

代码会越来越复杂。

因此 LangChain 提出了：

Chain

也就是：

把多个模型调用、Prompt、数据处理步骤按照一定逻辑连接起来。

可以把 Chain 理解成：

AI 应用中的流水线

二、什么是 Chain

Chain 最简单的理解：

Input ↓ Step 1 ↓ Step 2 ↓ Step 3 ↓ Output

每一个 Step 都可以是：

Prompt LLM Retriever Parser 另一个 Chain Tool 自定义函数

因此：

Chain 的核心不是“大语言模型”，而是流程编排。

三、本章四种 Chain

本章主要介绍：

Chain │ ├── LLMChain │ ├── SimpleSequentialChain │ ├── SequentialChain │ └── Router Chain └── MultiPromptChain

它们的关系可以简单理解为：

LLMChain ↓ 单个任务 SimpleSequentialChain ↓ 多个单输入单输出任务串联 SequentialChain ↓ 复杂多输入多输出任务串联 Router Chain ↓ 根据输入动态选择执行哪条链

这是整章最需要掌握的结构。

四、LLMChain

4.1 什么是 LLMChain

LLMChain是最基础的一种 Chain。

它主要把：

Prompt + LLM

组合起来。

即：

Input ↓ PromptTemplate ↓ LLM ↓ Output

五、初始化语言模型

教程首先导入：

from langchain.chat_models import ChatOpenAI from langchain.prompts import ChatPromptTemplate from langchain.chains import LLMChain

然后：

llm = ChatOpenAI( temperature=0.0 )

七、创建 Prompt Template

定义提示：

prompt = ChatPromptTemplate.from_template( "描述制造{product}的一个公司的最佳名称是什么?" )

这里：

{product}

是一个变量。

例如：

product = "大号床单套装"

那么真正发送给模型的 Prompt 类似：

描述制造大号床单套装的一个公司的最佳名称是什么?

所以：

PromptTemplate

可以理解为：

固定 Prompt + 动态变量

八、创建 LLMChain

接下来：

chain = LLMChain( llm=llm, prompt=prompt )

这一步把：

Prompt + LLM

组合成：

LLMChain

内部结构：

LLMChain │ ┌────────────┴────────────┐ │ │ Prompt LLM │ │ └────────────┬────────────┘ ↓ Output

九、运行 LLMChain

例如：

product = "大号床单套装" chain.run(product)

内部过程：

大号床单套装 ↓ 替换 {product} ↓ 完整 Prompt ↓ LLM ↓ 公司名称

例如输出：

豪华床纺

十、LLMChain 的本质

因此：

LLMChain( llm=llm, prompt=prompt )

本质就是：

Input ↓ Format Prompt ↓ Call LLM ↓ Output

可以近似理解成：

def chain(product): prompt_text = prompt.format( product=product ) result = llm(prompt_text) return result

LangChain 只是把这个过程进行了标准化封装。

十一、为什么一个 LLMChain 不够

假设我们想实现：

产品 ↓ 生成公司名称 ↓ 根据公司名称生成公司介绍

这里已经需要调用 LLM 两次。

第一步：

产品 ↓ 公司名称

第二步：

公司名称 ↓ 公司介绍

这时就需要：

Sequential Chain

十二、SimpleSequentialChain

SimpleSequentialChain中文可以理解为：

简单顺序链。

其特点是：

Chain 1 Output ↓ Chain 2 Input ↓ Chain 2 Output ↓ Chain 3 Input

即：

上一条链的输出直接作为下一条链的输入。

十三、创建第一个子链

首先：

first_prompt = ChatPromptTemplate.from_template( "描述制造{product}的一个公司的最好的名称是什么" )

构建：

chain_one = LLMChain( llm=llm, prompt=first_prompt )

它的作用：

product ↓ Chain 1 ↓ company_name

例如：

大号床单套装 ↓ 优床制造公司

十四、创建第二个子链

第二个 Prompt：

second_prompt = ChatPromptTemplate.from_template( "写一个20字的描述对于下面这个公司：{company_name}的" )

然后：

chain_two = LLMChain( llm=llm, prompt=second_prompt )

它的作用：

company_name ↓ Chain 2 ↓ company_description

例如：

优床制造公司 ↓ 优床制造公司是一家专注于生产高品质床具的公司。

十五、组合两个 Chain

然后：

from langchain.chains import SimpleSequentialChain

创建：

overall_simple_chain = SimpleSequentialChain( chains=[ chain_one, chain_two ], verbose=True )

结构：

SimpleSequentialChain │ ↓ chain_one │ 公司名称 ↓ chain_two │ ↓ 公司介绍

十六、运行 SimpleSequentialChain

例如：

product = "大号床单套装" overall_simple_chain.run(product)

完整过程：

大号床单套装 ↓ Chain 1 ↓ 优床制造公司 ↓ Chain 2 ↓ 优床制造公司是一家专注于生产高品质床具的公司。

十七、verbose=True 是什么

这里：

verbose=True

非常适合调试。

它会输出链的执行过程。

例如：

> Entering new SimpleSequentialChain chain... 优床制造公司 优床制造公司是一家专注于生产高品质床具的公司。 > Finished chain.

如果：

verbose=False

通常只返回最终结果。

因此开发阶段非常推荐：

verbose=True

因为可以观察：

每个 Chain 的输出是什么 数据有没有正确传给下一步 哪里出现了异常

十八、SimpleSequentialChain 的限制

它非常简单，但是限制也非常明显：

每一步只能处理一个输入和一个输出。

结构必须类似：

A ↓ B ↓ C ↓ D

不能很方便地处理：

A ────────┐ │ ↓ B → C → D ↑ │ E

如果后面的 Chain 同时需要：

原始输入 + 前面某一步结果 + 另外一个 Chain 的结果

SimpleSequentialChain 就不够用了。

因此需要：

SequentialChain

十九、SequentialChain

SequentialChain 是更加通用的顺序链。

核心特点：

可以同时保存和传递多个变量。

例如：

原始评论 Review │ ├───────────────┐ ↓ ↓ 翻译成英文 判断语言 ↓ ↓ English_Review language ↓ │ 生成 summary │ ↓ │ └───────┬───────┘ ↓ 生成最终回复 ↓ followup_message

这已经不是简单的“一条直线”。

而是：

多变量数据流

二十、SequentialChain 示例任务

教程实现的是：

用户评论 ↓ 翻译成英文 ↓ 英文评论 ↓ 进行总结

同时：

原始评论 ↓ 判断是什么语言

最后：

总结 + 原始语言 ↓ 生成对应语言的回复

因此完整流程：

Review │ ┌────────────┴────────────┐ │ │ ↓ ↓ Chain 1 Chain 3 │ │ English_Review language │ │ ↓ │ Chain 2 │ │ │ summary │ └────────────┬────────────┘ ↓ Chain 4 ↓ followup_message

这个图非常重要。

二十一、第一个 Chain：翻译评论

first_prompt = ChatPromptTemplate.from_template( "把下面的评论review翻译成英文:" "\n\n{Review}" )

构建：

chain_one = LLMChain( llm=llm, prompt=first_prompt, output_key="English_Review" )

输入：

Review

输出：

English_Review

特别注意：

output_key="English_Review"

二十二、output_key 的作用

为什么需要：

output_key

因为 SequentialChain 中同时存在很多数据：

Review English_Review summary language followup_message

必须告诉 LangChain：

当前 Chain 输出的数据叫什么名字。

因此：

output_key="English_Review"

可以理解为：

state["English_Review"] = chain_one(...)

这样后面的 Chain 就可以引用：

{English_Review}

二十三、第二个 Chain：总结评论

Prompt：

second_prompt = ChatPromptTemplate.from_template( "请你用一句话来总结下面的评论review:" "\n\n{English_Review}" )

Chain：

chain_two = LLMChain( llm=llm, prompt=second_prompt, output_key="summary" )

数据流：

English_Review ↓ Chain 2 ↓ summary

二十四、第三个 Chain：识别语言

Prompt：

third_prompt = ChatPromptTemplate.from_template( "下面的评论review使用的什么语言:\n\n{Review}" )

Chain：

chain_three = LLMChain( llm=llm, prompt=third_prompt, output_key="language" )

注意这里输入不是：

English_Review

而是最初的：

Review

所以 SequentialChain 能够：

保存原始输入，供后面的 Chain 再次使用。

二十五、第四个 Chain：生成最终回复

Prompt：

fourth_prompt = ChatPromptTemplate.from_template( "使用特定的语言对下面的总结写一个后续回复:" "\n\n总结: {summary}" "\n\n语言: {language}" )

Chain：

chain_four = LLMChain( llm=llm, prompt=fourth_prompt, output_key="followup_message" )

这里非常关键。

Chain 4 同时依赖：

summary + language

即：

Chain 2 Output + Chain 3 Output

这就是为什么：

SimpleSequentialChain

已经不够了。

二十六、构建 SequentialChain

from langchain.chains import SequentialChain

创建：

overall_chain = SequentialChain( chains=[ chain_one, chain_two, chain_three, chain_four ], input_variables=[ "Review" ], output_variables=[ "English_Review", "summary", "followup_message" ], verbose=True )

二十七、input_variables

这里：

input_variables=["Review"]

表示整个 SequentialChain 最开始需要用户提供：

Review

相当于函数：

def overall_chain(Review): ...

二十八、output_variables

这里：

output_variables=[ "English_Review", "summary", "followup_message" ]

表示整个 Chain 最后需要返回：

English_Review summary followup_message

例如：

{ "Review": "...", "English_Review": "...", "summary": "...", "followup_message": "..." }

二十九、SequentialChain 的核心：状态字典

理解 SequentialChain 最好的方法，是把它想象成维护了一个：

state = {}

假设最初：

state = { "Review": "法语评论" }

运行 Chain 1：

state["English_Review"] = ...

得到：

state = { "Review": "...", "English_Review": "..." }

运行 Chain 2：

state["summary"] = ...

现在：

state = { "Review": "...", "English_Review": "...", "summary": "..." }

运行 Chain 3：

state["language"] = "French"

于是：

state = { "Review": "...", "English_Review": "...", "summary": "...", "language": "French" }

最后 Chain 4 使用：

summary + language

得到：

state["followup_message"] = ...

所以：

SequentialChain 的本质，是让多个 Chain 共享一个不断扩展的变量状态。

三十、SimpleSequentialChain 和 SequentialChain 区别

这是本章非常容易考察的一个知识点。

最简单的记忆：

SimpleSequentialChain A → B → C → D

而：

SequentialChain A → B ──┐ │ ↓ └→ C → D

三十一、前面三种 Chain 都有一个共同特点

截至目前：

LLMChain SimpleSequentialChain SequentialChain

都有一个共同点：

执行路径是提前确定好的。

例如：

Chain1 ↓ Chain2 ↓ Chain3 ↓ Chain4

无论用户输入什么，流程都固定。

但真实系统可能不是这样。

比如：

用户问题

可能属于：

物理 数学 历史 计算机

如果全部使用同一个 Prompt：

你是一个专家，请回答： {question}

效果通常不如：

物理问题 → 物理 Prompt 数学问题 → 数学 Prompt 历史问题 → 历史 Prompt 计算机问题 → 计算机 Prompt

所以需要：

Router Chain

三十二、什么是 Router Chain

Router Chain 可以理解为：

大模型世界中的路由器。

输入：

Question

首先判断：

这个问题属于哪一类？

然后：

Question │ ↓ Router │ ┌───────────┼───────────┐ │ │ │ ↓ ↓ ↓ Physics Math History Chain Chain Chain

因此 Router Chain 的最大特点是：

运行路径不是固定的，而是根据输入动态选择。

三十三、Router Chain 的两个核心组成

Router 系统主要包含：

Router Chain

和：

Destination Chains

Router Chain

负责：

判断输入应该去哪里

Destination Chains

负责：

真正执行任务

例如：

Router │ ├── Physics Chain ├── Math Chain ├── History Chain └── Computer Science Chain

三十四、本章 Router 示例

教程创建了四类专家：

物理学 数学 历史 计算机科学

每个专家拥有不同 Prompt。

因此整体结构：

Question │ ↓ LLM Router │ 判断问题属于哪个领域 │ ┌─────────────┼─────────────┐ ↓ ↓ ↓ Physics Math History Chain Chain Chain ↓ Computer Science Chain

三十五、物理 Prompt

例如：

physics_template = """ 你是一个非常聪明的物理专家。 你擅长用一种简洁并且易于理解的方式回答问题。 当你不知道问题答案时，你承认你不知道。 这是一个问题： {input} """

核心就是：

角色设定 + 回答风格 + 约束 + 用户问题

三十六、数学 Prompt

数学 Prompt 强调：

把复杂问题拆成多个子问题

例如：

复杂数学问题 ↓ 拆分 ↓ 解决子问题 ↓ 组合结果 ↓ 最终答案

三十七、历史 Prompt

历史 Prompt 强调：

历史背景 历史证据 分析 反思 评估

因此同样的问题，如果使用不同 Prompt，模型行为也会产生明显差异。

三十八、计算机 Prompt

计算机 Prompt 强调：

算法 步骤 复杂度 问题求解 时间复杂度 空间复杂度

这实际上就是：

给不同任务配置不同的 Expert Prompt。

三十九、prompt_infos

定义好多个 Prompt 后，需要告诉 Router：

有哪些可选 Prompt 每个 Prompt 擅长什么

例如：

prompt_infos = [ { "名字": "物理学", "描述": "擅长回答关于物理学的问题", "提示模板": physics_template }, { "名字": "数学", "描述": "擅长回答数学问题", "提示模板": math_template }, { "名字": "历史", "描述": "擅长回答历史问题", "提示模板": history_template }, { "名字": "计算机科学", "描述": "擅长回答计算机科学问题", "提示模板": computerscience_template } ]

四十、Router 为什么需要 description

这是非常关键的一点。

Router 并不是根据：

chain 的代码

判断应该选择谁。

而主要依赖：

name + description

例如：

物理学： 擅长回答关于物理学的问题 数学： 擅长回答数学问题

当输入：

什么是黑体辐射？

Router 根据描述判断：

黑体辐射 → 物理学

因此：

Router 的路由质量很大程度取决于 Destination Description 是否清晰。

四十一、构建 Destination Chains

首先创建一个字典：

destination_chains = {}

然后：

for p_info in prompt_infos: name = p_info["名字"] prompt_template = p_info["提示模板"] prompt = ChatPromptTemplate.from_template( template=prompt_template ) chain = LLMChain( llm=llm, prompt=prompt ) destination_chains[name] = chain

最终：

destination_chains

大致类似：

{ "物理学": physics_chain, "数学": math_chain, "历史": history_chain, "计算机科学": computer_chain }

四十二、Default Chain

还有一个非常重要的设计：

Default Chain

因为用户可能问：

推荐几部科幻电影

这既不是：

物理 数学 历史 计算机

怎么办？

需要：

Default Chain

作为兜底。

四十三、创建 Default Chain

default_prompt = ChatPromptTemplate.from_template( "{input}" ) default_chain = LLMChain( llm=llm, prompt=default_prompt )

也就是说：

如果 Router 无法匹配任何专家 ↓ Default Chain ↓ 普通 LLM 回答

这是一种非常重要的软件设计思想：

Fallback / Graceful Degradation

即：

无法走专业路径 ↓ 至少还有通用路径

四十四、Router 本身也是一个 LLM

这是这一节非常值得理解的一点。

教程使用：

LLMRouterChain

它并不是传统的：

if question.contains("physics"):

也不是关键词分类。

而是：

Question ↓ LLM ↓ 判断属于哪个 Destination

所以实际上：

Router

本身也是一次 LLM 调用。

四十五、Router 的输出

Router 需要返回：

{ "destination": "...", "next_inputs": "..." }

其中：

destination

表示：

接下来调用哪个 Chain

例如：

物理学 数学 历史 计算机科学 DEFAULT

而：

next_inputs

表示：

传给目标 Chain 的输入

四十六、RouterOutputParser

因为 Router LLM 返回的是文本。

但是程序真正需要的是：

{ "destination": "...", "next_inputs": "..." }

所以需要：

RouterOutputParser()

它负责：

LLM Text Output ↓ Parser ↓ Structured Data

例如：

```json { "destination": "物理学", "next_inputs": "什么是黑体辐射？" }

Parser 将其转换成程序可以读取的数据。 --- # 四十七、构建 Router Chain 核心代码： ```python router_prompt = PromptTemplate( template=router_template, input_variables=["input"], output_parser=RouterOutputParser() )

然后：

router_chain = LLMRouterChain.from_llm( llm, router_prompt )

整体：

Question ↓ Router Prompt ↓ LLM ↓ RouterOutputParser ↓ destination + next_inputs

四十八、MultiPromptChain

最终：

chain = MultiPromptChain( router_chain=router_chain, destination_chains=destination_chains, default_chain=default_chain, verbose=True )

整体结构终于完整：

User Input │ ↓ Router Chain │ 判断 Destination │ ┌──────────────┼──────────────┐ │ │ │ ↓ ↓ ↓ Physics Mathematics History Chain Chain Chain │ └── Computer Science 如果无法匹配 ↓ Default Chain

四十九、物理问题的执行过程

输入：

chain.run( "什么是黑体辐射？" )

Router：

黑体辐射 ↓ 属于物理问题

所以：

Router ↓ Physics Chain ↓ 物理专家 Prompt ↓ LLM ↓ Answer

五十、数学问题

输入：

chain.run( "2+2等于多少？" )

Router：

2+2 ↓ 数学

于是：

Math Chain

负责回答。

五十一、Router Chain 的优势

如果没有 Router：

所有问题 ↓ 同一个 Prompt ↓ LLM

而有了 Router：

User Question │ ↓ Router │ ┌────────┼────────┐ ↓ ↓ ↓ Prompt A Prompt B Prompt C ↓ ↓ ↓ LLM LLM LLM

优势：

不同任务使用不同 Prompt 不同领域使用不同策略 系统模块化 更容易维护 更容易扩展

五十二、Router Chain 在真实系统中的应用

例如 AI 客服：

用户问题 ↓ Router │ ├── 售前咨询 Chain ├── 订单查询 Chain ├── 退款 Chain ├── 技术支持 Chain └── 投诉 Chain

再例如企业 AI 助手：

User Query ↓ Router │ ├── HR Chain ├── Finance Chain ├── IT Chain ├── Legal Chain └── General Chain

五十三、四种 Chain 的完整对比

五十四、从程序结构角度理解四种 Chain

LLMChain

类似：

def task(x): return llm(prompt(x))

SimpleSequentialChain

类似：

def workflow(x): x = chain1(x) x = chain2(x) x = chain3(x) return x

SequentialChain

类似：

def workflow(review): english_review = chain1(review) summary = chain2(english_review) language = chain3(review) reply = chain4( summary, language ) return { "english_review": english_review, "summary": summary, "reply": reply }

Router Chain

类似：

def router(question): category = classify(question) if category == "physics": return physics_chain(question) elif category == "math": return math_chain(question) elif category == "history": return history_chain(question) elif category == "computer": return computer_chain(question) else: return default_chain(question)

这四段伪代码把本章几乎所有核心内容都概括了。

五十五、Chain 本质上是在构建有向图

如果进一步抽象，会发现：

Chain

其实就是节点之间的数据流。

比如 SequentialChain：

Review │ ├─────────────┐ ↓ ↓ Translate Detect Language ↓ ↓ Summary │ └──────┬──────┘ ↓ Reply

可以看成：

Directed Graph

也就是：

有向图。

节点：

Prompt LLM Parser Retriever Tool Function

边：

数据流

这其实已经非常接近现代 LLM Workflow / Agent Framework 的底层思想。

五十六、Chain 和普通 Python Pipeline 有什么区别

有人可能会问：

这些东西我直接用 Python 函数串起来不就可以了吗？

当然可以。

例如：

english = translate(review) summary = summarize(english) language = detect_language(review) reply = generate_reply(summary, language)

完全可以实现。

LangChain Chain 的价值主要是：

统一接口 Prompt 管理 模型调用 日志 Tracing 输入输出约定 组件组合 后续扩展

所以：

Chain 不是 Python 做不到，而是把 LLM Application Workflow 标准化。

五十七、一个容易产生的误区

很多初学者看到：

Chain

会认为：

Chain = 多次调用 ChatGPT。

并不准确。

更准确地说：

Chain =多个组件按照既定的数据依赖关系组成一个工作流。

里面可以有：

LLM Prompt Memory Retriever Parser Tool Database Function

因此：

LLM Chain

只是 Chain 中的一种。

五十八、Chain 与 Prompt Chain 的区别

Prompt Chain 更强调：

Prompt1 ↓ LLM ↓ Prompt2 ↓ LLM

而 LangChain 中的 Chain 是更加通用的抽象：

Component A ↓ Component B ↓ Component C

例如后面的 RAG：

Question ↓ Retriever ↓ Documents ↓ Prompt ↓ LLM

也可以看成一个 Chain。

五十九、为什么 Chain 对复杂 LLM 应用很重要

一个真正的 AI Application 往往不是：

Question ↓ LLM ↓ Answer

而是：

Question ↓ Intent Classification ↓ Router ↓ Knowledge Retrieval ↓ Prompt Construction ↓ LLM ↓ Output Parser ↓ Validation ↓ Answer

甚至：

Answer ↓ 不通过？ ↓ 重新调用模型

因此：

随着系统复杂度提高，最困难的问题会逐渐从 Prompt Engineering 转向 Workflow Engineering。

六十、LLM Application 的三个层次

学习到这里，可以把 LLM 应用分成三个层次。

第一层：单次 Prompt

Prompt ↓ LLM

第二层：Chain

Prompt ↓ LLM ↓ Prompt ↓ LLM ↓ Parser

第三层：复杂 Workflow / Agent

Input ↓ Router ↓ Planning ↓ Tool ↓ Retriever ↓ LLM ↓ Evaluation ↓ Replan

所以 Chain 实际上是：

从简单 LLM 调用走向复杂 AI Agent 的重要过渡。

六十一、本章最重要的变量关系

SequentialChain 中一定要搞清：

input_variables output_key output_variables

input_variables

整个 Chain 的入口：

input_variables=["Review"]

output_key

某一个子 Chain 的输出名称：

output_key="summary"

output_variables

整个 Chain 最终返回哪些变量：

output_variables=[ "English_Review", "summary", "followup_message" ]

关系：

input_variables ↓ Chain ↓ output_key ↓ 成为其他 Chain 的 Input ↓ 最终部分结果进入 output_variables

六十二、Router 最重要的三个概念

Router 部分重点记住：

Router Chain Destination Chains Default Chain

对应：

Router Chain 负责： 去哪？ Destination Chain 负责： 干活 Default Chain 负责： 没人匹配怎么办？

可以记成：

Router = 调度员 Destination Chain = 专家 Default Chain = 全科医生

六十三、本章完整知识结构

LangChain Chains │ ├── LLMChain │ │ │ ├── Prompt │ └── LLM │ ├── SimpleSequentialChain │ │ │ ├── Chain 1 │ ├── Chain 2 │ └── Chain 3 │ ├── SequentialChain │ │ │ ├── input_variables │ ├── output_key │ ├── output_variables │ └── 多变量依赖 │ └── Router Chain │ ├── Router Chain │ ├── Destination Chains │ ├── Default Chain │ └── RouterOutputParser

六十四、一张图理解本章

第一阶段： Input ↓ Prompt ↓ LLM ↓ Output LLMChain

然后升级：

Input ↓ Chain1 ↓ Chain2 ↓ Chain3 ↓ Output SimpleSequentialChain

继续升级：

Input │ ┌─────┴─────┐ ↓ ↓ Chain1 Chain3 ↓ ↓ Chain2 │ └─────┬─────┘ ↓ Chain4 SequentialChain

最后：

Input │ ↓ Router │ ┌────────┼────────┐ ↓ ↓ ↓ Chain A Chain B Chain C │ 无匹配 → Default Router Chain

这就是本章的完整演进过程。

六十九、最终总结

本章介绍的核心并不是四个 LangChain 类，而是 AI Workflow 从简单到复杂的四个阶段：

LLMChain ↓ 封装单个 LLM 任务 SimpleSequentialChain ↓ 线性流水线 SequentialChain ↓ 多变量数据流 Router Chain ↓ 动态分支工作流

最终可以用一句话总结：

Chain 的本质，就是把大模型应用中的多个处理步骤，通过明确的数据输入输出关系连接起来。

如果再进一步抽象：

节点 + 数据流 + 路由 = LLM Workflow

七十、本章思维导图

模型链 Chains │ ├── 1. LLMChain │ ├── PromptTemplate │ ├── LLM │ └── Input → Prompt → LLM → Output │ ├── 2. SimpleSequentialChain │ ├── 多 Chain │ ├── 单输入单输出 │ └── A → B → C → D │ ├── 3. SequentialChain │ ├── input_variables │ ├── output_key │ ├── output_variables │ └── 多输入、多输出、多依赖 │ └── 4. Router Chain ├── Router Chain ├── Destination Chains ├── Default Chain ├── RouterOutputParser └── 根据输入动态选择执行路径