Announcing the TypeDB Plugin for LangGraph

The Agentic AI paradigm is revolutionizing how developers solve complex problems, and LangGraph is quickly becoming the de-facto framework for building these stateful, multi agent system.

To power these complex workflows, agents need a robust way to manage and persist their memory. That’s why we are releasing two LangGraph integration plugins: the TypeDB checkpoint saver and long-term store. Available as Pip packages for Python, these libraries let you seamlessly persist the working memory of your LangGraph agents directly into TypeDB.

What’s included

• Checkpoint saver: Persists LangGraph’s message history. Drop it in anywhere you’d use the built-in SQLiteSaver or PostgresSaver.
• Long-term store: Implements LangGraph’s BaseStore interface for cross-thread memory storing user preferences and learned facts.

Why use it

If you’re already running TypeDB as your application database, you can now use the same instance for agent state too! That means one database to manage instead of having to bolt on Redis or Postgres just for agents.

Get started

pip install langgraph-checkpoint-typedb langgraph-store-typedb

1. Using the checkpointer

The checkpointer lets you persist the state of a LangGraph agent, so that conversations can be resumed at a later time even if the agent process is stopped.

For background, see LangGraph’s persistence and checkpointing guide.

from langgraph_checkpoint_typedb import TypeDBSaver
from typedb.driver import Credentials, DriverOptions, TypeDB
driver = TypeDB.driver(
    "localhost:1729",
    Credentials("admin", "password"),
    DriverOptions(is_tls_enabled=False),
)
checkpointer = TypeDBSaver(driver, database="langgraph_checkpoints")
checkpointer.ensure_database()
checkpointer.ensure_schema()
graph = state_graph.compile(checkpointer=checkpointer)
config = {"configurable": {"thread_id": "1"}}
graph.invoke({"messages": [HumanMessage(content="hello")]}, config=config)

Using the long-term store

The long-term store holds memory that can be accessed by multiple LangGraph agents, such as facts the agent has learned about the user. This is particularly useful when you have multiple agents, or when you have some information that needs to be remembered across conversations.

For background, see LangGraph’s long-term memory guide.

from langgraph_store_typedb import TypeDBStore
from langchain.tools import tool
store = TypeDBStore(driver, database="langgraph_memory")
store.ensure_database()
store.ensure_schema()
NAMESPACE = ("users", "default-user", "notes")
@tool
def remember(note: str) -> str:
    """Save a note to the user's long-term memory."""
    key = uuid.uuid4().hex
    store.put(NAMESPACE, key, {"note": note})
    return f"saved note {key}"
@tool
def recall() -> list[str]:
    """List every note the user has saved."""
    items = store.search(NAMESPACE, limit=100)
    return [it.value["note"] for it in items]
graph = state_graph.compile(checkpointer=checkpointer, store=store)

Where to go next

In our next article, we’ll combine these plugins with typedb-mcp to show how an agent can query TypeDB as both its application database and its memory store.

Both plugins are a new experimental release and have some limitations. For instance, vector / semantic search are currently not supported. We’ll stabilise and add more advanced functionalities as we learn more from our users about their requirements.

Finally, we’d love to hear what you build. Drop into our Discord and let us know!