Vector Databases for Python Developers: pgvector, Chroma, and Qdrant Compared (2026)

pip install psycopg pgvector

import psycopg
from pgvector.psycopg import register_vector
import numpy as np

conn = psycopg.connect("postgresql://user:pass@localhost/mydb")

# The extension must exist before register_vector() can find the vector type
conn.execute("CREATE EXTENSION IF NOT EXISTS vector")
conn.commit()
register_vector(conn)

# Create table with vector column
conn.execute("""
    CREATE TABLE IF NOT EXISTS documents (
        id SERIAL PRIMARY KEY,
        content TEXT,
        embedding vector(1536)
    )
""")

# Insert document with embedding
embedding = np.array(get_embedding("my document text"))  # 1536-dim for text-embedding-3-small
conn.execute(
    "INSERT INTO documents (content, embedding) VALUES (%s, %s)",
    ("my document text", embedding)
)
conn.commit()

# Similarity search (cosine distance)
results = conn.execute("""
    SELECT content, 1 - (embedding <=> %s::vector) AS similarity
    FROM documents
    ORDER BY embedding <=> %s::vector
    LIMIT 5
""", (embedding, embedding)).fetchall()

pip install chromadb

import chromadb
from chromadb.utils import embedding_functions

# Persistent client — survives process restart
client = chromadb.PersistentClient(path="./chroma_db")

# Use OpenAI or any embedding function
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key="sk-...",
    model_name="text-embedding-3-small"
)

collection = client.get_or_create_collection(
    name="documents",
    embedding_function=openai_ef
)

# Add documents — Chroma handles embedding automatically
collection.add(
    documents=["Python is a high-level language", "pgvector extends PostgreSQL"],
    metadatas=[{"source": "tutorial"}, {"source": "blog"}],
    ids=["doc1", "doc2"]
)

# Query
results = collection.query(
    query_texts=["vector storage in postgres"],
    n_results=2,
    where={"source": "blog"}  # metadata filter
)
print(results["documents"])

pip install qdrant-client

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, VectorParams, PointStruct,
    Filter, FieldCondition, MatchValue, DatetimeRange,
)
import numpy as np

client = QdrantClient("localhost", port=6333)

# Create collection
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
)

# Upsert points
embedding = get_embedding("my document text")
client.upsert(
    collection_name="documents",
    points=[
        PointStruct(
            id=1,
            vector=embedding,
            payload={
                "content": "my document text",
                "source": "blog",
                "category": "python",
                "published_at": "2026-10-01T00:00:00Z"
            }
        )
    ]
)

# Search with payload filtering
results = client.query_points(
    collection_name="documents",
    query=get_embedding("vector database tutorial"),
    query_filter=Filter(
        must=[
            FieldCondition(key="category", match=MatchValue(value="python")),
            FieldCondition(
                key="published_at",
                range=DatetimeRange(gte="2026-01-01T00:00:00Z"),
            ),
        ]
    ),
    limit=5,
    with_payload=True,
)
for point in results.points:
    print(point.score, point.payload["content"])

Are you in production?
├─ No → Is your dataset > 1M vectors?
│       ├─ No → Chroma (embedded, fastest to start)
│       └─ Yes → Qdrant (even for dev at this scale)
└─ Yes → Do you already run Postgres?
         ├─ Yes → pgvector (no new service)
         └─ No → Qdrant (best ANN + filtering at scale)

import hashlib
import json
from functools import lru_cache

# Simple disk cache for embeddings
def get_cached_embedding(text: str, cache_dir: str = ".embedding_cache") -> list[float]:
    cache_key = hashlib.md5(text.encode()).hexdigest()
    cache_file = f"{cache_dir}/{cache_key}.json"

    try:
        with open(cache_file) as f:
            return json.load(f)
    except FileNotFoundError:
        pass

    # Only calls the API on cache miss
    embedding = client.embeddings.create(
        input=text,
        model="text-embedding-3-small"
    ).data[0].embedding

    os.makedirs(cache_dir, exist_ok=True)
    with open(cache_file, "w") as f:
        json.dump(embedding, f)

    return embedding