Best Self-Hosted Vector Databases (2026): Qdrant, Weaviate, Milvus, pgvector & Chroma

If you want a vector database you can run yourself — on your own VPS, in your own Kubernetes cluster, behind your own firewall — the five strongest open-source options in 2026 are Qdrant, Weaviate, Milvus, pgvector, and Chroma. For most teams the best default is Qdrant (fast, Apache-2.0, single Docker image, native hybrid search). If your data already lives in PostgreSQL, pgvector is the pragmatic winner. This guide compares all five honestly through the self-hosting lens — license, implementation language, GitHub traction, hybrid-search support, and how painful each is to operate — then gives recommendations by use case.

This is the comparison hub for vector databases. If you’re still deciding whether you need a dedicated vector store at all, start with the conceptual background, then come back here to choose an engine.

▶ Run it yourself — aquila-starter is the one-command, fully self-hosted version of this guide: Ollama + Qdrant + FastAPI via docker compose up. Fork it and make it your own.

The contenders at a glance

All five are genuinely open-source and genuinely self-hostable — that was the filter for this list. Hosted-only services like Pinecone are deliberately excluded; this is about search you own. (For the managed-vs-self-hosted cost question specifically, see our self-hosted RAG vs OpenAI + Pinecone cost breakdown.)

Engine	License	Core language	GitHub stars (June 2026)	Hybrid search	Self-host story
Qdrant	Apache-2.0	Rust	32.4k	Yes — native dense + sparse, RRF/fusion in one query	Single Docker image; single-node or distributed/clustered
Weaviate	BSD-3-Clause	Go	16.3k	Yes — vector + BM25 with fusion in one query	Docker / docker-compose; Kubernetes + Helm for production
Milvus	Apache-2.0	Go core + C++ engine	44.8k	Yes — dense + sparse + full-text in one collection	Milvus Lite (embedded), Standalone (Docker), distributed (K8s)
pgvector	PostgreSQL License (BSD-style)	C	21.8k	Partial / DIY — vector + Postgres full-text in SQL	CREATE EXTENSION vector; on any Postgres; Docker, APT/YUM, source
Chroma	Apache-2.0	Rust core (+ Python/TS/Go)	28.5k	Yes — repo lists vector, hybrid and full-text search	Embedded library (pip install chromadb) or client-server + Docker

Star counts are GitHub’s rounded figures as of June 2026 and will drift — treat them as a rough proxy for community size, not a ranking. License and language, by contrast, are stable facts worth weighting heavily.

License: the one to read before you commit

For a self-hosted deployment the license is the first thing to check, because it governs what you can build on top.

• Apache-2.0 — Qdrant, Milvus, Chroma. Permissive; you can embed and ship commercial products with no copyleft obligations. The safest default for most companies.
• BSD-3-Clause — Weaviate. Also permissive, very similar in practice to Apache-2.0 for downstream use.
• PostgreSQL License — pgvector. A permissive, BSD-style license inherited from the Postgres ecosystem. No copyleft.

Notably, none of the five core projects here is copyleft (GPL/AGPL), which makes all of them comfortable to embed. (That’s a meaningful contrast with some AI-search tools like Khoj or SearXNG, which are AGPL-3.0.) If license cleanliness is a hard requirement, any of these five is fine — the differentiator is elsewhere.

Performance and latency

Be skeptical of vector-DB benchmarks, including the vendors’ own — recall, dataset, dimensionality, filter selectivity, and hardware all swing the numbers, and most published benchmarks are run by the vendor that wins them. With that caveat, here is what each project actually claims (first-party where noted):

• Qdrant publishes benchmarks claiming the highest requests-per-second and lowest latency in most scenarios, roughly 4× RPS on one dataset, and an edge on filtered search. Note the benchmark data was last refreshed in 2024.
• Milvus claims (for Milvus 2.6) roughly 72% memory reduction with ~4× throughput on a 1M × 768-dim VectorDBBench run, and 3–4× (up to ~7×) higher full-text throughput vs Elasticsearch at equal recall. It’s built for very large scale.
• Weaviate publishes an ANN benchmark reporting end-to-end p99 latency and QPS-vs-recall curves — interactive, with no single headline number, which is arguably the more honest format.
• pgvector ships no first-party benchmark (it’s an extension). Third-party numbers exist — AWS reports HNSW builds up to ~30× faster in pgvector 0.7 on Aurora; Supabase reports its own HNSW speedups — but absolute latency is entirely host- and config-dependent. Treat these as vendor numbers, not pgvector’s own claims.
• Chroma has no canonical first-party latency benchmark we could verify. Don’t trust any specific Chroma latency figure presented as official.

The honest summary: Qdrant and Milvus are the performance/scale leaders by their own benchmarks; Weaviate is competitive; pgvector’s speed depends on your Postgres host and is excellent for moderate scale; Chroma is optimized for developer experience over raw throughput. For anything below a few million vectors, all five will feel fast on decent hardware — performance only becomes the deciding factor at scale.

Hybrid search

“Hybrid search” — combining dense vector similarity with sparse/keyword (BM25-style) matching — is increasingly table stakes, because pure vector search misses exact keywords, IDs, and rare terms. Here’s where the five differ most:

• Qdrant — native hybrid: dense + sparse vectors, multiple named vectors per point, and configurable fusion (e.g. Reciprocal Rank Fusion) in a single query.
• Milvus — semantic + full-text, with sparse and dense vectors in one collection.
• Weaviate — built-in vector + BM25 keyword search with fusion ranking, in a single query.
• Chroma — the repo lists “vector, hybrid, and full-text search.”
• pgvector — partial / DIY. pgvector gives you vector search (and a sparsevec type), but hybrid is something you assemble yourself by combining it with Postgres full-text search (tsvector) in SQL. There’s no single built-in hybrid operator. That’s more work, but it’s also more transparent and uses tooling you already know.

If hybrid search out of the box matters to you, Qdrant, Weaviate, and Milvus are the cleanest. With pgvector you can absolutely do hybrid, you just hand-roll the fusion.

Self-hosting and operations

This is the section that actually matters for “search you own.” The question isn’t just can you self-host — all five can — it’s how much operational weight each one carries.

• pgvector — lightest if you already run Postgres. It’s CREATE EXTENSION vector; on a database you (probably) already operate, back up, and monitor. Zero new infrastructure. If you don’t already run Postgres, you’re now operating Postgres, which is well-trodden but non-trivial.
• Chroma — lightest to start, period. pip install chromadb and it runs in-process with local persistence — no server at all. There’s an optional client-server mode and an official Docker image when you outgrow embedded. Ideal for prototypes and single-app use; less proven as a standalone production cluster.
• Qdrant — best single-binary/Docker experience for a dedicated engine. One official qdrant/qdrant image, runs single-node out of the box, scales to distributed/clustered when needed. This is the sweet spot for “I want a real vector DB without a Kubernetes project.”
• Weaviate — Docker/compose for dev, Kubernetes + Helm for production. More moving parts (modules, vectorizers), which is power if you want it and overhead if you don’t.
• Milvus — most operationally heavy at scale. It offers Milvus Lite (embedded, pip install) and Standalone (Docker) for small deployments, but its distributed mode is a multi-component system (it relies on object storage, a message queue, etc.) designed for billion-scale workloads and best run on Kubernetes. Powerful, but the heaviest to operate of the five.

A useful mental model: operational weight roughly tracks how big the system was designed to scale. Chroma and pgvector are light because they target the small-to-medium end; Milvus is heavy because it targets the very large end; Qdrant and Weaviate sit in the productive middle.

Cost and pricing

When you self-host an open-source vector DB, the software is free — your cost is the compute and storage you run it on. That’s the entire pitch of search you own: a predictable flat infrastructure bill instead of usage-metered managed pricing. A small-to-medium index runs comfortably on a modest VPS.

Each project also offers a managed cloud, which is useful as a fallback or for comparison — but note these are the hosted prices, not what self-hosting costs you:

• Qdrant Cloud — perpetual free tier (1-node, 0.5 vCPU / 1 GB RAM / 4 GB disk); paid Standard is usage-based via a calculator with no fixed published entry price.
• Weaviate Cloud — free Serverless Sandbox; paid “Flex” from ~$45/mo, pay-as-you-go (vector storage from ~$0.00465 per 1M dimensions, varies).
• Milvus / Zilliz Cloud — free tier (~5 GB + 2.5M vCUs/mo); serverless pay-as-you-go ($4 per 1M vCUs; storage $0.04/GB-mo); dedicated clusters from ~$99/mo (the dedicated entry price renders dynamically and is approximate).
• pgvector — there is no “pgvector Cloud.” It’s enabled by any managed Postgres (AWS RDS/Aurora, Google Cloud SQL/AlloyDB, Supabase, Neon, etc.), so your price is simply the host Postgres price.
• Chroma Cloud — serverless, Starter $0/mo + usage (free credits); usage billed at writes $2.50/GiB, storage $0.33/GiB-mo, queries $0.0075/TiB, egress $0.09/GiB; Team $250/mo + usage.

The takeaway for self-hosters: ignore the managed price tags and think in terms of the box you’ll run it on. A ~$20–30/mo VPS (DigitalOcean-class; cheaper on Hetzner) comfortably hosts pgvector, Chroma, Qdrant, or single-node Weaviate for a small-to-medium index. Milvus distributed and large indexes want more — that’s the tier where you should genuinely price out the hardware.

When to pick which

• Best all-round default → Qdrant. Apache-2.0, fast, native hybrid search, and the cleanest single-image self-host story for a dedicated engine. If you have no strong reason to choose otherwise, start here. (See the head-to-heads: Qdrant vs Weaviate and pgvector vs Qdrant.)
• Already on Postgres → pgvector. If your app’s data is in PostgreSQL, adding CREATE EXTENSION vector; is the lowest-friction path to vector search. No new service to run, back up, or monitor. Hybrid is DIY but doable.
• Prototyping / a single app’s embeddings → Chroma. pip install chromadb and you’re indexing in minutes, in-process. Graduate to a heavier engine if and when you outgrow it.
• Billion-scale / very large workloads → Milvus. Purpose-built for massive scale with the strongest large-scale throughput claims. Accept the operational weight of its distributed mode.
• Batteries-included with built-in modules → Weaviate. If you want vectorizers, hybrid, and an opinionated module ecosystem in one package and don’t mind Kubernetes for production, Weaviate is a strong pick.

Verdict

For most teams self-hosting in 2026, Qdrant is the best general-purpose choice — permissive license, strong performance, native hybrid search, and a Docker-first deploy that doesn’t demand a platform team. pgvector wins on pure pragmatism whenever you already operate Postgres, trading some hybrid-search convenience for zero new infrastructure. Chroma is the fastest way to get started and is excellent for prototypes and single-app embeddings. Milvus is the answer at billion-scale. Weaviate is the batteries-included middle ground if you want modules and hybrid out of the box. There’s no universally “best” vector database — there’s the best one for your license constraints, your existing stack, and your scale.

FAQ

What is the best open-source vector database to self-host in 2026? For most teams, Qdrant — it’s Apache-2.0 licensed, fast, supports native hybrid search, and ships as a single Docker image that runs single-node out of the box and scales to a cluster. If you already run PostgreSQL, pgvector is the more pragmatic pick because it adds vector search without any new infrastructure.

Which self-hosted vector database is easiest to run? Chroma is the lightest to start (pip install chromadb, runs in-process with local persistence). pgvector is the lightest if you already operate Postgres, since it’s just an extension. For a dedicated engine, Qdrant has the cleanest single-Docker-image experience.

Do all of these support hybrid search? Qdrant, Weaviate, Milvus, and Chroma offer hybrid (dense + sparse/keyword) search out of the box. pgvector can do hybrid too, but you assemble it yourself by combining pgvector with Postgres full-text search in SQL — there’s no single built-in hybrid operator.

Is self-hosting a vector database cheaper than a managed service like Pinecone? Usually yes for predictable workloads, because self-hosting turns a usage-metered bill into a flat infrastructure cost — a small-to-medium index runs fine on a ~$20–30/mo VPS. The trade is that you take on the operations. See our self-hosted RAG vs OpenAI + Pinecone cost breakdown for the full picture (and note the headline figures there are labelled illustrative).

Which vector database scales the largest? Milvus is purpose-built for billion-scale workloads and has the strongest large-scale throughput claims (via its distributed, Kubernetes-based mode), at the cost of being the heaviest of the five to operate.

---

Aquila is the independent guide to private, self-hosted AI search — search you own instead of rent. Go deeper with the head-to-heads on Qdrant vs Weaviate and pgvector vs Qdrant, or browse all comparisons. Own your search.