从 Agent 开始

1. 先从一个最小场景开始

假设你想让 AI 帮你做一件事：查一下团队本周的代码提交记录，然后按约定格式写一份简报。

如果只是单次调用模型，它大概率会"编造"几行看起来像提交记录的内容，格式也大概率和你团队的习惯对不上。不是模型不够强，而是它缺少三样东西：

获取真实数据的通道（工具）。
知道你们团队格式和术语的上下文（记忆与规则）。
把任务拆成"查数据 → 组织内容 → 按格式输出"的执行流程（编排）。

Agent 要解决的，正是把这三样东西补上的问题。它不再是一次性生成答案的函数，而是一个能接收输入、整理上下文、决定行动、调用工具、输出结果的独立个体。

一句话理解：Agent 不是让模型"凭空说对"，而是让它在一个有资料、有工具、有状态、有约束的环境里"按步骤做对"。

2. 什么是一个 Agent

在 LangChain 的视角里，Agent 是一个独立个体。它有自己的大脑（模型）、记忆（上下文）、工具、设定和行为方式。最简单的 Agent 只需要模型和调用方式：

typescript

import { createAgent } from "langchain";

const agent = createAgent({
  model: "openai:gpt-4.1-mini",
  tools: [],
});

真实项目里通常会显式定义模型对象，并配置参数：

typescript

import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  model: "gpt-4.1-mini",
  temperature: 0.1,
  maxTokens: 1000,
  timeout: 30,
});

const agent = createAgent({
  model,
  tools: [],
});

当需要让 Agent 具备外部能力时，再给它挂载工具：

typescript

import * as z from "zod";
import { tool } from "langchain";

const search = tool(
  ({ query }) => `Results for: ${query}`,
  {
    name: "search",
    description: "Search for information",
    schema: z.object({
      query: z.string().describe("The query to search for"),
    }),
  },
);

const agent = createAgent({
  model,
  tools: [search],
  systemPrompt: "你是一个乐于助人的助手。",
});

调用时，只需要把任务交给它：

typescript

const result = await agent.invoke("告诉我今天天气怎么样");
console.log(result);

从 Agent 出发，可以把它所处的技术栈拆成三个层次：

这个个体由哪些基础接口构成 -> @langchain/core
这个个体怎样被真正组装出来并开始行动 -> LangChain
当这个个体进入更大的系统后，怎样与其他步骤或其他 Agent 协作 -> LangGraph

下面按这条路径逐个展开。

3. 一个 Agent 内部需要哪些能力

先不谈框架，单纯从"一个个体怎样行动"来看，Agent 内部至少有五个部分。

层次	解决的问题	示例
输入	接收外部信息	用户消息、上游系统通知、其他 Agent 的调用
上下文	理解当前处境	身份、目标、对话历史、可用工具
思考材料	组织能被模型读取的内容	System Prompt、检索结果、工具说明、历史对话
行动	调用模型或工具	继续推理、查数据、写数据、请求外部系统
输出	返回可消费的结果	回复文本、工具调用请求、结构化数据、下游节点数据

同一句输入，在不同上下文里含义完全不同。Agent 不是拿到一句话就直接生成回复，而是要先整理好自己的身份、目标和可用工具。然后，它真正使用的不是原始业务代码，而是被整理过的思考材料：System Prompt、用户输入、检索结果、工具说明和历史对话。这些材料怎么拼，决定了 Agent 最终怎样行动。

到了行动层，Agent 才从"会生成文字"变成"能完成任务"：它可以调模型继续推理，可以调工具查数据、写数据，也可以请求别的系统执行任务。最终输出也不一定是自然语言，可能是工具调用请求、结构化结果，或交给下游节点继续处理的数据。

所以 Agent 更像一个有输入、有状态、有动作、有输出的个体，而不是单一的问答函数。

4. @langchain/core：定义这个个体的基础接口

@langchain/core 是基础抽象层。它并不直接替你实现完整业务，而是先把最基础的零件统一起来。可以把它理解成 Agent 个体的"器官和接口标准"。

4.1 消息类型：定义 Agent 怎样接收信息

如果每家模型、每段链路、每个工具都用不同的数据结构，整个系统会非常混乱。@langchain/core 先定义了统一的消息协议：

SystemMessage
HumanMessage
AIMessage
ToolMessage

这些类型看起来只是几个类名，但它们解决的是更深层的问题：让 Agent 的输入输出格式稳定下来。只要消息协议统一了，上层就能在不同模型、不同链路、不同节点之间复用同一套对话结构。

typescript

import { HumanMessage } from "@langchain/core/messages";

4.2 Prompt 抽象：定义 Agent 怎样组织思考材料

Agent 不会直接理解你的产品需求文档，它真正能读取的是最终送进模型的 Prompt。@langchain/core 把 Prompt 从随手拼接的字符串，提升成结构化模板。ChatPromptTemplate、MessagesPlaceholder 等抽象，实际上是在让 Agent 的思考材料像组件一样被拼装：

固定系统指令
动态用户输入
历史消息
外部检索结果

这样你就能稳定地把它们组合进同一条输入链路，而不是每次都靠字符串手工拼接。

4.3 Runnable 协议：定义 Agent 内部节点怎样连接

一个 Agent 内部不会只有一个步骤。哪怕是最简单的场景，也通常包含：

组织 Prompt
调用模型
解析输出

Runnable 定义了一种统一的节点接口，让不同能力都可以被当成同一类组件来连接：

typescript

const chain = prompt.pipe(model).pipe(parser);

这行代码之所以成立，不是因为 .pipe() 很神奇，而是因为 @langchain/core 先规定了统一的接口标准。

4.4 Parser 和 Tool 协议：定义 Agent 怎样输出结果、怎样调用能力

Parser 抽象解决的是：文本怎样提取、JSON 怎样解析、结构化结果怎样进入后续链路。

Tool 协议解决的是：外部能力怎样被描述、模型怎样知道某个工具可以做什么、工具参数怎样被约束。

也就是说，@langchain/core 实际上是在给 Agent 定义一整套基础规则：

信息怎么进来
材料怎么组织
节点怎么连接
结果怎么出去
外部能力怎么接进来

这就是它作为基础抽象层的意义。

5. LangChain：把单个 Agent 真正组装出来

如果说 @langchain/core 是器官和接口标准，LangChain 就是在做更贴近业务的一层封装：把这些基础零件真正组装成一个可以行动的 Agent。

这一层最重要的价值，不是再次定义协议，而是把开发者最常做的动作整理成高层 API。

5.1 它让 Agent 先能接上模型

一个 Agent 再完整，没有模型也无法真正运行。LangChain 负责把不同供应商的模型能力接进统一接口，让 Agent 可以稳定调用它们。应用层只需关注：

用哪个模型
这个模型支持哪些能力
如何把它接到现有 Prompt 和 Tool 链路里

而不是每次都重新写请求体、流式处理和响应解析。

5.2 它让 Agent 的上下文组织变成常规开发动作

单独看 Prompt、消息、历史上下文、检索结果，这些都只是材料。LangChain 的价值是把这些材料收拢到一套统一开发方式里：

用模板组织 Prompt
用消息维护角色结构
把历史记录注入链路
把检索结果拼进输入
把解析器接到模型输出后面

于是 Agent 不再像一段临时脚本，而更像一个稳定的业务单元。

5.3 它让 Agent 能调用多个工具

这是 LangChain 最重要的落点。一个实用的 Agent 不会只停留在"生成一句回答"，它还需要决定：

什么时候该查工具
先查哪个工具
拿到工具结果后要不要继续调用别的工具
最后怎样把多步执行结果组织成回复

只要这套能力建立起来，一个单独的 Agent 就可以承担很多真实工作：信息检索、日程记录、外部接口调用、业务操作等。LangChain 最适合承载的主线就是：一个独立 Agent，如何在一次请求中组织上下文，并按需要调用多个工具完成任务。

5.4 它把单 Agent 开发变成一套稳定范式

LangChain 最终形成的是一种稳定的开发模式：

定义输入结构
组织 Prompt 与上下文
接入模型
接入工具
让 Agent 在调用模型与调用工具之间完成决策
输出最终结果

这就是为什么 LangChain 更像应用开发层。因为它处理的正是"把一个独立 Agent 做出来并投入业务使用"这件事。

6. LangGraph：让 Agent 进入更大的协作系统

当你只有一个 Agent 时，上面的结构已经足够强大。但系统继续增长后，问题会变化。你关心的不再只是一个 Agent 怎样完成任务，而是：

任务当前走到哪一步
哪些状态要跨步骤保留
流程失败后从哪里恢复
多个 Agent 如何分工
哪个 Agent 负责路由，哪个 Agent 负责执行

这时进入的就不再只是"单个 Agent 组装"问题，而是"系统编排"问题。LangGraph 处理的正是这部分。

6.1 它关心的是 Agent 所处的流程

LangChain 更多是在组装一个个体。LangGraph 更像是在安排这个个体进入一条完整流程。在 LangGraph 的视角里，一个 Agent 可能只是系统中的一个节点。除了 Agent 之外，还可能有：

分类节点
检索节点
审核节点
人工确认节点
汇总节点

所以 LangGraph 看待问题的方式，不再是"这个 Agent 怎么调用工具"，而是：整个流程怎样向前推进。

6.2 它关心的是状态怎样持续存在

一个独立 Agent 在单轮任务里，很多信息可以放在当前上下文里临时处理。但一旦流程跨越多个阶段，状态就会成为核心问题：

当前任务完成到第几步了
哪个 Agent 已经执行过
哪些中间结果要保留
当前是否需要人工介入

LangGraph 的价值，是把这些状态问题从"零散业务代码"提升成正式的运行时能力。

6.3 它更适合承载多个 Agent 的协作

多个 Agent 组成系统时，每个 Agent 都可以继续被看成一个独立个体，但系统已经不再等于这些个体的简单相加。还会多出很多新的系统问题：

哪个 Agent 先接任务
哪个 Agent 负责细分子任务
哪个 Agent 负责回收结果
公共状态和私有状态怎么分开

这些问题继续放在单 Agent 的封装里实现会越来越吃力；放到状态流转、节点编排和运行时控制的层面来实现，就会更自然。

Agent	主要职责	写入状态
Research Agent	收集资料、归纳来源、标注证据缺口	`sources`
Planning Agent	生成结构、拆分节点、标记证据需求	`plan`
Execution Agent	根据结构和资料生成产物	`product`
Fact Check Agent	检查事实、引用和不确定表述	`factCheckNotes`
Style Editor Agent	按项目规范修订表达	`styleReviewNotes`、`product`
Delivery Agent	写入外部系统或提交发布请求	`approvalStatus`

LangGraph 没有要求所有 Agent 都合并成一个大 Prompt。更合适的做法是：每个 Agent 负责一个清晰的节点，节点内部用 LangChain 的模型、Prompt、Retriever 和 Tool；节点之间通过 State 和条件边协作。

7. 总结

先从一个独立 Agent 出发：

@langchain/core 定义它的基础接口
LangChain 把它组装成一个真正能工作的行动单元

然后当这个 Agent 被放进更复杂的任务系统中：

LangGraph 继续负责流程推进、状态保存和多 Agent 协作

因此，学习 LangChain / LangGraph 的最佳思路，就是顺着一个 Agent 从"基础构成"到"独立行动"再到"进入系统"的完整路径去思考。

8. 一句话总结

Agent 开发 = 在模型之外组织好输入、上下文、工具和行动，让单个 Agent 能独立完成任务，再让多个 Agent 能在状态图中协作。

9. 参考资料

LangChain Documentation. Introduction to LangChain. https://python.langchain.com/docs/intro/
LangChain. LangChain Expression Language (LCEL). https://python.langchain.com/docs/concepts/lcel/
LangGraph Documentation. LangGraph: Build stateful, multi-agent applications. https://langchain-ai.github.io/langgraph/
Yao, S., et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. https://arxiv.org/abs/2210.03629
LangChain. Tools in LangChain. https://python.langchain.com/docs/concepts/tools/

从 Agent 开始 ​

1. 先从一个最小场景开始 ​

2. 什么是一个 Agent ​

3. 一个 Agent 内部需要哪些能力 ​

4. @langchain/core：定义这个个体的基础接口 ​

4.1 消息类型：定义 Agent 怎样接收信息 ​

4.2 Prompt 抽象：定义 Agent 怎样组织思考材料 ​

4.3 Runnable 协议：定义 Agent 内部节点怎样连接 ​

4.4 Parser 和 Tool 协议：定义 Agent 怎样输出结果、怎样调用能力 ​

5. LangChain：把单个 Agent 真正组装出来 ​

5.1 它让 Agent 先能接上模型 ​

5.2 它让 Agent 的上下文组织变成常规开发动作 ​

5.3 它让 Agent 能调用多个工具 ​

5.4 它把单 Agent 开发变成一套稳定范式 ​

6. LangGraph：让 Agent 进入更大的协作系统 ​

6.1 它关心的是 Agent 所处的流程 ​

6.2 它关心的是状态怎样持续存在 ​

6.3 它更适合承载多个 Agent 的协作 ​

7. 总结 ​

8. 一句话总结 ​

9. 参考资料 ​

从 Agent 开始

1. 先从一个最小场景开始

2. 什么是一个 Agent

3. 一个 Agent 内部需要哪些能力

4. @langchain/core：定义这个个体的基础接口

4.1 消息类型：定义 Agent 怎样接收信息

4.2 Prompt 抽象：定义 Agent 怎样组织思考材料

4.3 Runnable 协议：定义 Agent 内部节点怎样连接

4.4 Parser 和 Tool 协议：定义 Agent 怎样输出结果、怎样调用能力

5. LangChain：把单个 Agent 真正组装出来

5.1 它让 Agent 先能接上模型

5.2 它让 Agent 的上下文组织变成常规开发动作

5.3 它让 Agent 能调用多个工具

5.4 它把单 Agent 开发变成一套稳定范式

6. LangGraph：让 Agent 进入更大的协作系统

6.1 它关心的是 Agent 所处的流程

6.2 它关心的是状态怎样持续存在

6.3 它更适合承载多个 Agent 的协作

7. 总结

8. 一句话总结

9. 参考资料