What's the proper way to use memory with langgraph?

[XiaoConstantine]

Context:

When trying this example:
agent executor-force tool

I seems that the AgentExectuor doesn't work with langgraph out of the box, specifically:

from langchain.agents import create_react_agent, AgentExecutor

def create_agent(tools):
    llm = Ollama(
        model="mistral:latest",
        temperature=0.0,
        num_ctx=16384,
    )
    prompt = create_prompt()
    memory = ConversationBufferMemory(memory_key="chat_history")
    agent = create_react_agent(llm=llm, tools=tools, prompt=prompt)
    agent_executor = AgentExecutor(
         agent=agent,  # type: ignore
         tools=tools,
         memory=memory,
         verbose=True,
         max_iterations=15,
         handle_parsing_errors=True,
     )
    return agent_executor
 

If i use this agent_executor as runnable for the subsequent calls, I will get:

    [
  File "xxx/.venv/lib/python3.11/site-packages/langchain/agents/agent.py", line 1166, in _iter_next_step
    output = self.agent.plan(
             ^^^^^^^^^^^^^^^^
TypeError: RunnableAgent.plan() got multiple values for argument 'intermediate_steps'

Where directly use agent works fine. It seems to me that AgentExecutor provides API for user to provide memory to keep track of all the messages happening within this agent, e.g.

    memory = ConversationBufferMemory(memory_key="chat_history")

Since the agent executor doesn't work, what's the proper way to have memory along with the langgraph app?

[zoltan-fedor]

I am also curious about what is (if any) the official recommendation for the memory for agents created with langgraph, but while waiting for that I have implemented it for myself by using the LangChain memory methods, see https://python.langchain.com/docs/modules/memory/types/buffer/

Basically when building the prompt I read out the memory with memory.load_memory_variables({})['chat_history'] and inject it into the prompt before sending that to the agent built with LangGraph and when that agent returns its response, then I take the input and the agent response and add it to the memory with memory.save_context({"input": "hi"}, {"output": "whats up"}).

It is rather simple actually.

[Sulomus]

@XiaoConstantine did you find solution?
I would love some examples of langgraph with proper memory!

[XiaoConstantine]

I ends up doing the similar thing like @zoltan-fedor proposed. I don't think current langgraph API accept the memories yet? Maybe someone has better understanding can chime in

[hinthornw]

Hi all - in LangGraph, memory is just checkpointing/persistence (see, e.g., the tutorial) - no need for other memory classes.

All you have to do is compile() it with a checkpointer, then any time you call the graph, add a {"configurable": {"thread_id": <the thread>}}, and your full graph has memory.

This is much more powerful than LangChain's older forms of chat memory for a couple of reasons:

• It supports more than just chat messages and isn't limited to the LLM
• It supports full time travel and branching to rewind and continue from previous states
• It's mutable by the developer, meaning you can create human-in-the-loop flows that let you edit past state

[zoltan-fedor]

In my mind those two - the conversation message memory (history) and the graph state checkpointing serve different purposes.

Typically the graph state represents a single execution of the graph - which is basically one message from user and how that message is handled by the agent.

The message memory though stores the message history of the given chat discussion - where each message from the user was handled by a graph execution.

[hinthornw]

What do you hope to gain by discarding the checkpoints across subsequent graph invocations and using additional storage?

To the graph, multi-turn interactions aren't much different than any other state transition

[nfcampos]

The best way to think of your graph state is as representing the state of a thread, ie a (potentially) multi-turn interaction between an agent and a user. State that is transient to a single execution should in fact be cleared at the end of the execution (eg in a "finish" node) or at the beginning of the next one (eg in a "start" node).

The graph state should contain any information from the thread history you deem useful to answer future turns of the conversation. That will usually be a list of chat messages.

Checkpointing would serve no purpose if the entire state of the graph was transient, ie if it doesn't contain any history information, as we would then storing the state at the end of a run and immediately discarding it?

[zoltan-fedor]

Thanks @nfcampos, that is exactly how I see it too.

In the ReAct agent conversational pattern I do store the conversational history outside of the Langgraph checkpoint using LangChain's ConversationBufferMemory and inject it into the ReAct prompt at every turn.
But a single turn in the chat session triggers the LangGraph graph and as long as I only want to carry over the information of the chat history messages of that session and not any other state from the previous execution of the graph, this works fine.