以下数字均为教学假设,不构成对任何真实系统或供应商的承诺。条目 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$。但只看这个目标会漏掉一个硬条件:关键条目必须全部进入,否则任务根本不可执行。于是实际要解的是两层问题:
- 可行性:所有 $c_i = 1$ 的条目是否都在 $S$ 中。
- 质量:在可行解中,效用保留率 $\sum_{i \in S} u_i / \sum_{i \in C} u_i$ 是否足够高。
这两层不能合成一个分数。一个方案可以效用很高,却漏掉工具 schema,导致模型知道该做什么但不知道怎么做;也可以关键项齐全,却因为保留了太多低价值历史而挤掉了关键证据的上下文。
| 策略 | 排序依据 | 隐含假设 | 典型失效 |
|---|---|---|---|
| newest | 越新越先保留 | 最近的信息最重要 | 旧但关键的约束被淘汰 |
| utility | 效用从高到低 | 效用可独立比较 | 高效用大条目挤掉多个关键小条目 |
| density | 效用 / token 从高到低 | 单位成本收益最有代表性 | 关键但“低密度”的 schema 被跳过 |
| critical_first | 关键项优先,再按密度 | 关键性可以被显式标注 | 标注错误会直接击穿可行性 |
“淘汰”在这里不是删除数据,而是本次组装不放入上下文。被淘汰的条目仍然可以留在外部存储里,下一轮重新检索、重新摘要或按需加载。把淘汰当成永久删除,会让 Agent 在后续轮次里反复丢失同一类信息。
为什么需要显式优先级
LLM 本身不会告诉你哪条信息关键。它会把提示里的所有内容一视同仁地读一遍,然后在生成时给不同位置不同权重。位置偏差、近因效应和截断共同作用,使得“模型看到了”不等于“模型用上了”。如果组装阶段没有显式优先级,实际优先级就由拼接顺序和窗口截断位置决定,而这两个因素通常没有人负责。
显式优先级至少带来三个好处:
- 可解释:为什么这轮没有带某条历史,可以从事先声明的策略和预算算出来,而不是靠猜。
- 可回归:同一组条目、同一预算、同一策略,应该得到同一个集合;出现差异时能定位到输入变化。
- 可降级:预算不足时,系统知道先牺牲质量还是先牺牲可行性,而不是把截断交给模型。
关键项的标注是这套机制的阿喀琉斯之踵。标多了,预算永远不够;标少了,任务会在最不该失败的地方失败。一个可操作的起点是把“没有它就无法形成合法动作”的条目列为关键:工具 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。它至少要有五件事:
- 条目清单:每个候选条目带来源、token 成本、效用、关键性、时间戳和是否已截断。
- 预算声明:模型窗口、输出预留、系统提示、工具 schema 的固定开销分别计算,剩余部分才是可分配预算。
- 策略与顺序:策略要显式命名并可配置;同一策略在同一输入上必须给出同一结果。
- 淘汰记录:本轮淘汰了哪些条目、原因是什么、下一轮是否可以重新召回。
- 不可行语义:当关键条目装不下时,返回明确的降级状态,而不是静默截断。
对三类负载,侧重点不同。W1 检索问答的上下文以检索片段为主,关键是引用可核对,淘汰记录要能回答“为什么这条证据没进上下文”。W2 代码修复的上下文包含仓库结构、错误日志和工具 schema,关键项更多,预算更大但增长也更快。W3 运维处置的上下文最短,却最不能漏:告警详情、runbook、权限策略和工具 schema 往往都是关键项,一次漏放可能直接导致错误动作。
判据表
| 判据 | 合格的样子 | 不合格的样子 | 验证方式 |
|---|---|---|---|
| 预算可计算 | 固定开销与可分配预算分开声明 | 只写“模型窗口 128k” | 用真实分词器复核总量 |
| 关键项显式 | 关键条目有来源和标注理由 | 靠拼接顺序隐式决定 | 抽查关键项覆盖率 |
| 策略确定 | 同输入同预算同输出 | 每次排序结果不同 | 固定输入回归 |
| 淘汰可解释 | 记录被淘汰条目与原因 | 只保留最终提示 | 失败时能回放组装决策 |
| 不可行可暴露 | 预算不足返回降级状态 | 静默截断末尾 | 构造超预算用例 |
| 位置可检查 | 关键项靠近指令或最新观测 | 关键项埋在长历史中间 | 对照评测 |
小结
- 上下文窗口是预算,不是容器;组装的本质是在成本约束下保留可行性和质量。
- 关键覆盖率是硬约束,效用保留率是软目标;两者不能合成一个分数。
newest用满预算也可能完全不可执行;utility效用最高也可能漏掉关键项。- 密度优先和关键优先通常能在更小预算下达到完整关键覆盖,代价是少量效用。
- 预算真的不够时,要显式暴露不可行,而不是把截断伪装成完成。
- 淘汰是本次不放入,不是永久删除;条目仍应可被重新召回。
- 位置、切分粒度和 token 估计误差都会让“在上下文里”不等于“被用上”。
阅读导航:上一节:9.2 摘要与压缩 · 下一节:10.1 工具选择 。
常见错误与边界
- 把预算使用率当质量指标。 用满窗口只说明成本高,不说明关键信息齐全;先看关键覆盖率,再看效用。
- 把效用和关键性混成一个分数。 关键项漏放会让任务不可执行,效用低只影响质量;硬约束不能被加权平均掉。
- 让拼接顺序决定优先级。 没有显式策略时,实际优先级由代码顺序和截断位置决定,通常无人负责。
- 静默截断。 超预算时直接截掉末尾,会把最新、最关键的观测丢掉;应返回降级状态并记录。
- 把淘汰当删除。 淘汰只是本轮不放入;外部存储和后续召回仍然保留,否则 Agent 会反复丢同一类信息。
- 忽略 token 估计误差。 估算偏小会导致上游截断;固定余量加真实分词器复核比经验系数可靠。
- 只检查“在不在”,不检查“用没用上”。 位置偏差和长上下文中段丢失会让关键条目实际失效,需要单独评测。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。