LangGraph gives you durable per-thread state through checkpointers — but that's short-term, within one conversation. The moment you need cross-thread, cross-user long-term memory — facts that persist across every run and are isolated per end user — you're building infrastructure: embeddings, a vector store, deduplication, retrieval tuning, and multi-tenant isolation. That's weeks of platform work before your agent gets meaningfully smarter. This guide shows what persistent memory for LangGraph looks like in practice — what to store, what it changes, and exactly how to wire it up. New to the idea? Start with the complete guide to persistent memory for AI.
Why LangGraph agents need persistent memory
The problem isn't the model — it's statelessness. LangGraph is only as consistent as the context it's handed each session, and without a durable memory that context resets to zero every time. Persistent memory is a store outside the model that keeps the facts, decisions, and preferences you build up, and surfaces them by meaning when they're relevant again — so LangGraph stops re-learning your project and starts compounding what it knows.
What your LangGraph setup should remember
- Durable user and account facts that should apply across every thread and run.
- Decisions and outcomes from prior graph executions, recalled by meaning.
- Preferences and corrections that personalize the agent per end user.
- Organization-level knowledge shared by a team, separate from any one user's memories.
What it changes, concretely
Before: your long-term memory epic is a store to stand up, an embedding model to pick, and a dedup strategy to tune. After: a recall node loads relevant memories into state at the start of a run, a remember node writes durable facts at the end, and the epic collapses into two tool calls.
How to add persistent memory to LangGraph
- Add the Kit for AI REST API or SDK as a tool (or a graph node): recall(query, end_user_id) to load memories, remember(fact, end_user_id) to write them.
- Pass an end_user_id per request — each of your users gets an isolated memory namespace automatically.
- Inject recalled memories into the graph state so downstream nodes and the LLM see them.
- The same API converts documents and runs hybrid search, so memory and RAG share one retrieval layer.
One memory across every tool
Because the memory lives in the cloud, it isn't locked to LangGraph. A decision you save here is recalled by every other MCP-capable tool and by your own scripts over the API — switch models or editors and your memory follows you. That's the difference between a per-app memory silo and a real memory layer for AI, and it's why the same account also handles document ingestion and cited search.
FAQ
Does LangGraph have persistent memory built in?
LangGraph can persist a single thread or run's state, but not a distilled, semantically searchable long-term memory that spans threads and users. Persistent memory adds exactly that — a durable store, recalled by meaning, isolated per end user — through one API.
How do I give LangGraph long-term memory?
Call the Kit for AI REST API or typed SDK from your LangGraph setup: recall(query, end_user_id) to load relevant memories into context and remember(fact, end_user_id) to save durable facts — with an isolated namespace per user, so one integration serves all of them.
Related guides
Go deeper: the AI memory API · memory and RAG are different jobs — or read the pillar guide to persistent memory for AI.
Add persistent memory to your LangGraph agents in minutes — Start free and call remember and recall over the REST API or the typed SDK.