LangGraph4j 入门指南

熊出没2026-06-30 22:28

LangGraph4j 入门指南：面向 Java 开发者的有状态 AI 工作流框架

LangGraph4j 是 Java 生态中用于构建「有状态、可循环、多步骤」LLM 应用的工作流编排库，灵感来自 Python 的 LangGraph，可与 LangChain4j、Spring AI 配合使用。

读者与前置知识

项目 说明
目标读者 有 Java 开发经验、刚开始接触 LLM / Agent 的开发者
需要会 Java 17+、Maven/Gradle、接口与 Lambda、基本的 CompletableFuture 概念
不必先会 Python、LangChain、向量数据库、Prompt 工程
建议搭配 至少了解「大模型能根据文本生成回复」这一基本事实即可开始

1. 先搞清楚：你要解决什么问题？

1.1 普通 Java 程序 vs LLM 应用

你熟悉的 Spring Boot 接口通常是：

复制代码 
请求 → 业务逻辑 → 数据库 → 返回 JSON

而 LLM 应用常见模式是：

复制代码 
用户问题 → 调用大模型 → 可能还要查资料、调工具、再调模型 → 最终回答

难点在于：中间步骤不固定 。模型可能决定「先搜网页」「再算数」「最后总结」，也可能失败后重试------这不是一条直线，而是一张带分支、可回环的流程图。

1.2 LangGraph4j 在生态中的位置

复制代码 
┌─────────────────────────────────────────────────────────┐
│                    你的 Java 应用                        │
├─────────────────────────────────────────────────────────┤
│  LangGraph4j          ← 工作流编排（图、状态、检查点）    │
├─────────────────────────────────────────────────────────┤
│  LangChain4j 或 Spring AI  ← 调模型、工具、RAG、记忆      │
├─────────────────────────────────────────────────────────┤
│  OpenAI / Ollama / 通义 / 其他模型 API                   │
└─────────────────────────────────────────────────────────┘
库 职责 类比
LangChain4j / Spring AI 封装模型调用、Tool、Embedding、RAG 像 JDBC 驱动 + 工具箱
LangGraph4j 定义「先做什么、再做什么、状态怎么传」 像工作流引擎（Activiti / Camunda 的 AI 版思路）
LangGraph (Python) 同一套设计理念的 Python 实现 Java 版即 LangGraph4j

LangGraph4j 不负责 替你选模型或写 Prompt；它负责把多个步骤（节点）连成一张可执行、可持久化、可调试的图。

1.3 为什么需要「图」而不是 if-else？

手写 if-else 在 3 步流程时还能应付。当出现以下情况时，图结构更清晰：

  • Agent 根据结果循环（例如：工具调用失败 → 换策略重试）
  • 多个 Agent 协作（研究 Agent → 写作 Agent → 审核 Agent）
  • 需要暂停等人审批（Human-in-the-loop）
  • 长对话要断点续跑（检查点持久化）
  • 要可视化流程、逐步调试

LangGraph4j 用 StateGraph（状态图） 表达这些逻辑；与只能表示「有向无环」的 DAG 相比，它支持环（cycle），这是 Agent「反复思考---行动」的基础。

2. 五个核心概念（用 Java 思维理解）

把 LangGraph4j 想成：共享状态的有限状态机 + 可编排的任务节点。
#mermaid-svg-B9fscy89HwBbUBE0{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-B9fscy89HwBbUBE0 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-B9fscy89HwBbUBE0 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-B9fscy89HwBbUBE0 .error-icon{fill:#552222;}#mermaid-svg-B9fscy89HwBbUBE0 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-B9fscy89HwBbUBE0 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-B9fscy89HwBbUBE0 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-B9fscy89HwBbUBE0 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-B9fscy89HwBbUBE0 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-B9fscy89HwBbUBE0 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-B9fscy89HwBbUBE0 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-B9fscy89HwBbUBE0 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-B9fscy89HwBbUBE0 .marker.cross{stroke:#333333;}#mermaid-svg-B9fscy89HwBbUBE0 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-B9fscy89HwBbUBE0 p{margin:0;}#mermaid-svg-B9fscy89HwBbUBE0 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-B9fscy89HwBbUBE0 .cluster-label text{fill:#333;}#mermaid-svg-B9fscy89HwBbUBE0 .cluster-label span{color:#333;}#mermaid-svg-B9fscy89HwBbUBE0 .cluster-label span p{background-color:transparent;}#mermaid-svg-B9fscy89HwBbUBE0 .label text,#mermaid-svg-B9fscy89HwBbUBE0 span{fill:#333;color:#333;}#mermaid-svg-B9fscy89HwBbUBE0 .node rect,#mermaid-svg-B9fscy89HwBbUBE0 .node circle,#mermaid-svg-B9fscy89HwBbUBE0 .node ellipse,#mermaid-svg-B9fscy89HwBbUBE0 .node polygon,#mermaid-svg-B9fscy89HwBbUBE0 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-B9fscy89HwBbUBE0 .rough-node .label text,#mermaid-svg-B9fscy89HwBbUBE0 .node .label text,#mermaid-svg-B9fscy89HwBbUBE0 .image-shape .label,#mermaid-svg-B9fscy89HwBbUBE0 .icon-shape .label{text-anchor:middle;}#mermaid-svg-B9fscy89HwBbUBE0 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-B9fscy89HwBbUBE0 .rough-node .label,#mermaid-svg-B9fscy89HwBbUBE0 .node .label,#mermaid-svg-B9fscy89HwBbUBE0 .image-shape .label,#mermaid-svg-B9fscy89HwBbUBE0 .icon-shape .label{text-align:center;}#mermaid-svg-B9fscy89HwBbUBE0 .node.clickable{cursor:pointer;}#mermaid-svg-B9fscy89HwBbUBE0 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-B9fscy89HwBbUBE0 .arrowheadPath{fill:#333333;}#mermaid-svg-B9fscy89HwBbUBE0 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-B9fscy89HwBbUBE0 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-B9fscy89HwBbUBE0 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-B9fscy89HwBbUBE0 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-B9fscy89HwBbUBE0 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-B9fscy89HwBbUBE0 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-B9fscy89HwBbUBE0 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-B9fscy89HwBbUBE0 .cluster text{fill:#333;}#mermaid-svg-B9fscy89HwBbUBE0 .cluster span{color:#333;}#mermaid-svg-B9fscy89HwBbUBE0 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-B9fscy89HwBbUBE0 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-B9fscy89HwBbUBE0 rect.text{fill:none;stroke-width:0;}#mermaid-svg-B9fscy89HwBbUBE0 .icon-shape,#mermaid-svg-B9fscy89HwBbUBE0 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-B9fscy89HwBbUBE0 .icon-shape p,#mermaid-svg-B9fscy89HwBbUBE0 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-B9fscy89HwBbUBE0 .icon-shape .label rect,#mermaid-svg-B9fscy89HwBbUBE0 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-B9fscy89HwBbUBE0 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-B9fscy89HwBbUBE0 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-B9fscy89HwBbUBE0 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 需要工具
可以回答
START
节点 A
节点 B
条件边
调用工具
生成回复
END

2.1 State（状态）--- AgentState

  • 整张图共享一个 Map 结构的状态（键值对）。
  • 你通常继承 AgentState，用 Schema 声明每个字段如何更新。
  • 类比：一个在整个流水线中传递的 Context 对象，每个节点只返回「要改的字段」，由框架合并进总状态。

关键机制：Reducer（归约器）

Reducer 类型 行为 典型用途
默认（覆盖） 新值直接替换旧值 当前步骤名、最终答案
Channels.appender() 新值追加到列表 对话消息列表、工具调用历史
自定义 Channel.of(reducer) 你定义合并规则 例如统一转大写、取最大值

2.2 Node（节点）--- 干活的单元

  • 实现 NodeAction<YourState> 或异步的 AsyncNodeAction。
  • 输入：当前状态；输出：Map<String, Object> 表示状态增量（不是整份状态）。
  • 节点里可以是：调 LLM、查数据库、发 HTTP、纯 Java 业务逻辑------不一定非要调模型。

2.3 Edge（边）--- 控制流

类型 API 思路 说明
普通边 addEdge("A", "B") A 执行完必定到 B
条件边 addConditionalEdges(...) 根据状态或路由函数决定下一跳
入口 addEdge(START, "firstNode") 图从哪里开始
出口 addEdge("lastNode", END) 图在哪里结束

2.4 Compile（编译）--- 运行前校验

stateGraph.compile() 得到 CompiledGraph：

  • 检查图结构（例如是否有孤立节点）
  • 可传入 CompileConfig：检查点、断点、递归深度限制等
  • 必须先 compile 才能 invoke / stream

2.5 Checkpoint（检查点）--- 可恢复的存档

  • 每一步可把状态存进 CheckpointSaver（内存、MySQL、PostgreSQL、Redis 等）。
  • 用途：多轮对话、崩溃恢复、人工审核后继续、调试时「时光倒流」看历史状态。

3. 环境准备与依赖

3.1 版本要求

发布线 Java 版本 说明
1.8.x 稳定版 Java 17+ 生产环境推荐
1.8-SNAPSHOT Java 17+ 尝鲜，API 可能变动

撰写本文时 Maven Central 最新稳定版为 1.8.18 （2026-06-12）。集成前请到 Maven Central 确认当前版本号。

3.2 Maven 依赖（最小可运行）

xml 复制代码 
<properties>
    <langgraph4j.version>1.8.18</langgraph4j.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.bsc.langgraph4j</groupId>
            <artifactId>langgraph4j-bom</artifactId>
            <version>${langgraph4j.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.bsc.langgraph4j</groupId>
        <artifactId>langgraph4j-core</artifactId>
    </dependency>
</dependencies>

3.3 常用扩展模块

模块 用途
langgraph4j-langchain4j / langchain4j-agent 与 LangChain4j 集成，含 ReAct Agent 示例
spring-ai-core / spring-ai-agent 与 Spring AI 集成
langgraph4j-postgres-saver / mysql-saver / redis-saver 检查点持久化
studio（Jetty / Spring Boot / Quarkus） 嵌入式 Web UI 调试图

4. 第一个图：从零跑通（官方最小示例）

下面示例不调用任何大模型，只演示 状态如何在节点间流动。建议原样复制运行一次，再改。

4.1 定义状态

java 复制代码 
import org.bsc.langgraph4j.state.AgentState;
import org.bsc.langgraph4j.state.Channels;
import org.bsc.langgraph4j.state.Channel;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

class SimpleState extends AgentState {
    public static final String MESSAGES_KEY = "messages";

    // messages 字段：每次更新会「追加」到列表，而不是覆盖
    public static final Map<String, Channel<?>> SCHEMA = Map.of(
            MESSAGES_KEY, Channels.appender(ArrayList::new)
    );

    public SimpleState(Map<String, Object> initData) {
        super(initData);
    }

    public List<String> messages() {
        return this.<List<String>>value(MESSAGES_KEY).orElse(List.of());
    }
}

4.2 定义两个节点

java 复制代码 
import org.bsc.langgraph4j.action.NodeAction;

import java.util.List;
import java.util.Map;

class GreeterNode implements NodeAction<SimpleState> {
    @Override
    public Map<String, Object> apply(SimpleState state) {
        System.out.println("GreeterNode，当前消息: " + state.messages());
        return Map.of(SimpleState.MESSAGES_KEY, "Hello from GreeterNode!");
    }
}

class ResponderNode implements NodeAction<SimpleState> {
    @Override
    public Map<String, Object> apply(SimpleState state) {
        System.out.println("ResponderNode，当前消息: " + state.messages());
        if (state.messages().contains("Hello from GreeterNode!")) {
            return Map.of(SimpleState.MESSAGES_KEY, "Acknowledged greeting!");
        }
        return Map.of(SimpleState.MESSAGES_KEY, "No greeting found.");
    }
}

4.3 组图、编译、执行

java 复制代码 
import org.bsc.langgraph4j.StateGraph;
import org.bsc.langgraph4j.GraphStateException;

import static org.bsc.langgraph4j.action.AsyncNodeAction.node_async;
import static org.bsc.langgraph4j.StateGraph.START;
import static org.bsc.langgraph4j.StateGraph.END;

import java.util.Map;

public class SimpleGraphApp {

    public static void main(String[] args) throws GraphStateException {
        var stateGraph = new StateGraph<>(SimpleState.SCHEMA, SimpleState::new)
                .addNode("greeter", node_async(new GreeterNode()))
                .addNode("responder", node_async(new ResponderNode()))
                .addEdge(START, "greeter")
                .addEdge("greeter", "responder")
                .addEdge("responder", END);

        var compiledGraph = stateGraph.compile();

        // stream：每执行完一个节点，yield 一次状态（适合观察中间过程）
        for (var item : compiledGraph.stream(
                Map.of(SimpleState.MESSAGES_KEY, "Let's begin!"))) {
            System.out.println(item);
        }
    }
}

4.4 执行过程解读

  1. 初始状态里 messages 已有 "Let's begin!"
  2. greeter 追加 "Hello from GreeterNode!"
  3. responder 看到问候语，追加 "Acknowledged greeting!"
  4. 到达 END，流结束

两条执行 API：

方法 返回 适用场景
stream(initialState, config) AsyncGenerator，逐步产出状态 调试、流式 UI、观察每步结果
invoke(initialState, config) CompletableFuture<最终状态> 只关心最终结果

5. 条件分支：让图「会做决定」

普通边是固定路线；条件边根据状态动态选下一节点------Agent「该不该调工具」就靠这个。

java 复制代码 
import org.bsc.langgraph4j.action.AsyncCommandAction;
import org.bsc.langgraph4j.graph.EdgeMapping;

// 伪代码结构：节点 A 执行完后，由 routingFunction 决定去向
graph.addConditionalEdges(
        "nodeA",
        (AsyncCommandAction<MyState>) (state, config) -> {
            if (state.needsTool()) {
                return "use_tool";
            }
            return "respond";
        },
        EdgeMapping.builder()
                .to("execute_tool", "use_tool")
                .to("generate_answer", "respond")
                .build()
);

路由函数返回值是逻辑标签 ；EdgeMapping 把标签映射到真实节点名。这样图里可以出现 A → 工具 → 再回到 A 的环，实现 ReAct（推理 + 行动）循环。

6. 运行时配置：RunnableConfig 与 CompileConfig

6.1 RunnableConfig（单次执行上下文）

java 复制代码 
import org.bsc.langgraph4j.RunnableConfig;
import org.bsc.langgraph4j.CompiledGraph;

var config = RunnableConfig.builder()
        .threadId("user-session-123")           // 会话/线程 ID，检查点按此分组
        .streamMode(CompiledGraph.StreamMode.UPDATES)  // 只流式输出「变更」
        .putMetadata("userId", "u-001")
        .putMetadata("model", "gpt-4")
        .build();

compiledGraph.stream(inputs, config);

节点可通过 AsyncNodeActionWithConfig 读取 config.metadata("userId")，实现「同一张图、不同用户不同策略」。

6.2 CompileConfig（编译期行为）

java 复制代码 
import org.bsc.langgraph4j.CompileConfig;

var compileConfig = CompileConfig.builder()
        .checkpointSaver(mySaver)              // 检查点存储
        .recursionLimit(50)                    // 防死循环，默认 25
        .interruptBefore("dangerous_step")     // 执行前暂停（人工审核）
        .interruptAfter("draft_ready")         // 执行后暂停
        .build();

var graph = stateGraph.compile(compileConfig);
配置项 作用
checkpointSaver 状态持久化实现
recursionLimit 超过步数抛错，防止 Agent 无限循环
interruptBefore / interruptAfter Human-in-the-loop 断点
graphId 日志、监控中区分多图实例

7. 检查点与多轮对话

没有检查点时，每次 stream 都是全新的一次执行。要支持「用户第 2 条消息接着聊」，需要：

  1. 编译时配置 CheckpointSaver
  2. 每次执行使用相同 threadId
java 复制代码 
import org.bsc.langgraph4j.checkpoint.MemorySaver;

var saver = new MemorySaver();
var compiled = stateGraph.compile(
        CompileConfig.builder().checkpointSaver(saver).build()
);

var config = RunnableConfig.builder().threadId("chat-001").build();

// 第一轮
compiled.invoke(Map.of("messages", "你好"), config);

// 第二轮：同一 threadId，从检查点恢复上下文
compiled.invoke(Map.of("messages", "刚才我说了什么？"), config);

生产环境可换：

  • langgraph4j-postgres-saver
  • langgraph4j-mysql-saver
  • langgraph4j-redis-saver

8. 与 LangChain4j / Spring AI 集成

LangGraph4j 可以单独用；实际项目里多数会叠加 AI 框架。

8.1 选型建议

你已经在用 建议
纯 Java、无 Spring LangChain4j + langchain4j-agent
Spring Boot 3.x Spring AI + spring-ai-agent
只想学图怎么跑 先只依赖 langgraph4j-core（上一章示例）

8.2 ReAct Agent 快速体验（LangChain4j）

ReAct = 模型推理 → 决定是否调工具 → 看结果 → 再推理，直到能回答。

java 复制代码 
// 1. 定义工具（LangChain4j 注解）
public class TestTool {
    @Tool("测试工具")
    String execTest(@P("消息") String message) {
        return "tool executed OK: " + message;
    }
}

// 2. 配置本地 Ollama 模型（需先安装并 pull 模型）
var model = OllamaChatModel.builder()
        .modelName("qwen2.5:7b")
        .baseUrl("http://localhost:11434")
        .temperature(0.0)
        .build();

// 3. AgentExecutor 内部已是 LangGraph4j 图
var agent = AgentExecutor.builder()
        .chatModel(model)
        .toolsFromObject(new TestTool())
        .build()
        .compile();

for (var item : agent.stream(Map.of("messages", "调用测试工具两次"))) {
    System.out.println(item);
}

Spring AI 侧 API 类似，工具注解为 @Tool + @ToolParam，详见仓库 spring-ai/spring-ai-agent 模块。

9. 能力一览（按学习顺序）

能力 说明 学习时机
线性图 START → 多节点 → END 第 1 天
条件边与环 Agent 循环、分支 第 2--3 天
stream / invoke 同步 vs 观察每步 第 1 天
Checkpointer 多轮对话、恢复 有状态需求时
Interrupt 人工审批 企业流程
子图 Subgraph 大图拆模块 复杂系统
并行分支 多节点同时跑 性能优化
Studio 浏览器里看图、跑图 调试阶段
PlantUML / Mermaid 导出流程图 文档与评审
OpenTelemetry 链路追踪 生产可观测

10. 典型应用场景

场景 图里大致长什么样
客服机器人 意图识别 → RAG 检索 → 生成 → 不满意则转人工
代码助手 读仓库 → 生成补丁 → 跑测试 → 失败则回到生成
研报生成 搜索 Agent → 摘要 Agent → 写作 Agent → 审核节点（可 interrupt）
审批流 + AI 业务节点纯 Java，AI 节点只负责起草意见
多用户 SaaS 每用户一个 threadId + DB Checkpointer

11. 与手写代码 / 其他方案的对比

方案 优点 缺点
手写 if-else + 状态对象 零依赖、完全可控 流程复杂后难维护、难可视化
仅 LangChain4j Chains 上手快 多为 DAG，难表达循环 Agent
LangGraph4j 环、检查点、断点、Studio 多一层概念，需先理解 State/Node/Edge
Python LangGraph 生态示例最多 非 Java 技术栈

12. 推荐学习路径（约 1--2 周）

复制代码 
第 1 步  跑通本文 §4 无 LLM 示例
    ↓
第 2 步  加一个条件边，模拟「需要/不需要工具」两分支
    ↓
第 3 步  引入 LangChain4j 或 Spring AI，跑通 AgentExecutor
    ↓
第 4 步  加 MemorySaver，用同一 threadId 发两轮消息
    ↓
第 5 步  读仓库 how-tos/ 里感兴趣的 notebook（需 Java 22 的部分工具可选）
    ↓
第 6 步  用 Studio 或 Mermaid 导出图，对照代码理解

13. 常见问题

Q1：compile() 报错 GraphStateException？

常见原因：节点未连到 START/END、条件边映射漏了分支、节点名拼写不一致。对照 addEdge / addConditionalEdges 逐项检查。

Q2：Agent 死循环？

调大或理解 recursionLimit（默认 25）。业务上应在条件边里设计「满足条件则 END」的出口。

Q3：stream 和 invoke 选哪个？

要接 SSE 给前端、或调试每步状态 → stream；批处理只要最终结果 → invoke。

Q4：必须用 LangChain4j 吗？

不必须。langgraph4j-core 可独立使用；只有调模型、Tool、RAG 时才需要 AI 框架。

Q5：和 Spring AI Alibaba Graph 什么关系？

阿里 spring-ai-alibaba-graph-core 内嵌了 LangGraph4j 思想/实现，概念相通；学会 LangGraph4j 后迁移成本低。

14. 参考资源

资源 链接
GitHub 主仓库 https://github.com/langgraph4j/langgraph4j
官方文档站 https://langgraph4j.github.io/langgraph4j/
Maven Central https://central.sonatype.com/search?q=g%3Aorg.bsc.langgraph4j
示例项目集 https://github.com/langgraph4j/langgraph4j-examples
Discord 社区 https://discord.gg/szVVztSYKh
Spring AI + LangGraph4j 入门模板 https://github.com/Breezeware-OS/dynamo-multi-ai-agent-langgraph4j-starter

15. 术语表

术语 含义
LLM Large Language Model，大语言模型
Agent 能根据环境多步决策的程序（常含模型 + 工具）
ReAct Reasoning + Acting，边想边调工具的模式
RAG Retrieval-Augmented Generation，检索增强生成
State / AgentState 图内共享状态对象
Node 执行单元
Edge 节点间跳转规则
Reducer 合并状态更新的函数
Checkpoint 某时刻状态的快照
threadId 区分不同会话的执行线程标识

文档基于 LangGraph4j 1.8.x 官方 README 与 Core Library 文档整理。版本号与 API 以官方仓库为准。

热门推荐
012026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？022026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04Trae国际版与国内版深度测评：AI原生IDE的双生花05飞书长连接_事件订阅（接收消息，审批任务状态变更）06【AI】2026 年具身智能模型和世界模型总结07Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析08GitHub 镜像站点092026年AI架构实战：彻底解决OpenAI接口超时与封号，Python调用GPT-5.2/Sora2企业级架构详解（附源码+压测报告）102026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？