KeyError: "Input to ChatPromptTemplate is missing variables {'agent_scratchpad'}. and TypeError: string indices must be integers -> format_to_openai_function_messages( x["intermediate_steps"] ),

[milovate]

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

prompt = ChatPromptTemplate.from_messages(
        [
            (
                "system",
                system_prompt,
            ),
            MessagesPlaceholder(variable_name="chat_history"),
            ("human", "{human_input}"),
            # MessagesPlaceholder("agent_scratchpad"),
            ("ai", "{agent_scratchpad}"),
            
        ]
    )
    
    # Conversation buffer memory will keep track of the conversation in the
    # memory. It will use the "chat_history" as the name of the key.
    memory = ConversationBufferMemory(memory_key="chat_history",
                                      return_messages=True) # We create the internal llm chain first that takes our input and chat
    # history and wraps it in a dictionary before passing it as input to our
    # prompt. The prompt is then passed to our llm to generate an ai response.
   
    agent_executor = create_sql_agent(llm, db=db, agent_type="openai-tools", verbose=True)

    llm_chain = {
            "human_input": RunnablePassthrough(),
            "chat_history": (
                RunnableLambda(memory.load_memory_variables) |
                itemgetter("chat_history")
            ),
            "agent_scratchpad": lambda x: format_to_openai_function_messages(
            x["intermediate_steps"]
        ),
        
        
        } | prompt | agent_executor

Description

i am trying to add conversational memory to my chatbot application , i want to use create_sql_agent to execute my query , i am stuck at this error

KeyError: "Input to ChatPromptTemplate is missing variables {'agent_scratchpad'}. Expected: ['agent_scratchpad', 'chat_history', 'human_input'] Received: ['human_input', 'chat_history']"

to resolve this issue i tried to use

        "agent_scratchpad": lambda x: format_to_openai_function_messages(
        x["intermediate_steps"]

as agent_scratchpad needs BaseMessage

it further throws a type Error

TypeError: string indices must be integers

System Info

langchain==0.2.0
langchain-community==0.2.0
langchain-core==0.2.0
langchain-openai==0.1.1
langchain-text-splitters==0.2.0

[dosubot[bot]]

To resolve the KeyError and TypeError when adding conversational memory to your chatbot application using create_sql_agent, you need to ensure that the agent_scratchpad variable is correctly handled and that the format_to_openai_function_messages function processes the intermediate steps properly.

Here is a revised version of your code snippet:

from langchain_core.prompts.chat import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.memory import ConversationBufferMemory
from langchain_core.runnables import RunnablePassthrough, RunnableLambda
from langchain_core.language_models import BaseLanguageModel
from langchain_core.tools import BaseTool
from langchain.agents.agent import AgentExecutor
from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent
from operator import itemgetter

# Define the system prompt
system_prompt = "Your system prompt here."

# Create the prompt template
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", system_prompt),
        MessagesPlaceholder(variable_name="chat_history"),
        ("human", "{human_input}"),
        ("ai", "{agent_scratchpad}"),
    ]
)

# Initialize the memory
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# Create the SQL agent
agent_executor = create_sql_agent(llm, db=db, agent_type="openai-tools", verbose=True)

# Define the function to format intermediate steps
def format_to_openai_function_messages(intermediate_steps):
    # Ensure intermediate_steps is a list of messages
    if isinstance(intermediate_steps, list):
        return [BaseMessage(content=step) for step in intermediate_steps]
    else:
        raise TypeError("intermediate_steps must be a list of messages")

# Create the LLM chain
llm_chain = {
    "human_input": RunnablePassthrough(),
    "chat_history": (
        RunnableLambda(memory.load_memory_variables) |
        itemgetter("chat_history")
    ),
    "agent_scratchpad": lambda x: format_to_openai_function_messages(x["intermediate_steps"]),
} | prompt | agent_executor

# Example usage
input_data = {
    "human_input": "What is the capital of France?",
    "chat_history": memory.load_memory_variables({})["chat_history"],
    "intermediate_steps": ["Step 1", "Step 2"]  # Example intermediate steps
}

# Invoke the LLM chain
response = llm_chain.invoke(input_data)
print(response)

Key Points:

1. Prompt Template: Ensure placeholders for chat_history, human_input, and agent_scratchpad are correctly set.
2. Memory Initialization: Use ConversationBufferMemory with memory_key="chat_history" and return_messages=True.
3. SQL Agent Creation: Use create_sql_agent to create the SQL agent executor.
4. Formatting Intermediate Steps: Ensure intermediate_steps is a list of messages to avoid TypeError.
5. LLM Chain: Combine the necessary components, including the prompt and agent executor, into the LLM chain.

By following these steps, you should be able to resolve the KeyError and TypeError and successfully add conversational memory to your chatbot application.

Details

Sources

• Adding variables to Prompt
• ValueError: Prompt missing required variables: {'tools', 'tool_names'} when using third-party models
• OpenAI Function Invocation and RAG Not working together in a single prompt ?
• Window memory with intermediate steps on OpenaiFucntions agent
• Issue: problem with conversationchain take multiple inputs
• Adding memory with customprompt and Custom agent is resulting in error
• libs/langchain/langchain/agents/agent_toolkits/conversational_retrieval/openai_functions.py
• libs/langchain/tests/unit_tests/chains/test_conversation_retrieval.py
• libs/experimental/tests/unit_tests/test_sql.py
• libs/langchain/tests/unit_tests/chains/test_conversation.py
• cookbook/LLaMA2_sql_chat.ipynb
• libs/community/langchain_community/agent_toolkits/sql/base.py
• libs/langchain/langchain/memory/buffer.py

About Dosu
This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

To continue the conversation, mention @dosu.

[milovate]

@dosu still not resolved type error
"agent_scratchpad": lambda x: format_log_to_str(x["intermediate_steps"]),
TypeError: string indices must be integers

[dosubot[bot]]

To resolve the TypeError related to agent_scratchpad, ensure that intermediate_steps is correctly processed and formatted. Here’s how you can adjust your code:

1. Ensure intermediate_steps is a list of tuples:

   kwargs = {
       "intermediate_steps": [
           (AgentAction(log="Action log 1"), "Observation 1"),
           (AgentAction(log="Action log 2"), "Observation 2")
       ],
       # other key-value pairs
   }

2. Merge variables correctly:

   def _merge_partial_and_user_variables(self, **kwargs: Any) -> Dict[str, Any]:
       intermediate_steps = kwargs.pop("intermediate_steps")
       kwargs["agent_scratchpad"] = self._construct_agent_scratchpad(intermediate_steps)
       return kwargs

3. Format agent_scratchpad properly:

   def format_to_openai_function_messages(intermediate_steps):
       if isinstance(intermediate_steps, list):
           return [BaseMessage(content=step) for step in intermediate_steps]
       else:
           raise TypeError("intermediate_steps must be a list of messages")

4. Include agent_scratchpad in the prompt template:

   prompt = ChatPromptTemplate.from_messages(
       [
           ("system", system_prompt),
           MessagesPlaceholder(variable_name="chat_history"),
           ("human", "{human_input}"),
           ("ai", "{agent_scratchpad}"),
       ]
   )

5. Create the LLM chain:

   llm_chain = {
       "human_input": RunnablePassthrough(),
       "chat_history": (
           RunnableLambda(memory.load_memory_variables) |
           itemgetter("chat_history")
       ),
       "agent_scratchpad": lambda x: format_to_openai_function_messages(x["intermediate_steps"]),
   } | prompt | agent_executor

By following these steps, you should be able to resolve the TypeError and ensure that agent_scratchpad is correctly processed in your chatbot application.

Details

Sources

• playwright example faile with 'agent_scratchpad=lambda x: format_log_to_str(x["intermediate_steps"])'
• how to include history in few shot prompt with agent?
• how to access intermediate steps while constructing prompt using prompt template langchain
• error: I now need to return a final answer based on the previous steps:
• libs/langchain/langchain/agents/schema.py
• libs/community/langchain_community/agent_toolkits/sql/base.py
• libs/langchain/langchain/agents/chat/base.py
• libs/langchain/langchain/agents/conversational_chat/base.py
• templates/anthropic-iterative-search/anthropic_iterative_search/agent_scratchpad.py
• libs/langchain/langchain/memory/buffer.py
• libs/core/langchain_core/runnables/passthrough.py
• libs/core/langchain_core/messages/base.py
• libs/core/langchain_core/messages/function.py
• libs/core/langchain_core/messages/chat.py
• libs/core/langchain_core/messages/init.py

About Dosu
This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

To continue the conversation, mention @dosu.

[maximeperrindev]

Hi @milovate,

Here is a working code. Does it solve your problem ?

from langchain_core.prompts.chat import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory.buffer import ConversationBufferMemory
from langchain_core.runnables import RunnablePassthrough, RunnableLambda
from langchain_openai.chat_models import ChatOpenAI
from operator import itemgetter
from langchain_community.agent_toolkits.sql.base import create_sql_agent
from langchain_community.utilities.sql_database import SQLDatabase

pg_uri = "DB_URL"
db = SQLDatabase.from_uri(pg_uri)

system_prompt = "Your system prompt here."

prompt = ChatPromptTemplate.from_messages(
        [
            (
                "system",
                system_prompt,
            ),
            MessagesPlaceholder(variable_name="chat_history"),
            ("human", "{input}"),
            # MessagesPlaceholder("agent_scratchpad"),
            ("ai", "{agent_scratchpad}"),
            
        ]
    )

# Conversation buffer memory will keep track of the conversation in the
# memory. It will use the "chat_history" as the name of the key.
memory = ConversationBufferMemory(memory_key="chat_history",
                                    return_messages=True) # We create the internal llm chain first that takes our input and chat
# history and wraps it in a dictionary before passing it as input to our
# prompt. The prompt is then passed to our llm to generate an ai response.

agent_executor = create_sql_agent(ChatOpenAI(),prompt=prompt, db=db, agent_type="openai-tools", verbose=True)

chain = RunnablePassthrough.assign(
    chat_history=RunnableLambda(memory.load_memory_variables) | itemgetter("chat_history")
) | agent_executor

print(chain.invoke({"input": "Hello, how are you?"}))

[PolyLiYJ]

KeyError: "Input to PromptTemplate is missing variables {'instructions'}. Expected: ['agent_scratchpad', 'input', 'instructions'] Received: ['input', 'chat_history', 'intermediate_steps', 'agent_scratchpad']" here is my code

ollama_model_name= "llama3.1"
llm = Ollama(model=ollama_model_name) #, temperature=0.1)
df = pd.read_csv(file_path)
labels = df["label"].unique()

true_labels = []
predicted_labels = []
flow_ids = []

predicts_analysis = []

class GoogleSearchInput(BaseModel):
query: str

search_tool = StructuredTool(
name="google_search",
description="Search Google for informations.",
func=google_search.run, # Assuming this is the correct function for the tool
args_schema=GoogleSearchInput
)

api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=1000)
wiki_tool = WikipediaQueryRun(api_wrapper=api_wrapper)

tools = [search_tool, wiki_tool, knowledge_retriever]
message_history = RedisChatMessageHistory(
url="redis://127.0.0.1:6379/0", ttl=600, session_id="my-session"
)

prompt = hub.pull("hwchase17/openai-tools-agent")
agent = create_openai_tools_agent(llm, tools, prompt)