把前 18 天学的东西回顾一下：StateGraph 描述"有哪些节点、边怎么连、状态长什么样"，但它只是一份声明。真正让图"动起来"——决定每一轮跑哪些节点、怎么并行、写入怎么合并、什么时候停——是另一套完全独立的代码，位于 libs/langgraph/langgraph/pregel/。

BSP 全称 Bulk Synchronous Parallel（批量同步并行），源自 Google 处理超大图（比如全网页链接图）的 Pregel 论文。LangGraph 直接借用了这个名字和模型。核心一句话：计算被切成一个个"超步（super-step）"，每个超步内部所有活跃节点并行跑，跑完统一同步一次，再进下一步。

Pregel 类的 docstring 把这个模型写得清清楚楚（main.py:461-477）：

# main.py:461 —— Pregel 类文档，逐字翻译在下面
# Pregel organizes the execution of the application into multiple steps,
# following the **Pregel Algorithm**/**Bulk Synchronous Parallel** model.
#
# Each step consists of three phases:
#  - Plan:  决定这一步要跑哪些 actor（节点）
#  - Execution: 并行执行所有选中的 actor，直到全部完成 / 其一失败 / 超时
#               —— 期间，channel 更新对 actor 不可见，要等到下一步
#  - Update: 用本步 actor 写出的值，更新 channel
#
# Repeat until no actors are selected for execution,
# or a maximum number of steps is reached.

把 docstring 里那三个阶段翻译成"这一步引擎具体在忙什么"，并预告后面几天分别讲哪块：

而把这三阶段串成循环、反复跑的那个"主发条"，是 _loop.py 的 PregelLoop.tick()（Day 20 主讲）。今天只需记住这张表——它是整个阶段 4 的地图。

Pregel 世界只有两种东西，docstring 开头就点明了（main.py:458-460）：

# main.py:458
# Pregel combines **actors** and **channels** into a single application.
# **Actors** read data from channels and write data to channels.

docstring 还列了内置 channel 类型（main.py:496-512）：LastValue（默认，存最后一个值）、Topic（发布订阅/累积列表）、Context（管理外部资源生命周期）、BinaryOperatorAggregate（用二元运算累积，如 operator.add 求和）。

现在打开 Pregel 类本体，看它到底持有哪些字段（main.py:705-756，裁剪核心）：

class Pregel(...):                              # main.py:450
    nodes: dict[str, PregelNode]               # 705 所有节点（actor），name -> PregelNode
    channels: dict[str, BaseChannel | ...]     # 707 所有通道，name -> Channel
    stream_mode: StreamMode = "values"         # 709 默认流式模式
    input_channels: str | Sequence[str]        # 725 输入写进哪些 channel（如 __start__）
    output_channels: str | Sequence[str]       # 716 从哪些 channel 读最终输出
    stream_channels: str | Sequence[str] | None = None  # 718 流式时读哪些 channel
    interrupt_before_nodes: All | Sequence[str]         # 723 静态断点（Day 43）
    interrupt_after_nodes: All | Sequence[str]          # 721
    step_timeout: float | None = None          # 727 单个超步的墙钟超时（Day 20）
    checkpointer: Checkpointer = None          # 733 存档器（阶段 6）
    store: BaseStore | None = None             # 736 长期记忆（Day 40）
    retry_policy: Sequence[RetryPolicy] = ()   # 742 全局重试策略（Day 25）
    trigger_to_nodes: Mapping[str, Sequence[str]]       # 755 反查表：channel -> 订阅它的节点

平时你都用 StateGraph，看不到 Pregel 长什么样。docstring 里给了一个不用 StateGraph、直接手搓 Pregel的例子（main.py:527-553），最能暴露引擎的本来面目：

# main.py:527
from langgraph.channels import EphemeralValue
from langgraph.pregel import Pregel, NodeBuilder

node1 = (
    NodeBuilder().subscribe_only("a")   # 订阅 channel "a"（读输入）
    .do(lambda x: x + x)                # 干活：把输入翻倍
    .write_to("b")                      # 把结果写到 channel "b"
)

app = Pregel(
    nodes={"node1": node1},
    channels={
        "a": EphemeralValue(str),       # 两个通道
        "b": EphemeralValue(str),
    },
    input_channels=["a"],               # 输入进 "a"
    output_channels=["b"],              # 从 "b" 取输出
)

app.invoke({"a": "foo"})                # -> {'b': 'foofoo'}

把 L06 反过来想：你写的 StateGraph，.compile() 之后其实就返回了一个 Pregel 的子类实例（CompiledStateGraph）。对照一下你熟悉的写法与引擎字段的关系：

验证一下也很简单——编译产物就是个 Pregel：

from langgraph.graph import StateGraph
g = StateGraph(dict)
g.add_node("double", lambda s: {"x": s["x"] * 2})
g.set_entry_point("double")
app = g.compile()

type(app).__mro__      # 里面能看到 Pregel —— 编译产物是 Pregel 子类
app.nodes.keys()       # dict_keys(['__start__', 'double'])  ← 多了个内部起点节点
app.channels.keys()    # 你的状态字段都变成了 channel

✋ 10 分钟动手

# 1. 读 Pregel 类的 BSP 文档（三阶段就在这里）
sed -n '450,477p' libs/langgraph/langgraph/pregel/main.py

# 2. 看 Pregel 到底有哪些字段
sed -n '705,756p' libs/langgraph/langgraph/pregel/main.py

# 3. Python 里验证"编译产物就是 Pregel"
python -c "
from langgraph.graph import StateGraph
g = StateGraph(dict); g.add_node('d', lambda s: {'x': s['x']*2})
g.set_entry_point('d'); app = g.compile()
print([c.__name__ for c in type(app).__mro__])
print('nodes:', list(app.nodes)); print('channels:', list(app.channels))
"