Analytics cookies only (Google Analytics, PostHog). No ad networks, no cross-site tracking. See our privacy policy.
upstream: github.com/milvus-io/milvus (opens in new tab) · github.com/qdrant/qdrant (opens in new tab)
Pick Qdrant
If you want the smallest deployment: one Apache-2.0 container, an API key, a dashboard, payload filters and quantization from 4x to 64x, with Raft clustering across plain servers later.
Pick Milvus
If you expect to outgrow one machine and want to stay on the same system, want its wider index menu (GPU and DiskANN among them) or per-field multi-vector search, or already run Kubernetes, and can spare the 8 GB upstream states for Standalone plus etcd and MinIO.
Milvus and Qdrant are both Apache-2.0 vector databases, and on paper they do the same job: store embeddings, filter on structured fields, return nearest neighbours over gRPC and REST. What differs is the shape you deploy. Qdrant is one Rust container with no separate datastore. Milvus Standalone is a Milvus container that leans on etcd for metadata and MinIO for the data files, a three-service stack that is the small version of a system designed to be taken apart on Kubernetes. If you also read Qdrant vs Weaviate, this is the other half of the vector-database picture in our catalog.
Qdrant runs as a single process that keeps its own storage under
/qdrant/storage. Our install is one service in a compose file. That is the
whole deployment, and it is the main reason we rate it 2 out of 5.
Milvus describes itself in terms of "fully disaggregated storage and compute
layers", and its docs note that "Worker nodes are stateless thanks to separation
of storage and computation." The storage layer "comprises meta storage, log
broker, and object storage". Meta storage uses etcd, and object storage "persists
data and index files" on MinIO, AWS S3 or Azure Blob Storage. For a single
machine, upstream offers Standalone: "a single-machine server deployment",
suited to production on one box when you do not want Kubernetes. By default
Standalone "runs Woodpecker (embedded) as its message queue", so no Kafka or
Pulsar is needed. The compose file we use starts etcd, MinIO, the Milvus
container and a short-lived milvus-volume-init job that fixes data-directory
ownership and exits. Above that sits "Milvus Distributed", which "can be
deployed on Kubernetes clusters" for large-scale production, and below it Milvus
Lite, "a Python library that can be imported into your applications".
That ladder is Milvus's real argument: three deployment modes from one project, from a library to a Kubernetes cluster. The price is that your first VPS install already carries two extra services to back up, upgrade and secure.
Qdrant clusters without extra infrastructure. You enable cluster mode in the
config file or with QDRANT__CLUSTER__ENABLED, and collections are split into
shards. Raft consensus manages cluster metadata (topology and collection
structure), not the points themselves. Turning on distributed mode does not
replicate anything by itself: you set a replication factor of two or more when
you create a collection. Qdrant's docs say a two-node cluster cannot create,
edit or delete collections while one node is down, since those need more than
half the nodes, and recommend three or more nodes with a replication factor of
two or higher for production.
Milvus scales by moving to its distributed deployment on Kubernetes, where components scale and fail over independently. On a VPS that means you are not scaling Milvus at all; you are running Standalone on the biggest single server you are willing to rent. Qdrant gives a self-hoster a path to several plain servers. Milvus gives you a path to a Kubernetes cluster.
Milvus has the longer index menu. Its docs list FLAT, the IVF family, HNSW variants and DISKANN among the vector indexes, plus GPU indexes and a sparse inverted index. The docs suggest FLAT "for the most accurate search results" when a filter excludes over 98% of the data, the HNSW family "excels in high-dimensional spaces and scenarios demanding low-latency queries", and DISKANN stores its graph on disk for datasets too large for memory, best when raw data sits on SSD. You choose an index per field.
Qdrant has fewer knobs and puts its effort into compression and filtering. Its quantization guide covers four methods: TurboQuant, which "supports 4x to 32x compression", scalar quantization, "achieving 4x compression", binary quantization "for up to 32x compression" and product quantization for "up to 64x compression", and it lets you "Keep the original vectors on disk and the quantized vectors in RAM". Payload filters sit in the same query as the vector search.
Both do hybrid retrieval. Milvus "supports this by allowing search on multiple
vector fields", merged with a reranking strategy (it offers RRF and weighted
rankers). Qdrant's Query API fuses sparse and dense queries with rrf or
dbsf, and can pre-fetch candidates with dense vectors and re-score them with a
multi-vector model such as ColBERT.
Neither deserves a public port as shipped. For Qdrant you set an API key
(QDRANT__SERVICE__API_KEY) and clients send it in a header; the dashboard at
/dashboard asks for that key. Our Qdrant snippet sets one.
Milvus's authentication is something you switch on. The docs tell you to set
common.security.authorizationEnabled to true in the Milvus config, and say
that "By default, the root user is created with the password Milvus", so
change that password immediately. Our Milvus snippet does not turn this on, and
publishes ports 19530 (gRPC) and 9091, where the built-in web console lives at
/webui/. The management port is unauthenticated by default, so put both behind
a firewall or reverse proxy before you load real data. The MinIO container in the
stack also ships with credentials; ours are generated into .env.
Milvus is the one with a stated minimum. Its Docker prerequisites list 8 GB of RAM minimum and 16 GB recommended for Standalone, 4 or more CPU cores recommended, a CPU with a SIMD extension (SSE4.2, AVX, AVX2 or AVX-512), and an SSD, adding that "The size of RAM depends on the data volume." Qdrant sets no fixed minimum: its capacity-planning guide sizes RAM per collection from the vector count and dimensions and points to a sizing calculator. The 1 GB floor on our Qdrant page is our own estimate for a small collection.
Our measurement is a different thing from that minimum. On a GCP e2-standard-2 (Ubuntu 26.04, October 2026), idle at first boot with our default install snippet and an empty database, Milvus used ~195 MB of RAM and ~2.4 GB of disk for the whole stack, and Qdrant used ~17 MB of RAM and ~278 MB of disk. Those are empty-database numbers, not load, and they say nothing about how either behaves with millions of vectors. The disk gap is the three images and their volumes. The RAM gap is real but small beside the 8 GB upstream asks of Milvus once data is in.
Qdrant's install is one docker compose up -d and a dashboard URL, difficulty
2 out of 5. Milvus's is 3 out of 5: a four-container compose file, a health
check that only passes once etcd and MinIO are reachable, and a first-start
wait.
Choose Qdrant if you want the smallest possible deployment: one container, an API key, a dashboard, payload filters and quantization from 4x to 64x, with clustering available later across plain servers. It is the better default for most VPS-sized collections.
Choose Milvus if you expect to outgrow one machine and want to stay on the same system when you do, if you want its wider choice of index types (GPU and DiskANN included) or per-field multi-vector search, or if your team already runs Kubernetes. Accept etcd and MinIO as part of the price, and budget for the 8 GB upstream says Standalone needs.
Both installs are verified on Ubuntu 26.04; the pinned compose files are on the
Milvus and Qdrant pages. Qdrant fits
the smallest plan most providers sell while you test; give Milvus the 8 GB
upstream states, a fast disk, and a firewall in front of ports 19530 and 9091.
Back up the Milvus volumes/ directory (Milvus, etcd and MinIO state live there
together), and Qdrant's qdrant_storage directory. For Qdrant, snapshots are
the native route.
Qdrant for most single-server setups: one Apache-2.0 container with its own storage, an API key, a dashboard and quantization, idling at ~17 MB in our first-boot check. Milvus if you expect to scale beyond one machine to Kubernetes, want its wider index choice or multi-vector search, and can run etcd and MinIO beside it on the 8 GB upstream states for Standalone.
Milvus separates storage from compute. Its docs describe meta storage (etcd) for collection schema and checkpoints and object storage (MinIO, S3 or Azure Blob) that persists data and index files; Standalone embeds Woodpecker as its message queue by default. Our compose install starts etcd, MinIO and Milvus together, which is part of why it measured ~2.4 GB of disk against Qdrant's ~278 MB.
Milvus's Docker prerequisites list 8 GB minimum and 16 GB recommended for Standalone, noting RAM depends on data volume. Qdrant sets no fixed minimum and sizes RAM per collection in its capacity-planning guide; our 1 GB floor is our own estimate. In our check on a GCP e2-standard-2, empty and idle, Milvus used ~195 MB and Qdrant ~17 MB. That is not a load test: your vectors will decide the server.
Qdrant can: set cluster mode in config, split collections into shards, and set a replication factor of two or more. Its docs recommend three or more nodes for production, because collection operations need more than half the nodes up. Milvus's distributed mode is deployed on Kubernetes, so on a plain VPS you run Standalone on one server.
Paid link — we earn a commission if you shop through it.
A single-node server that embeds text with a default model for you, or a Rust engine with payload filters, quantization and Raft clustering.
Bring your own vectors to a Rust engine with a dashboard, or let a Go database call the embedding model for you.
A whiteboard-and-docs workspace on a plain Compose file vs. native apps on a commercial server.