Vector Databases in 2026: pgvector vs Qdrant

1. The Problem: Vectors Don’t Fit in a B-Tree

Embeddings turn text into long arrays of floats — hundreds or thousands of dimensions. A classic B-tree index cannot answer “find the 10 nearest neighbors” efficiently, so vector engines use approximate nearest neighbor search: they trade a sliver of recall for logarithmic-time queries. If you brute-force the comparison past a few thousand documents, latency collapses.

The goal of this guide is practical: understand the one algorithm that matters, know exactly when Postgres plus pgvector stops being enough, and leave with runnable Docker, SQL, and Python code for both paths.

2. Minimum Concepts: HNSW, Distance, and Recall

Nearly every serious vector engine relies on the same algorithm, so learn it once and most vendor docs suddenly make sense. These are the only three ideas you need before touching code.

3. pgvector vs Qdrant: The Decision Rule

Both are open source and both index with HNSW. The difference is operational: pgvector adds vectors to the Postgres you already run, Qdrant is a second service written in Rust that is purpose-built for vector workloads at scale.

4. Tutorial: Running Both in 15 Minutes

Theory is done — let us run both engines. Every command below is verified against the official docs linked in Sources, so copy with confidence.

Step 1 — Start Qdrant with Docker

Pull the official image and run it. Under the default configuration all data lands in ./qdrant_storage, and the dashboard appears at localhost:6333/dashboard.

docker pull qdrant/qdrant

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

Step 2 — Enable pgvector in Postgres

One statement adds the vector type. Then create an HNSW index per distance function you query — cosine below — and tune recall at query time with hnsw.ef_search.

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);

-- higher = better recall, slightly slower
SET hnsw.ef_search = 100;

SELECT content
FROM documents
ORDER BY embedding <=> $1
LIMIT 5;

Step 3 — Talk to Qdrant from Python

Install the official client, point it at your local container, and insert plus query documents. The add/query helpers embed text for you via FastEmbed; the search call shows a metadata-filtered query.

pip install 'qdrant-client[fastembed]'

from qdrant_client import QdrantClient

client = QdrantClient(url="http://localhost:6333")

client.add(
    collection_name="demo_collection",
    documents=["Qdrant has Langchain integrations",
                 "Qdrant also has Llama Index integrations"],
)

results = client.query(
    collection_name="demo_collection",
    query_text="vector search integrations",
    limit=3,
)
print(results)

from qdrant_client.http.models import Filter, FieldCondition, MatchValue

results = client.query_points(
    collection_name="demo_collection",
    query=[0.2, 0.1, 0.9, 0.7],
    query_filter=Filter(
        must=[FieldCondition(
            key="city",
            match=MatchValue(value="London")
        )]
    ),
    with_payload=True,
    limit=5,
).points

5. Common Mistakes in Production

The demo always works. These are the unglamorous details that bite once real traffic and real data arrive — budget for them now.

Sources

• pgvector on GitHub — README: CREATE EXTENSION vector, HNSW indexing
• Qdrant docs — Local quickstart with Docker and Python client
• Qdrant python client — quickstart notebook (add, query, filtered search)
• pgvector 0.8.0 release — iterative index scans for filtered search
• Supabase docs — HNSW indexes in pgvector

Conclusion

For most RAG apps in 2026, pgvector inside the Postgres you already run is the honest default: one system, transactions, SQL filtering, and HNSW speed that covers you into the millions of vectors. Qdrant is the excellent specialist you reach for when scale, selective filtered search, or aggressive quantization genuinely demand a dedicated engine.

Run the tutorial above this week: stand up both, load a slice of your real corpus, and measure filtered p99 on your own queries. That one experiment is worth more than ten benchmark blog posts — and if you want help designing that evaluation, get in touch.