子图

图越来越复杂

单个图有 30 个节点、20 条边——没人能看懂，也没人敢改。

开始之前

什么是子图

子图就是作为另一个图中节点使用的图

两种通信

关键决策：父子图的状态是否共享？

节点内调用

父子图状态不同时，在节点函数内调用子图并转换状态

// 子图 — 有自己的状态 { bar }
const SubgraphState = new StateSchema({ bar: z.string() });

const subgraph = new StateGraph(SubgraphState)
  .addNode("subgraphNode1", (state) => {
    return { bar: "hi! " + state.bar };
  })
  .addEdge(START, "subgraphNode1")
  .compile();

// 父图 — 状态是 { foo }，和子图的 { bar } 不同
const State = new StateSchema({ foo: z.string() });

const graph = new StateGraph(State)
  .addNode("node1", async (state) => {
    // 手动映射：foo → bar
    const output = await subgraph.invoke({ bar: state.foo });
    // 手动映射回：bar → foo
    return { foo: output.bar };
  })
  .addEdge(START, "node1")
  .compile();

📄 完整代码：11_call_inside_node.ts

直接作为节点

父子图共享状态键时，直接传入编译后的子图

// 父子图共享 { foo } 状态
const State = new StateSchema({ foo: z.string() });

const subgraph = new StateGraph(State)
  .addNode("subgraphNode1", (state) => {
    return { foo: "hi! " + state.foo };
  })
  .addEdge(START, "subgraphNode1")
  .compile();

// 直接传入子图作为节点 — 无需包装函数
const graph = new StateGraph(State)
  .addNode("node1", subgraph)  // 直接传！
  .addEdge(START, "node1")
  .compile();

📄 完整代码：11_direct_as_node.ts

子图持久化

子图的检查点行为取决于它的 checkpointer 配置

📄 完整代码：11_persistence_modes.ts

查看子图状态

用 subgraphs: true 选项查看子图内部状态

// 查看当前调用的子图状态
const subgraphState = (await graph.getState(config, { subgraphs: true }))
  .tasks[0].state;

// 流式输出子图结果
for await (const chunk of await graph.stream(
  { foo: "foo" },
  { subgraphs: true, streamMode: "updates" }
)) {
  console.log(chunk);
}

📄 完整代码：11_subgraph_state.ts

排错指南

动手练习

构建一个包含两个子图的父图

• 子图 A（研究）：状态为 { topic, findings }，包含"搜索"和"整理"两个节点
• 子图 B（写作）：状态为 { findings, article }，包含"起草"和"润色"两个节点
• 父图状态为 { topic, findings, article }
• 用节点内调用模式连接两个子图

参考答案

// 子图 A：研究
const ResearchState = new StateSchema({
  topic: z.string(),
  findings: z.array(z.string()).optional(),
});

const researchGraph = new StateGraph(ResearchState)
  .addNode("search", async (state) => {
    // 模拟搜索
    return { findings: [`Found info about ${state.topic}`] };
  })
  .addNode("organize", (state) => {
    return { findings: state.findings?.map(f => `Organized: ${f}`) };
  })
  .addEdge(START, "search")
  .addEdge("search", "organize")
  .compile();

// 子图 B：写作
const WritingState = new StateSchema({
  findings: z.array(z.string()).optional(),
  article: z.string().optional(),
});

const writingGraph = new StateGraph(WritingState)
  .addNode("draft", (state) => {
    return { article: `Draft based on ${state.findings?.join(", ")}` };
  })
  .addNode("polish", (state) => {
    return { article: `Polished: ${state.article}` };
  })
  .addEdge(START, "draft")
  .addEdge("draft", "polish")
  .compile();

// 父图 — 用节点内调用连接
const ParentState = new StateSchema({
  topic: z.string(),
  findings: z.array(z.string()).optional(),
  article: z.string().optional(),
});

const parentGraph = new StateGraph(ParentState)
  .addNode("research", async (state) => {
    const out = await researchGraph.invoke({ topic: state.topic });
    return { findings: out.findings };
  })
  .addNode("write", async (state) => {
    const out = await writingGraph.invoke({ findings: state.findings });
    return { article: out.article };
  })
  .addEdge(START, "research")
  .addEdge("research", "write")
  .addEdge("write", END)
  .compile();

📄 完整代码：11_multi_level_subgraph.ts

本章回顾

延伸阅读