mrkeyoor.com_
Wed 16 Sept 05:25 UTC
Dataevaluationupdated 26 Aug 2026

qdrant review

Qdrant is a vector database for storing embeddings with JSON payloads, filtering them, and retrieving similar items through REST or gRPC. It supports dense, sparse, and multivector search, so one service can handle semantic retrieval, keyword-style matching, recommendation, and hybrid ranking.

+132stars / 7d
Verdict

Our Qdrant build took 680 seconds, and cargo test ended with 23 failures in storage-read API cases despite 134 passes, so source adopters should reproduce that suite before shipping commit 74f3e85. Qdrant remains a strong choice for teams that need filtered hybrid retrieval and can operate a stateful service. Use the container for evaluation, secure it before any real data arrives, and choose something smaller if vector search is only an experiment.

We ran it

Lab card: what happened when we ran qdrantScreenshot of qdrant (qdrant.tech)
Install✓ · 33s802 packages
Build✓ · 680s
Tests✗ · 180s134 passed · 23 failed of 157 (cargo test)
Repo2244 files~522,371 lines of source · 34.3 MB · 18 CI workflows · Dockerfile · tests dir

Answers from our run

Does qdrant build from source?

Dependencies installed in 33 seconds (802 packages), and the build succeeded in 680 seconds. We cloned commit 74f3e85 into a clean Debian container with 3 CPUs and no project-specific setup.

Do qdrant's tests pass?

Not all of them: 134 of 157 passed and 23 failed when we ran the project's own test command (cargo test). Some failures need services or credentials a bare container does not have.

Who should not use qdrant?

Developers wanting a library that creates embeddings for them: Qdrant stores and searches vectors, while the application or another model service supplies them.

What are the alternatives to qdrant?

Milvus, Weaviate, Chroma. Our Qdrant build took 680 seconds, and cargo test ended with 23 failures in storage-read API cases despite 134 passes, so source adopters should reproduce that suite before shipping commit 74f3e85.

Setup3/5One-command trial, followed by real stateful-service operations
Docs5/5Clear API, security, scaling, storage, and client guidance
Community5/5August release, current pushes, and active issue response
Maturity4/5Deep database features, reduced by 23 failures in our root suite

Discussed on

  1. hnWe were not accepted into Google Summer of Code. So, we started our own146 points
  2. hnQdrant, the Vector Search Database, raised $28M in a Series A round131 points
  3. hnQdrant 1.7.087 points
  4. hnImmutable Data Structures in Qdrant46 points
  5. hnQdrant: Vector Database for the next generation of AI applications29 points

Who it’s for

Search and AI teams that need payload filtering alongside vector similarity.
Operators who want an Apache-licensed server with sharding, replication, snapshots, and official clients.
Applications combining dense embeddings, sparse text signals, and late-interaction vectors such as ColBERT.
Teams willing to test index, memory, consistency, and recovery settings against their own corpus.

Who it’s NOT for

Developers wanting a library that creates embeddings for them: Qdrant stores and searches vectors, while the application or another model service supplies them.
Teams likely to expose a quick-start container unchanged: the README warns that it has no authentication and listens on all network interfaces.
Small projects that only need exact filters or ordinary text search: operating vector indexes, payload indexes, snapshots, and upgrades adds work without a clear payoff.
Release pipelines that require the full root suite to pass in a plain container: our run ended with 23 storage-read API test failures.
Operators unwilling to investigate current correctness reports: open issues include concurrent payload-index desynchronization and a crash from an extreme shard count.

Setup reality

Our sandbox installed 802 Rust packages in 33 seconds, then the build took 680 seconds. Tests ran for 180 seconds and failed with exit 101: 134 passed and 23 failed of 157. The log tail named tonic::api::storage_read_api cases for missing collections, byte ranges, streams, whole-file reads, and shard-scoped access.

The README's trial path is a container on port 6333, followed by an official client. That command starts without authentication and binds to all interfaces. Production needs persistent storage, an API key or other access controls, TLS or a trusted network boundary, resource sizing, collection settings, snapshots, and a tested restore procedure.

The checkout was 34.3 MB with 2,244 files and roughly 522,371 source lines. It included a Dockerfile, a tests directory, and 18 CI workflow files. Our 3-CPU, 12 GB unprivileged container was enough to build, but the failing tests mean this commit did not clear a plain cargo test run in our environment.

Payload filtering is the reason to choose Qdrant

Vector similarity alone is easy to demonstrate and hard to turn into a useful product. Real searches also need rules such as tenant, price, geography, permissions, document type, or time range. Qdrant stores JSON payloads beside vectors and indexes those fields for filtering. It supports dense vectors for semantic similarity, sparse vectors for lexical signals, and multivectors for late-interaction models. One query can combine retrieval branches and merge them with configurable fusion.

That breadth fits product search, retrieval for language models, recommendations, and image matching. The API has recommendation and discovery modes, facets, relevance feedback, and multitenant partitioning. Official clients cover Python, JavaScript or TypeScript, Rust, Go, Java, .NET, and C#. REST lowers the barrier to an initial integration, while gRPC is available when an application wants a typed binary interface.

The one-line container is intentionally insecure

The README starts Qdrant by mapping port 6333 from a container. It immediately warns that this deployment has no authentication and is open on all network interfaces. That warning should be treated as part of the command, not optional reading. A laptop trial can remain on a private interface. A server needs authentication, network restrictions, encryption, persistent storage, monitoring, snapshots, and a recovery rehearsal before ingesting valuable embeddings or payloads.

Qdrant is a database, so collection design matters. Operators choose dimensions, distance measures, payload indexes, quantization, memory behavior, sharding, replication, and consistency. Release v1.19.0 added per-component memory tiers named cold, cached, and pinned, a global quota API, read-affinity routing, prefix filtering, and 4-bit TurboQuant primary storage. Those controls are useful, but they also create settings that must be measured against real traffic rather than copied from a tutorial.

What happened when we ran it

Our fresh Rust sandbox installed 802 packages in 33 seconds. Building commit 74f3e85 took 680 seconds on 3 CPUs with 12 GB of RAM. The checkout occupied 34.3 MB and contained 2,244 files with roughly 522,371 source lines. This is a substantial database codebase, and the 11-minute build is a practical cost for source-based development and continuous integration.

The test stage failed after 180 seconds with exit code 101. Cargo reported 134 passed and 23 failed of 157. The final log lines named storage-read API tests covering a missing collection, bounded byte reads, streaming reads, a zero-length stream, whole-file retrieval, batches, and file access scoped by shard ID. Cargo suggested rerunning with --bin qdrant. The supplied log does not show why those tests failed, so we will not assign a cause.

The repository contained a Dockerfile, a tests directory, and 18 CI workflow files. That is strong project machinery, but it does not erase our result. A team building from source should rerun the failing binary in its intended development environment and compare the full logs with CI. Users pulling a released container should still run API, persistence, snapshot, and restore checks against the exact image they intend to deploy.

Storage controls are powerful and easy to mis-size

Qdrant can keep vectors and indexes in memory or on disk, use quantization to cut storage, and accelerate some indexing with NVIDIA or AMD GPUs. It also has write-ahead logging, snapshots, sharding, replication, telemetry, and a web UI for collections and API calls. Qdrant Edge embeds a smaller local engine inside Python or Rust applications and can synchronize with a server, which covers offline or device-side uses without the full client-server arrangement.

None of this removes capacity planning. Vector count, dimensions, payload cardinality, update rate, filter selectivity, replication, and query mix all change the result. We did not run search benchmarks, and the README's performance and memory claims are not substitutes for a corpus test. Measure ingestion, recall, tail latency, RAM, disk growth, snapshot time, and restore time with your embedding model and filters. A configuration that excels at dense nearest-neighbor search can behave differently under hybrid queries and selective payload filters.

Active fixes show both maturity and database risk

The repository was pushed on August 25, 2026, and v1.19.0 was released on August 5. Its release notes include fixes for data loss in a race between payload-index removal and segment flushing, snapshot recovery states, WAL replay, resharding, readiness checks, and a path traversal issue in S3-backed snapshots. Fixing these cases is evidence of active maintenance. It also shows why database upgrades require changelog review and recovery testing.

GitHub reports 705 open issues and pull requests combined. A search that excluded pull requests found 479 open issues, including current reports about payload keyword indexes desynchronizing during concurrent filtered updates and collection creation crashing with an extreme shard count. These reports may be configuration-specific or awaiting confirmation. They are still relevant checkpoints for teams using the same operations. The issue queue is busy, and maintainer activity is current rather than dormant.

The alternatives trade simplicity for a different operating model

Milvus targets distributed vector workloads with a larger supporting system. Weaviate combines vector search with its own object schema and modules. Chroma is often the shorter path for a small Python retrieval application. Qdrant sits between those experiences: the local container is approachable, while production features extend to multi-node operation, fine-grained memory tiers, quotas, hybrid search, and edge synchronization.

Our failed suite prevents an unqualified recommendation for building this exact commit from source. It does not prove released Qdrant containers are broken, because we did not test one, and the log gives no failure cause. For a serious filtered-retrieval service, reproduce the 23 failures, secure port 6333, and test recovery before launch. If the application only needs a disposable embedding index, Chroma or an embedded library will demand less operational attention.

Alternatives

ProjectWhat it isPick it when
Milvus gh↗A distributed vector database built for large collections and horizontal scale.pick this instead when a distributed data platform and its broader service stack fit your operations team.
WeaviateA vector database with schema, hybrid search, modules, and managed or self-hosted deployment.pick this instead when its object model and integrated module ecosystem match the application better.
Chroma gh↗A developer-focused embedding store with a quick local path for retrieval applications.pick this instead when a small application values a compact Python-friendly start over Qdrant's operational controls.

Sources

  1. Qdrant README
  2. Qdrant v1.19.0 release
  3. Qdrant security documentation
  4. Qdrant open issues

More data reviews

GeoLibre · TradingView-API · os-taxonomy · Lean · bokeh · orm · the whole board →