Every session starts from zero. Smara gives Claude Code, Cursor, and Codex a shared memory that persists, decays naturally, and follows you across tools.
Works with your tools
The problem
"I use Tailwind, not Bootstrap." "The API is at /v2, not /v1." "We deploy to Fly.io." You've said it before. Your AI forgot.
Smara stores context automatically as you work. Next session — in any tool — your AI already knows.
How it works
Add Smara to your MCP config and start coding. Context follows you everywhere.
Add Smara to your MCP config. One JSON block. Works in Claude Code, Cursor, Windsurf, or any MCP client.
Smara runs silently. It auto-loads context at conversation start and stores new facts as you work. No manual commands.
Switch to Cursor, open Codex, start a new Claude session — your context is already there. One pool, every tool.
See it in action
Demo 1 — Install & auto-capture
Smara silently captures decisions as you work. No tagging, no commands — just code normally.
Demo 2 — Cross-tool recall
Switch from Claude Code to Cursor — your context follows. Zero re-explaining.
Demo 3 — Smart decay
Ebbinghaus decay keeps context fresh. Frequently-used facts stay strong. Old noise fades naturally.
Demo 4 — API integration
Simple REST API. Store, search, context — 3 endpoints. Works from any language.
Team collaboration New
Your AI automatically sorts memories — project decisions go to the team, personal preferences stay private. Override anytime. Search returns both.
Admin, member, or read-only. Control who can store, search, and manage team memories.
AI classifies automatically — "uses RS256" goes to the team, "prefers dark mode" stays private. Override anytime.
Invite teammates with a link. They accept, join the team, and immediately see shared context.
Persistent agents with memory, skills, and shared team context. Create once, plug into any LLM or MCP client.
REST API
No SDKs to install. No schemas to define. Just REST.
curl -X POST https://api.smara.io/v1/memories \ -H "Authorization: Bearer smara_your_key" \ -H "Content-Type: application/json" \ -d '{ "user_id": "user_42", "fact": "Prefers dark mode. Uses vim keybindings.", "importance": 0.7, "visibility": "private" // or "team" }'
{ "id": "mem_8f3a...", "decay_score": 1.0, "status": "stored" }curl https://api.smara.io/v1/memories/search \ -H "Authorization: Bearer smara_your_key" \ -G \ -d user_id=user_42 \ -d q="editor preferences" \ -d limit=5 \ -d include_team=true
{ "memories": [
{ "fact": "Prefers dark mode. Uses vim keybindings.",
"similarity": 0.94, "decay_score": 0.97,
"visibility": "private", "source": "claude-code" }
] }curl https://api.smara.io/v1/users/user_42/context \
-H "Authorization: Bearer smara_your_key"
{ "user_id": "user_42",
"memory_count": 23,
"context": [
{ "fact": "Prefers dark mode. Uses vim keybindings.", "score": 0.96 },
{ "fact": "Working on a Rust CLI tool for log parsing", "score": 0.89 }
] }MCP tools
Every Smara MCP server exposes these tools to your AI. No configuration required.
Memory control
No dashboards needed. Just tell your AI what you want. Smara's MCP tools handle the rest.
Ebbinghaus decay
Infinite context is noise. Smara uses Ebbinghaus decay scoring — the same curve that models human forgetting.
Recent facts stay sharp. Old trivia fades. Important memories that keep getting reinforced persist forever. Contradictions are auto-resolved.
The result: your AI's context window is always fresh, relevant, and right-sized. No bloat, no stale facts.
Under the hood
MCP for Claude Code, Cursor, Windsurf. REST API for everything else. One memory layer, every tool you use.
Install the MCP server. That's it. Context loads at conversation start. New facts store silently as you work.
Old trivia fades. Important facts persist. Contradictions auto-resolve. Your context stays fresh without manual cleanup.
Every memory knows its origin — Claude Code, Cursor, Codex, or your API. Filter by source or see everything together.
Shared memory pools for your team. Private stays private. Team memories visible to all members. Role-based access.
Persistent agents with memory, skills, and team context. Create once, use across any LLM or MCP client.
FAQ
Smara is a persistent memory layer for AI coding tools. It gives Claude Code, Cursor, Windsurf, Codex, and any MCP-compatible client shared context that survives across sessions.
Install with one command: npx @smara/mcp-server --init
Smara uses Ebbinghaus forgetting curves to score memory relevance over time. Important facts persist while trivial details naturally fade, just like human memory.
The formula is R = e^(-t/S) where t is time elapsed and S is memory strength based on importance and access frequency. A memory referenced daily stays near score 1.0; something mentioned once 60 days ago fades toward 0.
Any MCP-compatible tool: Claude Code, Cursor, Windsurf, Codex, VS Code with Copilot, and any custom MCP client.
Smara also provides a REST API for direct integration from any language or framework — Python, TypeScript, Go, Ruby, anything that can make HTTP requests.
Create a team, invite members by email, and memories are automatically sorted into private or team:
Your AI classifies automatically via MCP — no manual tagging. Override by saying "make that private" or setting visibility: "team". Combined search returns both private and team memories together.
Yes. Each API key isolates your data completely. Memories are encrypted in transit (TLS 1.3) and stored in isolated PostgreSQL schemas. We never use your data for training.
You can delete all memories at any time via the delete_memory MCP tool or the REST API.
Three plans:
No credit card required for the free tier. Cancel anytime.
Pricing
From the blog
Technical articles on decay-scored retrieval, agent memory patterns, and building context-aware AI tools.
Head-to-head comparison of architecture, pricing, and developer experience.
Comparing Smara, Zep, Letta, and more — pricing, features, and real tradeoffs.
How forgetting curves make AI memory smarter — the math behind Smara's decay scoring.
Patterns for giving autonomous agents context that survives across sessions.
Step-by-step guide to giving Claude Code persistent memory with Smara's MCP server.
Get started
Free tier. 10,000 memories. No credit card required.
Takes 2 seconds. Your key appears right here.
We're a small team shipping fast. The best features come from real developers hitting real problems. Try Smara, break things, and tell us what's missing.
Or reach out directly