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 创始人。我教过并辅导过很多开发者,他们凭自己的努力拿到了高薪技术工作,也帮助很多科技公司解决了各自独特的问题,还创建了很多被顶级公司使用的开源库。我热衷于通过开源、博客和视频分享知识。

我在 Outcome School 教 AI and Machine Learning。

我们开始吧。

问题:用户的问题不是一个好的搜索查询

Query Rewriting 和 Multi-Query Retrieval 用在 RAG(Retrieval-Augmented Generation,检索增强生成)的检索步骤里。在这个步骤中,我们搜索自己的文档,挑出和问题最相关的文本片段,也就是 chunks,再把它们交给 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:LLM 写的不是查询,而是一段假想答案,然后我们拿这段答案去搜索。

Query Rewriting 的代码示例

现在来看一个简单的 Query Rewriting 步骤的代码。这里,call_llm 会把 prompt 发给 LLM 并返回文本,retriever.search 会搜索我们的 chunk。为了便于理解,我们把它们的细节隐藏起来。

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

不用停下来现在就看——先收藏起来,等有时间再看。以后的你会感谢现在的自己。

现在,我们回到正题。

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。

如果你想系统掌握 RAG、Vector Databases、设计一个 RAG 系统(和你的文档聊天),并从零开始构建 AI Tutor,可以了解 Outcome School 的 AI and Machine Learning Program。

Multi-Query Retrieval 的代码示例

现在来看使用 RRF 做 Multi-Query Retrieval 的代码。我们可以这样写:

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 里,agent 还会再往前走一步:它会自行决定什么时候改写查询,什么时候再次搜索。

保持更新: 订阅我们的 邮件通讯,第一时间收到最新的 AI 和 Machine Learning 博客。

它们适合哪里,又会在哪里失效

优点:

  • 两者都能在不修改文档和 retriever 的情况下改进检索。

  • Query Rewriting 能让聊天中的追问被正确处理。

  • Multi-Query Retrieval 能找到更多有用 chunk,这叫更好的 recall。

  • 两者都可以配合任何 retriever 使用:关键词搜索、vector search,或者两者一起用。

缺点:

  • 两者都会在搜索前增加一次额外的 LLM 调用,也就增加了时间和成本。

  • LLM 在改写时可能改变原意。比如,它可能漏掉版本号这样的重要细节。我们必须认真测试改写 prompt。

  • Multi-Query Retrieval 可能带回一些只是松散相关的 chunk,给 prompt 增加噪声。合并之后再加一个 reranker,可以按真正的相关性重新排列 chunk,让只有最好的 chunk 进入 LLM。

  • 对于简单清楚的问题,它们会增加成本,却未必带来多少收益。

Query Rewriting 和 Multi-Query Retrieval 改进的是搜索的问题侧。我们还可以改进 chunk 侧:给每个 chunk 加一小段说明,标明它来自文档里的什么位置。我们有一篇详细文章介绍 Contextual Retrieval 是怎么工作的,从头到尾解释了这件事。

现在,我们应该已经明白 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 创始人