What is the best memory API for AI agents?

It depends on your app. For one memory shared by your code and your AI tools, Membase. For multi-tenant personalization, Mem0. For facts that change over time, Zep. For teams on AWS or Google Cloud, their built-in memory services.

What is a memory layer API?

A hosted service that stores what your agent learns and returns what's relevant later, through calls like add and search. It handles extraction, indexing, updates and user separation, so you don't build them on a vector database yourself.

Is there a free memory API?

Yes. Membase is free during its beta. Mem0 (Hobby), Zep (10K credits) and Cognee (1M tokens) have free tiers, and Supermemory has a free plan.

How do memory APIs charge?

By requests (Mem0), credits (Zep), tokens processed (Cognee, Honcho, Supermemory), or usage components such as events and stored records (AWS). Model your expected writes and reads before choosing.

Mem0 vs Membase: which should I use?

Use Mem0 when many end users share one key and you pass a user_id on each call. Use Membase when your agents and AI tools such as Claude Code and Cursor should share one memory, with per-key access and sources on every result. See the full Membase vs Mem0 comparison.

Do I need a vector database if I use a memory API?

No. The memory API stores and indexes for you. A vector database on its own leaves extraction, updates and user separation to your code.

Can I use a memory API with Claude Code or Cursor?

Yes, if it has an MCP server. Membase, Mem0, Supermemory and Zep offer one. With Membase, the MCP server reads the same memory your code writes.

Best Memory APIs for AI Agents in 2026: 9 Hosted Memory Layers Compared

Disclosure: Membase is our product. We list it first because it’s the API we know best, and we say plainly where another API is the better fit. Pricing, free tiers and SDKs were checked on vendor pages and docs in October 2026. See “How we compared” at the end.

Quick links: Get a free Membase API key · Python SDK · SDK reference · Docs · GitHub

TL;DR: A memory API is a hosted memory layer you call over HTTP: send it conversations or documents, and search them later. You don’t run a vector database, an extraction pipeline or a graph yourself. The right one depends less on benchmarks than on four API questions: how it bills, how it separates your users, what the free tier covers, and whether your AI tools can reach the same memory.

Membase: one memory your code and your AI tools (Claude Code, Cursor, ChatGPT) both use, over SDK, REST or MCP. Free in beta.
Mem0 Platform: the most widely used memory API, with a user_id model for multi-tenant apps.
Zep Cloud: temporal knowledge graph, with enterprise compliance.
Supermemory: memory plus data connectors, priced by tokens and queries.
Cognee Cloud: graph memory from documents, pay per token.
Honcho: reasoning about users, pay per token ingested.
Hindsight Cloud: hosted version of an open-source engine.
AWS Bedrock AgentCore Memory: memory inside the AWS agent stack.
Google Vertex AI Memory Bank: memory inside Google’s Agent Engine.

Comparison table of nine memory APIs by memory model, free tier, paid entry price, billing unit, user isolation and SDKs

What is a memory API?

A memory API is a hosted service with two core calls: add (store a message, fact or document) and search (get back what’s relevant to a query). Behind those calls, the service extracts facts, indexes them, resolves duplicates and keeps users apart.

Using one means you don’t have to build that yourself on top of a vector database. The trade-off is a vendor dependency and a bill that grows with usage, which is why the pricing model matters as much as recall quality.

Looking for open-source frameworks you host yourself, such as LangMem, Letta or Graphiti? See our broader comparison: Best AI Agent Memory Tools in 2026.

Memory APIs at a glance

API	Memory model	Free tier	Paid from	Billed by	User isolation	SDKs
Membase (beta)	Episodes and topic trees, with sources	Free in beta	Paid plans coming soon	—	Per account; scoped keys per memory	Python, TypeScript, REST, MCP
Mem0 Platform	Extracted facts; graph on Pro	10K adds, 1K retrievals/month	$19/month	Add and retrieval requests	user_id, agent_id, run_id	Python, TypeScript, REST, MCP
Zep Cloud	Temporal knowledge graph	10K credits/month	$125/month	Credits	Users and threads	Python, TypeScript, Go
Supermemory	Memories plus connected sources	Yes	$19/month	Tokens and queries	Container tags, scoped keys	TypeScript, Python, MCP
Cognee Cloud	Knowledge graph plus vectors	1M tokens	$1 per 1M tokens	Tokens processed	Datasets	Python
Honcho	Reasoning over users and agents (“peers”)	Startup credits	$2 per 1M tokens ingested	Tokens ingested, reasoning per query	Peers and sessions	Python, TypeScript
Hindsight Cloud	Four retrieval strategies, reranked	Self-host free	Usage-based	Usage	Banks	Python, REST
AWS AgentCore Memory	Short-term events plus long-term strategies	AWS terms	Usage-based	Events, stored records, retrievals	Actor and session namespaces	AWS SDKs
Vertex AI Memory Bank	Memories generated from sessions	Google Cloud terms	Usage-based	Usage	Scope per user	Vertex AI SDK, ADK

How to evaluate a memory API

Benchmarks get the attention, but these five questions decide whether an API works in production:

What are you billed for? Requests, credits, tokens processed, or stored records. A token-billed API gets expensive with long documents; a request-billed one gets expensive with chatty agents.
What does the free tier really cover? Check retrievals, not just writes. Mem0’s free tier allows 10K adds but only 1K retrievals a month.
How are users kept apart? Some APIs take a user_id on every call; others give each user their own account or key. The first suits a multi-tenant app; the second suits users who own their memory.
Can your AI tools reach the same memory? If your team also uses Claude Code or Cursor, an MCP server on the same memory saves building a second store.
Where does data live, and is it certified? SOC 2, HIPAA and regional hosting matter for enterprise buyers.

1. Membase: one memory for your code and your AI tools

Membase, built by Unibase, is a hosted memory API with Python and TypeScript SDKs, a REST API and an MCP server, all on the same memory.

from membase import Membase

client = Membase()  # reads MEMBASE_API_KEY
client.add("Acme requires SSO via Okta before the pilot.", container="mv-...", custom_id="acme-001")
hits = client.search("what does Acme need before the pilot", limit=3)

Best for: teams whose agents and AI tools should share one memory.
Strengths:
- The memory your code writes is the memory Claude Code, Cursor, Codex and ChatGPT read over MCP.
- Each API key is scoped to specific memories (containers) and an access level, and can be revoked.
- Every search result comes back with its source file.
- custom_id makes writes idempotent, so retries never duplicate.
- Core engine: 93.1% on LoCoMo and 92.6% on LongMemEval_S, using up to 11× fewer tokens than the full history (our own numbers; method).
Watch out for: it’s in beta; isolation is per account rather than per user_id, so a multi-tenant app with thousands of anonymous users fits Mem0's model better today; no entity graph.
Pricing: Free in beta · Paid plans coming soon.

2. Mem0 Platform: the default for multi-tenant apps

Mem0 is the most widely used memory API. You pass a user_id (and optionally agent_id or run_id) on each call, and it extracts and stores facts.

Best for: apps that personalize for many end users behind one key.
Strengths: fast setup; clear multi-tenant model; large ecosystem; hosted MCP server.
Watch out for: retrieval quotas are tight (1K/month free, 5K on Starter); graph memory needs the $249 Pro plan; since v3, contradicting facts are stored side by side rather than updated.
Pricing: Hobby free · Starter $19/month · Pro $249/month · Enterprise.

3. Zep Cloud: temporal graph with enterprise compliance

Zep stores memory as a temporal knowledge graph: each fact has a time it was valid, so the agent can tell current facts from old ones.

Best for: agents where facts change and history matters, in regulated settings.
Strengths: temporal reasoning; ingests business data alongside chat; SOC 2 Type II and HIPAA.
Watch out for: credit-based pricing takes some modelling; the paid entry point is higher than most.
Pricing: Free (10K credits) · Flex $125/month · Flex Plus $375/month · Enterprise.

4. Supermemory: memory with data connectors

Supermemory is a memory API with connectors to sources such as Google Drive and Notion, plus an MCP server.

Best for: apps that need memory from outside the conversation, with little operational work.
Strengths: connectors; container tags and scoped keys for separation; MCP.
Watch out for: tokens and queries are metered separately; self-hosting is on the Scale plan.
Pricing: Free · $19 · $100 · $399/month.

5. Cognee Cloud: graph memory from documents

Cognee builds a knowledge graph plus vectors from documents and conversations.

Best for: document-heavy memory with multi-hop questions.
Strengths: open-source core you can also self-host; simple per-token pricing.
Watch out for: Python-first; more pipeline thinking than a drop-in API.
Pricing: Free (1M tokens) · $1 per 1M tokens · Enterprise (bring your own cloud).

6. Honcho: memory that reasons about users

Honcho, from Plastic Labs, models users and agents as “peers” and runs background reasoning to infer preferences they never state.

Best for: companion, coaching and education apps that need a model of the user.
Strengths: retrieval is unlimited; reasoning depth is a per-query choice.
Watch out for: reasoning is billed per query ($0.001 to $0.50); AGPL-3.0 if you self-host.
Pricing: $2 per 1M tokens ingested · startup credits available.

7. Hindsight Cloud: hosted open-source engine

Hindsight, from Vectorize, runs four retrieval strategies in parallel and reranks the results. The cloud service hosts the same MIT-licensed engine.

Best for: teams that want a hosted API with the option to self-host the same engine later.
Strengths: no feature paywall between self-hosted and cloud.
Watch out for: smaller ecosystem; benchmark claims come from its maker.
Pricing: free self-hosted · usage-based cloud.

8. AWS Bedrock AgentCore Memory: memory inside AWS

AgentCore Memory is part of Amazon Bedrock AgentCore. It keeps short-term events and turns them into long-term memory using built-in strategies such as semantic facts, summaries and user preferences, organized in namespaces per actor and session.

Best for: teams already building agents on AWS.
Strengths: IAM, VPC and AWS compliance come with it; works with any agent framework.
Watch out for: tied to AWS; several billable components, so model the cost before scaling.
Pricing: usage-based, billed per event, stored record and retrieval. See the AgentCore pricing page.

9. Google Vertex AI Memory Bank: memory inside Google Cloud

Memory Bank is part of Vertex AI Agent Engine. It generates memories from conversation sessions and scopes them per user, and works natively with Google’s Agent Development Kit (ADK).

Best for: teams already on Google Cloud and ADK.
Strengths: managed with Google Cloud security and regions; memories generated automatically from sessions.
Watch out for: tied to Google Cloud; best experience is with ADK.
Pricing: usage-based under Vertex AI Agent Engine pricing.

What’s not on this list

Letta Cloud is an API for running stateful agents, not a memory API you call from another agent.
LangMem and Graphiti are libraries you host yourself. They’re covered in Best AI Agent Memory Tools in 2026.
Vector databases (Pinecone, Qdrant) store embeddings but leave extraction, updates and user separation to you.

How to choose

One memory for your code and Claude Code, Cursor, ChatGPT → Membase
Per-agent keys you can scope and revoke → Membase
Results that cite their source → Membase
Free while you build → Membase (beta), Mem0 Hobby, Zep Free, Cognee Free
Personalization for many end users behind one key → Mem0
Facts that change over time, with history → Zep
SOC 2 / HIPAA from day one → Zep, or your cloud provider’s memory
Memory from Drive, Notion and other sources → Supermemory
Document-heavy memory, pay per token → Cognee
A model of the user’s unstated preferences → Honcho
Hosted now, self-hosted later on the same engine → Hindsight
You’re all-in on AWS → AgentCore Memory
You’re all-in on Google Cloud and ADK → Vertex AI Memory Bank

Start building with Membase

Get an API key: Membase web app → Connect › Developer keys
Python SDK: unibaseio-membase on PyPI · pip install unibaseio-membase
TypeScript SDK: @unibaseio/membase on npm · npm install @unibaseio/membase
MCP server: setup guide
Videos: Add memory with the Membase SDK · Give Claude Code permanent memory (MCP)
Guide: How to Add Long-Term Memory to an AI Agent
Docs: docs.membase.com · Help: Discord

How we compared

We read each vendor’s pricing page and docs in October 2026. Prices are list prices at that time; usage-based cloud services (AWS, Google) are described by their billing units rather than a single figure. We did not benchmark the APIs against each other. Membase is our product, and its numbers come from our own research page. Spot an error? Email support@membase.com and we’ll fix it.