Every "best AI memory tools" list gives you the same ranked lineup and leaves you with the same problem: you still don't know which one fits what you're building. Rankings assume every reader has the same job. You don't.
So here's a different way through the same eight open-source tools (Mem0, Cognee, Zep, Graphiti, Letta, MemGPT, LangMem, Supermemory). Start from the job you actually have, then pick the tool shaped for it. This is based on public docs and pricing as of September 2026, not hands-on benchmarking, so verify the details that matter to you against each project's repo before committing.
Start from the job, not the tool
Agent memory fails in predictable ways, and each failure mode points at a different tool:
- Your agent re-asks the user's name, stack, and preferences every session. That's a personalization problem.
- Your agent remembers a fact from March but the fact changed in June. That's a temporal problem.
- Your agent knows the entities but can't connect them. That's a relational problem.
- Your agent burns its context window on bookkeeping. That's an architecture problem.
- You just don't want to operate any of this. That's an ops problem.
Match your problem to the section below.
"My agent forgets who it's talking to"
You need per-user memory: facts and preferences extracted from conversation, stored per user, recalled next session. Nothing fancy, just persistent.
Look at Mem0. It's Apache 2.0, self-hostable, and purpose-built for exactly this. Conversation-level fact extraction, vector storage with an optional Neo4j graph add-on, a clean Python SDK, and a managed cloud tier if you want to skip ops. It has the largest community of the tools here and the fastest path from zero to working. The honest limits: graph support is an add-on rather than native, so don't expect multi-hop reasoning, and it's not built for heavy document ingestion.
Lighter alternative: Supermemory. MIT licensed, dead-simple REST API, document and URL ingestion, Docker self-hosting. If Mem0 feels like more than you need, Supermemory is the smallest thing that remembers stuff across your apps. Just know it tops out early: no graph support, no MCP, not built for scale.
"My facts have timestamps, and they change their minds"
The user moved cities. The API limit changed. The decision got reversed. If your memory can't version facts over time and resolve contradictions, it will confidently serve stale truth.
Look at Graphiti. It's the temporal knowledge graph engine behind Zep, released standalone under Apache 2.0. It builds temporally aware graphs from text and dialogue with contradiction detection, fact versioning, and bi-temporal modeling (it tracks both when something happened and when it was recorded). It integrates with Neo4j. The catch: it's a library, not a full memory solution. Budget real integration work, and there's no MCP support out of the box.
Want it packaged? Look at Zep. Zep wraps Graphiti's engine in a full memory store: episodic memory extraction from dialogue, semantic search, fact storage with temporal versioning, user and session isolation for multi-tenant apps, REST plus Python and TypeScript SDKs, and a managed cloud tier. Apache 2.0 and self-hostable. The tradeoff versus raw Graphiti is narrower ingestion scope and limited MCP support.
"My knowledge is a web, not a pile"
If your agent needs to reason across connected entities, follow chains of causation, or answer questions that span multiple documents, flat vector retrieval will quietly fail you. You need a graph, and not as an afterthought.
Look at Cognee. It's the graph-first option: Apache 2.0, with an ECL (Extract, Cognify, Load) pipeline that ingests documents, audio, images, and API data from 30+ sources into a traversable knowledge graph, queried with hybrid graph-plus-vector retrieval. Native MCP support, multi-tenancy, RDF ontology support for domain schemas, and self-hosting down to fully local air-gapped deployments. Cognee lists production users including Bayer and the University of Wyoming. Fair warning: the architecture takes more setup than the vector-only tools, the learning curve is real if your team is new to knowledge graphs, and building the graph costs LLM tokens that are wasted on a small corpus.
"I want the agent to manage its own memory"
Some teams don't want a memory service at all. They want a runtime where memory is part of the agent's architecture: the agent decides what stays in context and what gets archived.
Look at Letta. Formerly MemGPT, now a full agent framework under Apache 2.0. Hierarchical memory with in-context blocks for persona and active task state plus archival storage with vector search, agents that self-manage the boundary, REST API, multi-agent orchestration with shared memory, and a managed cloud option. The limits: no native graph storage, no native MCP support, and the context-window-centric design isn't ideal for knowledge-heavy workloads.
MemGPT is the research ancestor: OS-inspired virtual memory paging for LLM context, the project that proved agents could manage their own memory tiers. It's largely superseded by Letta for production, but if you're studying or teaching agent memory, start here.
"I'm already married to LangChain"
Look at LangMem. It's LangChain's own memory library for LangGraph agents: extraction, storage, and retrieval primitives at user, thread, and namespace level, integrated with LangGraph state and observable through LangSmith. MIT licensed. If your agents already run on LangGraph, this is the path of least resistance. If they don't, skip it: it's tightly coupled to the LangChain ecosystem, has no graph support, and the self-hosting story leans on LangChain infrastructure.
"I don't want to run any of this"
Here's the ops problem, and the honest answer to it: sometimes the right move is not picking from this list at all. If your goal is simply that your AI tools remember things across sessions and you have zero interest in operating databases, a managed layer beats a self-hosted one you never tune.
That's the slot Vilix AI fills. It's shared memory over MCP: auto-saves conversation turns, retrieves with semantic RAG, keeps the same memory across devices via server-side storage, and lets you list, update, delete, or export everything from any connected AI or the dashboard, with per-user isolation and last-write-wins semantics. It plugs into Claude, Codex, Cursor, OpenClaw, Hermes, Manus, and Lovable, takes about ten minutes to set up, and runs a free tier plus a 7-day Pro trial with no credit card.
Two things I'd tell you even if I weren't the one building it. First, Vilix AI is not open source, so if owning the code is the requirement, go back to the list above. Second, and this applies to every MCP memory tool: the model decides when to call the memory tools, and models sometimes skip the call unless nudged. Ask any vendor in this space what happens when the model doesn't call before you commit.
The one-paragraph decision
Personalization for a chatbot: Mem0, or Supermemory if you want it minimal. Facts that change over time: Graphiti if you'll build the pipeline, Zep if you want it packaged. Connected knowledge you can reason over: Cognee. Agents that own their memory: Letta. Already on LangGraph: LangMem. Studying the field's history: MemGPT. And if you'd rather not operate infrastructure at all, that's a managed layer's job, not an open-source one's.
Disclosure: I build Vilix AI, a shared memory layer for AI tools.
Top comments (0)