See how Smara stacks up against Mem0, Zep, Letta, and agentmemory. Spoiler: you can save up to 96% on your memory API bill.
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/mo | Free (OSS only) |
| Free tier | Yes (100 memories) | Yes (1K memories) | No | Yes (limited) | Yes |
| Semantic search (vector) | Yes | Yes | Yes | Yes | Yes |
| Memory decay (Ebbinghaus) | Yes | No | No | No | No |
| Contradiction detection | Yes (auto) | Partial | No | No | No |
| Knowledge graph | Yes (PG CTEs) | Yes (Neo4j) | Partial | No | No |
| Graph traversal API | Yes (recursive) | No | No | No | No |
| Multi-agent (scoped) | Yes | Yes | Partial | Yes | No |
| Agent skills system | Yes | No | No | Yes | No |
| MCP native | Yes | No | No | No | No |
| Team / org memory | Yes (RBAC) | Org only | Yes | No | No |
| Namespace support | Yes | No | Yes | No | No |
| Self-hostable | Yes (Docker) | Yes | No | Yes | Yes |
| LLM context endpoint | Yes | No | No | No | No |
| Stripe billing built-in | Yes | No | No | No | No |
| Feature | Smara | Mem0 |
|---|---|---|
| Starting price (paid) | $19/mo | $249/mo |
| Free tier | Yes (100 memories) | Yes (1K memories) |
| Semantic search | Yes (Voyage AI) | Yes (OpenAI) |
| Memory decay (Ebbinghaus) | Yes — importance-weighted | No — flat retrieval |
| Contradiction detection | Yes (cosine band 0.94-0.985) | Partial (LLM-based) |
| Deduplication | Yes (cosine >= 0.985) | Yes |
| Knowledge graph | Yes (PostgreSQL recursive CTEs) | Yes (Neo4j dependency) |
| Graph traversal depth | Up to 5 hops, bidirectional | No traversal API |
| Multi-agent scoping | Yes (agent CRUD + scoped memories) | Yes (agent_id param) |
| Agent skills system | Yes | No |
| MCP server | Yes (npm package) | No |
| Team memory (RBAC) | Yes (admin/member/read_only) | Org-level only |
| Invitations system | Yes (email + token) | No |
| Namespace isolation | Yes | No |
| LLM context endpoint | Yes (/v1/users/:id/context) | No |
| Self-hostable | Yes (Docker, no Neo4j) | Yes (requires Neo4j) |
| Database requirement | PostgreSQL only | PostgreSQL + Neo4j |
| Feature | Smara | Zep |
|---|---|---|
| Starting price | $19/mo | $475/mo (Flex+) |
| Free tier | Yes | No |
| Semantic search | Yes | Yes |
| Memory decay (Ebbinghaus) | Yes | No |
| Contradiction detection | Yes (automatic, cosine-based) | No |
| Knowledge graph | Yes | Partial (entity extraction) |
| Multi-agent support | Yes | Session-based |
| MCP native | Yes | No |
| Team memory | Yes (RBAC) | Yes |
| Namespace support | Yes | Yes (collections) |
| Self-hostable | Yes | No (cloud only) |
| LLM context endpoint | Yes | No |
| Conversation history | No (fact-based) | Yes |
| Feature | Smara | Letta |
|---|---|---|
| Starting price | $19/mo | $200/mo (Max) |
| Free tier | Yes | Yes (limited) |
| Focus | Memory API | Full agent framework |
| Semantic search | Yes | Yes |
| Memory decay (Ebbinghaus) | Yes | No |
| Contradiction detection | Yes | No |
| Knowledge graph | Yes | No |
| Multi-agent support | Yes | Yes |
| MCP native | Yes | No |
| Team memory | Yes | No |
| Self-hostable | Yes | Yes |
| Vendor lock-in | None (REST API) | High (agent framework) |
| LLM context endpoint | Yes | No |
| Feature | Smara | agentmemory |
|---|---|---|
| Hosted service | Yes | No (library only) |
| Price | $19/mo (free tier) | Free (self-host) |
| Semantic search | Yes (1024-dim Voyage) | Yes (local embeddings) |
| Memory decay | Yes (Ebbinghaus) | No |
| Contradiction detection | Yes | No |
| Knowledge graph | Yes | No |
| Multi-agent | Yes | No |
| MCP native | Yes | No |
| Team/org support | Yes | No |
| REST API | Yes | No (Python only) |
| Production-ready | Yes (Stripe, RBAC, limits) | No (prototype-grade) |
| Auth / API keys | Yes | No |
Lowest paid tier for each provider. Smara Developer includes 10K memories, 5 agents, team support, and graph memory.
Measured on 10K-memory tenants with production workloads. Smara runs on PostgreSQL with pgvector and IVFFlat indexing.
Drop-in replacement. Swap the client, keep your logic.
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"
)
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()
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"
)
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()
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"
)
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)