LangChain 的 6 个核心模块，分别解决什么问题
如果你读了上一篇《LangChain 是什么？》，大概率会有这个问题：它到底怎么用？
上一篇讲了定位和价值，这篇回答一个更具体的问题：LangChain 的六个核心模块分别解决什么实际问题，以及在真实开发场景中怎么用到它们。
一、LLM 与提示词管理
解决什么问题
直接用 API 调用大模型时，你得自己拼提示词。想让 AI 扮演客服，你得每次写：你是专业的客服，语气友好，回答要简洁...换个场景又得重写一遍。提示词一多，管理就成了噩梦。
LangChain 的提示词模板把这件事标准化了。你可以定义一个模板，里面留出变量位置，运行时自动填充。
代码示例
from langchain_core.prompts import ChatPromptTemplate
# 定义模板
template = ChatPromptTemplate.from_messages([
("system", "你是一个{persona}，请用{tone}的语气回答用户问题。"),
("human", "{question}")
])
# 填充变量
messages = template.format_messages(
persona="技术支持工程师",
tone="耐心专业",
question="怎么重置密码？"
)
# 调用模型
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o")
response = llm.invoke(messages)
print(response.content)
统一模型接口
另一个痛点是模型绑定。直接写死 openai.ChatCompletion.create() 的代码，换模型时得改一大堆。LangChain 的 LLM 抽象层让你写一次代码，通过配置切换不同模型。从 OpenAI 切换到 Anthropic，只需要改一个 model 参数。
# 用 OpenAI
llm = ChatOpenAI(model="gpt-4o")
# 切换到 Anthropic，调用方式完全不变
llm = ChatAnthropic(model="claude-sonnet-4-20250514")
# 切换到本地开源模型
llm = ChatOllama(model="llama3")
典型场景
一家电商公司用 ChatPromptTemplate 管理了 200 多个不同场景的客服提示词。以前每次改客服话术要改代码重新部署，现在运营直接在配置文件里改模板就行，不用碰代码。
二、链（Chain）
解决什么问题
现实中的 AI 任务往往不是一步完成的。比如你想让 AI 读一篇 PDF、总结内容、翻译成英文、生成摘要报告——每一步都需要调一次模型，中间还要做文本处理。自己写这种多步骤逻辑，代码很快变成意大利面条。
Chain 把多步骤编排变成声明式的管道。你定义好每一步是什么，LangChain 帮你串起来执行。
深入理解 Chain
Chain 的核心思想是：每个步骤是一个可复用的组件，步骤之间通过输入输出连接。最基本的 Chain 由三部分组成：提示词模板（把变量填充成完整提示词）、LLM（调用模型）、输出解析器（把模型返回的文本转成结构化数据）。
但 Chain 真正强大的地方在于组合。你可以把一个 Chain 的输出作为另一个 Chain 的输入，形成链式调用。也可以在一个 Chain 里并行执行多个子 Chain，最后合并结果。
代码示例
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o")
# 第一个 Chain：翻译
translate_prompt = ChatPromptTemplate.from_template("将以下文本翻译成中文：{text}")
translate_chain = translate_prompt | llm | StrOutputParser()
# 第二个 Chain：润色
refine_prompt = ChatPromptTemplate.from_template("润色以下中文文本，使其更流畅：{text}")
refine_chain = refine_prompt | llm | StrOutputParser()
# 组合：先翻译再润色
def full_pipeline(text):
translated = translate_chain.invoke({"text": text})
refined = refine_chain.invoke({"text": translated})
return refined
result = full_pipeline("Artificial intelligence is transforming every industry.")
print(result)
典型场景
我帮一个内容团队搭过一套自动化流程。原始素材是一篇英文技术博客，流程是：文本清洗（去掉格式和广告）→ 翻译成中文 → 生成 3 个不同风格的标题 → 生成配图描述。每一步都是一个独立的 Chain，串起来后，输入一篇英文博客，输出一套完整的中文内容包。
三、LCEL 表达式
解决什么问题
Chain 解决了多步骤编排的问题，但定义 Chain 的方式有点繁琐——你得实例化组件、手动接线、写 try-catch。LCEL（LangChain Expression Language）让这件事变得极其简单。
深入理解 LCEL
LCEL 的核心是管道符。用 | 把各个组件串起来，数据从左到右流动。比如 prompt | model | output_parser 这行代码，就定义了一个完整的 AI 处理流程。
这种写法看起来简单，但背后做了很多事。每个 | 连接的两个组件之间，LangChain 自动处理了异步执行、错误重试、流式输出。
代码示例
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
prompt = ChatPromptTemplate.from_template("用一句话概括{topic}")
model = ChatOpenAI(model="gpt-4o")
parser = StrOutputParser()
# 用管道符定义一个完整的 AI 处理链
chain = prompt | model | parser
# 调用
result = chain.invoke({"topic": "量子计算"})
print(result)
# 批量调用
results = chain.batch([
{"topic": "人工智能"},
{"topic": "区块链"},
{"topic": "量子计算"}
])
# 流式输出
for chunk in chain.stream({"topic": "机器学习"}):
print(chunk, end="", flush=True)
为什么比传统写法好
传统的写法是命令式的：先创建提示词模板，再调用模型，再解析结果，每一步都要写 try-catch。LCEL 是声明式的：你只描述要什么流程，框架负责执行。
我自己用 LCEL 写一个 Chain 大概 5 行代码。同样的功能，传统写法至少要 30 行。
四、检索增强生成（RAG）
解决什么问题
大模型的知识有截止日期。你问它 2025 年 5 月之后发生的事，它大概率在瞎编。更关键的是，公司内部文档、产品手册、技术规范——这些内容模型的训练数据里根本没有。
RAG 解决的就是这个问题。先从知识库里检索出和用户问题相关的文档片段，把这些片段塞进提示词，再让模型基于这些信息生成回答。相当于给模型开了一个外接硬盘。
深入理解 RAG
RAG 的管线大致是这样的：文档加载（读取 PDF、Word、网页等）→ 文档切分（把长文档切成小块）→ 向量化（把文本转成数字向量存入向量数据库）→ 检索（根据用户问题找最相关的片段）→ 生成（把检索结果塞进提示词让模型回答）。
每一步都有讲究。文档切分太粗，检索不精准；太碎，上下文不连贯。向量数据库选不好的话，检索速度慢且质量差。
代码示例
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
# 1. 加载文档
loader = PyPDFLoader("company_docs.pdf")
docs = loader.load()
# 2. 切分
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(docs)
# 3. 向量化并存入向量数据库
vectorstore = Chroma.from_documents(chunks, OpenAIEmbeddings())
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
# 4. 构建 RAG Chain
prompt = ChatPromptTemplate.from_template(
"基于以下上下文回答用户问题。如果上下文中没有相关信息，请说明。\n\n上下文：{context}\n\n问题：{question}"
)
def format_docs(docs):
return "\n\n".join(doc.page_content for doc in docs)
rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| ChatOpenAI(model="gpt-4o")
| StrOutputParser()
)
# 5. 使用
answer = rag_chain.invoke("公司的请假流程是什么？")
print(answer)
典型场景
一个常见的应用场景是内部知识库问答。比如一家公司有 500 篇技术文档，以前新人遇到问题得翻文档或者问老员工。现在用 RAG 搭一个问答系统，输入问题就能直接从文档里找到答案。
五、Agent（智能体）
解决什么问题
Chain 是固定流程——你提前定义好每一步怎么做。但现实中的很多任务没法提前规划。比如你问 AI 帮我查一下明天的天气然后根据天气推荐穿搭，这个任务需要两步，但第二步依赖第一步的结果，而且如果天气 API 调用失败了还得决定怎么处理。
Agent 解决的就是这种需要动态决策的问题。它以大模型为决策引擎，配备一套工具箱，自己决定用哪个工具、按什么顺序用、拿到中间结果后再决定下一步做什么。
深入理解 Agent
Agent 的核心循环是这样的：接收任务 → 大模型思考该怎么做 → 调用某个工具 → 拿到结果 → 大模型再思考下一步 → 继续调用工具或返回最终结果。这个循环可以重复多次，直到任务完成。
Agent 的工具箱可以包含：搜索引擎、数据库查询、API 调用、代码执行、文件读写等。关键在于，工具是可选的——Agent 自己决定要不要用、什么时候用。
代码示例
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate
# 定义工具
@tool
def get_weather(city: str) -> str:
"""获取指定城市的天气信息"""
# 这里可以调用真实的天气 API
weather_data = {
"北京": "晴，25°C",
"上海": "多云，28°C",
"深圳": "阴，26°C"
}
return weather_data.get(city, "未知城市")
@tool
def search_web(query: str) -> str:
"""搜索网络获取信息"""
# 这里可以调用真实的搜索 API
return f"关于'{query}'的搜索结果..."
# 创建 Agent
llm = ChatOpenAI(model="gpt-4o")
tools = [get_weather, search_web]
prompt = ChatPromptTemplate.from_template(
"你是一个助手，可以使用以下工具：{tools}\n\n用户问题：{input}\n\n请思考并使用工具来回答。"
)
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 使用
result = agent_executor.invoke({"input": "北京明天天气怎么样？适合穿什么？"})
print(result["output"])
典型场景
一个典型的场景是：你让 Agent 帮我查一下竞品最近发布了什么新功能。Agent 会先用搜索引擎查资讯，再用网页抓取工具读取具体内容，最后汇总成一份分析报告。整个过程你不需要写任何流程控制代码。
我自己做过一个更实际的例子：一个自动化运维 Agent，它能根据告警信息自动排查问题——先查日志，再查监控数据，最后给出修复建议。如果排查过程中需要重启服务，Agent 会先问你确认，不会擅自操作。
六、记忆模块
解决什么问题
大模型本身没有记忆——每次对话都是从零开始。你跟它说了自己的名字，下一轮它就忘了。这在聊天机器人场景中是致命的。
LangChain 的记忆模块让 AI 能够记住之前的对话内容，支持短期记忆（当前会话）和长期记忆（跨会话持久化）。
深入理解记忆模块
LangChain 提供了多种记忆类型：
- ConversationBufferMemory：保存完整对话历史，适合客服场景
- ConversationSummaryMemory：用模型总结对话历史，节省 token，适合长对话
- VectorStoreRetrieverMemory：用向量存储做语义检索回忆，适合知识库场景
代码示例
from langchain.memory import ConversationBufferMemory
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
# 创建记忆模块
memory = ConversationBufferMemory(memory_key="chat_history")
# 创建带记忆的 Chain
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个友好的助手，记住用户的偏好和历史对话。"),
("human", "{input}")
])
llm = ChatOpenAI(model="gpt-4o")
chain = LLMChain(llm=llm, prompt=prompt, memory=memory)
# 第一轮对话
response1 = chain.invoke({"input": "我叫小明，我喜欢简洁的回答"})
print(response1["text"])
# 第二轮对话，AI 会记住用户的名字和偏好
response2 = chain.invoke({"input": "帮我写一段 Python 代码"})
print(response2["text"])
# 查看记忆内容
print(memory.buffer)
典型场景
一个实际的使用场景是：你在做一个 AI 辅导系统，学生每次来问问题时，AI 需要记住他之前的学习进度和薄弱知识点。用 VectorStoreMemory，把学生的学习记录存入向量数据库，每次对话时检索出相关的历史记录，AI 就能做到因材施教。
总结
六个模块，解决六个不同的问题：
- LLM 与提示词管理解决的是怎么调模型的问题
- Chain解决的是怎么串步骤的问题
- LCEL解决的是怎么优雅地定义流程的问题
- RAG解决的是怎么给模型补充知识的问题
- Agent解决的是怎么让模型自主决策的问题
- 记忆模块解决的是怎么让模型记住上下文的问题
这六个模块不是孤立使用的。一个实际的 AI 应用往往会同时用到多个模块。比如一个智能客服系统：用提示词模板定义客服人设，用 RAG 检索知识库回答专业问题，用 Chain 编排多轮对话流程，用记忆模块记住用户的偏好和历史问题，用 Agent 处理需要调用外部系统的复杂请求。
LangChain 的价值就在这里：它提供了一整套经过验证的组件，让你不用从零开始造轮子。
系列文章：