AI Agents Forget Everything Without Memory: 9 Tools That Fix It

Last updated: August 9, 2026. Cognee joins the ranking at no. 3 on the strength of its published BEAM and HotpotQA numbers and an Apache 2.0 licence that gates nothing behind a paid tier. Everything else was re-verified in July: Mem0 tripled its free-tier limits, Zep retired self-hosted Community Edition (Graphiti itself stays open source), Pinecone switched from a vector-count cap to GB-based pricing, and Letta shipped a real $20/mo Pro cloud tier.

The best AI agent memory tools in 2026 are Mem0 (best overall), Zep (best for temporal context), Cognee (best self-hosted graph memory), Pinecone (best managed vector store), and Letta (best for full control). Most production systems combine a dedicated memory platform like Mem0, Zep, or Cognee with a storage layer like Pinecone or Redis, one tool rarely covers both extraction and retrieval at scale.

Choosing an AI agent memory tool is really a stack decision. You need a memory platform for extraction and retrieval, plus infrastructure underneath for storage, caching, or graph queries. New to the concept? Start with our complete guide to AI agent memory for the fundamentals.

We've tested these tools in production agent systems. Here's how they rank, and more importantly, why.

Rankings at a Glance

*Zep retired its self-hosted Community Edition in 2025. Its underlying Graphiti engine is still open source and self-hostable on its own, just not the full Zep product.

Every tool offers either a free tier or a fully open-source path (often both), so you can prototype without spending anything. Rankings weigh developer experience, production readiness, community size, and value at scale. Let's break each one down.

1. Mem0 -- Best Overall

Mem0 is the most popular dedicated memory platform right now, and it earns the top spot for good reason. With 61.2K GitHub stars (up from 47.8K in June) and a $24M across seed and Series A, it's backed by YC and has the most active community in the space.

What's Great

Mem0's hybrid architecture combines vector search, knowledge graphs (on Pro), and key-value storage. The standout feature is automatic memory extraction, feed it conversations, and it pulls out facts, preferences, and relationships without manual tagging. If you'd rather build that extraction step yourself, structured-output libraries help enforce a consistent schema on what the model returns. Multi-user and multi-agent support come built in, so a single Mem0 instance serves your entire product.

The developer experience is genuinely smooth. You're up and running in under 10 minutes, and the API design makes sense on the first read. The managed platform handles embedding, deduplication, and conflict resolution, which means less glue code on your side.

What's Not Great

Graph memory, one of the most compelling features, is locked behind the $249/mo Pro plan. Mem0 tripled its free-tier limits in its 2026 pricing update, from 1K to 10K memories per month, so the free tier now covers real prototyping instead of just a demo. Production traffic will still outgrow it. And if you're self-hosting the open-source version, you lose some of the managed platform's polish (automatic conflict resolution, hosted graph memory).

Pricing

Who Should Use It

Teams building production agents that need personalization and long-term recall. Startups who want to move fast without building memory infrastructure from scratch. Anyone prototyping who wants the widest feature set with minimal setup.

Verdict: Mem0 is the safest default choice for most teams. Widest feature set, best free tier, largest community. Start here unless you have a specific reason not to.

2. Zep, Best for Temporal Relationships

Zep takes a genuinely different angle from Mem0 by building around a temporal knowledge graph via its open-source Graphiti engine. Every fact gets timestamped, so your agent knows when something was true, not just that it was true.

What's Great

The temporal knowledge graph is a real differentiator. Support bots tracking evolving customer issues, project assistants following status changes, and any agent where context shifts over time, Zep handles these more naturally than alternatives. Its GraphRAG retrieval combines graph traversal with vector search for sub-second results.

Graphiti itself is fully open-source and self-hostable (28.9K GitHub stars on its own), which gives you an escape hatch from vendor lock-in even though Zep-the-product no longer offers self-hosting. Zep restructured its pricing in 2026: instead of pure pay-as-you-go from $25/mo, paid tiers now bundle a fixed monthly credit pool billed annually.

What's Not Great

Zep's community is smaller than Mem0's, so you'll find fewer tutorials and Stack Overflow answers when you get stuck. Zep also retired its self-hosted Community Edition in 2025, if full self-hosting matters to you, your only path now is running Graphiti (the open-source engine underneath Zep) yourself and rebuilding the platform layer on top, not deploying Zep itself. And if your agent doesn't deal with time-sensitive information, Zep's core advantage doesn't apply to you.

Pricing

Who Should Use It

Teams building agents where the timing of information matters. Customer support systems that track issue evolution. Project management bots that understand what changed and when.

Verdict: Zep is the clear pick when your agent needs to understand when things happened, not just what. The temporal knowledge graph is unique in this space, just budget for their cloud since a self-hosted Zep product no longer exists.

3. Cognee, Best Self-Hosted Graph Memory

Cognee builds a knowledge graph out of whatever you feed it, then answers over that graph instead of over a flat vector index. Apache 2.0, 29.9K GitHub stars, and unlike Mem0, no part of the memory layer is reserved for a paid tier.

What's Great

The pipeline handles the tedious half for you: chunking, entity extraction, concept derivation, and ontology induction all run inside one cognify() call, and retrieval then traverses relationships instead of guessing from cosine similarity. On the BEAM long-context benchmark Cognee reports 0.79 at 100K tokens and 0.67 at 10M, against a prior state of the art of 0.735 and 0.641.

Storage is pluggable rather than prescribed: pgvector or LanceDB for vectors, Neo4j or Kuzu for the graph, or one Postgres instance doing both if you'd rather run a single container than four. The Claude Code, Codex, and MCP integrations ship in the free tier, so you can wire agent memory into a coding agent without entering a card.

What's Not Great

The headline comparison numbers come from Cognee's own January 2026 benchmark, where Cognee ran tuned (GRAPH_COMPLETION_COT) while Graphiti, LightRAG, and Mem0 ran on defaults. On that 24-question HotpotQA subset Cognee scored 0.85 DeepEval correctness to Mem0's 0.54, but the configurations weren't matched, and Cognee's own writeup says as much. Read it as evidence that graph memory helps on multi-hop questions, not as a like-for-like ranking.

Graph construction also costs more per document than plain embedding, because every ingest runs LLM extraction passes, so ingest latency and token spend are both higher than a vector-only setup. And the managed connectors (Slack, Notion, Google Drive) are the one thing self-hosting doesn't hand you.

Pricing

Note the unit: Cognee bills tokens processed, not memories stored. That makes it cheaper than Mem0 for a small corpus queried constantly, and more expensive for a huge one ingested once.

Who Should Use It

Teams who want Mem0's extraction-plus-graph feature set without a $249/mo plan gating the graph. Anyone with a compliance reason to keep memory on their own Postgres. Agents answering multi-hop questions where "who connects to what" matters more than "what looks similar to this."

Verdict: Cognee is the pick when you want graph memory and self-hosting in the same tool. It burns more compute per ingest than a vector-only stack, and its published benchmark is tuned-vs-default, but the graph is free and the token pricing is predictable.

4. Pinecone, Best Managed Vector Store

Pinecone isn't a memory platform, it's the infrastructure layer that memory platforms often run on top of. But plenty of teams use it directly for agent memory, and it does that job exceptionally well.

What's Great

Serverless architecture means you never think about infrastructure. Pinecone scales to billions of vectors without you provisioning a single node. Metadata filtering and hybrid search (sparse + dense vectors) give you precise retrieval. The managed offering is the most mature in the vector database space, period.

For agent memory, Pinecone stores embeddings of past conversations, facts, and user profiles, generated by whichever embedding model you pick (see our best embedding models for RAG roundup if you haven't chosen one). Your agent retrieves what it needs via semantic search. The free tier now gives you 2GB of storage, Pinecone moved from a raw vector-count cap to a storage-based one in its 2026 pricing overhaul, still comfortably enough for prototyping and small production workloads.

What's Not Great

Pinecone is fully proprietary. No self-hosting option, no source code to inspect, no way to run it locally for development without hitting their API. You're committing to a vendor. Pricing used to jump steeply straight from free to pay-per-use; a new $20/mo Builder tier (10GB) now sits in between before Standard's $50/mo minimum kicks in, and the per-GB cost model still means you need to manage what you store.

It also doesn't handle any memory logic, no fact extraction, no conflict resolution, no temporal reasoning. You build that yourself or put a dedicated platform on top.

Pricing

Who Should Use It

Teams that want reliable vector storage without managing infrastructure. Backend for a dedicated memory platform. Anyone who values operational simplicity over flexibility. If you're building a retrieval system from scratch, our step-by-step RAG application guide shows exactly how to wire a vector store into a production pipeline.

Verdict: Best choice for zero-ops vector storage. Pair it with Mem0 or Zep for full memory capabilities, or use it directly if your memory needs are simple.

5. Letta, Best for Full Control

Letta (formerly MemGPT) treats agent memory like an operating system: main context is RAM, archival memory is disk, and the agent manages its own memory allocation. It's a fundamentally different philosophy from tools that abstract memory away from the agent.

What's Great

The OS-inspired approach gives agents more autonomy over what they remember and forget. This is genuinely powerful for research applications and custom memory architectures. Letta is fully open-source (23.9K GitHub stars) and self-hosted, so you have complete control over your data and infrastructure.

It's the most academically rigorous option here, the MemGPT paper introduced key concepts that influenced the entire agent memory space. If you're running experiments on memory architectures or need to customize memory behavior at a low level, nothing else matches Letta's flexibility. Their benchmarking work on agent memory evaluation (MemBench) is also pushing the field forward.

What's Not Great

The flexibility comes at a cost: more setup time, more infrastructure to manage, and a steeper learning curve if you self-host. Letta Cloud closed the managed-hosting gap in 2026 with a real Pro tier at $20/mo for up to 20 stateful agents, so "no cloud option" is no longer a fair knock, but the community is still smaller than Mem0's and the documentation assumes more background knowledge than most alternatives.

For teams that just want "add memory to my agent," Letta is overkill.

Pricing

Who Should Use It

Research teams exploring novel memory architectures. Teams with strong DevOps who want complete control. Anyone building custom memory behavior that off-the-shelf platforms can't support.

Verdict: Letta is best for teams that want maximum control over memory behavior. Self-hosting is still the most flexible path, but a $20/mo Pro cloud tier now exists if you'd rather not run the infrastructure yourself.

6. LangMem, Best for LangGraph Users

LangMem is LangChain's memory SDK, built specifically for the LangGraph ecosystem. If you're already building agents with LangGraph, LangMem plugs in as a background process that manages long-term memory without requiring a separate platform.

What's Great

The integration with LangGraph is smooth, it's a first-party SDK, not a third-party plugin. LangMem's most interesting feature is prompt optimization from memory: it learns from past conversations and adjusts prompts over time. It supports both semantic and episodic memory, and since it's free and open-source, there's zero cost barrier.

For teams already invested in the LangChain ecosystem, LangMem is the path of least resistance to adding agent memory. No new infrastructure, no new vendor relationship, no new billing.

What's Not Great

The tradeoff is ecosystem lock-in. LangMem assumes you're in the LangChain world, if you switch frameworks later, your memory system comes with you awkwardly or not at all. The feature set is also narrower than Mem0 or Zep: no built-in graph memory, no temporal reasoning, less sophisticated conflict resolution. Release cadence has slowed too, the latest PyPI package shipped in October 2025 even though the GitHub repo keeps getting active commits, so treat it as capable but still pre-1.0.

Evaluating your framework options? See our LangGraph vs CrewAI vs OpenAI Agents SDK comparison before committing.

Pricing

Who Should Use It

Teams already using LangGraph who want memory without adding a new vendor. Projects where prompt optimization is as important as factual recall. Startups on a tight budget who need something functional today.

Verdict: LangMem is the easiest path to agent memory if you're already invested in LangGraph. Free, native, and surprisingly capable, but only within its ecosystem.

7. Weaviate, Best Open-Source Vector Store

Weaviate is an open-source vector database that stands apart from Pinecone by offering hybrid search with built-in ML models. You can run it locally, self-host it, or use the managed cloud, your choice.

What's Great

Weaviate handles vectorization internally with built-in transformer models, so you don't need to manage a separate embedding pipeline. Hybrid search combines dense vectors with BM25 keyword search, giving you better retrieval accuracy than pure vector search alone. The multi-tenancy support is strong, making it a good fit for SaaS applications where each customer's memory needs to be isolated.

The open-source version is fully featured, and the community is large and active. If Pinecone's proprietary nature bothers you, Weaviate is the closest equivalent with an open-source foundation.

What's Not Great

Running Weaviate yourself means you're managing infrastructure, JVM tuning, storage provisioning, backup strategies. It's more operationally complex than Pinecone's serverless model. Weaviate restructured its cloud pricing in October 2025, the old $25/mo Serverless tier is gone, replaced by a $45/mo Flex tier and a genuinely free 100K-object cloud tier for testing. Query performance at very large scale (billions of vectors) requires careful index configuration.

Like Pinecone, it's a storage layer, no memory logic, no fact extraction, no conflict resolution.

Pricing

Who Should Use It

Teams who want open-source vector storage with built-in ML capabilities. SaaS companies needing multi-tenant memory isolation. Anyone who values self-hosting but still wants a managed option available. If you're comparing Weaviate against Pinecone and every other vector database side by side, our best vector databases 2026 guide has the full breakdown.

Verdict: Weaviate is the strongest open-source alternative to Pinecone. More operational overhead, but more flexibility and no vendor lock-in.

8. Neo4j, Best for Relationship Reasoning

Neo4j is the standard graph database, and its GraphRAG capabilities make it a strong choice for agents that need to reason about how entities relate to each other.

What's Great

Cypher queries let you traverse complex relationship networks in ways that vector search alone can't touch. Think research assistants connecting papers to authors to institutions, or knowledge management agents mapping organizational relationships. Neo4j's GraphRAG ecosystem specifically targets AI agent use cases with entity disambiguation, relationship extraction, and graph-aware retrieval.

The Community edition is genuinely capable and free to use. Enterprise features (clustering, advanced security) are available if you grow into them.

What's Not Great

Neo4j is a specialized tool. If your agent's memory is mostly "remember what the user said" rather than "understand how these 50 entities relate," it's more complexity than you need. The learning curve for Cypher and graph modeling is real, your team needs to think in graphs, which is a different mental model from tables or documents.

AuraDB now has a genuine $0 free tier for small dev instances (no credit card required), but Professional pricing is $65 per GB per month, not a flat monthly rate, so cost scales directly with graph size. That's still steep compared to vector database alternatives. And graph databases aren't great at pure semantic similarity search, you'll often pair Neo4j with a vector store anyway.

Pricing

Who Should Use It

Teams building agents that reason about entity relationships, knowledge management, research assistants, organizational intelligence. Applications where "who connects to what" matters more than "what's similar to this."

Verdict: Use Neo4j when your agent's value depends on understanding how things relate to each other. Specialized and powerful, but overkill for simpler memory needs.

9. Redis, Best for Caching and Session Memory

Redis isn't just a cache anymore. With vector search (RediSearch) and LangCache for semantic caching, it handles both short-term agent memory and LLM cost reduction in one tool.

What's Great

Sub-millisecond latency makes Redis unbeatable for session-scoped context. The semantic caching via LangCache is particularly valuable: similar queries hit the cache instead of making a new LLM call, cutting token costs significantly. You probably already have Redis in your stack, which means zero new infrastructure.

For short-term memory, "what did the user say in this session", Redis is hard to beat. It's the fastest option here by a wide margin.

What's Not Great

Redis was designed for caching, not for long-term memory. It lacks memory extraction, conflict resolution, temporal reasoning, or any of the higher-level features that dedicated platforms provide. Vector search in Redis works but isn't as mature or feature-rich as Pinecone or Weaviate. And data persistence requires explicit configuration, by default, Redis is ephemeral.

It ranks no. 9 not because it's bad, but because it's a supporting player rather than a primary memory tool.

Pricing

Who Should Use It

Teams that need fast session memory or want to slash LLM API bills with semantic caching. A complement to a dedicated memory platform, not a replacement for one.

Verdict: Reach for Redis when you need fast session memory or want to cut LLM costs. It's a supporting tool, pair it with a dedicated platform for full memory capabilities.

Mem0 Alternatives: Which Memory Tool Should Replace It?

The strongest Mem0 alternative is Zep, the no. 2 pick here, thanks to its temporal knowledge graph that timestamps every fact, just know you're committing to their cloud since Zep retired its self-hosted Community Edition in 2025. Cognee, our no. 3, is the closest feature-for-feature swap if the thing pushing you off Mem0 is graph memory sitting behind the $249/mo Pro plan. Letta wins for self-hosted control, LangMem for LangGraph-native projects, Pinecone for pure managed vector storage, and Hindsight is worth a look if you want multi-strategy retrieval with no vendor attached. Your best replacement depends on whether you need time-awareness, control, raw retrieval, or zero cloud dependency.

Looking for a Fully Open-Source Mem0 Replacement?

If "mem0 alternative" means something you can run yourself with no cloud bill, most of the names above don't actually qualify anymore. Zep's own product went cloud-only in 2025. Pinecone was never open-source. That leaves a shorter, more honest list:

• Cognee (Apache 2.0, 29.9K GitHub stars) runs its ingest-cognify-search pipeline, graph plus vector memory, on a single self-hosted Postgres instance. No feature sits behind a paid tier; the managed cloud is optional, not required. See the full breakdown at no. 3 above.
• Hindsight (MIT, 18.6K GitHub stars) runs four retrieval strategies, semantic, BM25, graph, and temporal, with a cross-encoder reranker, self-hosted via Docker, for free. Nothing here is gated the way Mem0's graph memory is gated behind Pro.
• Letta (Apache 2.0) is the most mature self-hosted option if you want OS-inspired memory management rather than a drop-in extraction and retrieval API.
• LangMem, Weaviate, Neo4j Community, and Redis OSS are all still free and self-hostable, useful as building blocks if you'd rather assemble your own stack than adopt one memory platform.
• Graphiti, Zep's underlying temporal graph engine, is still open source and self-hostable on its own (28.9K GitHub stars). It's just no longer packaged as the full Zep product.

None of these match Mem0's polish out of the box, you'll do more integration work. But if the deciding factor is no vendor and no recurring bill, Cognee and Hindsight are the closest functional matches to what Mem0 does.

Most teams that leave Mem0 do so for one specific reason: temporal reasoning (Zep), full infrastructure control (Letta), an existing LangGraph investment (LangMem), or a hard requirement to stay self-hosted (Cognee, Hindsight). Self-hosting Letta, Cognee, or Zep's Graphiti pairs naturally with an open-source LLM for a fully in-house stack. And since memory is just one layer of a larger system, our context engineering guide covers where memory fits alongside retrieval and prompt assembly, and our best context engineering tools roundup covers the tool picks for those other layers.

Why Techsy Picks Mem0 as no. 1

We've integrated memory systems into production agents across multiple client projects, customer support bots that remember user history, internal tools that learn team preferences, and RAG pipelines that need persistent context. Memory is one line item inside a larger build; if you want the full cost breakdown for AI agent development, framework, infra, deployment, and the vendor questions to ask, we laid that out in a dedicated guide.

Mem0 consistently wins our evaluations for a few practical reasons:

1. Time to first working memory is under 10 minutes. That matters when you're prototyping with a client on a tight timeline.
2. The free tier is actually useful, not just a demo. 10K memories per month (up from 1K before Mem0's 2026 pricing update) covers real prototype validation, not just a hello-world.
3. Multi-agent support worked out of the box for us. We had a project with three agents sharing memory about the same user, and Mem0 handled it without custom coordination logic.
4. Upgrade path is clear. We've moved two projects from free to Starter to Pro without migration headaches.

That said, we've used Zep for a project that tracked customer support ticket evolution (the temporal graph was genuinely the right fit), and we've paired Mem0 with Redis for session caching on latency-sensitive applications. To catch memory bugs early, we trace every read and write in production, our Langfuse vs LangSmith comparison covers the observability tooling we reach for.

The honest answer is that most production systems end up combining 2-3 tools. But if you're picking one to start with, Mem0 gives you the widest runway.

Need Something Custom?

Not every agent memory system fits neatly into an off-the-shelf tool. We've built custom memory architectures for clients who needed:

• Domain-specific memory extraction (medical, legal, financial contexts)
• Hybrid retrieval combining graph, vector, and rule-based logic
• Compliance-friendly self-hosted deployments with audit trails
• Memory systems that work across multiple agent frameworks

If your use case doesn't map cleanly to a single tool, reach out for a free consultation. We'll help you design the right memory stack for your specific requirements. See our AI integration services.

How to Choose the Right Memory Tool

Don't overthink this. Match your primary need to a tool, start building, and swap later if needed.

Scale path: Start with LangMem or Mem0's free tier for prototyping. Move to Mem0 Starter or Zep Cloud at growth stage. For enterprise, evaluate Letta or Zep self-hosted for compliance and cost control.

FAQ

What is the best memory framework for AI agents?

Mem0 is the best general-purpose choice for most teams in 2026. It combines vector, graph, and key-value storage with automatic memory extraction, has the largest community (61K+ GitHub stars), and offers a usable free tier. For LangGraph users specifically, LangMem is the path of least resistance.

Is Mem0 free?

Yes. Mem0 has a free tier that includes 10,000 memories per month, enough for real prototyping, not just a demo. Paid plans start at $19/mo for 50K memories.

Mem0 vs Zep: which is better?

They solve different problems. Mem0 is better for general-purpose personalization and long-term user profiles. Zep is better when temporal relationships matter, its Graphiti engine timestamps every fact, so your agent knows when something was true. If time-awareness isn't critical, start with Mem0.

What are the best Mem0 alternatives?

The best Mem0 alternatives are Zep for temporal, time-aware memory, Cognee for self-hosted graph memory, Letta for self-hosted control, and LangMem for LangGraph-native projects. Cognee is the closest match if the reason you're leaving is Mem0's $249/mo Pro gate on graph memory: it's Apache 2.0 and locks nothing behind a tier. Hindsight is the other vendor-free option worth a look. If you only need vector storage, Pinecone and Weaviate work well. Zep is the closest head-to-head replacement in terms of features, though it's cloud-only since it retired self-hosted Community Edition in 2025.

What's the best open-source alternative to Mem0?

If you need something you can run entirely yourself with no cloud bill, Cognee (Apache 2.0, 29.9K stars) is the closest match to what Mem0 does: automatic extraction, vector plus graph retrieval, and nothing gated behind a paid tier. Hindsight (MIT) is the runner-up if you want multi-strategy retrieval instead of a graph. Letta (Apache 2.0) is the better pick if you want OS-inspired agent memory management rather than a drop-in Mem0 replacement. Zep doesn't qualify here anymore, it retired its self-hosted Community Edition in 2025, though the underlying Graphiti engine is still open source on its own.

What is the best AI memory system for agents?

The best AI memory system for agents in 2026 is usually a stack, not a single tool: a dedicated platform like Mem0 or Zep for extraction and recall, paired with a storage layer like Pinecone or Redis. Mem0 is the strongest starting point because its free tier and automatic extraction cover most production needs.

Do I need a dedicated memory tool or can I use LangChain's built-in memory?

LangChain's older memory modules (ConversationBufferMemory, etc.) are being deprecated. For anything beyond basic chat history, you need a dedicated tool. LangMem is LangChain's own answer to this, it replaces the legacy memory modules with proper long-term memory that persists across sessions.

What vector database should I use for AI agent memory?

Pinecone if you want zero-ops managed hosting. Weaviate if you want open-source with built-in ML models. Redis if you also need caching. Many dedicated platforms like Mem0 handle vector storage internally, so you might not need a separate vector database at all.

Can I self-host AI agent memory?

Yes. Letta is fully open-source and designed for self-hosting. Zep's own product is cloud-only now, but its Graphiti engine is still self-hostable on its own. Mem0 has an open-source version, though graph memory requires the paid Pro plan. Cognee and Hindsight are newer options built specifically to match Mem0's full feature set (extraction, retrieval, graph memory) without gating anything behind a paid tier. Weaviate offers a full-featured open-source deployment. For infrastructure, Redis and Neo4j Community editions run anywhere.

How much does AI agent memory cost at scale?

At 100K memories per month, you're past Mem0's Starter cap (50K), so expect Mem0 Pro at $249/mo, which now covers up to 500K memories, plus infrastructure costs underneath it. Self-hosting with Letta, Cognee, Hindsight, or Graphiti reduces platform costs to zero but adds DevOps overhead. Redis and Pinecone's free tiers cover surprising amounts of traffic before you hit paid limits.

What is graph memory for AI agents?

Graph memory stores information as entities and relationships rather than flat vectors. Instead of "John works at Acme," a graph stores John (entity) -> WORKS_AT (relationship) -> Acme (entity). This lets agents answer questions like "Who else works at John's company?" through graph traversal. Neo4j, Cognee, and Mem0 Pro all support graph memory patterns, though only Cognee gives you the graph without a paid tier.

Is Zep open source?

Not the full product anymore. Graphiti, Zep's temporal knowledge graph engine, is still fully open-source and self-hostable on its own. But Zep retired its self-hosted Community Edition in 2025, so Zep Cloud, with managed infrastructure, user management, and hosted APIs, is now the only way to run the actual Zep product. The engine is free; the product is paid.

How do I reduce token costs with agent memory?

Two main approaches: semantic caching with Redis LangCache (similar queries return cached responses instead of calling the LLM), and smart context retrieval with any memory platform (send only relevant memories to the LLM instead of the full conversation history). Both reduce tokens per request, which directly cuts costs.

What are the best AI agent memory tools in 2026?

The top AI agent memory tools right now are Mem0, Zep, Cognee, Pinecone, and Letta. Mem0 leads for general-purpose use because it bundles extraction, deduplication, and retrieval in one API, with a free tier that covers real prototyping. Zep is the strongest pick when your agent needs to track how facts change over time. For pure vector storage, Pinecone is the most production-hardened option. If you want to understand how these tools fit into a broader agent build, our best AI agent frameworks guide covers the full stack.

Which agent memory tool should I use for a RAG pipeline?

For RAG pipelines, the right memory tool depends on what you're retrieving. Pinecone and Weaviate handle document chunk storage well, and Weaviate's built-in ML models remove the need for a separate embedding service. If your RAG pipeline also needs to track user-specific context across sessions, layer Mem0 on top: it handles user-scoped memory while your vector store handles document retrieval. See our best RAG tools comparison for the full picture on retrieval infrastructure.

Sources

• Mem0 Documentation
• Mem0 Pricing
• Mem0 GitHub Repository
• Zep Official Site
• Zep Pricing
• Graphiti GitHub Repository
• Letta Documentation
• Letta Pricing
• Letta GitHub Repository
• LangMem SDK Documentation
• Pinecone Documentation
• Pinecone Pricing
• Weaviate Documentation
• Weaviate Pricing
• Redis AI Agent Memory Management
• Redis Cloud Pricing
• Neo4j GraphRAG Documentation
• Neo4j Pricing
• Letta Benchmarking AI Agent Memory
• Cognee GitHub Repository
• Cognee Official Site
• Cognee Pricing
• Cognee AI Memory Benchmarks: Cognee vs Mem0, Graphiti, LightRAG
• Hindsight GitHub Repository