Caura MCP
Shared memory for fleets of AI agents with access scopes, an audit trail and a knowledge graph: an MCP server, Docker and a cloud
- 541 ★ on the repository
- Last commit
- Apache-2.0
Broad access
Why this level
- Stores agent entries, flags personal data and can delete entries in bulk
- Mandatory keystone rules override conflicting user instructions in a session
- Shared memory carries one agent's entries to others, so a wrong entry spreads through the fleet
Install
- Works in
Manual install
claude mcp add --transport http -s user caura http://localhost:8000/mcp --header "X-API-Key: standalone"For the local Docker stack in IS_STANDALONE=true mode. For the cloud platform use https://caura.ai/mcp and your own key with the mc_ prefix.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- Stores agent entries, flags personal data and can delete entries in bulk
- Mandatory keystone rules override conflicting user instructions in a session
- Shared memory carries one agent's entries to others, so a wrong entry spreads through the fleet
This is third-party code. Review the repository files before installing.
What it does
Caura (formerly MemClaw) keeps a shared memory for several agents and tenants. Agents write plain text into it, and the server turns the entries into searchable memory: it infers a type, title and summary, scores importance, flags personal data and extracts entities. One agent records a lesson, another finds and applies it, and the answer shows who wrote the entry. Every entry carries a visibility scope: private to the agent, shared within a team, or shared across the organization. Agent trust tiers govern reads across teams, and writes, deletes and transitions land in an audit log. Search is hybrid: vector similarity in pgvector, full-text matching and a two-hop walk over the knowledge graph. The server detects contradictions between entries and supersedes stale ones, and agents report outcomes of their actions. The system reinforces what worked and writes preventive rules after failures. Mandatory rules for a scope are stored as keystone policies, and the client reads them at the start of a session. MCP access is at /mcp over Streamable HTTP. The server exposes 12 tools, including caura_write, caura_recall, caura_manage and caura_doc. Beyond MCP there is a REST API, Python and TypeScript clients, an OpenClaw plugin and the Rail library, which pulls rules and facts before each agent turn.
Who it is for. For teams running several agents who want shared memory with access separation and a log, and for those who want to keep memory on their own server.
Good fit when
- Several agents in one team should reuse each other's lessons, such as a service rollback command
- You need to split memory between teams and show who wrote which entry
- You must keep memory inside your own infrastructure: Docker Compose brings up Postgres with pgvector, Redis and the API
- Agents need mandatory organization-level rules that the client reads at session start
- Outdated facts should be replaced by newer ones and contradictions should be found automatically
Not a fit when
- A single agent and a small number of notes: a local memory file without a database and Redis is enough
- You need to run without Docker and Postgres: the self-hosted deployment requires these services
- Data cannot go to a cloud and no local embedder is set up: semantic search needs a provider key or a local model
- You need memory for one laptop with no sharing: tenant and trust management is excess here
Example request
Write the auth-service rollback command into the fleet's shared memory and check whether other agents already have conflicting entriesMCP
- Transport
- http
- Authentication
- API key
Environment variables
CAURA_API_KEYrequired, secret- Caura access key. For the local stack in IS_STANDALONE mode the value standalone works; the cloud needs a key with the mc_ prefix.
OPENAI_API_KEYsecret- Provider key for semantic search and entry enrichment. Another provider or a local embedder can replace it.
Limitations
The self-hosted deployment brings up a whole stack: Postgres with pgvector, Redis, a storage service, the API and a scheduler. Without a provider key it runs without embeddings: entries are found by keyword and the type and title come from a heuristic. Semantic search needs a provider key (OpenAI, Gemini, Anthropic or OpenRouter) or a local embedder described in the docs. The OpenAI and Anthropic APIs are unavailable from Russia, so semantic mode there should rest on a local model.
In IS_STANDALONE=true mode key checks are off, so use it only on your own machine. Team use needs a scoped key per agent. Treat agent entries as unverified: a wrong entry reaches other agents. The cloud platform lives at caura.ai and requires signup.
How to disable. Remove the server from the client configuration with `claude mcp remove caura`. Stop the local stack with `docker compose down` in the repository directory. The data lives in Docker volumes; add the `-v` flag to delete them. Cloud platform keys are revoked in the dashboard at caura.ai.
FAQ
How do I connect Caura to Claude Code?
For the local stack run `claude mcp add --transport http -s user caura http://localhost:8000/mcp --header "X-API-Key: standalone"`. The `-s user` flag makes the server available in every directory. Claude Code does not read MCP servers from settings.json, so registration goes only through this command or a .mcp.json file in the project root.
How is Caura different from MemClaw?
It is the same project after a rename. Old `memclaw_*` calls and `MEMCLAW_*` variables keep working, while new configuration should use the `caura_*` names. The memclaw-client package on PyPI became a shell that installs caura-client.
Does Caura work without OpenAI keys?
Yes. Without keys entries are stored without embeddings and found by keyword. Search by meaning needs an embedding provider key or the local embedder from the repository docs.
What are keystone rules?
They are mandatory rules for a storage scope. The `caura_keystones` tool reads them at session start, and they take priority over conflicting user instructions. Creating and deleting rules through `caura_keystones_set` takes trust level 1 for your own rules and 2 for team or tenant rules.
How is Caura memory different from memory for a single agent?
Caura is built for several agents and tenants: entries have visibility scopes, trust tiers, an audit log and propagation of outcomes between agents. Simpler services fit a single agent.
Discussion
No questions or reviews yet.
Related
MCP serversSelf-hosted long-term memory for agents: semantic search, a knowledge graph and autonomous consolidation over MCP and a REST API
A self-hosted MCP server for long-term agent memory: structured records, versioned rollback and a visual dashboard
A long-term memory MCP server for AI agents: facts fade along a forgetting curve and related records are compressed into a summary
Local memory for agents: stores conversations and project files verbatim and retrieves them with semantic search over MCP
iai-memory
iai-memory (Personal Memory Engine)
A local long-term memory MCP server for agents: keeps conversations verbatim and returns the right context at the start of a session
Knowledge-graph memory for agents: Claude Code and Codex plugins, an MCP server and a Python library
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| Caura (this entry) | yes | API key | 541 | |
| Mem0 | no | 68,059 | memory for a single agent or user without visibility scopes or trust tiers between agents | |
| MCP Memory Service | no | not required | 2,054 | self-hosted memory with a knowledge graph, without tenant separation or an audit log |
| Graphiti MCP | no | API key | 32,326 | a time-aware knowledge graph on FalkorDB or Neo4j, without fleet policies or outcome propagation |
README in short
The documentation offers four ways in: the cloud platform, Docker on your own server, an OpenClaw plugin and the Rail SDK for your own agents. Separate sections cover governance features, the write pipeline, self-improving memory and comparison with other solutions. The repository holds guides to self-hosting, integrating without the plugin and upgrading the plugin.