conversation with NeptuneOpenCypherQAChain

[aradhanachaturvedi]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

CYPHER_TEMPLATE_PROMPT = PromptTemplate(
    input_variables=['question'], template=CYPHER_GENERATION_TEMPLATE
    )
    chain = NeptuneOpenCypherQAChain.from_llm(llm=llm, graph=graph,verbose=True,cypher_prompt=CYPHER_TEMPLATE_PROMPT,return_intermediate_steps=True)
    result=chain.invoke(query)

I am using ggpt-4o currently

Description

Hi I am trying to use NeptuneOpenCypherQAChain , but we want our bot to be conversational in nature. Is it possible with this QA chain to maintain history of conversation

System Info

langchain==0.1.20
langchain-community==0.0.38
langchain-core==0.1.52
langchain-experimental==0.0.57
langchain-openai==0.1.3
langchain-text-splitters==0.0.1

[dosubot[bot]]

Yes, it is possible to maintain the history of the conversation with NeptuneOpenCypherQAChain to make the bot conversational in nature. You can use the ConversationBufferMemory and ReadOnlySharedMemory classes to store and manage the chat history. Here is an example setup:

from langchain.memory import ConversationBufferMemory, ReadOnlySharedMemory
from langchain_core.prompts import PromptTemplate
from langchain_community.chains.graph_qa.cypher import NeptuneOpenCypherQAChain
from tests.unit_tests.llms.fake_llm import FakeLLM

memory = ConversationBufferMemory(memory_key="chat_history")
readonlymemory = ReadOnlySharedMemory(memory=memory)
prompt = PromptTemplate(
    input_variables=["schema", "question", "chat_history"], 
    template="""You are a nice chatbot having a conversation with a human.

    Schema:
    {schema}

    Previous conversation:
    {chat_history}

    New human question: {question}
    Response:"""
)

llm = FakeLLM(queries={})
chain = NeptuneOpenCypherQAChain.from_llm(
    cypher_llm=llm,
    qa_llm=FakeLLM(),
    graph=FakeGraphStore(),
    verbose=True,
    return_intermediate_steps=False,
    cypher_llm_kwargs={"prompt": prompt, "memory": readonlymemory},
    memory=memory,
)
chain.run("Test question")
chain.run("Test new question")

This setup ensures that the bot can understand and respond to follow-up questions appropriately by maintaining the conversation history ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[dosubot[bot]]

To save only the results in memory and avoid the error related to multiple output keys, you need to ensure that return_intermediate_steps is set to False. Here is how you can configure the NeptuneOpenCypherQAChain:

chain = NeptuneOpenCypherQAChain.from_llm(
    llm=llm,
    graph=graph,
    verbose=True,
    cypher_llm_kwargs={"prompt": CYPHER_TEMPLATE_PROMPT, "memory": readonlymemory},
    memory=memory,
    return_intermediate_steps=False,  # Ensure intermediate steps are not returned
    output_key="result"  # Explicitly set the output key
)

result = chain.invoke(query)

This setup ensures that only the final result is saved in memory, avoiding any issues with multiple output keys ^[1][2].

To continue talking to Dosu, mention @dosu.

[aradhanachaturvedi]

@dosu.

I want to return intermediate steps, but dont want to save it in output_keys

[dosubot[bot]]

To return intermediate steps but only save the final result in memory when using the NeptuneOpenCypherQAChain, you can use the return_intermediate_steps parameter and handle the output appropriately. Here is how you can do it:

1. Set return_intermediate_steps to True to get the intermediate steps in the output.
2. Filter the output to save only the final result in memory.

Here is an example:

chain = NeptuneOpenCypherQAChain.from_llm(
    llm=llm,
    graph=graph,
    verbose=True,
    cypher_llm_kwargs={"prompt": CYPHER_TEMPLATE_PROMPT, "memory": readonlymemory},
    memory=memory,
    return_intermediate_steps=True,
    output_key="result"  # Explicitly set the output key
)

# Invoke the chain and get the result
result = chain.invoke(query)

# Print the final result and intermediate steps
print(f"Final answer: {result['result']}")
print(f"Intermediate steps: {result['intermediate_steps']}")

# Save only the final result in memory
memory.save_context({"query": query}, {"result": result['result']})

This setup ensures that the intermediate steps are returned and can be accessed, but only the final result is saved in memory ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[aradhanachaturvedi]

@dosu.

But I have noticed few things with memory,
in my prompt template I have mentioned using few shot examples that while executing query result should be sorted based on a specific criteria. Also it should return few fields from top 10 results based on sorting criteria. But due to memory its returning everything .So do I need to create another chain , which can look at the few prompt examples and run the query ?

[dosubot[bot]]

To ensure that your query adheres to the few-shot examples in the prompt template, returns sorted and limited results, and saves only the final result in memory while returning intermediate steps, you can follow these steps:

1. Create a FewShotPromptWithTemplates with the necessary examples and context:

   from langchain_core.prompts import FewShotPromptWithTemplates, PromptTemplate
   
   examples = [
       {"input": "List all artists.", "query": "SELECT * FROM Artist ORDER BY Name LIMIT 10;"},
       {
           "input": "Find all albums for the artist 'AC/DC'.",
           "query": "SELECT * FROM Album WHERE ArtistId = (SELECT ArtistId FROM Artist WHERE Name = 'AC/DC') ORDER BY Title LIMIT 10;",
       },
       # Add more examples as needed
   ]
   
   example_prompt = PromptTemplate.from_template("User input: {input}\nSQL query: {query}")
   prompt = FewShotPromptWithTemplates(
       examples=examples[:5],
       example_prompt=example_prompt,
       prefix="You are a SQLite expert. Given an input question, create a syntactically correct SQLite query to run. Unless otherwise specified, do not return more than {top_k} rows.\n\nHere is the relevant table info: {table_info}\n\nBelow are a number of examples of questions and their corresponding SQL queries.",
       suffix="User input: {input}\nSQL query: ",
       input_variables=["input", "top_k", "table_info"],
   )

2. Format the prompt with the input, top_k, and table_info:

   context = db.get_context()
   formatted_prompt = prompt.format(input="How many artists are there?", top_k=3, table_info=context["table_info"])

3. Create the SQL query chain and invoke it:

   from langchain.chains import create_sql_query_chain
   from langchain_openai import ChatOpenAI
   
   llm = ChatOpenAI()
   chain = create_sql_query_chain(llm, db, prompt)
   result = chain.invoke({"question": "how many artists are there?"})

4. Ensure the query returns sorted and limited results:

   Modify the few-shot examples to include sorting and limiting clauses where necessary. For example:

   examples = [
       {"input": "List all artists.", "query": "SELECT * FROM Artist ORDER BY Name LIMIT 10;"},
       {
           "input": "Find all albums for the artist 'AC/DC'.",
           "query": "SELECT * FROM Album WHERE ArtistId = (SELECT ArtistId FROM Artist WHERE Name = 'AC/DC') ORDER BY Title LIMIT 10;",
       },
       # Add more examples as needed
   ]

5. Save only the final result in memory and return intermediate steps:

   This can be managed by the chain's internal mechanisms. Ensure that the chain is configured to store only the final result and return intermediate steps if needed.

   chain = create_sql_query_chain(llm, db, prompt, return_intermediate_steps=True)
   result = chain.invoke({"question": "how many artists are there?"})

By following these steps, you can ensure that your setup adheres to the few-shot examples in the prompt template, returns sorted and limited results, and manages memory efficiently while providing intermediate steps ^{[1][2][3][4][5]}.

To continue talking to Dosu, mention @dosu.