大模型上下文窗口管理策略

可视化演示

动态演示大模型上下文窗口管理策略的核心机制，通过入门/进阶/实战/优化四种模式展示关键概念与交互流程。

窗口分配策略

出发前，老练的旅行者会先把箱子分成几个固定区域：证件和充电器永远放在最上面，这个位置谁也不能抢；衣服占大头；还要留出一点空间给回程时买的纪念品，最后再留一条缝保证拉链能合上。行李箱的空间规划，决定了后面所有打包动作是否从容。

上下文窗口也一样，总容量 C 是一块固定预算，必须提前分配给四类内容：系统提示词（证件）、对话历史（衣服）、模型输出（纪念品）、安全余量（合箱子的缝）。系统提示词负责设定角色、规则和任务边界，相当于“你是一个……你必须……”这些铁律，每一轮都要在，不能省也不能丢。

常见的工程经验是：系统提示词控制在窗口的 10%~20%；对话历史 60%~70%；输出预留 10%~20%；再留 5%~10% 作为安全余量。例如 8K 窗口（K 是千，即 8000 个 token；token 是模型处理文本的最小计数单位，可粗略理解成一个字或一个词）可以切成：系统 1024 token，输出预留 1024，历史约 6144，余量由代码动态把控。分配不是一次定死，很多框架会在每次请求前重新计算预算，回收被浪费的空间。

$$\displaystyle C = C_{\text{sys}} + C_{\text{hist}} + C_{\text{out}} + C_{\text{res}}$$

1. 总容量 C：上下文窗口的 token 上限，是行李箱的总容积，由模型决定。

$$C:\ \text{窗口总预算}$$

2. 系统提示词预算：恒定占用的一块，设定角色与全局规则，永远最先保证。

$$C_{\text{sys}}:\ \text{系统提示词预算}$$

3. 历史与输出两块：对话历史是最大弹性块，输出预留则保证模型有空间生成答案。

$$C_{\text{hist}} + C_{\text{out}}:\ \text{历史与输出分配}$$

4. 安全余量：防止排满后因 token 计算误差溢出报错，相当于合箱子的那一条缝。

$$C_{\text{res}}:\ \text{安全余量}$$

规划好了区域，后面截断和压缩才有依据：哪些是证件不能扔，哪些是衣服可以压——空间分配的本质，是在出发前就想清楚“谁最重要”。

截断策略

箱子塞不下了，最简单粗暴的做法是把最底下的旧衣服掏出来。但如果你慌乱中把护照也掏了出去，到了机场就傻眼了。截断的难点从来不是“删”，而是“删什么、留什么”。

截断就是在窗口超限时，从对话历史中丢弃一些轮次或片段。最朴素的方法是头部截断：把最早的对话直接删掉。但它有致命伤——最早几轮里往往藏着系统指令、用户最初的诉求和尚未完成的任务，删了它们等于扔掉护照。

更聪明的做法是“中央保真”：研究发现模型对开头和结尾的信息关注更强、中间部分容易被忽略（业内称为 lost in the middle，即“中间迷失”），所以保留开头（系统+目标）和结尾（最新对话）的原文，把中间的旧对话压缩或删除。工程上还会设一份“关键信息保护名单”：用户最新诉求、未完成任务、指令约束等条目永不截断，只截断闲聊和重复内容。

$$\displaystyle \sum_{i=k}^{n} |t_i| \le C - C_{\text{sys}} - C_{\text{out}}$$

1. 每轮长度 t_i：第 i 轮对话（用户+助手）消耗的 token 数，是截断的基本单位。

$$t_i:\ \text{第 } i \text{ 轮对话的 token 数}$$

2. 起始轮 k：截断后保留的第一轮，k 越大丢掉的旧对话越多，太大则会丢掉系统与目标。

$$k:\ \text{保留范围的起始下界}$$

3. 历史可用预算：右侧是总容量减去系统提示词和输出预留后的可用空间，历史总量必须被它罩住。

$$C - C_{\text{sys}} - C_{\text{out}}:\ \text{历史可用预算}$$

取舍的智慧在于：旧衣服可以扔，但证件和这次旅行的车票不能扔。截断不是“删最早的”，而是“删最不重要的”——这也是后面优先级策略的伏笔。

滚动摘要

有些旧衣服扔了可惜，因为路上可能还要穿。聪明的旅行者会拿出真空压缩袋：一袋羽绒服“嗖”地变成豆腐块大小。滚动摘要就是上下文的真空压缩袋。

滚动摘要的思路是：当历史接近预算阈值（比如用掉可用空间的 80%）时，把最老的一批对话交给模型提炼成一小段摘要，放进下一次请求。摘要的位置放在历史之前、系统提示之后，相当于把压缩袋塞进箱子角落。

摘要质量与压缩比 r 是关键。好的摘要保留“用户诉求、结论、未完成任务、关键实体”，丢掉寒暄与重复；压缩比通常做到 0.1~0.3，即 1000 token 的对话缩成 100~300 token 的要点。面对超长对话，还有分层摘要树：摘要超过阈值后，再对摘要做摘要，形成多级金字塔，从而支持任意长度的会话记忆。

$$\displaystyle S_{\text{new}} = \operatorname{Summarize}(S_{\text{old}} \oplus T_{\text{expired}}), \quad r = \frac{|S_{\text{new}}|}{|S_{\text{old}}| + |T_{\text{expired}}|} \ll 1$$

1. 摘要生成函数：通常直接调用大模型把长文本提炼成要点，也可以用规则抽取。

$$\operatorname{Summarize}(\cdot):\ \text{摘要生成操作}$$

2. 拼接操作：旧摘要和新被淘汰的对话拼接在一起作为压缩输入，保证信息连续。

$$S_{\text{old}} \oplus T_{\text{expired}}:\ \text{旧摘要与被淘汰对话拼接}$$

3. 压缩比：新摘要长度除以压缩前总长度，远小于 1 意味着腾出了大量空间。

$$r \ll 1:\ \text{压缩比远小于 1 代表高效}$$

压缩袋不是把衣服揉成一团，而是抽掉空气、保留材质——摘要也是如此：丢掉废话、保留信息。它让“回忆”不占地方，还随时能打开接着用。

多轮优先级

箱子装好后，总有几样东西要放最上层：今晚要穿的睡衣、明早的牙刷，一伸手就摸到；底下的东西反正要弯腰翻。多轮对话里，信息也要分个尊卑。

不是所有历史轮次生而平等。刚说完的话（时效性）、与用户当前目标相关的话（相关性）、用户下达的指令（指令权重），都应该比闲聊权重更高。工程做法是给每条历史打一个优先级分 p，按分数排序分配窗口空间，低分的先丢进摘要或截断。

用户最新诉求和未完成任务通常设为最高优先级，称为“目标锚点”——就像箱子上层永远放着车票和行程单。当摘要本身也过长时，采用递归压缩：对摘要再做摘要，形成摘要树。这相当于把整个压缩袋再压缩一层，代价是信息多损失一档，但能对抗无限长的对话。

$$\displaystyle p(t_i) = \alpha f_i + \beta g_i + \gamma d_i$$

1. 时效性 f_i：信息越新越重要，因为对话延续性依赖最近上下文。

$$f_i:\ \text{第 } i \text{ 条信息的时效新鲜度}$$

2. 目标相关性 g_i：与当前未完成任务的相关程度，越相关越该保留原文。

$$g_i:\ \text{与当前目标的相关性得分}$$

3. 指令权重 d_i：包含用户明确指令或约束的信息权重最高，类似“必须遵循的规则”。

$$d_i:\ \text{指令遵从的重要程度}$$

4. 加权系数：α、β、γ 是超参数，工程上既可用人工规则，也可用数据学习得到。

$$\alpha,\ \beta,\ \gamma:\ \text{可调权重，和为 1}$$

优先级的本质，是把“最可能被用到的信息”放在最顺手的位置。箱子空间有限，但我们总能保证：当你需要车票时，它一定在最上层。

成本平衡

航空公司对超重行李按公斤收费，而且旺季每公斤更贵。模型厂商也一样：按 token 收费，输入一个价、输出一个价，长上下文模型的单价还更高。行李箱用多大、装多满，直接写在账单上。

成本公式很直白：每轮请求的输入 token 数乘以输入单价，加上输出 token 数乘以输出单价。注意输出单价通常是输入的两到三倍，但输入才是成本大头——因为每轮请求都要把整个上下文（系统+摘要+历史）重发一遍，十轮对话，历史信息就发了十遍。

所以削减输入 token 是省钱的第一杠杆：截断和滚动摘要正是为此而生。第二个杠杆是混合模型路由：把简单任务（如天气查询）路由到便宜短窗口模型，复杂任务（如长文档分析）才用贵的长窗口模型，相当于短途打车、长途坐高铁。第三个杠杆是请求级提示词缓存，让重复的前缀不再重复计费。

$$\displaystyle \text{Cost} = p_{\text{in}} \times n_{\text{in}} + p_{\text{out}} \times n_{\text{out}}$$

1. 输入单价 p_in：每千 token 的输入价格，通常比输出便宜。

$$p_{\text{in}}:\ \text{输入 token 单价}$$

2. 输入量 n_in：每轮请求携带的全部输入，包括系统、摘要、历史，是成本大头。

$$n_{\text{in}}:\ \text{单次输入 token 总数}$$

3. 输出成本：输出单价更高但数量小，两者之和才是单请求成本。

$$p_{\text{out}} \times n_{\text{out}}:\ \text{输出成本}$$

4. 降本杠杆：压缩 n_in 是最直接的控费手段。

$$n_{\text{in}} \downarrow \Rightarrow \text{Cost} \downarrow:\ \text{削减输入 token 即省钱}$$

省钱不是目的，把钱花在刀刃上才是。就像旅行者不会为省钱把箱子换小，而是会算清楚：哪些行李值得付超重费，哪些可以留在家里——上下文也一样，该精的地方精，该留的地方留。

最佳实践

老背包客的箱子永远整洁：他们从不临时慌乱打包，而是有一套固定流程——分层、防漏、清单、回程复盘。上下文窗口管理做到第五层，拼的就是这套工程习惯。

几条经过验证的实践：一是结构化提示词，系统提示写成固定模板，把关键指令放在开头和结尾（避开“中间迷失”区），方便后续裁剪复用；二是上下文分页管理，长文档按块拆分，按需把相关块注入窗口，而不是一次性全塞进来；三是记忆持久化，滚动摘要不只存在于请求里，还把摘要写入数据库跨会话复用，新会话可以直接加载“上次说到哪了”。

四是监控与调优：记录每轮 token 利用率、摘要长度、截断比例、回答质量打分，形成看板。目标是把利用率 u 保持在 0.8 左右——太低浪费容量，太高挤压输出导致截断报错。调优时依次检查：系统提示是否过大？历史是否冗余？摘要是否保真？用数据回答，而不是拍脑袋。

$$\displaystyle u = \frac{\text{tokens}_{\text{used}}}{C} \in [0,1]$$

1. 实际用量：本次请求真正注入窗口的总 token 数。

$$\text{tokens}_{\text{used}}:\ \text{实际注入的 token 数}$$

2. 窗口上限 C：模型支持的上下文总容量。

$$C:\ \text{上下文窗口上限}$$

3. 目标区间：u 过低浪费预算，过高则有溢出风险，经验上 0.7~0.85 为佳。

$$u \approx 0.8:\ \text{利用率目标}$$

旅行者最后都会形成自己的打包清单。上下文管理的最佳实践，就是把“什么重要、什么可舍、怎么压缩、怎么复盘”沉淀成一套可复用的系统——箱子是有限的，但装东西的智慧可以不断升级。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-# 上下文窗口管理器演示: 滑动截断 + 滚动摘要 + 成本估算  def estimate_tokens(text):    """粗略估算 token 数: 中文约 2 字 1 token."""    return max(1, len(text) // 2)  class WindowManager:    def __init__(self, system_prompt, max_tokens=512, reserve=128):        self.max_tokens = max_tokens        self.reserve = reserve        self.system_prompt = system_prompt        self.history = []        self.summary = ""        self.summarize_count = 0     def _tokens(self):        sys_tokens = estimate_tokens(self.system_prompt)        sum_tokens = estimate_tokens(self.summary)        hist_tokens = sum(            estimate_tokens(u) + estimate_tokens(a)            for u, a in self.history        )        return sys_tokens + sum_tokens + hist_tokens     def _compact(self):        budget = self.max_tokens - self.reserve        while self._tokens() > budget and len(self.history) > 1:            user, assistant = self.history.pop(0)            gist = "用户问{0}, 助手答{1}.".format(user[:8], assistant[:8])            self.summary = (self.summary + gist)[-400:]            self.summarize_count += 1     def add_turn(self, user, assistant):        self.history.append((user, assistant))        self._compact()     def build_prompt(self):        parts = [self.system_prompt]        if self.summary:            parts.append("[滚动摘要] " + self.summary)        for user, assistant in self.history:            parts.append("用户: " + user)            parts.append("助手: " + assistant)        return "\n".join(parts)     def report(self):        total = self._tokens()        sys_tokens = estimate_tokens(self.system_prompt)        sum_tokens = estimate_tokens(self.summary)        return [            total,            sys_tokens,            sum_tokens,            total - sys_tokens - sum_tokens,            self.max_tokens,            self.summarize_count,        ]  def estimate_cost(input_tokens, output_tokens, in_price, out_price):    return input_tokens / 1000 * in_price + output_tokens / 1000 * out_price  def main():    manager = WindowManager(        "你是一位耐心的客服助手, 请用简洁中文回答用户问题.",        max_tokens=512,        reserve=128,    )    questions = [        "我的订单还没到, 能帮我查一下吗?",        "下单当天是用的优惠券吗?",        "那请问退款大概多久到账?",        "如果到账时间超过7天怎么办?",        "这个商品还有黑色款吗?",    ] * 6     input_tokens = 0    output_tokens = 0    for i, question in enumerate(questions):        answer = "好的, 我理解您的问题:{0} 已为您记录并同步处理, 请放心.".format(question)        manager.add_turn(question, answer)        if i in (0, 4, 9, 14, 19, 24, 29):            total, sys_t, sum_t, hist_t, limit, comp_count = manager.report()            print("第{0:2d}轮 | 总{1:4d}/{2} 系统{3:3d} 摘要{4:3d} 历史{5:3d} 压缩{6}次".format(                i + 1, total, limit, sys_t, sum_t, hist_t, comp_count))        if i % 3 == 0:            prompt = manager.build_prompt()            input_tokens += estimate_tokens(prompt)            output_tokens += 80     cost = estimate_cost(input_tokens, output_tokens, 0.002, 0.006)    print("累计输入token: {0}, 累计输出token: {1}, 估算成本: ${2:.4f}".format(        input_tokens, output_tokens, cost))    print(manager.build_prompt()[:180])    print("...")  if __name__ == "__main__":    main()

1. budget = self.max_tokens - self.reserve先扣掉输出预留，剩下的才允许历史和摘要占用，相当于给“回程纪念品”留位置。
2. while self._tokens() > budget and len(self.history) > 1:只要超预算且还有旧对话可淘汰，就持续压缩。
3. user, assistant = self.history.pop(0)弹出最早的一轮，这是最简单的“头部截断”。
4. self.summary = (self.summary + gist)[-400:]把被淘汰轮浓缩成一句话并入摘要，并限制摘要总长不超过 400 字。
5. parts.append("[滚动摘要] " + self.summary)构建请求时摘要紧跟系统提示，历史排在其后，让模型先看到“纪要”。
6. manager.add_turn(question, answer)每来一轮对话就写入历史并触发可能的压缩，管理发生在请求之前。
7. estimate_cost(input_tokens, output_tokens, 0.002, 0.006)按输入 $0.002/千token、输出 $0.006/千token 估算总成本。

常见误区

面试题