NewRelease 0.12.2 is out: Engine v0.12.2, Dashboard 0.5.1, Helm 0.12.2, the four SDKs, CLI 0.8.1 and MCP 0.12.2Release 0.12.2 is outSee what's new →
v0.12.2 · 88.2% Recall@20 on LoCoMo (v0.11.107) · Self-hosted · Open core

Self-hosted memory
for AI agents.

Dakera stores what your agents learn and recalls it by meaning, keyword or relationship. One binary on your own infrastructure, with no external APIs.

No account required · Self-hosting is free.

Dakera memory infrastructure: your data (documents, code, conversations, APIs, databases) flows into the Dakera core, AI agents (Claude, Cursor, Windsurf, Agent Squad, custom) connect on top, and useful memory (vector search, BM25, knowledge graph, reranking, intelligent decay, sub-10ms retrieval) flows out. Deploy anywhere: on-premises, Kubernetes, any cloud. Single binary, zero dependencies.
  • 88.2%LoCoMo
  • ~1 msvector search p95 · 50k vectors
  • 14core MCP tools
  • 1binary to deploy
The problem

Your agents forget
everything they learn.

Without memory, every session starts from zero. Agents lose what they learned in earlier conversations, and you pay to re-teach the same context again and again.

Without Dakera
A mechanical counter reading 1,847 sessions and 000000 memories, key turned to RESET
  • Sessions are isolated silos
  • Knowledge evaporates at scale
  • Context stuffing is a dead end
0% retention · 1,847 sessions re-taught
With Dakera
The same counter lit up, reading 1,847 sessions and 041206 memories, key turned to PERSIST
  • Every session builds on the last
  • Knowledge compounds across agents
  • Relevant memories, not a bigger prompt
88.2% LoCoMo · 41,206 memories kept
Memory recall

Recall that feels like reasoning.

Each fact an agent stores becomes a memory linked to related people, events and decisions. A recall combines vector, full-text and knowledge-graph signals, so an answer can be found several hops away from the question.

agent.recall("why did the Q3 deploy fail?") traces a gold path through the knowledge graph: Q3 migration, deploy failed 03:14, Postgres cluster, connection pool exhausted. Recalled in 42ms, 3 hops.
Dakera Dashboard

See what your agents
remember.

The Dakera Dashboard shows the health of your memory layer, lets you browse and recall memories, and maps what your agents know. Take a look before you install.

The Dakera Dashboard 0.5.0 overview: an attention banner for an exceeded quota, then agent memories, stored records, agents, storage, recall latency and cache hit rate, with the largest namespaces and live agents listed below.
The Agents page for a support agent: its memory count, average importance and sessions, then its memories with type, tags and importance, and tabs for sessions, consolidation, wake-up, feedback and adding a memory.
The Recall lab running a question against a support agent, with ranked results showing smart score, relevance, vector and text similarity, importance and timings.
The Knowledge graph of a support agent: a force-directed network of memory nodes linked by related-memory connections, with decay, diff and time-travel controls.
The cross-agent memory network: five agents drawn as rows of memories, with lines showing shared concepts between agents, and network statistics at the side.
The Analytics page with vector queries, average and p99 latency, storage, a query latency histogram and a throughput chart.
01 / 06

See the health of your memory layer the moment you sign in.

One binary

One binary.
Everything included.

A typical memory stack combines a vector store, an embedding service, a graph database and a session store. Dakera runs embeddings, vector and full-text indexing, reranking, the knowledge graph and session storage in one Rust process. SDKs and an MCP server connect to it.

Typical setup: a rack of four services (vector store, embedding service, knowledge graph, session store), about 1 to 2 GB and 3 to 5 services, next to Dakera: one block, about ~101 MB, 1 binary
New in v0.12.0

Multilingual. Multimodal.
Multi-vector.

The new retrieval and media features are opt-in. Deployments on v0.11.108 upgrade in place and can roll back with one command.

Multilingual searchbge-m3 embeddings, per-language stemming, CJK bigrams, dates in seven query languages, per-request lang.
Multimodal memoryAttachments, speech to text (WAV; multilingual Whisper by default, language auto-detected) and page indexing with visual recall (PNG). Each media job reserves its RAM before it starts.
Multi-vector recordsOne indexed vector plus named dense, token and patch representations, stored as f32, f16 or i8.
Late interaction and RaBitQMaxSim reranking with colbert-small, a RaBitQ search mode, rerank controls and GET /v1/capabilities.
Measured performanceVector search 0.87 ms p50 / 1.17 ms p95 at recall@10 0.998 (BEIR Quora, 50k). Memory after reranking 4.98 GB → 0.65 GB, and reranking about 2× faster on the same CPU, no GPU.
Security hardeningAuthenticated gRPC and cluster traffic, record-bound encryption with a key ring, tighter admin permissions.
SDKs

Integrate in minutes.

Native SDKs for Python, TypeScript, Go and Rust, and a REST API for every other language. Claude, Cursor and Windsurf connect through the MCP server with one config block.

Store and recallEmbedded on the server, recalled by hybrid search.
SessionsGroup memories by conversation, with an optional summary.
Multi-agentMemory per agent, isolated by namespace.
MCP server14 core tools for Claude, Cursor and Windsurf.
from dakera import DakeraClient

client = DakeraClient(base_url="http://localhost:3000", api_key="dk-your-key")
client.store_memory(agent_id="assistant-1", content="User prefers TypeScript")
response = client.recall(agent_id="assistant-1", query="language preference")
print(response.memories[0].content)
import { DakeraClient } from "@dakera-ai/dakera"

const client = new DakeraClient({ baseUrl: "http://localhost:3000", apiKey: "dk-your-key" })
await client.storeMemory("assistant-1", { content: "User prefers TypeScript" })
const response = await client.recall("assistant-1", "language preference")
console.log(response.memories[0].content)
import dakera "github.com/dakera-ai/dakera-go"

client := dakera.NewClientWithOptions(dakera.ClientOptions{BaseURL: "http://localhost:3000", APIKey: "dk-your-key"})
client.StoreMemory(ctx, "assistant-1", dakera.StoreMemoryRequest{Content: "User prefers TypeScript"})
resp, _ := client.Recall(ctx, "assistant-1", dakera.RecallRequest{Query: "language preference"})
fmt.Println(resp.Memories[0].Content)
use dakera_client::{DakeraClient, RecallRequest, StoreMemoryRequest};

let client = DakeraClient::builder("http://localhost:3000").api_key("dk-your-key").build()?;
client.store_memory(StoreMemoryRequest::new("assistant-1", "User prefers TypeScript")).await?;
let response = client.recall(RecallRequest::new("assistant-1", "language preference")).await?;
println!("{}", response.memories[0].content);
# Store a memory
curl -X POST http://localhost:3000/v1/memory/store \
  -H "Authorization: Bearer dk-your-key" -H "Content-Type: application/json" \
  -d '{"agent_id":"assistant-1","content":"User prefers TypeScript"}'

# Recall
curl -X POST http://localhost:3000/v1/memory/recall \
  -H "Authorization: Bearer dk-your-key" -H "Content-Type: application/json" \
  -d '{"agent_id":"assistant-1","query":"language preference"}'
// MCP server entry for Claude Desktop, Cursor or Windsurf
{
  "mcpServers": {
    "dakera": {
      "command": "dakera-mcp",
      "env": {
        "DAKERA_API_URL": "http://localhost:3000",
        "DAKERA_API_KEY": "dk-your-key",
        "DAKERA_MCP_PROFILE": "core"
      }
    }
  }
}
// 14 core tools by default. Set DAKERA_MCP_PROFILE to admin, power or all for more.
$ docker run -p 3000:3000 -e DAKERA_ROOT_API_KEY=dk-your-key ghcr.io/dakera-ai/dakera:0.12.2
Works with
Benchmark

88.2% Recall@20 on LoCoMo.
No LLM post-processing.

Scored on the LoCoMo dataset: 10 conversations, 1,536 evaluated questions, across temporal, multi-hop, entity and implicit reasoning. No LLM in the retrieval path.

~1 msvector search p95 · 50k vectors
4reasoning categories
A brass-rimmed gauge reading 88.2% Recall@20 on LoCoMo
1,536evaluated questions
0LLM post-processing
Dakera Cloud

The self-hosted binary is free today.
Cloud is coming.

Dakera Cloud adds managed hosting, an SLA and team monitoring. Join the waitlist to reserve founder pricing before launch.

No spam. We reach out personally before launch.

✓ You're on the list. We'll reach out personally before launch.
The Dakera core with managed hosting, SLA and team monitoring
FAQ

Common
questions

Answers to the questions we hear most about Dakera. For anything else, open an issue on GitHub.

Open an issue
Is Dakera a vector database?
No. Dakera is a memory engine for AI agents. It gives your agents persistent, session-aware, cross-agent memory with importance decay. The retrieval engine underneath (HNSW, BM25 and hybrid search) is how memories are recalled; the product is agents that remember, not a database you query.
Do I need an OpenAI API key for embeddings?
No. Text is embedded on the server at store and query time with ONNX Runtime. The default model, bge-large, ships in the Docker image; bge-m3 (multilingual), MiniLM, E5 and other models can be selected with DAKERA_MODEL. No external API calls and no per-call cost.
Is Dakera production-ready?
The engine includes write-ahead-log durability, snapshots and backups, AES-256-GCM encryption at rest, scoped API keys, rate limiting, Prometheus metrics and OpenTelemetry tracing. The product is in public alpha on the 0.12 release line, so APIs can still change between releases; each release documents its upgrade and rollback path.
Can I use it with Claude, Cursor, or Windsurf?
Yes. The Dakera MCP server (dakera-mcp) exposes 14 core tools (90+ available via profiles). Add it to the Claude Desktop, Cursor or Windsurf configuration and your assistant keeps its memory across sessions. No code changes are required.
What does Dakera replace in my stack?
Dakera replaces the memory layer of a typical stack: vector store, embedding service, knowledge graph and session store, in one binary. There are no external API keys and no separate services to operate.
How does Dakera handle scaling?
A single node is the simplest deployment. For high availability, Dakera runs as a multi-node cluster: nodes discover each other over gossip, elect a leader, and replicate every write with versioned merges, so each node holds a full copy of the data. See high availability.
What languages and SDKs are supported?
Native SDKs for Python, TypeScript, Go and Rust, and a REST API (JSON) for any other language. A gRPC service (Protobuf) covers vector operations, and the MCP server connects AI tools.
Is Dakera open source or open core?
Open core, not fully open source. The integration layer (SDKs for Python, TypeScript, Go and Rust, the CLI and the MCP server) is MIT-licensed and on GitHub. The memory engine is proprietary: you self-host the binary on your own infrastructure and own your data, but the engine source is not public. Self-hosted deployments have no usage fees, including commercial use. Full breakdown →
Is Dakera self-hostable?
Yes. Dakera ships as a single binary or Docker image and needs no external services. Your data stays on your infrastructure. Pull the image, set DAKERA_ROOT_API_KEY and start it on any Linux server or Kubernetes cluster; the image includes its default models, so it is ready in seconds without network access.
When will Dakera be generally available?
Dakera is available now as a public alpha. You can deploy the self-hosted binary today: pull the Docker image, set an API key and start it. Dakera Cloud (managed hosting, SLA, team monitoring) is next; join the waitlist below to lock in founder pricing.
What's the pricing model?
The self-hosted binary is free to run on your own infrastructure, with no usage fees. Memory contents never leave your infrastructure. By default the engine sends product telemetry: lifecycle events and a 6-hourly heartbeat with version, platform, configuration and rounded usage counts, never memory content, ids, names, secrets or paths. Telemetry includes the machine's hostname, and the analytics provider records the connecting IP address for a coarse location. Turn it off with DAKERA_TELEMETRY=0 or DO_NOT_TRACK=1; see the telemetry page. Dakera Cloud (managed hosting, SLA, team monitoring) will be priced separately; join the waitlist to lock in founder pricing before launch.
Is Dakera an MCP memory server?
Yes. The Dakera MCP server loads 14 core tools by default: store, recall, semantic, hybrid and full-text search, sessions, knowledge graph, entity extraction and forget, plus two tools that discover and load the rest on demand. Set DAKERA_MCP_PROFILE=power or all to expose more of the 90+ tools. Connect it to Claude Desktop, Cursor or Windsurf with one config block. All memory stays on your infrastructure.
Self-hosting is free. No account required.