← Blog

Weaviate vs Qdrant: Which Open-Source Vector Database?

November 19, 2026

Tool Comparisons

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

WeaviateQdrant
Written inGoRust
LicenceBSD-3-Clause, plus a commercial-only wl/ folderApache-2.0
Latest stable releasev1.40.5 (November 10, 2026)v1.20.2 (November 16, 2026)
Built-in embeddingModel provider integrations, self-hosted or cloudCloud Inference on Qdrant Cloud only
Built-in RAG stepYes, generative integrationsNot in its docs; your code calls the LLM
Hybrid searchBM25F plus vectors, one alpha weightPrefetch sub-queries fused with RRF or DBSF
Multi-tenancyOne shard per tenant, with active, inactive and offloaded statesPayload partitioning, with tiered promotion to dedicated shards
Managed cloudWeaviate Cloud, shared or dedicatedQdrant Cloud on AWS, Azure and GCP
Runs in your own infrastructureSelf-hosted Docker or KubernetesSelf-hosted, plus Hybrid Cloud and Private Cloud
Cloud billing unitVector dimensions stored, plus storage and backupsvCPU, 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.

WeaviateQdrant
How you tune the blendOne alpha weightChoose sub-queries, fusion method and weights
Fusion methodsRelative Score Fusion (default), Ranked FusionRRF, weighted RRF, DBSF
Keyword leg tuningProperty limits, ^ boosts, and / or operatorsFull-text index on payload fields
Extra rescoringReranker integrationsFormula rescoring with payload fields and decay
Sparse vectorsKeyword leg is BM25FYou 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_tenant so 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

WeaviateQdrant
Local or self-hostedDocker, Kubernetes; Embedded Weaviate is experimentalDocker, Kubernetes, binary
Fully managedWeaviate Cloud, shared or dedicated (Premium)Qdrant Cloud
Managed in your own KubernetesNot on its current deployment pagesHybrid Cloud
Fully isolated, vendor-supportedSelf-hostPrivate 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 situationWhat 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 quantizationBoth reward it, in different ways: Weaviate's rate changes, Qdrant's cluster shrinks
Spiky, small workloadWeaviate's per-dimension model needs no cluster sizing
Steady, large workload you can sizeQdrant'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 alpha dial. 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.