5.6 LangGraph-Edges理解-Agent图的道路系统

常丛丛2026-07-01 10:52

边的概念与核心作用

在 LangGraph 中，Edge 是连接节点的道路，决定了执行流程的路径。箭头方向不仅把节点连起来，还在定义时就固定了「从哪到哪」。

边的三个核心作用：

作用 说明
定义执行顺序 规定节点之间先执行谁、后执行谁
控制 State 流转 每个节点执行后更新 State，再传给下一节点
构建完整工作流 与 START、END 配合，形成有入口、有出口的完整图

边的三种类型

LangGraph 中的边分为三类，共同构成图的「道路系统」：

1. 普通边（Normal Edge）

两个普通节点之间的固定连接，表示无条件的线性执行：

python 复制代码 
graph.add_edge("input", "process")
graph.add_edge("process", "output")

特点：固定路径、无条件跳转，适合线性流水线。

2. 起始边（Start Edge）

每个图都需要一个入口。LangGraph 内置特殊节点 START，通过起始边连接到第一个自定义节点：

python 复制代码 
from langgraph.graph import START

graph.add_edge(START, "input")

START 是框架内置的特殊节点，表示图的执行起点，不可省略。

3. 结束边（End Edge）

最后一个节点需要连接到内置特殊节点 END，表示图执行完成：

python 复制代码 
from langgraph.graph import END

graph.add_edge("output", END)

到达 END 后，整个工作流结束。

图的执行流程

一个典型的线性图结构如下：

text 复制代码 
START → Node1 → Node2 → Node3 → END

执行机制：

  1. 从 START 节点开始
  2. 按照边的连接顺序依次执行节点
  3. 每个节点执行后更新全局 State
  4. 下一个节点接收更新后的 State
  5. 到达 END 节点后结束

中间那些箭头，就是 Edge 在代码里的具象化------底层对应的就是「按顺序跑节点、逐步 update State」的执行机制。

编译与执行

所有边都连好之后，图还不能直接跑，必须先 编译 ，再 调用。

编译图：compile()

python 复制代码 
app = graph.compile()

关键点：

  • 编译是必须步骤：不编译，图无法执行
  • 编译后结构不可修改：如需改节点或边，须重新构建并再次编译
  • 返回可调用对象 ：app 就是可执行的图应用

执行图：invoke()

传入初始 State，同步跑完整个工作流：

python 复制代码 
result = app.invoke(initial_state)

invoke 的特点：

  • 同步执行：所有中间节点全部跑完才返回
  • 返回最终完整 State ：result 本质是一个字典
  • 主测试场景最常用 ：需要等待完整结果时，优先用 invoke

取值方式两种等价：

python 复制代码 
result["raw_input"]          # 方括号索引
result.get("processed", "")  # get 方法，可设默认值

完整工作流示例：三个节点分别负责接收输入、处理数据、格式化输出，通过边串成 START → input → process → output → END。这是最基础的线性流程模式；后续还会接触条件路由、循环路由等更复杂结构。

脚本 1：普通边连接节点

文件：1_普通边连接节点.py

在引入 add_edge 之前，先手动按顺序调用节点，理解边最终要表达的就是这个执行顺序：

python 复制代码 
from typing import TypedDict

class DataState(TypedDict):
    raw_input: str
    processed: str
    output: str

# 第一个节点：清理输入（去掉首尾空格）
def input_node(state: DataState):
    cleaned = state["raw_input"].strip()
    return {"raw_input": cleaned}

# 第二个节点：处理数据（转大写）
def process_node(state: DataState):
    processed = state["raw_input"].upper()
    return {"processed": processed}

# 第三个节点：整理输出
def output_node(state: DataState):
    output = f"Result: {state['processed']}"
    return {"output": output}

# 先手动按顺序调用节点，理解边最终要表达的就是这个执行顺序
state = {"raw_input": "  hello world  ", "processed": "", "output": ""}
print("初始状态:", state)

state.update(input_node(state))
print("清理输入后:", state)

state.update(process_node(state))
print("转大写后:", state)

state.update(output_node(state))
print("最终状态:", state)

运行结果：

text 复制代码 
初始状态: {'raw_input': '  hello world  ', 'processed': '', 'output': ''}
清理输入后: {'raw_input': 'hello world', 'processed': '', 'output': ''}
转大写后: {'raw_input': 'hello world', 'processed': 'HELLO WORLD', 'output': ''}
最终状态: {'raw_input': 'hello world', 'processed': 'HELLO WORLD', 'output': 'Result: HELLO WORLD'}

每一步只有目标字段变化：第一个节点只更新了 raw_input，第二个更新了 processed，第三个增加了格式化的 output。连接好边之后，框架做的就是这件事------依次运行节点，对每个节点返回的字典做 state.update()。

脚本 2：START 与 END

文件：2_START和END.py

理解手动流转后，用 StateGraph 和 add_edge 把节点与 START、END 连起来：

python 复制代码 
from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class DataState(TypedDict):
    raw_input: str
    processed: str
    output: str

def input_node(state: DataState):
    cleaned = state["raw_input"].strip()
    return {"raw_input": cleaned}

def process_node(state: DataState):
    processed = state["raw_input"].upper()
    return {"processed": processed}

def output_node(state: DataState):
    output = f"Result: {state['processed']}"
    return {"output": output}

# 创建图并添加节点
graph = StateGraph(DataState)
graph.add_node("input", input_node)
graph.add_node("process", process_node)
graph.add_node("output", output_node)

# 连接边：START → input → process → output → END
graph.add_edge(START, "input")
graph.add_edge("input", "process")
graph.add_edge("process", "output")
graph.add_edge("output", END)

此时图结构已经完整：

text 复制代码 
START → input → process → output → END

但还没有 compile() 和 invoke()，所以直接运行不会有输出------下一个脚本解决这个问题。

脚本 3：compile 与 invoke

文件：3_compile和invoke.py

在脚本 2 的基础上，补上编译、执行和结果读取：

python 复制代码 
from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class DataState(TypedDict):
    raw_input: str
    processed: str
    output: str

def input_node(state: DataState):
    cleaned = state["raw_input"].strip()
    return {"raw_input": cleaned}

def process_node(state: DataState):
    processed = state["raw_input"].upper()
    return {"processed": processed}

def output_node(state: DataState):
    output = f"Result: {state['processed']}"
    return {"output": output}

graph = StateGraph(DataState)
graph.add_node("input", input_node)
graph.add_node("process", process_node)
graph.add_node("output", output_node)

graph.add_edge(START, "input")
graph.add_edge("input", "process")
graph.add_edge("process", "output")
graph.add_edge("output", END)

# compile 把图配置转成真正可执行的应用
app = graph.compile()

# invoke 从初始 State 出发，跑完整个图
initial_state = {
    "raw_input": "  hello world  ",
    "processed": "",
    "output": "",
}

result = app.invoke(initial_state)

print("清理后的输入:", result["raw_input"])
print("处理后的结果:", result["processed"])
print("最终输出:", result["output"])
print("完整结果:", result)

运行结果：

text 复制代码 
清理后的输入: hello world
处理后的结果: HELLO WORLD
最终输出: Result: HELLO WORLD
完整结果: {'raw_input': 'hello world', 'processed': 'HELLO WORLD', 'output': 'Result: HELLO WORLD'}

result 就是一个字典（State），除了 result["key"]，也可以用 result.get("key") 取值，效果一致。

图可视化

LangGraph 内置可视化能力，编译后可以直观查看图结构。在 Jupyter Notebook 中：

python 复制代码 
from IPython.display import Image, display

display(Image(app.get_graph().draw_mermaid_png()))

可视化的价值：

  • 帮助理解图的执行流程
  • 快速发现结构问题
  • 便于团队沟通和文档化

边与 State、Node 的关系（一图看懂）

text 复制代码 
┌────────┐  起始边   ┌────────┐  普通边   ┌─────────┐  普通边   ┌────────┐  结束边   ┌─────┐
│ START  │ ───────→ │ input  │ ───────→ │ process │ ───────→ │ output │ ───────→ │ END │
└────────┘          └────────┘          └─────────┘          └────────┘          └─────┘
                         │                    │                    │
                         └──── 每步 update State，传给下一节点 ────┘
  • 边负责把节点执行过程用箭头串起来
  • 添加边之后还需 compile()，才能 invoke() 运行
  • 传入初始 State，框架自动沿图跑完所有节点和边，返回最终 Result

小结

要点 内容
本质 边 = 连接节点的道路，决定执行路径与 State 流转
普通边 两节点固定连接，线性、无条件
起始边 START → 第一个自定义节点，图的入口
结束边 最后一个节点 → END，图的出口
编译 graph.compile() 必须执行，编译后结构不可改
执行 app.invoke(初始State) 同步跑完，返回完整 State
取值 result["key"] 或 result.get("key") 均可
相关推荐
雪隐1 小时前
个人电脑玩AI-08让5060 Ti给你打工——我拿 Unlimited-OCR扫了 600 页书，然后悟了
人工智能·后端
Coffeeee1 小时前
Prompt要花心思写，与 AI 对话的七个技巧
人工智能·aigc·ai编程
蝎子莱莱爱打怪2 小时前
Claude Code 官宣新升级：子智能体默认后台跑，你边聊它边干活
人工智能
武子康2 小时前
调查研究-206 DeepSeek DSpark 深度解析：大模型推理加速，正在从“模型能力”转向“系统工程”
人工智能·agent·deepseek
甲维斯2 小时前
最佳work模型sonnet5来了，直接就能用！
人工智能
IT_陈寒3 小时前
React hooks 闭包陷阱把我的状态吃掉了，原来问题出在这里
前端·人工智能·后端
冬奇Lab15 小时前
Workflow 系列（03）：状态管理——持久化、幂等性与版本绑定
人工智能·工作流引擎
冬奇Lab15 小时前
每日一个开源项目（第146篇）：openpilot - 开源自动驾驶辅助系统，曾在 Consumer Reports 评测中超过特斯拉 Autopilot
人工智能·开源·自动驾驶
热门推荐
012026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf022026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？032026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？04【AI】2026 年具身智能模型和世界模型总结05Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析06Trae国际版与国内版深度测评：AI原生IDE的双生花07飞书长连接_事件订阅（接收消息，审批任务状态变更）082026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？09GitHub 镜像站点102026年AI架构实战：彻底解决OpenAI接口超时与封号，Python调用GPT-5.2/Sora2企业级架构详解（附源码+压测报告）