Managing Chat History with LangGraph and Postgres Checkpoints

[itogaston]

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

from langchain_aws import ChatBedrock
from langgraph.checkpoint.postgres import ShallowPostgresSaver
from langgraph.prebuilt import create_react_agent
from typing import Literal
from langchain_core.tools import tool
from langgraph.prebuilt.chat_agent_executor import AgentState


model = ChatBedrock(model="eu.anthropic.claude-3-5-sonnet-20240620-v1:0", region="eu-west-3", beta_use_converse_api=True)


# mock tool
@tool
def get_weather(city: Literal["nyc", "sf"]):
   """Use this to get weather information."""
   if city == "nyc":
       return "It might be cloudy in nyc"
   elif city == "sf":
       return "It's always sunny in sf"
   else:
       raise AssertionError("Unknown city")


tools = [get_weather]


with ShallowPostgresSaver.from_conn_string(
   settings.PSYCOPG_DATABASE_URI.unicode_string()
) as checkpointer:
   graph = create_react_agent(model, tools=tools, checkpointer=checkpointer, state_schema=AgentState)
   graph.invoke({"messages": [{"role": "user", "content": "What's the weather in NYC?"}]}, config={"configurable": {"thread_id": "12345"}})


# Method to get the conversation messages
with ShallowPostgresSaver.from_conn_string(
           settings.PSYCOPG_DATABASE_URI.unicode_string()
       ) as checkpointer:
           return checkpointer.get({"configurable": {"thread_id": conversation_id}})["channel_values"].get("messages")

Description

We’re building a RAG application using LangGraph’s React Agent and ShallowPostgresSaver for state management. Our current implementation stores conversation messages in the checkpoint, which might be summarized or deleted over time. This raises concerns about user experience when viewing conversation history.

To get the list of messages for the frontend we are doing something like this. With the thread id we get the checkpoint which has all the messages stored for that conversation in the state.

The Issue

When users revisit a conversation in the frontend, we send the entire list of messages saved in the checkpoint state. However, we want to start managing checkpoint messages through methods like history summarization or deletion, which means modifying the list. This will affect the conversation history visible to users.

The user's conversation history should remain static as seen by the user, even if internal state management summarizes or prunes the message list.

Questions

• Are we using the checkpoint state correctly to persist user conversations, or should we implement a separate persistence mechanism (e.g., another table) to store the full conversation history without interfering with state management?
• Is it acceptable to store all messages within the checkpoint state, or could this cause performance issues or other unintended side effects as the conversation grows?
• Are there recommended patterns or best practices when integrating checkpoint management with conversation history in this kind of RAG application?

We’d appreciate any guidance on whether we should decouple user-facing conversation history from internal state management. Are there recommended patterns for handling this scenario?

System Info

System Information

OS: Darwin
OS Version: Darwin Kernel Version 24.2.0: Fri Dec 6 19:02:41 PST 2024; root:xnu-11215.61.5~2/RELEASE_ARM64_T6030
Python Version: 3.12.7 (main, Oct 16 2024, 07:12:08) [Clang 18.1.8 ]

Package Information

langchain_core: 0.3.33
langchain: 0.3.17
langsmith: 0.3.3
langchain_aws: 0.2.11
langchain_text_splitters: 0.3.5
langgraph_sdk: 0.1.51

Optional packages not installed

langserve

Other Dependencies

aiohttp: 3.11.11
async-timeout: Installed. No version info available.
boto3: 1.36.10
httpx: 0.28.1
jsonpatch: 1.33
langsmith-pyo3: Installed. No version info available.
numpy: 2.2.2
orjson: 3.10.15
packaging: 24.2
pydantic: 2.10.6
pytest: 8.3.4
PyYAML: 6.0.2
requests: 2.32.3
requests-toolbelt: 1.0.0
rich: Installed. No version info available.
SQLAlchemy: 2.0.37
tenacity: 9.0.0
typing-extensions: 4.12.2
zstandard: 0.23.0

[itelleria]

Hi!

I saw that this issue hasn’t had any updates in a while. Just wondering if this is the right place to discuss it or if there’s a better forum or web for it.

Let me know what you think. Thanks!

[satyaprakash1729]

@itelleria Did you figure out a way forward or still stuck with this?

We exactly have similar use case, and this is what we're thinking to do:

1. Store Human and AI messages (last message from Agent to user for every execution) in a separate table called "ChatHistory"
2. Use Redis or Postgres checkpointer to shallow persist latest checkpoint.
3. Power chat experience through "ChatHistory" table.
4. Enrich Memory (RAG, build patterns, rules, preferences etc) using the Checkpointer data that's being persisted.