Write this on the architecture page before you buy a vector database for RAG: we will keep embeddings next to the application data in Postgres until a measured limit forces us out.
That sentence will annoy people who arrived looking for the "best vector database." It will also save them a second system to operate and a second place for permissions to drift. The rest of this article is the argument, the signals that mean you have earned a move, and a current reading of the options if you have.
What a vector database does in a RAG pipeline
A retrieval-augmented generation pipeline turns documents into chunks, turns those chunks into embeddings, stores the embeddings, and at query time retrieves the chunks closest to the question so a model can answer from them. The store in the middle is the vector database. It holds high-dimensional vectors, builds an approximate index over them, and returns nearest neighbors, usually with metadata filters attached.
Approximate is the word to keep in view. Indexes such as HNSW, IVF, and disk-oriented designs like DiskANN trade a little recall for speed. A query can miss a neighbor that an exact scan would have found. That is acceptable only if you measure recall on your own questions. Roro's piece on an LLM evaluation framework is the place to put that measurement, and AI observability is how you keep watching it after launch.
The store also has to stay in step with the source. Chunks get edited, permissions change, and embedding models get replaced. Freshness and a full re-embed are part of the job, along with the first demo query.
Why the default is Postgres
If the product already runs on PostgreSQL, pgvector is the default place to start. The project's README puts the pitch in one line: "Store your vectors with the rest of your data." You get exact and approximate search, HNSW and IVFFlat indexes, half-precision and binary vectors, and the usual Postgres features: transactions, point-in-time recovery, and joins. As of the v0.8.7 line, filtered approximate queries can use iterative index scans so a tight WHERE clause is less likely to starve the result list. The README tells you to turn those scans on, because without them "filtering is applied after the index is scanned."
That last point is why so many early RAG prototypes look fine in a notebook and then miss rows in production. The filter for a tenant, a locale, or a document class runs after the graph walk. If only a thin slice of the corpus should have been visible, the walk may not have visited enough of the right neighborhood. Iterative scans, partial indexes, and a recall check on filtered queries are the fix you try inside Postgres before you introduce a new vendor.
Memory is the other constraint. In an 18 August 2026 AWS Database Blog post, Steve Dille and Vinodh Manickam write that "when your HNSW index grows past available instance memory, most queries incur disk I/O at the lower graph layers and latency degrades from milliseconds to seconds." They size a full-precision HNSW index at 768 dimensions at "approximately 3.7 GB per million vectors (367 GB / 100M)." Binary quantization, they report, "compresses each vector to a single bit per dimension, shrinking a 100-million-vector index from 367 GB to ~38 GB so it can fit in the buffer cache of standard instances," with a reranking step against full-precision vectors to recover some of the lost accuracy. They also warn that "some recall loss is inherent, because relevant results excluded in the initial binary search cannot be recovered," and that "not all embedding models produce vectors that quantize well."
Postgres can go further than a lot of "you will outgrow it at a million rows" threads claim. The same AWS post notes that Ring "stores between 100-200 billion embeddings and ingests approximately 2 billion new embeddings daily for semantic video search on Amazon RDS for PostgreSQL." Treat that as proof that the engine can be pushed, with serious engineering, rather than as a promise that your current instance will behave the same way. Your bar remains a measured one: recall after filters, p95 or p99 latency under concurrent load, and whether the index still fits in cache after a realistic week of writes.
You stay in Postgres while those numbers hold, and while joins, row-level security, and a single backup story still outweigh a specialist's extra features. You also stay while the corpus is being designed, because chunking and metadata change quickly in the first months, and one database is easier to revise.
The signals that mean you have earned a move
Leave when a test on your data, with your filters and your concurrency, shows a gap that Postgres tuning, quantization, and iterative scans do not close.
The working set of the HNSW graph no longer stays in memory, and latency has stepped from milliseconds into a range users feel, even after binary or half-precision indexes and a check that maintenance_work_mem and autovacuum are in a sane place.
You need first-class hybrid retrieval, meaning a lexical score (BM25 or equivalent) fused with a dense-vector score in one request, and the fusion has to hold up at the size you are running. Postgres can combine tsvector search with pgvector, and teams do ship that. A search engine or a specialist store often makes the fusion less of a custom job. Elasticsearch documents hybrid search as full-text and vector search in one request, and recommends reciprocal rank fusion to merge the two rankings.
Write churn is constant, or you are about to re-embed the whole corpus after a model change. Postgres MVCC will keep old row versions until vacuum reclaims them. A dedicated engine can still hurt during a full rebuild, though that rebuild is usually a first-class operation.
You need horizontal sharding of a dense index, multi-region serving of the vectors, or a latency target under high concurrency that a vertically scaled Postgres primary cannot meet after obvious tunings.
You need tenant isolation as a product feature of the store, with per-tenant indexes or a documented multi-tenancy mode, and partitioning in Postgres is no longer keeping each query inside a small slice of the graph.
When you do leave, keep Postgres as the system of record if the rest of the product already lives there. The document, the ACL, and the embedding do not have to sit in the same process. A change-data-capture stream or a batch job can push vectors out, and the application can join IDs back. You give up a single-transaction write across both stores. You keep one place where permissions and source text are true.
Watch this video for a practitioner walkthrough -
What actually moves retrieval quality
A vector database comparison that only ranks QPS will not tell you whether the RAG answers get better. The levers that usually move quality, once the store can meet a latency bar, are closer to the retrieval design than to the logo on the invoice.
Hybrid search helps when users type identifiers, names, or error codes that embeddings blur. Dense search helps when they paraphrase a policy or a symptom. Most production RAG traffic is a mix, so plan for both. Reranking a short candidate list with a cross-encoder or a hosted rerank model often buys more quality than a vendor swap, at a cost in latency and request units. Pinecone and MongoDB Atlas sell reranking next to the index; you can also run a model yourself.
Metadata filters have to be part of the recall test. A store that looks strong on unfiltered nearest-neighbor charts can drop neighbors once a tenant or a time window is applied. Multi-tenancy, freshness, and access control belong in the same test, because a fast answer drawn from the wrong tenant is a failure.
Quantization is a quality decision as well as a cost one. Scalar (int8) and binary compression shrink RAM, which is what most invoices are really billing. They also change recall. Validate on your embeddings, as the AWS authors advise, and keep a rerank against full-precision vectors if you go binary.
None of this replaces a golden set of real questions. If you are still deciding whether retrieval is the right approach, start with RAG vs fine-tuning. If an agent sits around the retriever, the no-code AI agent builder field test and the orchestration post are useful companions.
Once you leave: the main options in November 2026
Prices and packaging move. The figures below come from official pages as they stood in mid-November 2026. Confirm them before you buy. Self-host options exist for the open-source engines; the cloud prices are what a team pays to avoid running them.
Option | Start here if | Official shape and price (mid-November 2026) | Check before you commit |
|---|---|---|---|
pgvector on Postgres | You already run Postgres and the measured bar still holds | Open-source extension. You pay for the Postgres instance, with no separate vector invoice. | Filtered recall with iterative scans; index size versus cache |
Pinecone | You want a managed service and will pay a usage floor for it | Proprietary, managed, with a BYOC option. Starter is free with caps. Builder is $20/mo flat. Standard has a $50/mo minimum, then $0.33/GB-month storage, about $4 to $4.50 per million write units, and about $16 to $18 per million read units, varying by region. Dense, sparse, and full-text indexes are listed. | How read units move with your queries, and whether usage clears the $50 floor |
Weaviate | You want hybrid search and multi-tenancy in an open-source core | BSD-3-Clause core; Weaviate Cloud is managed. Cloud Free allows 100,000 objects. Flex starts at $45/mo, with vector dimensions from $0.00465 per million, plus storage. Premium is a prepaid contract; the pricing FAQ lists a Premium minimum from $400/mo. Hybrid search and multi-tenancy are listed on all cloud plans. | Dimension rates after compression, and whether Flex's shared cluster fits |
Qdrant | You want an open-source engine with resource-based cloud billing and no per-query fee | Apache 2.0, plus Qdrant Cloud, Hybrid, and Private Cloud. Free tier: 0.5 vCPU, 1 GB RAM, 4 GB disk, described as enough for about one million 768-dimension vectors. Standard is billed hourly for vCPU, RAM, disk, backups, and paid inference tokens, with a 99.5% uptime SLA. | A calculator estimate for RAM after quantization; snapshot and HA choices |
Milvus / Zilliz Cloud | Very large collections, or Milvus without running it yourself | Milvus is Apache 2.0; Zilliz Cloud is managed. Free and serverless tiers are offered. Dedicated types are listed from $63 per million vectors/month (performance-optimized, about 2 million 768-dimension vectors per CU) down to $16 (capacity-optimized) and a cheaper tiered-storage option, based on 768-dimension evaluations. | CU capacity with your metadata attached; serverless versus dedicated |
MongoDB Atlas Vector Search | The operational data already lives in MongoDB | Included with Atlas, Enterprise Advanced, and Community under MongoDB's licenses. Official positioning is to "avoid the synchronization tax" by keeping operational and vector data together, with hybrid queries, independent scaling of vector search, quantization, and native reranking. | Whether embeddings are generated inside Atlas or brought in from your own model |
Elasticsearch / OpenSearch | You already run a search cluster, or lexical quality is as important as dense recall | Elastic's licenses for Elasticsearch; OpenSearch is open source. Elastic documents hybrid search in one request and recommends RRF to merge full-text and kNN rankings. Billing follows the search product's own meters. | Cluster sizing for inverted and vector indexes, and hybrid ranking on your queries |
turbopuffer | Object-storage-backed search with a low usage floor | Commercial and managed. Launch minimum $16/month. Indexed storage up to $0.33/GB-month, writes up to $2/GB, queried data up to $1/PB. A published calculator example showed about $7 usage for 1 million 1,024-dimension documents before the $16 floor. | Query billing (namespace size floors and discounts). The FAQ says they do not currently offer self-serve migration tools |
Chroma | Local or self-hosted prototypes only, if you choose it at all | Open-source ChromaDB remains Apache 2.0. Chroma Cloud is winding down: a 23 October 2026 notice says writes stop on 7 December 2026 and reads stop on 22 December 2026. Replit will keep contributing to the open-source project. | Do not start new production work on Chroma Cloud. Export anything still there before 22 December 2026 |
LanceDB | Embedded or lakehouse-style pipelines where vectors sit with files you already store | Confirm the current open-source and commercial terms on the vendor site. Do not lean on third-party price roundups. | How the embedded path and any commercial offering map to your ops model |
A short vector database comparison like this is only a shortlist. Run your own corpus through two finalists, with filters on, before you sign anything.
Watch this video as a visual tour of the usual suspects, and believe your own numbers first -
Cost at scale, with a labeled sketch
The invoice is usually a story about RAM, minimums, and query volume. Quantization cuts the first of those. The AWS sizing above, 3.7 GB of full-precision HNSW per million 768-dimension vectors, implies on the order of 37 GB of index at ten million, which is why binary quantization (down to about 38 GB at 100 million in that post) changes both the hardware and the bill.
Minimums change the math at small scale. Pinecone Standard starts at $50 per month, Weaviate Flex at $45, and turbopuffer Launch at $16. Qdrant Cloud's free tier covers a small prototype, then you pay for the cluster you size. Below those floors, pgvector on a database you already run is often cheaper, because the incremental cost is memory and disk on an instance that already has a budget line.
Here is an illustrative composite, used only as a cost sketch, with official unit prices as of mid-November 2026. Suppose the corpus is 2 million chunks at 1,536 dimensions, stored as float32. The raw vectors alone are 2,000,000 x 1,536 x 4 bytes, which is 12.3 GB. Scaling the AWS 768-dimension HNSW figure linearly with dimensions would put a full-precision index in the mid-teens of gigabytes; treat that as a planning estimate, then measure.
On Pinecone Standard, 12 to 20 GB of storage at $0.33 per GB-month is about $4 to $7, so the $50 minimum would dominate until read and write units grow past it. On Weaviate Flex, 2 million x 1,536 is 3.072 billion dimensions; at the published Flex list rate of $0.00465 per million dimensions, the dimension line is about $14, plus storage, against a $45 minimum (compression can discount the dimension rate). On turbopuffer, the vendor's own calculator example for 1 million 1,024-dimension documents came to about $7 of usage, billed at the $16 Launch minimum; a 2 million, 1,536-dimension corpus would need a fresh run of that calculator. Qdrant and Zilliz need their size and CU calculators, because you are buying RAM and compute rather than a simple dimension meter. In all of these, a realistic week's query volume, including retries and rerank calls, is the term that most often surprises people after a quiet proof of concept.
A model swap rewrites every vector, which means write units, a cluster rebuild, or a vacuum bill. Budget for that event.
How to read a benchmark
ANN-Benchmarks plots recall against queries per second for nearest-neighbor algorithms on public datasets. The project's GitHub README now says the suite "is no longer actively maintained" and asks people to consider other benchmarks such as VIBE. It is, by design, a test of algorithms more than of a full database, and the maintainers "mainly support CPU-based ANN algorithms." Use an old chart to understand an index family. Do not use it as a vendor bake-off for a 2026 RAG purchase.
VectorDBBench is an open-source tool for running database-level cases, including filtered and larger datasets. Zilliz, which commercializes Milvus, created it. The tool is still usable if you run it yourself, on hardware you specify, and read QPS only next to the recall it was measured at. Zilliz's own benchmarking guidance notes that latency tests are "heavily influenced by network conditions, especially for cloud products accessed through public networks," and that "relying solely on recall metrics is insufficient for evaluating query performance."
For a RAG purchase, the benchmark that counts is yours: real questions, real filters, a measured rerank, and a cost model that includes the re-embed you will eventually run.
If Postgres already holds the answer, keep it there. If you have hit the edges above and want help designing the retrieval path, or the evaluation around it, Roro builds products that have to hold up after launch. You can reach the team through the contact form.
FAQ
What is a vector database for RAG?
A vector database for RAG stores the embeddings of your chunks, builds an approximate index over them, and at query time returns the nearest neighbors, usually with metadata filters, so a language model can answer from those chunks. It sits alongside chunking, the embedding model, optional hybrid search and reranking, and an evaluation set.
Do I need a dedicated vector database to ship RAG?
No. If you already run Postgres and a measured test of recall, filtered queries, and latency still holds, pgvector is a sound production starting point. Add a dedicated store when that test fails, or when you need something Postgres cannot give you at your size, such as first-class hybrid fusion at scale or horizontal sharding of the dense index.
What is the best vector database for RAG?
The one that meets your recall, filtered-query, latency, and cost bar, and that you can operate. Managed specialists such as Pinecone, Weaviate Cloud, Qdrant Cloud, and Zilliz, or a search engine such as Elasticsearch, are reasonable finalists once you have left Postgres. Rank them with your corpus and your filters. A generic leaderboard will not do that work.
When should a team move off pgvector?
Move when the HNSW working set no longer stays in memory and latency stays user-visible even after quantization and tuning, when hybrid retrieval or horizontal scale is a hard requirement, when write churn or a full re-embed is stressing the database, or when tenant isolation can no longer be kept inside a small slice of one graph. Measure those conditions on your data before you migrate.
Does hybrid search matter in a RAG pipeline?
It does when queries contain exact strings, such as names, IDs, or error codes, as well as paraphrases. Fusing a lexical score with a dense-vector score, then reranking a short list, is often the quality upgrade a vendor swap will not give you by itself. Elasticsearch, Weaviate, Pinecone, and MongoDB Atlas all offer first-class ways to do that fusion.
How should I read vector database benchmarks?
Read recall next to throughput, and prefer tests that include metadata filters. ANN-Benchmarks is a useful algorithm reference and is no longer actively maintained. VectorDBBench can compare full databases if you run it yourself and remember that Zilliz created it. For a purchase, run your own questions against two finalists and include cost, updates, and a re-embed in the write-up.
Sources
- pgvector, README.
- Steve Dille and Vinodh Manickam, Scale pgvector with binary quantization on Amazon Aurora PostgreSQL, AWS Database Blog, 18 August 2026.
- Pinecone, Pricing.
- Weaviate, Pricing.
- Qdrant, Cloud Pricing.
- Zilliz, Zilliz Cloud Pricing.
- MongoDB, Vector Search.
- Elastic, Hybrid search.
- turbopuffer, Pricing.
- Chroma, Chroma Cloud wind-down timeline, 23 October 2026.
- ANN-Benchmarks and its GitHub README.
- Zilliz, VectorDBBench and Benchmarking Vector Database Performance.

