深入浅出RAG——第17章:RAG 系统性能优化实战

5 阅读22分钟

📖 本章学习目标

  • 对 RAG 请求做全链路延迟拆解,用数据定位最耗时的环节
  • 通过 Embedding 批处理和连接池复用降低检索层的延迟和资源消耗
  • 使用流式输出和上下文精简显著缩短生成层的首字延迟
  • 建立 Token 消耗统计并估算单次查询的成本构成
  • 根据延迟分布和成本约束选择优化手段,而非盲目套用所有技术

引言:从架构到性能

《第16章:生产级 RAG 系统架构设计》设计了生产级 RAG 系统的五层架构,包括异步索引管道、查询缓存和多租户隔离。架构正确不等于性能够快,一个结构合理的系统如果端到端延迟超过两秒,用户依然不会用。

RAG 请求的延迟来源分布在多个环节:Embedding 生成需要调用外部 API,向量检索涉及索引遍历,LLM 生成则需要逐 Token 输出。每个环节都有不同的优化空间和代价。本章从测量出发,先拆解全链路延迟的构成,再分别对检索层和生成层实施优化,最后建立成本统计机制,让优化决策有数据支撑而非凭直觉。

这里讨论的是单次请求的延迟优化和成本控制。高并发下的吞吐量、连接池配置和负载均衡放在第18章的部署实践中处理。

一、全链路延迟拆解

1. 延迟从哪里来

优化之前必须先知道时间花在哪里。一个典型的 RAG 请求可以分解为四个串行阶段,每个阶段的耗时特征各不相同。

gantt
    title RAG 请求延迟分解(示例值)
    dateFormat X
    axisFormat %s
    section 查询编码
    Embedding API 调用 :0, 100
    section 向量检索
    ANN 搜索 :100, 150
    section Prompt 组装
    模板渲染 :150, 151
    section LLM 生成
    首 Token :151, 601
    剩余 Token :601, 1200
graph LR
    A[用户提问] --> B[Embedding 生成]
    B --> C[向量检索]
    C --> D[Prompt 组装]
    D --> E[LLM 生成]
    E --> F[返回答案]

这四个阶段中,LLM 生成是延迟的大头,它又分为首 Token 延迟和逐 Token 输出两个子阶段。首 Token 延迟取决于模型加载和 Prompt 处理的时间,逐 Token 输出则与答案长度和模型推理速度成正比。Embedding API 调用排在第二位,主要消耗在网络往返和模型推理上。向量检索本身很快,在索引质量正常的情况下通常在几十毫秒内完成。Prompt 组装(模板渲染和字符串拼接)的时间基本可以忽略。

理解这个分布后我们就知道优化检索速度对整体延迟的改善有限,优先优化 LLM 生成环节和 Embedding 调用的收益最大。

2. 通过埋点获取真实数据

延迟分布不能用直觉估算,每次 API 调用的网络条件、模型负载和数据规模都不同。下面是一个带埋点的查询函数,它在每个阶段打时间戳,返回结构化的性能数据。

interface PerformanceMetrics {
  embeddingTime: number;
  retrievalTime: number;
  promptAssemblyTime: number;
  firstTokenTime: number;
  totalGenerationTime: number;
  totalTime: number;
}
async function queryWithMetrics(query: string): Promise<{
  answer: string;
  metrics: PerformanceMetrics;
}> {
  const startTime = Date.now();
  const metrics: PerformanceMetrics = {
    embeddingTime: 0, retrievalTime: 0, promptAssemblyTime: 0,
    firstTokenTime: 0, totalGenerationTime: 0, totalTime: 0,
  };

  const embedStart = Date.now();
  const queryEmbedding = await getEmbedding(query);
  metrics.embeddingTime = Date.now() - embedStart;

  const retrieveStart = Date.now();
  const docs = await retriever.invoke(queryEmbedding);
  metrics.retrievalTime = Date.now() - retrieveStart;

  const promptStart = Date.now();
  const prompt = buildPrompt(query, docs);
  metrics.promptAssemblyTime = Date.now() - promptStart;

  const generationStart = Date.now();
  let firstTokenReceived = false;
  let answer = "";

  const stream = await llm.stream(prompt);
  for await (const chunk of stream) {
    if (!firstTokenReceived) {
      metrics.firstTokenTime = Date.now() - generationStart;
      firstTokenReceived = true;
    }
    answer += chunk.content;
  }

  metrics.totalGenerationTime = Date.now() - generationStart;
  metrics.totalTime = Date.now() - startTime;

  return { answer, metrics };
}

这段代码的核心价值不在于计算绝对值,而在于建立基线。在自己的环境中跑几十条真实查询,记录每个阶段的耗时分布(P50、P95、P99),后续每次优化都用同一批查询对比,才能判断收益是否真实。

3. 解读延迟数据的三个视角

拿到延迟数据后,不要只盯着总延迟的平均值。建议从三个视角审视:

**(1)看分布而非均值。**P95 延迟比平均值更能反映用户的真实体验,因为平均值可能被少数极快的请求拉低,而 P95 代表大多数用户在大多数时候感受到的速度。

**(2)看占比而非绝对值。**Embedding 调用了 200ms在网络条件好的环境中可能算慢,在网络条件差的环境中可能算快。更值得关注的是每个阶段占总延迟的比例,比例最高的阶段就是优化的主要方向。

**(3)区分冷启动和热路径。**首次请求可能包含连接建立、模型预热等一次性开销,后续请求才是稳态表现。记录时把首次请求单独标记,优化决策以稳态数据为准。

二、检索层优化

虽然检索层在总延迟中的占比通常不高,但检索的吞吐量直接影响系统的并发能力。当并发请求增多时,检索层的瓶颈会在生成层之前暴露出来。

1. HNSW 索引参数调优

HNSW 有三个参数可以影响检索的速度和精度。它们在《第3章:向量数据库入门》已经介绍过,这里从性能调优的角度重新审视。

M控制每个节点在图中的最大连接数。M越大,图的连通性越好,检索精度越高,但索引占用的内存也越大,构建时间更长。efConstruction控制索引构建时探索的邻居数量,值越大索引质量越高但构建越慢。efSearch控制查询时维护的候选节点数量,值越大检索越精确但越慢。

这三个参数构成了一个三维权衡空间。调优的关键在于先明确优先级,是追求低延迟还是高精度。

interface HNSWParams {
  M: number;
  efConstruction: number;
  efSearch: number;
}

async function benchmarkHNSWConfig(
  config: HNSWParams,
  queries: number[][],
  collection: any
): Promise<{ avgLatency: number; p95Latency: number }> {
  const times: number[] = [];
  for (const queryVec of queries) {
    const start = Date.now();
    await collection.query({ queryEmbeddings: [queryVec], nResults: 10 });
    times.push(Date.now() - start);
  }
  times.sort((a, b) => a - b);
  const avg = times.reduce((a, b) => a + b, 0) / times.length;
  const p95 = times[Math.floor(times.length * 0.95)];
  return { avgLatency: avg, p95Latency: p95 };
}

这段基准测试代码用于在自己的数据上对比不同参数组合。不要在别人的推荐值上直接下结论,索引性能高度依赖数据规模、向量维度和硬件配置。

Chroma 允许在创建 Collection 时通过 metadata设置 HNSW 参数:

const collection = await client.createCollection({
  name: "perf_tuned",
  metadata: {
    "hnsw:space": "cosine",
    "hnsw:construction_ef": 128,
    "hnsw:M": 32,
    "hnsw:search_ef": 64,
  },
});

Pinecone 等托管服务会自动优化这些参数,无需手动设置。如果你用的是自托管方案,建议从 M=32、efConstruction=200、efSearch=100 起步,在自己的数据上做 A/B 测试后再调整。调整方向很直观:查询延迟过高就先降 efSearch,召回率不足就先提 efConstruction 然后重建索引。

2. Embedding 批处理

单个 Embedding 请求的网络往返开销是固定的。逐条调用时,每一条都需要一次完整的网络往返和 API 处理,1000 条文本就需要 1000 次往返。批量调用将多条文本合并为一次请求,N 次往返变成 1 次。

两者的时间差异可以用一个简单的模型表达,即总延迟约等于往返次数乘以单次 RTT(往返时延)加上总 Token 数的处理时间。逐条调用的往返次数等于文本数量,批量调用的往返次数等于分批数量。当文本数量远大于批次数时,批处理的收益非常明显。

async function embedBatch(
  texts: string[],
  batchSize: number = 100
): Promise<number[][]> {
  const allEmbeddings: number[][] = [];

  for (let i = 0; i < texts.length; i += batchSize) {
    const batch = texts.slice(i, i + batchSize);

    const response = await openai.embeddings.create({
      model: "text-embedding-3-small",
      input: batch,
    });

    const embeddings = response.data.map(d => d.embedding);
    allEmbeddings.push(...embeddings);
  }

  return allEmbeddings;
}

批次大小的选择取决于两个约束:API 的单次上限(OpenAI 为 2048 条)和单次请求的超时风险。批次太大,一次失败影响大量数据;批次太小,批处理的收益不明显。50 到 200 是一个合理的起始范围,具体值取决于文本的平均长度。文本较长时,单次请求的 Token 总量也会增大,需要适当减小批次。

3. 向量数据库连接池

高并发场景下,频繁创建和销毁数据库连接会产生不必要的开销。TCP 握手、TLS 协商和认证流程叠加起来,每次新连接可能消耗几十到上百毫秒。连接池在应用启动时预先建立若干连接并保持长连接,请求到来时直接复用,省去了重复握手的开销。

class VectorDBPool {
  private static instance: VectorDBPool;
  private client: ChromaClient;

  private constructor() {
    this.client = new ChromaClient({
      path: "http://localhost:8000",
    });
  }

  static getInstance(): VectorDBPool {
    if (!VectorDBPool.instance) {
      VectorDBPool.instance = new VectorDBPool();
    }
    return VectorDBPool.instance;
  }

  getClient(): ChromaClient {
    return this.client;
  }
}

对于 Chroma 这类以 HTTP 协议通信的向量数据库,单例模式已经足够。如果你用的是 gRPC 协议(如 Qdrant 的某些部署模式),还需要考虑连接的心跳保活和断线重连策略。这些网络层的细节放到第18章部署部分展开。

三、生成层优化

生成层在总延迟中的占比通常最高,是优化的重点。核心思路只有两条,一个是让用户更快地看到第一个字(流式输出),另一个是让模型处理更少的 Token(上下文精简)。

1. 流式输出:降低首字延迟

非流式输出需要等待 LLM 生成完全部 Token 后才返回结果,用户在这段时间里看到的是空白或加载动画。流式输出逐 Token 返回,首 Token 到达后立即展示,用户感知的等待时间从全文生成时间缩短为首 Token 延迟。

const llm = new ChatOpenAI({
  modelName: "claude-sonnet-5",
  streaming: true,
});

async function streamAnswer(
  query: string,
  docs: Document[]
): Promise<string> {
  const prompt = buildPrompt(query, docs);

  const stream = await llm.stream(prompt);
  let fullAnswer = "";

  for await (const chunk of stream) {
    const content = chunk.content as string;
    process.stdout.write(content);
    fullAnswer += content;
  }

  return fullAnswer;
}

前端通过 Fetch API 的 ReadableStream 逐块接收数据:

const response = await fetch("/api/query", {
  method: "POST",
  body: JSON.stringify({ query }),
});

const reader = response.body?.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader!.read();
  if (done) break;
  updateUI(decoder.decode(value));
}

流式输出的收益取决于首 Token 延迟和总生成时间的比例。假设首 Token 在 500ms 左右到达,总生成时间在两秒,用户感知的等待就从两秒降到了半秒。这个改善不需要任何后端架构改动,只需要启用 streaming 参数并适配前端接收方式。

流式输出的一个附带问题是引用标注。模型在逐 Token 生成时可能输出一个未闭合的引用标记,比如只生成了 [来源: 而后面的内容还在生成中,前端如果实时渲染就会显示一段不完整的标记。可以在 Prompt 中约定引用格式(如 [来源: 文档名]),流式结束后对完整答案做一次后处理,补全未闭合的标记或移除不完整的片段。

2. 上下文 Token 的精简

放入 Prompt 的检索结果越长,模型处理的 Input Token 就越多,首 Token 延迟和生成成本同步上升。《第10章:检索后处理与重排序》介绍的上下文压缩在这里直接转化为性能收益,其做法就是在检索结果进入 Prompt 之前,去掉与问题无关的句子,保留关键信息。

压缩前后的 Token 数量差异取决于文档的冗余程度。假设原始检索结果每条 500 字符,取 5 条共 2500 字符,约 600 Token。压缩后每条约 150 字符,总计 750 字符,约 180 Token。Input Token 减少约 70%,首 Token 延迟和成本同步下降。

上下文压缩的具体实现见第10章。从性能优化的角度,这里只强调一个原则,即每次 Prompt 组装前,确认进入模型的上下文没有冗余句子。这是成本几乎为零的优化,不需要改模型,不需要改检索器,只需要在组装环节加一层过滤。

3. 并行化独立操作

有些操作之间存在依赖关系,比如必须先做 Embedding 才能做检索,必须先检索才能做生成。但也有些操作天然独立,可以并行执行。

// 检索和历史摘要互不依赖,可以并行
const [docs, historySummary] = await Promise.all([
  retriever.invoke(query),
  summarizeHistoryIfLong(messages),
]);
const prompt = buildPrompt(query, docs, historySummary);

可并行的场景包括检索和历史对话摘要、多路检索中的不同检索策略、Rerank 与上下文压缩(如果它们是独立的不同后处理步骤)。不可并行的场景包括 Embedding 和检索(前者是后者的输入)、检索和生成(前者是后者的上下文)。

并行化的收益上限受限于最慢的那个操作。如果检索耗时 50ms,历史摘要耗时 200ms,并行后的总耗时为 200ms,比串行(250ms)节省了 50ms。这个收益在单个请求上不算大,但在高并发场景下,每个请求都节省几十毫秒,累积效果就很可观。

4. 按场景选择生成模型

不同的 LLM 在速度和精度之间的取舍不同。下表列出几种常见选择及其特征,注意具体的延迟数字取决于服务端负载和网络条件,这里只给出相对比较。

模型相对速度相对成本适用场景
Claude Opus 5中等较高复杂多步推理、高精度要求
Claude Sonnet 5快中等大多数场景的默认起点
GPT-5中等中等通用场景,生态集成广泛
自部署模型(如 Llama 4)取决于硬件固定成本超高并发、数据不出域

选型建议不是选一个最好的模型,而是根据问题复杂度做路由。简单问题(如"XX 是什么")用轻量模型,复杂问题(如"对比 A 和 B 的架构差异")用强模型。路由逻辑可以参考《第15章:Agent RAG —— 让 RAG 具备自主决策能力》 Router Agent 的设计模式。

async function selectModel(query: string): Promise<string> {
  const complexity = await estimateComplexity(query);
  if (complexity === "simple") return "claude-haiku-4-5";
  return "claude-sonnet-5";
}

estimateComplexity 的实现可以是一个简单的规则匹配,也可以是一个专门的分类模型。关键在于这个判断本身要足够快,如果路由判断比生成还慢,就失去了意义。

四、成本控制

性能优化关注的是速度,成本控制关注的是花费。两者有时是矛盾的,因为更快的模型通常更贵。本节的思路是先建立透明的成本可见性,再根据数据做取舍。

1. 统计 Token 消耗

Token 消耗统计是实现成本可见性的第一步。

价格定义和状态存储:

import { getEncoding } from "tiktoken";

const encoder = getEncoding("cl100k_base");

class TokenCostTracker {
  private totalEmbeddingTokens = 0;
  private totalInputTokens = 0;
  private totalOutputTokens = 0;

  private readonly PRICES = {
    embedding: 0.02,
    input: 2.50,
    output: 10.00,
  };

  countTokens(text: string): number {
    return encoder.encode(text).length;
  }

记录方法和成本汇总:

  trackEmbedding(texts: string[]) {
    const tokens = texts.reduce(
      (sum, text) => sum + this.countTokens(text), 0
    );
    this.totalEmbeddingTokens += tokens;
  }

  trackGeneration(inputText: string, outputText: string) {
    this.totalInputTokens += this.countTokens(inputText);
    this.totalOutputTokens += this.countTokens(outputText);
  }

  getCostEstimate() {
    const embeddingCost =
      (this.totalEmbeddingTokens / 1_000_000) * this.PRICES.embedding;
    const inputCost =
      (this.totalInputTokens / 1_000_000) * this.PRICES.input;
    const outputCost =
      (this.totalOutputTokens / 1_000_000) * this.PRICES.output;

    return {
      embedding: embeddingCost,
      generation: inputCost + outputCost,
      total: embeddingCost + inputCost + outputCost,
      breakdown: {
        embeddingTokens: this.totalEmbeddingTokens,
        inputTokens: this.totalInputTokens,
        outputTokens: this.totalOutputTokens,
      },
    };
  }

  reset() {
    this.totalEmbeddingTokens = 0;
    this.totalInputTokens = 0;
    this.totalOutputTokens = 0;
  }
}

代码中的价格是 text-embedding-3-small 和 claude-sonnet-5 在 2026 年的参考值。实际价格会变动,应该从环境变量或配置中心读取,不要硬编码在业务逻辑中。

成本分布通常呈现的一个规律是LLM 调用是主要成本来源,其中 Input Token(包含检索到的上下文)占大头。这意味着降低上下文的 Token 数量不仅能提速,还能直接省钱。

2. 降低成本的四个方向

(1)减少 Input Token。 上下文压缩、降低 Top-K、使用更紧凑的文档切分,都能减少送入模型的上下文量。这和第10章的压缩策略以及第5章的切分策略直接相关。

(2)减少 Output Token。 在 Prompt 中要求简洁回答、设置合理的 max_tokens 上限。但要注意,限制过紧可能导致答案不完整,需要在质量和成本之间做测试。

(3)缓存复用。 相同问题的 Embedding 结果和查询结果都可以缓存。第 《第16章:生产级 RAG 系统架构设计》已经讨论了 Query Cache 和 Embedding Cache 的实现方式,这里不再重复。缓存的收益率等于重复查询比例乘以单次查询成本,如果系统中重复查询很少,缓存的收益就有限。

(4)模型降级路由。 对于不需要强推理能力的简单问题,路由到更便宜的模型。路由的精度直接影响成本节省的上限,路由错误的代价是答案质量下降,需要在测试集上评估路由准确率后再上线。

五、优化决策框架

1. 按收益和代价排序

前面各节介绍了多种优化手段,但不需要全部实施。下表从延迟影响、成本影响和实现难度三个维度做一个相对比较,帮助你决定优先级。

优化手段主要收益主要代价实施建议
流式输出用户感知等待大幅缩短前端需适配流式接收所有系统默认开启
Embedding 批处理索引速度显著提升批次管理逻辑索引管道中必做
上下文压缩Input Token 和延迟同步降低需集成压缩模块上下文量大时优先做
Embedding 缓存重复查询的延迟和成本降低缓存失效策略重复查询多时做
并行化总延迟降低需分析依赖关系有独立操作时顺手做
HNSW 参数调优检索延迟降低需测试,可能需重建索引检索变瓶颈时做
模型降级路由成本和延迟同步降低路由精度风险简单问题占比高时做

流式输出和 Embedding 批处理是"零结构性代价"的优化,不需要改变架构设计,不需要额外的存储或服务,只需要启用已有能力。建议所有 RAG 系统先做完这两项,然后根据第19章的监控数据判断是否以及何时需要深入其他优化。

2. 建立优化基线

每次优化前后,用同一批查询测量并记录以下数据:

  • 延迟分布(P50、P95、P99)
  • 单次查询的平均 Token 消耗和成本
  • 答案质量指标(MRR、Faithfulness,确保优化没有降低质量)

优化不应该让质量指标明显下降。如果一项优化让延迟降低但 Faithfulness 退化了,说明可能压缩了不该压缩的上下文,或切换到了对当前任务精度不够的模型。这种情况需要回退,或者寻找更精确的优化方式。

把这些记录保存为版本化的优化日志。《第13章:RAG 系统调优实战》已经建立了实验闭环的方法论,这里把实验对象从检索配置切换为性能参数,逻辑是相通的。

从下一章开始,我们将离开单机性能优化的范畴,讨论如何将优化后的 RAG 系统通过 Docker 容器化、CI/CD 流水线和蓝绿部署,可靠地交付到生产环境。

FAQ

Q1:流式输出下如何保证引用标注完整?

流式输出无法提前知道完整答案,引用标记可能在流的中途被打断。可以在 Prompt 中约定引用格式(如 [来源 文档名]),流式结束后对完整答案做一次后处理校验,补全未闭合的标记或缺失的引用。如果引用准确性对业务至关重要,建议在流式完成后做一轮独立的引用验证(参考《第12章:RAG 系统评估与指标体系》的 Faithfulness 评估)。

Q2:什么时候应该考虑自部署 LLM 而非调用 API?

当查询量足够大,API 调用的边际成本超过了自部署的固定成本时,自部署开始有经济性。但这不是一个简单的单价对比,自部署的固定成本包含 GPU 服务器、运维人力、电力、模型更新等,API 调用的边际成本则随调用量线性增长。建议先在 API 模式下运行一段时间,积累真实的调用量和延迟数据,再计算自部署的总拥有成本。如果业务对数据不出域有硬性要求,则优先考虑自部署或私有化部署方案。

Q3:如何平衡延迟和成本?

这不是一个有没有最优解的问题,而是在什么约束下做选择的问题。建议先确定硬约束(如 P95 延迟不能超过两秒),在满足硬约束的配置中选择成本最低的。如果硬约束无法满足,再考虑是否接受更高的成本换取更低的延迟。没有硬约束的优化讨论很容易陷入无休止的权衡。

Q4:优化后如何验证效果?

使用《第12章:RAG 系统评估与指标体系》的评估集,对比优化前后三个维度的变化:延迟分布(P50、P95、P99)、单次查询平均成本、答案质量指标(MRR、Faithfulness)。如果延迟和成本降低,但质量指标显著退化,优化就是失败的。优化的底线是质量不能明显下降,否则只是把慢系统变成了快的坏系统。

Q5:批处理的批次大小怎么确定?

没有通用最优值,取决于文本的平均 Token 长度和 API 的单次上限。文本越长,同样批次大小的 Token 总量越大,需要减小批次。建议从 100 条起步,在自己的数据上测试不同批次大小下的成功率和耗时,选择总耗时最短且失败率在可接受范围内的配置。同时记录每次失败时的批次大小和错误类型,用于后续调整。

练习

练习 1:为你的 RAG 服务添加全链路埋点

参考本章第一节的 queryWithMetrics 实现,在你的 RAG 服务中添加全链路埋点。发送 50 条不同类型的查询,记录每个阶段的耗时。

验证步骤:

  1. 对 50 条查询分别记录 embeddingTime、retrievalTime、promptAssemblyTime、firstTokenTime、totalGenerationTime 和 totalTime
  2. 计算每个阶段的 P50 和 P95 延迟,以及占总延迟的比例
  3. 找出占比最高的阶段,作为后续优化的主要方向

预期结果:能准确指出当前系统中哪个环节耗时最多,占总延迟的比例是多少。

练习 2:实现 Embedding 批处理并对比性能

将你的索引流程改为批处理方式。准备 500 条文档片段,分别用逐条调用和批处理两种方式生成 Embedding,记录总耗时。

验证步骤:

  1. 记录逐条调用的总耗时和失败次数
  2. 记录批处理(batchSize=100)的总耗时和失败次数
  3. 对比两种方式的时间差异和 API 调用次数

预期结果:批处理的总耗时和 API 调用次数显著低于逐条调用,且能解释差异来自网络往返次数的减少。

练习 3:实现 Token 消耗统计

将本章的 TokenCostTracker 集成到你的 RAG 服务中。发送 20 条查询后查看 Embedding Token、Input Token 和 Output Token 的分布。

验证步骤:

  1. 记录 20 条查询的 Token 消耗明细
  2. 计算 Embedding、Input 和 Output 的 Token 占比和预估费用
  3. 找出 Token 消耗最高的环节,分析原因

预期结果:能清楚看到每类 Token 的消耗量和预估费用,并且能识别出 Input Token 通常是主要成本来源(因为包含了检索到的上下文)。

练习 4:对比流式和非流式的首字延迟

为你的 RAG 服务同时支持流式和非流式两种输出模式,用相同的 10 条查询分别测试两种模式的首字延迟。

验证步骤:

  1. 记录流式模式下每条查询的首字时间
  2. 记录非流式模式下每条查询的全文返回时间
  3. 对比两种模式下的用户感知等待时间

预期结果:流式模式下的首字延迟显著低于非流式模式的全文返回时间,而且用户感知的等待改善比数字显示的更明显,因为用户不需要盯着空白屏幕等待全文生成。

📚 延伸阅读