I am looking for a vector database that is open source and does not require a cloud subscription.

If you need an open-source vector search solution that runs entirely on your own local machine, edge device, or self-hosted server without any cloud subscription or mandatory telemetry, you have several great options depending on your architecture.

Here are the best open-source, self-hosted vector databases and libraries available:

• ChromaDB : A lightweight, open-source embedding database available under the Apache 2.0 license. It can run entirely in-process inside a Python or JavaScript application or as a local standalone server. It requires zero cloud setup and persists to your local file system out of the box.
• FAISS (Facebook AI Similarity Search) : An open-source library developed by Meta rather than a standalone database service. It runs entirely in memory or disk-persisted on a single machine, offering ultra-fast dense vector similarity search with absolute data sovereignty and zero external dependencies.
• PostgreSQL with pgvector : If you already use PostgreSQL, adding the open-source pgvector extension turns your existing relational database into a native vector search engine. You can self-host it locally or on your own hardware with zero cloud dependencies.
• Qdrant : A vector database written in Rust with an open-source core. It is exceptionally fast, highly optimized for filtering-heavy workloads, and trivial to spin up locally or on a private server via Docker with no cloud lock-in.
• Milvus : A highly scalable, open-source distributed vector database built for massive enterprise or billion-scale datasets. While it has heavier operational dependencies (like etcd and MinIO), it can be fully self-hosted on your own infrastructure (such as via Kubernetes/Helm) without utilizing Zilliz Cloud.

To help narrow down the best fit, tell me:

• What is your estimated dataset size (number of vectors)?
• Are you looking for an in-process library (like FAISS/Chroma running inside your app) or a standalone server/Docker container?

Yes. If your requirement is open source + fully self-hostable + no cloud subscription, you have several good options.

My top recommendations

1. Qdrant — my default recommendation

Qdrant is probably the one I'd choose if you specifically want a dedicated vector database rather than adding vector search to an existing database.

It can run entirely on your own server with Docker, without requiring a Qdrant Cloud subscription. It's designed around vector search and has strong metadata filtering and hybrid-search capabilities.

Good choice for: RAG applications, semantic search, AI agents, document retrieval.

2. pgvector — easiest if you already use PostgreSQL

pgvector is actually a PostgreSQL extension rather than a separate database. It supports exact search, HNSW and IVFFlat approximate indexes, cosine/L2/inner-product searches, metadata via normal SQL, and joins with your existing relational data.

You can literally run:

CREATE EXTENSION vector;

CREATE TABLE documents (
    id bigserial PRIMARY KEY,
    content text,
    embedding vector(1536)
);

CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);

No separate vector database is necessary.

Good choice for: applications that already have PostgreSQL, especially if you're dealing with millions rather than enormous numbers of vectors.

3. Milvus — for serious scale

Milvus is a more specialized, distributed vector database. It can run locally, through Docker, or on Kubernetes, and has a lightweight Milvus Lite option for smaller applications.

I'd consider it when you're talking about hundreds of millions or billions of vectors and are willing to operate a more complicated system.

What I'd choose

If you tell me nothing else about your application, I'd rank them:

1. Qdrant — best standalone choice
2. pgvector — best if you already use PostgreSQL
3. Milvus — best for very large scale
4. Weaviate — good if you want more built-in search/AI functionality
5. Chroma — excellent for simple local development and prototypes

Importantly, none of these require a cloud subscription. You can run them on your own PC, NAS, VPS, or server. Self-hosting does mean you're responsible for backups, upgrades, security, monitoring, and storage.

If you tell me roughly how many documents/vectors you expect (e.g. 100k, 10M, 1B) and whether you're building a RAG application, recommendation system, or semantic search, I can narrow this down to one choice and give you a Docker setup.

It can run entirely on your own server with Docker, without requiring a Qdrant Cloud subscription. It's designed around vector search and has strong metadata filtering and hybrid-search capabilities.

Good choice for: RAG applications, semantic search, AI agents, document retrieval.

2. pgvector — easiest if you already use PostgreSQL

pgvector is actually a PostgreSQL extension rather than a separate database. It supports exact search, HNSW and IVFFlat approximate indexes, cosine/L2/inner-product searches, metadata via normal SQL, and joins with your existing relational data.

You can literally run:

Yes. There are several genuinely open-source vector databases you can run entirely on your own hardware—no cloud subscription required.

My top recommendations

1. Qdrant — my default recommendation

Qdrant is probably the one I'd start with if you want a dedicated vector database.

It can run locally with Docker, has a REST/gRPC API, supports metadata filtering, and is designed specifically around vector similarity search. You can run it completely disconnected from Qdrant's cloud service.

A local instance is as simple as:

docker run -p 6333:6333 qdrant/qdrant

GitHubChoose Qdrant if: you're building RAG, semantic search, recommendations, document search, or an AI application and don't want PostgreSQL involved.

---

2. pgvector — excellent if you already use PostgreSQL

pgvector isn't a separate database—it turns PostgreSQL into a vector database.

This is an especially good option if your application already has relational data. You can keep users, documents, permissions, metadata, and embeddings in the same database, and use normal SQL/JOINs alongside vector search. It supports both exact search and approximate indexes such as HNSW and IVFFlat.

For example:

CREATE EXTENSION vector;

CREATE TABLE documents (
    id bigserial PRIMARY KEY,
    content text,
    embedding vector(1536)
);

CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);

Choose pgvector if: you already have PostgreSQL or your dataset isn't so enormous that you need a specialized distributed vector database.

---

3. Milvus — for very large deployments

Milvus is a more heavyweight option. It's Apache 2.0 licensed and can be run entirely on your own infrastructure. It supports standalone deployments as well as distributed/Kubernetes-oriented deployments and is designed to scale to very large vector collections.

There's even Milvus Lite, which can store a local database in a file:

from pymilvus import MilvusClient

client = MilvusClient("my_vectors.db")

GitHubChoose Milvus if: you're expecting hundreds of millions/billions of vectors or need a distributed architecture.

---

What I'd choose

For most new projects:

Qdrant → dedicated vector DB pgvector → PostgreSQL + vectors Milvus → massive-scale/distributed

If you tell me roughly how many documents/vectors you expect (10K, 1M, 100M, etc.), what language you're using (Python/Node/etc.), and whether you already have PostgreSQL, I can narrow it down to the best choice and give you a completely local Docker setup.

Several open-source vector databases and libraries can be completely self-hosted on your own hardware or local machine with zero cloud subscription or external dependency required.

The best options vary based on your specific scale and architecture:

1. Best for Local Dev, Prototyping, & Small-to-Mid Apps: ChromaDB

• What it is: A lightweight, developer-friendly embedding database designed to run locally or in a simple server mode.
• Why it fits: You can spin it up completely in-process within a Python or JavaScript script, or run it as a local persistent server. It requires no complex infrastructure, docker orchestration, or cloud accounts.
• Learn more: Check out ChromaDB.

2. Best for Production & Rich Filtering: Qdrant

• What it is: A vector-native search database written in Rust.
• Why it fits: It is fully open-source (Apache 2.0 core), highly performant, and trivial to self-host via a single Docker container on your own server or local machine. It offers rich payload filtering, making it ideal for robust retrieval-augmented generation (RAG).
• Learn more: Explore the Qdrant Documentation.

3. Best if You Already Use PostgreSQL: pgvector

• What it is: An open-source vector similarity search extension for standard PostgreSQL.
• Why it fits: If you already run a Postgres database locally or on-premise, you don't need a separate database at all. You just install the extension (CREATE EXTENSION vector; ) to store and query vector embeddings right alongside your relational data.
• Learn more: View the repository on the pgvector GitHub.

4. Best for Pure Local/On-Premise Scale (No Server Needed): FAISS

• What it is: A library developed by Meta AI for efficient similarity search and clustering of dense vectors.
• Why it fits: It isn't a traditional standalone client-server database, but rather an in-memory/disk-persisted library. If you want your application to process millions of vectors locally on a single machine or server without running a separate background database daemon, FAISS is exceptionally fast.
• Learn more: Read the overview on FAISS by Meta AI.

5. Best for Massive, Enterprise-Scale Distributed Data: Milvus

• What it is: A cloud-native, distributed open-source vector database built to handle billions of vectors.
• Why it fits: While it requires more heavy-duty orchestration (usually via Kubernetes/Helm), it is fully open-source and free to deploy on your own private infrastructure or bare-metal servers if you are managing enterprise-level scale.
• Learn more: Check the guides at Milvus.io.

If you can tell me:

• How many vectors you plan to store (e.g., thousands vs. millions)
• Your preferred programming language or stack (Python, Node.js, Postgres, etc.)
• Whether this is for a local desktop app/script or a dedicated self-hosted server

I can recommend the exact setup that matches your workflow.

If you need an open-source vector database that you can completely self-host with zero cloud dependencies or required subscriptions, you have several great options depending on your scale and architecture.

Here are the top choices for local-first, self-hosted, open-source vector search:

1. Chroma (ChromaDB)
   • Best for: Lightweight apps, local development, and in-memory or embedded RAG (Retrieval-Augmented Generation) pipelines.
   • How it works: It can run entirely in-process inside your Python or Node.js application or run as a local lightweight server. Data persists easily to your local disk.
   • License: Apache 2.0
   • Cloud requirement: None. (Explore the ChromaDB Project to get started locally via pip).
2. Qdrant
   • Best for: Production-grade performance, high-dimensional filtering, and scaling up on your own hardware.
   • How it works: Written in Rust, it is extremely fast and resource-efficient. You can spin it up locally in seconds using Docker or deploy it directly to your own bare-metal servers/VPS.
   • License: Apache 2.0 (the core engine is fully open source).
   • Cloud requirement: None, though a managed cloud exists, the self-hosted OSS version has zero limits or forced subscriptions. (Check out the documentation on Qdrant GitHub).
3. pgvector (PostgreSQL Extension)
   • Best for: Relational apps where you already use PostgreSQL and want to keep your stack unified.
   • How it works: Turns your standard, self-hosted PostgreSQL instance into a capable vector database by adding native vector data types and HNSW/IVFFlat indexing.
   • License: PostgreSQL License (Open Source)
   • Cloud requirement: None. It runs wherever you run Postgres (on-prem, local container, etc.). (Read more via GitHub pgvector).
4. Milvus
   • Best for: Massive, enterprise-scale data (handling tens of millions to billions of vectors) on self-managed infrastructure.
   • How it works: Highly distributed and performant, deployable via Docker Compose or Kubernetes on your own private infrastructure.
   • License: Apache 2.0
   • Cloud requirement: None for the open-source release. (Check out Milvus.io for deployment guides).
5. FAISS (Facebook AI Similarity Search)
   • Best for: Pure in-memory similarity search library rather than a full client-server database.
   • How it works: Embedded directly into your code. Great if you just want to dump vectors into an index file on your local machine and query them instantly.
   • License: MIT License
   • Cloud requirement: None.

To help narrow down the best fit, tell me:

• What programming language or framework are you building with?
• Roughly how many vectors do you plan to store?
• Do you prefer an in-process library (runs right inside your app) or a standalone local server (runs via Docker)?

Yes. If your requirement is open source + self-hosted + no cloud subscription, you have several very good options.

My top choices

1. Qdrant — my default recommendation

Qdrant is a purpose-built vector database that you can run entirely on your own machine or server. It's Apache 2.0 licensed and supports vector search, filtering, and hybrid search.

You don't need Qdrant Cloud. You can simply run the database yourself, including via Docker.

I'd choose Qdrant if: you're building an AI/RAG application and don't already have a strong reason to use PostgreSQL.

2. pgvector — excellent if you already use PostgreSQL

pgvector turns PostgreSQL into a vector database by adding vector types and similarity-search indexes. It supports exact search plus HNSW and IVFFlat approximate indexes.

This is particularly attractive because you can keep your:

• application data
• metadata
• relational tables
• vectors
• vector-search queries

all in the same database.

I'd choose pgvector if: you're already running PostgreSQL or your dataset isn't so large that you need a dedicated vector-search system.

3. Milvus — for large-scale workloads

Milvus is Apache 2.0 licensed and can be deployed standalone on a single machine or distributed for much larger workloads. Its documentation describes scaling to billions of vectors.

I'd choose Milvus if: you're expecting very large collections and high-throughput vector search, and you're comfortable operating a more substantial infrastructure stack.

What I'd pick

For most new projects:

Qdrant → PostgreSQL/pgvector → Milvus

I'd start with Qdrant unless you already use PostgreSQL. If this is for a personal project or a relatively small RAG system, pgvector or Qdrant are probably all you need.

And importantly, none of these require you to purchase a cloud subscription. You can run them on your own PC, NAS, VPS, or private server.

If you tell me roughly how many documents/vectors you expect (e.g. 100K, 10M, 1B) and whether you're using Python, Node, or something else, I can narrow it down to one.

If you want an open-source vector database that you can run yourself with no cloud subscription, you have several good options. The best choice depends on your scale and existing stack.

Top self-hosted open-source vector databases

My recommendation by use case

• Building a local AI assistant / RAG app: Start with Qdrant. It is a dedicated vector database, simple to run in Docker, and supports metadata filtering well.
• Already have PostgreSQL: Use pgvector. You may not need a separate vector database at all.
• Experimenting on a laptop: Use Chroma. It has a very low setup barrier.
• Hundreds of millions to billions of vectors: Consider Milvus.
• Need built-in hybrid search (semantic + keyword): Consider Weaviate.

Example: running a vector database without cloud

For Qdrant, a local deployment can be as simple as:

docker run -p 6333:6333 qdrant/qdrant

Then your application talks to your own machine or server instead of a hosted API.

Things to consider before choosing

• Data size: thousands of documents vs billions of embeddings changes the choice.
• Filtering needs: if you need queries like “find similar documents where customer_id = X,” metadata filtering matters.
• Operations: self-hosting means you manage backups, upgrades, monitoring, and storage.
• Embedding model: the vector database stores and searches embeddings; it does not replace the model that creates them.

For most self-hosted AI applications today, I would shortlist:

1. Qdrant — best general-purpose standalone option.
2. pgvector — best if PostgreSQL is already part of your stack.
3. Milvus — best for very large deployments.

If you tell me your expected scale (number of documents/vectors), language stack (Python/Node/etc.), and whether this is for RAG, search, or recommendations, I can narrow it down.

Several powerful, open-source vector databases run entirely locally or on your own self-hosted infrastructure without forcing you into a proprietary cloud subscription.

1. In-Process / Embedded (No Server Required)

These options run directly inside your application process (like a Python library) and persist data right to a local folder on your disk. They have zero infrastructure overhead.

• • ChromaDB: A Python-first, lightweight vector database designed specifically for AI and RAG applications. It can run entirely in-memory or persist locally inside your app with zero server configuration.
• • LanceDB: Serverless and built on a modern columnar data format (Lance). It runs embedded inside your application, handles multimodal data exceptionally well, and queries data directly on disk without a separate database daemon.

2. Standalone / Self-Hosted Servers (Docker or Binary)

If you need a client-server architecture that can scale up or handle multiple services connecting to it, but you still want to run it completely on your own hardware:

• • Qdrant: Written in Rust, making it blazing fast and resource-efficient. It has a robust open-source core, excellent filtering capabilities, and can be spun up locally via Docker with a single command.
• • Milvus: Highly scalable and designed for massive, billion-scale vector workloads. While enterprise deployments use Kubernetes, you can run it locally via Docker (using Milvus Lite or standalone mode) completely free.
• • Weaviate: An open-source vector search engine with a rich modular ecosystem and GraphQL/REST APIs. It is fully self-hostable via Docker.

3. Traditional Databases with Vector Extensions

If you already run a relational or search database in your stack, you can add local vector capabilities without adding a new standalone system:

• • pgvector (PostgreSQL extension): If you already use PostgreSQL, adding the pgvector extension lets you store and query vectors natively inside your existing database.
• • Elasticsearch / OpenSearch: Both feature robust native support for dense vector fields and approximate nearest neighbor (ANN) search if you are already self-hosting an ELK-style stack.

If you tell me:

• Your programming language/stack (Python, Node.js, Go, etc.)
• The approximate scale of your data (thousands vs. millions of vectors)
• Whether you want it embedded in your app or running in Docker

I can recommend the exact tool that fits your workflow.

Several robust, fully open-source vector databases and libraries run entirely on your local machine, on-premise, or via Docker with zero cloud subscription or vendor lock-in required.

Here are the best options broken down by how you plan to use them:

• ChromaDB — An AI-native ChromaDB GitHub Repository that can run entirely in-process (embedded directly inside your Python or JavaScript application) or spun up as a local lightweight server. It requires zero infrastructure or Docker setup for local usage and automatically persists data to a local directory.
• FAISS (Facebook AI Similarity Search) — A high-performance library developed by Meta rather than a standalone database server. It is ideal if you want to perform lightning-fast similarity search and clustering entirely in memory or persisted to a local disk file with absolute control and zero external dependencies.
• pgvector (PostgreSQL Extension) — Turns a standard, self-hosted PostgreSQL instance into a powerful vector database. If you already use Postgres for relational data, adding the pgvector GitHub Repository lets you store and query high-dimensional vectors right alongside your regular tables using standard SQL.
• Qdrant — Written in Rust, Qdrant is an open-source vector search engine that provides a comfortable local deployment via Docker. It features robust filtering capabilities and a generous open-source license without forcing you onto their managed cloud.
• Milvus Lite / Self-Hosted Milvus — Milvus is a heavy-duty distributed vector database, but it offers a local Milvus Lite python package that runs in-memory/on-disk for development, as well as full docker-compose deployment files to run the entire scalable stack on your own hardware.

If you tell me:

• The programming language or framework you're using (Python, Node.js, Go, etc.)
• The scale of your data (thousands of vectors vs. millions)
• Whether you want it embedded in your app or running as a local Docker container

I can help you pick the ideal match and write a quick setup snippet.

Yes. If your requirements are open source + self-hosted + no cloud subscription, you have several good choices.

My top picks

• Qdrant — My first recommendation. It is open source, can run entirely on your own machine/server, and supports dense, sparse, and multivector search, metadata filtering, and hybrid search. You can run it with Docker and persist the database to a local directory.
• Weaviate — A more feature-rich AI database. It supports semantic and hybrid search, RAG-oriented workflows, structured filtering, and can be deployed locally with Docker or Kubernetes without using Weaviate Cloud.

Quick comparison

What I'd choose

If you're building something like a local RAG application, document search system, or AI assistant, I'd choose Qdrant. It's relatively lightweight, has a straightforward API, and you aren't locked into a hosted service. Qdrant's local setup is essentially:

docker run -p 6333:6333 -p 6334:6334 \
  -v "$(pwd)/qdrant_storage:/qdrant/storage:z" \
  qdrant/qdrant

That gives you a vector database running on your own machine, with data persisted locally.

If you tell me what you're building (e.g. RAG, semantic search, image search, millions of documents, Python app, etc.) and roughly how many vectors you expect, I can narrow this down to the best 1–2 options.