JsonPlusSerializer compatibility between LangGraph Python and LangGraph JS

[afnan-davia]

Dear all, I hope you are doing well. I wanted to ask if there could be a possibility to have a SerializerProtocol for PostgresSaver that would be compatible for both Python and JavaScript.

I am currently implementing a complete Python back-end with LangGraph because it is very powerful and the Data Scientists are more familiar with Python. To save checkpoints, I use the PostgresSaver with a Supabase db. On the front-end, I am using Vercel's AI SDK and I implemented their stream protocol to be able to send streams from the back-end to the front-end. Everything is working great in this direction.

The problem arises when I want to retrieve chat history on the frontend. I wanted to rely on the channel_values available in the postgres checkpoints from the last "getTuple" result but I am having issues because of the use of msgpack since Python's JsonPlusSerializer uses that (or pickles for LangGraph api) whereas JS's JsonPlusSerializer only uses json serialization.

Having a SerializerProtocol that would bring compatibility could be absolutely amazing for startups using LangGraph Python and Vercel's AI SDK.

Of course, a workaround would be to independently save messages on the front end on each message received but that would just duplicate information across the database.

Thank you very much for all the great work!

[rajtilak-2020]

You raise an excellent point about the need for a consistent serialization protocol that bridges the gap between Python and JavaScript environments, particularly for tools like LangGraph and Vercel's AI SDK. Here's an approach to address this:

---

Challenges Identified:

1. Incompatible Serialization Protocols:

   • Python's JsonPlusSerializer in LangGraph defaults to msgpack or pickle, which aren't natively readable by JavaScript.
   • JavaScript's JsonPlusSerializer relies solely on JSON serialization, causing compatibility issues.

2. Data Duplication Concern:

   • Saving message states independently in the frontend and backend to bridge the gap could lead to data duplication.

---

Solution Proposal: SerializerProtocol for Compatibility

A unified SerializerProtocol compatible with both Python and JavaScript can be implemented using JSON as the baseline serialization format with extensions for additional metadata.

Step 1: Use JSON Serialization with Metadata

Define a serialization schema that adheres to JSON standards but includes metadata for extended features.

Python Implementation

In LangGraph, replace JsonPlusSerializer with a custom JSON serializer.

import json

class CustomJsonSerializer:
    @staticmethod
    def serialize(data):
        """Serialize Python objects to JSON."""
        return json.dumps(data, ensure_ascii=False, default=str)

    @staticmethod
    def deserialize(data):
        """Deserialize JSON strings to Python objects."""
        return json.loads(data)

JavaScript Implementation

Ensure the same schema is used on the frontend.

class CustomJsonSerializer {
  static serialize(data) {
    // Serialize JavaScript objects to JSON
    return JSON.stringify(data);
  }

  static deserialize(data) {
    // Deserialize JSON strings to JavaScript objects
    return JSON.parse(data);
  }
}

Step 2: Modify PostgresSaver to Use Custom Serializer

Override the default JsonPlusSerializer in LangGraph to use the CustomJsonSerializer for both saving and retrieving data.

from langgraph.persistence.postgres_saver import PostgresSaver

class CustomPostgresSaver(PostgresSaver):
    def serialize(self, data):
        return CustomJsonSerializer.serialize(data)

    def deserialize(self, data):
        return CustomJsonSerializer.deserialize(data)

---

Step 3: Integration with Vercel’s AI SDK

On the frontend, adapt the retrieval logic to use the compatible serializer.

fetch("/api/chat-history")
  .then((response) => response.json())
  .then((data) => {
    const history = CustomJsonSerializer.deserialize(data);
    console.log("Chat history:", history);
  });

---

Step 4: Migration Strategy

If existing data in your Postgres database uses msgpack or pickle, you’ll need to migrate it to the new JSON-compatible format. This could involve:

1. Retrieving all stored data using the current deserialization logic.
2. Reserializing it using the new JSON-compatible CustomJsonSerializer.
3. Updating the database records.

---

Why This Approach Works:

1. Language-Agnostic Serialization: JSON is natively supported in both Python and JavaScript, making it ideal for cross-language compatibility.
2. Extensible: You can include additional metadata in the JSON schema without breaking compatibility.
3. Minimal Overhead: Avoids data duplication while ensuring consistency.

---

Future Considerations:

1. Standardization in LangGraph: Propose a SerializerProtocol enhancement to the LangGraph team that uses JSON as the default for broader compatibility.
2. Efficiency Trade-offs: While JSON is readable and portable, it might be less efficient than msgpack or pickle for certain use cases.