Langgraph state reset

[Bennoo]

Hey there,
Looking for a way to reset (delete) the state of a graph.

I am using SqliteSaver, in memory, and at some time I would like to be able to reset to empty the state of a graph.
I don't find an easy way to do it..

Thanks

[vbarda]

Hi @Bennoo . There are a few things you can do:

(1) you can just start a new thread -- it will have a new empty state
(2) for in-memory you can just re-instantiate the saver or for SQLite you can delete the underlying file
(3) you can subclass either of existing checkpointers and add a method to clear if absolutely necessary

Hope this helps!

[Bennoo]

Thank you!
I would like to reset the state without changing thread id.
I already have a graph compiled and I don't want to recompile it.

I tried this:

config={"configurable": {"thread_id": thread_id}}
memory = AsyncSqliteSaver.from_conn_string(":memory:")
checkpoint = empty_checkpoint()
await memory.aput(config=config, checkpoint=checkpoint, metadata={})

It seems it is not working, the state is still there with all the variables set, when I get the state with

graph.aget_state(config)

I still see all the properties of the state, I expected to see them empty.
I know I probably do something wrong here but I just don't get the way to update (reset) the state from outside of the execution of the graph.

Thanks

[vbarda]

you shouldn't manually be calling memory.put() -- checkpointing should be handled by langgraph only. if it's hard requirement to clear the thread, you can implement some helpers to drop all records for the thread ID from checkpoints and writes tables in your sqlite database

[Bennoo]

thank you, could you please point me resources where I can find examples or guidance to drop records from checkpoints?
My use case is a chat bot with a langgraph backend. The threadId is linked to the user and I would like to give the possibility to wipe everything and start from scratch. But I cannot changed the threadId and I don't want the memory to go wild by multiplicating the threads.

[vbarda]

unfortunately we don't have any resources / examples for that as it's not something we generally recommend. here is the implementation for the sqlite checkpointer with all the relevant tables / queries, so to implement that you would just need to write DELETE FROM sql queries

[vbarda]

by the way, for your use case, i would not recommend linking thread ID to the user ID (i might have misunderstood you but it almost sounds like you have only one thread per user) -- thread ID is just a chat / session ID, and a single user can have multiple chats potentially

if the intent is starting from scratch, you should just make a new thread

[Bennoo]

but then the old thread is still there right? I mean the data.

[vbarda]

yes, the data for the old thread is still there, so if the concern is removing the old threads, then DELETE FROM approach from the above should help

[Bennoo]

Ok , thanks I don't want the memory to become saturated by old threads that are no more used nor reachable.

[jain009deep]

@Bennoo @vbarda how do you recommend same for memory saver and postgressaver? This seems like a legitimate need else your memory will keep on growing

[theivanfranco]

Hello @Bennoo ! I'd be curious to see your implementation if you are willing to share :) I'm currently facing a similar issue with MemorySaver.

[Bennoo]

I did a really simple piece of code. The data structure is really simple in the database. For PostgreSQL database:

cursor = self.graph.checkpointer.conn.cursor()
# try to delete the thread_id from the checkpoints and writes tables
try:
    cursor.execute("DELETE FROM checkpoints WHERE thread_id = %s", (thread_id,))
    cursor.execute("DELETE FROM checkpoint_writes WHERE thread_id = %s", (thread_id,))
    cursor.execute("DELETE FROM checkpoint_blobs WHERE thread_id = %s", (thread_id,))

    self.graph.checkpointer.conn.commit()
except Exception as exception:
    # Whatever
    pass

For usage with SQLite this is the same but the formatting of the SQL is a bit different:

cursor = self.graph.checkpointer.conn.cursor()
# try to delete the thread_id from the checkpoints and writes tables
try:
    cursor.execute("DELETE FROM checkpoints WHERE thread_id = ?", (thread_id,))
    cursor.execute("DELETE FROM checkpoint_writes WHERE thread_id = ?", (thread_id,))
    cursor.execute("DELETE FROM checkpoint_blobs WHERE thread_id = ?", (thread_id,))

    self.graph.checkpointer.conn.commit()
except Exception as exception:
    # Whatever
    pass

Not tested with SQLite but should work like that.

[hasansalimkanmaz]

For SQLite, the below line just works for me.

cursor.execute("DELETE FROM checkpoints WHERE thread_id = ?", (thread_id,))

[misterworker]

@hasansalimkanmaz What about the writes and blobs tables?

[hasansalimkanmaz]

I had only one table. there was no other table. Can be library version issue as I didn't set up anything specifically.

[HenryXiaoYang]

We need a function to delete the datas! A database can get larger and larger without deleting the outdated thread_ids, eventually either the machine or database will fail... Deleting using the sql, instead of python functions, does not seem to be safe..

[rtadewald]

Any update here? Seems like a basic feature...

[apthagowda97]

Any idea on Redis Checkpointer ?? I know i can set allkeys_lru ... but i want to delete some thread ids when user is stuck at interrupt and want to clear the memory and start fresh ( changing thread id is not possible in our case ) ?

[glmourad]

Also adding a creation and last time update timestamps to the checkpoint can help on cleansing the old ones

[NathanAP]

Guys this is a required need from the community.

When you need to retrieve data from elsewhere the data keeps growing forever too fast, my main issues with states are related to me having too much data in a few interactions between the user and the bot.

edit: this is just an opinion, but I think that the docs are not helping people understand the difference of config, state and when to use each of them. When I first started programming in LangGraph I thought that config was something I should never touch and state was my "session", then I discovered I should put my data (like access tokens, user id, etc) in the config because the state is "not safe enough".

Right now my state contains tons of data and I always thought that I would have total control of it, but right now I find myself limited by it.

We need an option between the state and config that we are free to manipulate.

edit 2: I created this reducer so I can use a "clear" node in the beginning of my graph:

def my_add(a: List[Any], b: List[Any]) -> List[Any]:
    """"""

    if len(b) == 0:
        return []

    return operator.add(a, b)

and then in my state I do retriever_data: Annotated[List[Dict[str, Any]], my_add] = [].

You could use add_messages instead of operator.add as well if you want to.
I'm just using these in my lists, but you could easily do something close to it for other types.

[misterworker]

why would your state not be safe?

[NathanAP]

"safe" might not be the right word, but I got an answer some days ago saying that the state is used internally by LangGraph, so its not recommended to store "personal" stuff in there.

[misterworker]

ahh ok that's good to know thanks for this

[ND56]

@NathanAP thanks much for the example for how to create a custom reducer; that is exactly the custom reducer I was looking for as well (one that is additive but clearable on demand). Should totally be a builtin. Crazy also how hard it was to find docs around building custom reducers (of which I could find zero!).