Memory object passed to prompttemplate as dict in langgraph

[pydisandeep]

Hello , I'm building a Bot using Langgraph. My requirement is if the question is follow up question i had to reformat / rewrite the question for which i have to pass conversation history as dictionary / list to the LLM through promptTemplate so that it rewrites question. im using memory checkpointer but still ,i want to store conversation history only.

[dosubot[bot]]

Hello @pydisandeep! I'm here to help you with any bugs, questions, or contributions you have. Let's tackle this together!

To pass conversation history as a dictionary or list to the LLM through promptTemplate in Langgraph while using a memory checkpointer, you can follow this approach:

1. Define the Graph State: Use MessagesState to manage the state as a list of messages.

2. Create a Function to Call the Model: This function should take the state, which includes the message history, and call the chat model.

3. Compile the Graph with Memory Checkpointer: Use MemorySaver to persist messages between runs.

Here's a code snippet to illustrate this setup:

from langchain_core.messages import HumanMessage
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import START, MessagesState, StateGraph

# Define a new graph
workflow = StateGraph(state_schema=MessagesState)

# Define the function that calls the model
def call_model(state: MessagesState):
    response = llm.invoke(state["messages"])
    # Update message history with response:
    return {"messages": response}

# Define the (single) node in the graph
workflow.add_edge(START, "model")
workflow.add_node("model", call_model)

# Add memory
memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

# Example invocation
query = "Hi! I'm Bob."
input_messages = [HumanMessage(query)]
config = {"configurable": {"thread_id": "abc123"}}
output = app.invoke({"messages": input_messages}, config)
output["messages"][-1].pretty_print()

This setup allows you to manage the conversation history effectively and pass it to the LLM for rewriting follow-up questions ^[1][2].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[dosubot[bot]]

To save input messages and user responses as HumanMessage and AIMessage in the messages key using Langgraph, you can follow this approach:

1. Initialize the Messages: Start with a list of messages, which will include both HumanMessage and AIMessage.

2. Add New Messages: When a new input is received, create a HumanMessage and append it to the list. After processing, append the AIMessage response.

Here's an example setup:

from langchain_core.messages import HumanMessage, AIMessage
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import START, MessagesState, StateGraph

# Define the state schema with messages as a key
class State(TypedDict):
    messages: Annotated[Sequence[BaseMessage], add_messages]
    language: str

# Create a state graph
workflow = StateGraph(state_schema=State)

# Define a function to call the model
def call_model(state: State):
    # Assume `llm` is your language model
    response = llm.invoke(state["messages"])
    # Append the AI response to the messages
    state["messages"].append(AIMessage(content=response))
    return {"messages": state["messages"]}

# Add nodes and edges to the workflow
workflow.add_edge(START, "model")
workflow.add_node("model", call_model)

# Compile the workflow
memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

# Example input
input_dict = {
    "messages": [HumanMessage(content="Hi, I'm Bob.")],
    "language": "English",
}

# Invoke the app with the input
output = app.invoke(input_dict)
output["messages"][-1].pretty_print()

This setup ensures that each user input is saved as a HumanMessage and each AI response is saved as an AIMessage in the messages key, maintaining a structured conversation history ^[1].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[pydisandeep]

@dosu got it. But checkpoint still saves memory but its more related to graph persistence. Can i use checkpoint object and pass it into PromptTemplate so that conversation history is accessible to LLM. Instead of graph state only input and output from checkpoint memory

[dosubot[bot]]

To pass the conversation history stored in a MemorySaver checkpoint directly into a PromptTemplate for use with the LLM, you can extract the messages from the checkpoint and format them for the prompt. Here's how you can achieve this:

1. Extract Messages from Checkpoint: Retrieve the conversation history from the MemorySaver checkpoint.

2. Format for PromptTemplate: Use the extracted messages to populate the PromptTemplate.

Here's an example setup:

from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.prompts import ChatPromptTemplate
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import START, MessagesState, StateGraph

# Initialize MemorySaver
memory = MemorySaver()

# Define the state graph
workflow = StateGraph(state_schema=MessagesState)

# Define a function to call the model
def call_model(state: MessagesState):
    # Extract messages from the state
    messages = state["messages"]
    # Format messages for the prompt
    formatted_messages = [{"role": "user", "content": msg.content} for msg in messages]
    # Create a prompt template
    prompt = ChatPromptTemplate.from_messages(
        [("system", "You are a helpful assistant."), *formatted_messages]
    )
    # Invoke the model with the prompt
    response = llm.invoke(prompt)
    # Append the AI response to the messages
    state["messages"].append(AIMessage(content=response))
    return {"messages": state["messages"]}

# Add nodes and edges to the workflow
workflow.add_edge(START, "model")
workflow.add_node("model", call_model)

# Compile the workflow with the memory checkpointer
app = workflow.compile(checkpointer=memory)

# Example input
input_dict = {
    "messages": [HumanMessage(content="Hi, I'm Bob.")],
}

# Invoke the app with the input
output = app.invoke(input_dict)
output["messages"][-1].pretty_print()

This setup allows you to use the MemorySaver checkpoint to manage conversation history and pass it into a PromptTemplate, making it accessible to the LLM for generating responses.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[pydisandeep]

@dosu Extract Messages from Checkpoint: Retrieve the conversation history from the MemorySaver checkpoint. i want sample code

[dosubot[bot]]

To extract messages from the MemorySaver checkpoint in Langgraph, you can access the stored conversation history and format it as needed. Here's a sample code snippet to demonstrate how you can retrieve and use the conversation history:

from langchain_core.messages import HumanMessage, AIMessage
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import START, MessagesState, StateGraph

# Initialize MemorySaver
memory = MemorySaver()

# Define the state graph
workflow = StateGraph(state_schema=MessagesState)

# Define a function to call the model
def call_model(state: MessagesState):
    # Extract messages from the state
    messages = state["messages"]
    # Process the messages as needed
    # For example, format them for a prompt
    formatted_messages = [{"role": "user", "content": msg.content} for msg in messages]
    # Assume `llm` is your language model
    response = llm.invoke(formatted_messages)
    # Append the AI response to the messages
    state["messages"].append(AIMessage(content=response))
    return {"messages": state["messages"]}

# Add nodes and edges to the workflow
workflow.add_edge(START, "model")
workflow.add_node("model", call_model)

# Compile the workflow with the memory checkpointer
app = workflow.compile(checkpointer=memory)

# Example input
input_dict = {
    "messages": [HumanMessage(content="Hi, I'm Bob.")],
}

# Invoke the app with the input
output = app.invoke(input_dict)

# Retrieve the conversation history from MemorySaver
conversation_history = memory.retrieve("your_thread_id")  # Replace with actual thread ID
for message in conversation_history:
    print(f"{message['role']}: {message['content']}")

In this example, memory.retrieve("your_thread_id") is used to get the conversation history for a specific thread. You can replace "your_thread_id" with the actual thread ID you are using. This will give you access to the stored messages, which you can then format and use as needed.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}