The insurer's retrieval team has a working prototype: guidance passages, Corpus A applicant profiles and Corpus B underwriter precedents, searched by the underwriting agent. Before production, someone shares a comparison chart: fourteen vector databases down the side, a dozen feature columns, a sea of green checkmarks. The message under it says: "Pick the one with the most ticks?"
The chart looks like an answer, but the agent's problems are specific. This site's case UW-R02 is a query that is the exact rule id R-SPRK-01; vector search alone ranks it low. Case UW-R01 is a broker who writes that the roof was redone a while back, with no rule id in sight; keyword search finds nothing. Case UW-R07 is a precedent from another tenant that must never appear. A column that says "metadata filtering ✓" does not say whether the tenant filter runs before or after the nearest rows are chosen, and that difference is a leak.
This page first sorts the names by kind, then reads the chart column by column, then shows what it leaves out, and ends with a matrix read on the vendors' own documentation on 2026-11-18.
What this is not. This page does not compare quality or speed; nothing here was benchmarked. Google Cloud products are on Google Cloud choices. How retrieved text is placed in the model's context window belongs to context.sammuthu.com.
One primitive, four kinds of product#
Every product on the chart serves the same primitive. An embedding column holds one vector per row, a list of numbers that places the row's text in a space of meaning. A vector query compares the query's vector with the rows' vectors, ranks the rows by distance and returns the nearest k. The model reads only what retrieval returned. Retrieval is a query. The model reads only what it returns.
What differs is how much of the system around that primitive the product gives you.
Before AI. Keyword search had the same four shapes. Lucene is a library you link into your program, owning its files and backups. PostgreSQL full-text search is a feature inside a database you already run. A search engine server stores documents and answers over the network. A hosted search service is that engine run by someone else.
A library is code you call inside your own process. It has no server, no network API and no access control. FAISS is the example here: a C++ library with Python wrappers for similarity search and clustering of dense vectors, MIT licensed, with exact indexes (IndexFlatL2, IndexFlatIP) and approximate ones such as HNSW and IVF variants, as documented on 2026-11-18. The approximate index mechanics are on ANN indexes.
An extension adds vector types and operators to a database you already run, so vectors sit next to your rows and share their transactions and backups. pgvector does this for PostgreSQL (pgvector); sqlite-vec does it for SQLite with a vec0 virtual table (SQLite). On this site they are extensions, not vector databases.
An engine is a server whose main job is search: Milvus, Qdrant, Weaviate, Vespa, Vald, Chroma, Redis with its search and query features, and Elasticsearch and OpenSearch, which are full-text engines that added vectors. You deploy it and query it over a network API.
A managed service is an engine you do not operate. Pinecone and Vectara are offered as services; many engines also have a managed edition, such as Qdrant Cloud, Weaviate Cloud, Zilliz Cloud for Milvus, Elastic Cloud, Redis Cloud and Chroma Cloud.
Diagram: Four kinds of product run the same vector query and own different amounts of the system
Read left to right: each step owns more of the system for you, and leaves less for you to see and run. A column on a comparison chart means something different for each kind.
- Library
- FAISS: Owns the math and the index in memory; no server, no filter, no backup.
- Extension
- pgvector, sqlite-vec: Adds vector types and operators; vectors share the rows' transactions and backups.
- Engine
- Dedicated search server: A server whose main job is search: stores data, filters, fuses, answers over a network.
- Managed service
- Run by the vendor: An engine you do not operate; storage, scaling and often embedding move to the vendor.
Moving right, the product owns more of the system and you own less. A column on a chart is only meaningful once you know which kind of product it describes: "Backup ✓" means something different for a library, which has no backup, than for a database extension, which inherits the database's backup.
The smallest primitive: the same question in three kinds of product#
Here is the guidance search for case UW-R03, "current roof rules for this tenant", in three kinds of product. The first is SQL with pgvector; the other two are the call shapes as documented on 2026-11-18, not run here.
Extension (pgvector, SQL):
SELECT passage_id FROM guidance_passages
WHERE policy_version = $2 AND tenant = $3
ORDER BY embedding <=> $1 LIMIT 50
-> filter, ranking and join back to the row in one statement
Engine (Qdrant Query API):
POST /collections/guidance/points/query
with nested "prefetch" sub-queries (one dense, one sparse) fused by RRF
-> the payload filter rides with each sub-query
Library (FAISS):
an IndexFlatIP over normalized vectors returns ids and scores
-> no filter, no rows: your code maps ids to passages and drops other tenants
Look at where the tenant condition lives: a WHERE clause, part of the request, or nowhere. In the library your code must filter, and if it filters after the top 50 were chosen, case UW-R07 can leak or come back empty. That difference matters more for this agent than most chart columns.
How to read a vector-database comparison chart#
Back to the shared chart. Some of its thirteen columns decide the insurance agent's choice, some barely matter, and the most important questions are not on it. Read each column for its plain meaning, why it matters and when it decides.
Open source / self-host#
Plain meaning: you may run the software on your own machines, under a license that lets you. For the insurer, self-hosting matters if guidance and precedents must stay inside its own network. Read the license, not the tick. As documented on 2026-11-18, Weaviate is BSD-3-Clause with enterprise files under a commercial license, Elasticsearch source is available under AGPLv3, SSPL and ELv2, and Marqo's open-source project is deprecated and will no longer receive updates.
Managed cloud#
Plain meaning: the vendor runs it for you. This decides the choice for a small team with no one to operate a cluster. "Managed" is not one thing: Zilliz Cloud lists Serverless, Dedicated and BYOC (bring your own cloud, where it runs in your cloud account), and Pinecone documents BYOC too. Those shapes differ in where the data sits.
Built-in embeddings#
Plain meaning: the database turns your raw text into vectors itself, so you send text, not numbers. Example: you insert the passage text of R-ROOF-03 and the service calls an embedding model at write time and again at query time. This is called a built-in embedding. It removes a moving part and moves a decision: the service now chooses and runs the model, which an audited workflow must still record. Chroma's default embedding function runs Sentence Transformers all-MiniLM-L6-v2 locally; MongoDB's autoEmbed uses Voyage AI models and is Preview.
Hybrid search#
Plain meaning: one request runs a keyword search and a vector search and merges the two ranked lists. This decides the choice for almost every enterprise corpus with identifiers: R-SPRK-01 needs keywords (UW-R02), "the roof was redone a while back" needs vectors (UW-R01). Fusion is on hybrid search; "hybrid" names at least three mechanisms, covered below.
Metadata filtering#
Plain meaning: restrict results by exact fields such as tenant, policy_version or status. It always matters for this agent, because similarity cannot tell a current rule from a superseded one: the 2025.4 roof rule and the 2026.2 rule are nearly the same text. The tick hides the question that decides: does the filter run inside the search, before the nearest k are chosen, or after? Pre-filtering versus post-filtering is explained on exact search and retrieval pipelines.
BM25#
Plain meaning: the classic keyword-scoring formula that rewards rare query words and corrects for document length. A real BM25 on the keyword side is what makes an exact id like R-SPRK-01 rank first. The formula is on SQL first. Read the cell carefully: OpenSearch's page shows a match query without naming BM25, and Chroma describes a "BM25-style" sparse pattern.
Full-text search engine#
Plain meaning: more than a scoring formula. Tokenizers, stemming, phrase queries and languages. It decides when people search policy text by phrase, such as "roof covering". Pinecone documents phrase and term matching ($match_phrase, $match_all, $match_any); Elasticsearch and OpenSearch are full-text engines first.
Multiple vectors per point#
Plain meaning: one stored record carries several vectors, for example one for a passage's title and one for its body, or one per token. Per-token vectors enable late interaction, where query tokens are matched to document tokens at query time; that technique is on advanced retrieval. Milvus documents several vector fields per entity; Weaviate added multi-vector support in v1.29.
Tensor search#
Plain meaning: storing and comparing a matrix of numbers rather than one list. It is the general form behind per-token vectors. Vespa documents ColBERT tensors scored with MaxSim, and notes they are used for ranking, not for the approximate retrieval step. It seldom decides a first RAG system.
Streaming index#
Plain meaning: a new or changed record becomes searchable without rebuilding the index. Example: an underwriter decides a case at 10:00 and the precedent is retrievable for the next submission at 10:05. That property is called a streaming index. It decides the choice for Corpus B, which grows with every decision. Some indexes need a training step that makes this harder: FAISS IVF indexes must be trained, while a pgvector HNSW index can be created on an empty table. Google's Vector Search fixes the choice at creation; a batch index cannot become streaming.
Framework integrations (LangChain, LlamaIndex)#
Plain meaning: a ready connector in a popular library. It is the least important column, for two reasons. A thin client for any database is quick to write and keeps the query visible (recipes shows one next to raw SQL). And connectors churn: the langchain-postgres README deprecates PGVector for PGVectorStore from v0.0.14, while the LangChain docs page for PGVector read on the same day does not mention it. Never choose a database on this column.
Metadata / document size#
Plain meaning: how much data you may store next to each vector. It decides whether passage text lives in the vector store or in a table joined by id. Pinecone caps metadata at 40 KB per record, as documented on 2026-11-18. For most other rows the pages read state no cap.
Max dimensions#
Plain meaning: the longest vector the product accepts, and often a lower limit for vectors it can index. It must fit your embedding model. Elasticsearch's dense_vector takes up to 4096 dimensions. pgvector stores vector up to 16,000 dimensions but indexes it with HNSW or IVFFlat only up to 2,000, and halfvec up to 4,000. So a 3072-dimension model fits pgvector's column but not its vector index; halfvec or a shorter output would. The insurer's 384-dimension vectors fit every limit stated on the pages read.
What the chart leaves out#
A checkmark says a feature exists, not how well it works on your data. The questions that decide a production choice are mostly missing:
| Missing from the chart | Why it decides more than a tick |
|---|---|
| Filtered-search behavior | A selective tenant filter after an approximate scan can return fewer than k rows (UW-R09) |
| Recall at a given latency | Approximate indexes trade found neighbors for work; only your labeled queries show the trade |
| Index types | HNSW, IVF, DiskANN-style and flat indexes behave differently under updates and memory limits |
| Quantization | Fewer bits per number saves memory and can cost recall |
| Update cost | Inserts, deletes and rebuilds have different costs per index type |
| Multi-tenancy | Namespaces, partitions or one index per tenant: different isolation guarantees |
| Backup and restore | A library has none; an extension inherits the database's; a service has its own |
| Security controls | Network isolation, encryption keys, access control on rows |
| Total cost | Memory, replicas and operations time, which no chart can show |
The framework column is visible and the filtered-search column is not. That is the chart's quiet bias: it shows what is easy to tick.
Diagram: Reading a checkmark: what the tick says, what it hides, what to test
A tick on a chart says a feature exists. Follow each row to the question it hides and the test that answers it for the insurance agent.
- The tick says
- Filtering: yes: The product can restrict results by metadata fields.
- Hybrid: yes: The product can combine a keyword search and a vector search.
- It hides
- Before or after top-k?: A filter after the nearest rows are chosen can return too few rows or leak.
- Which fusion?: Rank fusion, a score blend, or two queries you merge; defaults differ.
- Test it
- Smallest-tenant query: Query the smallest tenant and assert k rows, all from that tenant.
- Exact id plus paraphrase: Check that the exact id ranks first and the paraphrase still finds the rule.
Each tick leads to a hidden question and to a test on the insurer's own cases.
"Hybrid" means three different things#
A hybrid tick hides the fusion method, and the method changes results. Some products fuse by rank with Reciprocal Rank Fusion (RRF), which adds one over a constant plus the rank from each list; see hybrid search. Some blend scores: Weaviate's default fusion is relativeScoreFusion since v1.24, and Vectara blends lexical and vector scores linearly with lexical_interpolation. And some leave fusion to you: Pinecone documents client-side RRF over separate searches as one pattern.
Even "RRF" is not one setting. Qdrant's default constant k is 2, configurable since v1.16.0. Elasticsearch's rrf retriever defaults rank_constant to 60 and rank_window_size to 10. Redis FT.HYBRID defaults to RRF with CONSTANT 60 and WINDOW 20. Two products that both say "RRF" can rank R-SPRK-01 differently out of the box; test the defaults on UW-R02.
The 14-database matrix, read on 2026-11-18#
The lab filters the matrix by the columns that matter most for the insurer: hybrid search, filtering, built-in embeddings, multiple vectors per point, open source and managed. A "docs do not say" cell shows as unknown, never as a pass or a fail. The table after it is the matrix itself, every cell as recorded. "docs do not say" means the pages read did not state it; it does not mean the feature is missing.
| Database | Open source / self-host | Managed cloud | Built-in embedding | Hybrid (fusion) | BM25 / full-text | Filtering | Multi-vector |
|---|---|---|---|---|---|---|---|
| Pinecone | No OSS stated; BYOC (runs in your cloud account) | Yes | Yes (integrated embedding, hosted models) | Yes (one index; RRF for client-side fusion) | Yes (BM25, Lucene syntax) | Yes | docs do not say |
| Qdrant | Yes (Apache 2.0) | Yes (Qdrant Cloud, free tier) | Partial: Cloud Inference on Qdrant Cloud; BM25 sparse generated in-cluster; self-hosted docs recommend client-side FastEmbed | Yes (RRF, DBSF) | Yes (BM25 on full-text-indexed payload; sparse vectors) | Yes (payload filters) | Yes (multivector, ColBERT) |
| Weaviate | Yes (BSD-3-Clause; wl/ enterprise files commercial) | Yes (Weaviate Cloud) | Yes (vectorizer integrations, e.g. OpenAI, Cohere, HF, Jina) | Yes (relativeScoreFusion default since v1.24; rankedFusion) | Yes (BM25) | Yes | Yes (since v1.29; ColBERT, ColPali, ColQwen) |
| pgvector | Yes (repo has LICENSE; name not shown on page) | docs do not say | No (stores and queries vectors only) | Yes, with Postgres full-text search (RRF or cross-encoder, done in SQL) | Via Postgres full-text search | Yes (exact, partial indexes, iterative scans) | docs do not say |
| Vespa | docs do not say (pages read) | docs do not say (pages read) | Yes (embedders run inside Vespa: Hugging Face, ColBERT, SPLADE) | Yes (reciprocal rank in hybrid-rrf profile) | Yes (BM25 per field) | Yes (AND/OR/RANK operators) | Yes (ColBERT tensors, MaxSim; for ranking, not ANN retrieval) |
| Milvus | Yes (Apache 2.0, LF AI & Data) | Yes (Zilliz Cloud: Serverless, Dedicated, BYOC) | Yes (BM25 function makes sparse vectors; Function module calls OpenAI, Bedrock, Vertex, Voyage and others for dense, 2.6.x) | Yes (hybrid_search, RRFRanker / WeightedRanker) | Yes (native BM25) | Yes | Yes (multiple vector fields per entity); ColBERT docs do not say |
| MongoDB Atlas Vector Search | Yes, self-managed on recent Community versions (check the compatibility page) | Yes (Atlas) | Yes, Preview (autoEmbed, Voyage AI; Atlas + Community, not Enterprise) | Yes ($rankFusion, $scoreFusion; RRF not named on page) | Yes ($search full-text; BM25 not named) | Yes (filter fields) | docs do not say |
| Marqo | OSS deprecated ("will no longer receive updates"); repo Apache-2.0 | Yes (now an e-commerce search platform) | docs do not say | docs do not say | docs do not say | docs do not say | docs do not say |
| Vectara | docs do not say (has "Private deployment" option) | Yes (SaaS) | Yes (generates document and query embeddings) | Yes (lexical_interpolation, linear blend, not RRF) | Yes (1.0 = BM25) | Yes (SQL-like metadata_filter) | docs do not say |
| Elasticsearch | Yes (source: AGPLv3, SSPL, ELv2; AGPL added Sept 2024) | Yes (Elastic Cloud) | Yes (semantic_text + inference endpoints, ELSER, EIS) | Yes (RRF retriever) | Yes (BM25 default similarity) | docs do not say (pages read) | Yes (rank_vectors, max-sim late interaction, Preview since 9.0) |
| OpenSearch | Yes (Apache 2.0, LF Projects) | docs do not say (pages read) | Yes (ML Commons text_embedding ingest processor + neural query) | Yes (normalization processor or RRF via score-ranker / fusion mode) | Yes (match query; BM25 not named on page) | Yes (pre/post-filtering pages) | docs do not say |
| Chroma | Yes (Apache 2.0; local or self-host) | Yes (Chroma Cloud, serverless) | Yes (embedding functions; Cloud SPLADE auto-generates sparse) | Yes (Rrf; docs shown under /cloud/) | Keyword + regex search; BM25 only as "BM25-style" sparse pattern | Yes (.where) | docs do not say |
| Vald | Yes (Apache 2.0, Kubernetes/Helm) | docs do not say | No (you convert data to vectors yourself) | docs do not say | docs do not say | docs do not say (Filter Gateway listed, not explained) | docs do not say |
| Redis | Yes (Redis Open Source; license not on pages read) | Yes (Redis Cloud) | docs do not say | Yes (FT.HYBRID since 8.4.0: RRF default, LINEAR) | Yes (BM25STD default scorer) | Yes (TEXT, TAG, NUMERIC, GEO filters) | Yes (multiple vectors per JSON path, multi-value indexing) |
Two readings matter. The "docs do not say" cells are gaps in what two or three pages per product confirmed on one day, not gaps in the products; close the ones that matter with the vendor's documentation or a test. And no filtering cell says whether filtering runs inside the approximate search: the insurer must answer that with a test.
Sources per database (read 2026-11-18):
- Pinecone: hybrid search, overview
- Qdrant: hybrid queries, inference, repository
- Weaviate: hybrid search, multi-vector tutorial, repository
- pgvector: repository
- Vespa: hybrid search tutorial, embedding
- Milvus: full-text search, multi-vector search, embedding functions, repository
- MongoDB Atlas Vector Search: hybrid search, automated embedding, deployment options, self-managed compatibility
- Marqo: repository
- Vectara: hybrid search, filters
- Elasticsearch: hybrid with semantic_text, rank_vectors, similarity, licensing FAQ, repository
- OpenSearch: hybrid search, repository
- Chroma: introduction, hybrid search, sparse vectors
- Vald: repository
- Redis: vectors, FT.HYBRID
Changed since earlier charts. Pinecone now documents BM25 full-text search, hybrid search from one index and hosted integrated embeddings. Redis added one-command hybrid search, FT.HYBRID, in 8.4.0. Milvus has native BM25 full-text search. Weaviate added multi-vector support in v1.29. Elasticsearch source is also available under AGPLv3 since 2024. MongoDB Vector Search now runs self-managed. Marqo's open-source project is deprecated.
What goes wrong when you choose by checkmarks#
Suppose the team picks the product with the most ticks and builds Corpus B on its approximate index with a tenant filter. The filtering column said "Yes", and tests with one tenant pass.
In production one small book of business holds a few percent of the precedents. A query for that tenant gets the index's usual candidate list, and the filter then removes every other tenant's rows. The pgvector README gives the arithmetic for its own case: if 10% of rows match and hnsw.ef_search is 40, about 4 rows survive on average. The agent receives four precedents, or none, and reasons from too little evidence. That is this site's case UW-R09. If the filter step is skipped by a bug, the same design returns other tenants' precedents, case UW-R07.
The chart cannot show this. The fix is a property, not a product: filtering that runs inside the search (pgvector's iterative scans, Qdrant's filter-aware index built after payload indexes exist, AlloyDB's inline filtering) or a separate index per tenant, and a test that queries the smallest tenant and asserts at least k rows from that tenant only.
The second failure comes from the built-in embedding column. If the service embeds text with a model it chooses, record which model produced each vector. When that model changes and your stored vectors do not, query and rows no longer share one space, and results look plausible and are wrong: case UW-R06. Prefer a design where the model name is stored with every vector and a mismatched query is refused.
In the insurance build. In that build, both corpora are tables in PostgreSQL 16 with pgvector: an extension, not a dedicated engine. Corpus A filters first on state, zip3 and dwelling type, then sorts byembedding <=> :q, and useshnsw.iterative_scan = relaxed_orderwhen pgvector is 0.8 or later. Corpus B has no ANN index at all; its filtered sets are small enough for an exact sort.
In Mnemos. In the code read, Mnemos keeps everything in one SQLite file with the sqlite-vec extension: chunks in ordinary tables, vectors in a vec0 virtual table joined by chunk id. Retrieval is dense only, with no BM25 and no reranker. A chart would say "extension, no hybrid": accurate, and silent on whether it fits a personal, local-first corpus.
A decision path by situation#
None of these steps names a row count. Sizes alone never pick a product on this site; measured recall, latency and filters do (see scale).
| Your situation | Start by testing | What to measure first |
|---|---|---|
| Already on PostgreSQL | pgvector next to the rows you already back up and secure | Filtered recall on your smallest tenant; plan with EXPLAIN ANALYZE |
| Already run Elasticsearch or OpenSearch | Vectors in the engine that already holds your full-text search | Hybrid ranking on exact ids and paraphrases together |
| Retrieval is the product | A dedicated engine with the fusion, multi-vector and index options you need | Recall at your latency target with filters on |
| Small team, no operations | A managed service, after checking region, data residency and BYOC options | Freshness of new rows; export path |
| Prototype on a laptop | An embedded store such as Chroma locally, or SQLite with sqlite-vec | Whether the export path to production keeps ids and metadata |
If the insurer's prototype runs on PostgreSQL, as this site's SQL examples do, the first row applies: measure filtered recall and latency there, on labeled queries for UW-R01, UW-R02, UW-R03 and UW-R07, and move only when a measurement shows a requirement cannot be met.
In a coding agent. A chart of code-search tools has the same blind spot. "Semantic search ✓" does not say whether a search filtered tosrc/billing/runs the path filter inside the search. Symbol lookup and grep stay exact and lexical; identifiers such asretryProviderCallneed hybrid; and a store without a streaming index serves stale chunks after a refactor until someone rebuilds it.
A checklist before you trust a chart#
| Question | Why it matters |
|---|---|
| Is each name a library, an extension, an engine or a managed service? | The same tick means different things for each kind |
| Does the filter run inside the approximate search, and does a test on the smallest tenant prove it? | Post-filtering leaks or starves (UW-R07, UW-R09) |
| Which fusion does "hybrid" mean, with which defaults? | RRF with k 2 or 60, a score blend, or fusion you write |
| Is the keyword side a real BM25 with phrases and analyzers? | Exact ids such as R-SPRK-01 depend on it |
| Who chooses and versions the embedding model? | A built-in model can change the space under your stored vectors |
| Can a new row be searched without a rebuild? | Corpus B grows with every decision |
| What is the license, and is the open-source project maintained? | A deprecated project is an exit plan, not a foundation |
| What did the cell's source say, and on what date? | Every cell on this page was read on 2026-11-18 |
Multi-tenancy designs across productsNamespaces, partitions, payload indexes and one index per tenant
Products offer different units of isolation, and the unit decides what a bug can leak. Pinecone partitions records into namespaces; every data operation targets one namespace, which makes a cross-tenant result structurally impossible inside a single request. sqlite-vec offers partition key columns that shard a vec0 table internally so an equality constraint limits the search; its page advises hundreds of vectors per key value. pgvector's README suggests partial indexes for a few distinct filter values and partitioning for many. Weaviate's flat index is described as suited to small or multi-tenant collections.
Qdrant shows why order of operations matters. Its filter-aware HNSW edges are added only if payload indexes exist before the HNSW index is built, so the documentation says to create payload indexes before ingesting data. A team that adds the tenant index later gets a filter that works and a graph that was not built for it.
The general rule: if a tenant boundary is a permission, prefer a structural boundary (namespace, partition, separate index) over a filter, and if you use a filter, test it with a query vector copied from another tenant's row. Tenant isolation as an operations discipline is on operations.
Why comparing defaults compares configurations, not productsIndex parameters, fusion constants and distance defaults differ
A bake-off that installs each product and runs it with defaults measures defaults. They differ widely, as documented on 2026-11-18. HNSW ef_construction is 64 in pgvector, 100 in Elasticsearch, OpenSearch, Qdrant and Chroma. Search-time effort is hnsw.ef_search 40 in pgvector, 100 in OpenSearch's Faiss engine, and in Qdrant it defaults to ef_construct. OpenSearch's Lucene engine ignores ef_search and uses k. Default distance is l2 in OpenSearch and Chroma, cosine in Elasticsearch, negative dot product in Google's Vector Search. Fusion constants vary from 2 (Qdrant) to 60 (Elasticsearch, Redis).
So a fair comparison fixes the things you can fix: the same vectors from the same model, the same distance, exact search as ground truth for index recall, the same candidate count, and an effort setting tuned per product to the same recall target. Then compare latency at that recall, with filters on, on your labeled queries. The eight-step playbook is on scale; retrieval metrics are on evaluation.
Even then, report what you measured as one run on one setup. Products change monthly; Milvus documentation already defaults to v3.0.x, and Weaviate added a new cluster-based index, HFresh, in v1.36.
Licenses and the open-source columnWhat "Yes" means for an exit plan
The open-source column is usually read as "free to run". For a production system it means something narrower and more useful: if the vendor changes direction, can you keep running the version you have, and can someone else maintain it?
The matrix shows the range. Apache 2.0 (Qdrant, Milvus, OpenSearch, Chroma, Vald) and MIT (FAISS) are permissive. Weaviate is BSD-3-Clause but keeps some enterprise files under a commercial license. Elasticsearch's repository license file lists AGPLv3, SSPL and Elastic License 2.0, with ELv2-only code in x-pack; section 13 of the AGPL asks that a modified version used over a network offer its source to those remote users, which matters to an insurer that patches the engine. Marqo's repository is still Apache-2.0, but the project is deprecated, so the license protects a codebase no one updates.
For pgvector the matrix records that the repository has a LICENSE file whose name the page read did not show. That is an honest gap, and closing it before adoption is a five-minute task for your legal reviewer. The principle holds for every row: a tick is a pointer to a document someone must read.
In one breath#
A vector library, an extension, an engine and a managed service all run the same primitive and differ in how much of the system they own. A comparison chart is a snapshot of ticks: read each column for what it means and when it decides, distrust "filtering" until you know whether it runs inside the search, ask which fusion "hybrid" means, and ignore the framework column. The 14-database matrix here is dated 2026-11-18; its "docs do not say" cells are questions to close, not answers.
The insurance agent now has a way to shortlist a store and a list of tests that no chart can replace. What remains is keeping the store correct over time: changing the embedding model without downtime, deleting a precedent everywhere, isolating tenants and keeping caches fresh. That is operations.