《AI Agent 技术原理与架构·模型、推理与能力边界》9.2 长上下文与 RAG 的成本/质量边界

长上下文和 RAG 经常被当成二选一,其实它们解决的是不同问题。长上下文省掉索引,但每次请求都付全量 token;RAG 只送相关片段,却要维护检索质量与权限。本节用成本模型和盈亏平衡点,比较两条路线的质量、延迟与运维代价,并给出混合架构的选择框架。

以下数字为教学示例,不构成对任何真实模型或供应商训练结果的承诺。

“窗口够大了,还需要 RAG 吗?”这个问题通常问错了。长上下文和 RAG 不是同一层的替代品:长上下文是一种输入方式,把更多原始材料直接送给模型;RAG 是一种检索与筛选机制,决定哪些材料值得送。前者省掉索引,后者省掉 token。真正的选择取决于语料规模、更新频率、权限、延迟和质量的组合。

这一节先拆开两条路线的成本结构,再用一个盈亏平衡模型演示决策,最后讨论为什么生产系统通常是混合的。

两条路线在比什么

维度长上下文RAG
输入全量或大段原文top-k 相关片段
索引不需要需要构建与维护
每次成本高,随输入线性增长低,只付片段和检索
新鲜度每次可带最新原文取决于索引更新
权限由请求方控制需在检索层做过滤
质量风险中间信息丢失、噪声干扰召回失败、片段不完整
延迟prefill 长,首 token 慢检索 + 较短 prefill

两条路线都有“看不见的成本”。长上下文的隐性成本是每次请求都重复传输同一批材料;RAG 的隐性成本是索引管道、embedding 更新、召回评测和权限同步。只比较单次 token 价格,会得出片面的结论。

成本模型

一次请求的成本可以粗略写成:

$$
C = \frac{T_{\text{in}}}{1000} \cdot p_{\text{in}} + \frac{T_{\text{out}}}{1000} \cdot p_{\text{out}} + C_{\text{infra}}
$$

长上下文的 $T_{\text{in}}$ 很大,$C_{\text{infra}}$ 接近零;RAG 的 $T_{\text{in}}$ 很小,但有检索服务、向量库和索引更新的 $C_{\text{infra}}$。当请求量很大时,长上下文的重复输入成本会迅速累积;当语料很小、请求很少时,维护 RAG 的固定成本反而不划算。

还有两个常被忽略的变量:

  • 缓存:如果同一批材料被反复使用,提示缓存可以显著降低长上下文的实际成本。
  • 输出长度:两条路线的输出可能差不多,但长上下文更容易让模型生成更长的答案,进一步推高成本。

最小实验:成本与盈亏平衡

下面的实验用两个选项比较:64k token 的长上下文,和 4k token 的 RAG。两者单价相同,RAG 每次多 0.001 的检索基础设施成本;质量假设长上下文 0.90、RAG 0.85。

# file: agp_lab/longctx_rag.py | write
# tier: 3
# verify: python3 -m unittest tests.test_longctx_rag
"""长上下文与 RAG:成本曲线、质量假设与盈亏平衡。"""
from __future__ import annotations

from dataclasses import dataclass


@dataclass(frozen=True)
class Option:
    name: str
    tokens: int
    price_per_1k: float
    infra_per_request: float = 0.0
    quality: float = 0.0


LONG = Option("long-context", 64_000, 0.01, 0.0, 0.90)
RAG = Option("rag", 4_000, 0.01, 0.001, 0.85)


def request_cost(option: Option) -> float:
    return option.tokens / 1000 * option.price_per_1k + option.infra_per_request


def break_even_tokens(rag: Option, long: Option) -> float:
    """在质量假设之外,只比较成本时的 token 平衡点。"""
    if long.price_per_1k <= 0:
        raise ValueError("单价必须为正")
    return rag.tokens + rag.infra_per_request * 1000 / long.price_per_1k


def quality_gap(long: Option, rag: Option) -> float:
    return long.quality - rag.quality


def decide(long: Option, rag: Option, quality_weight: float = 10.0) -> str:
    """把质量差折算成成本,做一个显式的取舍。"""
    if not 0 <= quality_weight <= 1000:
        raise ValueError("质量权重越界")
    long_score = long.quality * quality_weight - request_cost(long)
    rag_score = rag.quality * quality_weight - request_cost(rag)
    return long.name if long_score > rag_score else rag.name


if __name__ == "__main__":
    print(f"long_cost={request_cost(LONG):.3f} rag_cost={request_cost(RAG):.3f}")
    print(f"break_even_tokens={break_even_tokens(RAG, LONG):.0f}")
    print(f"quality_gap={quality_gap(LONG, RAG):+.2f}")
    print("decision_default:", decide(LONG, RAG))
    print("decision_quality_first:", decide(LONG, RAG, quality_weight=1000.0))

运行:

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

输出:

long_cost=0.640 rag_cost=0.041
break_even_tokens=4100
quality_gap=+0.05
decision_default: rag
decision_quality_first: long-context

长上下文每次 0.640,RAG 每次 0.041,差了一个数量级。break_even_tokens=4100 的意思是:在只考虑成本、且 RAG 固定送 4k token 的情况下,长上下文只有在输入规模降到约 4100 token 时才和 RAG 打平。超过这个点,长上下文的单次成本更高。

quality_gap=+0.05 表示长上下文的质量假设高 5 个百分点。默认质量权重 10 时,这 5 个百分点折算成 0.5 的分数,抵不过 0.599 的成本差,所以默认选 RAG。把质量权重提高到 1000,质量差折算成 50 分,长上下文胜出。

这个模型是刻意简化的:它没有建模延迟、缓存、索引维护和召回失败。它的作用是让取舍显式化——你需要说明质量差多少、成本差多少、权重怎么定,而不是凭感觉选一个。

什么时候长上下文更合适

场景原因
语料小且固定不值得建索引管道
需要跨文档综合检索难以覆盖全部关联
一次性分析没有重复请求,缓存收益低
权限简单不需要在检索层做细粒度过滤
快速验证先跑通,再决定是否建索引

跨文档综合是一个典型例子:比较三份合同的条款差异,检索可能只召回各自最相似的段落,遗漏需要对照的部分。把三份合同整体送进去,模型能看到完整结构。代价是 token,但任务是低频、高价值的,成本可以接受。

什么时候 RAG 更合适

场景原因
语料巨大无法全部放入窗口
更新频繁索引可以增量更新
权限复杂检索层按用户过滤
请求量大片段输入显著省钱
需要引用片段天然带文档 ID

权限是 RAG 的结构性优势。长上下文由调用方决定送什么,一旦送错就是越权;RAG 可以在检索阶段按用户、租户、密级过滤,把权限控制放在数据出口。对多租户系统,这通常不是“能不能做”的问题,而是合规要求。

混合架构

生产系统常见的组合是:

  1. 检索先行:用 RAG 把候选范围缩小到几十条。
  2. 长上下文综合:把候选原文(而不是摘要)放进窗口做跨文档推理。
  3. 按需展开:模型需要细节时,再取回完整片段。
  4. 缓存复用:对重复出现的系统提示和固定文档使用提示缓存。

这个组合同时利用了 RAG 的筛选能力和长上下文的完整性。它比纯 RAG 贵,但比纯长上下文便宜,质量通常也更稳。

另一种混合是“路由”:简单问题走 RAG,复杂问题走长上下文。路由依据可以是问题类型、文档数量、是否需要跨文档推理,或者检索置信度。路由的代价是需要维护两套路径和一套判定逻辑。

延迟不只看 token 数

长上下文的主要延迟在 prefill:输入越长,首 token 越慢。RAG 的主要延迟在检索:一次向量搜索加一次重排,通常是几十到几百毫秒。两者的延迟结构不同:

路线延迟来源优化手段
长上下文prefill、长输出缓存、截断、流式输出
RAG检索、重排、短 prefill索引优化、并行检索、减少 k

对交互式 Agent,首 token 延迟往往比总成本更影响体验。一个便宜但慢 2 秒的方案,可能不如一个贵一点但立即开始的方案。延迟预算应该和成本预算一起设,而不是只优化其中一个。

质量怎么比

比较两条路线,必须用同一套评测集、同一套评分标准:

  • 用相同的问题集,分别跑长上下文和 RAG;
  • 评分覆盖事实正确性、引用完整性、拒答正确性;
  • 单独统计“需要跨文档”的子集;
  • 记录每次请求的 token、延迟和成本。

如果只在简单问题上比较,RAG 通常不输;只在跨文档问题上比较,长上下文通常更好。混合评测才能看出路由应该放在哪里。

架构含义

这个取舍对架构有四个直接约束:

  1. 成本要按请求建模。 不只看单价,还要看输入规模、缓存和请求量。
  2. 质量差要显式。 说清楚长上下文比 RAG 高多少,而不是假设“更长更好”。
  3. 权限放在数据出口。 多租户系统优先用检索层过滤,避免越权。
  4. 两条路线都要能评测。 没有同口径对比,就无法决定路由。

第 3 条经常被低估。长上下文方案里,模型看到什么完全由调用方决定;如果调用方拼接了不属于该用户的文档,模型不会拒绝。RAG 把过滤放在检索层,至少有一个强制的检查点。

架构判据

判据合格的样子不合格的样子
成本可核算单次 token + 基础设施只比较单价
质量有对比同评测集、同评分凭印象选路线
权限有检查点检索层过滤调用方自行保证
延迟有预算首 token 与总时长只看总成本
路线可切换路由或配置开关硬编码一条路

这些判据里,“路线可切换”决定系统能否随语料和成本变化调整。今天语料小,长上下文更简单;明年语料翻十倍,就需要 RAG。把选择做成配置,而不是写死在代码里,能省下一次重构。

一个合同审查的例子

法务 Agent 要比较三份供应商合同的违约责任条款。每份合同 30 页,约 2 万 token,三份共 6 万 token。

  • 纯 RAG:检索“违约责任”相关段落,可能每份只召回两三段,遗漏上下文和例外条款。
  • 纯长上下文:6 万 token 一次送入,模型能看到完整结构,但每次请求成本高。
  • 混合:先用 RAG 定位每份合同的相关系节,再把节选原文(而不是摘要)放进窗口做对照。

合同审查是低频、高价值、需要跨文档对照的任务,混合方案通常最合适。如果合同数量增加到几百份,纯长上下文就不可行,必须先检索再综合。

小结

  • 长上下文是输入方式,RAG 是筛选机制;它们不是同一层的二选一。
  • 长上下文省索引但每次付全量 token;RAG 省 token 但要维护索引、权限和召回质量。
  • 成本要按请求建模,考虑缓存、请求量和输出长度。
  • 语料小、跨文档、低频高价值时,长上下文更合适;语料大、更新快、权限复杂时,RAG 更合适。
  • 混合架构(检索缩小范围 + 长上下文综合)通常优于单一路线。
  • 延迟结构不同:长上下文慢在 prefill,RAG 慢在检索;两者都要进预算。

阅读导航:上一节:9.1 Lost in the Middle 与上下文腐化 · 下一节:9.3 上下文预算:分配、压缩与丢弃 。

常见错误与边界

  1. 把长上下文当 RAG 替代品。 语料大、更新快、权限复杂时,长上下文不可行。
  2. 只比较 token 单价。 忽略缓存、基础设施、请求量和输出长度,结论会失真。
  3. 假设“更长更好”。 长上下文有中间丢失和噪声干扰,质量不一定更高。
  4. 权限交给调用方。 多租户系统应在检索层强制过滤,避免越权拼接。
  5. 不做同口径评测。 在不同问题集上比较两条路线,结论不可信。
  6. 把教学数字当报价。 本节成本参数是示例,真实决策必须用当前价格和实测数据。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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