上篇我们把 embedding 这枚"源头旋钮"拧到了领域微调,召回质量这一关算过了。但有个现实问题躲不掉:Demo 里一次问答 2 秒能忍,线上几百 QPS 同时打进来,向量库和 LLM 一起抽风,响应直接飙到 10 秒开外。这篇专门讲 RAG 的性能优化——延迟怎么拆、并发怎么顶、批量怎么榨、缓存怎么分层。
一、先把延迟拆开看,不然无从下手
很多团队的"RAG 很慢"是一句笼统的抱怨,谁都改不动。真正能优化的前提是先把端到端延迟拆成三段,每一段都有独立的优化手段:
用户提问
│
├─[段1 检索] Query 改写 + 向量召回 + 重排 ← 通常 200ms~1.5s
│
├─[段2 组装] 拼接上下文 + Prompt 组装 ← 通常 <50ms(可忽略)
│
└─[段3 生成] LLM 流式输出(首 token + 吞吐) ← 首 token 300ms~1s,全文 2~8s
关键点:段3 是用户"体感"的主要来源,但段1 是"并发天花板"的主要来源。两端优化策略完全不同——段3 靠流式输出和模型选型,段1 靠批量、并发、缓存。
下面按"最容易见效"的顺序逐段给代码。
二、段1 优化:Embedding 批量 + 异步,把 GPU 喂饱
单条文本调一次 Embedding 接口,GPU 大部分时间在空转。RAG 里有两个高频批量场景:入库时给一批文档算向量、多路 Query 改写后一次性算多个子问题向量。核心是把 N 次串行 RPC 合并成 1 次批量 RPC。
// EmbeddingBatchService.java
// 依赖:Spring AI 1.0+(org.springframework.ai:spring-ai-openai-spring-boot-starter)
// 思路:把单条 embedding 调用改成批量,并用虚拟线程异步处理,避免阻塞 Tomcat 线程
@Service
public class EmbeddingBatchService {
private final EmbeddingClient embeddingClient; // Spring AI 抽象,底层可换 bge/m3e/OpenAI
public EmbeddingBatchService(EmbeddingClient embeddingClient) {
this.embeddingClient = embeddingClient;
}
/**
* 批量算向量。一次 RPC 返回 N 个向量,吞吐比逐条调用高 5~10 倍。
* 注意:批量大小别贪,单次 32~64 条是大多数 embedding 服务的甜点区,太大反而超时。
*/
public List<float[]> batchEmbed(List<String> texts) {
// Spring AI 的 embedForResponse 支持一次传多个 text
EmbeddingResponse resp = embeddingClient.embedForResponse(texts);
return resp.getResults().stream()
.map(Embedding::getOutput)
.toList();
}
/**
* 多路改写后的子问题,一次性并发嵌入(虚拟线程,JDK21+)。
* 用 CompletableFuture 串虚拟线程,既不阻塞业务线程,又不占用平台线程池。
*/
public List<float[]> parallelEmbed(List<String> subQueries) {
List<CompletableFuture<float[]>> futures = subQueries.stream()
.map(q -> CompletableFuture.supplyAsync(
() -> embeddingClient.embed(q), // 单条,但跑在虚拟线程上
Thread.ofVirtual().factory())) // JDK21 虚拟线程工厂
.toList();
return futures.stream().map(CompletableFuture::join).toList();
}
}
经验值:入库批量我一般压到 64 条/批;线上检索侧的"多子问题并发"用虚拟线程开 4~8 路足够,再多向量库先扛不住了。
三、检索并发合并:让"召回+重排"并行跑
高级 RAG(Day 98 讲过)经常是多路检索:向量一路、BM25 一路、可能还有图检索一路。这三路之间没有依赖,完全可以并发打出再融合。串行 3 路 = 3 倍延迟,并发 3 路 ≈ 最慢那一路的延迟。
// ConcurrentRetriever.java
// 思路:用虚拟线程同时打多路召回,RRF 融合后统一交重排,整体延迟取"最慢一路"
@Component
public class ConcurrentRetriever {
private final VectorRetriever vectorRetriever; // 向量召回(Day 101 的 Qdrant/Milvus)
private final KeywordRetriever keywordRetriever; // BM25 关键词召回
private final Reranker reranker; // Cross-Encoder 重排
public List<DocChunk> retrieve(String query) {
// 三路并发:各自跑在虚拟线程,join 等最慢的一路
var fVec = CompletableFuture.supplyAsync(
() -> vectorRetriever.search(query, 20), Thread.ofVirtual().factory());
var fKw = CompletableFuture.supplyAsync(
() -> keywordRetriever.search(query, 20), Thread.ofVirtual().factory());
List<DocChunk> vec = fVec.join();
List<DocChunk> kw = fKw.join();
// RRF 融合(Day 98 讲过),再交重排压到 top-5
List<DocChunk> fused = RrfFusion.fuse(List.of(vec, kw));
return reranker.rerank(query, fused, 5);
}
}
注意一个坑:多路并发时总 QPS 会被乘上去。比如 2 路并发、外层 100 QPS,向量库实际承受 ~200 QPS。压测时一定要按"并发倍数"算容量,别只盯外层 QPS(这点 Day 101 容量规划时就要预留)。
四、热点 Query 缓存:RAG 里最被低估的一招
RAG 的查询有个特征:少量热点问题占了大部分流量("怎么退款""运费怎么算"这类 FAQ 式提问反复出现)。这些问题的召回结果几乎不变,完全没必要每次都打向量库 + LLM。缓存是性价比最高的优化,没有之一。
缓存要分两级:
-
L1 检索结果缓存:
query → 召回的 top-k 文档。命中就跳过向量检索和重排,直接进生成。 -
L2 完整答案缓存:
query → 最终回答。命中连 LLM 都省了,延迟从秒级降到毫秒级。
// RagCache.java
// 依赖:Caffeine(本地)+ Redis(集群共享),Spring Boot 3.x
// 关键:缓存 key 要做语义归一,否则"运费咋算""运费怎么算"会被当成两个 key
@Component
public class RagCache {
// L1:本地 Caffeine,存检索结果,TTL 短(话题会变)
private final Cache<String, List<DocChunk>> recallCache =
Caffeine.newBuilder().maximumSize(2000).expireAfterWrite(Duration.ofMinutes(10)).build();
// L2:Redis,存完整答案,TTL 可长一点
private final RedisTemplate<String, String> redis;
/** 对 query 做归一化,去掉标点/空格/大小写差异,让近义问法命中同一缓存 */
private String normalize(String q) {
return q.replaceAll("[\\s\\p{P}]+", "").toLowerCase();
}
/** L2 命中直接返回答案;L1 命中跳过检索;都 miss 才走全链路 */
public Optional<String> getAnswer(String query) {
String key = normalize(query);
String cached = redis.opsForValue().get("rag:ans:" + key);
return Optional.ofNullable(cached);
}
public Optional<List<DocChunk>> getRecall(String query) {
return Optional.ofNullable(recallCache.getIfPresent(normalize(query)));
}
public void putRecall(String query, List<DocChunk> chunks) {
recallCache.put(normalize(query), chunks);
}
public void putAnswer(String query, String answer) {
redis.opsForValue().set("rag:ans:" + normalize(query), answer, Duration.ofHours(1));
}
}
两个纪律:
-
缓存 key 必须归一化(上面
normalize),不然同义问法各存一份,命中率起不来。 -
答案缓存只适合事实稳定的内容。政策类、价格类问题 TTL 要短,且写入时打"数据版本号"——底层知识库一更新就批量清对应前缀(接 Day 99 的来源溯源思路)。
五、段3 优化:流式输出救"体感"
段3(LLM 生成)是用户体感延迟的大头,但首 token 延迟通常只有几百毫秒。只要把生成改成流式(边生成边往前端推),用户"看到字在动"的体感延迟就从"等全文 5 秒"变成"0.5 秒出第一个字"。这是投入产出比极高的一招。
// StreamingAnswerController.java
// 依赖:Spring AI ChatClient,SSE 流式返回
@RestController
@RequestMapping("/rag")
public class StreamingAnswerController {
private final ChatClient chatClient;
public StreamingAnswerController(ChatClient.Builder builder) {
this.chatClient = builder.build();
}
@GetMapping(value = "/ask", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> ask(@RequestParam String q, @RequestParam List<String> ctx) {
String prompt = """
你是客服助手,仅依据下面提供的上下文回答,不知道就说不知道。
上下文:
%s
问题:%s
""".formatted(String.join("\n---\n", ctx), q);
// stream() 返回 Flux<String>,每个元素是一小段增量文本,前端边收边渲染
return chatClient.prompt(prompt).stream().content();
}
}
配合前端 fetch + ReadableStream 或 EventSource,用户几乎感觉不到"在等"。切记:流式只改善体感,不减少总 token 消耗;真正的算力成本是另一回事,靠 Day 102 的模型选型和下面的清单控。
六、端到端优化清单(直接照抄)
把上面所有手段汇总成一张清单,按"见效快慢"排好序,别一上来就搞最复杂的:
| 优先级 | 手段 | 主要压的对象 | 预期收益 | 复杂度 |
|---|---|---|---|---|
| P0 | 热点 Query 答案缓存(L2) | 段3 + 段1 全跳过 | 毫秒级,削峰 30%~60% | 低 |
| P0 | 生成端流式输出 | 段3 体感 | 体感 5s→0.5s | 低 |
| P1 | Embedding 批量 + 异步 | 段1 吞吐 | 入库/检索吞吐 3~8x | 低 |
| P1 | 多路检索并发合并 | 段1 延迟 | 多路延迟砍到 1 路 | 中 |
| P2 | 检索结果缓存(L1) | 段1 跳过 | 省向量库 QPS | 低 |
| P2 | 重排 top-k 收窄(如 20→5) | 段1+段3 输入 | 生成更快更准 | 低 |
| P3 | 换小模型做首轮召回/重排 | 段1 算力 | 成本降,延迟降 | 中 |
调优铁律:每次只动一项,用 Day 95 的回归集跑出延迟和召回的对比数字。并行改三处,你永远不知道哪处涨了哪处跌了——性能优化和评测一样,得单变量看。
七、实战建议
-
先量后优,别凭感觉。上线前用真实流量形态压一遍,画出"延迟分布直方图"。80% 的请求卡在段1 还是段3,决定了你该先上缓存还是先上流式。我见过团队花两周做重排模型蒸馏,结果瓶颈在 LLM 首 token——白干。
-
缓存是头号杠杆,但一定要配失效策略。L1 靠 TTL,L2 靠"知识库版本号"主动失效。没有失效机制的缓存,迟早变成"用户投诉回答是上周的旧政策"。
-
压测按并发倍数算容量。多路检索、批量嵌入都会放大对下游(向量库/LLM)的实际 QPS,容量规划时把倍数算进去,否则上线即雪崩。
慢不是 RAG 的原罪,不知道它慢在哪才是。把延迟拆开,每一段都有现成的扳手。
下篇预告:Day 104 我们收口 RAG 深水区这一周,聊聊 RAG 的"记忆与状态"——多轮会话怎么记住上下文、长期用户画像怎么沉淀、个性化口径怎么落地。性能拧好了,接下来让 RAG 更"懂"你的用户。
37



被折叠的 条评论
为什么被折叠?



