LangGraph 核心机制：从状态管理到人机协同

LangGraph 是 LangChain 生态中用于构建复杂、有状态、多 Agent 协作 工作流的编排框架。它通过图结构定义任务流程，支持条件分支、循环、持久化和中断恢复，比传统的线性链（Chain）更适合处理非确定性、多步骤的智能体应用。

1. 核心概念：图（Graph）与状态（State）

LangGraph 的工作流是一个有向图 ，由节点（Node） 和边（Edge） 构成。

节点：执行具体逻辑的函数（如调用 LLM、执行工具、处理数据）。
边：定义节点的执行顺序与跳转逻辑。

所有节点共享一个全局状态（State） 。状态通过注解（Annotation） 定义，并指定 reducer 函数来控制状态如何更新（覆盖、累加、合并等）。

javascript

javascript 复制代码

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

// 定义状态结构
const StateAnnotation = Annotation.Root({
  text: Annotation({
    reducer: (_prev, next) => next, // 直接覆盖
    default: () => "",
  }),
  count: Annotation({
    reducer: (prev, next) => (prev ?? 0) + next, // 累加
    default: () => 0,
  }),
});

// 定义节点
const step1 = (state) => ({ text: `${state.text} -> step1`, count: 1 });
const step2 = (state) => ({ text: `${state.text} -> step2`, count: 2 });

// 构建图
const graph = new StateGraph(StateAnnotation)
  .addNode("step1", step1)
  .addNode("step2", step2)
  .addEdge(START, "step1")
  .addEdge("step1", "step2")
  .addEdge("step2", END)
  .compile();

const result = await graph.invoke({ text: "hello" });
console.log(result);
// 输出: { text: 'hello -> step1 -> step2', count: 3 }

关键点 ：reducer 决定了状态如何演变。count 字段使用了累加器，每次节点返回的 count 值都会叠加。

2. 条件路由（Conditional Routing）

通过 addConditionalEdges 实现动态分支，根据当前状态的值决定下一步走向。

javascript

javascript 复制代码

const router = (state) => {
  const isMath = /[+-*/]/.test(state.query);
  return { route: isMath ? "math" : "chat" };
};

const mathNode = (state) => ({ answer: String(eval(state.query)) });
const chatNode = (state) => ({ answer: `你说的是：${state.query}` });

const graph = new StateGraph(StateAnnotation)
  .addNode("router", router)
  .addNode("math", mathNode)
  .addNode("chat", chatNode)
  .addEdge(START, "router")
  .addConditionalEdges(
    "router",
    (state) => state.route,
    { math: "math", chat: "chat" }  // 映射表
  )
  .addEdge("math", END)
  .addEdge("chat", END)
  .compile();

await graph.invoke({ query: "1+2" });  // 走 math 节点
await graph.invoke({ query: "你好" }); // 走 chat 节点

3. 循环与重试（Loop & Retry）

通过条件边指向自身节点，实现循环逻辑。

javascript

javascript 复制代码

const attempt = (state) => {
  const tries = state.tries + 1;
  const ok = tries >= 3;
  return { tries, ok, message: ok ? `第${tries}次成功` : `第${tries}次失败` };
};

const graph = new StateGraph(StateAnnotation)
  .addNode("attempt", attempt)
  .addEdge(START, "attempt")
  .addConditionalEdges(
    "attempt",
    (state) => state.ok ? "done" : "retry",
    { retry: "attempt", done: END }
  )
  .compile();

await graph.invoke({ tries: 0 });
// 输出: { tries: 3, ok: true, message: '第3次成功' }

4. 状态持久化（Checkpointing）

使用 MemorySaver 或数据库（如 SQLite、Redis）保存每次执行后的状态，配合 thread_id 实现多会话隔离与上下文记忆。

javascript

arduino 复制代码

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

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

const config = { configurable: { thread_id: "user-001" } };

await app.invoke({ visitCount: 0 }, config);
await app.invoke({}, config); // 状态自动恢复并累加

应用场景：多轮对话、长期任务、故障恢复。

5. 中断与恢复（Interrupt & Resume）

通过 interrupt() 函数暂停工作流，等待外部输入后再通过 Command({ resume }) 恢复执行。必须配合持久化使用。

javascript

arduino 复制代码

import { interrupt, Command, MemorySaver } from '@langchain/langgraph';

const waitConfirm = (state) => {
  const userInput = interrupt({ hint: "请输入确认信息" });
  return { userInput };
};

const graph = new StateGraph(StateAnnotation)
  .addNode("waitConfirm", waitConfirm)
  .addEdge(START, "waitConfirm")
  .addEdge("waitConfirm", END)
  .compile({ checkpointer: new MemorySaver() });

const config = { configurable: { thread_id: "demo" } };

// 第一次调用会抛出中断
try {
  await graph.invoke({}, config);
} catch (paused) {
  console.log(paused.__interrupt__[0].value); // 获取中断信息
}

// 模拟外部输入后恢复
const result = await graph.invoke(new Command({ resume: "确认" }), config);
console.log(result); // { userInput: '确认' }

典型场景：人工审核、二次确认、动态参数补全。

6. 多 Agent 分工优势

LangGraph 天然支持多 Agent 协作，相比单 Agent 架构具备以下优势：

对比维度	单 Agent	多 Agent（LangGraph）
Prompt 开销	每次携带全部工具描述，Token 大	每个 Agent 只带必要 Prompt，更省 Token
决策干扰	冗余信息多，易出错	职责单一，专注度高，准确率提升
执行效率	串行逐步思考	子 Agent 可并行处理，整体更快
纠错能力	单点决策，无法互相校验	多角色讨论（如 AutoGen 模式），容错强
模型选择	只能用一个模型	不同 Agent 可按需选用不同模型
加载方式	全量加载	按需动态加载，资源利用率高

总结

LangGraph 的核心能力可概括为四个层面：

结构编排：通过节点（Node）和边（Edge）构建任意复杂的网状工作流，支持分支和循环。
状态管理 ：利用 Annotation 和 reducer 统一管理全局状态，支持覆盖、累加等多种更新策略。
持久化与中断 ：基于 Checkpointer 实现状态快照，结合 interrupt/Command 实现人工介入与流程恢复。
多 Agent 协同：将复杂任务拆解给多个专用 Agent，降低 Token 消耗、提升准确率和执行效率。