Qdrant vs Weaviate vs Chroma: the open-source vector database call for a RAG app (2026)

Every RAG app in the ShipGarden gallery hits the same wall. The retrieval demo works on a laptop, the embeddings are flowing, and then you have to pick where the vectors actually live. Three open-source names keep coming up, and unlike the hosted-only options, all three are ones you can run yourself: Qdrant, Weaviate, and Chroma.

We test the building blocks so we can own the stack that funds the life, and a vector store is one you do not want to re-pick six months in. So this is the honest curator call: not "which is best" (none wins everywhere), but which of the three earns the shelf spot for your app, at your stage, on the criteria that actually change the decision.

Quick answer (July 2026)

For a self-hosted open-source vector database in 2026, pick by shape, not by leaderboard. Chroma is the fastest start because it runs embedded inside your app process, so a prototype needs zero extra infrastructure. Qdrant is the lean production pick: a single Rust binary with strong filtering and low memory, comfortable on a small VPS. Weaviate is the batteries-included server when you want built-in hybrid search and a module ecosystem, at a higher memory and ops cost. And if you already run Postgres, pgvector may beat all three for under a million vectors, because it adds no new service. All three are permissively licensed (Qdrant and Chroma Apache-2.0, Weaviate BSD-3), so there is no copyleft trap here.

The three you can actually run yourself

Qdrant (github.com/qdrant/qdrant, ~33.5k stars, Apache-2.0, July 2026) is a dedicated vector search engine written in Rust. It ships as a single binary, keeps memory low, and its calling card is fast, precise filtering alongside the vector search. The latest release is v1.18.3 (July 17, 2026), and the repo is pushed to daily.

Weaviate (github.com/weaviate/weaviate, ~16.6k stars, BSD-3-Clause, July 2026) is a Go server that stores objects and vectors together and bakes in hybrid (keyword plus vector) search and a module system for vectorizers and rerankers. Latest release v1.38.6 (July 21, 2026), also active daily. You get more out of the box; you also run a heavier process.

Chroma (github.com/chroma-core/chroma, ~28.8k stars, Apache-2.0, July 2026) started as the "just works in a notebook" store and rewrote its core in Rust. Its differentiator is that it runs embedded, in-process, persisting to local disk, so a prototype needs no separate server at all. It also runs as a client-server database when you outgrow that. Latest tagged release 1.5.9 (May 5, 2026).

How do they compare at a glance?

What does self-hosting actually cost?

This is where the gallery lens matters, because the sticker on the managed cloud is not the number most indie teams pay. All three are free to self-host. The real cost is the box you run them on.

• Chroma embedded: effectively $0 of new infrastructure. It runs inside the app you already deploy and persists to disk. Split it into its own small server later and a $5 to $6 per month VPS covers early loads.
• Qdrant: a single Rust binary with a low memory floor. A $5 to $10 per month VPS with 1 to 2 GB of RAM comfortably holds a few hundred thousand vectors before you think about scaling.
• Weaviate: heavier by design. Once you enable modules, the baseline RAM climbs, so budget a 4 to 8 GB box in the $20 to $40 per month range for a realistic production start.

Those are pragmatic rules of thumb, not a benchmark; your real number moves with vector count, dimensions, and how much filtering you do. The point of the ladder is that the order of magnitude is different, and for a bootstrapped app the difference between a $6 box and a $40 box is a decision, not a rounding error.

What does the managed cloud cost if you skip the ops?

If you would rather not run the box, here is the honest 2026 pricing, sourced from each vendor's own page:

• Qdrant Cloud (pricing, July 2026): a free-forever single-node cluster (0.5 vCPU, 1 GB RAM, 4 GB disk) for prototypes; a usage-based Standard tier with dedicated resources and a 99.5% uptime SLA; and a custom Premium tier with SSO and private VPC links.
• Weaviate Cloud (pricing, July 2026): an always-free sandbox (100k objects, 1 GB memory, 10 GB disk, one collection); a pay-as-you-go Flex plan from $45 per month (from $0.00465 per 1M vector dimensions plus $0.12 per GiB storage); and Premium from $400 per month.
• Chroma Cloud (pricing, July 2026): a Starter plan at $0 with $5 of free credits, then usage-based ($2.50 per GiB written, $0.33 per GiB stored monthly, $0.0075 per TiB queried); a Team plan at $250 per month.

Read those models carefully, because they price different things. Weaviate meters vector dimensions and storage, so wide embeddings cost more. Chroma meters writes, storage, and queries separately, which rewards read-heavy retrieval but punishes constant re-indexing. Qdrant leans on dedicated-resource sizing. The cheapest headline is not always the cheapest bill for your traffic shape.

Where does each one lose?

An honest gallery entry says where the thing falls short, so here it is.

• Qdrant gives you the vector engine and little else. There is no built-in object graph or module marketplace; if you want hybrid search or a managed embedding pipeline, you assemble it. Community threads on r/vectordatabase praise its latency but note you own more of the surrounding plumbing.
• Weaviate is the heaviest to run. The module system and object store that make it powerful also make its memory and operational footprint the largest of the three, and practitioners flag that costs climb as you scale.
• Chroma is the easiest to start and the earliest to strain. Embedded mode is a joy for a prototype, but for high-concurrency production you move to its server mode and give up the simplicity that sold you. Its tagged release cadence is also slower than the other two.

Do you even need a dedicated vector database?

The move most roundups skip: if you already run Postgres (through Supabase or Neon, say), pgvector (~22.3k stars, PostgreSQL License, July 2026) adds vector similarity search to the database you already operate. For under roughly a million vectors with straightforward filters, that is often the cheapest and lowest-ops answer, because you add zero new services, keep one backup story, and query vectors next to your relational data. We walked the RAG-store trade-off in more depth in our LlamaIndex.TS RAG starter review, and it sits alongside the other backends in the open-source Next.js starter scorecard. Reach for a dedicated vector DB when your vector count, filtering complexity, or query volume genuinely outgrows what Postgres does well.

The call

Prototype today, unsure about scale: start with Chroma embedded and lose nothing. Shipping a lean production RAG app on a small budget: Qdrant is the efficient default. Want hybrid search and modules handed to you and can pay for the RAM: Weaviate earns it. Already on Postgres and under a million vectors: try pgvector before you add a service you will have to babysit.

Your move: pick the one whose failure mode you can live with, not the one with the shiniest benchmark.