Self-hosted first
Your agent memory stays on your servers. No data leaves your infrastructure. Full control over storage, retention and access.
Give every AI agentperfect memory
Dakera builds open-core memory infrastructure so AI agents can remember context across conversations, sessions and teams, without sending data to third parties.
- 88.2%Recall@20 on LoCoMo
- 1 binaryno external services
- 1.17 msp95 vector search, 50,000 vectors
- MITlicensed SDKs
Why we're building Dakera
AI agents are getting smarter at reasoning, but they keep forgetting. Every time a conversation ends, the context is lost. Teams waste time re-explaining preferences. Customer support bots ask the same questions twice. Multi-agent systems can't share knowledge.
We believe memory is the missing layer in the AI stack. Not a simple key-value store, but real memory that understands temporal relationships, supports hybrid retrieval and builds knowledge graphs automatically.
Dakera is a single Rust binary that runs on your infrastructure. No external APIs, no embedding service, no separate database to manage: the ONNX models ship in the Docker image. Start the server, connect your agent or AI client, and it starts remembering. Most teams are running in under five minutes.
Read the quickstartHow Dakera works
A single binary handles the whole memory lifecycle, from storing a memory to recalling and decaying it, with no external services.
Your agents connect through
- SDKsPython · JS · Rust · Go
- MCPClaude · Cursor · Windsurf
- REST / gRPCDirect API access
- FrameworksLangChain · CrewAI · more
Store
A memory arrives with its metadata and is embedded on the machine, then indexed by every engine at once.
- Receive memory and metadata
- ONNX embedding, on-device
- Index across all engines
Recall
The query is classified, searched in parallel, fused and reranked into one ordered answer.
- Classify query intent
- Parallel hybrid search
- RRF fusion and rerank
Decay
Importance-weighted scoring keeps what the agent keeps using and lets the rest fall away.
- Importance-weighted scoring
- Important memories rise
- Stale memories fade
Kept in one process, on your disk
- HNSW vectorSimilarity search
- BM25 indexFull-text search
- Knowledge graphEntities and links
- RocksDBPersistent storage
What we will not trade away
Zero dependencies
One Rust binary. No Redis, no Postgres, no external embedding API. Storage, embeddings, retrieval and the knowledge graph are built in.
Open core
The memory engine is proprietary and free to self-host. SDKs for Python, JavaScript, Rust and Go are MIT-licensed. Build on Dakera without vendor lock-in.
88.2%Recall@20 on LoCoMo
Production-grade
88.2% Recall@20 on LoCoMo, the standard long-conversation memory benchmark. Built for concurrent agents, with encryption at rest, scoped API keys and metrics.
Who builds with Dakera
Not a tool for demos. Dakera is built for developers deploying intelligent agents into production who need real infrastructure underneath.
Read the deployment guide
AI and ML engineers
Building production agent pipelines
You ship LangChain or AutoGen agents that need to remember state across thousands of sessions, without duct-taping Redis, Pinecone and a custom decay script together.
- One binary replaces the usual memory stack: vector store, embeddings, session store and knowledge graph
- 88.2% Recall@20 on LoCoMo with hybrid retrieval you can tune per query type
- Native integrations: langchain-dakera, crewai-dakera, autogen-dakera. Drop-in memory classes
Backend engineers
Adding memory to LLM features
You are adding an AI feature to an existing product and need a reliable memory layer, not a research project. You care about latency, auth, multi-tenancy and zero new infra to maintain.
- REST API: integrate from any language, no Python runtime required
- Namespace isolation per user, scoped API keys and rate limiting built in
- Designed for low-latency retrieval. Rust with zero GC pauses will not bottleneck your LLM call chain
Framework builders
Integrating LangChain, CrewAI or LlamaIndex
You build tools on top of agent frameworks and need a memory backend that works across all of them: consistent API, framework-agnostic and fast enough for tool-calling loops.
- One REST API behind the Python, TypeScript, Go and Rust SDKs
- MCP protocol for LLM tool integration. The same backend serves IDE, API and framework use cases
- Open core: integrate the public API surface without vendor lock-in on internals
Platform teams
Deploying agent infrastructure at scale
You run the platform that dozens of internal teams build agents on. You need multi-tenancy, observability, horizontal scaling and security posture, not a managed service with opaque pricing.
- One instance serves hundreds of agents: namespaced, rate-limited and AES-256-GCM encrypted
- Prometheus metrics and OpenTelemetry tracing out of the box. Plug into your existing stack
- Multi-node clustering with gossip membership, leader election and replicated writes
The team
Dakera is built by infrastructure engineers who've shipped ML pipelines, vector search systems and distributed data stores at scale, and hit the same wall every time: agents that can't remember. We spent too many hours duct-taping Redis, Pinecone and custom TTL scripts together and decided to build the thing we wished existed.
Our background is in low-level systems engineering: Rust, storage engines and retrieval algorithms. Dakera's 88.2% LoCoMo Recall@20 comes from doing retrieval correctly at the engine level (hybrid BM25 and vector fusion, importance decay, on-device ONNX inference), not from bolting LLM reranking onto a vector store as an afterthought.
We believe the best infrastructure is invisible: it just works. Dakera should be as easy to set up as pulling a Docker image, and as reliable as the filesystem underneath it. No managed services, no opaque pricing, no data leaving your network.
Open at the edges. Closed at the core.
We open everything you need to integrate and keep what makes us fast. You can self-host the engine: the binary is yours to run on your own infrastructure, with no outbound user data and no external dependencies. What's closed is the source code, not your right to deploy it.
ClosedProprietary, free to self-host
Memory EngineThe Rust server: HNSW and BM25 hybrid retrieval, importance decay, knowledge graphs, AES-256-GCM encryption, multi-node clustering. Provided as a binary and Docker image. Source is not public.
DashboardWeb UI for monitoring agents, sessions, memory health and real-time analytics.
Built with
- RustMemory engine and server
- RocksDBPersistent storage engine
- HNSWVector similarity search
- BM25Full-text search index
- ONNX RuntimeOn-device inference
- Knowledge graphEntity extraction and linking
- MCP protocolAI tool integration
- OpenDALS3 and tiered storage
- gRPC + RESTDual API transport
Deploy in 5 minutes
One binary, no external services. Pull the Docker image, set your API key, and your agents start remembering.