LangGraph 提供三类"连线"能力，今天全部覆盖：

先看普通边。源码在 graph/state.py:915，这里裁掉文档字符串看核心：

# graph/state.py:915
def add_edge(self, start_key: str | list[str], end_key: str) -> Self:
    if self.compiled:
        logger.warning("Adding an edge to a graph that has already been compiled. ...")

    if isinstance(start_key, str):                       # 单个起点
        if start_key == END:
            raise ValueError("END cannot be a start node")     # ← 边界①
        if end_key == START:
            raise ValueError("START cannot be an end node")     # ← 边界②
        # 只对非 StateGraph 生效的一条老校验（这里略）
        self.edges.add((start_key, end_key))             # ← 核心：存进 set
        return self
    # ...（start_key 是 list 的情况见 L03）

add_edge 的第一个参数还能是一个列表——表示"这些节点全部完成后，才执行终点"。看 graph/state.py:956：

# graph/state.py:956
for start in start_key:                        # start_key 是 list
    if start == END:
        raise ValueError("END cannot be a start node")
    if start not in self.nodes:
        raise ValueError(f"Need to add_node `{start}` first")   # ← 边界：节点得先存在
if end_key == START:
    raise ValueError("START cannot be an end node")
if end_key != END and end_key not in self.nodes:
    raise ValueError(f"Need to add_node `{end_key}` first")

self.waiting_edges.add((tuple(start_key), end_key))     # ← 存进另一个 set

条件边是控制流的灵魂。源码 graph/state.py:969，核心逻辑其实只有最后几行：

# graph/state.py:969
def add_conditional_edges(self, source: str, path, path_map=None) -> Self:
    if self.compiled:
        logger.warning("Adding an edge to a graph that has already been compiled. ...")

    # find a name for the condition
    path = coerce_to_runnable(path, name=None, trace=True)     # ① 把普通函数包成 Runnable
    name = path.name or "condition"                            # ② 给这条分支起个名
    if name in self.branches[source]:                          # ③ 同名分支不能重复挂
        raise ValueError(
            f"Branch with name `{path.name}` already exists for node `{source}`"
        )
    self.branches[source][name] = BranchSpec.from_path(path, path_map, True)  # ④ 存！
    if schema := self.branches[source][name].input_schema:     # ⑤ 顺手登记推断出的输入 schema
        self._add_schema(schema)
    return self

def route(state) -> str:
    return "tools" if state["messages"][-1].tool_calls else "end"

builder.add_conditional_edges("agent", route, {"tools": "tools", "end": END})

条件边不像普通边塞进一个扁平 set，而是存进一个两层字典。声明在 graph/state.py:203：

# graph/state.py:201-203
edges: set[tuple[str, str]]                       # 普通边：扁平集合
nodes: dict[str, StateNodeSpec[Any, ContextT]]
branches: defaultdict[str, dict[str, BranchSpec]] # 条件边：源节点 → {分支名 → BranchSpec}

再看被存进去的 BranchSpec 本体，它是个 NamedTuple，graph/_branch.py:83：

# graph/_branch.py:83
class BranchSpec(NamedTuple):
    path: Runnable[Any, Hashable | list[Hashable]]   # 路由函数（已归一成 Runnable）
    ends: dict[Hashable, str] | None                 # 返回值 → 目标节点名 的翻译表
    input_schema: type[Any] | None = None            # 路由函数想读的状态 schema

把今天三种连线放一起，从"何时决定、几个下游、等不等"三个维度对照：

builder.add_edge(START, "agent")                       # 固定入口（普通边）
builder.add_conditional_edges("agent", route, {          # 看有没有工具调用（条件边）
    "tools": "tools", "end": END,
})
builder.add_edge("tools", "agent")                       # 工具跑完固定回 agent（普通边）

✋ 10 分钟动手

# 1. 读 add_edge 与 add_conditional_edges 全文
sed -n '915,1017p' libs/langgraph/langgraph/graph/state.py

# 2. 看三个容器的类型声明
sed -n '200,210p' libs/langgraph/langgraph/graph/state.py

# 3. 看 BranchSpec 定义
sed -n '83,120p' libs/langgraph/langgraph/graph/_branch.py

# 4. 亲手建个带三种边的小图，打印它的容器
python - <<'PY'
from langgraph.graph import StateGraph, START, END
from typing import TypedDict
class S(TypedDict): x: int
g = StateGraph(S)
g.add_node("a", lambda s: s); g.add_node("b", lambda s: s)
g.add_edge(START, "a")
g.add_conditional_edges("a", lambda s: "b" if s["x"]>0 else "end", {"b":"b","end":END})
print("edges:", g.edges)
print("branches:", dict(g.branches))
PY