# Best Open-Source Vector Databases for Enterprise RAG (2026 Guide)

> How to choose an open-source vector database for enterprise RAG: licences, security, hybrid search, tenancy, a shortlist, and a bake-off method.

Source: https://hyperlake.cloud/blog/best-open-source-vector-databases-for-enterprise-rag-2026
By Hyperlake Team · Hyperlake

The best open-source vector database for enterprise RAG is the one that fits your constraints. The longest feature list doesn't win by default. Qdrant, Milvus, Weaviate, pgvector, OpenSearch, Vespa, LanceDB and Chroma all publish their code publicly (check each licence, and note Weaviate's commercial-key exception). They differ mostly in how you operate them, how they filter and combine search types, and how they isolate tenants. Decide on licence, security and operations first, then test retrieval quality on your own documents.

We make HyperLake, a sovereign AI operating platform. It isn't a vector database, and the section on where it fits explains how it relates to the engines below.

![A funnel narrows open-source candidates by licence, security and operations, ending in a test on your own documents.](https://hyperlake.cloud/blog/img/production/2f7f1c29916396a4cf01d6400b91f49183789a52-1200x840.png?w=1600&fit=max&auto=format)

## What makes a vector database "enterprise-ready" for RAG?

Retrieval quality matters. But nearly every database in this space can run approximate nearest-neighbour search, so in an enterprise the questions that actually separate them tend to be these:

1. Licence and ownership. Is the code under an OSI-style open-source licence you can run, patch and audit, and are any features locked behind a commercial key?
1. Access control and isolation. Can you restrict who sees which collection, and keep one customer's or department's data apart from another's?
1. Filtering and hybrid search. RAG over company documents nearly always needs metadata filters (department, region, document date), and often a keyword component for product codes and names.
1. Operations. How does it deploy, scale, back up and upgrade, and does your team already know the technology?
1. Scale and cost. How many vectors, how fast they change, and whether the index has to sit in memory.
1. Fit with the rest of the stack. An existing PostgreSQL or search cluster may already do most of the job.

For the difference between vector, graph and knowledge-graph stores, see our [vector vs graph vs knowledge graph comparison](https://hyperlake.cloud/blog/vector-database-vs-graph-database-vs-knowledge-graphs-for-ai-2026). We won't repeat that here. This article is about choosing a store for a production RAG system.

## Which open-source vector databases should you shortlist?

The descriptions below come from each project's own public pages and are accurate as of October 2026. The "Our read" column is our summary, not a ranking.

| Database | Licence (per its repository) | Our read |
| --- | --- | --- |
| [Qdrant](https://qdrant.tech/documentation/overview/) | Apache 2.0 ([GitHub](https://github.com/qdrant/qdrant)) | Filtering during search plus BM25 and sparse vectors |
| [Milvus](https://milvus.io/docs/overview.md) | Apache 2.0 | Wide choice of index types and deployment modes |
| [Weaviate](https://github.com/weaviate/weaviate) | BSD-3-Clause for most of the repository | Built-in hybrid search and multi-tenancy |
| [pgvector](https://github.com/pgvector/pgvector) | PostgreSQL License ([LICENSE file](https://github.com/pgvector/pgvector/blob/master/LICENSE)) | Vectors inside PostgreSQL |
| [OpenSearch](https://github.com/opensearch-project/OpenSearch) | Apache 2.0 | Teams already running a search cluster |
| [Vespa](https://github.com/vespa-engine/vespa) | Apache 2.0 | Combined text, structured and vector queries |
| [LanceDB](https://github.com/lancedb/lancedb) | Apache 2.0 (listed on its repository) | Embedded, in-process retrieval |
| [Chroma](https://github.com/chroma-core/chroma) | Apache 2.0 | Prototyping that can move to client-server mode |

Notes on each, taken from their own pages:

- Qdrant documents payload indexes that extend its HNSW graph, so filters apply during the vector search itself. It also supports BM25 full-text search and sparse vectors, and it's offered as managed cloud, hybrid cloud, private cloud or open source.
- Milvus documents three modes (Lite, Standalone and Distributed on Kubernetes), index types including HNSW, IVF, ScaNN and DiskANN, and tenant isolation at database, collection, partition or partition-key level. It also has [role-based access control](https://milvus.io/docs/rbac.md) covering the instance, database and collection levels.
- Weaviate says most of its repository is BSD-3-Clause, but files in a `wl/` folder are available only under a commercial licence with a key, and enterprise features need a key. If your policy requires every component to be open source, that's a real issue. Its documentation describes [multi-tenancy](https://docs.weaviate.io/weaviate/concepts/data) where each tenant gets a dedicated vector index, and [hybrid search](https://docs.weaviate.io/weaviate/search/hybrid) that fuses a vector search with a BM25F keyword search.
- pgvector supports HNSW and IVFFlat indexes and, according to its README, keeps vectors next to your other data with ACID compliance, point-in-time recovery and joins.
- OpenSearch is a search and observability suite under Apache 2.0. Its documentation has a vector search section with a k-NN vector field type and tutorials on semantic and hybrid search.
- Vespa describes itself as a platform for low-latency computation over large data sets that stores and indexes structured, text and vector data, and lets you combine conditions on text, structured data and vectors in one query.
- LanceDB describes itself as an open-source embedded retrieval library for multimodal AI, and says it can run on your own machine or in your own cloud.
- Chroma shows an in-memory client for prototyping, a client-server mode started with `chroma run`, and a hosted service called Chroma Cloud.

Sometimes another route is better. If your vectors are a few million rows sitting next to relational data you already govern, pgvector may save you a whole new system. If you already run a search cluster, extending it can be less work than adding a database. And if you want no database operations at all, a managed service is a perfectly legitimate answer, which brings us to the next question.

## Open source vs cloud vector stores: which should you choose?

This is as much a deployment decision as a product one. Several of the projects above are also sold as managed services (Qdrant, Weaviate and Chroma each describe a cloud offering), and there are purely managed services too.

| Question | Self-hosted open source | Managed cloud service |
| --- | --- | --- |
| Who runs upgrades, backups, scaling? | Your team | The vendor |
| Where does data live? | Your infrastructure | The vendor's region or your account, depending on the offer |
| Can you audit and patch the code? | Yes, for open-source components | Usually not for proprietary services |
| Speed to first prototype | Slower | Faster |
| Exit path | Move the same engine elsewhere | Depends on export tools and format |

Open source doesn't automatically mean self-hosted. Managed doesn't automatically mean your data leaves your control. Ask each vendor where data is stored, who can reach it, and whether there's a bring-your-own-cloud or private deployment option. If data residency is driving the decision, see [Data Residency vs. Data Sovereignty for Enterprise AI](https://hyperlake.cloud/blog/data-residency-vs-data-sovereignty).

## How do you choose a vector database for enterprise RAG and AI workloads?

Here's the "enterprise RAG and AI workloads" question head on: what changes once RAG stops being a demo and becomes a service other people depend on?

Security and access control come first. In a demo, one API key reaches everything. In production, retrieval has to respect the permissions of whoever is asking. There are two common designs. You can enforce it in the database, with roles, per-tenant indexes or per-collection access. Or you can store an access label with each chunk as metadata and filter on it at query time. The second only works if your filtering is reliable, so test it with queries that should come back empty. For model and agent permissions more broadly, see [LLM Access Control: RBAC for Models and AI Agents](https://hyperlake.cloud/blog/llm-access-control-and-rbac).

Then multi-tenancy. If you serve many customers or business units, decide whether each one gets its own collection, its own partition or just a filter value. Milvus and Weaviate document native tenant-isolation features. For other engines, read what the documentation says before you assume anything.

Hybrid search is next. Embeddings are weak on exact strings like part numbers or contract IDs, and adding a keyword component (BM25) to vector search often helps. Qdrant, Milvus, Weaviate, Vespa and OpenSearch each document some form of hybrid or combined retrieval. pgvector can be paired with PostgreSQL's own text search, though you'd configure that yourself.

Index choice drives memory. HNSW is a common default, but it keeps a graph you usually want in memory, and other index types trade recall, speed and memory differently. See [Vector Indexing Algorithms: HNSW vs IVF-PQ vs ScaNN](https://hyperlake.cloud/blog/vector-indexing-algorithms-deep-dive-hnsw-vs-ivf-pq-vs-scann).

And retrieval quality is mostly upstream. We'd look at chunking, metadata and reranking before blaming the database, because they often move results more. Before switching engines, read [Semantic Chunking vs. Hierarchical and Structure-Aware Chunking](https://hyperlake.cloud/blog/semantic-chunking-vs-hierarchical-and-structure-aware-chunking) and [Contextual Compression: ColBERT vs. Cross-Encoders](https://hyperlake.cloud/blog/contextual-compression-and-reranking-colbert-or-cross-encoders).

## How should you run a vector database bake-off?

1. Write 50 to 100 real questions with the passages that should answer them, including some where the right answer is "nothing found".
1. Use your own documents, chunked the way you'll chunk them in production, with realistic metadata and permission labels.
1. Measure whether the correct passage shows up in the top results, plus filtered query latency and ingestion time. Vendor benchmarks use their own data and settings, so treat them as hints.
1. Score against your own criteria. A simple weighted score keeps the discussion honest.

Here's a hypothetical example, with weights you'd set for your own situation. Scores run from 1 to 5.

| Criterion (weight) | Database A | Database B |
| --- | --- | --- |
| Licence and deployment (30) | 4 | 3 |
| Security and isolation (25) | 3 | 5 |
| Retrieval on our questions (25) | 5 | 4 |
| Operations (20) | 2 | 4 |

Database A: (4 x 30) + (3 x 25) + (5 x 25) + (2 x 20) = 120 + 75 + 125 + 40 = 360, which is 72 out of 100 after dividing by 5. Database B: (3 x 30) + (5 x 25) + (4 x 25) + (4 x 20) = 90 + 125 + 100 + 80 = 395, or 79 out of 100. The numbers are invented to show the method. What they show is that the best retrieval score doesn't automatically win once security and operations carry weight.

## Where does HyperLake fit?

HyperLake doesn't replace a vector database. It's a platform for assembling, deploying and governing the data, models and applications behind AI in a customer's own environment or a client's. According to HyperLake's product description, engines follow the workload, and these include Qdrant or Milvus for vectors alongside engines for other data types. The platform's stated approach is to ground models in governed enterprise context, with people and agents reaching data through authenticated, governed services and policy decisions made by OPA. HyperLake is relevant if you also have to decide where the chosen engine runs and who can query it. If you just need a library for one application, it doesn't apply. The product description doesn't name Weaviate, pgvector, OpenSearch, Vespa, LanceDB or Chroma as supported engines, so ask the team if you need one of those.

## Frequently asked questions

### What is the best open-source vector database for RAG?

No single one wins. Qdrant, Milvus, Weaviate, pgvector, OpenSearch and Vespa all publish their code and support RAG-style retrieval. Choose by licence terms, security and tenant isolation, hybrid search needs and how your team will operate it, then test on your own questions.

### Is pgvector enough for enterprise RAG?

It can be, especially when your data already lives in PostgreSQL and you want joins, transactions and recovery in one place. Its README lists HNSW and IVFFlat indexes. If you need native tenant isolation or very large distributed indexes, compare it with purpose-built engines.

### Are all open-source vector databases fully open source?

Not always. Weaviate's README says most of the repository is BSD-3-Clause, but some files and enterprise features require a commercial licence key. Check each project's licence and any enterprise terms against your policy.

### Should I use a managed vector database or self-host?

Self-host if you must control where data lives, audit the code or avoid vendor dependence, and you have people to run it. Go managed if speed and low operational load matter more. Several open-source projects offer both, so you can start in one mode and switch later.

### Do I need hybrid search for RAG?

For enterprise content, often yes, because embeddings capture exact terms like codes and names poorly. Several engines, including Qdrant, Milvus and Weaviate, document combining vector and keyword search.

### How many vectors can an open-source vector database handle?

That depends on the engine, index type, hardware and recall target, so no one figure applies. Test with your own volume and filters instead of leaning on vendors' published numbers.

## Related reading

- [Vector Database vs Graph Database vs Knowledge Graphs for AI (2026)](https://hyperlake.cloud/blog/vector-database-vs-graph-database-vs-knowledge-graphs-for-ai-2026)
- [Vector Databases and Semantic Search Explained](https://hyperlake.cloud/blog/vector-databases-and-semantic-search)
- [RAG vs. Fine-Tuning: How to Choose](https://hyperlake.cloud/blog/rag-vs-fine-tuning)
