Query Rewriting 和 Multi-Query Retrieval 是怎么工作的?
Amit Shekhar
2026-10-08
D
原文
---
title: "Query Rewriting 和 Multi-Query Retrieval 是怎么工作的?"
author: "Amit Shekhar"
source_url: "https://outcomeschool.com/blog/how-do-query-rewriting-and-multi-query-retrieval-work"
published_at: "2026-10-08T00:00:00.000Z"
fetched_at: "2026-10-08T15:06:24Z"
updated_at: "2026-10-08T15:08:47Z"
language: "zh"
review_status: "draft"
---
# Query Rewriting 和 Multi-Query Retrieval 是怎么工作的?

Query Rewriting(查询改写)和 Multi-Query Retrieval(多查询检索)是改进 AI 系统搜索步骤的两种方法。Query Rewriting 用 LLM 把用户含混的问题改写成一个清晰的搜索查询;Multi-Query Retrieval 则用 LLM 把问题改写成多个不同的搜索查询,分别搜索,再把结果合并起来。
这篇文章会讲清楚 Query Rewriting 和 Multi-Query Retrieval 是怎么工作的。我们还会看到:为什么用户原始问题往往不是一个好的搜索查询,Query Rewriting 怎样修复含糊、追问和措辞不佳的问题,Multi-Query Retrieval 怎样从多个角度搜索,多次搜索得到的结果怎样用 Reciprocal Rank Fusion 合并,它们彼此有什么不同,以及什么时候该用哪一个。
我们会覆盖这些内容:
- 问题:用户的问题不是一个好的搜索查询
- 什么是 Query Rewriting?
- Query Rewriting 是怎么工作的?
- Query Rewriting 的类型
- Query Rewriting 的代码示例
- Query Rewriting 没能解决的问题
- 什么是 Multi-Query Retrieval?
- Multi-Query Retrieval 是怎么工作的?
- 怎么合并结果?Reciprocal Rank Fusion
- Multi-Query Retrieval 的代码示例
- Query Rewriting vs Multi-Query Retrieval
- 它们适合哪里,又会在哪里失效
我是 **Amit Shekhar**, [Outcome School](https://outcomeschool.com) 创始人。我教过并辅导过很多开发者,他们凭自己的努力拿到了高薪技术工作,也帮助很多科技公司解决了各自独特的问题,还创建了很多被顶级公司使用的开源库。我热衷于通过开源、博客和视频分享知识。
我在 Outcome School 教 [AI and Machine Learning](https://outcomeschool.com/program/ai-and-machine-learning)。
我们开始吧。
## 问题:用户的问题不是一个好的搜索查询
Query Rewriting 和 Multi-Query Retrieval 用在 **RAG**(Retrieval-Augmented Generation,检索增强生成)的检索步骤里。在这个步骤中,我们搜索自己的文档,挑出和问题最相关的文本片段,也就是 **[chunks](https://outcomeschool.com/blog/chunking-strategies-for-rag)**,再把它们交给 LLM,然后让 LLM 回答。
流程大致如下:
```
User question -> Retriever -> Top chunks -> LLM -> Answer
```
**如果检索拿回了错误的 chunk,LLM 往往就会给出错误答案。**
而检索完全取决于我们拿什么文本去搜。这段用于搜索的文本叫做 **search query**。
在一个简单的 RAG 系统里,我们会直接用用户原样输入的问题去搜索。但真实用户并不会输入完美的搜索查询。
来看几个真实场景:
- **追问:** 用户先问:“Pro plan 的退款政策是什么?”。接着又问:“Basic 那个呢?”。如果我们拿 “And what about the Basic one?” 去搜索,retriever 根本不知道这里说的是退款。
- **问题含糊:** “更新之后我的东西不能用了。”哪个东西?哪次更新?
- **用词不同:** 用户问:“我要怎么把钱拿回来?”,但文档里写的是 “refund process”。关键词搜索匹配不上。
- **噪声太多:** “你好,希望你一切都好,想快速问一下,我经理让我问,我们一年有多少天假?”这些词里大部分对搜索都没用。
- **一个问题里包含多个问题:** “比较一下 phone A 和 phone B 的电池续航和价格。”这需要从好几个不同地方找信息。
在这些情况下,retriever 拿回来的 chunk 质量会很差,LLM 给出的答案也会很差。
所以,Query Rewriting 就派上用场了。
## 什么是 Query Rewriting?
**Query Rewriting 是这样一个步骤:在搜索之前,让 LLM 把用户的问题改写成一个清晰、完整、适合搜索的查询。**
这有点像你去一座大图书馆,对图书管理员说:“我想找那本讲男孩巫师的书。”图书管理员不会去搜 “boy wizard”,而会去搜 “Harry Potter”。图书管理员改写了我们的查询。
现在流程变成这样:
```
User question -> LLM rewrites -> Clear query -> Retriever -> Top chunks -> LLM -> Answer
```
答案仍然会根据用户的原始问题来写。只有搜索这一步会使用改写后的查询。
## Query Rewriting 是怎么工作的?
理解它最好的方式,是看一个例子。
**第一步:** 用户正在和客服机器人聊天。
```
User: What is the refund policy of the Pro plan?
Bot: You can get a full refund within 30 days.
User: And what about the Basic one?
```
**第二步:** 搜索之前,我们把聊天历史和最新问题一起发给 LLM,并附上一条这样的指令:
```
Given the conversation and the latest question, rewrite the latest
question as a standalone search query that contains all the needed
details. Return only the query.
```
**第三步:** LLM 返回:
```
Refund policy of the Basic plan
```
**第四步:** 我们用 “Refund policy of the Basic plan” 去搜索。现在,retriever 就能找到关于 Basic plan 退款的正确 chunk。
**第五步:** 我们把这个 chunk 和用户的问题交给 LLM,它就能正确回答。
## Query Rewriting 的类型
Query Rewriting 是一个思路,但根据使用场景不同,它可以有几种不同用法:
- **改写成独立问题:** 利用聊天历史,把追问改写成一个完整问题。就像上面的退款例子。这是聊天应用里最常见的类型。
- **澄清和清理:** 去掉噪声,修正拼写,只保留重要词。“Hi, quick question, how many leaves do we get in a year?” 变成 “Annual leave policy number of days”。
- **扩展:** 加入文档里更可能出现的词。“How do I get my money back?” 变成 “refund process, return money, get refund”。
- **后退式改写(Step-back rewriting):** 把一个非常具体的问题改写成更泛化的问题,以便找到背景信息。“Why did my order #4521 get delayed in Mumbai?” 变成 “Reasons for order delivery delays”。
它们都遵循同一个模式:LLM 改写查询,然后我们拿改写后的查询去搜索。和这些方法很接近的还有 [HyDE](https://outcomeschool.com/blog/how-does-hyde-work):LLM 写的不是查询,而是一段假想答案,然后我们拿这段答案去搜索。
## Query Rewriting 的代码示例
现在来看一个简单的 Query Rewriting 步骤的代码。这里,`call_llm` 会把 prompt 发给 LLM 并返回文本,`retriever.search` 会搜索我们的 chunk。为了便于理解,我们把它们的细节隐藏起来。
```python
def rewrite_query(chat_history, question):
prompt = f"""Given the conversation and the latest question, rewrite the
latest question as a standalone search query. Return only the query.
Conversation:
{chat_history}
Latest question: {question}"""
return call_llm(prompt).strip()
def answer(chat_history, question):
search_query = rewrite_query(chat_history, question)
chunks = retriever.search(search_query, top_k=5)
return call_llm(f"Context:\n{chunks}\n\nQuestion: {question}\nAnswer:")
```
这里有几件事:
- `rewrite_query` 用聊天历史和最新问题构造 prompt,让 LLM 生成一个干净的搜索查询。
- 在 `answer` 里,我们先改写问题,再用改写后的查询搜索。
- 最后,我们把找到的 chunk 和原始问题交给 LLM,让它写出答案。
这里可以注意到:用户永远看不到改写后的查询。它只用于搜索。
**给你一个小提示**
不管你在哪个技术领域工作,都应该熟悉这些主题:
- LLM
- RAG
- MCP
- Agent
- Fine-tuning
- Quantization
我们把这些内容放进了一个视频:
[AI Engineering Explained: LLM, RAG, MCP, Agent, Fine-Tuning, and Quantization](https://www.youtube.com/watch?v=lnfWvX66FUk)
不用停下来现在就看——先收藏起来,等有时间再看。以后的你会感谢现在的自己。
现在,我们回到正题。
## Query Rewriting 没能解决的问题
Query Rewriting 给了我们一个更好的查询。但无论这个查询多好,一个查询都只能从一个角度看问题。
假设用户问:“Is the new phone good for gaming?”。有用的信息可能分散在很多地方:
- 一段关于处理器的 chunk。
- 一段关于屏幕刷新率的 chunk。
- 一段关于长时间使用时发热和电池表现的 chunk。
像 “new phone gaming performance” 这样的单个查询可能找到第一段 chunk,却漏掉其他内容,因为它们用的词非常不一样。
另外,如果 LLM 把查询稍微改错了,我们也没有备份。一次糟糕的改写,就可能导致糟糕的检索。
所以问题来了:如果我们同时从多个角度搜索,会怎么样?
这就轮到 Multi-Query Retrieval 出场了。
## 什么是 Multi-Query Retrieval?
**Multi-Query Retrieval 是一种方法:LLM 为用户问题生成几个不同版本的查询,我们分别用每个版本去搜索,然后把所有结果合并成一个列表。**
这就像在家里找一把丢失的钥匙。如果我们只在卧室找,就可能错过它。如果三个家人同时去卧室、厨房和车里找,找到钥匙的概率就高得多。
## Multi-Query Retrieval 是怎么工作的?
我们继续用同一个游戏手机的例子。
**第一步:** 用户问:“Is the new phone good for gaming?”。
**第二步:** 我们让 LLM 为同一个问题生成,比如 3 个不同的搜索查询:
```
Query 1: new phone processor and graphics performance
Query 2: new phone display refresh rate and touch response
Query 3: new phone heating and battery life during heavy use
```
**第三步:** 我们分别用每个查询去搜索。每次搜索都会返回各自排在前面的 chunk。
```
Query 1 -> [processor chunk, benchmark chunk, ...]
Query 2 -> [display chunk, touch chunk, ...]
Query 3 -> [battery chunk, heating chunk, ...]
```
**第四步:** 我们把所有结果合并成一个列表,并去掉重复项,因为同一个 chunk 可能来自不止一个查询。
**第五步:** 我们把合并后的 chunk 和原始问题交给 LLM,它就会写出一个覆盖速度、显示效果和电池的完整答案。
流程大致如下:
```
/--> Query 1 -> Retriever -> results 1 \
User question -> LLM ---> Query 2 -> Retriever -> results 2 --> Merge -> LLM -> Answer
\--> Query 3 -> Retriever -> results 3 /
```
**注意:** 很多系统还会把用户的原始问题保留为其中一个查询,这样我们就不会丢掉一次普通搜索本来能找到的内容。
同样,Multi-Query Retrieval 也能解决前面提到的“一个问题里包含多个问题”的情况。对于 “Compare the battery life and price of phone A and phone B”(比较 phone A 和 phone B 的电池续航和价格),LLM 可以把它拆成更小的问题,比如 “phone A battery life”、“phone A price”、“phone B battery life” 和 “phone B price”。像这样把一个大问题拆成更小的问题,叫做 **query decomposition(查询分解)**。
## 怎么合并结果?Reciprocal Rank Fusion
接下来一个大问题是:我们怎么合并这些列表?
最简单的方法是把所有列表里的 chunk 全拿出来,去掉重复项,然后保留下来。这叫取 **union(并集)**。它能工作,但不会告诉我们哪些 chunk 最重要。
更好的方法是 **Reciprocal Rank Fusion**,简称 **RRF**。当 Multi-Query Retrieval 和 RRF 结合使用时,它通常也叫 **RAG-Fusion**。
**RRF 会根据每个 chunk 在各个列表中的位置给它打分,并把它在所有列表中的分数加起来。**
公式如下:
**一个 chunk 的 RRF score = 对所有列表求和 1 / (k + rank)**
这里,`rank` 是 chunk 在该列表中的位置(第 1 名就是排在最前),`k` 是一个常数,通常取 60。
这里的 “reciprocal” 只是指 “1 除以”。排在列表顶部的 chunk 会拿到更高分。一个 chunk 如果出现在多个列表中,就会从每个列表里累积分数。
来看一个例子:3 个查询以及它们各自排前 3 的 chunk:
```
Query 1 -> [D2, D5, D1]
Query 2 -> [D5, D3, D2]
Query 3 -> [D5, D2, D4]
```
现在,我们用 `k = 60` 来计算:
```
D5: 1/(60+2) + 1/(60+1) + 1/(60+1) = 0.0161 + 0.0164 + 0.0164 = 0.0489
D2: 1/(60+1) + 1/(60+3) + 1/(60+2) = 0.0164 + 0.0159 + 0.0161 = 0.0484
D3: 1/(60+2) = 0.0161
D1: 1/(60+3) = 0.0159
D4: 1/(60+3) = 0.0159
```
最终顺序是 D5、D2、D3,然后是同分的 D1 和 D4。
这里可以看到,D5 胜出,是因为它在三个列表里都排得很靠前。D2 紧随其后。D3、D1 和 D4 都只出现在一个列表中,所以排在后面。
RRF 只需要位置,不需要原始分数。因此,即使这些列表来自不同类型的搜索,它也能工作。这也是为什么 RRF 是合并关键词搜索和语义搜索结果时最常用的方法,相关内容可以看 [Hybrid Search](https://outcomeschool.com/blog/how-does-hybrid-search-work)。
如果你想系统掌握 RAG、Vector Databases、设计一个 RAG 系统(和你的文档聊天),并从零开始构建 AI Tutor,可以了解 Outcome School 的 [AI and Machine Learning Program](https://outcomeschool.com/program/ai-and-machine-learning)。
## Multi-Query Retrieval 的代码示例
现在来看使用 RRF 做 Multi-Query Retrieval 的代码。我们可以这样写:
```python
def generate_queries(question, n=3):
prompt = f"""Write {n} different search queries for the question below.
Each query must look at the question from a different angle.
Return one query per line.
Question: {question}"""
lines = call_llm(prompt).strip().split("\n")
return [question] + [line.strip() for line in lines if line.strip()]
def rrf_merge(result_lists, k=60):
scores = {}
for results in result_lists:
for rank, chunk_id in enumerate(results, start=1):
scores[chunk_id] = scores.get(chunk_id, 0) + 1 / (k + rank)
return sorted(scores, key=scores.get, reverse=True)
def multi_query_search(question, top_k=5):
queries = generate_queries(question)
result_lists = [retriever.search(q, top_k=top_k) for q in queries]
return rrf_merge(result_lists)[:top_k]
```
这里有几件事:
- `generate_queries` 会让 LLM 生成 `n` 个不同查询,每行一个,同时也把原始问题保留在列表里。
- `retriever.search` 会为每个查询返回一组 chunk id,最相关的排在最前。
- `rrf_merge` 会遍历每个列表,给每个 chunk 加上 `1 / (k + rank)`,再把分数相加。然后,它按总分对 chunk 排序。重复项会自动处理,因为同一个 chunk id 只是会累积更多分数。
- `multi_query_search` 把所有步骤串起来,返回最好的 `top_k` 个 chunk。
## Query Rewriting vs Multi-Query Retrieval
为了方便理解,我把 Query Rewriting 和 Multi-Query Retrieval 的区别整理成表格。
| Point | Query Rewriting | Multi-Query Retrieval |
| --- | --- | --- |
| LLM 步骤的输出 | 一个更好的查询 | 几个不同查询 |
| 搜索次数 | 一次 | 每个查询一次 |
| 主要优势 | 修复追问、含糊问题和带噪声的问题 | 找到分散在不同地方的信息 |
| 面对糟糕改写的安全性 | 没有备份 | 其他查询可以作为备份 |
| 是否需要合并步骤 | 不需要 | 需要,使用 union 或 RRF |
| 速度和成本 | 快,只多一次 LLM 调用 | 更慢,一次额外 LLM 调用,加上多次搜索 |
| 最适合 | 带追问的聊天应用 | 宽泛问题或包含多部分的问题 |
**注意:** 两者可以一起用。先把追问改写成一个独立问题,再基于这个干净的问题生成多个查询。
在 [Agentic RAG](https://outcomeschool.com/blog/agentic-rag) 里,agent 还会再往前走一步:它会自行决定什么时候改写查询,什么时候再次搜索。
**保持更新:** 订阅我们的 [邮件通讯](https://outcomeschool.substack.com/subscribe),第一时间收到最新的 AI 和 Machine Learning 博客。
## 它们适合哪里,又会在哪里失效
**优点:**
- 两者都能在不修改文档和 retriever 的情况下改进检索。
- Query Rewriting 能让聊天中的追问被正确处理。
- Multi-Query Retrieval 能找到更多有用 chunk,这叫更好的 **[recall](https://outcomeschool.com/blog/precision-vs-recall)**。
- 两者都可以配合任何 retriever 使用:关键词搜索、[vector search](https://outcomeschool.com/blog/how-does-a-vector-database-work),或者两者一起用。
**缺点:**
- 两者都会在搜索前增加一次额外的 LLM 调用,也就增加了时间和成本。
- LLM 在改写时可能改变原意。比如,它可能漏掉版本号这样的重要细节。我们必须认真测试改写 prompt。
- Multi-Query Retrieval 可能带回一些只是松散相关的 chunk,给 prompt 增加噪声。合并之后再加一个 [reranker](https://outcomeschool.com/blog/how-does-a-reranker-work),可以按真正的相关性重新排列 chunk,让只有最好的 chunk 进入 LLM。
- 对于简单清楚的问题,它们会增加成本,却未必带来多少收益。
Query Rewriting 和 Multi-Query Retrieval 改进的是搜索的问题侧。我们还可以改进 chunk 侧:给每个 chunk 加一小段说明,标明它来自文档里的什么位置。我们有一篇详细文章介绍 [Contextual Retrieval 是怎么工作的](https://outcomeschool.com/blog/how-does-contextual-retrieval-work),从头到尾解释了这件事。
现在,我们应该已经明白 Query Rewriting 和 Multi-Query Retrieval 是怎么工作的、它们有什么区别,以及什么时候该用哪一个。
## 常见问题
### 用户会看到改写后的查询吗?
不会。用户永远看不到改写后的查询。它只用于搜索。最终答案仍然根据用户的原始问题,以及改写查询找到的 chunk 来写。
### Query Rewriting 和 Multi-Query Retrieval 可以一起用吗?
可以。两者可以一起用。先利用聊天历史,把追问改写成一个独立问题。然后,从这个干净的问题生成多个查询,分别搜索,再合并结果。
### 为什么要在 Multi-Query Retrieval 里把原始问题保留为一个查询?
很多系统会把用户的原始问题保留为其中一个查询,这样就不会丢掉一次普通搜索本来能找到的内容。其他查询也能作为备份,避免一次糟糕改写毁掉结果。
### Reciprocal Rank Fusion 使用的 k 是多少?
常数 k 通常设为 60。每个 chunk 会从它出现的每个列表中拿到 1 / (k + rank),这些分数会相加。一个 chunk 如果在多个列表中都排得很靠前,就会拿到最高的总分。
这次就到这里。
谢谢
**Amit Shekhar** [Outcome School](https://outcomeschool.com) 创始人