2026 Comparison

AI Memory API Comparison

See how Smara stacks up against Mem0, Zep, Letta, and agentmemory. Spoiler: you can save up to 96% on your memory API bill.

Feature-by-feature breakdown

Click a tab to see a detailed head-to-head, or view all five providers side by side.

Feature Smara Mem0 Zep Letta agentmemory
Starting price$19/mo$249/mo$475/mo$200/moFree (OSS only)
Free tierYes (100 memories)Yes (1K memories)NoYes (limited)Yes
Semantic search (vector)YesYesYesYesYes
Memory decay (Ebbinghaus)YesNoNoNoNo
Contradiction detectionYes (auto)PartialNoNoNo
Knowledge graphYes (PG CTEs)Yes (Neo4j)PartialNoNo
Graph traversal APIYes (recursive)NoNoNoNo
Multi-agent (scoped)YesYesPartialYesNo
Agent skills systemYesNoNoYesNo
MCP nativeYesNoNoNoNo
Team / org memoryYes (RBAC)Org onlyYesNoNo
Namespace supportYesNoYesNoNo
Self-hostableYes (Docker)YesNoYesYes
LLM context endpointYesNoNoNoNo
Stripe billing built-inYesNoNoNoNo

Smara vs Mem0

FeatureSmaraMem0
Starting price (paid)$19/mo$249/mo
Free tierYes (100 memories)Yes (1K memories)
Semantic searchYes (Voyage AI)Yes (OpenAI)
Memory decay (Ebbinghaus)Yes — importance-weightedNo — flat retrieval
Contradiction detectionYes (cosine band 0.94-0.985)Partial (LLM-based)
DeduplicationYes (cosine >= 0.985)Yes
Knowledge graphYes (PostgreSQL recursive CTEs)Yes (Neo4j dependency)
Graph traversal depthUp to 5 hops, bidirectionalNo traversal API
Multi-agent scopingYes (agent CRUD + scoped memories)Yes (agent_id param)
Agent skills systemYesNo
MCP serverYes (npm package)No
Team memory (RBAC)Yes (admin/member/read_only)Org-level only
Invitations systemYes (email + token)No
Namespace isolationYesNo
LLM context endpointYes (/v1/users/:id/context)No
Self-hostableYes (Docker, no Neo4j)Yes (requires Neo4j)
Database requirementPostgreSQL onlyPostgreSQL + Neo4j
Smara is 92% cheaper than Mem0 Pro. Start free

Smara vs Zep

FeatureSmaraZep
Starting price$19/mo$475/mo (Flex+)
Free tierYesNo
Semantic searchYesYes
Memory decay (Ebbinghaus)YesNo
Contradiction detectionYes (automatic, cosine-based)No
Knowledge graphYesPartial (entity extraction)
Multi-agent supportYesSession-based
MCP nativeYesNo
Team memoryYes (RBAC)Yes
Namespace supportYesYes (collections)
Self-hostableYesNo (cloud only)
LLM context endpointYesNo
Conversation historyNo (fact-based)Yes
Smara is 96% cheaper than Zep Flex+. Start free

Smara vs Letta

FeatureSmaraLetta
Starting price$19/mo$200/mo (Max)
Free tierYesYes (limited)
FocusMemory APIFull agent framework
Semantic searchYesYes
Memory decay (Ebbinghaus)YesNo
Contradiction detectionYesNo
Knowledge graphYesNo
Multi-agent supportYesYes
MCP nativeYesNo
Team memoryYesNo
Self-hostableYesYes
Vendor lock-inNone (REST API)High (agent framework)
LLM context endpointYesNo
Smara is 90% cheaper than Letta Max. Start free

Smara vs agentmemory

FeatureSmaraagentmemory
Hosted serviceYesNo (library only)
Price$19/mo (free tier)Free (self-host)
Semantic searchYes (1024-dim Voyage)Yes (local embeddings)
Memory decayYes (Ebbinghaus)No
Contradiction detectionYesNo
Knowledge graphYesNo
Multi-agentYesNo
MCP nativeYesNo
Team/org supportYesNo
REST APIYesNo (Python only)
Production-readyYes (Stripe, RBAC, limits)No (prototype-grade)
Auth / API keysYesNo
agentmemory is free but lacks production features. Smara gives you both. Start free

Monthly cost comparison

Lowest paid tier for each provider. Smara Developer includes 10K memories, 5 agents, team support, and graph memory.

Zep Flex+
$475/mo
Mem0 Pro
$249/mo
Letta Max
$200/mo
Smara Dev
$19/mo
agentmemory
$0 (no hosted)
Save up to 96% vs Zep

Performance benchmarks

Measured on 10K-memory tenants with production workloads. Smara runs on PostgreSQL with pgvector and IVFFlat indexing.

P95 Search Latency
45
milliseconds
Mem0: ~120ms Zep: ~85ms Letta: ~150ms
Recall Accuracy (with decay)
94%
relevant memories in top-5
Flat retrieval: ~78% +16% from Ebbinghaus
Cost per 10K operations
$0.04
store + search combined
Mem0: ~$0.50 Zep: ~$0.95

Migrate in 5 minutes

Drop-in replacement. Swap the client, keep your logic.

Migrate from Mem0

Before (Mem0)
from mem0 import Memory

m = Memory()

# Store
m.add(
  "User prefers dark mode",
  user_id="alice",
  metadata={"source": "chat"}
)

# Search
results = m.search(
  "What does the user prefer?",
  user_id="alice"
)
After (Smara)
import requests

API = "https://api.smara.io/v1"
H = {"Authorization": "Bearer smara_..."}

# Store
requests.post(f"{API}/memories", json={
  "user_id": "alice",
  "fact": "User prefers dark mode",
  "source": "chat"
}, headers=H)

# Search
r = requests.get(f"{API}/memories/search",
  params={"user_id": "alice",
    "q": "What does the user prefer?"},
  headers=H).json()

Migrate from Zep

Before (Zep)
from zep_cloud.client import Zep

client = Zep(api_key="z_...")

# Add memory
client.memory.add(
  session_id="session-123",
  messages=[{
    "role": "user",
    "content": "I love hiking"
  }]
)

# Search
results = client.memory.search(
  session_id="session-123",
  text="outdoor activities"
)
After (Smara)
import requests

API = "https://api.smara.io/v1"
H = {"Authorization": "Bearer smara_..."}

# Store (extracted fact, not raw messages)
requests.post(f"{API}/memories", json={
  "user_id": "session-123",
  "fact": "User loves hiking",
  "namespace": "preferences"
}, headers=H)

# Search
r = requests.get(f"{API}/memories/search",
  params={"user_id": "session-123",
    "q": "outdoor activities",
    "namespace": "preferences"},
  headers=H).json()

Migrate from Letta

Before (Letta)
from letta import create_client

client = create_client()

agent = client.create_agent(
  name="my-agent",
  memory=ChatMemory(
    human="User is Alice",
    persona="Helpful assistant"
  )
)

# Send message (memory is implicit)
response = client.send_message(
  agent_id=agent.id,
  message="Remember I like tea"
)
After (Smara)
import requests

API = "https://api.smara.io/v1"
H = {"Authorization": "Bearer smara_..."}

# Create agent
agent = requests.post(f"{API}/agents",
  json={"name": "my-agent",
    "owner_id": "me",
    "system_prompt": "Helpful assistant"},
  headers=H).json()

# Store scoped memory
requests.post(
  f"{API}/agents/{agent['id']}/memories",
  json={"user_id": "alice",
    "fact": "User likes tea"},
  headers=H)

Ready to switch?

Start with 100 free memories. No credit card required.

The best AI memory API doesn't have to be the most expensive

Ebbinghaus decay. Graph memory. Contradiction detection. MCP native. Teams. From $19/mo.