Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Vektordatabaser (Pinecone, Qdrant, Weaviate)

Lektion 8 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Hvorfor en vektordatabase?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma og pgvector
  7. Sammenligning
  8. Vigtige pointer

Mål

  • Forstå hvorfor vektordatabaser er nødvendige
  • Sammenligne Pinecone, Qdrant, Weaviate, Chroma og pgvector
  • Implementere søgning med hver af dem

Hvorfor en vektordatabase?

NumPy-indekset fra den forrige lektion fungerer perfekt til nogle få tusinde dokumenter, fordi en udtømmende scanning af ti tusinde vektorer forbliver umærkelig. Ved en million bliver samme beregning til et sekunds ventetid pr. forespørgsel, og matricen passer ikke længere komfortabelt i hukommelsen.

Fire behov opstår samtidigt. ANN-søgning (Approximate Nearest Neighbors) opgiver garantien for et nøjagtigt resultat til fordel for et millisekund-hurtigt svar på millioner af vektorer – et kompromis, der næsten altid er acceptabelt, da det at returnere det femtebedste dokument i stedet for det fjerde ikke ændrer noget for brugeroplevelsen. Metadata-filtrering kombineret med vektorsøgning giver dig mulighed for at begrænse en forespørgsel til en kategori, et sprog eller en datoperiode uden efterbehandling. Persistens og opdateringer i realtid undgår at skulle genopbygge en hel fil blot for at tilføje et dokument. Endelig er horisontal skalering det, der adskiller en prototype fra en produktionstjeneste.

Pinecone

Pinecone er en administreret tjeneste: du klargør ingen servere, du opretter et indeks ved at angive dets dimension og metrik, og resten håndteres for dig. Bemærk filteret categorie, der sendes direkte til query – vektorsøgning og filtrering udføres sammen, ikke den ene efter den anden.

from pinecone import Pinecone
from openai import OpenAI

pc = Pinecone(api_key="your-pinecone-key")
openai_client = OpenAI()

# Create an index
pc.create_index(
    name="my-corpus",
    dimension=3072,
    metric="cosine",
    spec={"serverless": {"cloud": "aws", "region": "eu-west-1"}}
)

index = pc.Index("my-corpus")

# Index documents
documents = [
    {"id": "doc1", "texte": "Python Installation Guide",
     "categorie": "tutorial"},
    {"id": "doc2", "texte": "Deploying a Flask Application",
     "categorie": "tutorial"},
    {"id": "doc3", "texte": "Q1 2026 Quarterly Report",
     "categorie": "report"},
]

# Generate embeddings
textes = [d["texte"] for d in documents]
response = openai_client.embeddings.create(
    input=textes,
    model="text-embedding-3-large"
)

# Upsert into Pinecone
vecteurs = [
    {
        "id": doc["id"],
        "values": emb.embedding,
        "metadata": {"texte": doc["texte"], "categorie": doc["categorie"]}
    }
    for doc, emb in zip(documents, response.data)
]
index.upsert(vectors=vecteurs)

# Search
query_emb = openai_client.embeddings.create(
    input="how to install Python",
    model="text-embedding-3-large"
).data[0].embedding

resultats = index.query(
    vector=query_emb,
    top_k=3,
    include_metadata=True,
    filter={"categorie": {"$eq": "tutorial"}}
)

for match in resultats.matches:
    print(f"[{match.score:.3f}] {match.metadata['texte']}")

Den dimension, der erklæres ved oprettelse, er endelig: skift fra text-embedding-3-large til text-embedding-3-small kræver genoprettelse af indekset. Så beslut dig for modellen før, ikke efter.

Qdrant

Qdrant er open source, selvhostet og tilbyder fremragende ydeevne. Ordforrådet er anderledes – vi taler om samlinger, punkter og payloads, hvor Pinecone taler om indeks, vektorer og metadata – men skemaet forbliver identisk. Bemærk, at eksemplet kalder embedding-API’en dokument for dokument inde i løkken: dette er acceptabelt for tre dokumenter, men husk at skifte tilbage til batches, så snart korpussen vokser.

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, VectorParams, PointStruct, Filter,
    FieldCondition, MatchValue
)
from openai import OpenAI

qclient = QdrantClient(url="http://localhost:6333")
openai_client = OpenAI()

# Create a collection
qclient.create_collection(
    collection_name="my-corpus",
    vectors_config=VectorParams(
        size=3072,
        distance=Distance.COSINE
    )
)

# Index documents
points = []
for i, doc in enumerate(documents):
    emb = openai_client.embeddings.create(
        input=doc["texte"],
        model="text-embedding-3-large"
    ).data[0].embedding

    points.append(PointStruct(
        id=i,
        vector=emb,
        payload={"texte": doc["texte"], "categorie": doc["categorie"]}
    ))

qclient.upsert(collection_name="my-corpus", points=points)

# Search with filter
query_emb = openai_client.embeddings.create(
    input="deploy a web application",
    model="text-embedding-3-large"
).data[0].embedding

resultats = qclient.search(
    collection_name="my-corpus",
    query_vector=query_emb,
    limit=3,
    query_filter=Filter(
        must=[FieldCondition(
            key="categorie",
            match=MatchValue(value="tutorial")
        )]
    )
)

for r in resultats:
    print(f"[{r.score:.3f}] {r.payload['texte']}")

Weaviate

Weaviate skiller sig ud med sin native hybride søgning, som vi vender tilbage til i lektion 9. Dens datamodel er mere struktureret end konkurrenternes: du erklærer eksplicit egenskaber og deres typer, før du indsætter noget, hvilket bringer oplevelsen tættere på en klassisk database.

import weaviate
from openai import OpenAI

wclient = weaviate.connect_to_local()
openai_client = OpenAI()

# Create a collection
from weaviate.classes.config import Property, DataType

collection = wclient.collections.create(
    name="Document",
    properties=[
        Property(name="texte", data_type=DataType.TEXT),
        Property(name="categorie", data_type=DataType.TEXT),
    ]
)

# Index
for doc in documents:
    emb = openai_client.embeddings.create(
        input=doc["texte"],
        model="text-embedding-3-large"
    ).data[0].embedding

    collection.data.insert(
        properties={"texte": doc["texte"], "categorie": doc["categorie"]},
        vector=emb
    )

# Search
query_emb = openai_client.embeddings.create(
    input="install Python",
    model="text-embedding-3-large"
).data[0].embedding

resultats = collection.query.near_vector(
    near_vector=query_emb,
    limit=3
)

Chroma og pgvector

Chroma sigter mod prototyping: en persistent klient pegende på en lokal mappe, en samling oprettet på farten, ingen infrastruktur. Dette er den mulighed, der tager dig fra et NumPy-indeks til en rigtig database uden at ændre dit arbejdsmiljø.

import chromadb
from openai import OpenAI

chroma = chromadb.PersistentClient(path="./chroma_db")
openai_client = OpenAI()

collection = chroma.get_or_create_collection("my-corpus")

# Index
for doc in documents:
    emb = openai_client.embeddings.create(
        input=doc["texte"],
        model="text-embedding-3-large"
    ).data[0].embedding

    collection.add(
        ids=[doc["id"]],
        embeddings=[emb],
        documents=[doc["texte"]],
        metadatas=[{"categorie": doc["categorie"]}]
    )

# Search
query_emb = openai_client.embeddings.create(
    input="how to install Python",
    model="text-embedding-3-large"
).data[0].embedding

resultats = collection.query(query_embeddings=[query_emb], n_results=3)

pgvector adresserer en helt anden situation: dine dokumenter er allerede i PostgreSQL med deres joins, adgangsrettigheder og sikkerhedskopier. I stedet for at introducere et andet system, der skal synkroniseres, tilføjer udvidelsen en vector-type og afstandoperatorer til den eksisterende database. Operatoren <=> beregner cosinusafstand, og HNSW-indekset er det, der gør forespørgslen brugbar ud over nogle få tusinde rækker.

-- pgvector extension
CREATE EXTENSION vector;

CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    texte TEXT,
    categorie TEXT,
    embedding vector(3072)
);

-- HNSW index for performance
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);

-- Search for the 5 nearest neighbors
SELECT id, texte, 1 - (embedding <=> $1::vector) AS score
FROM documents
ORDER BY embedding <=> $1::vector
LIMIT 5;

Sammenligning

KriteriumPineconeQdrantWeaviateChromapgvector
TypeAdministreretOpen sourceOpen sourceOpen sourceUdvidelse
HostingCloudSelvhostet/CloudSelvhostet/CloudLokal/EmbedPostgreSQL
Hybrid søgning✅✅✅ Native❌Via SQL
Produktion✅✅✅⚠️ Prototyping✅
Brugervenlighed✅✅✅✅✅✅✅

Valget afhænger mindre af rå ydeevne, som i praksis er meget tæt, end af din kontekst: et team, der allerede kører PostgreSQL, har al interesse i at blive ved det, et team uden ops vil vælge administreret, og et team, der skal hoste i Europa af regulatoriske årsager, vil vende sig mod selvhostede løsninger.

Vigtige pointer

  • Chroma til hurtig prototyping
  • pgvector hvis du allerede har PostgreSQL
  • Pinecone til administreret løsning uden infrastruktur
  • Qdrant til højtydende selvhosting
  • Weaviate til native hybrid søgning