§6

Vector databases and retrieval infrastructure

A vector database stores high-dimensional embeddings and answers approximate-nearest-neighbour (ANN) queries over them, almost always combined with metadata filters and increasingly with lexical BM25 scoring in the same query. The category has bifurcated since 2024: purpose-built engines (Pinecone, Qdrant, Weaviate, Milvus, Turbopuffer) on one side, and vector indexes bolted into systems you already run (Postgres/pgvector, Elasticsearch, MongoDB Atlas, Redis, OpenSearch) on the other.

Data checked 2026-09-06

The decisive architectural shift of 2025-2026 was separation of storage and compute onto object storage — Turbopuffer, S3 Vectors (GA December 2025), Milvus 3.0's lake-native release (July 2026), Weaviate's HFresh disk index, Elasticsearch DiskBBQ, and LanceDB all now keep the bulk of the index in S3-class storage rather than RAM, which collapsed the cost of a billion-vector index by roughly an order of magnitude. Quantization did the rest: BBQ, RaBitQ, and int8/binary compression routinely cut memory 32x at single-digit recall loss, so "how much RAM does 1M vectors need" is no longer the question it was. The practical consequence is that for most RAG workloads under ~10M vectors, the vector store is no longer the interesting engineering problem — chunking, filtering semantics, and reranking are.

A How to choose

Start by asking whether you need a separate system at all. If your data already lives in Postgres and you are under roughly 5-10M vectors, pgvector 0.8.x with HNSW and iterative scans is the correct answer and adds zero operational surface; adding pgvectorscale's StreamingDiskANN extends that to tens of millions. The popular default — reaching for Pinecone because it is the name you know — is usually wrong for small teams with an existing Postgres, and wrong again for anyone whose real bottleneck is retrieval quality rather than ANN latency.

The second axis is tenancy shape. If you have many small, mostly-idle namespaces (per-customer, per-workspace, per-user), object-storage-native systems — Turbopuffer, S3 Vectors, Pinecone serverless, Milvus 3.0, LanceDB — are dramatically cheaper than anything that pins an HNSW graph in RAM per tenant, because you pay for bytes at rest and bytes scanned rather than for provisioned memory. Conversely, if you have one large hot index under constant p99-sensitive load, a RAM-resident engine (Qdrant, Redis, Milvus dedicated, Vespa) will beat object storage on tail latency, and the object-storage systems will need pinning or warm-cache features that erode their price advantage.

Third: hybrid search and filtering are where these products actually differ. Native BM25-plus-vector fusion with real filter semantics is a first-class feature in Vespa, Elasticsearch, Weaviate, Qdrant, Turbopuffer, and now Pinecone; it is weak or absent in S3 Vectors and Cloudflare Vectorize, and pre-filter-versus-post-filter behaviour under selective filters (Qdrant's ACORN, pgvector's iterative scan, Milvus's filtered search) is the thing that silently destroys recall in production, so benchmark it on your own filter distributions rather than trusting published QPS numbers. Fourth: exit cost and control.

Self-hostable Apache-2.0 engines (Qdrant, Milvus, Weaviate, Vespa, Chroma, LanceDB, OpenSearch) let you move; Pinecone, Turbopuffer, S3 Vectors, and Vectorize do not, and Vespa's power comes with a genuine operational learning curve that only pays off if you need custom ranking phases and tensor expressions. Finally, ignore vendor benchmark charts. Every engine claims to beat every other engine, and the numbers are almost always run at a recall target, dataset, and filter selectivity chosen to flatter the publisher; run ANN-Benchmarks-style recall-versus-latency on your own embeddings before committing.

B At a glance

Name	Deployment	Hybrid search	Filtering	Index types	Proven scale	Pricing
Pinecone	Managed SaaS only (BYOC on Enterprise, GA Aug 2026)	Yes — BM25 + dense + sparse in document indexes, GA Sept 2026	Metadata filters applied during search; $in/$nin capped at 10,000 values per operator	Proprietary serverless index (no user-selectable ANN algorithm)	Billions of records; 100k namespaces/index standard, millions on request	Starter free (2 GB storage, 2M write units, 1M read units, 1 GB egress, 5 indexes). Builder $20/mo flat (10 GB). Standard pay-as-you-go, $50/mo minimum: $0.33/GB-mo storage, $16-18 per million read units, $4-4.50 per million write units. Enterprise $500/mo minimum: $24-27/M read units, $6-6.75/M write units. Bulk import $0.25/GB (cut from $1/GB in 2026). Egress is now metered with per-plan allowances.
Qdrant	Self-host (Docker/K8s), managed cloud, Hybrid Cloud, Private Cloud	Yes — dense + sparse (SPLADE/BM25-style) with server-side fusion	Payload filters with ACORN filtered-search; strong pre-filter semantics	HNSW, plus scalar / product / binary quantization and on-disk storage	Billion-scale with quantization and multitenant collections	Free forever managed cluster: 0.5 vCPU / 1 GB RAM / 4 GB disk, single node. Standard is usage-based hourly on vCPU, RAM, disk, backups and inference tokens with a 99.5% SLA; Premium requires a minimum spend and adds SSO, private VPC links and a 99.9% SLA. Qdrant does not publish a flat rate card — costs come from their pricing calculator. Self-hosted OSS is $0 plus your infrastructure.
Weaviate	Self-host (Docker/K8s), Weaviate Cloud shared or dedicated, BYOC	Yes — native BM25 + vector fusion, a headline feature	Typed property filters; nested object filtering in preview	HNSW, flat, dynamic, HFresh disk-based (GA v1.38); PQ/BQ/SQ compression	Billions of objects; multi-tenancy designed for very high tenant counts	Free plan $0 (1 cluster/user, 100,000 objects, 1 GB memory, 10 GB disk, 1 collection, 3 tenants). Flex from $45/mo: from $0.00465 per 1M vector dimensions, storage from $0.12/GiB, backup from $0.0264/GiB, 99.5% SLA. Premium from $400/mo prepaid: from $0.003875 per 1M dimensions shared, from $0.002718 dedicated, up to 99.95% uptime. Embeddings $0.025-$0.065 per 1M tokens; Query Agent free to 1,000 req/mo then $30/mo for 4,000.
Chroma	Embedded/in-process, self-hosted server, Chroma Cloud serverless, BYOC on request	Partial — vector search with metadata and full-text predicates, not a full BM25 ranker	Metadata where-clauses and document text filters, counted into query billing	HNSW (SPANN-style distributed indexing in the cloud backend)	Comfortable to tens of millions; large-scale track record still thin	Starter $0/mo plus usage, $5 in free credits, 10 databases, 10 team members. Team $250/mo including $100 of usage credits, 100 databases, 30 members. Usage rates: writes $2.50/GiB, storage $0.33/GiB/month (prorated hourly), queries $0.0075/TiB queried plus $0.09/GiB returned, forking $0.03/request, sync $0.04/GiB processed, $0.01 per document page extracted, $0.01 per web page scraped. Enterprise custom; BYOC on request.
Milvus	Self-host (Lite / Standalone / distributed K8s / Docker, air-gapped supported)	Yes — dense + sparse (BM25) multi-vector search with server-side reranking	Scalar filtering with expression language; partition keys for tenant isolation	HNSW, IVF_FLAT/SQ8/PQ, DiskANN, SCANN, RaBitQ 1-bit, int8 HNSW, GPU (CAGRA)	Documented tens of billions of vectors in distributed deployments	$0 — Apache 2.0. You pay only infrastructure. A single-node Milvus Standalone holding 1M×768d vectors runs comfortably on an ~8-16 GB instance (roughly $60-150/mo on a cloud VM); distributed deployments add coordinator, query and index nodes plus S3/MinIO storage. Managed pricing is Zilliz Cloud's (separate entry).
Zilliz Cloud	Managed serverless and dedicated clusters on AWS/GCP/Azure; BYOC available	Yes — dense + sparse/BM25 multi-vector with reranking, inherited from Milvus	Scalar expression filters; partition-key multi-tenancy	Milvus set — HNSW, IVF variants, DiskANN, RaBitQ, int8, GPU indexes; tiered storage	Billions of vectors across managed customers	Free cluster: 5 GB capacity, up to 2.5M vCUs/month, up to 5 collections. Serverless: $4 per million vCUs plus $0.04/GB/month storage (down from $0.30 in January 2026). Dedicated: $0.096 per CU-hour compute plus $0.02/GB storage, with dedicated plans commonly quoted from about $99/month. BYOC and enterprise tiers are custom.
pgvector	Self-host or any managed Postgres (RDS, Aurora, Cloud SQL, AlloyDB, Azure, Supabase, Neon)	DIY — combine tsvector/ts_rank with vector distance yourself; no built-in fusion	Full SQL WHERE with joins; iterative scans (0.8+) preserve recall under selective filters	HNSW and IVFFlat over vector, halfvec, bit, sparsevec; L2/cosine/inner-product/L1/Hamming/Jaccard	Comfortable to ~10M vectors on one node; tens of millions with halfvec/binary quantization	$0 — PostgreSQL License. Cost is whatever your Postgres costs: roughly $19-25/mo for a Neon or Supabase paid instance, ~$120-140/mo for an RDS db.m7g.large, $0 on a box you already own.
pgvectorscale	Self-hosted Postgres or Tiger Cloud; unavailable on RDS/Cloud SQL/Azure Postgres	DIY via Postgres full-text search, same as pgvector	Full SQL WHERE; label-based filtered search on the DiskANN index	StreamingDiskANN plus Statistical Binary Quantization (layers over pgvector types)	Benchmarked at 50M×768d on a single node	$0 for the extension. Tiger Cloud managed Postgres pricing applies if you use their hosting; self-hosting on EC2 costs only the instance. Exact Tiger Cloud tier prices not verified here.
Turbopuffer	Managed SaaS; single-tenancy and BYOC on Enterprise only	Yes — vector ANN and BM25 full-text in one system with documented hybrid patterns	Filterable attributes billed per vector column; filters evaluated during scan	Proprietary object-storage index with NVMe cache; multiple vector columns per namespace	Up to 256 TB in a single sharded namespace	Launch $16/mo minimum usage; Scale $256/mo minimum (audit log streams +$128/mo); Enterprise ≥$4,096/mo with a 35% usage premium, 99.95% SLA, BYOC and CMEK. Queries: $1 per PB scanned base, 1.28 GB minimum billable per query, 80% marginal discount 32-128 GB, 96% above 128 GB. Writes: up to $2.00/GB written with batch discounts up to 50% and a 10 KB minimum per write. Storage: up to $0.33/GB-month. Exact storage and write rates are surfaced only through the on-page calculator rather than a static table.
LanceDB	Embedded (in-process against S3/GCS/Azure), self-hosted, LanceDB Cloud, Enterprise	Yes — vector plus full-text (Tantivy-based) with reranking, less mature than search engines	SQL-style predicates pushed into the columnar scan	IVF_PQ, IVF_HNSW variants, scalar and binary quantization over the Lance format	Marketing cites 100B+ rows in a single table and 100k+ QPS	unknown — LanceDB publishes no rate card for Cloud or Enterprise; the site routes to a contact-sales form. Third-party reports of $100 in one-time cloud credits are unverified. The OSS engine and Lance format are free.
Vespa	Self-host (bare metal/K8s) or Vespa Cloud on AWS/GCP	Yes — the strongest here; BM25, ANN and ML ranking unified in multi-phase rank profiles	Full structured query language with true pre-filtering integrated into the ANN traversal	HNSW (including multiple vectors per document), plus exact search and tensor operations	Hundreds of billions of documents; among the largest production search deployments	Self-hosted: $0, Apache 2.0. Vespa Cloud Enterprise rates: $0.18 per vCPU-hour, $0.018 per GB-memory-hour, $0.0007 per GB-disk-hour, $0.125 per GPU-GB-hour; default spend quota $10/hour on paid plans. The Enterprise plan carries a $20,000/month minimum spend for its full entitlements. Self-serve pay-as-you-go plans exist at the same resource-based rates without the minimum.
Elasticsearch	Self-host, Elastic Cloud Hosted, Elastic Cloud Serverless, ECK on Kubernetes	Yes — BM25 + kNN via retrievers and reciprocal rank fusion, plus ELSER sparse retrieval	Full query DSL with pre-filtered kNN; document-level and field-level security	HNSW over dense_vector, int8/int4 scalar quantization, BBQ (default ≥384 dims in 9.1), DiskBBQ (GA 9.2)	Petabyte-scale clusters; billions of vectors with BBQ/DiskBBQ	Elastic Cloud Serverless: ingest from $0.14/VCU-hour, search from $0.09/VCU-hour, machine learning from $0.07/VCU-hour, storage from $0.047/GB retained per month, egress from $0.05/GB; vector profiles include 50 GB free storage. Elastic Managed LLM $4.50/M input and $21/M output tokens; Elastic Inference Service from $0.08/M tokens. Support ranges from included to 15% of charges. Self-managed Elasticsearch is free under Elastic License 2.0 / AGPL / SSPL; paid subscription tiers unlock security and ML features.
Amazon OpenSearch Service	Self-host, Amazon OpenSearch Service managed domains, OpenSearch Serverless (NextGen)	Yes — hybrid query with normalization/combination processors fusing BM25 and k-NN	Query DSL with efficient pre-filtering on Faiss and Lucene engines	HNSW and IVF via Faiss, Lucene and NMSLIB; binary quantization (2.17+), disk-based mode with SQ default (3.6+)	Billions of vectors on large managed domains; petabyte log clusters	Software is $0 (Apache 2.0). Amazon OpenSearch Serverless bills OpenSearch Compute Units at roughly $0.24/OCU-hour, so a two-OCU baseline is about $350/month and a single dev/test OCU about $175/month — but NextGen collections (GA May 2026) scale to zero after 10 minutes idle, leaving only storage. Managed domains bill per instance-hour plus EBS, from roughly $25-100/month for small single-node domains. Exact OCU rate is region-dependent and not independently verified here.
MongoDB Atlas Vector Search	MongoDB Atlas managed only (AWS/GCP/Azure); not available in self-managed MongoDB	Yes — combine $vectorSearch with Atlas Search BM25 via $rankFusion in the aggregation pipeline	Pre-filtering on indexed fields inside $vectorSearch; full aggregation pipeline afterwards	HNSW, with scalar and binary quantization options	Hundreds of millions of vectors with dedicated Search Nodes	M0 shared cluster free, including basic vector search. Dedicated clusters from about $0.08/hour (M10, roughly $57/month). Dedicated Search Nodes from $0.12/hour (S20) up to $1.77/hour (S60), minimum two nodes on M10+ clusters — so roughly $175/month for the smallest HA search-node pair on top of the cluster. Prices vary by cloud provider and region.
Redis	Self-host (Redis Open Source), Redis Cloud, Redis Software on-prem, cloud marketplaces	Yes — Redis Query Engine combines vector KNN with full-text, tag, numeric and geo filters	Pre-filter and post-filter hybrid queries in the query engine's syntax	FLAT (exact) and HNSW; float32/float16/bfloat16/int8; Vector Sets data type in beta	Tens of millions of vectors, bounded by available RAM (or flash via Redis Flex)	Redis Cloud Free: $0, single 30 MB database, best-effort SLA. Essentials: from $0.007/hour with a $5/month minimum, 250 MB to 100 GB, up to 99.99% uptime. Pro: from $0.014/hour with a $200/month minimum, unlimited RAM, dedicated deployment, active-active multi-region, 99.999% SLA, and Redis Flex for RAM:flash tiering. Redis Open Source is free to self-host.
Amazon S3 Vectors	AWS managed only (S3 vector buckets), 31 regions as of March 2026	No — vector similarity only; pair with OpenSearch for lexical or hybrid ranking	Basic metadata filtering on stored key-value attributes	Managed, not user-selectable; sub-second query target rather than tuned ANN parameters	2 billion vectors per index, 10,000 indexes per vector bucket	$0.06 per GB per month storage, $0.20 per GB for PUT operations, plus a per-query charge scaled by index size; query data processed is $0.002 per TB scanned beyond the first 100,000 vectors per index. No minimum, no provisioned capacity, standard AWS billing. Exact per-query rate tiers vary by region and were not independently verified here.
Cloudflare Vectorize	Cloudflare managed only, accessed from Workers, the REST API or Wrangler CLI	No — vector similarity with metadata filters only	Metadata filtering on indexed properties; limited operator set	Managed approximate index, not user-configurable	Low millions of vectors per index — the smallest ceiling in this list	Workers Free: 30 million queried dimensions per month and 5 million stored dimensions, $0. Workers Paid ($5/month for the Workers plan): 50 million queried dimensions included then $0.01 per million; 10 million stored dimensions included then $0.05 per 100 million. No egress fees, no per-index or per-hour charges. Cloudflare's own examples: ~$1.94/month for 50k×768d with 200k queries; ~$23.42/month for 500k vectors.
Azure AI Search	Azure managed only; dedicated hourly SKUs plus a serverless preview (billing from 13 Sept 2026)	Yes — BM25 + vector with RRF and an L2 semantic reranker	OData filter expressions with pre-filtering; Entra ID security trimming	HNSW and exhaustive KNN, with scalar and binary quantization and stored-vector reduction	Up to 4 TB storage on Storage Optimized L2 SKUs; hundreds of millions of vectors	unknown for exact tier prices — Microsoft's pricing page is region- and SKU-dependent and did not yield firm per-tier figures here. Structure: Free tier (50 MB storage, 3 indexes, $0); dedicated hourly tiers from Basic through Standard S1/S2/S3 to Storage Optimized L1/L2, scaling from 15 GB to 4 TB storage; Serverless preview billed on compute units plus indexed storage, billing from 13 September 2026. Agentic retrieval: first 50M tokens/month free then tiered. Semantic ranker: first 1,000 requests/month free.
Vertex AI Vector Search	Google Cloud managed only; index deployed to a Vertex AI endpoint with provisioned replicas	Partial — dense plus sparse (token-based) hybrid supported; no full BM25 ranking stack	Namespace and numeric restrict filters applied during ANN search; limited expressiveness	ScaNN (tree-AH and brute force), with configurable approximate neighbour counts	Billions of vectors; the algorithm underpins Google-scale retrieval	Index build: $3.00 per GiB of data processed. Serving: billed per node-hour for the deployed index endpoint, continuously while deployed; a modest index on three replicas is commonly reported around $700-800/month. Exact serving node-hour rates depend on machine type and region and were not verified against Google's rate card here — treat the serving figures as directional.

C Entries

Pinecone

Pinecone runs a proprietary serverless index on object storage with per-namespace isolation, and bills for storage, read units and write units rather than for provisioned nodes. During 2026 it moved decisively past pure ANN: Dedicated Read Nodes (GA April 2026) give provisioned read hardware for latency-sensitive traffic, BYOC (GA August 2026) runs the data plane in your own AWS/GCP/Azure account, full-text search with BM25 plus dense and sparse ranking went GA in September 2026, and Nexus (GA August 2026) is a higher-level knowledge/answer layer. Pod-based indexes moved to legacy status in April 2026 and new accounts see serverless only. Namespace counts scale to 100,000 per index on Standard and Enterprise, with higher on request.

Deployment	Managed SaaS only (BYOC on Enterprise, GA Aug 2026)
Hybrid search	Yes — BM25 + dense + sparse in document indexes, GA Sept 2026
Filtering	Metadata filters applied during search; $in/$nin capped at 10,000 values per operator
Index types	Proprietary serverless index (no user-selectable ANN algorithm)
Proven scale	Billions of records; 100k namespaces/index standard, millions on request
Cost at 1M×768d vectors	~3 GB — fits the $20/mo Builder plan; on Standard, ~$1/mo storage against a $50/mo floor plus reads

Watch out: Fully closed and unexportable in any structured way — there is no self-host escape hatch outside the Enterprise BYOC deal, so migration means re-embedding or re-uploading everything. Read units are opaque enough that cost forecasting is genuinely hard: a query fanning across a large namespace with a weak filter can cost many multiples of what you modelled, and 2026 added egress metering on top. Pod indexes are legacy, so long-lived deployments face a forced migration. Wrong choice when you already run Postgres and are under a few million vectors, or when regulatory constraints require the data plane in your own VPC on a non-Enterprise budget.

Starter free (2 GB storage, 2M write units, 1M read units, 1 GB egress, 5 indexes). Builder $20/mo flat (10 GB). Standard pay-as-you-go, $50/mo minimum: $0.33/GB-mo storage, $16-18 per million read units, $4-4.50 per million write units. Enterprise $500/mo minimum: $24-27/M read units, $6-6.75/M write units. Bulk import $0.25/GB (cut from $1/GB in 2026). Egress is now metered with per-plan allowances.

Qdrant

Qdrant is a Rust ANN engine with HNSW, rich payload filtering, and scalar/product/binary quantization, offered as self-hosted OSS or as managed Qdrant Cloud billed on the actual compute you allocate rather than on vectors or reads. Version 1.16 added tiered multitenancy with tenant promotion, inline storage for disk-efficient vector search, and ACORN for filtered search that keeps recall under selective filters. Qdrant Cloud Inference generates and indexes embeddings in the same API call using curated dense, sparse and CLIP-style multimodal models, removing a separate inference hop. Hybrid Cloud and Private Cloud run the managed control plane against your own Kubernetes for data residency.

Deployment	Self-host (Docker/K8s), managed cloud, Hybrid Cloud, Private Cloud
Hybrid search	Yes — dense + sparse (SPLADE/BM25-style) with server-side fusion
Filtering	Payload filters with ACORN filtered-search; strong pre-filter semantics
Index types	HNSW, plus scalar / product / binary quantization and on-disk storage
Proven scale	Billion-scale with quantization and multitenant collections
Cost at 1M×768d vectors	~3 GB raw; a small paid cluster in the ~$25-60/mo range (less with quantization), $0 self-hosted

Watch out: Because Qdrant Cloud prices resources rather than usage, an idle workload still pays for the cluster: there is no scale-to-zero and no object-storage tier, so cost scales with peak provisioned RAM even when queries are sporadic. The absence of a published per-unit rate card makes budget comparison against Pinecone or Turbopuffer awkward without running the calculator. It is a dedicated vector store, not a general database — you still need a system of record elsewhere and must keep the two in sync. Wrong choice when you want a metered serverless bill or when your workload is thousands of mostly-idle tenants.

Free forever managed cluster: 0.5 vCPU / 1 GB RAM / 4 GB disk, single node. Standard is usage-based hourly on vCPU, RAM, disk, backups and inference tokens with a 99.5% SLA; Premium requires a minimum spend and adds SSO, private VPC links and a 99.9% SLA. Qdrant does not publish a flat rate card — costs come from their pricing calculator. Self-hosted OSS is $0 plus your infrastructure. · open source

Weaviate

Weaviate stores objects with their vectors and offers native hybrid search fusing BM25 and vector scores, multi-tenancy with per-tenant activity states, and built-in vectorizer/reranker modules that call embedding providers for you. Its pricing is unusual: Weaviate Cloud bills per million vector dimensions per month rather than per vector or per GB, so dimension count directly drives the bill and quantization directly cuts it. During 2026 it shipped the HFresh disk-based vector index (GA in v1.38), a built-in MCP server exposing hybrid query and schema tools to coding agents, and made Engram — a managed agent memory service — generally available in June 2026, with free tiers across the whole cloud suite.

Deployment	Self-host (Docker/K8s), Weaviate Cloud shared or dedicated, BYOC
Hybrid search	Yes — native BM25 + vector fusion, a headline feature
Filtering	Typed property filters; nested object filtering in preview
Index types	HNSW, flat, dynamic, HFresh disk-based (GA v1.38); PQ/BQ/SQ compression
Proven scale	Billions of objects; multi-tenancy designed for very high tenant counts
Cost at 1M×768d vectors	768M dimensions ≈ $3.60/mo on Flex rates, but subject to the $45/mo Flex floor

Watch out: Dimension-based pricing punishes large embeddings — a 3072-dim model costs four times a 768-dim model for identical object counts, which is a real design constraint rather than a rounding error. The free tier's 100,000-object and single-collection ceiling is tight enough that most prototypes outgrow it quickly. Historically memory-hungry for large HNSW indexes; HFresh only reached GA in v1.38, so disk-based operation at scale is comparatively new. The built-in module ecosystem is convenient but couples your schema to Weaviate-specific configuration, raising migration cost.

Free plan $0 (1 cluster/user, 100,000 objects, 1 GB memory, 10 GB disk, 1 collection, 3 tenants). Flex from $45/mo: from $0.00465 per 1M vector dimensions, storage from $0.12/GiB, backup from $0.0264/GiB, 99.5% SLA. Premium from $400/mo prepaid: from $0.003875 per 1M dimensions shared, from $0.002718 dedicated, up to 99.95% uptime. Embeddings $0.025-$0.065 per 1M tokens; Query Agent free to 1,000 req/mo then $30/mo for 4,000. · open source

Chroma

Chroma began as the pip-installable, in-process vector store that made prototyping RAG trivial, and has since been rewritten around a Rust core with a distributed serverless backend. Chroma Cloud, launched in 2026, exposes that backend with genuinely transparent per-unit pricing — writes, storage, queries and bytes returned are each billed separately, with no compute to provision. Collection forking at $0.03 per request supports copy-on-write branching for evals and staging, and a sync feature ingests documents and web pages at published per-page rates. The local and cloud APIs are the same, so the prototype-to-production path is unusually short.

Deployment	Embedded/in-process, self-hosted server, Chroma Cloud serverless, BYOC on request
Hybrid search	Partial — vector search with metadata and full-text predicates, not a full BM25 ranker
Filtering	Metadata where-clauses and document text filters, counted into query billing
Index types	HNSW (SPANN-style distributed indexing in the cloud backend)
Proven scale	Comfortable to tens of millions; large-scale track record still thin
Cost at 1M×768d vectors	~3 GiB ≈ $1/mo storage plus ~$7.70 one-time write cost; no plan minimum on Starter

Watch out: Chroma is the youngest managed offering here and its distributed backend has far less production mileage than Milvus, Elasticsearch or Vespa; treat multi-hundred-million-vector claims with caution. Hybrid lexical search and ranking sophistication lag Weaviate, Vespa and Elasticsearch — full-text predicates exist but this is not a BM25 engine. The embedded single-node mode that made Chroma popular does not scale and is not the same operational thing as the cloud product, which trips teams who assume local behaviour transfers. Wrong choice for latency-critical, high-QPS serving or for complex multi-stage ranking.

Starter $0/mo plus usage, $5 in free credits, 10 databases, 10 team members. Team $250/mo including $100 of usage credits, 100 databases, 30 members. Usage rates: writes $2.50/GiB, storage $0.33/GiB/month (prorated hourly), queries $0.0075/TiB queried plus $0.09/GiB returned, forking $0.03/request, sync $0.04/GiB processed, $0.01 per document page extracted, $0.01 per web page scraped. Enterprise custom; BYOC on request. · open source

Milvus

Milvus is the largest open-source vector database by adoption, a graduated LF AI & Data project with a disaggregated architecture separating coordinators, query nodes, index nodes and object storage. Milvus 3.0, released 29 July 2026, is the lake-native rewrite: it builds and serves production indexes over vector data that remains in S3-compatible object storage and open table formats, and pushes sorting, aggregation, faceted search and multi-vector scoring into the engine instead of application code. The preceding 2.6 line delivered the cost work — RaBitQ 1-bit quantization, int8 compression for HNSW, tiered hot/cold storage, and the Woodpecker WAL that removes the Kafka/Pulsar dependency. It supports the widest index menu of any system here.

Deployment	Self-host (Lite / Standalone / distributed K8s / Docker, air-gapped supported)
Hybrid search	Yes — dense + sparse (BM25) multi-vector search with server-side reranking
Filtering	Scalar filtering with expression language; partition keys for tenant isolation
Index types	HNSW, IVF_FLAT/SQ8/PQ, DiskANN, SCANN, RaBitQ 1-bit, int8 HNSW, GPU (CAGRA)
Proven scale	Documented tens of billions of vectors in distributed deployments
Cost at 1M×768d vectors	$0 licence; ~$60-150/mo for a single cloud VM to host it

Watch out: The distributed deployment is genuinely complex — multiple node roles, etcd, and object storage — and running it well is a real infrastructure job, which is exactly why Zilliz Cloud exists. Milvus 3.0 is weeks old as of September 2026, initially Python/Go/Node SDKs only with Java following after release, so production adoption of the lake-native path is early. The breadth of index and quantization options is a burden as much as a feature: choosing badly costs recall or memory, and the defaults are not always right. Overkill below roughly 10M vectors, where pgvector or Qdrant will cost far less operator time.

$0 — Apache 2.0. You pay only infrastructure. A single-node Milvus Standalone holding 1M×768d vectors runs comfortably on an ~8-16 GB instance (roughly $60-150/mo on a cloud VM); distributed deployments add coordinator, query and index nodes plus S3/MinIO storage. Managed pricing is Zilliz Cloud's (separate entry). · open source

Zilliz Cloud

Zilliz Cloud is the commercial managed service from Milvus's creators, offering a serverless tier billed in vector compute units plus storage, and dedicated clusters billed per compute-unit hour. In January 2026 it cut storage pricing roughly 87% to a flat $0.04/GB/month standardised across AWS, Azure and GCP, which changes the arithmetic for large cold datasets substantially. It tracks Milvus releases closely — 2.6.x reached GA on the platform with tiered storage and the newer quantization modes — and adds BYOC and enterprise controls that the OSS project leaves to you.

Deployment	Managed serverless and dedicated clusters on AWS/GCP/Azure; BYOC available
Hybrid search	Yes — dense + sparse/BM25 multi-vector with reranking, inherited from Milvus
Filtering	Scalar expression filters; partition-key multi-tenancy
Index types	Milvus set — HNSW, IVF variants, DiskANN, RaBitQ, int8, GPU indexes; tiered storage
Proven scale	Billions of vectors across managed customers
Cost at 1M×768d vectors	~3 GB fits the free 5 GB cluster; on serverless ~$0.12/mo storage plus vCU charges

Watch out: vCU accounting is opaque in the same way Pinecone's read units are — cheap storage does not guarantee a cheap bill once query volume rises, and modelling serverless cost ahead of time is guesswork. The serverless tier does not match dedicated clusters on tail latency or on the full index menu, so you may be pushed to dedicated sooner than the pricing page implies. Feature parity with the very latest Milvus release lags by design. Being managed-Milvus means you inherit Milvus's conceptual complexity (collections, partitions, consistency levels) even though you no longer operate it.

Free cluster: 5 GB capacity, up to 2.5M vCUs/month, up to 5 collections. Serverless: $4 per million vCUs plus $0.04/GB/month storage (down from $0.30 in January 2026). Dedicated: $0.096 per CU-hour compute plus $0.02/GB storage, with dedicated plans commonly quoted from about $99/month. BYOC and enterprise tiers are custom.

pgvector

pgvector adds vector, halfvec, bit and sparsevec column types to PostgreSQL with HNSW and IVFFlat indexes, so embeddings live in the same transactional database, the same backup, and the same SQL query as the rest of your data. Version 0.8 introduced iterative index scans (hnsw.iterative_scan set to strict_order or relaxed_order), which fixed the long-standing overfiltering problem where a selective WHERE clause returned far fewer rows than requested; 0.8.x also added parallel HNSW builds that cut index build times 30-50% on multi-core machines. The current release is 0.8.2 (26 February 2026), which fixes a buffer overflow in parallel HNSW builds. It is pre-installed or one CREATE EXTENSION away on RDS, Aurora, Cloud SQL, AlloyDB, Azure, Supabase, Neon and Tiger/Timescale.

Deployment	Self-host or any managed Postgres (RDS, Aurora, Cloud SQL, AlloyDB, Azure, Supabase, Neon)
Hybrid search	DIY — combine tsvector/ts_rank with vector distance yourself; no built-in fusion
Filtering	Full SQL WHERE with joins; iterative scans (0.8+) preserve recall under selective filters
Index types	HNSW and IVFFlat over vector, halfvec, bit, sparsevec; L2/cosine/inner-product/L1/Hamming/Jaccard
Proven scale	Comfortable to ~10M vectors on one node; tens of millions with halfvec/binary quantization
Cost at 1M×768d vectors	~3 GB table plus index — fits a $19-25/mo managed Postgres instance

Watch out: HNSW indexes want to sit in shared_buffers; once the index exceeds RAM, latency degrades sharply and you are into pgvectorscale or a dedicated engine. Index builds on tens of millions of rows are slow and memory-hungry even with parallel builds, and rebuilding blocks capacity planning. There is no native BM25 — Postgres full-text search exists but fusing it with vector scores is DIY SQL, not a hybrid ranker. No sharding: you scale by making one machine bigger. Wrong choice for billion-scale corpora, for thousands of isolated tenants each needing their own index, or when you need sub-10ms p99 at high QPS.

$0 — PostgreSQL License. Cost is whatever your Postgres costs: roughly $19-25/mo for a Neon or Supabase paid instance, ~$120-140/mo for an RDS db.m7g.large, $0 on a box you already own. · open source

pgvectorscale

pgvectorscale complements pgvector with StreamingDiskANN, a disk-optimised graph index derived from Microsoft's DiskANN research, plus Statistical Binary Quantization — a compression scheme that improves on plain binary quantization. The point is cost: HNSW requires the graph in RAM, StreamingDiskANN does not, so tens of millions of vectors can be served from a machine sized for the working set rather than the whole index. Tiger Data's published benchmark on 50M 768-dim Cohere embeddings reports 28x lower p95 latency and 16x higher throughput than Pinecone's storage-optimised index at 99% recall for 75% less cost when self-hosted on EC2 — a vendor benchmark, so treat the multiple as directional rather than literal.

Deployment	Self-hosted Postgres or Tiger Cloud; unavailable on RDS/Cloud SQL/Azure Postgres
Hybrid search	DIY via Postgres full-text search, same as pgvector
Filtering	Full SQL WHERE; label-based filtered search on the DiskANN index
Index types	StreamingDiskANN plus Statistical Binary Quantization (layers over pgvector types)
Proven scale	Benchmarked at 50M×768d on a single node
Cost at 1M×768d vectors	$0 licence; overkill at this size — plain pgvector on a $19-25/mo instance suffices

Watch out: Availability is the real constraint: it is not installable on RDS, Cloud SQL or Azure Postgres, so in practice you either self-manage Postgres or move to Tiger Cloud — which is a smaller vendor bet than the mainstream clouds. Benchmarks come from the vendor and are run at recall targets they chose. It adds a second extension and a second index type to reason about, and StreamingDiskANN's tuning knobs are less documented than HNSW's. Pointless if you are under a few million vectors, where plain pgvector is simpler and equally fast.

$0 for the extension. Tiger Cloud managed Postgres pricing applies if you use their hosting; self-hosting on EC2 costs only the instance. Exact Tiger Cloud tier prices not verified here. · open source

Turbopuffer

Turbopuffer keeps every namespace in object storage and caches on NVMe, which makes idle namespaces nearly free and makes the natural unit of isolation a namespace-per-tenant rather than an index-per-tenant. Queries are billed on data scanned — the base rate dropped from $5/PB to $1/PB in February 2026, with an 80% marginal discount between 32 and 128 GB scanned and 96% beyond 128 GB, against a 1.28 GB minimum billable per query. April 2026 added namespace pinning, which bills GB-hours instead of per-query scan for latency-sensitive namespaces (minimum 128 GB and 10 minutes since August 2026), and single namespaces now shard to 256 TB. The Launch plan minimum fell from $64 to $16/month in June 2026.

Deployment	Managed SaaS; single-tenancy and BYOC on Enterprise only
Hybrid search	Yes — vector ANN and BM25 full-text in one system with documented hybrid patterns
Filtering	Filterable attributes billed per vector column; filters evaluated during scan
Index types	Proprietary object-storage index with NVMe cache; multiple vector columns per namespace
Proven scale	Up to 256 TB in a single sharded namespace
Cost at 1M×768d vectors	~3 GB stored ≈ ~$1/mo, so effectively the $16/mo Launch minimum

Watch out: Closed source, single vendor, no self-host outside an Enterprise BYOC arrangement — a genuine concentration risk for a company this young. Cold-start latency on an unpinned namespace is materially worse than a RAM-resident engine, and pinning to fix it reintroduces a GB-hour bill with a 128 GB minimum, so the headline cheapness erodes for consistently hot workloads. The 1.28 GB per-query billing minimum means many tiny queries against small namespaces cost more per query than the $1/PB rate suggests. Publishing rates only inside a JavaScript calculator makes procurement comparison harder than it should be.

Launch $16/mo minimum usage; Scale $256/mo minimum (audit log streams +$128/mo); Enterprise ≥$4,096/mo with a 35% usage premium, 99.95% SLA, BYOC and CMEK. Queries: $1 per PB scanned base, 1.28 GB minimum billable per query, 80% marginal discount 32-128 GB, 96% above 128 GB. Writes: up to $2.00/GB written with batch discounts up to 50% and a 10 KB minimum per write. Storage: up to $0.33/GB-month. Exact storage and write rates are surfaced only through the on-page calculator rather than a static table.

LanceDB

LanceDB is built on Lance, a columnar file format designed for random access and versioning over object storage, which lets it serve as both a vector index and the storage layer for the multimodal data behind it — images, video frames, audio, features. It runs embedded (no server) directly against S3, GCS or Azure Blob, which makes it the natural fit for ML training and feature pipelines where the same table is scanned for training and queried for retrieval. The company now positions itself as a multimodal lakehouse, with Lance Namespace integrating tables into Hive Metastore, AWS Glue and Unity Catalog. LanceDB Cloud and LanceDB Enterprise exist but carry no public rate card.

Deployment	Embedded (in-process against S3/GCS/Azure), self-hosted, LanceDB Cloud, Enterprise
Hybrid search	Yes — vector plus full-text (Tantivy-based) with reranking, less mature than search engines
Filtering	SQL-style predicates pushed into the columnar scan
Index types	IVF_PQ, IVF_HNSW variants, scalar and binary quantization over the Lance format
Proven scale	Marketing cites 100B+ rows in a single table and 100k+ QPS
Cost at 1M×768d vectors	$0 licence plus S3 storage (~$0.07/mo for 3 GB); Cloud pricing unknown

Watch out: The absence of any published pricing for Cloud or Enterprise is a real procurement problem — you cannot compare it against Turbopuffer or Pinecone without a sales call, and this list marks its price as unknown for that reason. Embedded operation means no server-side concurrency control across writers; multi-writer patterns need care. Hybrid lexical search and filtering are less mature than in Elasticsearch, Vespa or Weaviate. The lakehouse repositioning means the product's centre of gravity is moving toward data engineering, so a team that just wants a RAG index may find more surface area than it needs.

unknown — LanceDB publishes no rate card for Cloud or Enterprise; the site routes to a contact-sales form. Third-party reports of $100 in one-time cloud credits are unverified. The OSS engine and Lance format are free. · open source

Vespa

Vespa is the search engine Yahoo built and open-sourced: it combines ANN, BM25, structured filtering and multi-phase machine-learned ranking (including ONNX model inference and arbitrary tensor expressions) inside a single query plan, with real-time writes and automatic data distribution. It is the only system in this category that treats retrieval and ranking as one problem rather than treating vector search as the whole job, which is why it is the default at organisations serving personalised recommendations and search at scale. Vespa Cloud bills purely for allocated machine resources per hour with no separate per-query charge; the Enterprise plan adds a named representative and on-site support against a $20,000/month minimum spend.

Deployment	Self-host (bare metal/K8s) or Vespa Cloud on AWS/GCP
Hybrid search	Yes — the strongest here; BM25, ANN and ML ranking unified in multi-phase rank profiles
Filtering	Full structured query language with true pre-filtering integrated into the ANN traversal
Index types	HNSW (including multiple vectors per document), plus exact search and tensor operations
Proven scale	Hundreds of billions of documents; among the largest production search deployments
Cost at 1M×768d vectors	$0 self-hosted; a minimal HA Vespa Cloud cluster is a few hundred $/mo at listed resource rates

Watch out: By far the steepest learning curve here: application packages, schemas, rank profiles and tensor expressions are a full framework, and a competent Vespa deployment is weeks of work rather than an afternoon. Resource-hour pricing means an HA production cluster has a substantial fixed floor even at low traffic, and the $20,000/month Enterprise minimum puts full support out of reach for small teams. Documentation assumes search-engine literacy that most application developers do not have. Wrong choice for a straightforward RAG index — you will pay in complexity for capability you never use.

Self-hosted: $0, Apache 2.0. Vespa Cloud Enterprise rates: $0.18 per vCPU-hour, $0.018 per GB-memory-hour, $0.0007 per GB-disk-hour, $0.125 per GPU-GB-hour; default spend quota $10/hour on paid plans. The Enterprise plan carries a $20,000/month minimum spend for its full entitlements. Self-serve pay-as-you-go plans exist at the same resource-based rates without the minimum. · open source

Elasticsearch

Elasticsearch stores vectors as dense_vector fields indexed with HNSW and combines them with BM25 through reciprocal rank fusion or retrievers, inside the same index and the same permissions model as your logs and documents. Better Binary Quantization (BBQ) became the default for vectors of 384 dimensions or more in 9.1, cutting memory by over 95% versus float32, and DiskBBQ reached GA in 9.2, making disk-backed vector search practical for very large indexes on cost-sensitive hardware. Elastic Cloud Serverless prices compute in Virtual Compute Units split across ingest, search and ML, with vector profiles including 50 GB of free storage.

Deployment	Self-host, Elastic Cloud Hosted, Elastic Cloud Serverless, ECK on Kubernetes
Hybrid search	Yes — BM25 + kNN via retrievers and reciprocal rank fusion, plus ELSER sparse retrieval
Filtering	Full query DSL with pre-filtered kNN; document-level and field-level security
Index types	HNSW over dense_vector, int8/int4 scalar quantization, BBQ (default ≥384 dims in 9.1), DiskBBQ (GA 9.2)
Proven scale	Petabyte-scale clusters; billions of vectors with BBQ/DiskBBQ
Cost at 1M×768d vectors	~3 GB raw, under 200 MB with BBQ — inside serverless free storage; realistically ~$95+/mo for a small hosted deployment

Watch out: The licence is not OSI-approved except for the AGPL option, which matters if you intend to embed or resell — and the Elastic/OpenSearch fork means ecosystem tooling is split. JVM memory tuning, shard sizing and heap pressure are the operational tax, and vector-heavy indexes make it worse. Serverless VCU billing is difficult to forecast for spiky ingest, and self-managed clusters with production-grade HA are expensive per byte relative to object-storage-native systems. Wrong choice as a greenfield pure-vector store: you inherit an entire search platform's complexity to use one field type.

Elastic Cloud Serverless: ingest from $0.14/VCU-hour, search from $0.09/VCU-hour, machine learning from $0.07/VCU-hour, storage from $0.047/GB retained per month, egress from $0.05/GB; vector profiles include 50 GB free storage. Elastic Managed LLM $4.50/M input and $21/M output tokens; Elastic Inference Service from $0.08/M tokens. Support ranges from included to 15% of charges. Self-managed Elasticsearch is free under Elastic License 2.0 / AGPL / SSPL; paid subscription tiers unlock security and ML features.

Amazon OpenSearch Service

OpenSearch is the Apache-2.0 fork of Elasticsearch, now governed by the OpenSearch Software Foundation under the Linux Foundation, with a k-NN plugin supporting Faiss, Lucene and NMSLIB engines. Its vector cost story rests on quantization and disk mode: binary quantization with Faiss has been supported since 2.17, disk-based vector search compresses with scalar quantization (the default type from 3.6) or binary quantization, and AWS markets roughly a third of prior cost for equivalent workloads. Amazon OpenSearch Serverless NextGen collections went GA on 28 May 2026 with scale-to-zero after a 10-minute idle timeout and no minimum OCU floor when configured that way — removing the standing bill that made the earlier serverless offering unattractive for small workloads.

Deployment	Self-host, Amazon OpenSearch Service managed domains, OpenSearch Serverless (NextGen)
Hybrid search	Yes — hybrid query with normalization/combination processors fusing BM25 and k-NN
Filtering	Query DSL with efficient pre-filtering on Faiss and Lucene engines
Index types	HNSW and IVF via Faiss, Lucene and NMSLIB; binary quantization (2.17+), disk-based mode with SQ default (3.6+)
Proven scale	Billions of vectors on large managed domains; petabyte log clusters
Cost at 1M×768d vectors	~$25-100/mo on a small managed domain; serverless ~$175-350/mo unless scale-to-zero applies

Watch out: The historic OCU floor made serverless expensive for small workloads; NextGen fixes it but is only months old, so scale-to-zero behaviour under bursty traffic has limited public track record, and cold-start latency after idle is a real cost. Managed domains still require shard and JVM tuning, and blue/green upgrade cycles are slow. Vector performance has historically trailed Elasticsearch's BBQ work and the purpose-built engines. Wrong choice outside AWS, and wrong choice if you want the newest vector features first — OpenSearch tends to land them after Elastic.

Software is $0 (Apache 2.0). Amazon OpenSearch Serverless bills OpenSearch Compute Units at roughly $0.24/OCU-hour, so a two-OCU baseline is about $350/month and a single dev/test OCU about $175/month — but NextGen collections (GA May 2026) scale to zero after 10 minutes idle, leaving only storage. Managed domains bill per instance-hour plus EBS, from roughly $25-100/month for small single-node domains. Exact OCU rate is region-dependent and not independently verified here. · open source

MongoDB Atlas Vector Search

Atlas Vector Search is an index type on your existing MongoDB collections, so the embedding lives in the same document as the payload and can be queried in the same aggregation pipeline as the rest of your application data — no dual-write, no sync job, no consistency window. There is no separate product to buy: you pay for the underlying Atlas cluster. For production you generally add Search Nodes, which decouple search compute from the primary cluster so indexing and querying vectors do not steal CPU and memory from transactional workloads; they run on M10 and above with a minimum of two nodes.

Deployment	MongoDB Atlas managed only (AWS/GCP/Azure); not available in self-managed MongoDB
Hybrid search	Yes — combine $vectorSearch with Atlas Search BM25 via $rankFusion in the aggregation pipeline
Filtering	Pre-filtering on indexed fields inside $vectorSearch; full aggregation pipeline afterwards
Index types	HNSW, with scalar and binary quantization options
Proven scale	Hundreds of millions of vectors with dedicated Search Nodes
Cost at 1M×768d vectors	~$57/mo on an M10 alone; ~$230/mo with the minimum two S20 Search Nodes

Watch out: Running vector search on the primary cluster contends with your transactional workload; running it properly means Search Nodes, which doubles your infrastructure bill and is where the real cost lives. ANN capability is narrower than the dedicated engines — HNSW only, fewer quantization options, less control over index parameters. SSPL makes self-hosting the equivalent stack legally awkward for service providers, and Atlas Search is Atlas-only regardless. Wrong choice if MongoDB is not already your system of record, and wrong choice for very large or very high-QPS vector workloads where a specialist engine costs less per query.

M0 shared cluster free, including basic vector search. Dedicated clusters from about $0.08/hour (M10, roughly $57/month). Dedicated Search Nodes from $0.12/hour (S20) up to $1.77/hour (S60), minimum two nodes on M10+ clusters — so roughly $175/month for the smallest HA search-node pair on top of the cluster. Prices vary by cloud provider and region.

Redis

Redis serves vector similarity search from RAM through the Redis Query Engine (FLAT for exact search, HNSW for approximate), combined with full-text, numeric, tag and geo predicates in one query — and returns results in single-digit milliseconds because there is no disk in the path. Redis 8 merged Redis Stack into a single Redis Open Source distribution, so query and vector capability ship in the base product, and added Vector Sets, a native data type designed by Salvatore Sanfilippo for vector similarity; Vector Sets remain in beta with APIs subject to change, so production work should still use the Query Engine. Its real niche is semantic caching and short-lived agent memory, where RAM residency is the point.

Deployment	Self-host (Redis Open Source), Redis Cloud, Redis Software on-prem, cloud marketplaces
Hybrid search	Yes — Redis Query Engine combines vector KNN with full-text, tag, numeric and geo filters
Filtering	Pre-filter and post-filter hybrid queries in the query engine's syntax
Index types	FLAT (exact) and HNSW; float32/float16/bfloat16/int8; Vector Sets data type in beta
Proven scale	Tens of millions of vectors, bounded by available RAM (or flash via Redis Flex)
Cost at 1M×768d vectors	~3 GB in RAM — well past the 30 MB free tier; an Essentials database of that size runs into the tens of dollars per month and up

Watch out: RAM cost dominates and is the reason Redis loses on large corpora — 1M×768d float32 is roughly 3 GB before index overhead, and Redis Cloud Essentials at that size is meaningfully more expensive per vector than any disk-based system. Vector Sets are still beta as of the Redis 8.x line, so the newer API is not yet a safe production commitment. The 2024 licence change to RSALv2/SSPL (AGPL added in Redis 8) still colours vendor and cloud-provider relationships. Wrong choice as the primary store for a large RAG corpus; right choice as a cache in front of one.

Redis Cloud Free: $0, single 30 MB database, best-effort SLA. Essentials: from $0.007/hour with a $5/month minimum, 250 MB to 100 GB, up to 99.99% uptime. Pro: from $0.014/hour with a $200/month minimum, unlimited RAM, dedicated deployment, active-active multi-region, 99.999% SLA, and Redis Flex for RAM:flash tiering. Redis Open Source is free to self-host. · open source

Amazon S3 Vectors

S3 Vectors adds a vector bucket type to S3 with native APIs for storing and querying embeddings, went generally available in December 2025 with 40x the preview's scale, and expanded to 31 AWS Regions by March 2026. Each index holds up to 2 billion vectors and a bucket holds up to 10,000 indexes, with AWS claiming up to 90% lower total cost to upload, store and query than conventional vector databases. The tradeoff is explicit and AWS states it: infrequent queries return in under a second, frequent queries around 100ms or less — this is durable, cheap, cold-ish vector storage, and AWS positions it as complementary to OpenSearch rather than a replacement.

Deployment	AWS managed only (S3 vector buckets), 31 regions as of March 2026
Hybrid search	No — vector similarity only; pair with OpenSearch for lexical or hybrid ranking
Filtering	Basic metadata filtering on stored key-value attributes
Index types	Managed, not user-selectable; sub-second query target rather than tuned ANN parameters
Proven scale	2 billion vectors per index, 10,000 indexes per vector bucket
Cost at 1M×768d vectors	~3 GB ≈ $0.18/mo storage plus ~$0.60 one-time upload — the cheapest option here by a wide margin

Watch out: Latency is the explicit tradeoff: sub-second is not the same as sub-50ms, and cold indexes are at the slow end of that range, so it is unsuitable for interactive search-as-you-type or high-QPS serving. Filtering and metadata query capability are far thinner than any real database, and there is no BM25, no hybrid ranking, and no reranking — AWS expects you to pair it with OpenSearch or Bedrock Knowledge Bases for those. It is AWS-only and closed, with no export path beyond re-reading your vectors. Wrong choice as the retrieval layer for a latency-sensitive chat product.

$0.06 per GB per month storage, $0.20 per GB for PUT operations, plus a per-query charge scaled by index size; query data processed is $0.002 per TB scanned beyond the first 100,000 vectors per index. No minimum, no provisioned capacity, standard AWS billing. Exact per-query rate tiers vary by region and were not independently verified here.

Cloudflare Vectorize

Vectorize is Cloudflare's vector database for Workers, billed on two metrics only — queried vector dimensions and stored vector dimensions — with no charge for CPU, memory, index hours or number of indexes, and no egress fees. It exists to close the loop with Workers AI and Workers KV so a retrieval app can run entirely at the edge without an origin, and Cloudflare publishes worked examples: 50,000 vectors at 768 dimensions with 200,000 monthly queries costs about $1.94/month, and 500,000 vectors about $23.42/month. Empty indexes cost nothing, and queries count toward usage regardless of whether they come from a Worker, the API or the CLI.

Deployment	Cloudflare managed only, accessed from Workers, the REST API or Wrangler CLI
Hybrid search	No — vector similarity with metadata filters only
Filtering	Metadata filtering on indexed properties; limited operator set
Index types	Managed approximate index, not user-configurable
Proven scale	Low millions of vectors per index — the smallest ceiling in this list
Cost at 1M×768d vectors	768M stored dimensions ≈ $0.38/mo storage plus query dimensions — a few dollars a month, but near the index-size ceiling

Watch out: Index size caps are the binding constraint — Vectorize is designed for indexes in the low millions of vectors, not the hundreds of millions, so it is not a candidate for large corpora. Metadata filtering and hybrid lexical search are basic compared with Weaviate, Qdrant or Elasticsearch, and there is no BM25. It is only sensibly usable from inside the Cloudflare ecosystem; calling it from another cloud adds latency and defeats the point. Closed and non-portable. Wrong choice for anything that is not already a Workers application.

Workers Free: 30 million queried dimensions per month and 5 million stored dimensions, $0. Workers Paid ($5/month for the Workers plan): 50 million queried dimensions included then $0.01 per million; 10 million stored dimensions included then $0.05 per 100 million. No egress fees, no per-index or per-hour charges. Cloudflare's own examples: ~$1.94/month for 50k×768d with 200k queries; ~$23.42/month for 500k vectors.

Azure AI Search

Azure AI Search provides vector fields with HNSW and exhaustive KNN alongside BM25 and a semantic reranker, plus indexers that crawl Blob Storage, SQL and Cosmos DB and chunk and embed documents for you — the integrated-vectorization pipeline is the differentiator against running your own ingestion. In 2026 Microsoft layered Foundry IQ on top as the managed knowledge-base front door for agents in Microsoft Foundry; it is built on Azure AI Search rather than replacing it, and existing custom RAG pipelines do not need to migrate. A serverless preview tier that scales to zero when idle begins billing on 13 September 2026, alongside the long-standing dedicated tiers from Free through Storage Optimized L2.

Deployment	Azure managed only; dedicated hourly SKUs plus a serverless preview (billing from 13 Sept 2026)
Hybrid search	Yes — BM25 + vector with RRF and an L2 semantic reranker
Filtering	OData filter expressions with pre-filtering; Entra ID security trimming
Index types	HNSW and exhaustive KNN, with scalar and binary quantization and stored-vector reduction
Proven scale	Up to 4 TB storage on Storage Optimized L2 SKUs; hundreds of millions of vectors
Cost at 1M×768d vectors	~3 GB exceeds the 50 MB free tier; needs Basic or above — exact price unknown, region-dependent

Watch out: Pricing is opaque enough that this entry cannot state real per-tier numbers, which is itself a procurement problem — you need the Azure calculator and a region before you know what anything costs. Dedicated tiers have hard storage and index-count ceilings per SKU, and outgrowing one means a tier migration rather than elastic scaling; the serverless answer is still preview. Naming churn (Azure AI Search under Foundry IQ under Microsoft Foundry) makes documentation hard to navigate and older guidance stale. Wrong choice outside Azure, and wrong choice if you want control over ANN index parameters.

unknown for exact tier prices — Microsoft's pricing page is region- and SKU-dependent and did not yield firm per-tier figures here. Structure: Free tier (50 MB storage, 3 indexes, $0); dedicated hourly tiers from Basic through Standard S1/S2/S3 to Storage Optimized L1/L2, scaling from 15 GB to 4 TB storage; Serverless preview billed on compute units plus indexed storage, billing from 13 September 2026. Agentic retrieval: first 50M tokens/month free then tiered. Semantic ranker: first 1,000 requests/month free.

Vertex AI Vector Search

Vertex AI Vector Search is the productised form of ScaNN, the algorithm behind Google's own retrieval systems, exposed as a managed index you deploy to an endpoint backed by serving nodes. It handles very large indexes with low latency and integrates directly with Vertex AI embeddings, Gemini and Agent Builder, which is the main reason to choose it. The billing shape is the thing to understand: you pay to build the index per GiB processed and then pay per node-hour for the serving replicas continuously, whether or not queries arrive, so there is a standing monthly floor rather than a usage-proportional bill.

Deployment	Google Cloud managed only; index deployed to a Vertex AI endpoint with provisioned replicas
Hybrid search	Partial — dense plus sparse (token-based) hybrid supported; no full BM25 ranking stack
Filtering	Namespace and numeric restrict filters applied during ANN search; limited expressiveness
Index types	ScaNN (tree-AH and brute force), with configurable approximate neighbour counts
Proven scale	Billions of vectors; the algorithm underpins Google-scale retrieval
Cost at 1M×768d vectors	~$9 one-time build (3 GiB × $3) plus a continuous node-hour floor — a few hundred $/mo for an HA endpoint

Watch out: The always-on serving-node cost is the dominant issue: there is no scale-to-zero, so a low-traffic index still carries a several-hundred-dollar monthly floor, which makes it one of the worst-value options for small or bursty workloads. Index updates are batch-oriented in character and streaming updates carry their own constraints, so it is a poor fit for high-churn corpora. Filtering and hybrid lexical search are thin compared with Vespa or Elasticsearch. GCP-only, closed, with no export path. Wrong choice for anything under roughly 10M vectors or with intermittent query traffic.

Index build: $3.00 per GiB of data processed. Serving: billed per node-hour for the deployed index endpoint, continuously while deployed; a modest index on three replicas is commonly reported around $700-800/month. Exact serving node-hour rates depend on machine type and region and were not verified against Google's rate card here — treat the serving figures as directional.