pgvector vs Pinecone vs QdrantVector DBs 2026

# pgvector - just Postgres + SQL
import psycopg
from openai import OpenAI

client = OpenAI()
conn = psycopg.connect("postgresql://...")

# One-time setup:
# CREATE EXTENSION vector;
# CREATE TABLE docs (
#   id bigserial PRIMARY KEY,
#   content text, embedding vector(1536));
# CREATE INDEX ON docs USING hnsw (embedding vector_cosine_ops);

def upsert(id, content):
    emb = client.embeddings.create(
        model="text-embedding-3-large", input=content
    ).data[0].embedding
    conn.execute(
        "INSERT INTO docs (id, content, embedding) VALUES (%s, %s, %s)",
        (id, content, emb),
    )

def query(text, k=5):
    qemb = client.embeddings.create(
        model="text-embedding-3-large", input=text
    ).data[0].embedding
    rows = conn.execute(
        "SELECT content FROM docs ORDER BY embedding <=> %s LIMIT %s",
        (qemb, k),
    ).fetchall()
    return [r[0] for r in rows]

# Pinecone - managed serverless
from pinecone import Pinecone
from openai import OpenAI

client = OpenAI()
pc = Pinecone(api_key="...")
index = pc.Index("docs")  # created in the console or via API

def upsert(id, content):
    emb = client.embeddings.create(
        model="text-embedding-3-large", input=content
    ).data[0].embedding
    index.upsert(vectors=[
        {"id": str(id), "values": emb, "metadata": {"content": content}},
    ])

def query(text, k=5):
    qemb = client.embeddings.create(
        model="text-embedding-3-large", input=text
    ).data[0].embedding
    res = index.query(vector=qemb, top_k=k, include_metadata=True)
    return [m.metadata["content"] for m in res.matches]

# Qdrant - open source, self-host or Qdrant Cloud
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct, Distance, VectorParams
from openai import OpenAI

client = OpenAI()
qdrant = QdrantClient("localhost:6333")

# One-time setup:
# qdrant.create_collection(
#   collection_name="docs",
#   vectors_config=VectorParams(size=1536, distance=Distance.COSINE))

def upsert(id, content):
    emb = client.embeddings.create(
        model="text-embedding-3-large", input=content
    ).data[0].embedding
    qdrant.upsert(
        collection_name="docs",
        points=[PointStruct(id=id, vector=emb, payload={"content": content})],
    )

def query(text, k=5):
    qemb = client.embeddings.create(
        model="text-embedding-3-large", input=text
    ).data[0].embedding
    # qdrant-client 1.10+ uses query_points; .search() was removed.
    res = qdrant.query_points(
        collection_name="docs", query=qemb, limit=k,
    )
    return [p.payload["content"] for p in res.points]

# pgvector - SQL WHERE plus vector similarity
def query_filtered(text, user_id, k=5):
    qemb = embed(text)
    rows = conn.execute(
        """SELECT content FROM docs
           WHERE user_id = %s AND tags @> ARRAY[%s]::text[]
           ORDER BY embedding <=> %s LIMIT %s""",
        (user_id, "public", qemb, k),
    ).fetchall()
    return [r[0] for r in rows]

# SQL WHERE is infinitely expressive.
# The planner will fetch-and-filter, which can be slow if the filter
# is very restrictive. Partial indexes help. HNSW + filter is a
# known-tricky combination for the optimizer.

# Pinecone - filter expression in query
def query_filtered(text, user_id, k=5):
    qemb = embed(text)
    res = index.query(
        vector=qemb, top_k=k,
        filter={"user_id": {"$eq": user_id}, "tags": {"$in": ["public"]}},
        include_metadata=True,
    )
    return [m.metadata["content"] for m in res.matches]

# Filters are evaluated at search time inside the index.
# Pinecone namespaces can also partition by tenant for
# multi-tenant scale.

# Qdrant - rich payload filter DSL
from qdrant_client.models import Filter, FieldCondition, MatchValue, MatchAny

def query_filtered(text, user_id, k=5):
    qemb = embed(text)
    # qdrant-client 1.10+ uses query_points; .search() was removed.
    res = qdrant.query_points(
        collection_name="docs",
        query=qemb,
        query_filter=Filter(must=[
            FieldCondition(key="user_id", match=MatchValue(value=user_id)),
            FieldCondition(key="tags", match=MatchAny(any=["public"])),
        ]),
        limit=k,
    )
    return [p.payload["content"] for p in res.points]

# Filtering is fast and interleaves with HNSW traversal.
# Payload indexes can be created for high-selectivity filters.