NewRelease 0.12.3 is out: Engine v0.12.3, Dashboard 0.5.2, Helm 0.12.3, the four SDKs, CLI 0.8.2 and MCP 0.12.3Release 0.12.3 is outSee what's new →
COMPARE · VECTOR DB

Dakera vs Qdrant: a great vector engine vs a complete memory engine

Qdrant and Dakera are both written in Rust and both run as a self-hosted service. Qdrant is an Apache 2.0 vector search engine with the richest payload filtering and sharded scale of the two. Dakera is a memory engine: it adds the layers an agent needs above its own vector index. This page shows which layers are which.

Reviewed October 2026

88.2%
LoCoMo Recall@20, 1,536 questions: does retrieval surface the answer. Method
0.87 ms
vector search p50 at recall@10 0.998 (50k vectors, CPU only, v0.12.0)
~101 MB
server binary; models run on-device, with no external API
100+
languages in one embedding space (v0.12.0)

Same foundations, and where Qdrant leads

Qdrant is a mature, widely used engine, and on the vector side the two overlap more than you might expect. The v0.12.0 release closed most of the remaining gaps in representations and compression.

Vector engine capabilities
CapabilityQdrantDakera
HNSW dense searchYesYes
Sparse or BM25 plus dense, with fusionQdrant: RRF and DBSF, formula queries. Dakera: BM25 + HNSW with RRFYesYes
Multi-vector records with MaxSimDakera: opt-in records and late interaction, v0.12.0YesYes
QuantizationQdrant: scalar, product, binary, TurboQuant. Dakera: RaBitQ mode, opt-inYesYes
REST and gRPCDakera gRPC covers vector operations; authenticated and rate-limited in v0.12.0YesYes
Official MCP serverYesYes
Sharding and replicationDakera: replicated writes, every node holds a full copyYesPartly
Nested, geo and datetime payload filtersYesPartly

Choose Qdrant for sharded datasets that outgrow one machine, for payload filters as expressive as nested objects and geo shapes, for its broader quantization menu, and for official clients in Python, TypeScript, Go, Rust, Java and .NET. Dakera ships Python, TypeScript, Go and Rust SDKs under MIT.

The layers above the index

A memory system needs more than nearest-neighbour search. Qdrant stops at the engine, which is the right place for a database to stop. Dakera continues upward.

LayerQdrantDakera
Agents, sessions, scoped keys
Your application
agent_id, sessions and API keys pinned to namespaces
Entity extraction and knowledge graph
Your application
On-device entity extraction, 5 edge types, BFS traversal
Memory lifecycle
Your application
6 decay curves, TTL, deduplication, consolidation
Embeddings and reranking
Bring your own vectors, or Qdrant inference options
Embedding, cross-encoder rerank and rerank_report run on-device
Hybrid retrieval and fusion
Sparse and dense vectors, RRF and DBSF fusion, formula queries
HNSW + BM25 with RRF fusion, then rerank
Filtering and compression
Nested, geo and datetime payload filters; scalar, product, binary and TurboQuant quantization
Metadata filters on recall; RaBitQ mode, f16 graph nodes, f32/f16/i8 multi-vector
Index, storage, clustering
HNSW in Rust, sharding and replication, snapshots
HNSW in Rust, multi-node high availability with replicated writes, encrypted backups
Dashed cells are layers an application normally builds on top of a vector database. Qdrant publishes an official MCP server, mcp-server-qdrant, with qdrant-store and qdrant-find for keeping and retrieving memories.

What those layers look like in code

Sessions, importance, recall and a graph walk are four calls on the same Python client, against one server. Entities are extracted on-device when a namespace has extraction switched on. See the Python SDK.

from dakera import DakeraClient

client = DakeraClient(
    "http://localhost:3000", api_key=KEY)

s = client.start_session(agent_id="support")
client.store_memory(
    agent_id="support",
    content="Maria prefers email, in German",
    session_id=s["id"],
    importance=0.8,
)
hits = client.recall(
    agent_id="support",
    query="How do we contact Maria?",
)
graph = client.knowledge_graph(
    agent_id="support",
    memory_id=hits.memories[0].id,
    depth=2,
)
The Dakera Dashboard knowledge graph view showing entity nodes and labelled edges for one agent.
The Dakera Dashboard knowledge graph view: entities and edges extracted from an agent's memories.

What v0.12.0 adds for vector-engine buyers

  • Representations: records keep one indexed vector plus named dense, token or patch vectors as f32, f16 or i8, preserved through snapshots, export and replication. Late interaction uses colbert-small with a MUVERA first stage and MaxSim rerank. See Records and Search and ranking.
  • Inspectable ranking: every response carries a rerank_report, rerank_candidates bounds the cross-encoder per request, and GET /v1/capabilities tells clients what the server supports.
  • Memory footprint: HNSW memory per vector is 43% lower (4.81 KB to 2.76 KB at 1024 dimensions, recall@10 unchanged), and the container holds 0.65 GB after reranking.
  • Languages and media: full-text stemming in 18 languages, and opt-in file attachments, on-device speech to text and visual recall over document pages.
  • Security: authenticated, audited gRPC; AES-256-GCM encryption at rest once a key is configured, bound to its record and namespace, with per-namespace rotation.

When to choose Qdrant, and when Dakera

Choose Qdrant if

  • Your dataset needs sharding across machines, or runs to billions of vectors.
  • Filtering is central: nested objects, geo radius or polygon, datetime ranges.
  • You want to pick a quantization method, including product and TurboQuant.
  • You prefer a fully Apache 2.0 server and official Java or .NET clients.
  • You are building retrieval for RAG or recommendations and will own the memory logic yourself.

Choose Dakera if

  • You are building agent memory and want extraction, sessions, decay and a graph built in.
  • You want embeddings, reranking and entity extraction on-device, with no per-call cost.
  • You need multilingual or multimodal memory behind one API.
  • You want a dashboard that shows why each memory ranked where it did.

Qdrant Cloud offers a free 1 GB cluster, usage-based Standard and Premium tiers, and Hybrid Cloud. Prefer managed? Dakera Cloud is coming. Join the waitlist.

Frequently asked questions

Both are written in Rust. What is actually different?

Scope. Qdrant is a vector search engine: points, payloads, filters and fusion. Dakera layers memory semantics over its own index: agents, sessions, decay, deduplication, consolidation, a knowledge graph and on-device models.

Can Qdrant be used for agent memory?

Yes. Qdrant publishes mcp-server-qdrant, an official MCP server for storing and retrieving memories, and you can build lifecycle logic in your application. Dakera provides those layers as part of the server.

Does Dakera support multi-vector and quantization like Qdrant?

Yes, as opt-in v0.12.0 features: multi-vector records, late interaction with MaxSim, and a RaBitQ search mode. Qdrant offers a wider choice of quantization methods.

How should I read the LoCoMo figure?

Dakera reports Recall@20: whether the answer is among the top 20 retrieved memories, with no LLM in the retrieval path. LoCoMo is a memory benchmark, so it is not set against vector-search benchmarks, which measure a different thing.

Self-hosted is free

Run Dakera on your own infrastructure.

One binary with its models baked in and no per-call fees. Start it with one Docker command and see it for yourself.

Prefer managed hosting? Join the Dakera Cloud waitlist →