在信息检索领域，查询扩展技术正在推动一场效率变革。那么，这项“拼图”技术究竟如何运作？LangChain与Llama-Index两款主流框架又是怎样落地实现的？本文将带领读者深入剖析多查询检索的核心机制，并对比这两大框架在实现上的差异。

首先明确几个关键结论：当用户的查询过于宽泛或模糊时，传统检索容易偏离目标，而多查询检索通过从多个角度生成问题，能显著提升召回率。其本质，是对语义鸿沟的一种巧妙弥补。

1 查询扩展

什么是查询扩展？简单而言，它是一种通过在原始查询中添加相关或同义词汇来优化搜索结果的信息检索技术。这种方法能够丰富查询的语义，从而提升检索系统的准确性和相关性。

在多查询检索中，查询扩展正是其核心策略。它会自动生成多个相关的查询请求，从而扩大搜索范围，帮助用户更全面地获取所需信息。对于复杂查询，这种技术尤为有效——例如，当用户搜索“AI在医疗领域的应用”，系统会自动衍生出“机器学习诊断”、“深度学习影像识别”等变体，大大降低信息遗漏的风险。

2 机制

当系统接收到一个查询请求后，并不会直接前往数据库检索，而是先借助高级语言模型“脑补”出一个与原查询相近的新查询。这个新查询随后被用于在Llama-Index中检索相关文档，从而获取与原查询高度相关的信息。整个过程增强了上下文理解，确保结果更精准、更符合用户的实际需求。

两次LLM交互：

为了精确生成查询，流程设计了向大型语言模型（LLM）并行发出两次请求：初次使用GPT-3模型，之后可能升级为GPT-4或其他更高级模型，以获取更丰富的查询结果。这种分层调用本质上是一种“先粗筛、再精调”的策略。

3 实现方法

3.1 LangChain

loader = UnstructuredPDFLoader(FILE_NAME)
docs = loader.load()

text_splitter = SentenceTransformersTokenTextSplitter()
texts = text_splitter.split_documents(docs)

emb = OpenAIEmbeddings(openai_api_key=openai.api_key)
vec_db = Chroma.from_documents(documents=texts, embedding=emb)

lc_model = ChatOpenAI(openai_api_key=openai.api_key, temperature=1.5)
base_retriever = vec_db.as_retriever(k=K)
final_retriever = MultiQueryRetriever.from_llm(base_retriever, lc_model)

tmpl = """
You are an assistant to answer a question from user with a context.

Context:
{context}

Question:
{question}

The response should be presented as a list of key points, after creating the title of the content,
    formatted in HTML with appropriate markup for clarity and organization.
"""
prompt = ChatPromptTemplate.from_template(tmpl)
chain = {"question": RunnablePassthrough(), "context": final_retriever} 
        | prompt 
        | lc_model 
        | StrOutputParser() 

result = chain.invoke("What is the doc talking about?")

LangChain的实现相对简洁，这主要得益于MultiQueryRetriever类已经封装好了大部分细节。其核心机制很简单：配备一个基础检索器后，自动生成最多三个定制化的查询。整个过程安全且封装完善，开发者只需直接调用即可。

3.2 Llama-Index

Llama-Index的实现则更为“硬核”——因为它要求开发者不仅要手动创建“生成的查询”，还需自行实现这些查询的检索流程。面对多查询需求，这里采用了必要的协程机制来确保过程顺利进行。

vector_index: BaseIndex = VectorStoreIndex.from_documents(
    docs,
    service_context=service_context, 
    show_progress=True,
)

base_retriever = vector_index.as_retriever(similarity_top_k=K)

class MultiQueriesRetriever(BaseRetriever):
    def __init__(self, base_retriever: BaseRetriever, model:OpenAI):
        self.template = PromptTemplate("""You are an AI language model assistant. Your task is to generate Five
    different versions of the given user question to retrieve relevant documents from a vector
    database. By generating multiple perspectives on the user question, your goal is to
    help the user overcome some of the limitations of the distance-based similarity search.
    Provide these alternative questions seperated by newlines.
    Original question: {question}""")
        self._retrievers = [base_retriever]
        self.base_retriever = base_retriever
        self.model = model
    
    def gen_queries(self, query) -> List[str]:
        gen_queries_model = OpenAI(model="gpt-3-turbo", temperature=1.5)
        prompt = self.template.format(question=query)
        res = self.model.complete(prompt)
        return res.text.split("n")

    async def run_gen_queries(self,generated_queries: List[str]) -> List[NodeWithScore]:
        tasks = list(map(lambda q: self.base_retriever.aretrieve(q), generated_queries)) 
        res = await tqdm.gather(*tasks)
        return res[0]

    def _retrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]:
        return list()

    async def _aretrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]:
        query = query_bundle.query_str
        generated_queries = self.gen_queries(query)
        query_res = await self.run_gen_queries(generated_queries)
        return query_res

    
mr = MultiQueriesRetriever(base_retriever, li_model)

final_res = await RetrieverQueryEngine(mr).aquery(query_text)

关键一步是继承BaseRetriever类，将其功能与基础检索器相融合，以便根据生成的查询检索信息。由于这些生成的查询是通过协程机制实现的，因此需要对_aretrieve方法进行重写。这段代码的核心逻辑是：先生成多个问题，再并行检索，最后汇总结果。如果你熟悉Python的异步编程，这种模式会非常自然。

3.3 子问题查询引擎

Llama-Index还提供了一个名为SubQuestionQueryEngine的类，它基本上能满足我们对复杂查询的需求。有趣的是，该类并非采用“生成相似查询”的思路，而是将复杂查询分解成多个子问题。来看具体用法：

query_engine_tools = [
    QueryEngineTool(
        query_engine=vector_query_engine,
        metadata=ToolMetadata(
            name="pg_essay",
            description="Paul Graham essay on What I Worked On",
        ),
    ),
]

query_engine = SubQuestionQueryEngine.from_defaults(
    query_engine_tools=query_engine_tools,
    use_async=True,
)

response = query_engine.query(
    "How was Paul Grahams life different before, during, and after YC?"
)

SubQuestionQueryEngine的工作原理是将复杂的原始查询拆分成多个子问题，每个子问题都针对特定的数据源。这些子问题的答案不仅提供了必要的上下文信息，还为构建最终答案做出了贡献。每个子问题专门设计用来从相应的数据源中抽取关键信息，综合这些答案，就能得到对原始查询的完整回应。

此外，SubQuestionQueryEngine能够将一个复杂查询细化为多个子问题，并为每个子问题指定相应的查询引擎进行处理。一旦所有子问题都得到解答，这些答案将被汇总并传递给响应合成器，以生成最终的答案。在该过程中，引擎会根据SubQuestion中的tool_name属性，决定使用哪个QueryEngineTool来处理每个子问题。