How to use memory with create_react_agent

[YogeshSaini85]

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

llm = AzureChatOpenAI(deployment_name="azure-xxxxx", temperature=0.0)

prompt = PromptTemplate(
        template=COPILOT_PROMPT,
        input_variables=["input", "agent_scratchpad"],        
        )
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

agent = ZeroShotAgent(
        llm_chain=LLMChain(llm=llm, prompt=prompt, memory=memory),
        allowed_tools=[tool.name for tool in tools],        
    )
-------------------------------------------------------------------------------------
agent = create_react_agent(llm, tools, prompt)

Description

I have an application which builds a "process".
It has a tool to take user input and other tools to add/remove/update process object.
It starts by detecting items for the process from the initial input and then using appropriate tools to add these items.
Then it uses the 'User Input' tool to get further items about the process and adds it to the process.
This goes on for a while until it has all the items required to create a process, at which point it ends.

Although I have tested the application and it works, but we want to pass external memory,

We can use ZeroShotAgent with memory but it's deprecated and we're suggest to use create_react_agent.

But create_react_agent does not have an option to pass memory.

Can someone please help me figure out how I can use memory with create_react_agent?

Am I using wrong agent for this use case?

System Info

langchain==0.2.16
langchain-community==0.2.16
langchain-core==0.2.38
langchain-openai==0.1.7
langchain-text-splitters==0.2.4

[dosubot[bot]]

To use memory with the create_react_agent function in LangChain, you need to add a checkpointer to the agent. This will enable chat memory for the agent. Here is an example of how to do this:

from langgraph.checkpoint.memory import MemorySaver  # an in-memory checkpointer
from langgraph.prebuilt import create_react_agent
from langchain_anthropic import ChatAnthropic
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.messages import HumanMessage

# Create the agent
memory = MemorySaver()
model = ChatAnthropic(model_name="claude-3-sonnet-20240229")
search = TavilySearchResults(max_results=2)
tools = [search]
agent_executor = create_react_agent(model, tools, checkpointer=memory)

# Use the agent
config = {"configurable": {"thread_id": "abc123"}}
for chunk in agent_executor.stream(
    {"messages": [HumanMessage(content="hi im bob! and i live in sf")]}, config
):
    print(chunk)
    print("----")

for chunk in agent_executor.stream(
    {"messages": [HumanMessage(content="whats the weather where I live?")]}, config
):
    print(chunk)
    print("----")

Additionally, you can create a custom agent with shared memory across both the agent and its tools. Here is an example:

from langchain import hub
from langchain.agents import AgentExecutor, Tool, ZeroShotAgent, create_react_agent
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory, ReadOnlySharedMemory
from langchain.prompts import PromptTemplate
from langchain_community.utilities import GoogleSearchAPIWrapper
from langchain_openai import OpenAI

# Define the prompt template
template = """This is a conversation between a human and a bot:

{chat_history}

Write a summary of the conversation for {input}:
"""
prompt = PromptTemplate(input_variables=["input", "chat_history"], template=template)

# Create memory objects
memory = ConversationBufferMemory(memory_key="chat_history")
readonlymemory = ReadOnlySharedMemory(memory=memory)

# Create the summarization chain
summary_chain = LLMChain(
    llm=OpenAI(),
    prompt=prompt,
    verbose=True,
    memory=readonlymemory,  # use the read-only memory to prevent the tool from modifying the memory
)

# Define tools
search = GoogleSearchAPIWrapper()
tools = [
    Tool(
        name="Search",
        func=search.run,
        description="useful for when you need to answer questions about current events",
    ),
    Tool(
        name="Summary",
        func=summary_chain.run,
        description="useful for when you summarize a conversation. The input to this tool should be a string, representing who will read this summary.",
    ),
]

# Pull the prompt from the hub
prompt = hub.pull("hwchase17/react")

# Create the agent
model = OpenAI()
agent = create_react_agent(model, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory)

# Use the agent
agent_executor.invoke({"input": "What is ChatGPT?"})
agent_executor.invoke({"input": "Who developed it?"})
agent_executor.invoke({"input": "Thanks. Summarize the conversation, for my daughter 5 years old."})

# Confirm that the memory was correctly updated
print(agent_executor.memory.buffer)

This code demonstrates how to create a create_react_agent with memory using the MemorySaver checkpointer and how to share memory across both the agent and its tools using ConversationBufferMemory and ReadOnlySharedMemory. The agent can remember previous interactions within the same thread, as indicated by the thread_id in the configuration.

For more advanced memory management, you can use the GenerativeAgentMemory class from LangChain, which provides functionalities like scoring memory importance, reflecting on recent observations, and fetching related memories. This class allows for more sophisticated memory handling, including the ability to pause and reflect on recent events to generate insights.

from langchain_experimental.generative_agents.memory import GenerativeAgentMemory
from langchain_core.language_models import BaseLanguageModel
from langchain.retrievers import TimeWeightedVectorStoreRetriever

# Initialize the memory retriever and language model
memory_retriever = TimeWeightedVectorStoreRetriever()
llm = BaseLanguageModel()

# Create the generative agent memory
generative_memory = GenerativeAgentMemory(
    llm=llm,
    memory_retriever=memory_retriever,
    verbose=True,
    reflection_threshold=0.5
)

# Add a memory
generative_memory.add_memory("I had a great conversation with Bob about the weather in SF.")

This setup allows the agent to manage its memory more effectively, scoring the importance of memories and reflecting on them to generate new insights.

For a detailed walkthrough of LangChain's conversation memory abstractions, visit the How to add message history (memory) LCEL page ^{[1][2][3][4][5]}.

To continue talking to Dosu, mention @dosu.

[YogeshSaini85]

@dosu

1. Problem with first solution is that it uses langGraph and in that create_react_agent I can't pass the prompt which is essential for my agent to drive the process building.
2. Problem with second solution is that I have tools that don't use LLM (or LLMChain) and AgentExecutor doesn't accept memory argument in constructor.

[dosubot[bot]]

To use memory with create_react_agent in LangChain when you need to pass a custom prompt and have tools that don't use LLM or LLMChain, you can follow these steps:

1. Define a custom prompt.
2. Create a ConversationTokenBufferMemory or AgentTokenBufferMemory object.
3. Use ReadOnlySharedMemory for tools that should not modify the memory.
4. Create the tools, including those that don't use LLM or LLMChain.
5. Create the agent with the custom prompt and tools.
6. Use AgentExecutor to manage the agent and memory.

Here is the code to achieve this:

from langchain import hub
from langchain.agents import AgentExecutor, Tool, create_react_agent
from langchain.chains import LLMChain
from langchain.memory import ConversationTokenBufferMemory, ReadOnlySharedMemory
from langchain.prompts import PromptTemplate
from langchain_community.utilities import GoogleSearchAPIWrapper
from langchain_openai import OpenAI

# Define the custom prompt
template = """This is a conversation between a human and a bot:

{chat_history}

Write a summary of the conversation for {input}:
"""
prompt = PromptTemplate(input_variables=["input", "chat_history"], template=template)

# Create memory objects
memory = ConversationTokenBufferMemory(memory_key="chat_history", max_token_limit=2000)
readonlymemory = ReadOnlySharedMemory(memory=memory)

# Create the summary chain with read-only memory
summary_chain = LLMChain(
    llm=OpenAI(),
    prompt=prompt,
    verbose=True,
    memory=readonlymemory,
)

# Create tools, including those that don't use LLM or LLMChain
search = GoogleSearchAPIWrapper()
tools = [
    Tool(
        name="Search",
        func=search.run,
        description="useful for when you need to answer questions about current events",
    ),
    Tool(
        name="Summary",
        func=summary_chain.run,
        description="useful for when you summarize a conversation. The input to this tool should be a string, representing who will read this summary.",
    ),
]

# Pull the custom prompt for the agent
prompt = hub.pull("hwchase17/react")

# Create the agent with the custom prompt and tools
model = OpenAI()
agent = create_react_agent(model, tools, prompt)

# Create the agent executor with memory
agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory)

# Example usage
agent_executor.invoke({"input": "What is ChatGPT?"})
agent_executor.invoke({"input": "Who developed it?"})
agent_executor.invoke({"input": "Thanks. Summarize the conversation, for my daughter 5 years old."})

# Confirm that the memory was correctly updated
print(agent_executor.memory.buffer)

This setup ensures that the agent and tools can share memory appropriately, with tools that should not modify the memory using ReadOnlySharedMemory ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[YogeshSaini85]

@dosu Okay so I found the way to pass redis memory to the agent executor.
But when I run the agent, I see that it doesn't make any entry in the redis database.

Here is my code:

prompt = PromptTemplate(
        template=COPILOT_PROMPT,
        input_variables=["input", "agent_scratchpad"],       
    )
memory = RedisChatMessageHistory(
        url="redis://127.0.0.1:6379/0", ttl=6000, session_id="my-session"
    )
agent = create_react_agent(llm, tools, prompt)

agent_executor = AgentExecutor.from_agent_and_tools(
        agent=agent,
        tools=tools,
        verbose=False,
        handle_parsing_errors=True,
        max_iterations=4000,
        max_execution_time=60000
    )
agent_history = RunnableWithMessageHistory(
        agent_executor,
        lambda session_id: memory,
        input_messages_key="input",
        history_messages_key="agent_scratchpad",
    )

agent_history.invoke({"input": "This is my query"}, config={"configurable": {"session_id": "my-session"}})

Why won't it make any entries in the redis database? What am I doing wrong?

[dosubot[bot]]

The issue might be that you haven't properly initialized or used the RedisChatMessageHistory instance within your AgentExecutor. Ensure that you have correctly set up the Redis connection and are using the RedisChatMessageHistory instance as shown in the provided example.

Here is a step-by-step guide to ensure everything is set up correctly:

1. Install Required Dependencies:

   %pip install -qU langchain-redis langchain-openai redis

2. Ensure Redis Server is Running:
   You can start a Redis server using Docker:

   docker run -d -p 6379:6379 redis:latest

3. Set Up Redis URL:

   import os
   
   # Use the environment variable if set, otherwise default to localhost
   REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379")
   print(f"Connecting to Redis at: {REDIS_URL}")

4. Initialize RedisChatMessageHistory:

   from langchain_redis import RedisChatMessageHistory
   
   # Initialize RedisChatMessageHistory
   history = RedisChatMessageHistory(session_id="user_123", redis_url=REDIS_URL)

5. Add Messages to History:

   history.add_user_message("Hello, AI assistant!")
   history.add_ai_message("Hello! How can I assist you today?")

6. Integrate with Language Models:

   from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
   from langchain_openai import ChatOpenAI
   from langchain_core.runnables.history import RunnableWithMessageHistory
   
   # Create a prompt template
   prompt = ChatPromptTemplate.from_messages(
       [
           ("system", "You are a helpful AI assistant."),
           MessagesPlaceholder(variable_name="history"),
           ("human", "{input}"),
       ]
   )
   
   # Initialize the language model
   llm = ChatOpenAI()
   
   # Create the conversational chain
   chain = prompt | llm
   
   # Function to get or create a RedisChatMessageHistory instance
   def get_redis_history(session_id: str) -> BaseChatMessageHistory:
       return RedisChatMessageHistory(session_id, redis_url=REDIS_URL)
   
   # Create a runnable with message history
   chain_with_history = RunnableWithMessageHistory(
       chain, get_redis_history, input_messages_key="input", history_messages_key="history"
   )
   
   # Use the chain in a conversation
   response1 = chain_with_history.invoke(
       {"input": "Hi, my name is Alice."},
       config={"configurable": {"session_id": "alice_123"}},
   )
   print("AI Response 1:", response1.content)
   
   response2 = chain_with_history.invoke(
       {"input": "What's my name?"}, config={"configurable": {"session_id": "alice_123"}}
   )
   print("AI Response 2:", response2.content)

Additionally, you can refer to the following test example to ensure your setup is correct:

import json

from langchain.memory import ConversationBufferMemory
from langchain_core.messages import message_to_dict

from langchain_community.chat_message_histories import RedisChatMessageHistory

def test_memory_with_message_store() -> None:
    """Test the memory with a message store."""
    # setup Redis as a message store
    message_history = RedisChatMessageHistory(
        url="redis://localhost:6379/0", ttl=10, session_id="my-test-session"
    )
    memory = ConversationBufferMemory(
        memory_key="baz", chat_memory=message_history, return_messages=True
    )

    # add some messages
    memory.chat_memory.add_ai_message("This is me, the AI")
    memory.chat_memory.add_user_message("This is me, the human")

    # get the message history from the memory store and turn it into a json
    messages = memory.chat_memory.messages
    messages_json = json.dumps([message_to_dict(msg) for msg in messages])

    assert "This is me, the AI" in messages_json
    assert "This is me, the human" in messages_json

    # remove the record from Redis, so the next test run won't pick it up
    memory.chat_memory.clear()

Ensure that the session_id used in RedisChatMessageHistory matches the one used in the AgentExecutor. If the session IDs do not match, the messages will not be stored or retrieved correctly.

If you follow these steps and still face issues, double-check the Redis server connection and ensure there are no network issues preventing the agent from writing to the Redis database ^[1][2].

To continue talking to Dosu, mention @dosu.

[YogeshSaini85]

Okay I am able to see the entries in redis. Closing the thread.