🔥彻底搞懂 AI Agent！LangGraph 从入门到实战（附完整源码）

从零开始，彻底掌握 AI Agent 的构建之道 ------ 让 AI 从「只能说」进化到「能思考、能行动、能记忆」 （😊若你第一次听说LangChain，可以浏览我往期文章，快速构建认知体系）

技术栈 ：LangChain v0.3 | LangGraph v0.2 | Node.js 18+

---

🚀 代码仓库 & 运行环境

📦 本文所有代码示例均已上传 GitHub，请放心食用！

GitHub 仓库地址

🔗 github.com/Lidh1023/no...

运行环境要求

# 环境要求
Node.js >= 18.0.0
npm >= 9.0.0

# 克隆代码
git clone https://github.com/Lidh1023/nodejs-basic.git
cd nodejs-basic/langchain-learning

# 安装依赖
npm install

# 配置环境变量（创建 .env 文件）
DEEPSEEK_API_KEY=your_api_key_here

# 运行示例
node src/agent.js

依赖包版本

包名	版本	说明
@langchain/langgraph	^0.2.x	LangGraph 核心库
@langchain/core	^0.3.x	LangChain 核心组件
@langchain/deepseek	^0.1.x	DeepSeek 模型支持
zod	^3.x	参数校验
dotenv	^16.x	环境变量管理

💡 Tips: 拉取代码后，只需配置好 API Key，即可直接运行所有示例代码！

---

📖 写在前面

你是否想过这些问题？

• 🤔 为什么 ChatGPT 只能聊天，不能帮我真正做事？
• 🤔 如何让 AI 自己决定什么时候查资料、什么时候计算？
• 🤔 AI Agent 到底是什么？和普通的 AI 对话有什么区别？
• 🤔 LangChain Agent 和 LangGraph 到底是什么关系？

本文将带你彻底理解 Agent 的概念、原理和实现！

读完本文，你将能够：

• ✅ 理解 LangChain 与 LangGraph 的关系
• ✅ 掌握 Agent 的本质和工作原理
• ✅ 掌握 ReAct 模式（推理 + 行动）
• ✅ 使用 LangGraph 构建自己的 Agent
• ✅ 为 Agent 添加记忆功能，实现多轮对话
• ✅ 理解 Agent 与 Tools 的协作关系

---

📚 文章大纲

📖 Part 1: 基础概念
   ├── LangChain 与 LangGraph 的关系
   ├── 什么是 Agent
   └── Agent vs 普通 LLM

🔄 Part 2: ReAct 模式
   ├── ReAct 模式详解
   └── ReAct 的核心循环

🧩 Part 3: Agent 核心组件
   ├── 组件架构图
   ├── LLM（大脑）
   ├── Tools（工具）
   ├── State（状态）
   └── Graph（流程图）

🛠️ Part 4: 构建 Agent
   ├── 环境准备
   ├── 完整代码示例
   └── Agent 的工作流程

💾 Part 5: 记忆功能
   ├── 为什么需要记忆
   ├── MemorySaver 详解
   └── thread_id 线程标识

🎯 Part 6: 实战案例
   ├── 多轮对话机器人
   ├── 带记忆的 Agent
   └── 智能客服 Agent

✅ Part 7: 最佳实践

❓ Part 8: 常见问题 FAQ

🚀 Part 9: 进阶主题

---

Part 1: 基础概念

LangChain 与 LangGraph 的关系

💡 这是很多初学者的困惑点，让我们先把这个问题搞清楚

一句话回答

Agent 是一个通用概念，但在 LangChain 生态中，构建复杂 Agent 的能力主要由 LangGraph 提供。

两者的定位区别

┌─────────────────────────────────────────────────────────────────┐
│                    LangChain 生态系统                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                    LangChain                             │   │
│   │                                                         │   │
│   │   📦 基础组件库                                          │   │
│   │   • LLM（大语言模型）                                    │   │
│   │   • Prompt（提示词模板）                                 │   │
│   │   • Tools（工具定义）                                    │   │
│   │   • Memory（记忆组件）                                   │   │
│   │   • 简单组合：pipe()、RunnableSequence                   │   │
│   │   • 主要处理：线性流程                                   │   │
│   └─────────────────────────────────────────────────────────┘   │
│                              │                                  │
│                              ▼                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                    LangGraph                             │   │
│   │                                                         │   │
│   │   🔄 工作流编排框架                                       │   │
│   │   • 状态管理（StateGraph）                               │   │
│   │   • 复杂流程：分支、循环、并行                            │   │
│   │   • Agent 模式（ReAct）                                  │   │
│   │   • 检查点/记忆（Checkpointer）                          │   │
│   │   • 主要处理：非线性、有状态的复杂流程                    │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

详细对比

层面	LangChain	LangGraph
定位	基础组件库	工作流编排框架
提供	LLM、Prompt、Tools、Memory	状态管理、循环、条件分支
流程	线性流程	复杂的非线性流程
Agent	早期有简单 Agent API	推荐的 Agent 构建方式
适用场景	简单的 Prompt → LLM → Parser	条件分支、循环迭代、复杂 Agent

配合使用示例

// LangChain 组件
import { ChatDeepSeek } from "@langchain/deepseek";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { DynamicStructuredTool } from "@langchain/core/tools";

// LangGraph 编排
import { StateGraph, Annotation } from "@langchain/langgraph";

// 组合使用
const llm = new ChatDeepSeek({ model: "deepseek-chat" });
const tools = [
  new DynamicStructuredTool({
    /* ... */
  }),
];
const llmWithTools = llm.bindTools(tools); // LangChain 能力

const graph = new StateGraph(State) // LangGraph 编排
  .addNode("agent", async (state) => {
    const response = await llmWithTools.invoke(state.messages);
    return { messages: [response] };
  });

选择指南

场景	选择
简单的 Prompt → LLM → Parser	LangChain pipe()
RAG 检索问答	LangChain
多步骤生成流程	两者都可
条件分支逻辑	LangGraph
循环/迭代任务	LangGraph
复杂 Agent	LangGraph
多 Agent 协作	LangGraph

为什么 Agent 要用 LangGraph？

Agent 的 ReAct 模式需要：

• ✅ 循环迭代 - LangGraph 原生支持
• ✅ 条件分支 - 根据工具调用结果决定下一步
• ✅ 状态管理 - 自动管理对话历史和中间状态

这些能力 LangChain 的简单 pipe() 难以实现，但 LangGraph 原生支持。

💡 总结 ：Agent 的概念和组件 （如 Tools）来自 LangChain，但构建和编排 Agent 的能力主要由 LangGraph 提供。现在官方推荐使用 LangGraph 来构建生产级的 Agent。

---

什么是 Agent

🤔 一句话解释

Agent（智能代理）是能够自主思考、决策并执行任务的 AI 系统。

它不仅能"说"（生成文本），还能"做"（调用工具执行操作）。

形象比喻

想象你雇了一个助理：

类型	行为特点
普通 AI	只会回答问题，"天气我不知道，你自己查吧"
AI Agent	会主动行动，"我帮你查一下... 北京今天 15°C"

Agent = 有手有脚的 AI

Agent 的核心能力

┌─────────────────────────────────────────────────────────────┐
│                      Agent 的核心能力                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  🧠 推理能力 (Reasoning)                                    │
│     理解用户意图，分解任务，制定计划                          │
│                                                             │
│  🔧 工具使用 (Tool Use)                                     │
│     调用外部工具：搜索、计算、API、数据库等                   │
│                                                             │
│  🔄 自主循环 (Autonomous Loop)                              │
│     思考 → 行动 → 观察 → 再思考，直到完成任务                 │
│                                                             │
│  📝 记忆能力 (Memory)                                       │
│     记住对话历史和上下文，保持连贯性                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

---

Agent vs 普通 LLM

关键区别

对比维度	普通 LLM	Agent
能力边界	只能生成文本	可以调用工具、执行操作
信息来源	仅限训练数据	可获取实时信息（搜索、API）
任务执行	一问一答，被动响应	自主规划、多步执行
决策方式	无	根据情况自主决定下一步
复杂任务	难以处理	可分解并逐步完成

实际对比示例

场景：用户问「帮我订一张明天去上海的机票」

普通 LLM 的回答

抱歉，我无法帮您订机票。您可以通过以下方式预订：
1. 访问携程、去哪儿等网站
2. 下载航空公司 App
3. 拨打航空公司客服电话
...

Agent 的行为

[思考] 用户想订机票，我需要：
  1. 确认出发地
  2. 搜索航班
  3. 选择合适的航班
  4. 完成预订

[行动 1] 调用 search_flights(from="北京", to="上海", date="明天")
[观察 1] 找到 15 个航班，最低价 ¥550

[行动 2] 调用 get_flight_details(flight_id="CA1234")
[观察 2] CA1234，08:00-10:30，¥680

[思考] 需要用户确认航班选择...

[回答] 我找到了 15 个航班，推荐以下选项：
  - CA1234，08:00-10:30，¥680
  - MU5678，10:00-12:30，¥550
  请问您想预订哪个？

---

Part 2: ReAct 模式

ReAct 模式详解

什么是 ReAct？

ReAct = Reasoning + Acting（推理 + 行动）

这是构建 Agent 最流行的范式，源自 2022 年的论文《ReAct: Synergizing Reasoning and Acting in Language Models》。

ReAct 的核心循环

┌────────────────────────────────────────────────────────────┐
│                     ReAct 循环流程                          │
├────────────────────────────────────────────────────────────┤
│                                                            │
│    ┌─────────┐                                             │
│    │ Thought │ 思考：分析当前状态，决定下一步               │
│    └────┬────┘                                             │
│         │                                                  │
│         ▼                                                  │
│    ┌─────────┐                                             │
│    │ Action  │ 行动：调用工具执行操作                       │
│    └────┬────┘                                             │
│         │                                                  │
│         ▼                                                  │
│    ┌─────────────┐                                         │
│    │ Observation │ 观察：获取工具返回的结果                  │
│    └──────┬──────┘                                         │
│           │                                                │
│           ▼                                                │
│    ┌──────────────┐                                        │
│    │   再次思考    │ 是否需要继续？                          │
│    └──────┬───────┘                                        │
│           │                                                │
│     ┌─────┴─────┐                                          │
│     │           │                                          │
│     ▼           ▼                                          │
│   继续循环    生成最终答案                                   │
│                                                            │
└────────────────────────────────────────────────────────────┘

具体示例

用户问：北京比上海冷多少度？

[Thought 1]
用户想知道温度差，我需要：
1. 查询北京天气
2. 查询上海天气
3. 计算温度差

[Action 1]
调用 get_weather(city="北京")

[Observation 1]
{"city": "北京", "temperature": "5°C", "condition": "晴天"}

[Thought 2]
已获取北京温度 5°C，现在需要查上海

[Action 2]
调用 get_weather(city="上海")

[Observation 2]
{"city": "上海", "temperature": "12°C", "condition": "多云"}

[Thought 3]
北京 5°C，上海 12°C，需要计算差值

[Action 3]
调用 calculator(expression="12 - 5")

[Observation 3]
12 - 5 = 7

[Thought 4]
计算完成，上海比北京高 7 度，可以回答了

[Final Answer]
目前北京气温 5°C，上海气温 12°C，上海比北京高 7°C。
北京今天会比较冷，出门记得多穿衣服！

为什么 ReAct 有效？

优势	说明
可解释性	每一步思考都可见，便于调试和理解
准确性	通过工具获取真实数据，避免 LLM 幻觉
灵活性	可根据中间结果动态调整策略
可扩展性	只需添加新工具即可扩展 Agent 能力

---

Part 3: Agent 核心组件

组件架构图

┌─────────────────────────────────────────────────────────────┐
│                         Agent 架构                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌───────────────────────────────────────────────────────┐  │
│  │                      🧠 LLM（大脑）                    │  │
│  │  • 理解用户意图                                        │  │
│  │  • 推理和决策                                          │  │
│  │  • 生成回答                                            │  │
│  └───────────────────────────────────────────────────────┘  │
│                             │                               │
│                             ▼                               │
│  ┌───────────────────────────────────────────────────────┐  │
│  │                    🔧 Tools（工具）                    │  │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐      │  │
│  │  │  天气   │ │  搜索   │ │  计算   │ │ 数据库  │ ...  │  │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘      │  │
│  └───────────────────────────────────────────────────────┘  │
│                             │                               │
│                             ▼                               │
│  ┌───────────────────────────────────────────────────────┐  │
│  │                    📋 State（状态）                    │  │
│  │  • messages: 对话历史                                  │  │
│  │  • 其他上下文信息                                      │  │
│  └───────────────────────────────────────────────────────┘  │
│                             │                               │
│                             ▼                               │
│  ┌───────────────────────────────────────────────────────┐  │
│  │                   🔄 Graph（流程图）                   │  │
│  │  定义节点之间的流转逻辑                                 │  │
│  └───────────────────────────────────────────────────────┘  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

1. LLM（大脑）

LLM 是 Agent 的核心，负责：

• 理解：解析用户意图
• 推理：分析问题，制定策略
• 决策：选择合适的工具
• 生成：产出最终回答

import { ChatDeepSeek } from "@langchain/deepseek";

const llm = new ChatDeepSeek({
  model: "deepseek-chat",
  temperature: 0, // 工具调用建议低温度
});

2. Tools（工具）

工具是 Agent 的"双手"，扩展 Agent 的能力边界：

import { DynamicStructuredTool } from "@langchain/core/tools";
import { z } from "zod";

// 示例：天气查询工具
const weatherTool = new DynamicStructuredTool({
  name: "get_weather",
  description: "获取城市天气信息。当用户询问天气时使用。",
  schema: z.object({
    city: z.string().describe("城市名称"),
  }),
  func: async ({ city }) => {
    // 调用天气 API
    return JSON.stringify({ city, temp: "15°C", condition: "晴天" });
  },
});

3. State（状态）

状态保存 Agent 的"记忆"：

import { Annotation } from "@langchain/langgraph";

const AgentState = Annotation.Root({
  messages: Annotation({
    reducer: (prev, next) => [...prev, ...next], // 累加消息
    default: () => [],
  }),
});

消息类型：

类型	说明
HumanMessage	用户发送的消息
AIMessage	AI 的回复（可能包含 tool_calls）
ToolMessage	工具执行的结果
SystemMessage	系统指令

4. Graph（流程图）

使用 LangGraph 定义 Agent 的执行流程：

import { StateGraph, START, END } from "@langchain/langgraph";

const graph = new StateGraph(AgentState)
  .addNode("agent", agentNode) // 思考节点
  .addNode("tools", toolNode) // 工具节点
  .addEdge(START, "agent")
  .addConditionalEdges("agent", shouldCallTools, {
    tools: "tools",
    end: END,
  })
  .addEdge("tools", "agent"); // 关键：循环！

---

Part 4: 构建 Agent

环境准备

# 安装依赖
npm install @langchain/langgraph @langchain/core @langchain/deepseek zod dotenv

// .env 文件
DEEPSEEK_API_KEY = your_api_key;

完整代码示例

/**
 * 使用 LangGraph 构建 ReAct Agent
 */
import { StateGraph, Annotation, START, END } from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { ChatDeepSeek } from "@langchain/deepseek";
import { DynamicStructuredTool } from "@langchain/core/tools";
import { HumanMessage } from "@langchain/core/messages";
import { z } from "zod";
import "dotenv/config";

// 1. 定义工具
const tools = [
  new DynamicStructuredTool({
    name: "get_weather",
    description: "获取城市天气",
    schema: z.object({ city: z.string() }),
    func: async ({ city }) => {
      const data = { 北京: "15°C 晴", 上海: "20°C 多云" };
      return data[city] || "22°C 晴天";
    },
  }),
  new DynamicStructuredTool({
    name: "calculator",
    description: "数学计算",
    schema: z.object({ expression: z.string() }),
    func: async ({ expression }) => {
      return String(Function(`"use strict"; return (${expression})`)());
    },
  }),
];

// 2. 初始化 LLM 并绑定工具
const llm = new ChatDeepSeek({ model: "deepseek-chat", temperature: 0 });
const llmWithTools = llm.bindTools(tools);

// 3. 定义状态
const AgentState = Annotation.Root({
  messages: Annotation({
    reducer: (prev, next) => [...prev, ...next],
    default: () => [],
  }),
});

// 4. 定义节点
async function agentNode(state) {
  const response = await llmWithTools.invoke(state.messages);
  return { messages: [response] };
}

const toolNode = new ToolNode(tools);

// 5. 定义路由
function shouldCallTools(state) {
  const last = state.messages[state.messages.length - 1];
  return last.tool_calls?.length > 0 ? "tools" : "end";
}

// 6. 构建图
const graph = new StateGraph(AgentState)
  .addNode("agent", agentNode)
  .addNode("tools", toolNode)
  .addEdge(START, "agent")
  .addConditionalEdges("agent", shouldCallTools, {
    tools: "tools",
    end: END,
  })
  .addEdge("tools", "agent");

// 7. 编译并使用
const agent = graph.compile();

const result = await agent.invoke({
  messages: [new HumanMessage("北京天气怎么样？")],
});

console.log(result.messages[result.messages.length - 1].content);

代码解析

步骤 1-2：定义工具并绑定

// 创建工具
const tools = [weatherTool, calculatorTool];

// 绑定到 LLM（关键！）
const llmWithTools = llm.bindTools(tools);

bindTools() 告诉 LLM 有哪些工具可用，LLM 会：

• 在需要时返回 tool_calls
• 包含工具名称和参数

步骤 3：定义状态

const AgentState = Annotation.Root({
  messages: Annotation({
    reducer: (prev, next) => [...prev, ...next], // 累加！
    default: () => [],
  }),
});

为什么用累加模式？

• 对话需要保留历史
• LLM 需要完整上下文
• 工具结果需要追加

步骤 4：定义节点

// Agent 节点：调用 LLM 做决策
async function agentNode(state) {
  const response = await llmWithTools.invoke(state.messages);
  return { messages: [response] };
}

// Tool 节点：执行工具（使用内置 ToolNode）
const toolNode = new ToolNode(tools);

ToolNode 自动处理：

1. 解析 tool_calls
2. 执行对应工具
3. 包装结果为 ToolMessage

步骤 5：定义路由

function shouldCallTools(state) {
  const last = state.messages[state.messages.length - 1];
  // 有 tool_calls → 去执行工具
  // 没有 → 结束
  return last.tool_calls?.length > 0 ? "tools" : "end";
}

步骤 6：构建图

const graph = new StateGraph(AgentState)
  .addNode("agent", agentNode)
  .addNode("tools", toolNode)
  .addEdge(START, "agent") // 入口
  .addConditionalEdges("agent", shouldCallTools, {
    tools: "tools",
    end: END,
  })
  .addEdge("tools", "agent"); // 循环回 agent！

关键：tools → agent 形成循环！

这让 Agent 可以多次调用工具，直到完成任务。

---

Agent 的工作流程

流程图

                    用户输入
                       │
                       ▼
              ┌────────────────┐
              │   START        │
              └───────┬────────┘
                      │
                      ▼
              ┌────────────────┐
              │   Agent 节点   │◄──────────────┐
              │   (LLM 思考)   │               │
              └───────┬────────┘               │
                      │                        │
                      ▼                        │
              ┌────────────────┐               │
              │   路由判断      │               │
              │ 有 tool_calls? │               │
              └───────┬────────┘               │
                      │                        │
           ┌──────────┴──────────┐             │
           │ Yes                 │ No          │
           ▼                     ▼             │
    ┌────────────┐        ┌────────────┐       │
    │ Tools 节点 │        │    END     │       │
    │ (执行工具) │         │  输出结果   │       │
    └─────┬──────┘        └────────────┘       │
          │                                    │
          └────────────────────────────────────┘
                   工具结果返回

消息流转示例

以「北京天气怎么样？」为例：

// 初始状态
messages: [
  HumanMessage("北京天气怎么样？")
]

// Agent 节点执行后
messages: [
  HumanMessage("北京天气怎么样？"),
  AIMessage({
    content: "",
    tool_calls: [{ name: "get_weather", args: { city: "北京" } }]
  })
]

// Tools 节点执行后
messages: [
  HumanMessage("北京天气怎么样？"),
  AIMessage({ tool_calls: [...] }),
  ToolMessage({ content: '{"city":"北京","temp":"15°C"}' })
]

// Agent 节点再次执行后（最终）
messages: [
  HumanMessage("北京天气怎么样？"),
  AIMessage({ tool_calls: [...] }),
  ToolMessage({ content: '...' }),
  AIMessage({ content: "北京今天天气晴朗，气温15°C，适合出行！" })
]

---

Part 5: 记忆功能

为什么需要记忆

没有记忆的问题

// ❌ 没有记忆的对话（每次都是全新的）

// 第一次对话
await app.invoke({ messages: [new HumanMessage("我叫小明")] });
// AI: "你好小明！"

// 第二次对话（AI 完全不记得！）
await app.invoke({ messages: [new HumanMessage("我叫什么名字？")] });
// AI: "抱歉，我不知道你的名字，你还没告诉我呢"  ← 尴尬！

有记忆后的效果

// ✅ 有记忆的对话（连贯自然）

// 第一次对话
await app.invoke(
  { messages: [new HumanMessage("我叫小明")] },
  { configurable: { thread_id: "user_001" } }
);
// AI: "你好小明！"

// 第二次对话（同一个 thread_id，AI 记得！）
await app.invoke(
  { messages: [new HumanMessage("我叫什么名字？")] },
  { configurable: { thread_id: "user_001" } }
);
// AI: "你叫小明呀！"  ← 完美！

记忆功能的应用场景

场景	描述	为什么需要记忆
客服机器人	处理用户问题	记住用户身份、之前的问题、处理进度
个人助理	日程管理、任务跟踪	记住用户偏好、待办事项、上下文
教育辅导	一对一教学	记住学习进度、薄弱点、学习风格
游戏 NPC	交互式对话	记住剧情进展、玩家选择、关系状态
心理咨询	陪伴对话	记住用户情况、历史对话、情绪变化

---

MemorySaver 详解

什么是 MemorySaver

MemorySaver = 让 AI 记住对话历史的工具

想象一下，你和朋友聊天：

• ❌ 没有 MemorySaver：每句话 AI 都当作新对话，完全不记得之前说了什么
• ✅ 有 MemorySaver：AI 能记住你说过的每一句话，像真人一样连贯对话

形象比喻

┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│   📝 MemorySaver 就像一本「对话日记」                             │
│                                                                 │
│   ┌───────────────────────────────────────────────────────┐    │
│   │  对话日记 (thread_id: "user_001")                      │    │
│   │  ─────────────────────────────────────────────────    │    │
│   │  [轮次 1] 用户: 你好，我叫小明                          │    │
│   │          AI:   你好小明！有什么可以帮你的？              │    │
│   │  ─────────────────────────────────────────────────    │    │
│   │  [轮次 2] 用户: 我喜欢编程                              │    │
│   │          AI:   编程很棒！小明，你主要用什么语言呢？       │    │
│   │  ─────────────────────────────────────────────────    │    │
│   │  [轮次 3] 用户: 我叫什么名字？                          │    │
│   │          AI:   你叫小明呀！（因为我记得！）              │    │
│   └───────────────────────────────────────────────────────┘    │
│                                                                 │
│   📌 关键点：AI 能回忆起之前说的"小明"和"喜欢编程"              │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

核心概念

🔹 Checkpointer（检查点器）

通俗解释：就像游戏里的「存档功能」

• 游戏存档：保存游戏进度，下次可以继续玩
• Checkpointer：保存对话状态，下次可以继续聊

游戏存档                          LangGraph Checkpointer
─────────                        ─────────────────────
存档位置: 第3关Boss前              存档位置: 第5轮对话后
角色等级: 50级                     消息历史: [msg1, msg2, ...]
背包物品: [剑, 盾, 药水]           状态数据: { topic: "编程", ... }

🔹 MemorySaver

通俗解释：将存档保存在「内存」里的存档器

• 优点：速度快、使用简单
• 缺点：程序关闭后存档丢失（就像没有插记忆卡的游戏机）

import { MemorySaver } from "@langchain/langgraph";

const memory = new MemorySaver(); // 创建一个"内存存档器"

基本使用步骤

import { StateGraph, Annotation, START, END } from "@langchain/langgraph";
import { MemorySaver } from "@langchain/langgraph"; // 1️⃣ 导入

// 2️⃣ 创建 MemorySaver 实例
const memory = new MemorySaver();

// 3️⃣ 定义状态
const ChatState = Annotation.Root({
  messages: Annotation({
    reducer: (prev, next) => [...prev, ...next],
    default: () => [],
  }),
});

// 4️⃣ 构建图
const graph = new StateGraph(ChatState)
  .addNode("chat", chatNode)
  .addEdge(START, "chat")
  .addEdge("chat", END);

// 5️⃣ 编译时传入 checkpointer
const app = graph.compile({
  checkpointer: memory, // 关键！添加记忆功能
});

// 6️⃣ 调用时指定 thread_id
const result = await app.invoke(
  { messages: [new HumanMessage("你好")] },
  { configurable: { thread_id: "my_thread_123" } } // 关键！指定对话线程
);

💡 关键理解 ：compile() 不传 checkpointer 时，应用没有记忆功能；传了才有！

---

thread_id 线程标识

什么是 thread_id

thread_id 是对话的「身份证号」，用来区分不同的对话。

┌─────────────────────────────────────────────────────────────────┐
│                    thread_id 的作用                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   想象一个客服系统，同时服务多个用户：                              │
│                                                                 │
│   用户 A (thread_id: "user_a_session")                          │
│   ├── "我要退货" → AI记住                                        │
│   └── "订单号是123" → AI关联到退货请求                            │
│                                                                 │
│   用户 B (thread_id: "user_b_session")                          │
│   ├── "推荐一款手机" → AI记住                                     │
│   └── "预算3000" → AI结合推荐需求                                 │
│                                                                 │
│   两个用户的对话完全独立，互不干扰！                               │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

thread_id 的命名建议

// ✅ 好的 thread_id 命名
{
  thread_id: "user_12345";
} // 用户ID
{
  thread_id: "session_abc123";
} // 会话ID
{
  thread_id: "user_12345_chat_1";
} // 用户ID + 对话序号
{
  thread_id: "order_inquiry_67890";
} // 业务类型 + ID

// ❌ 不好的 thread_id 命名
{
  thread_id: "1";
} // 太简单，容易冲突
{
  thread_id: "test";
} // 不具体
{
  thread_id: "";
} // 空字符串

多用户场景示例

const memory = new MemorySaver();
const app = graph.compile({ checkpointer: memory });

// 用户 A 的对话
async function chatWithUserA() {
  const config = { configurable: { thread_id: "user_a" } };

  await app.invoke({ messages: [new HumanMessage("我是用户A")] }, config);
  await app.invoke({ messages: [new HumanMessage("我喜欢Python")] }, config);

  // 用户 A 的对话历史只包含用户 A 说的话
}

// 用户 B 的对话
async function chatWithUserB() {
  const config = { configurable: { thread_id: "user_b" } };

  await app.invoke({ messages: [new HumanMessage("我是用户B")] }, config);
  await app.invoke({ messages: [new HumanMessage("我喜欢Java")] }, config);

  // 用户 B 的对话历史只包含用户 B 说的话
}

// 两个用户的对话互不影响
await chatWithUserA();
await chatWithUserB();

---

Part 6: 实战案例

案例 1：多轮对话机器人

需求分析

构建一个能够：

1. 记住用户名字
2. 记住对话历史
3. 基于上下文回答问题

完整代码

import { StateGraph, Annotation, START, END } from "@langchain/langgraph";
import { MemorySaver } from "@langchain/langgraph";
import { ChatDeepSeek } from "@langchain/deepseek";
import {
  HumanMessage,
  AIMessage,
  SystemMessage,
} from "@langchain/core/messages";
import "dotenv/config";

// 1. 创建组件
const memory = new MemorySaver();
const llm = new ChatDeepSeek({ model: "deepseek-chat", temperature: 0.7 });

// 2. 定义状态
const ChatbotState = Annotation.Root({
  messages: Annotation({
    reducer: (prev, next) => [...prev, ...next],
    default: () => [],
  }),
});

// 3. 定义聊天节点
async function chatNode(state) {
  // 添加系统提示（让 AI 知道要记住上下文）
  const systemPrompt = new SystemMessage(
    "你是一个友好的助手。请记住用户在对话中提到的信息（如名字、偏好等），" +
      "并在后续对话中自然地使用这些信息。保持对话连贯性。"
  );

  // 组合消息：系统提示 + 历史消息
  const messagesWithSystem = [systemPrompt, ...state.messages];

  const response = await llm.invoke(messagesWithSystem);
  return { messages: [response] };
}

// 4. 构建图
const chatbot = new StateGraph(ChatbotState)
  .addNode("chat", chatNode)
  .addEdge(START, "chat")
  .addEdge("chat", END)
  .compile({ checkpointer: memory });

// 5. 对话函数
async function chat(threadId, userMessage) {
  const config = { configurable: { thread_id: threadId } };

  const result = await chatbot.invoke(
    { messages: [new HumanMessage(userMessage)] },
    config
  );

  // 获取最后一条 AI 回复
  const aiResponse = result.messages[result.messages.length - 1];
  return aiResponse.content;
}

// 6. 测试多轮对话
async function main() {
  const threadId = "demo_conversation";

  console.log("🤖 开始多轮对话演示\n");
  console.log("=".repeat(50));

  // 第一轮
  console.log("👤 用户: 你好，我叫小明");
  let response = await chat(threadId, "你好，我叫小明");
  console.log(`🤖 AI: ${response}\n`);

  // 第二轮
  console.log("👤 用户: 我喜欢编程，特别是 JavaScript");
  response = await chat(threadId, "我喜欢编程，特别是 JavaScript");
  console.log(`🤖 AI: ${response}\n`);

  // 第三轮（测试记忆）
  console.log("👤 用户: 我叫什么名字？我喜欢什么？");
  response = await chat(threadId, "我叫什么名字？我喜欢什么？");
  console.log(`🤖 AI: ${response}\n`);

  console.log("=".repeat(50));
  console.log("✅ 演示完成！AI 成功记住了用户信息！");
}

main();

执行效果

🤖 开始多轮对话演示

==================================================
👤 用户: 你好，我叫小明
🤖 AI: 你好小明！很高兴认识你，有什么可以帮你的吗？

👤 用户: 我喜欢编程，特别是 JavaScript
🤖 AI: 太棒了小明！JavaScript 是个很好的选择，
      你是做前端开发还是全栈开发呢？

👤 用户: 我叫什么名字？我喜欢什么？
🤖 AI: 你叫小明，你喜欢编程，特别是 JavaScript！

==================================================
✅ 演示完成！AI 成功记住了用户信息！

---

案例 2：带记忆的 Agent

需求分析

构建一个能够：

1. 记住对话历史
2. 使用工具（计算器、天气查询）
3. 多轮交互完成复杂任务

核心代码结构

import { StateGraph, Annotation, START, END } from "@langchain/langgraph";
import { MemorySaver } from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { ChatDeepSeek } from "@langchain/deepseek";
import { DynamicStructuredTool } from "@langchain/core/tools";
import { HumanMessage } from "@langchain/core/messages";
import { z } from "zod";
import "dotenv/config";

// 1. 创建记忆存储
const memory = new MemorySaver();

// 2. 定义工具
const tools = [
  new DynamicStructuredTool({
    name: "calculator",
    description: "数学计算",
    schema: z.object({ expression: z.string() }),
    func: async ({ expression }) => {
      return String(eval(expression)); // 注意：生产环境需要安全处理
    },
  }),
  // ... 其他工具
];

// 3. 绑定工具到 LLM
const llm = new ChatDeepSeek({ model: "deepseek-chat", temperature: 0 });
const llmWithTools = llm.bindTools(tools);

// 4. 定义状态
const AgentState = Annotation.Root({
  messages: Annotation({
    reducer: (prev, next) => [...prev, ...next],
    default: () => [],
  }),
});

// 5. 定义节点
async function agentNode(state) {
  const response = await llmWithTools.invoke(state.messages);
  return { messages: [response] };
}

const toolNode = new ToolNode(tools);

// 6. 路由函数
function shouldCallTools(state) {
  const lastMessage = state.messages[state.messages.length - 1];
  return lastMessage.tool_calls?.length > 0 ? "tools" : "end";
}

// 7. 构建图并添加记忆
const agent = new StateGraph(AgentState)
  .addNode("agent", agentNode)
  .addNode("tools", toolNode)
  .addEdge(START, "agent")
  .addConditionalEdges("agent", shouldCallTools, {
    tools: "tools",
    end: END,
  })
  .addEdge("tools", "agent")
  .compile({ checkpointer: memory }); // 关键：添加记忆！

// 8. 使用
const config = { configurable: { thread_id: "agent_session_1" } };

// 第一轮：计算
await agent.invoke(
  { messages: [new HumanMessage("帮我计算 100 * 5")] },
  config
);

// 第二轮：基于上下文继续（记得上次算了 500）
await agent.invoke({ messages: [new HumanMessage("再乘以 2")] }, config);

记忆在 Agent 中的作用

┌─────────────────────────────────────────────────────────────────┐
│                 带记忆的 Agent 执行流程                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  第一轮对话 (thread_id: "session_1")                            │
│  ──────────────────────────────────────                         │
│  用户: "帮我计算 100 * 5"                                        │
│    ↓                                                            │
│  Agent 决定调用 calculator                                       │
│    ↓                                                            │
│  Tool 返回: "500"                                                │
│    ↓                                                            │
│  AI 回复: "100 × 5 = 500"                                        │
│    ↓                                                            │
│  💾 保存到 memory（包含完整对话）                                 │
│                                                                 │
│  第二轮对话 (同一个 thread_id)                                    │
│  ──────────────────────────────────────                         │
│  用户: "再乘以 2"                                                 │
│    ↓                                                            │
│  📖 从 memory 读取历史（知道上次算了 500）                        │
│    ↓                                                            │
│  Agent 理解上下文，调用 calculator("500 * 2")                    │
│    ↓                                                            │
│  AI 回复: "500 × 2 = 1000"                                       │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

---

案例 3：智能客服 Agent

场景

电商客服，能查询订单、处理退款

// 订单查询工具
const orderTool = new DynamicStructuredTool({
  name: "query_order",
  description: "查询订单状态",
  schema: z.object({
    order_id: z.string().describe("订单号"),
  }),
  func: async ({ order_id }) => {
    // 调用订单系统
    return JSON.stringify({
      order_id,
      status: "已发货",
      shipping: "顺丰快递",
      expected: "明天送达",
    });
  },
});

// 退款申请工具
const refundTool = new DynamicStructuredTool({
  name: "request_refund",
  description: "申请退款",
  schema: z.object({
    order_id: z.string(),
    reason: z.string(),
  }),
  func: async ({ order_id, reason }) => {
    // 调用退款系统
    return JSON.stringify({
      refund_id: "RF" + Date.now(),
      status: "审核中",
      message: "退款申请已提交，预计1-3个工作日处理",
    });
  },
});

// 构建客服 Agent
const customerServiceAgent = new StateGraph(AgentState)
  .addNode("agent", agentNode)
  .addNode("tools", new ToolNode([orderTool, refundTool]))
  // ... 其他配置
  .compile({ checkpointer: memory });

对话示例

用户：我的订单 12345 什么时候到？

Agent:
[思考] 用户查询订单状态，需要调用订单查询工具
[行动] query_order(order_id="12345")
[观察] {"status":"已发货","shipping":"顺丰","expected":"明天送达"}
[回答] 您的订单 12345 已经发货啦！由顺丰快递配送，预计明天送达。
       请保持手机畅通，快递小哥会提前联系您~

---

Part 7: 最佳实践

✅ 1. 工具设计原则

// ✅ 好的工具设计
const goodTool = {
  // 名称：简洁、描述性
  name: "search_products",

  // 描述：详细、包含使用场景
  description:
    "搜索商品信息。" +
    "当用户询问商品价格、库存、规格时使用。" +
    "返回商品名称、价格、库存数量。",

  // 参数：每个都有清晰的 describe
  schema: z.object({
    keyword: z.string().describe("搜索关键词，如商品名称"),
    category: z.string().optional().describe("商品类别，如'电子产品'"),
    max_results: z.number().optional().describe("最大返回数量，默认10"),
  }),

  // 返回：结构化 JSON
  func: async (params) => {
    const results = await searchProducts(params);
    return JSON.stringify(results);
  },
};

✅ 2. 控制 Agent 行为

// 使用 SystemMessage 设定 Agent 人设和行为规范
const messages = [
  new SystemMessage(`
你是一个专业的客服助手。

规则：
1. 始终保持礼貌和专业
2. 如果不确定，请使用搜索工具查询
3. 涉及退款等敏感操作，先确认用户身份
4. 如果问题超出能力范围，建议转人工客服
  `),
  new HumanMessage(userQuestion),
];

✅ 3. 限制和兜底

// 设置合理的限制
const agent = graph.compile({
  checkpointer: memory,
  recursionLimit: 15, // 最大循环次数
});

// 超时处理
const result = await Promise.race([
  agent.invoke(input),
  new Promise((_, reject) =>
    setTimeout(() => reject(new Error("超时")), 30000)
  ),
]);

✅ 4. 消息状态使用累加 reducer

// ✅ 正确：使用累加 reducer
messages: Annotation({
  reducer: (prev, next) => [...prev, ...next],  // 累加
  default: () => [],
}),

// ❌ 错误：使用替换 reducer（会丢失历史）
messages: Annotation({
  reducer: (prev, next) => next,  // 替换
  default: () => [],
}),

✅ 5. 限制消息历史长度

// 当消息过多时，可能超出 LLM 上下文限制
// 解决方案：在节点中裁剪历史
async function chatNode(state) {
  // 只保留最近 20 条消息
  const recentMessages = state.messages.slice(-20);

  const response = await llm.invoke(recentMessages);
  return { messages: [response] };
}

✅ 6. 日志和监控

// 记录 Agent 的每一步操作
async function agentNodeWithLogging(state) {
  const startTime = Date.now();

  console.log(`[${new Date().toISOString()}] Agent 开始思考`);
  console.log(`输入消息数: ${state.messages.length}`);

  const response = await llmWithTools.invoke(state.messages);

  console.log(`耗时: ${Date.now() - startTime}ms`);
  console.log(`是否调用工具: ${response.tool_calls?.length > 0}`);

  return { messages: [response] };
}

---

Part 8: 常见问题 FAQ

Q1: Agent 陷入死循环怎么办？

问题：Agent 不断调用工具，无法停止

解决方案：

// 方法 1：限制最大迭代次数
const agent = graph.compile({
  recursionLimit: 10, // 最多 10 次循环
});

// 方法 2：在路由函数中检查
function shouldCallTools(state) {
  if (state.messages.length > 20) {
    console.log("警告：达到最大消息数，强制结束");
    return "end";
  }
  // ... 正常逻辑
}

Q2: Agent 选错了工具怎么办？

问题：Agent 调用了不相关的工具

解决方案：

// 1. 优化工具描述
const weatherTool = {
  name: "get_weather",
  // ❌ 不好的描述
  description: "查询天气",

  // ✅ 好的描述
  description:
    "获取指定城市的天气信息，包括温度、天气状况、风力等。" +
    "当用户询问天气、温度、是否下雨、是否需要带伞时使用此工具。",
};

// 2. 使用 SystemMessage 给 Agent 明确指令
const messages = [
  new SystemMessage(
    "你是一个智能助手。请仔细分析用户问题，选择最合适的工具。" +
      "如果问题不需要工具，直接回答即可。"
  ),
  new HumanMessage("用户问题..."),
];

Q3: 如何调试 Agent？

// 1. 在节点中添加日志
async function agentNode(state) {
  console.log("=== Agent 节点 ===");
  console.log("当前消息数:", state.messages.length);
  console.log("最后一条消息:", state.messages.slice(-1));

  const response = await llmWithTools.invoke(state.messages);

  console.log("LLM 返回:", response);
  console.log("tool_calls:", response.tool_calls);

  return { messages: [response] };
}

// 2. 使用 LangGraph 的流式输出查看中间状态
const stream = await agent.stream({
  messages: [new HumanMessage("问题")],
});

for await (const chunk of stream) {
  console.log("Chunk:", JSON.stringify(chunk, null, 2));
}

Q4: 为什么 AI 没有记住我说的话？

可能原因：

1. 没有添加 checkpointer

// ❌ 忘记添加 checkpointer
const app = graph.compile();

// ✅ 正确
const app = graph.compile({ checkpointer: memory });

2. thread_id 不一致

// ❌ 每次用不同的 thread_id
await app.invoke(input, { configurable: { thread_id: "thread_1" } });
await app.invoke(input, { configurable: { thread_id: "thread_2" } }); // 新线程！

// ✅ 使用相同的 thread_id
const threadId = "my_conversation";
await app.invoke(input, { configurable: { thread_id: threadId } });
await app.invoke(input, { configurable: { thread_id: threadId } });

3. 消息 reducer 设置错误

// ❌ 使用替换 reducer
reducer: (prev, next) => next; // 每次都替换，丢失历史

// ✅ 使用累加 reducer
reducer: (prev, next) => [...prev, ...next]; // 保留历史

Q5: 程序重启后记忆丢失了？

解答：MemorySaver 存储在内存中，程序结束后数据就没了。如需持久化，请使用 SqliteSaver 或其他持久化 Checkpointer。

常见 Checkpointer 对比

类型	存储位置	持久化	适用场景
MemorySaver	内存	❌	开发测试
SqliteSaver	SQLite 文件	✅	本地应用
PostgresSaver	PostgreSQL	✅	生产环境
RedisSaver	Redis	✅	高性能场景
MongoSaver	MongoDB	✅	文档型存储

Q6: 多个用户会共享记忆吗？

不会，只要使用不同的 thread_id，每个用户的对话是完全隔离的。

// 用户 A 和用户 B 使用不同的 thread_id
const userAConfig = { configurable: { thread_id: "user_a" } };
const userBConfig = { configurable: { thread_id: "user_b" } };
// 两者的对话历史互不影响

---

Part 9: 进阶主题

1. 多 Agent 协作

// 主 Agent 调度多个子 Agent
const researchAgent = buildResearchAgent();
const writerAgent = buildWriterAgent();
const reviewerAgent = buildReviewerAgent();

// 工作流：研究 → 写作 → 审核
const workflow = new StateGraph(State)
  .addNode("research", researchAgent)
  .addNode("write", writerAgent)
  .addNode("review", reviewerAgent)
  .addEdge(START, "research")
  .addEdge("research", "write")
  .addEdge("write", "review")
  .addEdge("review", END);

2. 人工介入（Human-in-the-Loop）

// 在关键步骤等待人工确认
const graph = new StateGraph(AgentState)
  .addNode("agent", agentNode)
  .addNode("tools", toolNode)
  .addNode("human_review", async (state) => {
    // 等待人工确认
    console.log("请确认是否执行以下操作...");
    // 实际应用中，这里会等待用户输入
    return { messages: [new HumanMessage("已确认")] };
  })
  .addConditionalEdges(
    "agent",
    (state) => {
      // 敏感操作需要人工确认
      const last = state.messages.slice(-1)[0];
      if (isSensitiveOperation(last.tool_calls)) {
        return "human_review";
      }
      return "tools";
    },
    {
      human_review: "human_review",
      tools: "tools",
      end: END,
    }
  );

3. 错误恢复

// 工具失败时的处理
async function toolNodeWithRetry(state) {
  const toolNode = new ToolNode(tools);

  try {
    return await toolNode.invoke(state);
  } catch (error) {
    console.log("工具调用失败，尝试重试...");

    // 返回错误信息给 Agent，让它决定下一步
    return {
      messages: [
        new ToolMessage({
          content: `工具调用失败: ${error.message}。请尝试其他方法。`,
          tool_call_id: state.messages.slice(-1)[0].tool_calls[0].id,
        }),
      ],
    };
  }
}

4. 并行工具调用

// LangGraph 的 ToolNode 自动支持并行调用
// 当 AI 返回多个 tool_calls 时，会并行执行

// AI 返回：
{
  tool_calls: [
    { name: "get_weather", args: { city: "北京" } },
    { name: "get_weather", args: { city: "上海" } },
    { name: "get_time", args: {} },
  ];
}

// ToolNode 会并行执行这 3 个工具调用

5. 状态查看与调试

// 使用 getState 方法查看当前状态
const state = await app.getState({ configurable: { thread_id: "my_thread" } });

console.log("当前状态:", state.values);
console.log("消息数量:", state.values.messages.length);

// 获取所有历史状态（检查点）
const history = app.getStateHistory({
  configurable: { thread_id: "my_thread" },
});

for await (const checkpoint of history) {
  console.log("时间:", checkpoint.createdAt);
  console.log("消息数:", checkpoint.values.messages.length);
  console.log("---");
}

---

总结

🎯 核心要点

1. LangChain vs LangGraph

   • LangChain 提供基础组件（LLM、Tools、Prompt）
   • LangGraph 提供编排能力（循环、分支、状态管理）
   • 构建复杂 Agent 推荐使用 LangGraph

2. Agent = LLM + Tools + 自主决策

   • LLM 负责思考和推理
   • Tools 提供执行能力
   • 循环机制实现自主决策

3. ReAct 模式是 Agent 的核心

   • Thought → Action → Observation → Thought...
   • 循环直到完成任务

4. MemorySaver 让 Agent 拥有记忆

   • checkpointer 保存对话状态
   • thread_id 区分不同对话
   • 消息使用累加 reducer

5. 工具设计决定 Agent 能力

   • 清晰的描述
   • 合理的参数
   • 稳定的返回格式

💡 记住这句话

Agent 的强大不在于它有多聪明，而在于它能用工具做多少事。

工具越丰富、越可靠，Agent 的能力就越强。

---

学习路径建议

📁 配套实战文件

🔗 仓库地址：github.com/Lidh1023/no...

文件	内容	预计用时	GitHub 链接
src/agent.js	Agent 入门 Demo	30 分钟	📄 查看代码
src/langgraph/06-react-agent.js	ReAct Agent 详解	30 分钟	📄 查看代码
src/langgraph/07-memory-basic.js	MemorySaver 基础	20 分钟	📄 查看代码
src/langgraph/08-memory-chatbot.js	多轮对话机器人	30 分钟	📄 查看代码
src/langgraph/09-memory-agent.js	带记忆的 Agent	30 分钟	📄 查看代码
src/tools-demo.js	Tools 使用详解	20 分钟	📄 查看代码

🎯 学习路线

阶段 1：理解概念（1 小时）

1. ✅ 阅读本文档，理解 Agent、ReAct、MemorySaver 的概念
2. ✅ 运行 src/agent.js，观察 Agent 的工作过程
3. ✅ 尝试修改问题，观察 Agent 的不同行为

阶段 2：动手实践（2 小时）

1. 🔥 添加新的工具（如翻译、数据库查询）
2. 🔥 实现一个特定场景的 Agent（如客服、助手）
3. 🔥 尝试处理复杂的多步骤任务

阶段 3：进阶掌握（3+ 小时）

1. 💎 学习 MemorySaver 实现对话记忆
2. 💎 实现人工介入的审核流程
3. 💎 探索多 Agent 协作

---

参考资源

官方文档

• LangGraph 官方文档 : langchain-ai.github.io/langgraphjs...
• LangChain Tools 文档 : js.langchain.com/docs/concep...
• ReAct 论文 : arxiv.org/abs/2210.03...

相关文章

• 《ReAct: Synergizing Reasoning and Acting in Language Models》
• 《Tool Learning with Foundation Models》

---

作者寄语

Agent 是 AI 应用的未来。理解了 Agent，你就掌握了让 AI "做事"而不仅仅是"说话"的能力。

从简单的 ReAct Agent 开始，逐步探索更复杂的场景。记住：

• 先理解原理，再堆功能
• 从简单场景开始，逐步增加复杂度
• 多调试、多观察 Agent 的行为

如果你完成了本教程的所有练习，恭喜你！你已经具备了构建生产级 AI Agent 的基础能力。

Happy Coding! 🚀

---

💡 学习建议: 先理解 LangChain 和 LangGraph 的关系，再从简单的 Agent 开始，逐步添加记忆功能。每一步都观察 AI 是如何"思考"和"行动"的！