《AI Agent 技术原理与架构·决策、记忆与学习》9.3 上下文预算:分配、优先级与淘汰

上下文窗口是有限预算,每个条目都有 token 成本、效用和关键性。本节把上下文组装形式化为带硬约束的背包问题,用四种策略在四个预算档位上比较关键覆盖率与效用保留率,说明为什么“效用最高”不等于“任务可执行”,并给出分配、淘汰、降级三层可检查的架构判据。

以下数字均为教学假设,不构成对任何真实系统或供应商的承诺。条目 token 数、效用分值与预算档位只用于展示分配策略的计算方式,不代表任何生产环境的最优配置。

上下文窗口不是一个“能装多少字”的容器,而是一份有价格的预算。工具 schema、检索片段、对话历史、任务状态、策略约束都在竞争同一块空间;多放一段历史,就可能少放一条能让任务继续的关键证据。真正的问题不是“怎么塞满”,而是“在装不下的时候,先保什么、后丢什么、丢了以后怎么解释”。

这一节把上下文组装写成一个小型背包问题,比较四种常见策略:按新近、按效用、按效用密度、关键项优先。重点不在求出某个最优解,而在暴露一个工程上经常被忽略的区分:效用最高的上下文,不一定是任务能继续执行的上下文。

从“拼提示”到预算分配

设上下文条目集合为 $C$,每个条目 $i$ 有三个属性:token 成本 $t_i$、任务效用 $u_i$、是否关键 $c_i \in {0,1}$。给定预算 $B$,分配就是选一个子集 $S \subseteq C$,满足:

$$
\sum_{i \in S} t_i \le B
$$

在这个约束下,通常希望最大化 $\sum_{i \in S} u_i$。但只看这个目标会漏掉一个硬条件:关键条目必须全部进入,否则任务根本不可执行。于是实际要解的是两层问题:

  1. 可行性:所有 $c_i = 1$ 的条目是否都在 $S$ 中。
  2. 质量:在可行解中,效用保留率 $\sum_{i \in S} u_i / \sum_{i \in C} u_i$ 是否足够高。

这两层不能合成一个分数。一个方案可以效用很高,却漏掉工具 schema,导致模型知道该做什么但不知道怎么做;也可以关键项齐全,却因为保留了太多低价值历史而挤掉了关键证据的上下文。

策略排序依据隐含假设典型失效
newest越新越先保留最近的信息最重要旧但关键的约束被淘汰
utility效用从高到低效用可独立比较高效用大条目挤掉多个关键小条目
density效用 / token 从高到低单位成本收益最有代表性关键但“低密度”的 schema 被跳过
critical_first关键项优先,再按密度关键性可以被显式标注标注错误会直接击穿可行性

“淘汰”在这里不是删除数据,而是本次组装不放入上下文。被淘汰的条目仍然可以留在外部存储里,下一轮重新检索、重新摘要或按需加载。把淘汰当成永久删除,会让 Agent 在后续轮次里反复丢失同一类信息。

为什么需要显式优先级

LLM 本身不会告诉你哪条信息关键。它会把提示里的所有内容一视同仁地读一遍,然后在生成时给不同位置不同权重。位置偏差、近因效应和截断共同作用,使得“模型看到了”不等于“模型用上了”。如果组装阶段没有显式优先级,实际优先级就由拼接顺序和窗口截断位置决定,而这两个因素通常没有人负责。

显式优先级至少带来三个好处:

  1. 可解释:为什么这轮没有带某条历史,可以从事先声明的策略和预算算出来,而不是靠猜。
  2. 可回归:同一组条目、同一预算、同一策略,应该得到同一个集合;出现差异时能定位到输入变化。
  3. 可降级:预算不足时,系统知道先牺牲质量还是先牺牲可行性,而不是把截断交给模型。

关键项的标注是这套机制的阿喀琉斯之踵。标多了,预算永远不够;标少了,任务会在最不该失败的地方失败。一个可操作的起点是把“没有它就无法形成合法动作”的条目列为关键:工具 schema、权限与策略约束、当前任务的目标与验收条件。历史对话、示例、背景资料通常不是关键项,它们影响质量,但不影响动作是否合法。

最小实验:四种策略、四个预算

实验使用一次 W3 告警处置可能出现的 8 个条目,总成本 6000 token,总效用 65,其中 4 个被标为关键。预算取 1500、3000、4500、6000 四档,分别对应用户消息、工具返回、检索片段和历史的典型占比。所有策略都是贪心:按声明顺序尝试放入,装不下就跳过,不拆分条目。

这个实验刻意做得很小,因为它要验证的不是“哪种策略最好”,而是“不同策略在同一个预算下会牺牲什么”。真实的 token 计数、效用评估和关键性标注都更复杂,但决策结构是一样的。

# file: agp_lab/context_priority.py | write
# tier: 3
# verify: python3 -m unittest tests.test_context_priority
"""上下文预算分配:优先级、淘汰与关键项保留。

把一次上下文组装看成带预算的背包:每个条目有 token 成本、效用和是否
关键。四种策略分别是:按新近、按效用、按效用密度、关键项优先。实验比较
同一组条目在四个预算档位下的关键覆盖率与效用保留率。
"""
from __future__ import annotations

from dataclasses import dataclass


@dataclass(frozen=True)
class Item:
    name: str
    tokens: int
    utility: float
    critical: bool = False


@dataclass(frozen=True)
class Plan:
    strategy: str
    kept: tuple[str, ...]
    dropped: tuple[str, ...]
    tokens: int
    utility: float
    critical_coverage: float
    utility_ratio: float


STRATEGIES = ("newest", "utility", "density", "critical_first")

# 一次 W3 告警处置可能的上下文条目;数字为教学设定。
CONTEXT = (
    Item("alert_detail", 400, 10.0, critical=True),
    Item("runbook", 800, 12.0, critical=True),
    Item("tool_schema", 600, 8.0, critical=True),
    Item("policy", 300, 10.0, critical=True),
    Item("service_owner", 200, 6.0),
    Item("metrics", 1000, 7.0),
    Item("past_incident", 1200, 9.0),
    Item("chat_history", 1500, 3.0),
)

TOTAL_TOKENS = sum(item.tokens for item in CONTEXT)
TOTAL_UTILITY = sum(item.utility for item in CONTEXT)
TOTAL_CRITICAL = sum(1 for item in CONTEXT if item.critical)


def order_items(items: tuple[Item, ...], strategy: str) -> list[Item]:
    """按策略给出贪心选择顺序;顺序本身就是优先级声明。"""
    if strategy == "newest":
        return list(reversed(items))
    if strategy == "utility":
        return sorted(items, key=lambda item: (-item.utility, item.name))
    if strategy == "density":
        return sorted(items, key=lambda item: (-item.utility / item.tokens, item.name))
    if strategy == "critical_first":
        return sorted(
            items,
            key=lambda item: (not item.critical, -item.utility / item.tokens, item.name),
        )
    raise ValueError(f"未知策略: {strategy}")


def allocate(items: tuple[Item, ...], budget: int, strategy: str) -> Plan:
    """按顺序装入条目,装不下就跳过;返回保留与淘汰的完整记录。"""
    if budget < 0:
        raise ValueError("budget 不能为负")
    kept: list[Item] = []
    used = 0
    for item in order_items(items, strategy):
        if item.tokens <= budget - used:
            kept.append(item)
            used += item.tokens
    kept_names = tuple(item.name for item in kept)
    critical_kept = sum(1 for item in kept if item.critical)
    total_utility = sum(item.utility for item in items)
    return Plan(
        strategy=strategy,
        kept=kept_names,
        dropped=tuple(item.name for item in items if item.name not in kept_names),
        tokens=used,
        utility=sum(item.utility for item in kept),
        critical_coverage=critical_kept / TOTAL_CRITICAL,
        utility_ratio=sum(item.utility for item in kept) / total_utility,
    )


def sweep(
    items: tuple[Item, ...] = CONTEXT,
    fractions: tuple[float, ...] = (0.25, 0.5, 0.75, 1.0),
    strategies: tuple[str, ...] = STRATEGIES,
) -> list[Plan]:
    """在每个预算档位上跑完所有策略。"""
    total = sum(item.tokens for item in items)
    plans: list[Plan] = []
    for fraction in fractions:
        if not 0.0 <= fraction <= 1.0:
            raise ValueError("fraction 必须在 [0, 1] 内")
        budget = int(total * fraction)
        for strategy in strategies:
            plans.append(allocate(items, budget, strategy))
    return plans


if __name__ == "__main__":
    print(f"total_tokens={TOTAL_TOKENS} total_utility={TOTAL_UTILITY:.0f}")
    print(f"{'budget':<8}{'strategy':<16}{'tokens':>7}{'critical':>10}{'utility':>9}")
    for budget in (1500, 3000, 4500, 6000):
        for strategy in STRATEGIES:
            plan = allocate(CONTEXT, budget, strategy)
            print(
                f"{budget:<8}{strategy:<16}{plan.tokens:>7}"
                f"{plan.critical_coverage:>10.2f}{plan.utility_ratio:>9.2f}"
            )

运行:

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

输出:

total_tokens=6000 total_utility=65
budget  strategy         tokens  critical  utility
1500    newest             1500      0.00     0.05
1500    utility            1500      0.75     0.49
1500    density            1500      0.75     0.52
1500    critical_first     1500      0.75     0.49
3000    newest             2900      0.00     0.28
3000    utility            2900      0.75     0.72
3000    density            2300      1.00     0.71
3000    critical_first     2300      1.00     0.71
4500    newest             4200      0.25     0.54
4500    utility            4500      1.00     0.95
4500    density            4500      1.00     0.95
4500    critical_first     4500      1.00     0.95
6000    newest             6000      1.00     1.00
6000    utility            6000      1.00     1.00
6000    density            6000      1.00     1.00
6000    critical_first     6000      1.00     1.00

这张表最重要的不是最后一行,而是 3000 那一档。newest 保留了 2900 token,看起来“几乎用满”,但关键覆盖率是 0:它把最近的历史和指标都带上了,却一条关键条目都没有。utility 的关键覆盖率是 0.75,效用保留率 0.72;它为了两个高效用大条目,挤掉了 tool_schema。density 和 critical_first 只用了 2300 token,关键覆盖率就是 1.00,效用保留率 0.71。

这里出现了三个反直觉但很重要的结论:

  • 用满预算不等于准备好。 newest 在 3000 档用了 2900 token,却完全不可执行。预算使用率是一个成本指标,不是质量指标。
  • 效用最大化可能牺牲可行性。 utility 的效用保留率最高,但漏掉了一个关键条目。只要“关键项必须全在”是硬约束,这个解就不可接受。
  • 好策略可以更省。 density 和 critical_first 用更少的 token 达到了完整的关键覆盖,代价是效用保留率低了一个百分点。这个交换通常是值得的。

在 1500 档,所有非 newest 策略的关键覆盖率都只有 0.75。这不是策略失败,而是预算真的不够:4 个关键条目合计 2100 token,1500 的预算无论如何装不下。此时正确的行为不是继续优化排序,而是显式暴露不可行:要么扩容,要么摘要关键条目,要么向用户/上游请求更多信息。把不可行伪装成“已经尽力”,是上下文组装里最危险的失败模式。

边界与失败模式

这个模型有三类边界,工程上必须分别处理。

第一类是成本估计误差。token 计数依赖分词器、消息格式和工具 schema 的序列化方式;估算偏小会导致实际请求被上游截断,而截断通常发生在末尾,正好是最近、最可能关键的内容。可靠的做法是留出固定余量,并在发送前用真实分词器复核,而不是相信字符数除以某个常数。

第二类是效用与关键性标注误差。效用分往往来自启发式或模型自评,容易高估“看起来相关”的长文档,低估短小的约束。关键性标注则更危险:漏标一个权限约束,Agent 可能生成一个格式正确但会被拒绝的调用;错标一堆历史为关键,预算会被迅速耗尽。标注本身需要版本化和回归测试。

第三类是动态性。多轮任务里,条目集合和预算都在变:工具返回会新增观测,用户会追加约束,摘要会替换原始片段。一次静态分配不够,需要每轮重新计算,并保留“上一轮保留了什么、这一轮为什么变化”的记录。否则一旦任务失败,你无法判断是检索没召回、组装没保留,还是模型没用上。

还有两个容易被忽略的边界:

  • 条目不可拆分。一个 1200 token 的文档即使只有一段相关,也只能整段放入或整段淘汰。现实系统通常先做片段级切分和摘要,再进入预算分配;切分粒度本身会影响可行解。
  • 位置影响使用。同样进入上下文的两条信息,放在开头、中间和结尾的效果可能不同。预算分配解决了“在不在”,没有解决“模型用不用得上”。关键条目应尽量靠近任务指令或最近一轮观测,并在评测里单独检查。

把预算分配落到架构

上下文预算应该是一个独立组件,而不是散落在提示拼接代码里的若干 if。它至少要有五件事:

  1. 条目清单:每个候选条目带来源、token 成本、效用、关键性、时间戳和是否已截断。
  2. 预算声明:模型窗口、输出预留、系统提示、工具 schema 的固定开销分别计算,剩余部分才是可分配预算。
  3. 策略与顺序:策略要显式命名并可配置;同一策略在同一输入上必须给出同一结果。
  4. 淘汰记录:本轮淘汰了哪些条目、原因是什么、下一轮是否可以重新召回。
  5. 不可行语义:当关键条目装不下时,返回明确的降级状态,而不是静默截断。

对三类负载,侧重点不同。W1 检索问答的上下文以检索片段为主,关键是引用可核对,淘汰记录要能回答“为什么这条证据没进上下文”。W2 代码修复的上下文包含仓库结构、错误日志和工具 schema,关键项更多,预算更大但增长也更快。W3 运维处置的上下文最短,却最不能漏:告警详情、runbook、权限策略和工具 schema 往往都是关键项,一次漏放可能直接导致错误动作。

判据表

判据合格的样子不合格的样子验证方式
预算可计算固定开销与可分配预算分开声明只写“模型窗口 128k”用真实分词器复核总量
关键项显式关键条目有来源和标注理由靠拼接顺序隐式决定抽查关键项覆盖率
策略确定同输入同预算同输出每次排序结果不同固定输入回归
淘汰可解释记录被淘汰条目与原因只保留最终提示失败时能回放组装决策
不可行可暴露预算不足返回降级状态静默截断末尾构造超预算用例
位置可检查关键项靠近指令或最新观测关键项埋在长历史中间对照评测

小结

  • 上下文窗口是预算,不是容器;组装的本质是在成本约束下保留可行性和质量。
  • 关键覆盖率是硬约束,效用保留率是软目标;两者不能合成一个分数。
  • newest 用满预算也可能完全不可执行;utility 效用最高也可能漏掉关键项。
  • 密度优先和关键优先通常能在更小预算下达到完整关键覆盖,代价是少量效用。
  • 预算真的不够时,要显式暴露不可行,而不是把截断伪装成完成。
  • 淘汰是本次不放入,不是永久删除;条目仍应可被重新召回。
  • 位置、切分粒度和 token 估计误差都会让“在上下文里”不等于“被用上”。

阅读导航:上一节:9.2 摘要与压缩 · 下一节:10.1 工具选择 。

常见错误与边界

  1. 把预算使用率当质量指标。 用满窗口只说明成本高,不说明关键信息齐全;先看关键覆盖率,再看效用。
  2. 把效用和关键性混成一个分数。 关键项漏放会让任务不可执行,效用低只影响质量;硬约束不能被加权平均掉。
  3. 让拼接顺序决定优先级。 没有显式策略时,实际优先级由代码顺序和截断位置决定,通常无人负责。
  4. 静默截断。 超预算时直接截掉末尾,会把最新、最关键的观测丢掉;应返回降级状态并记录。
  5. 把淘汰当删除。 淘汰只是本轮不放入;外部存储和后续召回仍然保留,否则 Agent 会反复丢同一类信息。
  6. 忽略 token 估计误差。 估算偏小会导致上游截断;固定余量加真实分词器复核比经验系数可靠。
  7. 只检查“在不在”,不检查“用没用上”。 位置偏差和长上下文中段丢失会让关键条目实际失效,需要单独评测。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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