《AI Agent 技术原理与架构·运行时、协议与系统架构》7.1 上下文组装:系统、任务、记忆、工具

运行时把系统提示、任务规格、记忆片段、工具 schema 组装成一次请求的上下文,token 预算有限,必须按优先级放进:重要的先放,超出预算的低优先级片段被挤出。实验实现优先级组装器,对比预算充足与紧张时的取舍。结论是组装不是拼接,是预算内的优先级排序。

以下片段 token 数、优先级与预算均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。system_policy 600 等数字是讲解用的模型,真实系统的 token 数与窗口按实测配置,但"预算有限时必须按优先级放"这一条不变。

模型一次请求能读的上下文有限。运行时要把系统提示、任务规格、记忆片段、工具 schema 组装成这一次请求——装不下怎么办?答案不是"全部塞进去让模型自己消化",而是预算内的优先级排序:重要的先放,超出预算的低优先级片段被挤出。

组装不是拼接。拼接是"有什么放什么",组装是"该放什么、放不下放弃什么"。这一节把组装变成可判定的算法:每个片段有 token 数和优先级,按优先级降序装进预算。

一次请求的上下文里有什么

一次 Agent 请求的上下文由几类片段组成:

片段内容优先级token
system_policy系统提示、安全策略高600
task_spec任务规格高400
tool_schemas工具定义中1500
memory_recent近期记忆中低300
memory_summary记忆摘要低1200
retrieved_docs检索文档最低5000

优先级决定谁先放。 system_policy 和 task_spec 是这次任务的定义,必须进;tool_schemas 是工具能用的前提;retrieved_docs 虽然信息量大,但优先级最低——预算紧的时候最先被挤出。

组装是预算内的取舍

给定预算,组装算法按优先级降序尝试放进每个片段,放不下就跳过:

预算保留挤出已用
9000(充足)全部 6 个片段无9000
4000(紧张)system_policy、task_spec、tool_schemas、memory_recent、memory_summaryretrieved_docs4000

预算充足时全部放得下;预算紧张时,优先级最低的 retrieved_docs 被挤出——这正是"组装"与"拼接"的区别:拼接是爆掉窗口或超长,组装是显式地决定放弃什么。

为什么宁可挤掉检索文档而不是工具定义?因为工具 schema 是"这次请求能做什么"的前提,缺了模型会幻觉式地调用不存在的工具;检索文档是"可选的信息补充",缺了任务还能做,只是信息少一点。

最小实验:优先级组装器

实验实现按优先级组装器(assemble)与挤出检测(dropped),对比两种预算的取舍。

# file: agp_lab/context_assembly.py | write
# tier: 3
# verify: python3 -m unittest tests.test_context_assembly
"""上下文组装:系统、任务、记忆、工具按优先级进预算。

运行时把系统提示、任务规格、记忆片段、工具 schema 组装成一次
请求的上下文。token 预算有限,必须按优先级放进:重要的先放,
超出预算的低优先级片段被挤出。

本模块实现优先级组装器,并对比预算充足与紧张时的取舍。
"""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any


@dataclass(frozen=True)
class Fragment:
    name: str
    tokens: int
    priority: int  # 越大越重要


def assemble(fragments: list[Fragment], budget: int) -> tuple[list[Fragment], int]:
    """按优先级降序组装,返回(保留片段, 已用 token)。"""
    kept: list[Fragment] = []
    used = 0
    for fragment in sorted(fragments, key=lambda f: (-f.priority, f.name)):
        if used + fragment.tokens <= budget:
            kept.append(fragment)
            used += fragment.tokens
    return kept, used


def dropped(fragments: list[Fragment], budget: int) -> list[str]:
    """返回被挤出预算的片段名(保持原顺序)。"""
    kept, _ = assemble(fragments, budget)
    kept_names = {fragment.name for fragment in kept}
    return [fragment.name for fragment in fragments if fragment.name not in kept_names]


FRAGMENTS: list[Fragment] = [
    Fragment("system_policy", 600, 5),
    Fragment("task_spec", 400, 5),
    Fragment("tool_schemas", 1500, 4),
    Fragment("memory_recent", 300, 3),
    Fragment("memory_summary", 1200, 2),
    Fragment("retrieved_docs", 5000, 1),
]


def demo() -> dict[str, Any]:
    roomy_kept, roomy_used = assemble(FRAGMENTS, 9000)
    tight_kept, tight_used = assemble(FRAGMENTS, 4000)
    return {
        "roomy_kept": [f.name for f in roomy_kept],
        "roomy_used": roomy_used,
        "tight_kept": [f.name for f in tight_kept],
        "tight_used": tight_used,
        "tight_dropped": dropped(FRAGMENTS, 4000),
    }


if __name__ == "__main__":
    for key, value in demo().items():
        print(f"{key}: {value}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.context_assembly

输出:

roomy_kept: ['system_policy', 'task_spec', 'tool_schemas', 'memory_recent', 'memory_summary', 'retrieved_docs']
roomy_used: 9000
tight_kept: ['system_policy', 'task_spec', 'tool_schemas', 'memory_recent', 'memory_summary']
tight_used: 4000
tight_dropped: ['retrieved_docs']

四行输出对应两种预算:

  1. roomy(9000):六个片段全部保留,已用 9000。注意顺序——按优先级降序:system_policy、task_spec(高),tool_schemas(中),memory_recent(中低),memory_summary(低),retrieved_docs(最低)。
  2. tight(4000):保留五个,已用 4000,挤出 retrieved_docs。5000 token 的检索文档在 4000 预算里根本放不下——它不是"被挤出",是从优先级到体量都排最后。

一个值得点破的细节:挤出的顺序与放入的顺序一致,都是优先级。 tight 场景里 system_policy(600)+ task_spec(400)+ tool_schemas(1500)+ memory_recent(300)+ memory_summary(1200)= 4000,刚好用满;retrieved_docs 是唯一在预算外的。组装器用 -priority 排序、逐个尝试装入,保证了"先放重要"这个语义被严格执行。

上下文组装在真实系统里还要回答"片段从哪来"。系统提示来自策略层,任务规格来自请求,记忆片段来自记忆库(见卷二 8),工具 schema 来自注册表(见 6.1)。组装器的输入是这些来源的接口,而不是硬编码的文本。这样每个片段都有明确的拥有者和更新路径,组装器只负责排序和预算。

片段来源更新时机
system_policy策略配置发布时
task_spec用户请求每次请求
tool_schemas工具注册表工具变更时
memory_recent记忆库每次会话
retrieved_docs检索器每次请求

还有一个优先级原则:交互必需的放前面,信息补强的放后面。系统策略和任务规格是"没有它们模型无法正确行动",工具定义是"没有它们无法安全行动",记忆是"有了更好",检索文档是"锦上添花"。组装器按这个优先级排序,正好对应实验里的 priority 值。

组装结果要可审计。每次组装应该能回答"这次请求用了哪些片段、各占多少 token、挤掉了什么"。可审计的组装,让"为什么这次请求表现差"可以定位到上下文层面,而不是笼统归因于模型。

组装还要面对模型之间的窗口差异。同一套组装逻辑,目标模型窗口 8K 和 128K,预算完全不同:8K 窗口下 retrieved_docs 基本进不去,128K 窗口下可以多放。组装器把预算做成模型相关的配置,而不是写死。 切换模型时,组装逻辑不变,预算参数变——这正是把"组装"从拼接中区分出来的又一证据:逻辑与预算分离。

模型窗口system+task+tool可放 docs
8K4000(核心)很少
32K4000(核心)部分
128K4000(核心)大部分

还有一个容易忽略的组装维度:顺序内的稳定性。同一个片段今天排第 2、明天排第 5,模型对上下文的利用会波动。组装器要对同优先级片段给出确定性的排序键(实验里的名称排序),让组装结果可复现——同样的输入,永远组装出同样的上下文。

组装与缓存的接口也要提前定:7.3 的前缀缓存要求前缀稳定,组装器就要把易变的片段(记忆、检索)放在前缀之后、把稳定片段(系统、工具)放在前缀之前。组装顺序不是只服务于模型理解,还服务于缓存命中。

组装还有一个容易被忽略的片段类型:中间结果。多轮 Agent 运行中,上一轮的推理摘要、未完成的子任务状态,往往也要进下一轮上下文。它们优先级介于记忆与工具之间——丢了任务接不上,但有压缩与记忆兜底。中间结果的进与出,是组装器要显式管理的,不能靠对话历史自然累积。

片段优先级丢失后果
推理摘要中思路中断,可重推
子任务状态中子任务需重查
已用工具结果中低可重新调用

组装与检索的协作顺序也要定:先检索再组装,还是先组装后按缺口检索?常用的是"预算充足先装、装不下再按优先级裁检索",也就是 7.1 的挤出机制与检索层配合——挤出某类片段时,检索层重查更相关的替代内容。组装器是消费检索结果的,但它也在约束检索(挤出就是给检索下指令)。

最后,组装要能回放。一次请求的组装结果(放进了什么、挤掉了什么)存成日志,故障复盘时重放组装,判断是组装决策的问题还是内容本身的问题。可回放是"组装可调优"的前提——没有回放,每次表现差异只能归因给"模型随机性"。

组装的失败模式要显式定义:预算装不下、片段来源超时、片段缺失。组装器不能静默地"尽力而为"——要知道装不下了、知道谁没装进去、知道原因是超时还是预算。组装的结果状态(成功/部分/失败)要返回给调用方,而不是只返回一个拼接后的字符串。

组装失败表现处理
预算装不下挤出低优先级记录挤出(正常)
来源超时片段缺失降级或重试
核心片段缺失任务无法定义显式失败

组装还要考虑多模态内容:图片、代码、结构化数据与文本的预算口径不同(token 换算方式不同)。文本 token 好估,图片按像素块估算、代码按语法树估算——预算口径要按片段类型分开算,统一按"字符数"会低估代码、高估文本。

组装的时间维度:何时组装。 一次请求组装一次?还是多轮会话按需增量组装?交互场景每轮都组装(内容在变),批量场景一次组装多次复用。组装时机与缓存(7.3)直接相关——每轮组装则前缀变化频繁,一次组装则前缀稳定可缓存。组装的频率是"信息新鲜度"与"缓存收益"之间的权衡。

组装时机信息新鲜度缓存收益
每轮组装高低(前缀常变)
分阶段组装中中
一次组装复用低高

组装器与多轮会话的衔接:上一轮的组装结果(保留了什么、挤掉了什么)要不要传给下一轮?通常是"会话级状态"(记忆、子任务)持续累积,请求级片段(检索文档)每轮重组装。组装器要区分会话级与请求级片段——混在一起,会话状态会无限膨胀、挤掉每轮的即时信息。

片段生命周期例子处理
会话级记忆、子任务跨轮保留
请求级检索文档、任务规格每轮重组装

架构判据

上下文组装是否合格,用五条判据检查:

判据合格的样子不合格的样子
优先级显式每个片段有明确优先级靠文本拼接顺序碰运气
预算内装入超出预算被显式挤出超长截断或撑爆窗口
核心必保系统/任务/工具不被挤出任务定义被检索文档挤掉
挤出可观测被挤出的片段可追踪放弃哪些靠猜
顺序稳定同优先级片段顺序确定每次组装顺序抖动

判据第三条是组装与拼接的分水岭:核心片段(系统、任务、工具)必须有保底,不能被低优先级的信息片段挤出。 判据第四条提醒:挤出要可观测——调试时能说清"这次请求放弃了哪些文档"。

小结

  • 上下文组装是预算内的优先级排序:重要的先放,超预算的低优先级片段被挤出。
  • 一次请求的上下文由系统、任务、记忆、工具几类片段组成,优先级各异。
  • 工具 schema 是"能做什么"的前提,检索文档是"可选信息";预算紧时挤文档不挤工具。
  • 挤出顺序与优先级一致,且可观测。

阅读导航:上一节:6.3 AG-UI/事件协议与版本兼容 · 下一节:7.2 压缩、摘要与预算分配 。

常见错误与边界

  1. 把组装当拼接。 有什么放什么会撑爆窗口或超长;组装要按预算显式决定放弃什么。
  2. 让低优先级挤掉核心。 检索文档挤掉任务定义,模型就不知道要做什么;核心片段要保底。
  3. 优先级不显式。 靠文本拼接顺序碰运气,顺序一改结果就变;优先级要建模。
  4. 挤出不可观测。 调试时说不清放弃了哪些文档;挤出列表要可追踪。
  5. 只按大小排序。 体量大的不一定优先级低;要按(优先级, 名称)排序,不是按 token 数。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图