查询转换手册¶

在执行作为RAG查询引擎、智能体或其他任何流程的一部分之前，用户查询可以通过多种方式进行转换和分解。

在本指南中，我们将向您展示多种转换、分解查询以及查找相关工具集的方法。每种技术可能适用于不同的使用场景！

出于命名目的，我们将底层流程定义为"工具"。以下是不同的查询转换方式：

路由: 保留查询内容，但识别出查询适用的相关工具子集。将这些工具输出为相关选项。
查询重写: 保留工具不变，但以多种不同方式重写查询，以便针对相同的工具执行。
子问题: 将查询分解为针对不同工具(通过其元数据识别)的多个子问题。
ReAct智能体工具选择: 根据初始查询，确定1)要选择的工具，以及2)要在该工具上执行的查询。

本指南的目标是向您展示如何将这些查询转换作为模块化组件使用。当然，这些组件都可以集成到更大的系统中（例如子问题生成器是我们SubQuestionQueryEngine的一部分）- 每个组件的详细指南链接如下。

看看并告诉我们你的想法！

In [ ]:

Copied!

%pip install llama-index-question-gen-openai
%pip install llama-index-llms-openai
%pip install llama-index-question-gen-openai
%pip install llama-index-llms-openai

In [ ]:

Copied!





from IPython.display import Markdown, display


# define prompt viewing function
def display_prompt_dict(prompts_dict):
    for k, p in prompts_dict.items():
        text_md = f"**Prompt Key**: {k}<br>" f"**Text:** <br>"
        display(Markdown(text_md))
        print(p.get_template())
        display(Markdown("<br><br>"))
from IPython.display import Markdown, display


# define prompt viewing function
def display_prompt_dict(prompts_dict):
    for k, p in prompts_dict.items():
        text_md = f"**Prompt Key**: {k}
" f"**Text:** 
"
        display(Markdown(text_md))
        print(p.get_template())
        display(Markdown("

"))

路由¶

在这个示例中，我们将展示如何通过查询来选择一组相关的工具选项。

我们使用selector抽象层来选择相关工具 - 根据抽象层级的不同，它可以是单个工具，也可以是多个工具。

我们有四种选择器：(LLM或函数调用) x (单选或多选)的组合

In [ ]:

Copied!





from llama_index.core.selectors import LLMSingleSelector, LLMMultiSelector
from llama_index.core.selectors import (
    PydanticMultiSelector,
    PydanticSingleSelector,
)
from llama_index.core.selectors import LLMSingleSelector, LLMMultiSelector
from llama_index.core.selectors import (
    PydanticMultiSelector,
    PydanticSingleSelector,
)

In [ ]:

Copied!





# pydantic selectors feed in pydantic objects to a function calling API
# single selector (pydantic, function calling)
# selector = PydanticSingleSelector.from_defaults()

# multi selector (pydantic, function calling)
# selector = PydanticMultiSelector.from_defaults()

# LLM selectors use text completion endpoints
# single selector (LLM)
# selector = LLMSingleSelector.from_defaults()
# multi selector (LLM)
selector = LLMMultiSelector.from_defaults()
# pydantic选择器将pydantic对象输入到函数调用API
# 单选择器 (pydantic, 函数调用)
# selector = PydanticSingleSelector.from_defaults()

# 多选择器 (pydantic, 函数调用)
# selector = PydanticMultiSelector.from_defaults()

# LLM选择器使用文本补全端点
# 单选择器 (LLM)
# selector = LLMSingleSelector.from_defaults()
# 多选择器 (LLM)
selector = LLMMultiSelector.from_defaults()

In [ ]:

Copied!





from llama_index.core.tools import ToolMetadata

tool_choices = [
    ToolMetadata(
        name="covid_nyt",
        description=("This tool contains a NYT news article about COVID-19"),
    ),
    ToolMetadata(
        name="covid_wiki",
        description=("This tool contains the Wikipedia page about COVID-19"),
    ),
    ToolMetadata(
        name="covid_tesla",
        description=("This tool contains the Wikipedia page about apples"),
    ),
]
from llama_index.core.tools import ToolMetadata

tool_choices = [
    ToolMetadata(
        name="covid_nyt",
        description=("该工具包含一篇关于COVID-19的纽约时报新闻文章"),
    ),
    ToolMetadata(
        name="covid_wiki",
        description=("该工具包含关于COVID-19的维基百科页面"),
    ),
    ToolMetadata(
        name="covid_tesla",
        description=("该工具包含关于苹果的维基百科页面"),
    ),
]

In [ ]:

Copied!

display_prompt_dict(selector.get_prompts())
display_prompt_dict(selector.get_prompts())

提示词键: prompt
文本:

Some choices are given below. It is provided in a numbered list (1 to {num_choices}), where each item in the list corresponds to a summary.
---------------------
{context_list}
---------------------
Using only the choices above and not prior knowledge, return the top choices (no more than {max_outputs}, but only select what is needed) that are most relevant to the question: '{query_str}'


The output should be ONLY JSON formatted as a JSON instance.

Here is an example:
[
    {{
        choice: 1,
        reason: "<insert reason for choice>"
    }},
    ...
]

In [ ]:

Copied!

selector_result = selector.select(
    tool_choices, query="Tell me more about COVID-19"
)
selector_result = selector.select(
    tool_choices, query="告诉我更多关于COVID-19的信息"
)

In [ ]:

Copied!

selector_result.selections
selector_result.selections

输出[ ]:

[SingleSelection(index=0, reason='This tool contains a NYT news article about COVID-19'),
 SingleSelection(index=1, reason='This tool contains the Wikipedia page about COVID-19')]

了解更多关于我们的路由抽象，请访问专用路由器页面。

查询重写¶

在本节中，我们将向您展示如何将查询重写为多个查询。然后您可以针对检索器执行所有这些查询。

这是高级检索技术中的关键步骤。通过查询重写，您可以为[集成检索]和[融合]生成多个查询，从而获得更高质量的检索结果。

与子问题生成器不同，这只是一个提示调用，独立于工具存在。

查询重写（自定义）¶

这里我们将向您展示如何使用提示通过我们的LLM和提示抽象来生成多个查询。

In [ ]:

Copied!





from llama_index.core import PromptTemplate
from llama_index.llms.openai import OpenAI

query_gen_str = """\
You are a helpful assistant that generates multiple search queries based on a \
single input query. Generate {num_queries} search queries, one on each line, \
related to the following input query:
Query: {query}
Queries:
"""
query_gen_prompt = PromptTemplate(query_gen_str)

llm = OpenAI(model="gpt-3.5-turbo")


def generate_queries(query: str, llm, num_queries: int = 4):
    response = llm.predict(
        query_gen_prompt, num_queries=num_queries, query=query
    )
    # assume LLM proper put each query on a newline
    queries = response.split("\n")
    queries_str = "\n".join(queries)
    print(f"Generated queries:\n{queries_str}")
    return queries
from llama_index.core import PromptTemplate
from llama_index.llms.openai import OpenAI

query_gen_str = """\
你是一个乐于助人的助手，能够基于单个输入查询生成多个搜索查询。请生成{num_queries}个搜索查询，每行一个，\
与以下输入查询相关：
查询：{query}
查询列表：
"""
query_gen_prompt = PromptTemplate(query_gen_str)

llm = OpenAI(model="gpt-3.5-turbo")


def generate_queries(query: str, llm, num_queries: int = 4):
    response = llm.predict(
        query_gen_prompt, num_queries=num_queries, query=query
    )
    # 假设LLM正确地将每个查询放在新行上
    queries = response.split("\n")
    queries_str = "\n".join(queries)
    print(f"生成的查询：\n{queries_str}")
    return queries

In [ ]:

Copied!

queries = generate_queries("What happened at Interleaf and Viaweb?", llm)
queries = generate_queries("Interleaf和Viaweb发生了什么?", llm)

Generated queries:
1. What were the major events or milestones in the history of Interleaf and Viaweb?
2. Who were the founders and key figures involved in the development of Interleaf and Viaweb?
3. What were the products or services offered by Interleaf and Viaweb?
4. Are there any notable success stories or failures associated with Interleaf and Viaweb?

In [ ]:

Copied!

queries
查询

输出[ ]:

['1. What were the major events or milestones in the history of Interleaf and Viaweb?',
 '2. Who were the founders and key figures involved in the development of Interleaf and Viaweb?',
 '3. What were the products or services offered by Interleaf and Viaweb?',
 '4. Are there any notable success stories or failures associated with Interleaf and Viaweb?']

如需了解关于带有检索器的端到端实现的更多详情，请查阅我们的融合检索器指南：

查询重写（使用QueryTransform）¶

在本节中，我们将向您展示如何使用我们的QueryTransform类进行查询转换。

In [ ]:

Copied!

from llama_index.core.indices.query.query_transform import HyDEQueryTransform
from llama_index.llms.openai import OpenAI
from llama_index.core.indices.query.query_transform import HyDEQueryTransform
from llama_index.llms.openai import OpenAI

In [ ]:

Copied!

hyde = HyDEQueryTransform(include_original=True)
llm = OpenAI(model="gpt-3.5-turbo")

query_bundle = hyde.run("What is Bel?")
hyde = HyDEQueryTransform(include_original=True)
llm = OpenAI(model="gpt-3.5-turbo")

query_bundle = hyde.run("Bel是什么？")

这会生成一个查询包，其中包含原始查询，还有代表应该被嵌入的查询的custom_embedding_strs。

In [ ]:

Copied!

new_query.custom_embedding_strs
new_query.custom_embedding_strs

输出[ ]:

['Bel is a term that has multiple meanings and can be interpreted in various ways depending on the context. In ancient Mesopotamian mythology, Bel was a prominent deity and one of the chief gods of the Babylonian pantheon. He was often associated with the sky, storms, and fertility. Bel was considered to be the father of the gods and held great power and authority over the other deities.\n\nIn addition to its mythological significance, Bel is also a title that was used to address rulers and leaders in ancient Babylon. It was a term of respect and reverence, similar to the modern-day title of "king" or "emperor." The title of Bel was bestowed upon those who held significant political and military power, and it symbolized their authority and dominion over their subjects.\n\nFurthermore, Bel is also a common given name in various cultures around the world. It can be found in different forms and variations, such as Belinda, Isabel, or Bella. As a personal name, Bel often carries connotations of beauty, grace, and strength.\n\nIn summary, Bel can refer to a powerful deity in ancient Mesopotamian mythology, a title of respect for rulers and leaders, or a personal name with positive attributes. The meaning of Bel can vary depending on the specific context in which it is used.',
 'What is Bel?']

子问题¶

给定一组工具和用户查询，决定1)要生成的子问题集合，以及2)每个子问题应该运行的工具。

我们通过一个示例来演示如何使用OpenAIQuestionGenerator(它依赖于函数调用)以及LLMQuestionGenerator(它依赖于提示)。

In [ ]:

Copied!

from llama_index.core.question_gen import LLMQuestionGenerator
from llama_index.question_gen.openai import OpenAIQuestionGenerator
from llama_index.llms.openai import OpenAI
from llama_index.core.question_gen import LLMQuestionGenerator
from llama_index.question_gen.openai import OpenAIQuestionGenerator
from llama_index.llms.openai import OpenAI

In [ ]:

Copied!

llm = OpenAI()
question_gen = OpenAIQuestionGenerator.from_defaults(llm=llm)
llm = OpenAI()
question_gen = OpenAIQuestionGenerator.from_defaults(llm=llm)

In [ ]:

Copied!

display_prompt_dict(question_gen.get_prompts())
display_prompt_dict(question_gen.get_prompts())

提示词键: question_gen_prompt
文本:

You are a world class state of the art agent.

You have access to multiple tools, each representing a different data source or API.
Each of the tools has a name and a description, formatted as a JSON dictionary.
The keys of the dictionary are the names of the tools and the values are the descriptions.
Your purpose is to help answer a complex user question by generating a list of sub questions that can be answered by the tools.

These are the guidelines you consider when completing your task:
* Be as specific as possible
* The sub questions should be relevant to the user question
* The sub questions should be answerable by the tools provided
* You can generate multiple sub questions for each tool
* Tools must be specified by their name, not their description
* You don't need to use a tool if you don't think it's relevant

Output the list of sub questions by calling the SubQuestionList function.

## Tools
```json
{tools_str}
```

## User Question
{query_str}

In [ ]:

Copied!





from llama_index.core.tools import ToolMetadata

tool_choices = [
    ToolMetadata(
        name="uber_2021_10k",
        description=(
            "Provides information about Uber financials for year 2021"
        ),
    ),
    ToolMetadata(
        name="lyft_2021_10k",
        description=(
            "Provides information about Lyft financials for year 2021"
        ),
    ),
]
from llama_index.core.tools import ToolMetadata

tool_choices = [
    ToolMetadata(
        name="uber_2021_10k",
        description=(
            "提供2021年Uber财务信息"
        ),
    ),
    ToolMetadata(
        name="lyft_2021_10k",
        description=(
            "提供2021年Lyft财务信息"
        ),
    ),
]

In [ ]:

Copied!

from llama_index.core import QueryBundle

query_str = "Compare and contrast Uber and Lyft"
choices = question_gen.generate(tool_choices, QueryBundle(query_str=query_str))
from llama_index.core import QueryBundle

query_str = "比较优步和Lyft的异同"
choices = question_gen.generate(tool_choices, QueryBundle(query_str=query_str))

输出结果为SubQuestion Pydantic对象。

In [ ]:

Copied!

choices
选择

输出[ ]:

[SubQuestion(sub_question='What are the financials of Uber for the year 2021?', tool_name='uber_2021_10k'),
 SubQuestion(sub_question='What are the financials of Lyft for the year 2021?', tool_name='lyft_2021_10k')]

如需了解如何以更集成的方式将此功能接入您的RAG流程，请查看我们的SubQuestionQueryEngine。

使用ReAct提示进行查询转换¶

ReAct是一个流行的智能体框架，这里我们展示如何利用核心ReAct提示来转换查询。

我们使用ReActChatFormatter来获取LLM的输入消息集。

In [ ]:

Copied!





from llama_index.core.agent import ReActChatFormatter
from llama_index.core.agent.react.output_parser import ReActOutputParser
from llama_index.core.tools import FunctionTool
from llama_index.core.llms import ChatMessage
from llama_index.core.agent import ReActChatFormatter
from llama_index.core.agent.react.output_parser import ReActOutputParser
from llama_index.core.tools import FunctionTool
from llama_index.core.llms import ChatMessage

In [ ]:

Copied!





def execute_sql(sql: str) -> str:
    """Given a SQL input string, execute it."""
    # NOTE: This is a mock function
    return f"Executed {sql}"


def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b


tool1 = FunctionTool.from_defaults(fn=execute_sql)
tool2 = FunctionTool.from_defaults(fn=add)
tools = [tool1, tool2]
def execute_sql(sql: str) -> str:
    """给定SQL输入字符串，执行它"""
    # 注意：这是一个模拟函数
    return f"Executed {sql}"


def add(a: int, b: int) -> int:
    """两数相加"""
    return a + b


tool1 = FunctionTool.from_defaults(fn=execute_sql)
tool2 = FunctionTool.from_defaults(fn=add)
tools = [tool1, tool2]

这里我们获取要传递给LLM的输入提示信息。来看看吧！

In [ ]:

Copied!





chat_formatter = ReActChatFormatter()
output_parser = ReActOutputParser()
input_msgs = chat_formatter.format(
    tools,
    [
        ChatMessage(
            content="Can you find the top three rows from the table named `revenue_years`",
            role="user",
        )
    ],
)
input_msgs
chat_formatter = ReActChatFormatter()
output_parser = ReActOutputParser()
input_msgs = chat_formatter.format(
    tools,
    [
        ChatMessage(
            content="你能从名为`revenue_years`的表中找出前三行数据吗",
            role="user",
        )
    ],
)
input_msgs

输出[ ]:

[ChatMessage(role=<MessageRole.SYSTEM: 'system'>, content='\nYou are designed to help with a variety of tasks, from answering questions     to providing summaries to other types of analyses.\n\n## Tools\nYou have access to a wide variety of tools. You are responsible for using\nthe tools in any sequence you deem appropriate to complete the task at hand.\nThis may require breaking the task into subtasks and using different tools\nto complete each subtask.\n\nYou have access to the following tools:\n> Tool Name: execute_sql\nTool Description: execute_sql(sql: str) -> str\nGiven a SQL input string, execute it.\nTool Args: {\'title\': \'execute_sql\', \'type\': \'object\', \'properties\': {\'sql\': {\'title\': \'Sql\', \'type\': \'string\'}}, \'required\': [\'sql\']}\n\n> Tool Name: add\nTool Description: add(a: int, b: int) -> int\nAdd two numbers.\nTool Args: {\'title\': \'add\', \'type\': \'object\', \'properties\': {\'a\': {\'title\': \'A\', \'type\': \'integer\'}, \'b\': {\'title\': \'B\', \'type\': \'integer\'}}, \'required\': [\'a\', \'b\']}\n\n\n## Output Format\nTo answer the question, please use the following format.\n\n```\nThought: I need to use a tool to help me answer the question.\nAction: tool name (one of execute_sql, add) if using a tool.\nAction Input: the input to the tool, in a JSON format representing the kwargs (e.g. {"input": "hello world", "num_beams": 5})\n```\n\nPlease ALWAYS start with a Thought.\n\nPlease use a valid JSON format for the Action Input. Do NOT do this {\'input\': \'hello world\', \'num_beams\': 5}.\n\nIf this format is used, the user will respond in the following format:\n\n```\nObservation: tool response\n```\n\nYou should keep repeating the above format until you have enough information\nto answer the question without using any more tools. At that point, you MUST respond\nin the one of the following two formats:\n\n```\nThought: I can answer without using any more tools.\nAnswer: [your answer here]\n```\n\n```\nThought: I cannot answer the question with the provided tools.\nAnswer: Sorry, I cannot answer your query.\n```\n\n## Current Conversation\nBelow is the current conversation consisting of interleaving human and assistant messages.\n\n', additional_kwargs={}),
 ChatMessage(role=<MessageRole.USER: 'user'>, content='Can you find the top three rows from the table named `revenue_years`', additional_kwargs={})]

接下来我们从模型获取输出。

In [ ]:

Copied!

llm = OpenAI(model="gpt-4-1106-preview")
llm = OpenAI(model="gpt-4-1106-preview")

In [ ]:

Copied!

response = llm.chat(input_msgs)
response = llm.chat(input_msgs)

最后我们使用ReActOutputParser将内容解析为结构化输出，并分析动作输入。

In [ ]:

Copied!

reasoning_step = output_parser.parse(response.message.content)
reasoning_step = output_parser.parse(response.message.content)

In [ ]:

Copied!

reasoning_step.action_input
推理步骤.动作输入

输出[ ]:

{'sql': 'SELECT * FROM revenue_years ORDER BY revenue DESC LIMIT 3'}