在进行查询分析时如何处理多个查询

有时，一种查询分析技术可能会生成多个查询。在这种情况下，我们需要记得运行所有查询，然后将结果合并。我们将通过一个简单的示例（使用模拟数据）来展示如何实现这一点。

设置

安装依赖项

%pip install -qU langchain langchain-community langchain-openai langchain-chroma

Note: you may need to restart the kernel to use updated packages.

设置环境变量

在本示例中，我们将使用 OpenAI：

import getpass
import os

if "OPENAI_API_KEY" not in os.environ:
    os.environ["OPENAI_API_KEY"] = getpass.getpass()

# Optional, uncomment to trace runs with LangSmith. Sign up here: https://smith.langchain.com.
# os.environ["LANGSMITH_TRACING"] = "true"
# os.environ["LANGSMITH_API_KEY"] = getpass.getpass()

创建索引

我们将创建一个虚假信息的向量存储。

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter

texts = ["Harrison worked at Kensho", "Ankush worked at Facebook"]
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_texts(
    texts,
    embeddings,
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 1})

API 参考：OpenAIEmbeddings | RecursiveCharacterTextSplitter

查询分析

我们将使用函数调用的方式来结构化输出。我们将让它返回多个查询。

from typing import List, Optional

from pydantic import BaseModel, Field


class Search(BaseModel):
    """Search over a database of job records."""

    queries: List[str] = Field(
        ...,
        description="Distinct queries to search for",
    )

from langchain_core.output_parsers.openai_tools import PydanticToolsParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI

output_parser = PydanticToolsParser(tools=[Search])

system = """You have the ability to issue search queries to get information to help answer user information.

If you need to look up two distinct pieces of information, you are allowed to do that!"""
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", system),
        ("human", "{question}"),
    ]
)
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
structured_llm = llm.with_structured_output(Search)
query_analyzer = {"question": RunnablePassthrough()} | prompt | structured_llm

API 参考：PydanticToolsParser | ChatPromptTemplate | RunnablePassthrough | ChatOpenAI

我们可以看到，这使得创建多个查询成为可能

query_analyzer.invoke("where did Harrison Work")

Search(queries=['Harrison Work', 'Harrison employment history'])

query_analyzer.invoke("where did Harrison and ankush Work")

Search(queries=['Harrison work history', 'Ankush work history'])

通过查询分析进行检索

那么我们该如何将其包含在链中呢？如果我们将检索器异步调用，将会方便很多——这样我们就可以循环处理查询，而不会因响应时间被阻塞。

from langchain_core.runnables import chain

API 参考：Chains

@chain
async def custom_chain(question):
    response = await query_analyzer.ainvoke(question)
    docs = []
    for query in response.queries:
        new_docs = await retriever.ainvoke(query)
        docs.extend(new_docs)
    # You probably want to think about reranking or deduplicating documents here
    # But that is a separate topic
    return docs

await custom_chain.ainvoke("where did Harrison Work")

[Document(page_content='Harrison worked at Kensho'),
 Document(page_content='Harrison worked at Kensho')]

await custom_chain.ainvoke("where did Harrison and ankush Work")

[Document(page_content='Harrison worked at Kensho'),
 Document(page_content='Ankush worked at Facebook')]