Weaviate vs Qdrant: Which Open-Source Vector Database?
November 19, 2026

Weaviate vs Qdrant is a closer fight than most vector database comparisons, because both are open source and both sell a managed cloud. "Can I host it myself?" doesn't separate them. What does is how much each one does for you.
- Pick Weaviate if you want the database to call your embedding model, run the RAG step, and keep thousands of tenants apart with almost no glue code of your own.
- Pick Qdrant if you want a lean engine under one permissive licence, with fine control over filtering and fusion, and a cloud bill tied to the cluster size you chose.
- Either works for a first RAG prototype. Both run in Docker on a laptop and both have a small no-cost cloud cluster.
One time-sensitive point: if you're on Weaviate today, its GraphQL API is being retired. That changes your client code either way, so it's a good moment to compare.
This guide uses only what each vendor's own repo, docs and pricing page say in November 2026. It skips third-party speed benchmarks, which depend on your data and go stale fast.
Quick Comparison
| Weaviate | Qdrant | |
|---|---|---|
| Written in | Go | Rust |
| Licence | BSD-3-Clause, plus a commercial-only wl/ folder | Apache-2.0 |
| Latest stable release | v1.40.5 (November 10, 2026) | v1.20.2 (November 16, 2026) |
| Built-in embedding | Model provider integrations, self-hosted or cloud | Cloud Inference on Qdrant Cloud only |
| Built-in RAG step | Yes, generative integrations | Not in its docs; your code calls the LLM |
| Hybrid search | BM25F plus vectors, one alpha weight | Prefetch sub-queries fused with RRF or DBSF |
| Multi-tenancy | One shard per tenant, with active, inactive and offloaded states | Payload partitioning, with tiered promotion to dedicated shards |
| Managed cloud | Weaviate Cloud, shared or dedicated | Qdrant Cloud on AWS, Azure and GCP |
| Runs in your own infrastructure | Self-hosted Docker or Kubernetes | Self-hosted, plus Hybrid Cloud and Private Cloud |
| Cloud billing unit | Vector dimensions stored, plus storage and backups | vCPU, memory and disk of your cluster |
Embedding and RAG: How Much the Database Does for You
This is the biggest practical difference, and it decides how much code you write around the database.
Weaviate: send text, get vectors and answers
Weaviate's model provider integrations connect it to API-based models from OpenAI, Cohere, Anthropic, Google, Voyage AI, Mistral and many others, plus locally hosted options such as Ollama and Hugging Face Transformers. With an embedding integration on, Weaviate sends your text to the provider at import and stores the vector it gets back.
It does the same at query time. The OpenAI integration docs say that for near-text and hybrid search, "Weaviate converts the text query into an embedding using the specified model." So your app sends plain text in both directions.
Two more layers sit on top:
- Generative integrations let Weaviate run the RAG step itself: retrieve objects, pass them to an LLM, return the answer.
- Reranker integrations from Cohere, Jina AI, Voyage AI, NVIDIA and others reorder results before you see them.
The OpenAI integration, for example, is on by default in Weaviate Cloud, while self-hosted users enable the modules they need. Weaviate Cloud also offers Weaviate Embeddings, hosted embedding models billed per million tokens, and a Query Agent that turns natural-language questions into database operations.
Qdrant: you bring the vectors, unless you're on its cloud
Qdrant keeps the engine focused on storing and searching vectors. Its inference docs describe Cloud Inference, which generates embeddings server-side for managed clusters. Some hosted models cost nothing to use, and you can route to OpenAI, Cohere, Jina AI or OpenRouter with your own API key.
Self-hosted, Qdrant points you to client-side inference with FastEmbed, its own Python library, which runs locally with no external network calls. Qdrant's docs describe its inference features as embedding, not answer generation, so in a typical Qdrant RAG app your code takes the retrieved points and passes them to the LLM.
What that means in practice: with Weaviate, the database owns more of the RAG pipeline. With Qdrant, you own it. Some teams want the convenience. Others want the embedding step in their own code, so they can swap the model or the database independently.
Hybrid Search and Filtering
Both combine keyword matching with vector similarity. They expose it differently.
Weaviate's hybrid search runs a BM25F keyword search and a vector search, then fuses the two result sets. One parameter, alpha, sets the balance: 1 is pure vector search and 0 is pure keyword search. The default fusion method since v1.24 is Relative Score Fusion, which uses the actual scores, and Ranked Fusion is the alternative. You can limit the keyword leg to certain properties and boost fields with ^. It's one query with a dial.
Qdrant's hybrid queries are built from parts. You run one or more prefetch sub-queries (dense, sparse, multivector or full-text), then fuse them in the main query with Reciprocal Rank Fusion or Distribution-Based Score Fusion. Weighted RRF arrived in v1.17.0. Since v1.14.0 you can also rescore with a formula that mixes the fused score with payload fields and decay functions, for example to boost recent or popular items.
That's more to learn. It's also more control. If your ranking needs "semantic match, then favour newer documents, then favour this customer's top sellers", Qdrant lets you express it in one request.
For filters, Qdrant stores metadata as a JSON payload on each point and filters on keywords, full text, numeric ranges and geo-locations. Weaviate pairs vector search with filters on object properties, and its hybrid docs show the keyword operators or, and and and_cross.
| Weaviate | Qdrant | |
|---|---|---|
| How you tune the blend | One alpha weight | Choose sub-queries, fusion method and weights |
| Fusion methods | Relative Score Fusion (default), Ranked Fusion | RRF, weighted RRF, DBSF |
| Keyword leg tuning | Property limits, ^ boosts, and / or operators | Full-text index on payload fields |
| Extra rescoring | Reranker integrations | Formula rescoring with payload fields and decay |
| Sparse vectors | Keyword leg is BM25F | You supply sparse vectors, or use a full-text index |
Multi-Tenancy: Shards per Tenant vs One Shared Collection
If you're building a SaaS product where every customer has their own documents, this section matters more than speed.
Weaviate stores each tenant on its own shard, which isolates its data from the others. Each tenant has an activity state:
- Active: available for reads and writes.
- Inactive: kept on local disk, not queryable.
- Offloaded: moved to cloud storage through an S3-based offload module.
So a customer who logs in once a month doesn't need to sit in memory all month. You can also turn on autoTenantCreation, so inserting into a new tenant creates it. The docs warn that typos create new tenants too: "TenantOne" and "tenantOne" become two.
Qdrant advises against a collection per tenant. Its multitenancy guide says that "is rarely the most efficient approach", and Qdrant Cloud caps clusters at 1,000 collections by default. Instead:
- Payload partitioning. One collection, a tenant field on every point, and a keyword index marked
is_tenantso each tenant's vectors sit together. Best for many small tenants. - User-defined sharding. A dedicated shard per tenant, for a few large ones.
- Tiered multitenancy. Small tenants share a fallback shard. When one grows, you promote it to its own shard, and reads and writes keep working during the move. Qdrant suggests promoting at around 20,000 points and staying under about 1,000 dedicated shards per cluster.
The short version: Weaviate gives you isolation and hot-or-cold tenant states built in. Qdrant gives you one efficient shared collection, and a path to isolate only the customers who need it. Weaviate's model is simpler to reason about. Qdrant's needs you to remember the tenant filter on every query.
Licence, Hosting and the GraphQL Retirement
Licences
The Qdrant repository is Apache-2.0, full stop.
The Weaviate repository is mostly BSD-3-Clause, also permissive. But it says files in the wl/ folder are only available under a commercial licence, enterprise features need a licence key from Weaviate, and the official binaries combine both editions. For most teams that's fine. If your legal team wants one permissive licence on everything you ship, Qdrant is the easier sign-off.
Where each one runs
| Weaviate | Qdrant | |
|---|---|---|
| Local or self-hosted | Docker, Kubernetes; Embedded Weaviate is experimental | Docker, Kubernetes, binary |
| Fully managed | Weaviate Cloud, shared or dedicated (Premium) | Qdrant Cloud |
| Managed in your own Kubernetes | Not on its current deployment pages | Hybrid Cloud |
| Fully isolated, vendor-supported | Self-host | Private Cloud |
Qdrant's Hybrid Cloud docs say your databases run inside your own Kubernetes cluster, Qdrant's control plane receives only telemetry, metrics and status, and it needs outbound HTTPS on port 443 with no inbound ports. Weaviate's deployment docs list Weaviate Cloud, cloud marketplaces, self-hosted Docker and Kubernetes, and Snowflake's Snowpark Container Services. Weaviate used to market a BYOC option, but that page now redirects to Dedicated Cloud, and we found no current equivalent of Hybrid Cloud on its site. Ask Weaviate's sales team if you need it.
The GraphQL retirement (Weaviate only)
Weaviate's post on deprecating the GraphQL API sets the dates:
- October 26, 2026: GraphQL deprecated. Nothing breaks yet.
- December 1, 2026: Weaviate Cloud switches GraphQL off on clusters that haven't used it in 30 days.
- May 1, 2027: switched off on all remaining Cloud clusters.
The replacement is gRPC through the current Python, TypeScript, Java, C# and Go v6 clients, plus a REST Search API in preview. You're affected if you use the Python v3 client, weaviate-ts-client v2, Java v5, Go v5 or raw /v1/graphql calls. Self-hosted releases before May 1, 2027 keep GraphQL.
If you're already on a current client, this costs you nothing. If you're not, you have a rewrite coming whether you stay or move.
Pricing: Vector Dimensions vs Cluster Size
The two clouds measure different things, so the cheaper one depends on your data.
Weaviate Cloud bills mainly on the total number of vector dimensions you store, at rates that vary by index type, compression, cloud provider and region. Storage and backups are billed per GiB on top. Its pricing page lists:
- Free: a small shared cluster with caps on objects, memory, disk and collections, on AWS only.
- Flex: pay-as-you-go on shared clusters, with a monthly minimum and a 99.5% uptime target.
- Premium: a prepaid contract, shared or dedicated, on AWS, GCP or Azure, priced by quote.
Hosted embeddings and the Query Agent are billed separately.
Qdrant Cloud bills hourly for the vCPU, memory and disk of the clusters you provision, plus backup storage and tokens on paid inference models. Its pricing page lists:
- Free: one single-node cluster with 0.5 vCPU, 1 GB RAM and 4 GB disk, with no high availability.
- Standard: usage-based, for production.
- Premium: a minimum spend, with enterprise security and compliance features.
- Hybrid Cloud and Private Cloud: through sales. A Serverless option is waitlist-only.
What this means for you:
| Your situation | What tends to happen |
|---|---|
| Large embeddings (thousands of dimensions) | Weaviate's bill grows with the model you pick; Qdrant's grows with the RAM you need |
| Heavy compression or quantization | Both reward it, in different ways: Weaviate's rate changes, Qdrant's cluster shrinks |
| Spiky, small workload | Weaviate's per-dimension model needs no cluster sizing |
| Steady, large workload you can size | Qdrant's provisioned cluster is easier to predict |
Prices change. Check both pages before you budget, and price the same dataset on each.
Weaviate vs Qdrant: Which Should You Pick
Choose Weaviate if:
- You want the database to embed text at import and query time, and to run the RAG step.
- You're building a multi-tenant SaaS app and want per-tenant shards you can deactivate or offload.
- You like one simple hybrid dial over assembling fusion pipelines.
- You're already on a current gRPC client, so the GraphQL retirement doesn't touch you.
Choose Qdrant if:
- You want one Apache-2.0 licence on everything.
- You want to keep embedding in your own code, or you self-host and would build that step anyway.
- Your ranking needs custom fusion, weights or score formulas.
- You want vendor-managed clusters running inside your own Kubernetes (Hybrid Cloud).
- You'd rather pay for a cluster size you chose than for dimensions stored.
Where each is honestly stronger: Weaviate is the more complete product out of the box. Qdrant is the more flexible engine. Neither is a bad choice, and the data model is close enough (an ID, a vector and metadata) that you can move later if you keep embedding and chunking code separate from database calls.
If neither fits, we cover the wider field in Weaviate alternatives and Qdrant alternatives. If you're weighing a fully managed service instead, see Qdrant vs Pinecone.
Where Taku Fits
Picking a vector database is a job for whoever builds the retrieval stack, and Taku doesn't replace either one. If you'd rather run an AI tool someone has already built than assemble the retrieval stack yourself, that's where Taku comes in. Taku Apps and Sites, built by the best AI minds. Find one, run it, and keep it in your Mac Dock. Taku is in Beta, and the Mac app is available now.
Key Points
- Both are open source with a managed cloud, so the real differences are in what the database does for you.
- Weaviate embeds text at import and query time, can run the RAG step, and reranks, through model provider integrations.
- Qdrant offers server-side embedding only on Qdrant Cloud. Self-hosted, you embed in your own code, for example with FastEmbed.
- Weaviate's hybrid search is one
alphadial. Qdrant builds hybrid search from prefetch sub-queries, fusion and optional score formulas. - Weaviate puts each tenant on its own shard with active, inactive and offloaded states. Qdrant prefers one shared collection with tiered promotion.
- Qdrant is Apache-2.0. Weaviate is BSD-3-Clause plus a commercial-only
wl/folder. - Weaviate Cloud retires GraphQL by May 1, 2027. Check your client versions now.
FAQ
Is Weaviate better than Qdrant?
Neither wins across the board. Weaviate does more for you: built-in embedding, a generative RAG step and per-tenant shards. Qdrant gives you a leaner engine with finer control over fusion and scoring, under a single Apache-2.0 licence. Test both on your own data before you commit.
Are Weaviate and Qdrant both open source?
Yes. Qdrant is Apache-2.0. Weaviate is mostly BSD-3-Clause, but its repo says the wl/ folder is available only under a commercial licence, and enterprise features need a licence key.
Does Qdrant create embeddings for you like Weaviate does?
Only on Qdrant Cloud, through Cloud Inference. Self-hosted Qdrant expects you to send vectors, and Qdrant recommends its FastEmbed library for local, client-side embedding. Weaviate's model integrations work self-hosted too, once you enable the modules.
Which is better for multi-tenant apps, Weaviate or Qdrant?
Weaviate is simpler if you want hard isolation, because each tenant gets its own shard and can be set inactive or offloaded to cloud storage. Qdrant is efficient for many small tenants in one collection, and can promote large tenants to dedicated shards when they grow.
Is Weaviate removing GraphQL?
Yes, on Weaviate Cloud. It was deprecated on October 26, 2026, is switched off on idle Cloud clusters from December 1, 2026, and on all Cloud clusters on May 1, 2027. Current clients use gRPC instead. Self-hosted releases before May 1, 2027 keep GraphQL.
Which is cheaper, Weaviate Cloud or Qdrant Cloud?
It depends on your data. Weaviate bills mainly on vector dimensions stored, so large embeddings cost more. Qdrant bills for the CPU, memory and disk of your cluster, so it rewards workloads you can size. Price the same dataset on both pricing pages.