Open Source · Curated · Updated periodically
A curated index of open-source memory frameworks for AI agents. Classified by layer (Framework, Infra, Research), memory class, architecture pattern, license, and maturity. Filter by layer or maturity, sort by any column.
| Framework |
Stars |
Layer |
Memory Class |
Architecture |
License |
Maturity |
Topics |
|---|
An AI agent memory framework gives an agent state that survives past its context window: facts, preferences, or events stored during one run and retrieved in a later one. A model's context window is short-term memory — it disappears when the conversation ends. A memory framework adds the layer underneath: what gets stored, how it's indexed (vector similarity, a knowledge graph, key-value), how it's retrieved when relevant, and — in the more complete implementations — how it's consolidated or forgotten over time so it doesn't grow unbounded.
This is a narrower, more specific problem than general agent orchestration, which is why it has its own ecosystem and its own index here rather than living inside the AI Agent Frameworks list. Some entries (mem0, Letta, Zep) are purpose-built memory layers you drop into any agent stack. Others (LlamaIndex, Haystack, AutoGen) are broader frameworks where memory is one capability among several. A few (chroma, dolt) are storage primitives that memory frameworks are frequently built on top of, rather than memory systems themselves.
Every entry above is classified by which layer of the memory stack it occupies — use the Layer filter to isolate one.
A purpose-built API for agent memory — store, retrieve, consolidate, forget. Drops into an existing agent loop. Most entries in this index (mem0, Letta, Zep, Graphiti, LangMem, cognee) sit here.
A lower-level storage or versioning substrate that memory frameworks are often built on top of — a vector database, a versioned relational store, or an OS-style unified memory layer (chroma, dolt, MemOS).
Early, single-paper implementations exploring a new memory architecture, not yet aimed at production adoption.
Beyond layer, each framework is tagged by who the memory is for and how it's structured underneath.
Remembers facts about one user or session — preferences, history, prior conversations — for continuity in a single-user experience.
Remembers shared knowledge across users or sessions — a domain knowledge base or organizational fact store used consistently by many agents.
Supports personalization and institutional patterns at once. The majority of production-grade frameworks in this index — mem0, Letta, Zep, Graphiti — fall here.
Similarity search over embeddings. The oldest and simplest retrieval pattern, and the one most storage-layer tools (chroma) implement directly.
Facts and relationships stored as a graph rather than embeddings — better for multi-hop reasoning, harder to keep consistent at scale.
A knowledge graph where facts carry validity windows, so the system can reason about what was true when. Zep and Graphiti are the reference implementations.
Memory organized into layers by recency or importance, modeled on operating-system memory hierarchies (Letta, MemOS).
Memory as a versioned, git-like history rather than a mutable store — useful for auditability and rollback (dolt, Memoria).
Six things worth checking before committing to one.
Personalization (per-user continuity), institutional (shared knowledge base), or both? This decides more than any other factor.
Vector similarity, knowledge graph, temporal graph, or tiered/OS-style — trades off recall precision against latency and implementation complexity.
A full framework (mem0, Letta) gives you a memory API. An infra primitive (chroma, dolt) gives you storage you still have to wire into an agent loop yourself.
Does it have a native adapter for the orchestration layer you're already using — see the agent frameworks index — or do you build the plumbing yourself?
Apache-2.0 and MIT cover most of this index unrestricted for commercial use. Check for mixed or copyleft licensing (some entries carry AGPL-3.0 or split licensing) before adopting.
The Maturity column (Production, Emerging, Research, Experimental) reflects real-world adoption more reliably than star count alone.
Software that gives an agent state beyond its context window — storing facts, preferences, or events from one run and retrieving them in a later one. It covers how memory is indexed (vector, graph, key-value), how it's retrieved, and often how it's consolidated or forgotten over time.
A vector database (like chroma) is a storage primitive — it stores embeddings and answers similarity queries, with no opinion on agent memory. A memory framework (like mem0) adds the layer on top: deciding what's worth remembering, when to retrieve it, how to merge conflicting facts, and when to forget. Several entries in this index are storage layers rather than full memory systems — check the Layer column.
Personalization memory tracks one user or session — preferences, history, continuity. Institutional memory tracks shared knowledge used consistently across many users or agents, closer to a knowledge base. Most production frameworks now support both at once rather than picking one.
Short-term memory is the model's context window — it holds the current conversation and vanishes when the session ends. Long-term memory is what a memory framework adds: state that's written to persistent storage and retrieved in a future session, independent of context window size.
Yes. mem0 is Apache-2.0 licensed and can be run fully self-hosted; a managed cloud version is also offered separately. Check the License column above for the current licensing of any entry before adopting it commercially.
A knowledge graph where facts carry validity windows, so the system can answer "what was true at time X" rather than only "what's true now." Zep and Graphiti are the reference implementations in this index.
The AI Agent Frameworks index covers general orchestration — how an agent decides what to do next. This index is narrower: frameworks and infrastructure specifically for giving an agent persistent memory across runs. Some tools (AutoGen, LlamaIndex) appear conceptually in both spaces but are indexed here for their memory capability specifically.
Stars, forks, and topics are refreshed daily via GitHub Actions; layer, memory class, architecture, and maturity are manually curated and updated as the ecosystem changes.