Serialize the compiled graph to JSON for saving in Redis

[sagorbrur]

Hi,
I want to keep the compiled graph into redis. Is there any way to serialize the compiled graph and save it in Redis?
Please let me know. I am getting error while loading the graph into Redis.
redis.exceptions.DataError: Invalid input of type: 'CompiledStateGraph'. Convert to a bytes, string, int or float first.

Thanks in advance.

Update: I can save the compiled graph as to_json but can't load this. Is there any to load the graph?

Kind regards

[nfcampos]

Hi, what's your use case for storing the compiled graph in redis?

The compiled graph includes references to your node and edge functions therefore can't be serialized to json (or any similar format). You could try pickling the graph, see https://docs.python.org/3/library/pickle.html

[sagorbrur]

Hi @nfcampos ,
Thanks for your reply.
My graph compiling method is a dynamic method where I pass the graph data and compiled the graph accordingly.
For scalling factor, each time a client send the graph data my method will compiled the graph and return it for further use cases.
I tried pickling but there was an error that It couldn't pickle the object due to the below error.

AttributeError: Can't pickle local object 'CompiledStateGraph.attach_node.<locals>._get_state_key'

Kind regards
Sagor

[filip-michalsky]

same

[love-danika]

+1

[pedrorfig]

+1

[menon92]

@nfcampos Hi,

I tried https://docs.python.org/3/library/pickle.html but got AttributeError: Can't pickle local object 'CompiledStateGraph.attach_node.<locals>._get_state_key'

I also tried dill but I'm getting,

    538                 return value if value is not None else SKIP_WRITE
    539             else:
--> 540                 raise InvalidUpdateError(f"Expected dict, got {input}")
    541 
    542         # state updaters

InvalidUpdateError: Expected dict, got <object object at 0x7e7b38378d10>

[soyfjimenez]

Hi!

Im facing the same issue. Did you found any way to achieve this?

[sagorbrur]

Hi @soyfjimenez ,
We tried Dill for this, but the problem is that Dill saves the graph perfectly, but it won't work after loading.
So, we are not saving the graph in a persistent disk right now, we are keeping it in memory. We are trying alternative solutions so skip these options.

regards

[jmchn]

We are having similar problem right now. We have a scenario where users can dynamically create a graph on the web ui which we persist somewhere and can load later (when user logs out and logs in later). Is that feasible in LangGraph? Is there some kind of serilization of the compiled graph?

Appreciated!

[kashyap-aditya]

We have this exact same scenario.
We need a way to be able to save and reload a graph using some id otherwise if we have a 100 users and each can create different configurations of a graph for a conversation, we would need to keep all of those in memory.

Closest item I can think of is something like this:
https://learn.microsoft.com/en-us/azure/bot-service/bot-builder-basics?view=azure-bot-service-4.0

[bharath4moltin]

DId anyone find a solution for this? I tried dill but it's unable to serialize the compiled graph.Keep running into _pickle.PicklingError: Can't pickle <class 'langchain_core.runnables.base.RunnableParallel[dict[str, Any]]'>: it's not found as langchain_core.runnables.base.RunnableParallel[dict[str, Any]]

[abhishekbpandit]

Hi, im looking for a solution to this too. Any updates?

[strickvl]

Just wondering whether any inbuilt solution to this issue is planned?

[oscarjb]

Workaround for Pickling Error in LangGraph

Hello everyone,

I found a workaround for the pickling issue when trying to serialize a compiled StateGraph from langgraph.

⚠️ Note

This solution is intended for testing purposes in development environments only.

The Issue

If you attempt to serialize a compiled StateGraph using pickle, like this:

import pickle

with open("graph.pkl", "wb") as fp:
    pickle.dump(graph, fp)

you might encounter the following error:

---------------------------------------------------------------------------
AttributeError: Can't pickle local object 'CompiledStateGraph.attach_node.<locals>._get_state_key'

Why Does This Happen?

This error occurs because CompiledStateGraph (or other objects from langgraph) do not support direct serialization.

The Workaround

Instead of serializing the compiled graph, I serialized the graph definition and the checkpointer separately.

Steps to Save and Restore the Graph

1️⃣ Save the Graph Definition (Before Compilation)

from langgraph.graph import StateGraph
from langgraph.checkpoint import MemorySaver
from json import dumps
import dill

# Define the graph before compilation
graph_builder = StateGraph(State)
graph_builder.add_node("node1", node)  # Example nodes
graph_builder.add_node("node2", node2)

graph_builder.add_edge(START, "node1")
graph_builder.add_edge("node1", "node2")
graph_builder.add_edge("node2", END)

memory = MemorySaver()
graph_builder.compile(checkpointer=memory)

# Serialize the original StateGraph definition
with open("builder.pkl", "wb") as fp:
    dill.dump(graph_builder, fp)

2️⃣ Save the Checkpointer (MemorySaver)

# Serialize only the internal state of MemorySaver
with open("memory.pkl", "wb") as fp:
    dill.dump(memory.__dict__, fp)

3️⃣ Restore the Graph and Memory

# Load the graph definition
with open("builder.pkl", "rb") as fp:
    builder = dill.load(fp)

# Load the checkpointer's state
with open("memory.pkl", "rb") as fp:
    memory_data = dill.load(fp)

# Recreate the MemorySaver and restore its state
memory = MemorySaver()
memory.__dict__.update(memory_data)

# Recompile the graph with restored memory
graph_loaded = builder.compile(checkpointer=memory)

Now, you have a fully restored graph with the entire conversation state preserved! 🎉

I tested this using Amazon S3, and it worked perfectly. I hope this update helps you resolve your issue! 😊

[hinthornw]

While this may work for this demo, it's a bit of an anti-pattern.

LangGraph is designed around the idea that your application state is defined in the state object so the actual graph & process can be stateless. It would be better to use a real DB-backed checkpointer than to use the ephemeral in-memory abstraction and try to pickle the entire application between executions.

[kashyap-aditya]

So what approach would you recommend?
Let's say I have a web app and I am allowing the user to pass in some config and making a graph tailored to their needs. I can't keep every graph for everyone in memory forever!
We have to either recreate the graph for them at every request, which is time taking since it would involve a lot of tool initialization or we would cache the graph for the short term and pickle it (and save it in the db) for the long term.

My current solution is to cache the graph for the short term and recreate it entirely in the long term by saving their initial configuration and recreating the graph for them.

PS: I do pass in a postgres checkpointer to the graph so the graph saves the state to memory.

[strickvl]

Yeah we've also been thinking a lot about what it means to serialize / deserialize a graph as part of CI/CD or in a pipeline workflow. Moved away from langgraph because it was hard to make that happen. FWIW, haystack has really nice inbuilt serialization/deserialization of their pipelines (the equivalent of a langgraph workflow AFAIK): https://docs.haystack.deepset.ai/docs/serialization

[oscarjb]

@hinthornw Yes, I completely agree that using a database-backed checkpointer is the better and the right approach. As I mentioned in my note, this solution is intended solely for testing in development environments.