LangChain零基础入门：详解Model与Agent核心概念与实战

很多初学者第一次接触 LangChain 时，最困惑的问题不是“怎么安装”，而是“我明明已经能调用大模型 API 了，为什么还要用一个框架”？如果只是发一段 Prompt、拿一段回复，原生的 OpenAI SDK 或者 Requests 就足够了。但一旦你想做的是“根据用户问题自动选择工具”“让模型记住多轮对话”“从文档里检索资料后再回答”这类真正的智能应用，代码复杂度会迅速失控。

这篇文章会从零开始，把 LangChain 中最重要的两个概念拆开讲清楚：Model和Agent。我们会先理解 LangChain 的设计思路，再完成一个可运行的 AI 问答应用，最后实现一个能调用工具的 Agent 并解决实际任务。全文包含完整代码、环境配置、运行结果和常见问题排查，适合零基础入门，也适合想系统梳理 LangChain 知识体系的开发者收藏备用。

1. 为什么零基础入门先要理解 LangChain、Model、Agent

1.1 大模型应用开发的现实问题

假设你现在想做一个智能助手，功能是帮用户查时间、做算术、写周报。用原始 API 写的话，你要做的事包括：

• 设计提示词，并且在不同场景下拼接不同的提示词；
• 判断用户意图，然后自己写 if-else 决定调用哪个函数；
• 把函数返回结果拼回对话上下文，再请求一次模型；
• 处理多轮对话里的历史记录，避免上下文越攒越长；
• 兼容不同模型服务商，换一个模型就要改一遍调用代码。

这些工作本身并不复杂，但非常零散。LangChain 的价值在于，它把这些高频操作提炼成标准组件，并且提供了组合这些组件的“语法”。你可以把一次 AI 任务理解成一条流水线：输入 -> 提示词 -> 模型 -> 输出解析 -> 工具调用 -> 返回结果。LangChain 负责把流水线上的每个环节串起来。

1.2 LangChain 的定位：组件库 + 编排框架

LangChain 并不是一个类似 PyTorch 的深度学习框架，也不是一个类似 vLLM 的推理服务。它们解决的是完全不同的层级问题：

所以面试题或者项目文档里如果出现“LangChain、vLLM 跟 PyTorch 框架一个类型吗”，答案是否定的。LangChain 更接近“胶水层”，它不负责模型推理，而是负责让开发者用统一的方式调用各种模型、管理提示词、串联业务逻辑。

LangChain 的核心模块包括：

• Model I/O：负责模型调用、提示词管理、输出解析；
• Retrieval：负责文档加载、切分、向量化、检索，常与 RAG 结合；
• Memory：负责多轮对话历史存储；
• Agent：负责让模型自主决策并调用工具；
• Chain / LangGraph：负责把上面所有组件编排成完整流程。

1.3 Model 与 Agent 到底有什么区别

这是很多人混淆的地方。

Model（模型）是智能应用的大脑。它接收一段文本输入，返回一段文本输出。它的能力边界是“理解和生成语言”，但它本身不能执行操作。你让它“查询当前时间”，如果 Prompt 里没有时间信息，它只能凭训练数据猜一个，或者明确告诉你不知道。

Agent（智能体）是基于模型构建的决策和执行系统。Agent 的职责是：

1. 理解用户目标；
2. 判断需要哪些工具；
3. 调用工具获取结果；
4. 把工具结果交给模型继续推理；
5. 输出最终答案。

可以这样理解：Model 是“会说的人”，Agent 是“会做事的人”。Agent 内部的推理和表达仍然依赖 Model，但 Agent 额外拥有工具使用权和决策循环。

所以本文的实战会分两条线：第一条线是直接用 Model 做问答，第二条线是用 Agent 让模型调用工具完成任务。

2. 环境准备与版本说明

2.1 Python 环境准备

LangChain 是一个 Python 库，所以首先需要准备 Python 环境。建议使用 Python 3.10 或 3.11，过旧的版本可能导致依赖兼容问题。为了不污染系统环境，推荐创建独立虚拟环境。

在终端中执行：

python -m venv .venv

激活虚拟环境：

• Windows：

.venv\Scripts\activate

• Linux / macOS：

source .venv/bin/activate

激活后，终端提示符前面会出现(.venv)，说明当前已经进入虚拟环境。

2.2 安装 LangChain 相关依赖

LangChain 生态发展很快，一个容易踩坑的点是：不要只安装langchain一个包。现在的官方推荐是“按需安装”：

• langchain：核心框架；
• langchain-openai：OpenAI 以及 OpenAI 兼容接口的模型封装；
• langchain-community：社区贡献的集成组件；
• langchain-core：核心抽象，通常会被自动安装；
• python-dotenv：读取.env环境变量文件。

安装命令：

pip install "langchain" "langchain-openai" "langchain-community" "python-dotenv"

如果你的项目需要固定依赖版本，建议生成requirements.txt文件。下面是一个参考：

langchain>=0.3,<1.1 langchain-core>=0.3 langchain-openai>=0.2 langchain-community>=0.3 python-dotenv>=1.0

强调一点：LangChain 在 0.3 和 1.x 之间有一些接口调整。本文示例以 0.3 之后到 1.x 初期仍然稳定的 API 为主，如果你安装的是更高版本，遇到导入路径变化时，以官方迁移文档为准。

2.3 准备模型服务与密钥

LangChain 可以对接很多模型服务，包括 OpenAI、DeepSeek、通义千问、本地部署的 vLLM、Ollama 等。本文以“OpenAI 兼容接口”为例，这也是目前兼容性最好的方式。

你需要准备以下信息：

• 一个可用的大模型 API Key；
• 模型名称，例如gpt-4o-mini、deepseek-chat等；
• 如果是兼容接口，还需要 API Base URL。

不要把密钥直接写在代码里，更不要提交到 Git 仓库。推荐使用.env文件保存：

OPENAI_API_KEY=你的密钥 OPENAI_BASE_URL=https://api.openai.com/v1

如果你的模型服务商提供的是兼容 OpenAI 的 Base URL，可以替换OPENAI_BASE_URL。本文示例代码会先读取.env，再通过环境变量传给 LangChain。

2.4 项目目录结构设计

下面是一个简单但清晰的项目结构：

langchain-demo/ ├── .env ├── requirements.txt ├── chat_model.py # Model 基础调用示例 ├── prompt_template.py # 提示词模板示例 ├── chain_demo.py # 第一条链示例 ├── agent_demo.py # Agent 实战示例 └── app.py # 问答应用入口

实际开发中，推荐按功能拆分成models/、tools/、agents/、chains/等目录。前期练习阶段，先保持单文件风格更容易理解。

3. 第一个关键步骤：用 ChatModel 完成模型调用

3.1 ChatModel 基础用法

LangChain 里最常用的模型接口是ChatOpenAI，它对应的是聊天模型。与文本补全模型不同，聊天模型的输入输出都是消息对象，便于保留多轮对话结构。

先来看一个最基础的调用示例。新建chat_model.py：

import os from dotenv import load_dotenv from langchain_openai import ChatOpenAI load_dotenv() llm = ChatOpenAI( model="gpt-4o-mini", temperature=0, ) response = llm.invoke("用一句话简介 LangChain") print(response)

运行：

python chat_model.py

输出结果会是一个AIMessage对象，而不是普通字符串：

content='LangChain 是一个用于构建大语言模型应用的开源框架，通过将模型、提示词和工具编排成工作流，让开发者更高效地开发智能应用。' ...

这里有两个关键点：

1. temperature=0表示输出更确定，适合代码生成、分类、提取类任务；如果做创意写作，可以调大到 0.7 或更高。
2. invoke是 LangChain 统一的同步调用方法，返回的是结构化消息对象。如果直接打印整个对象，会包含content、response_metadata等字段。

如果只想拿文本，可以访问response.content：

print(response.content)

如果你的模型服务商使用兼容 OpenAI 的接口，可以加两个参数：

llm = ChatOpenAI( model="deepseek-chat", api_key=os.getenv("DEEPSEEK_API_KEY"), base_url=os.getenv("DEEPSEEK_BASE_URL"), )

模型名称必须以你实际使用的服务商为准，不同平台模型名称不同，即使底层模型相同，暴露出来的名字也可能不一样。

3.2 PromptTemplate：把提示词变成模板

直接在代码里拼字符串非常痛苦，尤其当提示词长达几十行时。LangChain 提供了PromptTemplate，支持变量插值和消息模板。

新建prompt_template.py：

from langchain_core.prompts import ChatPromptTemplate prompt = ChatPromptTemplate.from_messages([ ("system", "你是一名资深 Python 技术博主，擅长用通俗易懂的语言解释技术概念。"), ("human", "请帮我解释一下 {concept}，要求结合例子说明。"), ]) messages = prompt.invoke({"concept": "LangChain Agent"}) print(messages)

ChatPromptTemplate.from_messages接收一个消息列表，每条消息由角色和内容组成。角色可以是：

• system：系统指令，设定 AI 的角色和行为规范；
• human：用户输入；
• ai：AI 的历史回复；

invoke时传入一个字典，把{concept}替换成实际内容。这样做的最大好处是：提示词和代码逻辑解耦。后续要调整提示词，只需要改动模板，不需要动 Python 代码。

3.3 用 StrOutputParser 串联成第一条链

Model 返回的是AIMessage，但很多业务接口希望直接拿到字符串。LangChain 提供了输出解析器StrOutputParser，可以把消息对象中的content提取出来。

LangChain 从 0.2 开始主推LCEL（LangChain Expression Language），用|符号把组件串联起来，写法非常直观：

from langchain_core.prompts import ChatPromptTemplate from langchain_core.output_parsers import StrOutputParser from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-4o-mini", temperature=0) prompt = ChatPromptTemplate.from_template( "用一句话解释 {concept}，并给出一个实际应用场景。" ) chain = prompt | llm | StrOutputParser() result = chain.invoke({"concept": "LangChain Memory"}) print(result)

这里的chain就是一条完整的处理链路：

用户输入 -> 填充 Prompt -> 调用模型 -> 解析输出 -> 字符串结果

|符号并不是 Python 自带的语法，而是 LangChain 对__or__运算符的重写。它让代码读起来像管道，也方便在不同组件之间自由组合。

这是 LangChain 最核心的编程模型：一切皆组件，一切皆可链。

4. 实战一：从零搭建 AI 智能问答应用

4.1 创建项目结构与配置文件

在项目根目录创建.env文件：

OPENAI_API_KEY=你的密钥 OPENAI_BASE_URL=https://api.openai.com/v1

创建requirements.txt：

langchain>=0.3,<1.1 langchain-openai>=0.2 langchain-community>=0.3 python-dotenv>=1.0

安装依赖：

pip install -r requirements.txt

4.2 编写最小问答脚本

新建app.py：

import os from dotenv import load_dotenv from langchain_core.prompts import ChatPromptTemplate from langchain_core.output_parsers import StrOutputParser from langchain_openai import ChatOpenAI load_dotenv() # 1. 初始化模型 llm = ChatOpenAI( model=os.getenv("OPENAI_MODEL", "gpt-4o-mini"), temperature=0.3, ) # 2. 构建提示词模板 prompt = ChatPromptTemplate.from_messages([ ("system", "你是一个乐于助人的 AI 助手。回答尽量简洁、准确、有条理。"), ("human", "{question}"), ]) # 3. 串联成链 chain = prompt | llm | StrOutputParser() # 4. 接收用户输入并回答 if __name__ == "__main__": while True: question = input("请输入问题（输入 exit 退出）：").strip() if question.lower() == "exit": break if not question: continue answer = chain.invoke({"question": question}) print("AI:", answer) print("-" * 50)

4.3 流式输出改造

上面代码是一次性返回完整答案，如果问题复杂，用户等待时间会很长。你可以把chain.invoke改成chain.stream，实现打字机效果：

if __name__ == "__main__": while True: question = input("请输入问题（输入 exit 退出）：").strip() if question.lower() == "exit": break if not question: continue print("AI: ", end="", flush=True) for chunk in chain.stream({"question": question}): print(chunk, end="", flush=True) print("\n" + "-" * 50)

4.4 运行验证与输出说明

运行：

python app.py

示例交互：

请输入问题（输入 exit 退出）：LangChain 中的 Agent 是什么？ AI: Agent 是 LangChain 中能够根据用户目标自主选择并调用工具的智能体，它通过大模型进行推理决策，再借助外部工具完成实际操作。 -------------------------------------------------- 请输入问题（输入 exit 退出）：exit

到这里，你已经完成了第一个基于 LangChain 的 AI 问答应用。虽然功能简单，但已经覆盖了 LangChain 最核心的 Component + Chain 模式。

5. 深入 Agent：从“会聊天”到“会办事”

5.1 模型单独工作时的边界

现在我们对模型提一个问题：

请计算 12345 乘以 6789 等于多少？

大模型很可能给出一个接近但不完全正确的答案。原因是语言模型本身不擅长精确计算，它是通过“预测下一个 token”来生成文本的，而不是像计算器那样真的做四则运算。

再比如：

现在是几点钟？

如果模型没有联网能力，也没有接收系统时间，它就无法回答当前时间。

这些场景都说明：模型单独工作时有明确边界。Agent 解决的就是这个边界问题——当模型发现自己能力不足时，可以调用外部工具来获得准确结果。

5.2 Agent 的执行机制：ReAct 循环

LangChain Agent 的经典机制是ReAct，即 Reasoning + Acting。整个执行过程可以理解成循环：

1. 思考（Thought）：模型分析用户问题，决定下一步要做什么；
2. 行动（Action）：模型选择一个工具，并生成调用参数；
3. 观察（Observation）：系统执行工具，把结果返回给模型；
4. 继续循环：模型根据观察结果继续思考，直到认为可以输出最终答案；
5. 回答（Final Answer）：模型生成最终回复。

这个过程可以用下面这个流程描述：

用户输入 -> 模型推理 -> 需要工具？ -> 是：调用工具 -> 返回观察结果 -> 回到模型推理 -> 否：生成最终答案 -> 输出结果

Agent 最大的价值是“把决策权交给模型”。你不需要提前写好if-else判断用户意图，模型会在每次调用时自主决定。

5.3 用 @tool 自定义工具

LangChain 提供一个@tool装饰器，可以把普通函数快速包装成可供 Agent 调用的工具。工具需要满足两个条件：

1. 有清晰的函数名；
2. 有描述性的 docstring，模型会根据 docstring 判断什么时候调用这个工具。

新建agent_demo.py：

import os from datetime import datetime from dotenv import load_dotenv from langchain_openai import ChatOpenAI from langchain.agents import create_tool_calling_agent, AgentExecutor from langchain.tools import tool from langchain_core.prompts import ChatPromptTemplate load_dotenv() @tool def multiply(a: int, b: int) -> int: """计算两个整数的乘积，适合做精确乘法运算。""" return a * b @tool def get_current_time() -> str: """获取当前的日期和时间。当用户询问“现在几点”“今天日期”时使用。""" return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

重点说明：

• 函数名multiply会成为工具名；
• 函数签名a: int, b: int会告诉模型需要传入的参数类型；
• docstring 是模型判断调用时机的重要依据；
• 如果 docstring 写得太模糊，模型可能不知道在什么时候用这个工具。

5.4 使用 create_tool_calling_agent 构建 Agent

继续在agent_demo.py中添加代码：

# 初始化模型，注意工具调用需要模型支持 function calling llm = ChatOpenAI(model="gpt-4o-mini", temperature=0) tools = [multiply, get_current_time] prompt = ChatPromptTemplate.from_messages([ ("system", "你是一个可靠的 AI 助手，可以调用工具解决用户问题。"), ("placeholder", "{chat_history}"), ("human", "{input}"), ("placeholder", "{agent_scratchpad}"), ]) # 构建 Agent agent = create_tool_calling_agent(llm, tools, prompt) agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) result = agent_executor.invoke({ "input": "请帮我计算 12345 乘以 6789，然后告诉我当前时间。" }) print("\n最终答案:", result["output"])

代码里几个关键点：

• create_tool_calling_agent是专门给支持“工具调用”的模型使用的创建函数；
• tools列表决定 Agent 能使用哪些工具；
• agent_scratchpad是 Agent 的“草稿板”，用来记录已经产生的思考和观察结果；
• AgentExecutor负责真正执行循环，verbose=True会在控制台输出完整的运行过程。

5.5 运行 Agent 并观察思考过程

运行代码：

python agent_demo.py

如果一切正常，你会看到类似下面的日志：

> Entering new AgentExecutor chain... Invoking: `multiply` with `{'a': 12345, 'b': 6789}` 83774205 Invoking: `get_current_time` with `{}` 2025-XX-XX 14:30:22 > Finished chain. 最终答案: 12345 乘以 6789 的结果是 83774205。当前的日期和时间是 2025-XX-XX 14:30:22。

观察输出可以看到，Agent 确实没有自己做乘法，而是：

1. 调用了multiply工具，得到 83774205；
2. 调用了get_current_time工具，拿到当前时间；
3. 把两个结果组织成自然语言回答。

这就是 Agent 与普通 Model 调用的本质区别。模型还是那个模型，但因为有了工具使用权，它在面对事实性、实时性、精确性任务时，可以借助外部工具拿到准确结果。

6. LangGraph 与 LangChain：Agent 编排的下一站

6.1 LangGraph 与 LangChain 的关系

如果你搜索 LangChain 进阶内容，会发现一个高频词：LangGraph。简单理解：

• LangChain是组件库，解决“用什么组件”的问题；
• LangGraph是状态化编排框架，解决“流程如何流转、状态如何保存”的问题。

LangGraph 建立在 LangChain 组件之上，但它用“图”来描述 Agent 流程。节点代表一步操作，边代表状态转移，全局状态会随着流程推进不断更新。相比AgentExecutor，LangGraph 提供了更精细的控制能力。

6.2 为什么多 Agent 场景推荐 LangGraph

AgentExecutor适合快速实现单 Agent 的简单循环。但在生产级项目中，你可能会遇到这些需求：

• 一个 Agent 负责理解用户意图，另一个 Agent 负责搜索数据，第三个 Agent 负责生成报告；
• 某个节点执行失败时，希望回到上一步重新尝试；
• 需要人工审核后再继续执行；
• 需要控制每个节点的最大执行次数和时间。

这些需求用线性 Chain 和自带的 AgentExecutor 很难优雅实现。LangGraph 把流程建模成状态图，每个节点更新全局状态，执行器按照图结构遍历节点，因此天然支持分支、循环、回退、持久化。

6.3 从 Chain 到 Graph 的迁移思路

对于初学者，不需要立刻把所有项目都改成 LangGraph。推荐的学习路径是：

1. 先用 Chain 完成简单问答；
2. 再用 AgentExecutor 完成单工具、多工具调用；
3. 当流程中出现明显分支、循环、人工确认需求时，再引入 LangGraph。

理解这个演进关系，可以避免“一上来就上重器”的误区。我们后面部署到生产环境时，也需要先评估复杂度，而不是默认选择所有运行模式。

7. 常见问题与排查思路

7.1 高频报错对照表

7.2 模型调用与鉴权类问题

遇到鉴权类错误时，先按下面顺序排查：

1. 确认.env文件是否存在，并且位置在项目根目录；
2. 确认代码里调用了load_dotenv()；
3. 临时打印环境变量是否存在，注意不要打印完整密钥，建议只打印前几位；
4. 确认模型名称和服务商平台一致；
5. 如果使用了兼容接口，确认 Base URL 格式正确，例如是否缺少/v1路径。

下面这段代码可以帮助你快速检查环境变量：

import os from dotenv import load_dotenv load_dotenv() api_key = os.getenv("OPENAI_API_KEY") print("Key 是否存在:", bool(api_key))

7.3 Agent 不调用工具或调用失败怎么排查

如果 Agent 运行了，但完全没有调用工具，或者调用时参数错误，可以按下面步骤排查：

• 确认模型支持工具调用：create_tool_calling_agent要求模型支持 function calling，部分本地模型或旧模型不支持，可选择create_react_agent或换模型；
• 检查工具 docstring：工具描述越清晰，模型越容易判断何时使用；
• 检查工具参数类型：如果函数签名要求int，模型传入字符串时可能报错；
• 打开 verbose 日志：把AgentExecutor的verbose=True开启，观察模型每一步的思考和行动；
• 简化问题：先让 Agent 只做“计算 12 乘 13”，确认基本链路通后再增加多工具场景。

8. 最佳实践与工程建议

8.1 密钥与配置管理

生产环境中，密钥管理是第一优先级。任何时候都不要把 API Key 写在代码里，也不要提交到 Git 仓库。建议做法：

• 本地开发使用.env文件，并加入.gitignore；
• 服务器部署使用环境变量或密钥管理系统；
• 不同环境（开发、测试、生产）使用不同的 Key，避免一个 Key 泄露影响所有环境；
• 对 Key 设置额度上限和调用权限，遵循最小权限原则。

一个典型的.gitignore片段：

.env .venv/ __pycache__/

8.2 提示词与工具设计

提示词和工具描述的质量，直接影响 Agent 的准确性。在工程实践中，有几点很实用：

• 系统提示词要明确角色、任务边界、输出格式；
• 工具不要设计得太“大”，一个工具只做一件事；
• docstring 里写清楚“什么时候用、参数是什么、返回值是什么”；
• 工具名称使用动词+名词结构，例如get_current_time比time_tool更清晰；
• 如果 Agent 决策经常出错，优先改进提示词和工具描述，而不是急着换模型。

8.3 错误处理、重试与降级

大模型 API 并不是 100% 稳定，生产应用必须考虑容错。建议至少处理以下几种情况：

• 网络超时：设置合理的超时时间，并增加重试机制；
• 限流：捕捉限流异常，做指数退避重试；
• 模型不可用：准备一个备用模型，例如主模型失败时切换到其他模型；
• 输出格式不符合要求：增加输出校验，解析失败时让模型重新生成或返回兜底文案。

可以用下面的思路封装一个带重试的调用逻辑：

import time from tenacity import retry, stop_after_attempt, wait_exponential @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, max=10)) def call_with_retry(chain, params): return chain.invoke(params)

tenacity是一个通用的 Python 重试库，实际项目中可以直接引入。

8.4 成本、性能与可观测性

大模型应用的成本并不低。上线前要关注：

• 模型选择：简单任务不要用大参数模型，gpt-4o-mini级别的模型足够处理大部分问答任务；
• 上下文压缩：多轮对话历史不要无限追加，可以做滑动窗口或摘要；
• 缓存：相同问题在短期内可以复用答案，减少重复调用；
• 并发控制：不要无限制并发请求模型接口，避免触发限流；
• 日志：记录每次调用的模型、输入长度、输出长度、耗时和错误信息，方便成本核算和问题定位。

8.5 安全合规与生产发布

生产环境发布 AI 应用时，要注意安全的边界：

• 对用户输入做必要的过滤，防止提示词注入攻击；
• 对 Agent 工具权限做最小化设计，不要让 Agent 能直接删除数据库或执行高危命令；
• 输出内容要做合规校验，尤其涉及用户数据和敏感信息时；
• 涉及修改、删除、写入外部系统的操作，必须显式授权、人工确认、操作前备份；
• 不要在日志中记录完整密钥、用户敏感信息；
• 发布前先在测试环境完成全链路验证，再灰度发布到生产环境。

安全原则可以总结成一句话：Agent 的能力越强，权限边界越要收紧。

9. 总结与下一步学习路线

如果用一句话概括这篇文章的内容：Model 让 AI 拥有“语言能力”，Agent 让 AI 拥有“执行能力”，LangChain 是连接两者的高效工具链。

你掌握了哪些能力，可以对照检查：

• 理解了 LangChain 的模块定位，能说清 Chain、Agent、LangGraph 的区别；
• 能创建虚拟环境、安装 LangChain 依赖、配置模型 API Key；
• 能用 ChatModel、PromptTemplate、StrOutputParser 搭建第一条链；
• 能实现一个简单的 AI 问答应用，并支持流式输出；
• 能用@tool自定义工具，用create_tool_calling_agent构建 Agent；
• 遇到鉴权失败、模型不可用、工具不调用等问题时，有清晰的排查思路。

下一步建议按这个顺序继续深入：

1. 给问答应用增加“记忆”能力，让 Agent 记住多轮对话；
2. 学习 RAG，把本地文档切片、向量化、检索后交给模型回答；
3. 尝试 LangGraph，实现带分支和人工确认的复杂流程；
4. 把本地脚本包装成工具，让 Agent 能操作真实业务系统。

最后一个建议：不要重复造轮子，但也别盲目追新。先把你手头的场景用最小代码跑通，再逐步替换成更复杂的组件。多写几遍，多踩几次环境配置相关的坑，LangChain 的脉络就会越来越清楚。如果这篇文章对你有帮助，可以收藏备用，后续我会继续更新记忆、RAG 和 LangGraph 的实战内容。