7.1 框架落地：LangChain 与 LangGraph 等

7.1 框架落地：LangChain 与 LangGraph 等

本节摘要：本节承接高频查询「上下文工程 langchain」。先说清立场：前六章的手艺全部可以裸机实现——ce_budget.py 到 ce_snapshot.py 没有一行依赖框架；框架的价值在别处：把纪律变成默认行为（checkpointer 让每轮状态自动持久化，断点续跑），把轮子变成预置组件（消息裁剪、摘要节点、检索件），把孤岛连成生态（LangMem、观测工具）。坐标系是 LangChain 的四操作分类（官方）：write（把信息存到窗口外）对应 4.2 写入策略，落点是 store 写入与 LangMem；select（按需取回）对应 4.2 召回与 5.1 检索，落点是检索器与按需工具加载；compress（缩减占用）对应 6.1 压缩，落点是裁剪与摘要节点；isolate（子上下文隔离）对应 3.2 子 Agent，落点是子图与 Deep Agents。附 ce_graph.py 四操作同框示意、Deep Agents 与记忆生态（Mem0 / Zep / Letta，社区）一段、选型五问。所有组件细节以官方文档为准，事实基准 2026-09。

学习目标

阅读完本节，你应当能够：

1. 说出框架相对裸机的三条价值与一条不豁免。
2. 默写四操作 × 本书章节 × 框架组件的三方映射表。
3. 把 LangGraph 的 state / store / runtime context 翻译成四成分语言。
4. 在 ce_graph.py 里指出四操作各自的落点。
5. 用选型五问为自己的项目做框架决策。

一、裸机之后，为什么还要框架

第 2~6 章的每一件工具——分配表、驱逐器、分层记忆、片段组装、压缩、快照——都是纯 Python 就能落地的裸机手艺（各节的 ce_*.py 就是证据）。那框架解决什么？三条：

1. 默认行为：裸机世界里"每轮快照""历史持久化"全靠自觉，忘了就是 6.2 节说的盲调现场；图框架（以 LangGraph 为代表）把状态放进 checkpointer，每个节点执行后自动落盘——断点续跑、时间旅行调试、失败重试从纪律变成默认（官方）。
2. 预置组件：消息裁剪、摘要生成、检索接入这些轮子，框架有现成件与参考实现——你写的是配置与策略参数，不是从零的管道。
3. 生态：记忆管理（LangMem）、观测、部署周边与框架同轴，集成成本低于拼装散件。

但有一条不豁免：预算表怎么分、驱逐顺序怎么排、写入门槛怎么定、片段摆哪里——决策层框架一概不替你做。框架把你的决策变成默认行为，不能替你产生决策。读完本节的检验标准：拿任何一份框架文档，先把它的组件翻译成四成分（1.2 节），再套预算恒等式——两步之后它不再是黑盒。

二、四操作 × 本书章节 × 框架组件

LangChain 把 Agent 的上下文工程策略归为四族操作：write、select、compress、isolate（官方）。这张三方映射表是本节的核心：

读表两个要点：其一，四操作是"动词"，四成分是"名词"——操作作用于成分（write 作用于记忆、select 取回记忆与素材、compress 作用于历史），两套语言合起来才是完整坐标系。其二，映射不是一对一——同一操作在不同成分上有不同形态：select 在记忆上是召回（4.2），在素材上是检索（5.1），在工具上是按需注入（3.2 节分阶段注入）。

三、LangGraph 三件套翻译成四成分

以 LangGraph 为例做一次完整翻译（4.1 节翻译过前两件，此处补全）：

注意最后一行的微妙之处：runtime context 是框架对"常驻层"的实现——3.1 节说过，动态信息禁入系统提示；框架侧同理，把静态配置与动态状态分开注入，正是 1.2 节三问在框架世界的投影。检索接 store 或外部索引，供给结果按素材对待（4.1 口诀）。

四、ce_graph.py：四操作同框

# ce_graph.py —— 四操作在一个 Agent 循环里的落点（写法示意，以官方文档为准）
# 概念对应（示意）：state ≈ thread 内状态（checkpointer 持久化）；store ≈ 跨 thread
# 长期记忆；compress 步 ≈ 裁剪/摘要节点；subagent ≈ 子图隔离。

def est_tokens(text: str) -> int:                     # 与 ce_budget.py 同口径
    cn = sum(1 for ch in text if "\u4e00" <= ch <= "\u9fff")
    return cn + (len(text) - cn) // 4

HEAVY_TOOLS = {"audit_order_history", "analyze_logs"}  # 重活：isolate 的候选（3.2）

def run_agent(state: dict, store: dict, model, tools: dict, cap: int) -> str:
    """state 形如 {"query": str, "history": [str], "brief": str}；
    model 为返回 {"text", "tool", "tool_args"} 的占位接口（示意）。"""
    # ── select（记忆侧）：会话开始按需召回，注入记忆区块（4.2）──
    for m in recall(store, state["query"]):
        state["history"].insert(0, "[记忆] " + m["text"])

    while True:
        ctx = assemble(state)                          # 组装：2.1 分配 + 2.2 位置
        if est_tokens(ctx) > cap:
            evict(state)                               # 前置防线：驱逐（2.1 四顺位）
            ctx = assemble(state)
        if est_tokens(ctx) > cap:                      # ── compress：结构性超支 ──
            state["brief"] = summarize(state)          #   6.1 五栏任务简报；原文外存
            ctx = assemble(state)

        msg = model(ctx, tools=visible_tools(tools, state))   # select（工具侧）
        if msg.get("tool"):
            if msg["tool"] in HEAVY_TOOLS:             # ── isolate：独立窗口干重活 ──
                result = run_subagent(msg["tool"], msg["tool_args"])
                state["history"].append(f"[子Agent] {msg['tool']} 结论：{result}")
            else:                                      #   主窗口只收摘要（3.2）
                state["history"].append(f"[工具] {msg['tool']}: {run_tool(tools, msg)}")
            continue
        maybe_write(store, state)                      # ── write：门槛三问后入库（4.2）
        return msg["text"]

# 占位实现（示意）：生产中分别由检索器 / 摘要节点 / 子图 / LangMem 类组件承担
def assemble(state: dict) -> str: ...                  # 2.1 分配表 + 2.2 位置模板
def evict(state: dict) -> None: ...                    # 2.1 驱逐四顺位 + pinned 保护
def summarize(state: dict) -> str: ...                 # 6.1 五栏任务简报
def recall(store: dict, query: str) -> list: ...       # 4.2 预算内召回
def visible_tools(tools: dict, state: dict) -> dict: ...  # 3.2 分阶段注入工具子集
def run_subagent(name: str, args: dict) -> str: ...    # isolate：独立窗口只回结论
def run_tool(tools: dict, msg: dict) -> str: ...       # 普通工具执行
def maybe_write(store: dict, state: dict) -> None: ... # 4.2 写入门槛三问
​

读这份代码的方式不是抄它，而是看结构：循环里每一步都能在前面某章找到出处——召回来自 4.2、驱逐来自 2.1、简报来自 6.1、隔离来自 3.2、门控写入来自 4.2。框架的 Agent 循环本质上就是把这张出处表工程化；你在框架里配置的每个参数（保留几轮原文、摘要触发水位、子 Agent 回传格式），都是前六章某张表里的一个数字。

五、Deep Agents 与记忆生态

Deep Agents（Anthropic 生态的深度任务 SDK）把三件本书讲过的手艺做成了内置原语（官方，2026-01）：offloading（把上下文卸载到外部文件——6.1 节的"压缩改变内容的地址"）、summarization（子任务级别的摘要压缩——6.1 分级压缩）、filesystem abstraction（给 Agent 一个虚拟文件系统当工作记忆——4.2 节结构化笔记的基建）。它的存在印证了本书的判断：上下文工程的原语正在从"自家手艺"沉淀为"框架默认"。

记忆侧的第三方生态（社区，选型时以各自官方文档为准）：Mem0——抽取式记忆层，自动从对话抽取事实入库（4.2 写入门槛的托管实现）；Zep——时间感知的记忆服务，强调事实的新旧与时效（4.2 冲突与过期的一派思路）；Letta（前身 MemGPT）——把分层记忆做成操作系统式的核心，Agent 自主管理自己的记忆分页（4.1 三层地图的产品化）。三者的共同点：替你实现记忆层，但什么值得记、召回给多少预算，仍要你按第 4 章的决策层配置。完整速查见附录 B。

⚠️ 生态演进出名地快：本书事实基准 2026-09，上述组件的接口与能力到你看时大概率已变。不变的仍然是那套语言——四成分、预算恒等式、四操作；拿着它们读任何新框架的文档，都能在半小时内画出自己的映射表。

六、选型五问

1. 要持久化与断点续跑吗（长任务、高价值会话）→ 图框架 + checkpointer；一次性短问答用不上。
2. 记忆要跨会话吗（4.1 第二层非空）→ store / LangMem / Mem0 系；只活在单会话内就先别引。
3. 素材主体是什么（文档库为主偏检索侧选型，代码库为主看 repo map / agentic 检索配套——实现深潜见《语义代码检索》第 6 章）。
4. 压缩策略要多定制（标准裁剪够用选预置件；五栏简报这类定制形态自己写节点，6.1 的模板直接搬）。
5. 团队已有栈是什么（集成成本常常压倒功能差异；ce_*.py 系列证明裸机可行，引入框架的每一步都该换来对应的默认行为）。

五问的共同前提：先有 2.1 的预算表与驱逐顺序，再选框架——决策层不带着走，框架只会把错误的决定执行得更快。

本节要点回顾

1. 框架三价值一不豁免：默认行为、预置组件、生态；决策（预算、驱逐、门槛、摆位）永远是你的。
2. 四操作映射表：write→写入（4.2）→store/LangMem；select→召回与检索（4.2/5.1）→检索器/按需工具；compress→压缩（6.1）→裁剪/摘要/offloading；isolate→子 Agent（3.2）→子图/Deep Agents。
3. 动词与名词：四操作是动词、四成分是名词，两套语言合成完整坐标系；select 在记忆、素材、工具上各有形态。
4. LangGraph 翻译：state=会话内记忆、store=跨会话记忆、runtime context=常驻层的一部分。
5. Deep Agents（官方）：offloading / summarization / filesystem abstraction 是 6.1 与 4.2 手艺的内置化。
6. 选型五问：持久化、跨会话、素材主体、压缩定制度、已有栈——先有决策层再选框架。

语言统一了：你的每件手艺在框架世界里都有了名字。现在做一次完整合成——从一个客服 Agent 的需求出发，把四成分、预算表、驱逐顺序、位置效应、压缩与快照全部用上，走完从零到装配图的全流程。这是全书最后一节。