Which memory tool should your AI agent use? 5 options compared
This page is for agents that have to remember something after the chat ends: a preference, a fact that changed, or a file the agent keeps editing. Picking a framework is a different job, covered in the agent frameworks guide. Clicking through a website is covered in the browser automation guide. The tools below split into a hosted memory API, a stateful agent harness, a temporal context graph, and two libraries that add memory to a framework you already run. We checked every price, free tier, and license on the vendor's own pages on November 3, 2026.
Before you compare prices, decide what "remember" means for this agent:
Extract facts from a chat and search them later. You send messages in, and a model writes short memories you can filter by user or agent. Mem0 is built for that loop. LangMem's memory manager and LlamaIndex's FactExtractionMemoryBlock do the same job inside a framework.
Let the agent keep its own working memory. The agent reads and edits files that stay in the prompt, or calls a tool to save a note. Letta is a harness built around that. LangMem's hot-path tools are the smaller version: two tools on an agent you already run.
Track what was true, and when it stopped being true. A flat list of facts goes stale when someone changes jobs or a preference flips. Zep and Graphiti store entities and facts with a validity window, and they keep the old fact as history.
Remember only the recent turns. A token-limited chat buffer is enough for one sitting. LlamaIndex's Memory class does that by default, and adds longer-term blocks only if you pass them in. A framework's checkpointer does the same job for a single thread. That is not the same as a memory product.
Every extraction step spends model tokens. Estimate that bill with our AI API cost calculator before you turn background memory on for every message.
Do you need a memory tool, or just a vector DB / file?
A memory product is an extra model call, an extra store, and another place a wrong sentence can stick. Skip it when a simpler store already matches the job.
A vector database is enough when the text is already written and you only need to find similar chunks: a docs site, a ticket archive, a folder of notes you do not rewrite. You embed, you search, you stop. Nothing in that loop updates a fact when a newer message contradicts it. pgvector, Qdrant, or the vector store you already run will do this. Mem0's self-hosted server bundles Postgres with pgvector, and the library can also point at Qdrant. On that path you run the database.
SQLite, or any table, is enough when the fields are ones you set: user_id, a key, a value, updated_at. Preferences from a settings form, session state, and a job queue belong here. LlamaIndex's Memory class defaults to an in-memory SQLite database for chat messages, which is this pattern with a token cap.
Markdown or a file is enough when the memory is small enough to read, and a person or the agent can edit it. A project instruction file, a notes folder, and a git repo of preferences all qualify. Letta's MemFS is this idea turned into the agent's state: root Markdown files load into the system prompt, and the rest stays on disk until the agent opens it. A file falls over when you have thousands of users, each with facts that change, and no one is going to edit the files by hand.
Extraction earns the tool when you would otherwise paste the whole transcript back in, and you want a short list of facts that gets updated. Mem0, LangMem's create_memory_manager, and LlamaIndex's FactExtractionMemoryBlock all call a model to do that. You pay for those calls. The model can also store a sentence the user never meant as a durable fact, including instructions hidden in a page or a chat. Read the "Before you store" section before you trust the store.
A temporal graph earns the tool when relationships change and a vector hit would return both the old fact and the new one. Graphiti's README describes facts with a validity window: when the fact became true, and when it was superseded. Zep sells that as a managed Context Graph, with retrieval and storage unmetered and ingestion billed by episode size. Bring this in when you also need provenance back to the source message or record.
Agent-curated memory earns the tool when the same agent runs across sessions and should decide what stays in its prompt. Letta commits those edits to a git repository the agent owns. LangMem's create_manage_memory_tool lets a LangGraph agent write during the turn. A static block in LlamaIndex is the version you fill in yourself and pin so it is never truncated. Use these when the working set is small and the agent is the one who knows what changed.
The usual mix is all three, in that order: a file for rules a human edits, a vector index for documents, and a memory tool only for the user facts that change. Add the graph when "what was true in March" is a real question.
Tool by tool
Prices are in US dollars, from each vendor's own page on November 3, 2026. Where a page does not print a number, this guide says so.
Type · free tier: Memory layer (library, self-hosted server, hosted platform) · first 30 days: 10,000 adds and 1,000 retrievals a month, with Mem0 paying for the model calls
What it is: a memory layer that extracts memories from messages and lets you search them later. The docs describe two products on the same loop: Mem0 Platform (MemoryClient in Python, mem0ai on npm) and Mem0 Open Source (Memory / AsyncMemory, and mem0ai/oss). Both support add, search, get, get_all, update, delete, delete_all, and per-memory history, scoped by user_id, agent_id, and run_id.
When to pick it: you want memory as an API beside an agent you already run, and you want extraction and search handled for you. Pick Platform when you do not want to run a vector store. Pick the open-source library or the Docker server when the data has to stay on your infrastructure.
Open source: Apache-2.0, confirmed on the GitHub license API for mem0ai/mem0 on November 3, 2026. The repo's last push was October 30, 2026. The self-hosted setup page says the Docker bundle ships the REST API on port 8888 and a dashboard on port 3000, with auth on by default. The platform vs open source table on the same docs site says a web dashboard is not included for Open Source. Read the setup page for what the server bundle actually starts, and treat the comparison table as out of date on that row until Mem0 reconciles it.
Pricing: the pricing page is a FAQ, and it says Starter, Growth, and Pro are no longer sold to new accounts. Existing customers keep their price and limits. Plan changes go through Mem0's team. Canceling moves the account to the free plan, and the old plan cannot be restarted.
Free, first 30 days: Mem0 pays for the model calls. Limits are 10,000 adds and 1,000 retrievals a month. Accounts that signed up before October 26, 2026 have until November 25, 2026. Everyone else starts the 30 days on signup.
Free, after 30 days, with your own LLM key: 50,000 adds and 10,000 retrievals a month, at no charge from Mem0. You can connect a key during the first 30 days as well. Supported providers on the FAQ are OpenAI, Anthropic, Azure OpenAI, and OpenRouter. Organizations created through the Vercel Marketplace cannot use bring-your-own-key.
Free, after 30 days, with no key: memories stay. Searches keep working up to 1,000 a month. New adds return an error.
Over the free limits: the FAQ says you can turn on usage-based billing once a key is connected, set a monthly cap, and pay for adds and retrievals above the free limits. The rate is shown in the dashboard when you turn it on. It is not printed on the pricing page, so this guide does not quote one.
Your provider's bill is separate. The FAQ says recommended models cost about $3.55 to $5.34 per 1,000 adds: GPT-6 Luna on OpenAI, Claude Haiku 5.5 on Anthropic, and DeepSeek V4.1 Flash on OpenRouter. The BYOK page says embeddings, search, and reranking still run on Mem0, and that search latency on Mem0's side is about 270 ms at p50 and 640 ms at p95. Those provider figures are Mem0's measurements, not a Mem0 invoice line.
MCP: a hosted server at https://mcp.mem0.ai/mcp. The docs say it needs a Platform account. Clients can sign in through the browser, or send an API key as a bearer token. Documented tools include add_memory, search_memories, update_memory, and delete_memory. The older local repo mem0ai/mem0-mcp is archived. GitHub reports it archived, Apache-2.0, last push March 24, 2026. Its README points people at the hosted server.
Downsides: the open-source comparison page says Graph Memory, Memory Decay, Temporal Reasoning, and Dream are Platform-only. It also says the v3 pipeline removed OSS connectors for Neo4j, Memgraph, Kuzu, and Apache AGE. OSS still extracts entities for ranking, and it does not expose a queryable graph. Platform has app_id, webhooks, custom categories, and batch update and delete of up to 1,000 memories. OSS does not. You still pay a model provider for extraction on either path. The dashboard row disagrees between two Mem0 docs pages, as noted above.
Our take: The default when memory is a feature of your app and the agent framework is already chosen. Start on the free Platform tier, connect your own key before day 30, and move to the Apache-2.0 server when the vector store has to be yours. Do not budget a Mem0 overage rate until you see it in the dashboard.
Type · free tier: Stateful agent harness, formerly MemGPT · $0, limited to 3 stateful agents, 5 MiB of storage per memory repository
What it is: a runtime for agents that keep their own state, not a standalone memory API. The docs homepage calls the harness fully open source. Memory is MemFS: a git repository the agent owns. Cloud agents have that repo hosted by Letta. MemFS checks the repo out on whatever computer the agent is using. Edits become memory when they are committed and pushed. Files at the memory root load into the system prompt every turn. Directories with their own MEMORY.md stay out of context until the agent opens them. Older agents use a system/ directory instead. The current source is letta-ai/letta-code. Install is npm install -g @letta-ai/letta-code, then letta. The letta-code README says Letta Cloud is the default, and the first launch can stay on the local backend. The self-hosting docs start a local App Server with letta server --backend local --listen ws://127.0.0.1:4500. That backend stores state under ~/.letta/lc-local-backend. A plain letta server in the letta-code README connects a computer for agents whose state is already in Letta Cloud.
When to pick it: you want the agent, the tools, and the memory in one harness, and you want the agent to edit what it remembers. Use it for a coding agent, a personal assistant, or an agent embedded with the Agent SDK. Use Mem0, LangMem, or LlamaIndex when you only need a memory store and the loop already lives somewhere else.
Open source: Apache-2.0 on both letta-ai/letta-code and letta-ai/letta, confirmed on the GitHub license API on November 3, 2026. letta-code was pushed the same day. The letta README says active development lives in letta-code, and that the archive branch holds the retired V1 API server. The repo itself is not marked archived on GitHub. Self-hosting is the CLI with --backend local, or the App Server command above. The docs also link a Docker Compose deployment that keeps state on the machine you run.
Pricing: from the pricing page. Letta Auto is a model route (plus Auto Chat and Auto Fast). The page does not print the size of the included weekly or monthly Auto quota. Model rates for credits are on platform.letta.com/models, which is a separate page from the plan list.
Free: $0. The intro says free plans are limited to 3 stateful agents. The plan card says limited agents, 5 MiB of storage per memory repository, limited Letta Auto, and bring-your-own keys, including coding plans from ChatGPT/Codex, Kimi, and Z.AI.
Pro: $20/month. Up to 20 stateful agents, 50 MiB per memory repository, Letta Auto weekly and monthly quota, pay-as-you-go overage. The page says Pro can run agents in remote sandboxes.
API Plan: $20/month, for workloads that use API keys. Unlimited agents, $0.10 per active agent per month, tool execution at $0.00015 per second, and pay-as-you-go LLM usage. The page does not define "active." Server-side tools bill CPU time on this plan. Remote MCP tools do not, because the MCP provider runs them. Letta built-in tools are free except web search and fetch. Client-side tools, such as bash in the CLI, run on your machine and have no credit cost.
Teams Pro: $20 per seat per month. Adds teammates, shared agents, and access control, and includes the individual Pro features.
Letta's own usage note on the same page: chat users often stay inside Pro, casual coding (a few hours a day) is typically about $100 a month or more, and power users often approach or pass $200 a month. Those are Letta's estimates, not a rate card.
MCP: a hosted server at https://api.letta.com/mcp. You send a Letta API key as a bearer token. The docs say OAuth-only clients are not supported yet. Tools: list_agents, list_models, create_agent, send_agent_message, get_run, and get_reply. A call waits up to 110 seconds. The same page says messages run on a Cloud computer in unrestricted permission mode, so the agent executes tools without approval prompts. Separately, a Letta agent can call external MCP servers. That is the Agent SDK's MCP tools, not this hosted server.
Downsides: you are adopting an agent runtime. MemFS has no semantic or vector index by default. Keyword search is the MemFS Search mod (letta install npm:@letta-ai/memfs-search). Semantic and hybrid search in that mod need QMD installed over the memory directory. Conversation search on Letta Cloud can be full-text, vector, or hybrid. The MemFS page says local backends currently search transcripts with full-text matching only. Shared memory repositories are a cloud feature. The memory docs say self-hosted agents can share files by pointing at their own git remote. The self-hosting page says local agents are not available at chat.letta.com and are not backed up automatically. The hosted MCP's unrestricted mode is a bad default for any tool that can pay, send, or delete.
Our take: Pick Letta when the thing you want is a long-lived agent, and memory is how it stays itself between sessions. Pick Mem0 or LangMem when memory is a store your existing loop should call. Read the hosted MCP permission line before you connect it to a coding agent.
Type · free tier: Managed temporal Context Graph · 10,000 credits a month, no rollover
What it is: a managed context layer. Zep ingests business data, documents, and conversations, builds a Context Graph per user, account, or domain, and returns the context for a task. Facts are dated. The homepage says retrieval is under 200 ms. Graphiti is the open-source framework that builds those graphs. Graphiti's README says Graphiti is the graph construction framework inside Zep, and that Zep's own graph database service is Konig. The same README says neither product is "an agent memory product": Graphiti builds graphs, and Zep unifies and serves context. Teams still use both as agent memory. That wording is Zep's, and it is the right scope for this comparison.
When to pick it: many users or accounts, facts that change, and you want the old fact kept as history rather than overwritten. Pick Zep when you want that hosted, with seats for a Context MCP server. Pick Graphiti when you will run Neo4j, FalkorDB, or Amazon Neptune yourself and supply the model and embedder.
Open source: Graphiti is Apache-2.0, confirmed on the GitHub license API for getzep/graphiti on November 3, 2026. The repo was pushed the same day. Zep Cloud is the commercial service. Graphiti's README comparison says Zep deploys fully managed or in your cloud (BYOC), and Graphiti is self-hosted only. You bring the graph database on Graphiti. Zep does not ask you to run Neo4j.
Pricing: self-serve plans are credit based. An episode is one object you send: a chat message, a JSON payload, or a block of text. An episode up to 350 bytes is 1 credit. Each additional 350 bytes, or part of 350, is another credit. A webhook invocation is 1/8 credit where webhooks exist. Retrieval, storage, threads, users, and graph storage are 0 credits. The pricing page has an annual toggle labeled "Save 17%." It does not print a separate annual dollar figure, so the monthly prices below are the ones on the page.
Free: 10,000 credits a month. No rollover and no auto top-up. 2 projects, 1 Context MCP Server seat, 5 custom entity and edge types. Rate limits vary with load. Episode processing is lower priority. The FAQ says feature availability on this plan may change.
Flex: $125/month, 50,000 credits, then $25 per 10,000 credits. Auto top-up at 20% of the balance adds 10,000 credits for $25. Credits roll over 30 days. 600 requests per minute, 5 projects, 5 Context MCP seats, 10 custom entity and edge types, API logs kept 1 day. Memories, retrieval, and users are unlimited. The comparison table marks Observations, custom extraction instructions, webhooks, and analytics as not included.
Flex Plus: $375/month, 200,000 credits, then $75 per 40,000 credits. Auto top-up adds 40,000 credits for $75. Rollover is 60 days. 1,000 requests per minute, 10 projects, 15 MCP seats, 20 custom entity and edge types, API logs kept 7 days. Observations, custom extraction instructions, webhooks, and analytics are included.
Enterprise: custom credits and rates, unlimited projects, custom MCP seats, SOC 2 Type II, a HIPAA BAA, audit logs, API logs kept 1 year, and deployment on Zep Cloud, Zep Cloud with your encryption keys, or your VPC. The plan table marks SOC 2 and HIPAA as Enterprise. The homepage deployment cards also list both on Cloud and on Cloud with your own keys. If the contract matters, use the plan table and ask Zep which deployment the certification covers.
The FAQ says Free and Flex rate limits may be lowered depending on service usage. Enterprise limits are guaranteed. You are charged for ingesting episodes, not for storing them.
MCP: two different servers. Zep's Context MCP Server is https://api.getzep.com/mcp on managed cloud. BYOC uses the same /mcp path on your API host. Clients need Streamable HTTP and OAuth 2.1 with PKCE. The user signs in with Google Workspace or an enterprise identity provider. Seats match the plan: 1, 5, or 15 on Free, Flex, and Flex Plus. The Context MCP docs say custom OIDC requires Enterprise. Documented read tools include search_graph, get_user_summary, and list_episodes. Graphiti ships a separate experimental MCP server in mcp_server/. The default endpoint is http://localhost:8000/mcp/. Graphiti's security policy says that server has no authentication, no authorization, and no prompt-injection protection, and that any caller can read, change, or delete graph data. Do not expose it to an untrusted network.
Downsides: Flex is $125 before you have sent a paid episode, which is a large step up from Mem0's free tier or a library that has no vendor fee. Credits scale with episode size, so a long transcript costs more than a short message, and auto top-up will buy more credits when the balance drops under 20%. The free plan's rate limit is variable. Graphiti still needs a graph database, a model, and an embedder, and its README says retrieval performance depends on your setup. Zep's sub-200 ms figure is Zep's claim for Zep, not a number this guide re-measured.
Our take: The pick when the memory is really a changing graph of people, accounts, and facts, and you want it hosted and governed. Use Graphiti when that graph should live in your Neo4j or FalkorDB and you will operate it. For a single user's preferences inside one app, Mem0 or a file is the smaller system.
Type · free tier: Memory SDK (MIT) for LangGraph and any storage · the library is free; you pay the model
What it is: a Python library that extracts memories from conversations, lets an agent record and search them during a turn, and can rewrite a prompt from feedback. Install is pip install -U langmem. The core API is storage-agnostic. The stateful layer uses LangGraph's BaseStore. The intro's agent example uses create_manage_memory_tool and create_search_memory_tool with create_react_agent. The conceptual guide also documents create_memory_manager, for semantic collections, profiles, and episodes, and create_prompt_optimizer, which updates a system prompt from trajectories. Hot path means the agent writes during the conversation. Background means a manager extracts after the turn.
When to pick it: the agent is already a LangGraph app, or you want the extraction functions without adopting Mem0 or Zep. Use the hot-path tools when the agent should choose what to save. Use the background manager when you do not want that tool call on the user's latency. Skip it if you are not in Python and you do not want to store the results yourself.
Open source: MIT, confirmed on the GitHub license API for langchain-ai/langmem on November 3, 2026. The repo was pushed the same day. There is no separate LangMem hosted product in the docs.
Pricing: no LangMem fee. The quickstart expects an LLM API key, and the examples pass a model id such as anthropic:claude-3-5-sonnet-latest. InMemoryStore keeps memories in the process and loses them on restart. The docs say to use AsyncPostgresStore or another database-backed store in production. The intro says LangGraph's long-term memory store is available by default in all LangGraph Platform deployments. That platform is a separate product, and this guide did not find a LangMem line item on a pricing page. LangSmith's MCP server is also a different product: it exposes traces, prompts, datasets, and billing, not LangMem's memory tools.
MCP: LangMem does not publish an MCP server. The memory tools are LangChain tools on your agent. If a coding agent should call memory over MCP, use Mem0's, Letta's, or Zep's hosted server instead, and see our MCP setup guide.
Downsides: you own the database, the namespaces, and the decision of what a "memory" is. The conceptual guide says over-extraction hurts search precision and under-extraction hurts recall. Hot-path tools add latency on the turn that writes. Background extraction means the memory is missing until the job runs. Prompt optimization can rewrite the agent's instructions from a single low score, so keep a copy of the prompt you started with. The default store in the quickstart will not survive a restart.
Our take: The library to add when the agent is already LangGraph and you want either the agent or a background job to maintain memory. It is the wrong first purchase if you wanted a dashboard and a free hosted tier. That is Mem0.
Type · free tier: Memory classes inside the LlamaIndex framework (MIT) · the library is free; you pay the model and any database
What it is: composable memory for LlamaIndex agents, in llama_index.core.memory. The current class is Memory. You pass it to agent.run(..., memory=memory) or call put_messages and get yourself. Short-term memory is a token-limited queue of chat messages. Long-term memory is optional MemoryBlock objects that receive messages flushed out of that queue. The docs name three blocks: StaticMemoryBlock (text you set, always inserted), FactExtractionMemoryBlock (an LLM extracts facts, and condenses them when max_facts is exceeded; the example uses 50), and VectorMemoryBlock (batches of flushed messages in a vector store you pass in). Each block has a priority. Priority 0 is kept. Higher numbers are truncated first when the combined memory exceeds token_limit.
When to pick it: the agent is already a LlamaIndex FunctionAgent, AgentWorkflow, or ReActAgent, and you want the chat buffer and the long-term blocks in one object. Use a static block for facts that must stay in the prompt. Use fact extraction when a model should maintain the list. Use the vector block when you want old turns searchable. Use Mem0 or Zep when memory should be a service other agents call.
Open source: MIT, confirmed on the GitHub license API for run-llama/llama_index on November 3, 2026. The memory classes ship in that framework. The repo was pushed the same day.
Pricing: no LlamaIndex fee for these classes. Defaults on the memory page: token_limit 30000, chat_history_token_ratio 0.7, token_flush_size 3000. Tokens are counted with tiktoken unless you pass tokenizer_fn. The default database is an in-memory SQLite store. A remote database is an async_database_uri such as Postgres via postgresql+asyncpg, or your own AsyncDBChatStore. Fact extraction calls whatever LLM you pass into the block. We did not find a LlamaIndex-operated memory API with a price. LlamaParse (formerly LlamaCloud) is the hosted document product: parse, extract, classify, split, and index. It is not this memory module. The docs also show an integration, llama-index-memory-bedrock-agentcore, which talks to AWS Bedrock AgentCore Memory. That bill is AWS's, and the page lists AWS permissions rather than a LlamaIndex plan.
MCP: the memory classes are not an MCP server. LlamaIndex hosts a documentation MCP server at https://developers.llamaindex.ai/mcp so an agent can read the docs. That server does not store your agent's memory. LlamaParse has its own platform MCP for documents. Neither one is a substitute for Memory.
Downsides: the memory page says ChatMemoryBuffer is deprecated and still the default across the framework, with Memory planned as the future default. Code that never passes a memory object is still on the buffer. The same page lists older types, ChatSummaryMemoryBuffer, VectorMemory, and SimpleComposableMemory, as deprecated. The docs also say that once you customize Memory, serializing a workflow Context is not enough, because the customized Memory object is not serializable. You pass it in again on the next run. Fact extraction is only as good as the model you attach, and the vector block does nothing until you supply a vector store and an embedder.
Our take: The right memory if the agent is already LlamaIndex and you want to compose a static profile, extracted facts, and a vector recall block. It is a library, so there is no hosted memory tier to graduate to. Add Mem0 or Zep when a second app has to read the same memories.
Add memory to an app this week, without running a database: Mem0 Platform. Use the free limits, then connect your own model key.
The same extraction loop on your own machines: Mem0's Apache-2.0 library or the Docker server. You pay the model and the vector store.
An agent that should keep editing its own memory: Letta. Run letta server --backend local, or use Letta Cloud when you want the hosted memory repo.
Facts that change, for many users, with a record of what used to be true: Zep. Start on the 10,000-credit free tier and read the episode-size rule before you send whole transcripts.
That graph, in your own Neo4j, FalkorDB, or Neptune: Graphiti. Leave its MCP server off the public internet.
You already use LangGraph: LangMem. Persist with a database-backed store, not the in-memory quickstart, once the process has to restart.
You already use LlamaIndex agents:Memory plus the blocks you actually need. A static block is enough for a profile that rarely changes.
You only need search over documents you already have: a vector database or a file. The vector DB / file section is the decision, and the web scraping guide is the one for getting those documents in the first place.
Before you store
Treat stored memory as untrusted. A page or a chat can contain a sentence that extraction will save, and the agent will read it back later as fact. Keep a way to list and delete memories. Mem0's hosted MCP includes delete tools. Graphiti's reference MCP can clear a graph and has no auth.
Do not connect a write-capable memory server to a client that auto-approves tools until you have read that server's permission model. Letta's hosted MCP docs say Cloud messages run in unrestricted permission mode, with no approval prompts.
Cap the spend before background jobs loop. Mem0's overage rate is set in the dashboard, not on the public pricing page. Zep Flex tops up credits automatically at 20% of the balance. Letta API Plan bills tool CPU time at $0.00015 per second, and model usage is pay as you go. LangMem and LlamaIndex fact extraction call your model on every flush.
Keep provider keys in a dashboard or an environment variable, not in a shared MCP config. Mem0, Letta, and the open-source stacks all send the text you store to whatever model is configured.
Decide who can read a user's memory. Zep's Context MCP is per signed-in user and uses seats. Mem0 scopes by user_id and, on Platform, app_id. A shared vector collection with no filter is a different design. Add an MCP server with the steps in our setup guide.
FAQ
What's the best memory tool for AI agents?
It depends on the job. For a hosted memory API with a free tier, start with Mem0. For an agent that keeps and edits its own memory, use Letta. For governed context that changes over time, use Zep, or Graphiti if you will run the graph yourself. If you already build on LangGraph, add LangMem. If you already build on LlamaIndex, use its Memory blocks.
Do I need a memory tool, or is a vector database enough?
A vector database, SQLite, or a Markdown file is enough when you only need to store and search text you already wrote. A memory tool earns its place when something has to extract facts, update them as they change, or let the agent edit its own memory. That choice is covered at https://hotfixdaily.com/guides/memory-for-ai-agents/#need.
Mem0 Platform or the open-source library?
Both run the same add and search loop. Platform is the hosted API. The open-source library and the Docker server run on your infrastructure, and you pay for the model and the vector store. Mem0's comparison page lists Graph Memory, Memory Decay, Temporal Reasoning, and Dream as Platform-only. The self-hosted setup page describes a dashboard. The comparison table says Open Source does not include one.
Zep or Graphiti?
Graphiti is the Apache-2.0 framework that builds temporal context graphs. You bring the graph database, the model, and the embedder. Zep is the managed context layer: 10,000 credits a month free, then plans from $125 a month. Graphiti's README says Graphiti is the graph construction framework inside Zep.
Which of these have an MCP server?
Mem0 hosts one at https://mcp.mem0.ai/mcp. Letta hosts one at https://api.letta.com/mcp and authenticates with a bearer API key. Zep hosts a Context MCP server at https://api.getzep.com/mcp, with seats that depend on the plan. Graphiti ships an experimental MCP server with no authentication. LangMem and LlamaIndex Memory do not publish a memory MCP server.
Can I self-host these?
Mem0's library and Docker server are Apache-2.0. Letta's current harness is Apache-2.0 in letta-ai/letta-code. The self-hosting docs say to run letta server --backend local, and agent state stays on that machine. Graphiti, LangMem, and LlamaIndex Memory are libraries you run. Zep's pricing page lists a VPC deployment on Enterprise. Mem0 Platform, Letta Cloud, and Zep Cloud are the hosted products.
What does Mem0 cost after the first 30 days?
Mem0's pricing FAQ says the first 30 days include 10,000 adds and 1,000 retrievals a month, with Mem0 paying for the model calls. After that, connecting your own LLM key raises the limits to 50,000 adds and 10,000 retrievals a month at no charge from Mem0. Without a key, searches keep working up to 1,000 a month and new adds return an error. The price for usage above the free limits is shown in the dashboard when you turn billing on. It is not printed on the pricing page.
How we write these: every price, free tier and feature comes from the vendor's own pricing page, docs or GitHub repo (linked as Source) and was checked on the date above. Licenses come from each project's GitHub repo. "Our take" lines are our opinion. Prices change often, so check the link before you pay. Something out of date? Email hello@hotfixdaily.com. No tool paid to be listed. This guide has no affiliate links.
Get the next issue in your inbox
Five things worth your attention in AI, agents, vibe coding and game dev, every weekday. Plus 13 free Starter Prompts and the AI Builder Starter Stack PDF when you join.
