BM25 Plus pgvector mit rekursiver Rangfusion: Hybrider Suchalgorithmus für RAG in Python
Hybride Suche für RAG in Python: Warum dichte Suche genaue Begriffe übersieht, wie BM25 und pgvector-Kosinus-Suche sich ergänzen, kombiniert mit RRF in Postgres.
Quellen: Why BM25 + pgvector Hybrid Search Beats Naive RAG — A Deep Technical Breakdown
Reine Dichtvektoren übersehen genaue Schlüsselwörter, seltene Begriffe sowie Fachjargon aus bestimmten Bereichen. Die Kombination eines lexikalischen Rangierers mit einem Vektorindex schließt diese Lücke, und das Ganze passt in eine auf Postgres ausgerichtete Python-Stack-Lösung. Die Mathematik, die Architektur sowie der Code folgen daraufhin.
Was stimmt bei herkömmlichem RAG nicht?
Ein grundlegender, auf Abruf basierender Pipeline ist kurz gefasst wie folgt:
- Embedden Sie die Abfrage mit einem Modell wie
text-embedding-3-small. - Führen Sie eine Kosinus-Suche in einem Vektorlagersystem wie pgvector, Pinecone oder Weaviate durch.
- Nehmen Sie die besten K-Blöcke.
- Fügen Sie diese dem Prompt des LLM hinzu.
Das funktioniert, solange eine Abfrage auf einem wörtlichen String beruht. Angenommen, ein Benutzer fragt, wie ein Projekt BM25 zur Rangliste erstellt. Die Abfragedarstellung liegt dann in der Nähe von Vektoren zu Themen wie Ranglisten, Suchalgorithmen und Relevanzbewertung, sodass ein Dokument, das den wörtlichen Token BM25 enthält, gegenüber einer allgemeineren Seite über Suchmodelle verlieren kann. Das ist das Problem des Wortschatzunterschieds, das Forscher im Bereich der Informationsbeschaffung bereits seit den 1990er Jahren kennen.
Embeddings pressen Bedeutungen in einen kontinuierlichen Raum und verwischen dabei genaue Übereinstimmungen. Eine Nähe zwischen „Herzinfarkt“ und „Herzattacke“ ist erwünscht. Eine Nähe zwischen BM25 und Okapi Ranking hingegen stellt ein Nachteil dar, wenn die Abfrage spezifisch ist.
BM25 im Überblick
BM25, abgekürzt für Best Match 25, ist eine probabilistische Term-Gewichtungsfunktion aus der Okapi-Familie von Suchmodellen. Für ein Dokument d und eine Abfrage q addiert sie die Gewichte der Abfrageterme zusammen:
score(q, d) = Σ IDF(tᵢ) · [f(tᵢ, d) · (k₁ + 1)] / [f(tᵢ, d) + k₁ · (1 - b + b · |d| / avgdl)]
Die Symbole bedeuten Folgendes:
tᵢist ein Begriff der Abfrage.f(tᵢ, d)zählt, wie oft dieser Begriff im Dokument vorkommt.|d|ist die Länge des Dokuments in Tokens undavgdlist die durchschnittliche Länge im Korpus.k₁, in der Regel zwischen 1,2 und 2,0, legt fest, wie schnell die Termhäufigkeit sättigt; ein höherer Wert verleiht der Häufigkeit mehr Gewicht.b, zwischen 0 und 1, steuert die Längennormalisierung, wobei 0 keine Normalisierung und 1 eine vollständige Normalisierung bedeutet.IDF(tᵢ)ist das Logarithmus des Verhältnisses zwischen Dokumenten, die den Begriff nicht enthalten, und Dokumenten, die ihn enthalten (jeweils um die Hälfte eines Dokuments verschoben), plus eins. Hier zählt N alle Dokumente und n(tᵢ) diejenigen, die den Begriff enthalten.
Drei Intuitionen erklären, warum BM25 sich gut verhält. Die Termhäufigkeit sättigt sich, sodass das Zehnmal Nennen von BM25 nicht zehnmal so viele Punkte einbringt wie ein einziges Nennen, und k₁ prägt diese Kurve. Die Längennormalisierung verhindert, dass Dokumente wegen einer niedrigen Rohanzahl bestraft werden, wobei b durch die durchschnittliche Länge skaliert wird. Zudem bevorzugt die umgekehrte Dokumenthäufigkeit seltene Begriffe: „BM25“ in einem Korpus allgemeiner Machine-Learning-Texte hat ein hohes Gewicht, während „the“ fast keines hat.
All das macht BM25 hervorragend für Abfragen mit exakter Übereinstimmung, seltenen Begriffen oder vielen Schlüsselwörtern – ein Bereich, in dem dichte Embeddings ins Stolpern geraten.
pgvector und dichte Suche
pgvector ist eine Erweiterung für PostgreSQL, die Embeddings speichert und eine annähernde Suche nach dem nächsten Nachbarn über HNSW-Graphen oder IVFFlat-Indizes ermöglicht. Die Ähnlichkeit zwischen einem Abfragevektor und einem Dokumentvektor wird durch den Kosinus berechnet:
cosine_sim(q, dᵢ) = (q · dᵢ) / (‖q‖ · ‖dᵢ‖)
HNSW-Abfragen benötigen in der Regel eine logarithmische Laufzeit, wobei der Speicherverbrauch proportional zu N mal M ist, wobei M die Anzahl der bidirektionalen Verbindungen pro Knoten darstellt. Dadurch wird die Suche bei Millionen von Vektoren in deutlich unter einem Millisekunde abgeschlossen. Die dichte Suche eignet sich hervorragend für semantische Abgleiche, wie z. B. Paraphrasen, sprachliche Variationen und ähnlichkeit auf Konzeptebene. Aus dem oben genannten Grund werden exakte Zeichenketten unterindiziert.
Verbindung beider Methoden mittels Reciprocal Rank Fusion
Es existieren zwei gerankte Listen, eine aus BM25 und eine aus pgvector. Reciprocal Rank Fusion kombiniert sie, indem jedem Dokument eine Bewertung auf der Grundlage seiner Position in jeder Liste zugewiesen wird:
RRF(d) = Σᵢ 1 / (k + rankᵢ(d))
Der Konstante k beträgt 60. Sie mildert die Wirkung sehr hoher Ranglisten und hat sich in vielen Aufgaben bewährt. Die Summe bezieht sich auf beide Suchalgorithmen.
Warum RRF gegenüber einem gelernten Kombinierer bevorzugen? Es werden keine beschrifteten Relevanzdaten benötigt. RRF arbeitet mit Rängen und nicht mit Scores, wodurch es der Diskrepanz zwischen den unbegrenzten BM25-Werten und den zwischen -1 und 1 liegenden Kosinuswerten ausweicht. Zudem zeigten Cormack und Kollegen im Jahr 2009, dass RRF ohne Anpassung mit einer gewichteten linearen Kombination gleichzieht oder diese sogar übertrifft. Eine naive Mischung wie α · bm25_score + β · cosine_score ist unsicherer, da die Rohwerte auf inkompatiblen Skalen liegen.
Beweise aus Benchmarks
Im BEIR-Benchmark, einem gemischten Satz an Datensätzen aus den Bereichen Biomedizin, Nachrichten und Technik, bei dem BM25 mit einem dichten Suchmodell kombiniert wird, übertrifft diese Kombination in der Regel jede einzelne Methode für sich. TREC-COVID ist ein anschauliches Beispiel: Dort schneidet BM25 besser ab als das dichte Modell, da biomedizinische Abfragen wie „SARS-CoV-2 Spike-Protein ACE2-Bindung“ von hochspezifischen Begriffen geprägt sind, die durch Embeddings verfälscht werden. Das hybride Verfahren nutzt die Stärken beider Ansätze.
Python-Implementierung
Einrichtung
Alles befindet sich in einem einzigen Postgres-Schema. Installieren Sie zunächst die Abhängigkeiten:
# requirements: psycopg2, pgvector, rank-bm25, openai, numpy
Dann richten Sie die Verbindung, den Vekortyp sowie die Bibliotheken ein:
import psycopg2
from pgvector.psycopg2 import register_vector
from rank_bm25 import BM25Okapi
import openai
import numpy as np
from typing import List, Tuple# ── DB setup ──────────────────────────────────────────────────────────────
conn = psycopg2.connect("postgresql://user:pass@localhost/ragdb")
register_vector(conn)with conn.cursor() as cur:
cur.execute("CREATE EXTENSION IF NOT EXISTS vector;")
cur.execute("""
CREATE TABLE IF NOT EXISTS documents (
id SERIAL PRIMARY KEY,
content TEXT NOT NULL,
embedding vector(1536) -- text-embedding-3-small dim
);
""")
# HNSW index: m=16 (edges/node), ef_construction=64 (build-time beam width)
cur.execute("""
CREATE INDEX IF NOT EXISTS doc_hnsw_idx
ON documents USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
""")
conn.commit()
Indizierung
Ein Hilfsprogramm umhüllt den Aufruf der Embedding-API:
def embed(texts: List[str]) -> List[List[float]]:
resp = openai.embeddings.create(
model="text-embedding-3-small",
input=texts
)
return [r.embedding for r in resp.data]
Und die Indexierungsfunktion speichert jedes Dokument zusammen mit seiner Embedding-Darstellung:
def index_documents(docs: List[str]) -> None:
embeddings = embed(docs)
with conn.cursor() as cur:
for doc, emb in zip(docs, embeddings):
cur.execute(
"INSERT INTO documents (content, embedding) VALUES (%s, %s)",
(doc, emb)
)
conn.commit()
Hybride Suche
Die lexikalische Suche ordnet das Korpus mit BM25Okapi:
def bm25_search(
corpus: List[str],
query: str,
top_k: int = 20
) -> List[Tuple[int, float]]:
"""Returns [(doc_idx, bm25_score), ...] sorted descending."""
tokenized = [doc.lower().split() for doc in corpus]
bm25 = BM25Okapi(tokenized, k1=1.5, b=0.75)
scores = bm25.get_scores(query.lower().split())
ranked = sorted(enumerate(scores), key=lambda x: x[1], reverse=True)
return ranked[:top_k]
Die dichten Suchanfragen von pgvector sowie der Fusionsschritt wenden anschließend RRF an:
def dense_search(
query: str,
top_k: int = 20
) -> List[Tuple[int, float]]:
"""Returns [(doc_id, cosine_sim), ...] sorted descending."""
q_emb = embed([query])[0]
with conn.cursor() as cur:
cur.execute("""
SELECT id, 1 - (embedding <=> %s::vector) AS cosine_sim
FROM documents
ORDER BY embedding <=> %s::vector
LIMIT %s;
""", (q_emb, q_emb, top_k))
return [(row[0], row[1]) for row in cur.fetchall()]
def reciprocal_rank_fusion(
*ranked_lists: List[Tuple[int, float]],
k: int = 60
) -> List[Tuple[int, float]]:
"""
RRF(d) = Σᵢ 1 / (k + rankᵢ(d))
k=60 is the standard constant from Cormack et al. 2009.
"""
scores: dict[int, float] = {}
for ranked in ranked_lists:
for rank, (doc_id, _) in enumerate(ranked, start=1):
scores[doc_id] = scores.get(doc_id, 0.0) + 1.0 / (k + rank)
return sorted(scores.items(), key=lambda x: x[1], reverse=True)
def hybrid_retrieve(
corpus: List[str],
doc_ids: List[int], # DB IDs aligned with corpus
query: str,
top_k: int = 5
) -> List[dict]:
"""
Full hybrid pipeline:
1. BM25 sparse search
2. pgvector dense ANN search
3. RRF fusion
4. Return top-K merged results
"""
bm25_results = bm25_search(corpus, query, top_k=20)
# Map corpus index → DB id for BM25
bm25_db = [(doc_ids[idx], score) for idx, score in bm25_results] dense_results = dense_search(query, top_k=20) fused = reciprocal_rank_fusion(bm25_db, dense_results, k=60) # Fetch content for top-K
top_ids = [doc_id for doc_id, _ in fused[:top_k]]
with conn.cursor() as cur:
cur.execute(
"SELECT id, content FROM documents WHERE id = ANY(%s)",
(top_ids,)
)
rows = {row[0]: row[1] for row in cur.fetchall()} return [
{"id": doc_id, "rrf_score": score, "content": rows.get(doc_id, "")}
for doc_id, score in fused[:top_k]
]
Antwortgenerierung
In der letzten Phase werden die besten Ergebnisse abgerufen und der Kontext erstellt:
def rag_answer(query: str, corpus: List[str], doc_ids: List[int]) -> str:
results = hybrid_retrieve(corpus, doc_ids, query, top_k=5)
context = "\n\n---\n\n".join(r["content"] for r in results)
Eine restriktive Anweisung hält das Modell bei dem, was abgerufen wurde:
prompt = f"""You are a precise technical assistant.
Use only the provided context to answer the question.
If the context doesn't contain the answer, say so.Context:
{context}Question: {query}
Answer:""" resp = openai.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}],
temperature=0
)
return resp.choices[0].message.content
Parameter, die angepasst werden sollten
Bei BM25 liegt der Standardwert für k₁ bei 1,5 – ein höherer Wert verleiht wiederholten Begriffen mehr Gewicht, was sich bei ausführlichen Abfragen eignet. Der Standardwert für b beträgt 0,75, und eine Erhöhung verstärkt die Strafe für längere Dokumente. Bei HNSW liegt der Standardwert für m bei 16, da mehr Kanten zu einer besseren Trefferquote führen, allerdings auf Kosten des Speicherverbrauchs; ef_construction hat standardmäßig den Wert 64 – ein höherer Wert verbessert die Qualität des Index, verlangsamt aber dessen Erstellung. Der RRF-Wert k von 60 kann gesenkt werden, wenn das am höchsten bewertete Ergebnis stärker dominieren soll. 20 Kandidaten pro Suchmechanismus sind ein guter Standardwert, und insgesamt mehr Kandidaten verbessern in der Regel die Fusion der Ergebnisse.
In domänenspezifischen Korpora wie im medizinischen, juristischen oder kodierten Bereich sollte b auf 0,5 gesenkt werden, um die Strafe für lange technische Dokumente zu verringern, und k₁ auf 2,0 erhöht werden, damit wiederholte technische Begriffe belohnt werden.
Die richtige Suchmaschine auswählen
Genaue Schlüsselwörter, Produktnummern und API-Bezeichnungen bevorzugen BM25. Konzeptionelle, umformulierte oder mehrsprachige Abfragen bevorzugen die dichte Suche. Die meisten tatsächlichen Abfragen sind eine Mischung aus beidem, wodurch die hybride Variante mit RRF die beste Wahl ist. Fachjargon aus Medizin, Recht oder Programmierung funktioniert am besten mit BM25 oder der hybriden Variante.
Fazit
Naives RAG liefert eine solide Grundlage, vernachlässigt jedoch bei abfragenden Anfragen mit vielen Schlüsselwörtern oder spezialisierter Thematik die Vollständigkeit. Die Verbesserung ist in der Architektur einfach: Führen Sie BM25 auf demselben Korpus neben der pgvector-Suche durch, verschmelzen Sie die beiden gerankten Listen mithilfe von RRF bei k=60 und senden Sie die zusammengeführten Top-K-Einträge an den LLM. Der resultierende Suchmechanismus bewältigt gleichermaßen semantische Fragen wie „Was ist maschinelles Lernen?“ sowie lexikalische Fragen wie „Zeigen Sie mir die Handhabung des BM25Okapi k1-Parameters“, ohne dass ein zusätzliches Modell trainiert werden muss und lediglich eine mikrosekundenkurze Zusatzverarbeitung für BM25 erforderlich ist.
pgvector ist bereits in Postgres enthalten, BM25 wird durch eine Installation von rank-bm25 verfügbar, und RRF benötigt nur wenige Zeilen Code. Es gibt kaum Hindernisse, um eine hybride Suche in ein produktives RAG-System einzufügen.
Verwandte Literatur
- Semantische Suche in PostgreSQL mit pgvector und .NET: Eine praktische Einrichtung — Speichern Sie Embeddings neben relationalen Daten, erstellen Sie HNSW- oder IVFFlat-Indizes, filtern und mischen Sie hybride Ranglisten sowie beurteilen Sie, wann pgvector für Ihre Anwendung ausreicht.
- GraphRAG gegen Vector RAG: Warum die Vektor-Suche in großem Maßstab versagt — Vector RAG hat Schwierigkeiten mit der Trennung von Datenblöcken, dem abstrakten Denken über mehrere Dokumente sowie mit der Skalierbarkeit. Erfahren Sie, wie GraphRAG Communities und Zusammenfassungen erstellt, um dieses Problem zu lösen, und wann Sie welche Methode wählen sollten.