Spring AI Alibaba 97｜Graph Core · 子图 · 多智能体系统示例

子图在构建多智能体系统时特别有用。每个智能体可以是一个独立的子图：

import com.alibaba.cloud.ai.graph.CompiledGraph;
import com.alibaba.cloud.ai.graph.KeyStrategy;
import com.alibaba.cloud.ai.graph.KeyStrategyFactory;
import com.alibaba.cloud.ai.graph.StateGraph;
import com.alibaba.cloud.ai.graph.state.strategy.ReplaceStrategy;

import java.util.HashMap;
import java.util.Map;

import static com.alibaba.cloud.ai.graph.StateGraph.END;
import static com.alibaba.cloud.ai.graph.StateGraph.START;
import static com.alibaba.cloud.ai.graph.action.AsyncNodeAction.node_async;

// 定义智能体状态策略
KeyStrategyFactory agentKeyStrategyFactory = () -> {
  HashMap<String, KeyStrategy> strategies = new HashMap<>();
  strategies.put("topic", new ReplaceStrategy());
  strategies.put("research", new ReplaceStrategy());
  strategies.put("summary", new ReplaceStrategy());
  strategies.put("outline", new ReplaceStrategy());
  strategies.put("content", new ReplaceStrategy());
  return strategies;
};

// 研究智能体子图
StateGraph researcherGraph = new StateGraph(agentKeyStrategyFactory)
  .addNode("research", node_async(state -> {
      String topic = (String) state.value("topic").orElse("");
      return Map.of("research", "Research on: " + topic);
  }))
  .addNode("summarize", node_async(state -> {
      String research = (String) state.value("research").orElse("");
      return Map.of("summary", "Summary: " + research);
  }))
  .addEdge(START, "research")
  .addEdge("research", "summarize")
  .addEdge("summarize", END);

CompiledGraph researcherAgent = researcherGraph.compile();

// 写作智能体子图
StateGraph writerGraph = new StateGraph(agentKeyStrategyFactory)
  .addNode("outline", node_async(state -> {
      String summary = (String) state.value("summary").orElse("");
      return Map.of("outline", "Outline based on: " + summary);
  }))
  .addNode("write", node_async(state -> {
      String outline = (String) state.value("outline").orElse("");
      return Map.of("content", "Content: " + outline);
  }))
  .addEdge(START, "outline")
  .addEdge("outline", "write")
  .addEdge("write", END);

CompiledGraph writerAgent = writerGraph.compile();

// 协调器（父图）
KeyStrategyFactory coordinatorKeyStrategyFactory = () -> {
  HashMap<String, KeyStrategy> strategies = new HashMap<>();
  strategies.put("topic", new ReplaceStrategy());
  strategies.put("research", new ReplaceStrategy());
  strategies.put("summary", new ReplaceStrategy());
  strategies.put("outline", new ReplaceStrategy());
  strategies.put("content", new ReplaceStrategy());
  return strategies;
};

StateGraph coordinatorGraph = new StateGraph(coordinatorKeyStrategyFactory)
  .addNode("researcher", researcherAgent)  // 直接使用编译的子图
  .addNode("writer", writerAgent)           // 直接使用编译的子图
  .addEdge(START, "researcher")
  .addEdge("researcher", "writer")
  .addEdge("writer", END);

CompiledGraph multiAgentSystem = coordinatorGraph.compile();

// 执行多智能体系统
Map<String, Object> result = multiAgentSystem.invoke(
  Map.of("topic", "AI的未来")
).orElseThrow();

当子图需要完全独立的状态时，可以使用状态隔离模式：

import com.alibaba.cloud.ai.graph.CompiledGraph;
import com.alibaba.cloud.ai.graph.OverAllState;
import com.alibaba.cloud.ai.graph.StateGraph;
import com.alibaba.cloud.ai.graph.action.NodeAction;
import com.alibaba.cloud.ai.graph.exception.GraphStateException;

import java.util.Map;
import java.util.Optional;

public static class IsolatedSubGraphNode implements NodeAction {
  private final CompiledGraph subGraph;

  public IsolatedSubGraphNode(StateGraph subGraphDef) throws GraphStateException {
      this.subGraph = subGraphDef.compile();
  }

  @Override
  public Map<String, Object> apply(OverAllState parentState) {
      // 提取父状态数据
      String input = (String) parentState.value("input").orElse("");

      // 创建子图独立状态
      Map<String, Object> subState = Map.of("subInput", input);

      // 执行子图
      Optional<OverAllState> subResult = subGraph.invoke(subState);

      // 将子图结果映射回父状态
      String output = (String) subResult.get().value("subOutput").orElse("");
      return Map.of("output", output);
  }
}

1. 明确接口：定义清晰的输入和输出 schema，便于团队协作。
2. 状态隔离：当子图需要独立状态时，使用转换节点或状态隔离模式。
3. 错误处理：在调用子图时添加适当的错误处理，使用 orElseThrow() 或 Optional 处理。
4. 组件复用：将常用的处理逻辑封装为子图，在多个地方复用。
5. 文档化：为每个子图编写清晰的文档，说明其用途和接口。
6. 测试：独立测试每个子图，然后测试整个系统。
7. 性能考虑：编译的子图可以复用，避免重复编译。

通过子图，您可以：

• 构建多智能体系统：每个智能体作为独立的子图
• 实现组件复用：在多个父图中重用相同的子图
• 支持团队协作：不同团队可以独立开发子图
• 实现模块化设计：将复杂系统分解为可管理的子图

通过合理使用子图，您可以构建模块化、可维护和可扩展的复杂 AI 工作流系统。

本文整理自 Spring AI Alibaba 官方文档《子图》：https://java2ai.com/docs/frameworks/graph-core/examples/subgraph