Qdrant vs Weaviate vs Milvus

Qdrant, Weaviate and Milvus all fit self-hosted RAG, but they differ in footprint, license edges and operating effort. This page shows which one fits your data size and team.

On this page

Qdrant vs Weaviate vs Milvus: which fits your data size and team

For a team choosing a self-hosted vector store for retrieval-augmented generation inside its own infrastructure, the choice turns on three things: corpus size, how much operating capacity the team actually has, and how much enterprise security must be licensed on top of the open-source core. Qdrant is a single Rust service that scales by sharding and replication, and it is Apache-2.0 licensed. Weaviate has a BSD-3-Clause core with built-in hybrid search (vector plus BM25 keyword filtering) and built-in vectorization, but its enterprise features sit in a separate directory under a Weaviate enterprise license and are enabled by a license key. Milvus is Apache-2.0 licensed and is a disaggregated cluster that depends on etcd for metadata, object storage such as MinIO, S3 or Azure Blob, and a write-ahead log such as Woodpecker, Kafka or Pulsar.

Milvus is the heaviest of the three to run, because each of those dependencies is a service your team must provision, secure, back up and upgrade. Its Distributed mode is designed for large collections, while its Standalone and Milvus Lite modes exist for smaller footprints. Qdrant asks for less: it needs block-level storage with a POSIX-compatible file system (not NFS or S3) and SSD or NVMe drives, and its distributed mode is built on Raft for cluster topology. Weaviate sits between the two in dependency count, and its replication is leaderless and off by default, so it has to be enabled per collection. In all three cases, the open-source core is free to self-host, and the costs that scale with the team are operations, security hardening and enterprise features.

Before you shortlist, confirm three points in writing with each vendor: which security features your deployment needs and whether they are in the open-source core or behind a license, how your expected corpus size maps to the node count and shard plan you will run, and who on your team will own upgrades for every service in the stack. Qdrant's security docs state that self-deployed instances listen on all interfaces with no authentication by default, so configure API keys and TLS before any network exposure. The detailed feature and migration comparison between two of these products is covered in the sibling sections of this page.

Which vector database fits which scenario

This table matches each common deployment scenario to the vector database that fits it best and the condition that makes that choice hold. Read each row against your own corpus growth, storage platform and operations team, since the condition matters more than the label.

ScenarioBest fitCondition that makes it the fit
Small prototype on one machineMilvus Lite or Qdrant single nodeMilvus Lite runs as a Python library and Standalone covers a single machine. Qdrant on one node also works if the host has SSD or NVMe block storage, since Qdrant cannot run on NFS or S3-style object storage.
Mid-sized RAG service on a small clusterQdrantChoose Qdrant when you want one Rust binary to scale by sharding and replication, and you can plan at least three nodes for quorum with block storage on each node.
Large multi-tenant corpusMilvusChoose Milvus when you need multi-tenancy at database, collection, partition or partition key level and can run etcd, object storage and a write-ahead log such as Woodpecker, Kafka or Pulsar.
Team that already runs Kubernetes operatorsMilvus or WeaviateMilvus Distributed is Kubernetes-native, and Weaviate documents Kubernetes as an install path. Qdrant's enterprise Kubernetes operator comes with Qdrant Private Cloud, while its community Helm chart lacks zero-downtime upgrades and automatic shard rebalancing. Confirm which operator features your contract includes.
Team that wants built-in vectorizationWeaviateWeaviate can vectorize at import time through integrated model providers such as OpenAI, Cohere and Hugging Face. Qdrant and Milvus expect pre-computed embeddings in your pipeline, so budget the embedding service yourself.
Team that needs access control on a self-hosted clusterWeaviate or QdrantBoth offer API keys, TLS and role controls. Weaviate has RBAC and OIDC in its authentication docs, and Qdrant has JWT per-collection permissions and audit logging. Confirm which of these features sit under a commercial license for your edition.

What is free and what is paid in each platform

The Qdrant engine is Apache-2.0 licensed and the open-source engine is free to self-host, according to the project's repository and pricing page. The commercial choices sit around the engine rather than inside the license. Qdrant Cloud has a free single-node tier with 0.5 vCPU, 1 GB RAM and 4 GB disk, a usage-priced Standard tier and a Premium tier with a minimum spend. Qdrant Hybrid Cloud runs managed clusters on your own infrastructure, and Qdrant Private Cloud is a dedicated, fully isolated enterprise deployment. Both are priced through Qdrant sales.

  • Engine license: Apache-2.0 for the self-hosted engine, with no license key required for the core product.
  • Cloud tiers: a free single-node tier, a usage-priced Standard tier with a 99.5% uptime SLA and a Premium tier with SSO, private VPC links and a 99.9% uptime SLA.
  • Hybrid and Private Cloud: managed or dedicated deployments priced through sales, with no public price list in the sources reviewed.
  • Enterprise Kubernetes operator: offered as part of Qdrant Private Cloud, while the community Helm chart lacks features such as zero-downtime upgrades and automatic shard rebalancing.

Confirm with Qdrant which features in your target tier are included in writing, including SSO, audit and support terms, and whether the operator is bundled with your contract.

How the architecture changes what you run

The three databases differ most in what must be running before queries and writes succeed. Qdrant's distributed mode uses Raft consensus for cluster topology and collection structure, splits each collection into shards across nodes, and keeps extra copies through a replication factor, which doubles storage at a factor of 2. Qdrant's distributed deployment docs recommend at least three nodes for production so quorum survives a node failure, with a shard count that is a multiple of the node count. Storage is the other constraint: Qdrant needs block-level storage with a POSIX-compatible file system and cannot use NFS or S3 as primary storage, with SSD or NVMe recommended. Before sizing, confirm that your storage class meets this requirement, because it decides whether Qdrant can run on your existing infrastructure at all.

Weaviate's replication is leaderless, disabled by default, and enabled per collection with a replication factor. Consistency is tunable at query time through ONE, QUORUM and ALL, so the choice is a per-workload decision rather than a single cluster setting. The practical risk is the default: a team that deploys Weaviate and creates collections without configuring replication runs without replicas. Weaviate's operational footprint is a single server type, but its replication and consistency behavior lives in collection definitions and application queries. Your backup and monitoring plans should cover each collection's replication settings, and you should confirm with Weaviate how those settings are checked after upgrades.

Milvus separates storage from compute more explicitly than either alternative. Its distributed architecture includes stateless proxies, a coordinator and worker nodes, with etcd holding metadata, MinIO, S3 or Azure Blob holding objects, and Woodpecker, Kafka or Pulsar acting as the write-ahead log. Each of these is a separate dependency with its own failure modes, sizing, backup path and monitoring. The Milvus architecture overview documents how these pieces interact. Milvus Lite and Standalone reduce this count for smaller workloads, but the team should choose a write-ahead log and object store early and list the owner of each component before committing to the distributed mode.

Which security controls each platform ships with

Each of the three platforms ships with a different security starting point, and none of them should go live with its defaults. The cards below cover what must be switched on before any data arrives, which controls are enterprise or license-gated, and what to confirm with each vendor before you sign off on access design.

Qdrant starts with no authentication

The Qdrant security documentation states that self-deployed instances listen on all network interfaces and have no authentication configured by default. Before any data is loaded, restrict network exposure and set an API key, so that the instance is never reachable without credentials. Treat this as a day one gate in your build checklist, not a hardening step for later. Confirm that your deployment method (Helm chart, operator or manual install) applies the same settings.

Qdrant API keys and TLS

Qdrant supports admin and read-only API keys, and TLS for both REST and gRPC. Use the read-only key for query services and keep the admin key out of application configuration. Terminate or encrypt traffic between clients, nodes and the cluster, and document where certificates are issued and rotated. Confirm with Qdrant how key rotation is handled in your chosen deployment model.

Qdrant JWT and audit logging

Qdrant's JWT-based access control grants read or write permissions per collection, which matters when several teams or tenants share one cluster. JSON audit logging of authenticated API operations arrived in v1.17.0. Map each application identity to the collections it needs, and ship the audit log to your existing retention and review process. Ask Qdrant whether per-collection JWT rules are the same across Cloud, Hybrid and self-hosted deployments.

Weaviate API keys, OIDC and RBAC

Self-hosted Weaviate supports API key authentication, OIDC and a user management API that assigns custom roles through RBAC. Anonymous access is available but discouraged outside development, so disable it in any shared environment. Decide whether your identity provider will issue OIDC tokens for service accounts and users, and map roles to collections before go-live. Confirm with Weaviate which RBAC scopes are available in the edition you plan to run.

Weaviate license-gated features

Weaviate's core source is BSD-3-Clause, but code in the repository's wl directory is available only under a separate enterprise license, and enterprise features are enabled by a license key. Before you assume a control is available, check whether it sits in the open core or behind the key. Ask Weaviate for a written statement of which access and audit controls require the enterprise license, and budget for that in the quote.

Milvus authentication, TLS and RBAC

Milvus documents authentication, TLS encryption and role-based access control as part of its platform. Enable authentication and TLS on the proxy layer before exposing it to applications, and define roles that separate schema administration from read and write access per database or collection. Its disaggregated design means etcd, object storage and the write-ahead log also hold sensitive data, so encrypt and restrict them too. Confirm with the Milvus maintainers which controls are covered in both the 2.6 and 3.0 release lines.

What implementing each platform involves

Implementation effort starts with the deployment path you pick, and the three platforms offer very different routes. Qdrant runs as a single binary in Docker, and the documented production paths are the managed Qdrant Cloud, a community-supported Kubernetes Helm chart and an enterprise Kubernetes operator that comes with Qdrant Private Cloud. The Helm chart does not include enterprise features such as zero-downtime upgrades and automatic shard rebalancing, so a self-hosted team on the open-source path should confirm which of those operations it will perform by hand. Weaviate's README lists Docker, Kubernetes and Weaviate Cloud as installation options, which makes the first deployment straightforward, but the production choices sit in the configuration. Milvus has three modes: Milvus Lite as a Python library for prototyping, Standalone on one machine, and Distributed as a Kubernetes-native cluster. Standalone is not a substitute for Distributed when you need separate scaling of components, so decide the mode before the first build, not after.

Securing the defaults is the first task on every platform, and the gap is widest on Qdrant. The Qdrant security documentation states that self-deployed instances listen on all network interfaces and have no authentication configured by default, so the team must set API keys, enable TLS and restrict network exposure before any data is loaded. Weaviate's self-hosted authentication offers API key, OIDC and anonymous access, with anonymous access discouraged outside development, and its RBAC API assigns custom roles. Milvus documents authentication, TLS and role-based access control. In each case, confirm the controls in your own environment, run a scan against the deployed endpoints and record the result as evidence. Sizing storage is the next decision. Qdrant needs block-level storage with a POSIX-compatible file system and cannot use NFS or S3, with SSD or NVMe recommended. Milvus Distributed separates object storage (MinIO, S3 or Azure Blob), metadata in etcd and a write-ahead log, so each of those services becomes a component you must size, back up and monitor.

Shard and replica planning and later migration are where early choices become expensive. Qdrant's distributed mode uses Raft for cluster topology, splits collections into shards and stores extra copies through a replication factor, which doubles storage at a factor of 2. The documentation recommends at least three nodes for production so quorum survives a node failure, and a shard count that is a multiple of the node count. Weaviate replication is disabled by default and set per collection with a replication factor, and consistency levels are chosen at query time, so the team must decide these per collection before loading. Milvus shards and partitions are set through its collection and partition design. Migration is cheaper when the collection schema, payload fields and embedding model version are documented before the first load, because moving between vector stores usually means re-indexing from source data. Ask each vendor or your implementation partner for the export and import path for your data size and confirm it in a test environment first.

How to choose and validate a vector store in four steps

This sequence moves a team from shortlist to signed scope by testing corpus size, security requirements, licensing and retrieval quality on its own data before any implementation work is committed.

  1. Define corpus size and filter needs

    Write down the expected number of vectors, the vector dimensions your embedding model produces, the query rate, and the metadata fields users will filter on, such as tenant, document owner or date. Owners are the RAG product lead and the platform engineer who will run the cluster. Done means you have a one-page sheet that states whether you need a single node or a distributed cluster, and which filters must be applied during search rather than after it. Ask each vendor how filtering interacts with its index before you rely on it.

  2. Confirm required security features and their licenses

    Have the security team list the controls it must see before approval, such as API key or OIDC authentication, role-based access, per-collection permissions, TLS on all client paths and audit logging of API operations. Then check each control against the license of the exact build you plan to run. Weaviate places some features in code under a separate enterprise license enabled by a license key, and Milvus and Qdrant documentation describe their own authentication and access controls, so confirm which edition includes what. Done means a signed-off checklist with the license source for each item.

  3. Map the deployment and operating footprint

    Compare what each option needs to run in your environment. Qdrant needs block storage with a POSIX-compatible file system and does not run on NFS or S3, and its distributed docs recommend at least three nodes for quorum. Milvus Distributed depends on etcd, object storage and a write-ahead log such as Woodpecker, Kafka or Pulsar. Weaviate replication is disabled by default and must be enabled per collection. Platform engineers own this step. Done means a list of every stateful service you would operate, with the team that will be paged for each.

  4. Benchmark on your own data with planned replication

    Load a representative sample of your own embeddings and metadata into each shortlisted option using the replication factor and consistency settings you expect to run in production. Measure recall against a known-good answer set, query latency under your expected concurrency, and memory use with the quantization setting you intend to keep. Repeat any test that changes replication, because a factor of 2 doubles stored data in Qdrant and consistency levels change Weaviate results. Done means a short written report with the same test set run against every candidate, and a recommendation you can defend to the security and finance reviewers.

  5. Get a written scope before implementation

    Once a candidate is chosen, ask DeployOpen or another implementer for a fixed-scope written proposal that lists the deployment target, the security controls to configure, the backup and upgrade process, the data migration plan and the documentation you will receive. Include what your team must provide, such as network access, storage classes and identity provider details. DeployOpen agrees scope, deliverables and timelines in writing before work starts and does not publish a price list, so the quote follows from this document. Done means a signed scope that matches the benchmark and checklist from the earlier steps.

Questions buyers ask before choosing a vector database

Which of the three vector databases costs the least to run?

No single answer holds for every team, because the bill depends on who operates the cluster and how much infrastructure it needs. Qdrant's open-source engine is Apache-2.0 and free to self-host, so its recurring cost is mainly the nodes, block storage and the engineering time to run them. Weaviate's core is BSD-3-Clause, but features inside its enterprise directory need a license key, so confirm which capabilities your RBAC, OIDC and replication requirements depend on. Milvus is Apache-2.0 but its distributed mode adds etcd, object storage and a write-ahead log to operate. Ask each vendor for a written list of components and paid features you would need in production, then price those against your data volume and staffing.

How much effort does self-hosting a vector database take?

Effort scales with the number of moving parts. Qdrant runs as a single binary, but its documentation requires block-level storage with a POSIX-compatible file system, so NFS and S3 are not options, and it recommends SSD or NVMe drives. Its distributed mode uses Raft and needs at least three nodes for production quorum. Milvus Distributed is a Kubernetes-native system with stateless proxies, coordinators, worker nodes, etcd, object storage and a write-ahead log, which is the largest footprint of the three. Weaviate is leaderless for replication and offers Docker and Kubernetes installs, so its operating load sits between the two. Your team should estimate effort from the components in the target design, not from the first install.

Can our team run one of these without outside help?

It depends on your Kubernetes and storage experience and on how much production hardening you need. A team that already operates stateful workloads on Kubernetes can usually run Qdrant or Weaviate from the official documentation, while Milvus Distributed asks for more depth in etcd, object storage and messaging. Qdrant's documentation notes that the community Helm chart lacks enterprise features such as zero-downtime upgrades and automatic shard rebalancing, so plan who performs those tasks by hand. DeployOpen plans, implements, hardens, backs up, upgrades and documents self-hosted open-source platforms in your infrastructure, and supports them through retainers. Ask for a written scope listing the platform tasks your staff will keep.

How long does implementation take, and what drives that time?

No researched figure exists for implementation duration on these three platforms, so ask for a timeline in the written scope rather than relying on a general estimate. The main drivers are the target architecture (single node or cluster), the storage and network approvals in your infrastructure, the identity integration for access control, the size and format of the embeddings you will migrate, and the number of collections and tenants. Security testing and compliance evidence add time if your auditors need them. DeployOpen engagements are typically fixed-scope, so scope, deliverables and timelines are agreed in writing before work starts.

What does the work need from our infrastructure team?

Your infrastructure team usually provides the compute, block storage, network segmentation, DNS, TLS certificates, backup targets and identity connections. For Qdrant, that means SSD or NVMe volumes with a POSIX-compatible file system, because the documentation rules out NFS and S3. For Milvus Distributed, it means running or allocating etcd, S3, Azure Blob or MinIO storage and a write-ahead log such as Woodpecker, Kafka or Pulsar. For Weaviate, it means API key or OIDC setup and an RBAC model. Note also that self-deployed Qdrant listens on all interfaces with no authentication by default, so network policy and API keys must be in place before any data is loaded.

When should we move from one node to a cluster?

Move to a cluster when a single node can no longer meet your availability target or when collection size and query load exceed what one machine handles with acceptable latency. Qdrant's distributed docs recommend at least three nodes for production so quorum survives a node failure, and a shard count that is a multiple of the node count. Replication doubles storage at a replication factor of 2, so storage planning must include copies. Test with your own embeddings and filters, since no supplied figure sets a universal threshold. Plan the cluster before growth forces a migration, because resharding is a manual task on self-hosted clusters.

How do we switch vector databases later without losing the index?

Switching cost comes from re-embedding data, rewriting client code and rebuilding filters, not from copying vectors alone. Keep your embedding pipeline and source documents outside the database so you can re-index into another store. Export payloads and vectors in a format you control, and record the distance metric, index settings and filter schema for each collection. Qdrant publishes a migration tool and snapshot documentation, and Weaviate and Milvus have their own import paths; confirm each tool's current behavior against the vendor documentation before you commit. Run both stores in parallel on a sample of queries and compare recall before cutting over.

When outside help changes the outcome

The choice between Qdrant, Weaviate and Milvus is easier to make well when you know what an outside partner would and would not do for you. DeployOpen plans, implements, hardens, backs up, upgrades and documents self-hosted platforms inside your own cloud accounts, data centers or air-gapped networks, so the vector store you pick would run in your infrastructure under your keys, your identity provider and your backup policy. Most engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts. That makes it practical to ask a partner to stand up one of these engines, but it also means the decision should be settled before the statement of work is written.

Let your data and team drive the pick, not a DeployOpen preference. The questions that matter are concrete: how many vectors you expect to hold and how fast they grow, whether you need metadata filtering with access control on each query, whether you can run a three-node cluster with block storage, and whether your staff already operate etcd and an object store, as a Milvus deployment requires. If your team is small and a single service is enough, a narrower scope for one engine is usually easier to price and verify than a broad platform project. Ask any partner to show how the chosen engine's authentication, TLS and role settings will be configured, because Qdrant's security documentation states that self-deployed instances are not secure by default. DeployOpen does not issue audit reports, attestations or certifications. If your compliance program needs evidence about access control, logging or backup for a vector store, DeployOpen can prepare the configurations, controls and records that an independent auditor or certification body would review, but the assessment itself comes from that auditor. Confirm with your assessor which evidence they will accept, such as exported audit logs or documented role assignments, before you commit to a design. Ask any provider for their written deliverables, the acceptance criteria and who keeps the runbooks after handover.

How DeployOpen helps choose and implement a vector database

DeployOpen is a Chainscore Labs company that plans, implements, hardens, documents and supports self-hosted open-source platforms inside the client's own infrastructure. For a vector database decision, we start from your corpus, filtering needs, access model and the team that will operate the cluster, then build and hand over the option that fits.

How we scope

  • We confirm the document count, embedding dimensions, filter fields and query patterns before naming a candidate.
  • The written scope states which deployment path applies, such as Qdrant's Helm chart, Weaviate on Kubernetes or Milvus Standalone or Distributed.
  • We list which licensed features you need, such as Weaviate OIDC or Qdrant JWT access control, so license terms are settled before build.
  • Engagements are fixed-scope, with deliverables and timelines agreed in writing before work starts.

How we build

  • We deploy inside your cloud account, data center or air-gapped network, with storage that meets each database's documented requirements.
  • We configure authentication, TLS and role-based access, since Qdrant and Weaviate ship without auth enabled by default in self-deployed setups.
  • We set replication factors, shard counts and node counts against your availability target, and test failover before handover.
  • We run retrieval tests on your own data to compare recall, latency and filtering behavior across the candidates in scope.

How we hand over

  • We document the cluster topology, backup and snapshot procedures, upgrade steps and the access model for your operators.
  • We deliver runbooks for scaling, resharding or rebalancing, written for the mechanisms your chosen database actually uses.
  • We train your platform and security staff on day-two operations so the system does not depend on one engineer.
  • We package evidence of configuration, access controls and tests that your auditors or internal reviewers can examine.

How we support

  • Ongoing support, upgrades and continuous testing are available as retainers after handover.
  • Retainers can cover version upgrades, such as moving between the release lines your chosen vendor maintains.
  • Periodic security testing of the retrieval API and its access controls can run alongside routine operations.
  • Ask any vendor or integrator to confirm license terms, enterprise feature availability and support windows in writing before you sign.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.