BM25 Plus pgvector avec fusion de rangs réciproques : recherche hybride pour RAG en Python
Recherche hybride pour RAG en Python : pourquoi la récupération dense rate les termes exacts, comment BM25 et la recherche cosinus de pgvector se complètent, fusionnés avec RRF sur Postgres.
Sources: Why BM25 + pgvector Hybrid Search Beats Naive RAG — A Deep Technical Breakdown
Seuls les vecteurs denses manquent de mots-clés précis, de termes rares et de jargon sectoriel. La combinaison d’un classeur lexical et d’un index vectoriel comble cette lacune, et l’ensemble s’intègre dans une stack Python centrée sur Postgres. La mathématique, l’architecture et le code suivent.
Quels sont les problèmes avec le RAG classique
Un pipeline de récupération augmentée de base est simple :
- Incorporer la requête à l’aide d’un modèle tel que
text-embedding-3-small. - Effectuer une recherche cosinus contre un stockage vectoriel comme pgvector, Pinecone ou Weaviate.
- Prendre les fragments les plus pertinents (top-K).
- Les intégrer dans le prompt du LLM.
Cela fonctionne tant que la requête ne repose pas sur une chaîne de caractères littérale. Supposons qu’un utilisateur demande comment un projet utilise BM25 pour le classement. L’incorporation de la requête se situe près de vecteurs concernant le classement, les algorithmes de recherche et l’évaluation de la pertinence, de sorte qu’un document contenant le token littéral BM25 peut être devancé par une page plus vague traitant des modèles de récupération d’informations. C’est le problème du manque de correspondance du vocabulaire, connu des chercheurs en récupération d’informations depuis les années 1990.
Les incorporations compressent le sens dans un espace continu, et ce faisant, elles estompent les correspondances exactes. Une proximité entre « infarctus du myocarde » et « attaque cardiaque » est souhaitable. En revanche, une proximité entre BM25 et Okapi ranking constitue un inconvénient lorsque la requête est spécifique.
BM25 en bref
BM25, abréviation de Best Match 25, est une fonction de pondération des termes probabiliste issue de la famille de modèles de recherche Okapi. Pour un document d et une requête q, elle calcule la somme des termes de la requête :
score(q, d) = Σ IDF(tᵢ) · [f(tᵢ, d) · (k₁ + 1)] / [f(tᵢ, d) + k₁ · (1 - b + b · |d| / avgdl)]
Les symboles signifient ce qui suit :
tᵢreprésente un terme de la requête.f(tᵢ, d)indique la fréquence à laquelle ce terme apparaît dans le document.|d|est la longueur du document en tokens, tandis queavgdlreprésente la longueur moyenne dans l’ensemble des documents.k₁, généralement compris entre 1,2 et 2,0, détermine la vitesse à laquelle la fréquence des termes sature ; une valeur plus élevée accorde plus d’importance à la fréquence.b, compris entre 0 et 1, contrôle la normalisation de la longueur, 0 signifiant aucune normalisation et 1 signifiant une normalisation complète.IDF(tᵢ)est le logarithme du rapport entre les documents ne contenant pas le terme et ceux qui le contiennent (chaque groupe étant décalé d’un demi-document), majoré de un. Ici, N représente le nombre total de documents et n(tᵢ) représente le nombre de documents contenant le terme.
Trois intuitions expliquent pourquoi ce système se comporte bien. La fréquence des termes sature, de sorte que mentionner BM25 dix fois ne rapporte pas dix fois le score d’une seule mention, et k₁ façonne cette courbe. La normalisation de la longueur empêche que les documents ne soient pénalisés en raison d’un faible comptage brut, b assurant une mise à l’échelle en fonction de la longueur moyenne. De plus, la fréquence inverse des documents favorise les termes rares : « BM25 » dans un corpus de textes de apprentissage automatique général a un poids élevé, tandis que « the » n’en a presque aucun.
Tout cela rend BM25 excellent pour les requêtes de correspondance exacte, celles impliquant des termes rares ou de nombreux mots-clés, domaines où les embeddings denses échouent.
pgvector et la recherche dense
pgvector est une extension de PostgreSQL qui stocke des embeddings et permet une recherche d’adjacents les plus proches de manière approximative à l’aide de graphes HNSW ou d’index IVFFlat. La similarité entre un vecteur de requête et un vecteur de document est donnée par le cosinus :
cosine_sim(q, dᵢ) = (q · dᵢ) / (‖q‖ · ‖dᵢ‖)
Les requêtes HNSW prennent un temps approximativement logarithmique, avec une mémoire proportionnelle à N fois M, où M est le nombre de liens bidirectionnels conservés par nœud. Cela permet une récupération en bien moins d’un milliseconde même pour des millions de vecteurs. La recherche dense excelle dans la correspondance sémantique, telle que les paraphrases, les variations linguistiques et la similarité au niveau des concepts. Elle sous-indexe les chaînes de caractères exactes pour la raison mentionnée ci-dessus.
Fusion des deux méthodes par Reciprocal Rank Fusion
Il existe deux listes classées, l’une issue de BM25 et l’autre de pgvector. La Reciprocal Rank Fusion les combine en attribuant à chaque document un score en fonction de sa position dans chaque liste :
RRF(d) = Σᵢ 1 / (k + rankᵢ(d))
La constante k vaut 60. Elle atténue l’effet des rangs très élevés et s’est avérée efficace dans de nombreuses tâches. La somme prend en compte les deux méthodes de récupération.
Pourquoi privilégier RRF par rapport à une combinaison apprise ? Aucuns données de pertinence étiquetées ne sont nécessaires. Il fonctionne sur les rangs et non sur les scores, ce qui permet d’éviter le déséquilibre entre les valeurs BM25, qui ne sont pas bornées, et les valeurs cosinus, qui se situent entre -1 et 1. De plus, Cormack et ses collaborateurs ont montré en 2009 que RRF égale ou dépasse une combinaison linéaire pondérée sans nécessiter de réglage. Une combinaison naïve telle que α · bm25_score + β · cosine_score est moins fiable, car les valeurs brutes se situent sur des échelles incompatibles.
Études de cas
Sur le benchmark BEIR, un ensemble mixte couvrant des corpus biomédicaux, des actualités et des textes techniques, qui combine BM25 avec une récupération dense, a tendance à surpasser chacune des approches utilisées séparément. TREC-COVID est un exemple parlant : BM25 y performe mieux que le modèle dense, car les requêtes biomédicales telles que « SARS-CoV-2 spike protein ACE2 binding » contiennent de termes très spécifiques que les embeddings rendent flous. L’approche hybride conserve les forces des deux méthodes.
Implémentation en Python
Prérequis
Tout est stocké dans un seul schéma Postgres. Installez d’abord les dépendances :
# requirements: psycopg2, pgvector, rank-bm25, openai, numpy
Ensuite, configurez la connexion, le type de vecteur et les bibliothèques :
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()
Indexation
Un outil d’aide entoure l’appel de l’API d’embedding :
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]
Et la fonction d’indexation stocke chaque document avec son embedding :
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()
Récupération hybride
La recherche lexicale classe le corpus à l’aide de 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]
Les requêtes de recherche intensives pgvector et l’étape de fusion appliquent ensuite RRF :
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]
]
Génération de la réponse
La dernière étape récupère les meilleurs résultats et construit le contexte :
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)
Une instruction restrictive maintient le modèle ancré dans ce qui a été récupéré :
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
Paramètres à ajuster
Par défaut, la valeur de k₁ dans BM25 est de 1,5 : une valeur plus élevée accorde plus de poids aux termes répétés, ce qui convient aux requêtes longues. La valeur par défaut de b dans BM25 est de 0,75, et son augmentation renforce la pénalité liée à la longueur des documents. Pour HNSW, m vaut 16 par défaut, car davantage d’arêtes améliorent le taux de rappel au détriment de la mémoire, tandis que ef_construction vaut 64 par défaut : une valeur plus élevée améliore la qualité de l’index mais ralentit sa création. La valeur de k dans RRF, qui est de 60, peut être réduite si l’on souhaite que le résultat le mieux classé domine davantage. Un nombre de 20 candidats par moteur de recherche constitue une valeur par défaut judicieuse, et un plus grand nombre de candidats améliore généralement la fusion des résultats.
Dans les corpus axés sur des domaines spécifiques tels que la médecine, le droit ou le code, il convient de réduire b à 0,5 afin d’atténuer la pénalité appliquée aux longs documents techniques, et d’augmenter k₁ à 2,0 pour récompenser les termes techniques répétés.
Choisir le bon moteur de recherche
Les mots-clés exacts, les codes de produit et les noms d’API favorisent BM25. Les requêtes conceptuelles, paraphrasées ou multilingues privilégient la recherche dense. La plupart des requêtes réelles sont un mélange des deux, ce qui fait du système hybride avec RRF le meilleur choix, tandis que le jargon sectoriel en médecine, en droit ou en programmation fonctionne le mieux avec BM25 ou le système hybride.
En résumé
Le RAG naïf constitue une bonne base de référence, mais il néglige le taux de rappel pour les requêtes riches en mots-clés ou spécialisées. La correction est simple du point de vue architectural : appliquer BM25 sur le même corpus en parallèle de la recherche pgvector, fusionner les deux listes classées à l’aide de RRF avec k=60, puis envoyer les K meilleurs résultats fusionnés à l’LLM. Le système de récupération ainsi obtenu gère aussi bien une question sémantique comme « qu’est-ce que l’apprentissage automatique » qu’une question lexicale comme « montrez-moi le traitement du paramètre k1 de BM25Okapi », sans nécessiter d’entraînement supplémentaire de modèle et avec uniquement un traitement supplémentaire en microsecondes pour BM25.
pgvector est inclus dans Postgres, BM25 se installe via rank-bm25, et RRF ne nécessite que quelques lignes de code. Peu d’obstacles s’opposent à l’intégration d’une recherche hybride dans un système RAG en production.
Lectures complémentaires
- Recherche sémantique dans PostgreSQL avec pgvector et .NET : une configuration pratique — Stockez les embeddings à côté des données relationnelles, créez des index HNSW ou IVFFlat, filtrez et combinez des classements hybrides, et déterminez quand pgvector est suffisant pour votre application.
- GraphRAG vs Vector RAG : pourquoi la recherche vectorielle échoue à grande échelle — Vector RAG rencontre des difficultés avec l’isolation des blocs, le raisonnement entre documents et l’échelle. Découvrez comment GraphRAG crée des communautés et des résumés pour y remédier, ainsi que le moment de choisir l’un ou l’autre.