Running Qdrant?

Qdrant collection recall or latency off? We sort it out.

Qdrant is fast and honest about its trade-offs. Most of the pages we see come from collections that were created on defaults and then grew: a vector size that no longer matches the embedding model, HNSW parameters that produce lower recall than the benchmark promised, payload indexes that were never built so filters scan every point, or a node that ran out of disk mid-optimizer run. We tune what is there rather than rewriting it.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

qdrant.log

still flaky

What it is

Qdrant at a glance

Qdrant is an open-source vector database written in Rust. Collections hold points with one or more vectors and an attached JSON payload, and queries combine approximate nearest-neighbour search with payload filtering in a single request. The engine uses HNSW for the index, supports scalar and product quantization, and exposes gRPC and REST APIs along with mature Python, JavaScript and Rust clients.

It competes with Pinecone, Weaviate, Milvus and the pgvector extension for Postgres. Teams reach for Qdrant when they want a self-hosted option, fine-grained control over index parameters, strong payload filtering, and a cost profile that scales linearly with their own infrastructure rather than per-vector pricing. Qdrant Cloud exists for teams that want a managed deployment with the same engine behind it.

Type
Vector similarity search engine with payload filtering
First released
2021 open-source release
License
Apache 2.0, free and permissive
Maintained by
Qdrant Solutions GmbH and the open-source community
Typically used for
Semantic search, retrieval-augmented generation, recommendation, deduplication, multimodal search

The honest version

Qdrant pros and cons

No technology is all upside. This is where Qdrant earns its place and where it tends to cause trouble.

Where Qdrant is strong

  • Honest and well-documented performance characteristicsHNSW parameters, quantization trade-offs and payload index behaviour are all documented with the actual recall and latency numbers, which makes capacity planning realistic instead of guesswork.
  • Filtering sits inside the searchPayload filters are evaluated during HNSW traversal rather than as a post-filter, so complex tenancy and metadata queries return the top K after filtering rather than after a two-pass hack.
  • Self-hostable without a licence conversationThe Apache 2.0 engine runs the same way in your own Kubernetes as it does in Qdrant Cloud, which is a different story than some commercial vector databases that reserve features for their managed tier.
  • Rust implementation is efficientMemory use and raw throughput are strong relative to Python-heavy alternatives, which matters once a collection has tens of millions of points.
  • Quantization options are practicalScalar and product quantization, combined with on-disk HNSW, make it realistic to run large collections without renting the memory to hold every float.

Where Qdrant bites

  • Defaults are not production parametersAn HNSW built with default m and ef_construct values is fine for a tutorial and shortfalls on recall for a production workload. Teams discover this when relevance regresses silently after their corpus grows.
  • Payload indexes are not automaticFilters on unindexed payload fields fall back to a full scan, and the only signal is slow queries. The concept exists in the API, but creating the right indexes is a task operators have to remember.
  • Cluster mode is relatively youngMulti-node clusters, sharding, and Raft-based replication work, but the operational story around rebalancing and failure recovery is less mature than mainstream databases, and some upgrades still want careful coordination.
  • Snapshotting large collections is slowBackups and migrations on tens of millions of points take real time, and the lock behaviour during snapshot creation can affect write latency more than it does on traditional databases.
  • Ecosystem is still LLM-framework-shapedLangChain and LlamaIndex integrations are first class, but outside that ecosystem the tooling for data loading, migrations and observability is thinner than for Postgres or Elasticsearch.
  • Vector size changes are destructiveSwitching embedding models means a new collection and a full reindex. Any system that treats a vector collection as upgradeable in place will have a bad time.

Sound familiar?

Common Qdrant problems we fix

The Qdrant problems that bring people to us, and what you have once each one is fixed.

Vector size is inconsistent: expected 1536, got 3072

Embedding model changed and inserts are rejected

A new model emitting a different vector dimension pushed into a collection that was configured for the previous size, which fails every insert until the collection is recreated or a second one is used.

Collection sized to the right model

Payload field 'tenant_id' not indexed

Filtered queries are unexpectedly slow

A multi-tenant setup filtering on tenant_id against a collection where no payload index exists on that field, so every query scans all candidates before filtering.

Payload indexes created on real filter fields

Optimizer is lagging: 42 segments pending

Optimizer falls behind on write-heavy collections

A high-ingest workload producing segments faster than the optimizer can merge them, so query latency climbs and memory use grows as segments accumulate.

Optimizer tuned for the ingest rate

HNSW search ef=64 may be too low

Recall is lower than the benchmark suggested

A production query path using the default search-time ef value rather than one tuned for the actual recall target, so retrieval misses relevant results the collection does contain.

Parameters tuned against a labelled eval set

No space left on device

Node runs out of disk mid-optimizer

A storage volume sized against the vector data alone, with no headroom for optimizer temporary files, so a large merge fails and the collection enters a degraded state.

Storage sized against real workload

Timeout: Search operation exceeded 5000ms

Search queries start timing out

A collection whose index parameters, payload filter complexity and point count have drifted past what the configured timeout allows, often because filters are not indexed and ef is pushed up to compensate.

Latency back inside SLO

Quantization enabled, on-disk HNSW not enabled

Memory use does not drop after quantization

Scalar quantization turned on without moving the HNSW index on-disk, so the index still sits fully in memory and the expected savings do not materialise.

Quantization and on-disk index working together

Raft: not the leader of peer group

Cluster writes fail after a node restart

A Raft peer group that has not elected a new leader after a rolling restart, so writes against that shard are refused until leadership stabilises.

Cluster leader elections healthy

What we do

Qdrant help, from first collection to production

Call us for one slow collection, or hand us the whole vector stack.

Rescue
A collection whose recall dropped, queries that are timing out, or an optimizer that cannot keep up. We stabilise the engine first and work back to what changed.
Collection design
Vector size, distance metric, HNSW parameters, payload schema and indexes chosen deliberately, with a labelled eval set to prove the quality end to end.
Scaling and sharding
Moving from a single-node setup to a sharded, replicated cluster with a plan for rebalancing, upgrades, and the operator footprint that comes with it.
Quantization and memory tuning
Scalar and product quantization, on-disk HNSW, and memory footprint tuned against actual query latency targets, not the defaults.
Migration from other vector DBs
Moving collections from Pinecone, Weaviate, pgvector or a hand-rolled store onto Qdrant without losing data, filter semantics or recall.
Managed Tech
Collection health checks, optimizer monitoring, snapshot lifecycle, upgrade planning, and an engineer on call when relevance regresses in production.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Qdrant alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Qdrant questions

Something else? Call+1 737 727 7327

Should we use Qdrant instead of Pinecone or pgvector?

It depends on the shape of the workload. Qdrant is a strong choice when you want self-hosting, serious payload filtering, and predictable costs that scale with your own infrastructure. Pinecone wins on zero-operator overhead and a very mature managed experience. pgvector is often the right answer when your dataset is modest and your team already runs Postgres heavily. We help teams pick by looking at vector count, filter complexity, and operational budget.

Why is recall lower than we expected?

Usually a combination of HNSW parameters that were left at defaults, search-time ef values that are too low, and payload filters evaluated in a way that excludes relevant candidates during traversal. The honest fix is a labelled eval set that lets you tune m, ef_construct and search ef against real relevance numbers rather than vibes.

When do we need quantization?

Once the collection would otherwise require more RAM than you can comfortably rent. Scalar quantization usually gives a strong win at modest recall cost. Product quantization pushes that further with more careful tuning. Both pair with on-disk HNSW for the storage side. The main risk is enabling one without the other and seeing no real memory reduction.

How do we handle changing embedding models?

By treating the vector dimension as part of the collection identity. Create a new collection for the new model, reindex the corpus, run both collections side by side long enough to compare relevance, then retire the old one. There is no in-place upgrade of embedding models, and attempting one usually causes more pain than planning the switch.

Is Qdrant production ready in cluster mode?

For most workloads, yes. Multi-node clusters with Raft-based replication work and are run in production at real scale. The operational practice around rebalancing, upgrades and failure recovery is less mature than for a decade-old database, so we usually recommend starting with a smaller cluster, running representative failure drills, and expanding once the operator confidence is there.

How much does Qdrant help cost?

Initial estimates are complimentary. Share the collection size, embedding model, filter patterns and the specific symptoms, and you get a quote back before we touch the engine.

Free estimate

Qdrant giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.