EVERY LLM MEMORY SOLUTION IN ONE PLACE

I spent a few weeks cataloging every LLM memory system I could find. Open-source libraries, commercial platforms, built-in features from the major LLM providers. This page is the result.

The space has exploded since mid-2025. A year ago, Mem0 and MemGPT were the only names most people knew. Now there are 20+ active projects, each with a different bet on how memory should work. Some use vector stores. Some use knowledge graphs. Some let the LLM manage its own memory. Some use SQL. One uses the Zettelkasten method, which I did not see coming.

I have tried to be fair. I built widemem, so I have opinions, but this page is meant to be useful regardless of which system you pick. Every project listed here is solving a real problem. Some are solving it differently than I would. That is fine. The field is better for having multiple approaches.

OPEN SOURCE: THE MAJOR PROJECTS

These are the projects with significant traction (10k+ GitHub stars), active development, and real production usage. If you are evaluating memory systems for a serious project, start here.

OPEN SOURCE: GROWING AND RESEARCH PROJECTS

Smaller but interesting. Some are research projects with NeurIPS papers behind them. Others are newer projects trying a different angle. Worth watching even if you would not put them in production today.

COMMERCIAL PLATFORMS

Some of the open-source projects above also have commercial offerings. These are the managed/hosted versions plus dedicated commercial products.

BUILT-IN MEMORY FROM LLM PROVIDERS

Every major LLM provider now ships some form of memory. These are consumer-facing features baked into the chat interfaces. Most are not available via API, which means you cannot build on them.

WHAT PATTERNS ARE EMERGING

Graph is winning the architecture debate

A year ago, most memory systems were vector-store-plus-similarity-search. Now the top projects (Mem0, Graphiti, Cognee) are all graph-based or hybrid. The reason: entity relationships matter. "Alice works at Google" and "Alice lives in San Francisco" are related through Alice, and a graph captures that relationship in a way a flat vector store does not.

The tradeoff is complexity. A graph database is more infrastructure to manage. For single-user agents on a laptop, a flat vector store with good scoring is often enough. For multi-tenant platforms with complex entity relationships, graph memory is worth the overhead.

LLM providers are not solving the developer problem

OpenAI, Anthropic, and Microsoft all have memory features now. None of them expose it through an API (except Google through Vertex AI). If you are building an AI application and need memory, you cannot rely on the provider's built-in feature. You need a memory layer.

This is probably intentional. Memory is a differentiator for the consumer chat products. But it creates a gap that open-source projects are filling.

Benchmarks exist but nobody agrees on them

Supermemory leads on LongMemEval, LoCoMo, and ConvoMem. Zep leads on Deep Memory Retrieval (94.8%). Mem0 reports 26% improvement over OpenAI's memory. These numbers are not directly comparable because they measure different things.

There is no ImageNet moment for AI memory yet. No single benchmark that the community agrees on as the standard. This makes comparison shopping difficult. Pick the benchmark that matches your use case and evaluate against that, not the headline number.

Local-first is a real use case, not just a philosophy

Several projects (widemem, Memori, OpenMemory, Google's Always-On agent) run fully local with SQLite and FAISS or no vector database at all. This is not just privacy theater. For personal AI assistants, coding agents, and edge deployments, sending every memory operation to a cloud API is impractical. The local-first projects tend to be simpler but cover a real need that the enterprise-focused solutions do not.

Nobody has solved forgetting

Most systems are still primarily accumulation engines. They add information well. Removing or superseding outdated information is an afterthought. Temporal graphs (Zep), conflict resolution (widemem, Mem0), and self-editing memory (Letta) all take different approaches, but none of them have a satisfying answer to the question: "how do you know when a fact is no longer true?"

This is the hardest open problem in the space. Whoever solves intelligent forgetting will have a significant advantage. The brain does it through synaptic pruning and retrieval-induced suppression. We are still using exponential decay functions and hoping the LLM catches contradictions. The gap is large.

HOW TO CHOOSE

Picking a memory system depends on what you are building. Here is a rough decision tree:

Or just try two or three. Most of these install with pip and take five minutes to set up. The best way to evaluate a memory system is to throw your actual data at it and see what comes back.

This page will be updated as the space evolves. If I missed a project or got something wrong, open an issue and I will fix it.