"Agent responds to the previous question rather than addressing the current one."

[vigneshkaladharan]

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

import os

### Langchain imports
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, PromptTemplate
from langchain.chains import LLMChain
from langchain_community.tools import tool
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_openai.chat_models import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.runnables.history import RunnableWithMessageHistory

from avx_api_planner import api_planner



# Invoking the workflow
# response = app.invoke("")
# print(response)
class FeatureInstructionTool():

    @tool("feature_sample_instructions")
    def feature_instructor(data):
        """Call this tool to get a list of sample instructions about a feature
        """
        print("feature_instructor", data)
        return ["this feature talks about user experience"]

    @tool("feature_execution")
    def feature_execution(data):
        """Call this tool to execute a feature
         input to the tool is the user input
        """
        print("feature execution", data)
        result = api_planner().invoke(data)
        return result


feature_tool = [FeatureInstructionTool.feature_instructor, FeatureInstructionTool.feature_execution]

from langchain_community.chat_message_histories import RedisChatMessageHistory


def get_session_history(self):
    return RedisChatMessageHistory(session_id="23499", url="redis://localhost:6379")


class Chatbot:
    def __init__(self, model='gpt-4o-mini', temperature=0, memory=None):
        self.llm_rec = ChatOpenAI(model=model, temperature=temperature)
        self.system_prompt = ''' You are a friendly assistant who responds in a jovial way,guiding customers in executing a feature"
        You will follow a multi-stage approach

        Introduction: Introduce yourself as a  Chat Assistant.

        You should always answer to the new input {input}


        Stage 1: invoke the tool you are provided with to know about the feature,the input to the tool should be plain understandable text.

        Stage 2: The tool will give you all the details about the feature and sample instructions
                 that is required in the user input to execute the feature

        Stage 3: Compare the user's input with the sample instructions and suggest any necessary inputs the user needs to provide.

        Stage 4: if the user has provided all the required inputs.execute the feature by invoking the appropriate tool,do not get confirmation from the user
                 if the user has provided additional inputs ,you are still good to proceed

        Stage 5: understand the response from the tool and if required proceed to next step.

        Please do step by step and do  output the steps
        General rules:
        1. Ask one question at a time. Wait for the user's response before asking the next question
        2. You should strictly only answer to the feature supported by the tool


        '''
        self.memory = memory
        self.tools = feature_tool

    def run(self, input):
        ## Load Current Profile
        print("current input", input)
        prompt_rec = ChatPromptTemplate.from_messages(
            [
                SystemMessage(
                    content=self.system_prompt
                ),
                HumanMessage(input),

                MessagesPlaceholder(variable_name="chat_history"),
                MessagesPlaceholder(variable_name="agent_scratchpad"),

            ]
        )
        # Construct the OpenAI Functions agent
        recommendation_agent = create_openai_tools_agent(self.llm_rec, self.tools, prompt_rec)
        agent_executor = AgentExecutor(agent=recommendation_agent, tools=self.tools, max_iterations=4, verbose=True)
        agent_with_chat_history = RunnableWithMessageHistory(
            agent_executor,
            # This is needed because in most real world scenarios, a session id is needed
            # It isn't really used here because we are using a simple in memory ChatMessageHistory
            get_session_history,
            input_messages_key="input",
            history_messages_key="chat_history",
        )
        result = agent_with_chat_history.invoke({'input': input, }, config={"configurable": {"session_id": "222"}})
        response = result['output']
        return response


import streamlit as st

if "messages" not in st.session_state:
    st.session_state.messages = []

for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

if prompt := st.chat_input("What is up?"):
    st.session_state.messages.append({"role": "user", "content": prompt})

    # Process the question using the custom function
    response = Chatbot().run(prompt)

    # Append the response to the session state
    st.session_state.messages.append({"role": "assistant", "content": response})

    # Display both the question and the response in the chat
    with st.chat_message("user"):
        st.markdown(prompt)

    with st.chat_message("assistant"):
        # st.markdown(response)
        st.write(response)

Description

"Agent responds to the previous question rather than addressing the current one."
Example behavoir
User :How are you
AI: i am good thanku for asking
User: Can you tell me about mesi
AI: Thanku for asking i am good
User: can you tell me abour ronaldo
AI: Messi is an international football player

System Info

langchain==0.2.6
langchain-anthropic==0.1.19
langchain-aws==0.1.9
langchain-cohere==0.1.8
langchain-community==0.2.6
langchain-core==0.2.11
langchain-fireworks==0.1.4
langchain-google-genai==1.0.7
langchain-google-vertexai==1.0.6
langchain-groq==0.1.6
langchain-huggingface==0.0.3
langchain-mistralai==0.1.9
langchain-openai==0.1.14
langchain-text-splitters==0.2.2
langchain-together==0.1.3
langchainhub==0.1.20

[dosubot[bot]]

The issue where the agent responds to the previous question rather than addressing the current one is likely due to how the chat history is being managed and incorporated into the prompt. The RunnableWithMessageHistory class should ensure that the chat history is correctly passed and updated, but there might be a misconfiguration or missing step in your setup.

Here are a few steps to troubleshoot and potentially resolve the issue:

1. Ensure Proper Chat History Management:
   Make sure that the chat history is correctly retrieved and updated. The RunnableWithMessageHistory should be configured to handle the chat history properly.

2. Check the Prompt Template:
   Ensure that the prompt template includes placeholders for the chat history and that these placeholders are correctly populated with the historical messages.

3. Review the RunnableWithMessageHistory Configuration:
   Verify that the RunnableWithMessageHistory is correctly configured with the appropriate keys for input and history messages.

Here is an example of how you can ensure the chat history is correctly managed and incorporated into the prompt:

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessage, HumanMessage
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI
from langchain_community.chat_message_histories import RedisChatMessageHistory
from langchain.agents import AgentExecutor, create_openai_tools_agent

# Define the prompt template
prompt_rec = ChatPromptTemplate.from_messages(
    [
        SystemMessage(content=self.system_prompt),
        MessagesPlaceholder(variable_name="chat_history"),
        HumanMessage(content="{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
)

# Create the chain with history
agent_with_chat_history = RunnableWithMessageHistory(
    agent_executor,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

# Invoke the chain with history
result = agent_with_chat_history.invoke({'input': input}, config={"configurable": {"session_id": "222"}})
response = result['output']

Ensure that the get_session_history function correctly returns the chat history for the given session ID:

def get_session_history(session_id):
    return RedisChatMessageHistory(session_id=session_id, url="redis://localhost:6379")

By ensuring that the chat history is correctly managed and incorporated into the prompt, the agent should be able to respond to the current question rather than the previous one ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[vigneshkaladharan]

its already been followed properly,Still its an error