AI Engineering Academy · Lektion

pgvector: Embeddings i PostgreSQL

Aktivér pgvector-udvidelsen i PostgreSQL, opret en tabel med en vektorkolonne, indsæt embeddings, og kør forespørgsler efter nærmeste naboer ved hjælp af operatoren til cosinusafstand.

Lektion 3 af 413 trin

pgvector: Embeddings i PostgreSQL er en gratis AI Engineering Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i AI Engineering Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. AI Engineering Academy-kurset indeholder 4 lektioner i alt.

pgvector: Vektorsøgning i PostgreSQL

pgvector er en open source-udvidelse til PostgreSQL, der tilføjer datatypen vector og operatorer til lighedssøgning. Den lader dig gemme embeddings sammen med dine almindelige applikationsdata i den samme database, som du allerede driver, så du undgår et separat vektorlager.

Det er ideelt for teams, der allerede bruger PostgreSQL og vil tilføje semantisk søgning uden at introducere en ny infrastrukturafhængighed.

Aktivering af pgvector-udvidelsen

Installér pgvector fra det officielle repository, eller brug en administreret PostgreSQL-udbyder, der har det installeret på forhånd (Supabase, Neon, AWS RDS, Render). Aktivér det derefter i din database med en enkelt SQL-kommando — ingen genstart er nødvendig.

-- Run this once per database to enable the extension
CREATE EXTENSION IF NOT EXISTS vector;

-- Verify it's installed
SELECT extname, extversion
FROM pg_extension
WHERE extname = 'vector';
-- Returns: vector | 0.7.0 (or similar)

Oprettelse af en tabel med en vektorkolonne

Tilføj en vektorkolonne ved at angive vector(n), hvor n er embeddingens dimension. Du kan kombinere den med almindelige PostgreSQL-kolonner til metadata — det giver dig mulighed for at filtrere efter user_id, created_at eller et hvilket som helst andet felt ved hjælp af standardiserede SQL WHERE-betingelser.

CREATE TABLE documents (
    id          BIGSERIAL PRIMARY KEY,
    content     TEXT NOT NULL,
    category    TEXT,
    created_at  TIMESTAMPTZ DEFAULT NOW(),
    embedding   vector(1536)   -- must match your model dimension
);

-- Index on category for fast metadata filtering
CREATE INDEX ON documents (category);

SELECT column_name, data_type
FROM information_schema.columns
WHERE table_name = 'documents';

Indsættelse af embeddings fra Python

Brug driveren psycopg2 eller asyncpg til at indsætte rækker med embeddings. Konvertér Python-listen med kommatal til en streng i formatet '[0.1, 0.2, ...]', som pgvector fortolker korrekt. Python-pakken pgvector indeholder en hjælper kaldet register_vector, der håndterer dette automatisk.

import psycopg2
from pgvector.psycopg2 import register_vector
from openai import OpenAI

conn = psycopg2.connect('postgresql://user:pass@localhost/mydb')
register_vector(conn)
cur = conn.cursor()

client = OpenAI()

document = 'pgvector adds vector search to PostgreSQL.'
resp = client.embeddings.create(model='text-embedding-3-small', input=document)
embedding = resp.data[0].embedding

cur.execute(
    'INSERT INTO documents (content, category, embedding) VALUES (%s, %s, %s)',
    (document, 'database', embedding)
)
conn.commit()
print('Inserted document with embedding')

Cosinuslighed med operatoren <=>

pgvector tilføjer tre afstandsoperatorer:

<=> — cosinusafstand (1 - cosine_similarity)
<-> — euklidisk afstand (L2)
<#> — negativt indre produkt (bruges til lighed baseret på prikprodukt)

Brug <=> (cosinusafstand) til tekstembeddings. ORDER BY distance ASC returnerer de mest lignende dokumenter først.

-- Find top 5 documents most similar to a query embedding
-- Replace '[0.1, 0.2, ...]' with the actual query vector
SELECT
    id,
    content,
    category,
    1 - (embedding <=> '[0.1, 0.2, 0.3]'::vector) AS cosine_similarity
FROM documents
ORDER BY embedding <=> '[0.1, 0.2, 0.3]'::vector
LIMIT 5;

Kombination af vektorsøgning med SQL-filtre

En af pgvectors største fordele er, at du kan kombinere ANN-søgning med standardiserede SQL WHERE-betingelser. Det muliggør indbygget metadatafiltrering uden nogen særlig syntaks — du skal bare skrive SQL.

-- Semantic search filtered to the 'database' category
-- and only recent documents
SELECT
    id,
    content,
    1 - (embedding <=> %s::vector) AS similarity
FROM documents
WHERE
    category = 'database'
    AND created_at > NOW() - INTERVAL '30 days'
ORDER BY embedding <=> %s::vector
LIMIT 5;

-- In Python with psycopg2:
# cur.execute(sql, (query_embedding, query_embedding))

Oprettelse af et HNSW-indeks for højere hastighed

Uden et indeks gennemgår pgvector hver enkelt række — det fungerer fint ved under 10.000 rækker, men bliver langsomt i stor skala. Opret et HNSW-indeks til omtrentlig nærmeste-nabo-søgning. Parametrene m (forbindelser pr. node) og ef_construction (søgebredde under opbygning) afvejer indeksstørrelse og opbygningstid mod træfsikkerhed.

-- Create an HNSW index for cosine distance queries
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);

-- At query time, control recall vs speed:
SET hnsw.ef_search = 40;  -- higher = better recall, slower

-- Verify the index is being used:
EXPLAIN SELECT * FROM documents
ORDER BY embedding <=> '[0.1]'::vector(1)
LIMIT 5;

IVFFlat-indeks: Et alternativ til HNSW

Indekstypen IVFFlat grupperer vektorer i lists-spande og søger kun i de nærmeste probes-spande på forespørgselstidspunktet. Det opbygges hurtigere end HNSW og bruger mindre hukommelse, men har en lidt lavere træfsikkerhed ved samme hastighed.

Tommelfingerregel: Brug IVFFlat, når du har brug for hurtigere indeksopbygning under hyppig genindeksering; brug HNSW til stabile korpora, der kræver maksimal søgehastighed.

-- IVFFlat index: good for large, infrequently updated corpora
-- lists ≈ sqrt(n) where n is the number of vectors
CREATE INDEX ON documents
USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);

-- At query time, probes controls recall vs speed:
SET ivfflat.probes = 10;  -- check 10 of 100 clusters

Komplet Python-eksempel på en forespørgsel

Her er en komplet Python-funktion, der modtager en brugerforespørgsel, opretter en embedding af den, kører en pgvector-lighedssøgning med metadatafiltrering og returnerer de bedste k resultater som en liste af dicts.

import psycopg2
from pgvector.psycopg2 import register_vector
from openai import OpenAI

conn = psycopg2.connect('postgresql://user:pass@localhost/mydb')
register_vector(conn)
client = OpenAI()

def semantic_search(query, category=None, top_k=5):
    resp = client.embeddings.create(model='text-embedding-3-small', input=query)
    q_vec = resp.data[0].embedding

    sql = '''
        SELECT content,
               1 - (embedding <=> %s::vector) AS similarity
        FROM documents
        {where}
        ORDER BY embedding <=> %s::vector
        LIMIT %s
    '''
    where = 'WHERE category = %s' if category else ''
    params = [q_vec, q_vec, top_k] if not category else [q_vec, category, q_vec, top_k]
    cur = conn.cursor()
    cur.execute(sql.format(where=where), params)
    return [{'text': r[0], 'score': r[1]} for r in cur.fetchall()]

Afvejning mellem pgvector og Pinecone

Sammenligning af pgvector og Pinecone:

pgvector: selvhostet, ingen ekstra omkostninger, perfekt SQL-integration, skalerer godt til omkring 5 millioner vektorer, kræver DBA-viden til tuning
Pinecone: fuldt administreret, massiv skala (milliarder af vektorer), specialiseret filtrering, dyrere, separat tjeneste, der skal driftes

Vælg pgvector, når du allerede kører PostgreSQL, og dit korpus er på under nogle få millioner dokumenter. Vælg Pinecone til massiv skala, eller når det er omkostningen værd at undgå driftsarbejde.

Brug af pgvector med Supabase

Supabase er en hostet PostgreSQL-tjeneste med pgvector installeret på forhånd. Den leverer en Python-klient (supabase-py) og en REST API til vektorforespørgsler, hvilket gør den til den nemmeste måde at få en pgvector-opsætning i produktion på uden selv at administrere en databaseserver.

from supabase import create_client
import os

url = os.environ['SUPABASE_URL']
key = os.environ['SUPABASE_SERVICE_KEY']
supabase = create_client(url, key)

# Insert a document with embedding
supabase.table('documents').insert({
    'content': 'Supabase hosts PostgreSQL with pgvector.',
    'embedding': embedding   # list of 1536 floats
}).execute()

# Vector similarity search via RPC (Supabase edge function)
# result = supabase.rpc('match_documents', {'query_embedding': q_vec, 'match_count': 5}).execute()

Hurtigt tjek

Test din forståelse af begreberne inden for AI Engineering fra denne lektion.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion har du lært, at pgvector tilføjer en vektorkolonn datatype samt operatorer til cosinus- og euklidisk afstand i PostgreSQL, at HNSW-indekser muliggør hurtig omtrentlig nærmeste-nabo-søgning i stor skala, og at standardiserede SQL WHERE-betingelser giver metadatafiltrering uden nogen særlig syntaks. Dernæst sammenligner vi alle de vigtigste muligheder for vektorlager, så du kan vælge den rigtige til dit projekt.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 30
Lektioner: 120

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “pgvector: Embeddings i PostgreSQL” gratis?

Ja — hele teksten til “pgvector: Embeddings i PostgreSQL” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af AI Engineering Academy-kurset, skal du opgradere til CoddyKit PRO. AI Engineering Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “pgvector: Embeddings i PostgreSQL”?

Aktivér pgvector-udvidelsen i PostgreSQL, opret en tabel med en vektorkolonne, indsæt embeddings, og kør forespørgsler efter nærmeste naboer ved hjælp af operatoren til cosinusafstand. Du øver dig i AI Engineering Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på AI Engineering Academy?

Der kræves ingen tidligere erfaring. AI Engineering Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “pgvector: Embeddings i PostgreSQL”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne AI Engineering Academy-lektion?

Ja. Alle AI Engineering Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Hvorfor De har brug for en vektordatabase
Kom godt i gang med Pinecone
pgvector: Embeddings i PostgreSQL
Valg og benchmarking af vektorlager

← Tilbage til AI Engineering Academy