{"canonical_url":"https://engineer.company/sv/glossary/vector-search/","content_markdown":"# Vektorsökning\n\n## Vad det är\n\nVektorsökning hittar de lagrade objekt vars vektorer ligger närmast sökningens\nvektor. På engelska heter det vector search. En vektor är här en lista med tal\nav fast längd som en embeddingmodell räknar fram ur ett textstycke, en bild\neller en produktpost. Modellen är tränad så att objekt med liknande innehåll får\nvektorer som ligger nära varandra, och därför kan en fråga och stycket som\nbesvarar den hamna tätt intill varandra även när de inte har ett enda ord\ngemensamt.\n\n”Närmast” kräver ett mått. pgvector, det PostgreSQL-tillägg som exemplen i den\nhär artikeln använder, stöder sex: L2-avstånd (euklidiskt), skalärprodukt,\ncosinusavstånd och L1-avstånd, plus Hammingavstånd och Jaccardavstånd för binära\nvektorer. Embeddingmodellens egen dokumentation anger vilket mått vektorerna är\navsedda för. För vektorer som är normaliserade till längden 1 ger cosinusavstånd\noch skalärprodukt grannarna samma ordning, och där rekommenderar pgvector\nskalärprodukt eftersom den ger bäst prestanda.\n\nDet finns två sätt att besvara sökningen. Exakt sökning jämför sökningen med\nvarenda lagrad vektor och returnerar de verkliga närmaste grannarna. Det är vad\npgvector gör som standard, och dokumentationen kallar det perfekt täckning\n(recall). Ungefärlig sökning kan använda ett index som bara besöker en del av datan\noch byter bort lite täckning mot fart. Hur många verkliga grannar som kommer\nmed beror på datan, indexet och dess inställningar; inte ens en majoritet är garanterad. Därför varnar pgvector för att ett ungefärligt\nindex, till skillnad från ett vanligt index, ändrar vad en fråga returnerar.\n\npgvector har två typer av ungefärliga index. HNSW bygger en graf i flera lager,\nen metod som Malkov och Yashunin först publicerade 2016. Varje lager innehåller\nett urval av noderna i lagret under, en sökning börjar i det lilla översta\nlagret och går nedåt till det fullständiga, och enligt deras artikel växer\nsökkostnaden logaritmiskt. IVFFlat delar in vektorerna i listor och söker bara i\nde listor som ligger närmast sökningen.\n\n## Varför det spelar roll\n\nFulltextsökning jämför ord. Med enbart ordmatchning och stemming hittar en kund som skriver ”skärmen förblir svart”\ninte avsnittet i handboken med rubriken ”displayen startar inte”, eftersom de\ntvå inte delar något ord som stemmingen kan föra samman. Konfigurerade synonymer kan överbrygga några sådana skillnader. Vektorsökning jämför\nbetydelse så som embeddingmodellen har fångat den, så klagomålet och avsnittet\nkan hamna nära varandra. Samma idé fungerar bortom text: en bild som liknar den\nhär, ett supportärende som liknar ett som redan är löst, en produkt som liknar\nden som ligger i varukorgen.\n\nDet är också ett sätt att sköta hämtningen i retrieval-augmented generation, där\nen stor språkmodell svarar utifrån textstycken som hämtats för frågan. Frågan\ngörs om till en vektor med samma modell som styckena, och de närmaste styckena\nläggs in i prompten. Svaret blir aldrig bättre än det sökningen fick med sig, så\nsökningen förtjänar lika mycket omsorg som modellen.\n\nAtt ha vektorerna i den databas ni redan driver har en praktisk sida, och\npgvector inleder sin dokumentation med just det argumentet. Vektorerna får samma\ntransaktioner, samma återställning till en viss tidpunkt (point-in-time\nrecovery) och samma joinar som alla andra kolumner, och eftersom pgvector\nskriver till write-ahead-loggen (WAL) följer de med i replikeringen också. Ett\nfilter på kund, datum eller behörighet är ett vanligt `WHERE`-villkor på samma\nrad. En ögonblicksbild som tas efter att en radering har bekräftats ser inte\nlängre dokumentet, men en fråga med en äldre ögonblicksbild kan fortfarande se det. Ett separat vektorlager är ett system till som måste\nfyllas och hållas i takt med det första.\n\nEtt team bör också veta vad vektorsökning inte gör. Den rangordnar efter närhet,\ninte efter sanning. Det närmaste stycket är det som mest liknar frågan; det kan\nändå vara inaktuellt, fel eller hämtat ur ett dokument som läsaren inte får se.\nVissa frågor hänger på ett exakt ord, som ett namn, ett artikelnummer eller en\nfelkod, och pgvectors dokumentation föreslår att vektorsökning används\ntillsammans med fulltextsökningen i PostgreSQL. Den kombinationen kallas\nhybridsökning.\n\n## Så ser det ut i praktiken\n\npgvector, i version 0.8.7 i oktober 2026, stöder PostgreSQL 13 och senare.\nTillägget aktiveras en gång i varje databas, och sedan får tabellen en kolumn av\ntypen `vector` med det antal dimensioner som modellen ger:\n\n```sql\nCREATE EXTENSION vector;\n\nCREATE TABLE passages (\n    id        bigserial PRIMARY KEY,\n    source    text NOT NULL,\n    body      text NOT NULL,\n    embedding vector(3)\n);\n\nCREATE INDEX ON passages USING hnsw (embedding vector_cosine_ops);\n```\n\nTre dimensioner håller exemplet läsbart; en verklig modell ger betydligt fler,\noch kolumnen anger det antal som modellen ger. Applikationen räknar fram varje\nembedding med modellen och lägger in den bredvid texten den kom från. Indexet\ngäller ett enda avstånd: `vector_cosine_ops` betjänar frågor som sorteras efter\ncosinusavstånd, och en fråga som sorteras efter L2-avstånd behöver ett index\ntill, byggt med `vector_l2_ops`. HNSW har inget träningssteg, så indexet kan\nskapas på en tabell utan rader.\n\nVid sökning görs frågan om till en vektor med samma modell, och SQL-frågan ber\nom de närmaste styckena:\n\n```sql\nSELECT id, source, body\nFROM   passages\nORDER  BY embedding \u003c=\u003e $1\nLIMIT  5;\n```\n\n`\u003c=\u003e` är cosinusavstånd, och `$1` är sökvektorn, skickad som parameter. Två\ndetaljer gör att planeraren kan använda indexet: frågan har både `ORDER BY` och\n`LIMIT`, och `ORDER BY` står på själva avståndsoperatorn i stigande ordning. Ett\nlikhetsvärde att visa, `1 - (embedding \u003c=\u003e $1)`, hör hemma i `SELECT`-listan. De\nandra operatorerna är `\u003c-\u003e` för L2-avstånd, `\u003c+\u003e` för L1 och `\u003c#\u003e` för\nskalärprodukt. Den sista returnerar den negativa skalärprodukten, eftersom\nPostgreSQL bara skannar ett index på en operator i stigande ordning.\n\nHNSW-indexet har två byggparametrar: `m`, det största antalet förbindelser per\nlager, 16 som standard, och `ef_construction`, storleken på kandidatlistan under\nbygget, 64 som standard. Vid sökning sätter `hnsw.ef_search` storleken på\nkandidatlistan, 40 som standard. Ett högre värde ger bättre täckning på\nbekostnad av fart, och `SET LOCAL` höjer det fram till slutet av den aktuella\ntransaktionen. För att begränsa inställningen till en fråga ska transaktionen\nbara innehålla den frågan. Vill du veta hur mycket täckning indexet kostar kör du samma fråga i en\ntransaktion med `SET LOCAL enable_indexscan = off`, som ger det exakta svaret,\noch jämför de två listorna.\n\nFöretagets [arbete med skräddarsydda AI-agenter](/sv/ai-agents/) lägger agentens\nminne av tidigare ärenden i kundens egen databas, inte i en leverantörs\nchatthistorik. En tabell som `passages` är en form ett sådant minne kan ta: när\nett nytt ärende kommer in ligger de tidigare ärenden som liknar det mest en\nfråga bort, i samma databas och under samma behörigheter som resten av datan.\n\nHybridsökning kör båda sökningarna och slår ihop de två listorna. pgvectors\ndokumentation nämner Reciprocal Rank Fusion, från en artikel av Cormack, Clarke\noch Büttcher från 2009: varje dokument får 1 / (k + rang) för varje lista det\nfinns med i, och andelarna läggs ihop. Författarna satte k till 60, och deras\nprovkörningar visade att 60 var ”near-optimal, but that the choice was not\ncritical”. Med en `tsvector`-kolumn `search_vec` i samma tabell, byggd som för\nfulltextsökning, ser den sammanslagna frågan ut så här:\n\n```sql\nWITH semantic AS (\n    SELECT id, row_number() OVER (ORDER BY dist) AS r\n    FROM  (SELECT id, embedding \u003c=\u003e $1 AS dist\n           FROM   passages\n           ORDER  BY dist\n           LIMIT  20) AS nearest\n),\nkeyword AS (\n    SELECT id, row_number() OVER (ORDER BY score DESC) AS r\n    FROM  (SELECT id, ts_rank_cd(search_vec, query) AS score\n           FROM   passages, plainto_tsquery('swedish', $2) AS query\n           WHERE  search_vec @@ query\n           ORDER  BY score DESC\n           LIMIT  20) AS matches\n)\nSELECT id,\n       coalesce(1.0 / (60 + s.r), 0)\n     + coalesce(1.0 / (60 + k.r), 0) AS rrf\nFROM   semantic AS s\nFULL   JOIN keyword AS k USING (id)\nORDER  BY rrf DESC\nLIMIT  5;\n```\n\nVarje sökning behåller sina egna 20 bästa och numrerar dem från 1. Ett stycke\nsom båda sökningarna placerar högt får två andelar och stiger till toppen; ett\nstycke som bara en sökning hittade behåller en. Sammanslagningen använder\nrangordning i stället för poäng, eftersom ett cosinusavstånd och en textrang\nligger på skalor som inte går att jämföra. Språket i `plainto_tsquery` måste\nvara detsamma som i kolumnen, här `swedish`. pgvector nämner en cross-encoder\nsom det andra sättet att kombinera listorna.\n\n## Var det går fel\n\n**Färre rader än `LIMIT` bad om.** Med ett ungefärligt index tillämpas\n`WHERE`-villkoret först efter att indexet har skannats. pgvector visar\nräkneexemplet: om ett villkor träffar 10 % av raderna ger ett HNSW-index med\nstandardvärdet 40 för `hnsw.ef_search` i genomsnitt bara omkring 4 rader. Från\noch med version 0.8.0 skannar iterativa indexskanningar mer av indexet tills\ntillräckligt många rader har passerat filtret eller skanningsgränserna har nåtts. Slå på dem med\n`SET hnsw.iterative_scan = strict_order`, eller `relaxed_order` för bättre\ntäckning med resultat som kan stå något i fel ordning. För HNSW är\n`hnsw.max_scan_tuples`, 20 000 som standard, en ungefärlig gräns för ytterligare\nbesökta tupler och påverkar inte den första skanningen. En separat minnesgräns\nkan också stoppa fortsatt skanning. För ett filter med bara ett\nfåtal olika värden fungerar också ett partiellt index per värde.\n\n**En fråga som missar indexet för närmaste grannar.** `ORDER BY 1 - (embedding \u003c=\u003e $1) DESC` sorterar efter ett uttryck, och en fråga utan `LIMIT` begär inte ett avgränsat resultat med de närmaste grannarna. Inget av fallen uppfyller pgvectors krav för att använda det indexet. Hur många rader den valda planen läser beror också på filter och andra val som planeraren gör. Ett index byggt med `vector_l2_ops` hjälper inte en fråga som sorteras efter `\u003c=\u003e`. Sortera efter själva operatorn, stigande, med `LIMIT`; bygg ett index per avstånd du söker med; och kontrollera planen med `EXPLAIN (ANALYZE, BUFFERS)`.\n\n**Ett IVFFlat-index byggt för tidigt.** IVFFlat kör k-means över de rader som\nfinns när indexet byggs och delar in vektorerna i listor utifrån resultatet. Ett\nindex som skapats med för lite data för sitt antal listor returnerar färre rader\nän frågan bad om, och pgvector råder dig att ta bort det tills tabellen har fått\nmer data. Läs in datan först och bygg sedan. pgvector föreslår att börja med\nrader / 1000 listor upp till en miljon rader och kvadratroten ur antalet rader\ndärutöver, och att sätta probes, 1 som standard, till kvadratroten ur antalet\nlistor. HNSW har inget sådant träningssteg.\n\n**Rader som aldrig hittas.** NULL-vektorer indexeras inte, och det gör inte\nheller nollvektorer vid cosinusavstånd, eftersom de saknar en riktning att\njämföra. En rad som saknar embedding är osynlig för en sökning via indexet. Lägg\ntill `NOT NULL` när inläsningen är pålitlig, och kör en schemalagd räkning av\nrader som fortfarande saknar embedding.\n\n**Vektorer från två modeller i en kolumn.** Två embeddingmodeller, eller två\nversioner av samma modell, placerar samma text på olika ställen, och deras\nvektorer går inte att jämföra ens när antalet dimensioner stämmer. Gör om frågan\ntill en vektor med den modell som tog fram vektorerna för styckena, spara\nmodellen i en kolumn och räkna om alla vektorer när modellen byts. För en kolumn\nmed vektorer av flera storlekar visar pgvector ett uttrycksindex med ett villkor\nper modell, `WHERE (model_id = 123)`.\n\n**För många dimensioner för indexet.** Typen `vector` lagrar upp till 16 000\ndimensioner, men HNSW och IVFFlat indexerar högst 2 000. Indexera en\n`halfvec`-konvertering för att nå upp till 4 000, använd binär kvantisering för\nupp till 64 000 och rangordna kortlistan på nytt med de fullständiga vektorerna,\neller indexera en delvektor när modellen stöder det.\n\n**En kunds vektorer saktar ner en annans.** pgvector varnar för att när flera\nkunder delar ett ungefärligt index kan vektorerna hos en av dem påverka täckning\noch fart för de andra. Partitionera tabellen per kund med listpartitionering,\neller ge varje kund en egen tabell.\n\n**Ett indexbygge som blockerar applikationen.** HNSW byggs mycket snabbare när\ngrafen får plats i `maintenance_work_mem`, och pgvector skriver ut ett\nmeddelande när den inte längre gör det; att sätta det minnet så högt att servern\nfår för lite minne orsakar ett eget driftstopp. På ett system i drift bygger du\nmed `CREATE INDEX CONCURRENTLY`, som inte blockerar skrivningar.\n\n**Stycken som läsaren inte får se.** En sökning över alla stycken kan ge en\nspråkmodell text ur ett dokument som användaren inte har rätt att läsa, och\nmodellen kan citera den. Lägg behörighetsvillkoret i samma `WHERE`-villkor som\nsökningen, så att en sådan rad aldrig lämnar databasen, och slå på iterativa\nskanningar för att leta efter fler tillåtna stycken när filtreringen tar bort\nkandidater, inom skanningsgränserna.\n\n**Ett avstånd som tolkas som visshet.** Ett cosinusavstånd på 0,2 säger att ett\nstycke ligger närmare än ett på 0,4, inte att det besvarar frågan. En tröskel\nsom är inställd för en modell betyder ingenting för nästa. Sortera efter\navstånd, begränsa med `LIMIT` och bedöm sökningen mot en uppsättning verkliga\nfrågor där de rätta styckena är kända.\n\n## Läs mer\n\n- [pgvector](https://github.com/pgvector/pgvector) — tilläggets egen\n  dokumentation: typer, avståndsoperatorer, inställningar för HNSW och IVFFlat,\n  filtrering, iterativa indexskanningar, hybridsökning och felsökning.\n- [Efficient and robust approximate nearest neighbor search using Hierarchical Navigable Small World graphs](https://arxiv.org/abs/1603.09320)\n  — artikeln av Malkov och Yashunin som introducerade HNSW.\n- [Reciprocal Rank Fusion outperforms Condorcet and individual Rank Learning Methods](https://cormack.uwaterloo.ca/cormacksigir09-rrf.pdf)\n  — SIGIR-artikeln från 2009 med formeln för sammanslagningen och\n  provkörningarna bakom dess konstant.\n- [Introduction to full text search](https://www.postgresql.org/docs/current/textsearch-intro.html)\n  — ordbaserad sökning i PostgreSQL, den andra halvan av en hybridfråga.\n- [Controlling Text Search](https://www.postgresql.org/docs/current/textsearch-controls.html)\n  — `plainto_tsquery` och `ts_rank_cd`, så som de används i ordsökningen ovan.\n- [Transaction Isolation](https://www.postgresql.org/docs/current/transaction-iso.html)\n  — när PostgreSQLs ögonblicksbilder ser bekräftade ändringar, inklusive varför en äldre ögonblicksbild fortfarande kan se ett dokument efter att dess radering har bekräftats.\n\n\u003chttps://engineer.company/sv/glossary/vector-search/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Vad vektorsökning är: embeddingar jämförda efter avstånd, exakta och ungefärliga index i pgvector, hybridsökning och de vanliga felen.","formats":{"gemtext":"https://engineer.company/sv/glossary/vector-search/index.gmi","gopher":"https://engineer.company/sv/glossary/vector-search/gophermap","html":"https://engineer.company/sv/glossary/vector-search/","json":"https://engineer.company/sv/glossary/vector-search/index.json","markdown":"https://engineer.company/sv/glossary/vector-search/index.md","pdf":"https://engineer.company/sv/glossary/vector-search/index.pdf"},"kind":"page","language":"sv","title":"Vad är vektorsökning?","url":"https://engineer.company/sv/glossary/vector-search/","version":1}