User Query Recommnedation

[Esg-developers]

Hi Team

I have a RAG application, which is responsible for performing text-to-sql. After a user query comes in and complete the execution, along with the output of that query i want to give 3-5 more recommended queries to prompt in the chatbot.
consider i have the metadata.csv consisting of column names and its definitions.

So using this data how can i build the query recommendation pipeline?

Thanks, Pradipta

[dosubot[bot]]

Hello @Esg-developers! I'm here to help you with any bugs, questions, or contributions you may have. If you need assistance, feel free to ask.

To build a query recommendation pipeline using the metadata.csv file for your RAG application responsible for performing text-to-SQL conversions, follow these steps:

1. Ingest Metadata: Load the metadata.csv file which contains column names and their definitions.

2. Create Embeddings: Generate embeddings for the column names and definitions to facilitate semantic search.

3. Build a Vector Store: Store these embeddings in a vector store to enable efficient retrieval.

4. Query Pipeline: Implement a query pipeline that uses the vector store to recommend relevant columns based on the input query.

Here is a simplified example in Python:

import pandas as pd
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Step 1: Load metadata
metadata = pd.read_csv('metadata.csv')

# Step 2: Create embeddings
model = SentenceTransformer('all-MiniLM-L6-v2')
column_embeddings = model.encode(metadata['column_definition'].tolist())

# Step 3: Build a vector store (using a simple in-memory approach)
vector_store = {metadata['column_name'][i]: column_embeddings[i] for i in range(len(metadata))}

# Step 4: Query pipeline
def recommend_columns(query, top_k=5):
    query_embedding = model.encode([query])[0]
    similarities = {col: cosine_similarity([query_embedding], [emb])[0][0] for col, emb in vector_store.items()}
    recommended_columns = sorted(similarities, key=similarities.get, reverse=True)[:top_k]
    return recommended_columns

# Example usage
query = "Find the user email"
recommended_columns = recommend_columns(query)
print("Recommended columns:", recommended_columns)

For more advanced implementations, refer to the Text-to-SQL from Scratch guide. This guide includes advanced capabilities such as query-time table retrieval and query-time row retrieval, which can significantly enhance the performance and accuracy of your text-to-SQL pipeline ^[1][2].

To continue talking to Dosu, mention @dosu.

[Esg-developers]

@dosu

I dont want the recommended columns instead i want some suggested or recommended question based on history

[dosubot[bot]]

To build a query recommendation pipeline that suggests relevant questions based on past queries, you can follow a structured approach leveraging LlamaIndex. Here is a step-by-step guide to set up such a pipeline:

1. Load and Ingest Data: Extract and summarize past queries.
2. Store Data in a Database: Use a database to store the past queries.
3. Define Core Modules: Create modules for indexing and retrieving past queries.
4. Define Query Pipeline: Set up the pipeline to process and recommend queries.

Step 1: Load and Ingest Data

First, extract and summarize past queries. You can use a similar approach to the table extraction in the document.

from llama_index.legacy.bridge.pydantic import BaseModel, Field
from llama_index.legacy.llms import OpenAI
from llama_index.legacy import LLMTextCompletionProgram

class QueryInfo(BaseModel):
    """Information regarding a past query."""
    query_text: str = Field(..., description="The text of the past query")
    query_summary: str = Field(..., description="Short, concise summary of the query")

prompt_str = """\
Give me a summary of the query with the following JSON format.

Query:
{query_str}

Summary: """

program = LLMTextCompletionProgram.from_defaults(
    output_cls=QueryInfo,
    llm=OpenAI(model="gpt-3.5-turbo"),
    prompt_template_str=prompt_str,
)

# Example usage
query_str = "What was the year that The Notorious B.I.G was signed to Bad Boy?"
query_info = program(query_str=query_str)
print(query_info)

Step 2: Store Data in a Database

Store the past queries in a database using SQLAlchemy.

from sqlalchemy import create_engine, MetaData, Table, Column, String
import pandas as pd

engine = create_engine("sqlite:///:memory:")
metadata_obj = MetaData()

# Define the table schema
queries_table = Table(
    'queries', metadata_obj,
    Column('id', String, primary_key=True),
    Column('query_text', String),
    Column('query_summary', String)
)

# Create the table in the database
metadata_obj.create_all(engine)

# Insert data into the table
with engine.connect() as conn:
    for query_info in query_infos:  # Assuming query_infos is a list of QueryInfo objects
        insert_stmt = queries_table.insert().values(
            id=query_info.id,
            query_text=query_info.query_text,
            query_summary=query_info.query_summary
        )
        conn.execute(insert_stmt)
    conn.commit()

Step 3: Define Core Modules

Create modules for indexing and retrieving past queries.

from llama_index.core import VectorStoreIndex, SQLDatabase

sql_database = SQLDatabase(engine)

# Create an index for the queries
query_index = VectorStoreIndex.from_vector_store(
    sql_database.vector_store, 
    service_context=ServiceContext.from_defaults()
)
query_retriever = query_index.as_retriever(similarity_top_k=3)

Step 4: Define Query Pipeline

Set up the pipeline to process and recommend queries.

from llama_index.core.query_pipeline import QueryPipeline
from llama_index.core.llms.llm import LLM
from llama_index.core.output_parsers import LangchainOutputParser
from langchain_core.output_parsers import JsonOutputParser
from llama_index.core.llms import ChatMessage, MessageRole
from llama_index.core import ChatPromptTemplate
from llama_index.core.prompts.mixin import PromptDictType, PromptMixin, PromptMixinType

class PromptModule(PromptMixin):
    """
    A module for managing prompt templates used by the HubPlanner.
    """

    def __init__(self) -> None:
        """
        Initialize the PromptModule with an empty set of prompts.
        """
        self._prompts = {}

    def _get_prompts(self) -> PromptDictType:
        """
        Get the current set of prompts.

        Returns:
            PromptDictType: A dictionary containing the current prompts.
        """
        return self._prompts

    def _get_prompt_modules(self) -> PromptMixinType:
        """
        Get sub-modules that are instances of PromptMixin.

        Returns:
            PromptMixinType: An empty dictionary as there are no sub-modules.
        """
        return {}

    def _update_prompts(self, prompts_dict: PromptDictType) -> None:
        """
        Update the prompts for the current module.

        Args:
            prompts_dict (PromptDictType): A dictionary containing the prompts to update.
        """
        self._prompts.update(prompts_dict)

class HubPlanner:
    """
    The HubPlanner class generates plans based on user queries, tool information, and chat history.
    It utilizes an LLM and custom prompt templates to create structured workflows.
    """

    def __init__(self, llm: LLM) -> None:
        """
        Initialize the HubPlanner with an LLM and set up the prompt module and output parser.

        Args:
            llm (LLM): The large language model used for generating plans.
        """
        self.llm = llm

        prompt_module = PromptModule()
        prompt_module.setup_planner_template()
        self.template_planner = prompt_module.get_prompts().get("planner")

        lc_output_parser = JsonOutputParser()
        self.output_parser = LangchainOutputParser(lc_output_parser)

        self.query_pipeline = QueryPipeline(
            chain=[self.template_planner, self.llm, self.output_parser], verbose=True
        )

    def plan_generate(self, query, tool_info, chat_history):
        """
        Generate a plan based on the user's query, tool information, and chat history.

        Args:
            query (str): The user's query.
            tool_info (str): Information about the available tools.
            chat_history (str): The chat history.

        Returns:
            dict: The generated plan in JSON format.
        """
        return self.query_pipeline.run(
            input=query, tools=tool_info, chat_history=chat_history
        )

def query_input(query_str: Optional[str] = None) -> str:
    return query_str or ""

query_component = FnComponent(
    fn=query_input, output_key="output", req_params={"query_str"}
)

qp = QP(
    modules={
        "query": query_component,
        "retriever": query_retriever,
    },
    verbose=True,
)

qp.add_link("query", "retriever")

# Example usage
response = qp.run(query_str="What was the year that The Notorious B.I.G was signed to Bad Boy?")
print(str(response))

This setup will allow you to recommend relevant queries based on past queries by leveraging the indexing and retrieval capabilities of LlamaIndex. Additionally, you can enhance the pipeline by incorporating various query patterns and techniques provided by LlamaIndex, such as semantic search, summarization, and multi-step queries, to refine and improve query recommendations ^{[1][2][3][4][5]}.

To continue talking to Dosu, mention @dosu.