comparisonvector-dbraglocal-llmpgvectorqdrantchromaweaviate

pgvector vs Qdrant vs ChromaDB vs Weaviate 2026

pgvector vs Qdrant vs ChromaDB vs Weaviate compared: four vector databases for local RAG in 2026. Scale, ops, features, and which to pick.

Published June 29, 2026 · Updated June 29, 2026 · By Local LLM Team

Disclosure: Some tools on this page are built by our team (Cognisoc). We hold our own tools to the same tests as everyone else's, and a customer's acceptance criteria outrank any wish to recommend them. Editorial policy.

These four are the most common vector databases for local RAG in 2026. They differ in operational complexity, feature set, and scale ceiling. This page helps you pick.

Overview

pgvectorQdrantChromaDBWeaviate
TypePostgres extensionstandalone Rust serverPython in-process or serverstandalone Go server
First release2023202120222019
Best forteams already on Postgresproduction scale, low latencylocal dev, prototypinghybrid search, rich features
Single-node scale10M+ vectors100M+ vectors1M vectors50M+ vectors
Distributedvia Postgres itself✓ (Raft)✗ (single node)✓ (Raft)
LicensePostgreSQLApache 2.0Apache 2.0BSD-3
Embedding modelsbring your ownbring your ownbundled + bring your ownbundled + bring your own
Hybrid searchpartial (2026)✓ (BM25 + dense)partial✓ (BM25 + dense + multi-vector)
FiltersSQLrichbasicrich
Multi-tenancyvia Postgres schemas✓ (collections + tags)✗✓

When to use each

Choose pgvector when…

  • You are already on Postgres for your application data. The vector store sits next to the rest of your data, no extra service to run.
  • You want transactional consistency between metadata and vectors (rare, but sometimes needed).
  • Your scale is <10M vectors and your queries are <100ms latency.
  • You prefer operational simplicity (one database, not two).

Choose Qdrant when…

  • You need production scale (10M–100M+ vectors) with sub-10ms p99 latency.
  • You want rich filtering combined with vector search (e.g., “find docs about X for users in region Y created after date Z”).
  • You need multi-tenancy for a SaaS product.
  • You are willing to run a standalone service (one more thing to monitor).

Choose ChromaDB when…

  • You are prototyping or building a personal RAG that fits in <1M vectors.
  • You want zero-config setup (ChromaDB has an in-process mode that needs no server).
  • You are using LangChain or LlamaIndex and want a drop-in default.
  • You do not need multi-user, multi-tenant, or production scale.

Choose Weaviate when…

  • You need the richest hybrid search (BM25 + dense + multi-vector + re-ranking).
  • You are building a production RAG system with a team to operate it.
  • You want built-in vectorization modules (any-to-any embeddings, automatic chunking).
  • You need GraphQL or gRPC APIs in addition to REST.

Performance

On a single node (32 vCPU, 64GB RAM, 1M 768-dim vectors, top-10 ANN):

DBRecall@10p50 latencyp99 latency
pgvector (HNSW)0.9512 ms38 ms
Qdrant (HNSW)0.974 ms9 ms
ChromaDB (HNSW)0.9418 ms65 ms
Weaviate (HNSW + flat)0.968 ms22 ms

Qdrant is the consistent performance leader. pgvector and Weaviate are close. ChromaDB is the slowest (Python overhead).

Setup with a local LLM

All four work with any OpenAI-compatible embedding endpoint, including Ollama, Mullama, llama.cpp, and LM Studio.

# Start an embedding model
ollama pull nomic-embed-text
ollama serve

# Then point your vector DB at it
export OPENAI_BASE_URL=http://localhost:11434/v1
export OPENAI_API_KEY=not-needed

ChromaDB (simplest)

import chromadb
from chromadb.utils import embedding_functions

client = chromadb.PersistentClient(path="./chroma")
ef = embedding_functions.OpenAIEmbeddingFunction(
    api_base="http://localhost:11434/v1",
    api_key="not-needed",
    model_name="nomic-embed-text",
)
collection = client.get_or_create_collection("docs", embedding_function=ef)
collection.add(documents=["local llm is great"], ids=["1"])

Qdrant (production)

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams

client = QdrantClient(host="localhost", port=6333)
client.create_collection("docs", vectors_config=VectorParams(size=768, distance=Distance.COSINE))

pgvector

CREATE EXTENSION vector;
CREATE TABLE docs (id bigserial PRIMARY KEY, content text, embedding vector(768));
CREATE INDEX ON docs USING hnsw (embedding vector_cosine_ops);

Weaviate

import weaviate
client = weaviate.Client("http://localhost:8080")

Decision matrix

Your situationUse
Already on Postgrespgvector
Need sub-10ms p99 at scaleQdrant
Personal RAG, <100k vectorsChromaDB (in-process)
Production RAG with teamWeaviate or Qdrant
Multi-tenant SaaSQdrant
Rich hybrid search (vector + keyword + re-rank)Weaviate
Want zero-configChromaDB
Want to minimize new servicespgvector
Need a managed cloud option laterWeaviate (best cloud) or Qdrant Cloud

See also

Frequently Asked Questions

Which vector DB is best for local RAG in 2026?

For a typical home or small-team RAG setup with <1M vectors, pgvector (if you already have Postgres) or ChromaDB (if you want zero-config) is the easiest. For production-scale RAG with >10M vectors and need for sub-10ms latency, Qdrant is the strongest. Weaviate sits between the two, with the richest feature set for hybrid search.

Do I need a vector database, or can I just use in-memory embeddings?

For <100k vectors and single-user chat, in-memory (numpy, Faiss) is fine. For multi-user, production, or any kind of scale, you need a real vector DB. The crossover is around 100k vectors or 5ms p99 latency requirements.

Can I use these with Ollama or Mullama for embeddings?

Yes. All four support any embedding model exposed via an OpenAI-compatible HTTP endpoint. Ollama and Mullama both serve embedding models (nomic-embed, bge, mxbai-embed) on port 11434.

Which has the best hybrid search (vector + keyword)?

Weaviate and Qdrant. Both support BM25 + dense vector fusion. pgvector is adding this in 2026 but it's still early. ChromaDB has limited hybrid support.