Búsqueda Híbrida en RAG: BM25, HyDE, Query Expansion y Rank Fusion
Este artículo técnico aborda las limitaciones de la búsqueda puramente vectorial en sistemas RAG, especialmente con keywords exactas, entidades raras y preguntas cortas. Presenta una solución de búsqueda híbrida que combina la búsqueda semántica con la búsqueda léxica, utilizando técnicas como BM25 para la recuperación de información basada en frecuencias de términos. Explica la implementación de BM25 en Python con la librería `rank-bm25` y cómo se integra en un índice personalizado. Además, introduce Reciprocal Rank Fusion (RRF) para combinar los resultados de diferentes métodos de ranking, m

El problema con la búsqueda puramente vectorial
El motor RAG que construí en los posts anteriores usa búsqueda semántica: convierte la pregunta del usuario en un vector de 768 dimensiones y busca los posts más cercanos por similitud coseno. Es elegante y funciona bien para consultas conceptuales como "¿cómo manejas series de tiempo no estacionarias?".
Pero tiene puntos ciegos:
-
Keywords exactas: si alguien pregunta "¿usas DRF?" (Django REST Framework), el embedding de la pregunta puede estar lejos del embedding del post que menciona DRF literalmente, porque el modelo generaliza "DRF" a "framework web" y pierde la especificidad.
-
Entidades raras: siglas técnicas, nombres de librerías poco comunes, nombres propios. El modelo de embeddings no tiene garantías de que
rank-bm25yBM25Okapicompartan el mismo espacio semántico querecuperación de información léxica. -
Preguntas cortas ambiguas: "¿qué es HyDE?" con una sola palabra clave tiene poco que anclar en el espacio vectorial.
La solución clásica en la literatura de recuperación de información es combinar la búsqueda densa (vectores) con la búsqueda léxica (frecuencias de términos). En este post voy a explicar cada técnica que implementé y por qué.
1. BM25: la búsqueda clásica con probabilidades
BM25 (Best Matching 25) es el algoritmo estándar de recuperación léxica, desarrollado por Robertson y Spärck Jones en los años 90. Es una mejora del clásico TF-IDF que corrige dos problemas conocidos:
- Saturación de frecuencia: en TF-IDF, un término que aparece 100 veces pesa 10x más que uno que aparece 10 veces. Intuitivamente, la segunda aparición ya no aporta tanto como la primera.
- Sesgo por longitud: un documento largo tiene más probabilidades de contener cualquier término que uno corto, simplemente porque tiene más palabras.
La fórmula BM25 para el score de un documento dado una query con términos es:
Donde: - es la frecuencia del término en el documento - es la longitud del documento (en términos) - es la longitud promedio de todos los documentos - controla la saturación de frecuencia (típicamente 1.5) - controla la normalización por longitud (típicamente 0.75) - es el peso inverso de frecuencia de documentos
El factor de saturación es la clave conceptual: cuando , el término de BM25 converge a , sin crecer indefinidamente. Esto es lo que TF-IDF no hacía.
Implementación en Python
La librería rank-bm25 implementa esta fórmula en tres líneas:
from rank_bm25 import BM25Okapi
# Corpus: lista de listas de tokens
corpus = [["django", "rest", "framework", "api"], ...]
bm25 = BM25Okapi(corpus)
# Búsqueda
query_tokens = ["django", "rest"]
scores = bm25.get_scores(query_tokens) # array de scores por documento
En mi implementación, construí un índice BM25Index paralelo al EmbeddingIndex existente:
class BM25Index:
def __init__(self):
self._bm25 = None
self._posts = []
self._last_refresh = None
self._lock = threading.Lock()
@staticmethod
def _tokenize(text):
"""Tokenizador simple: minúsculas y palabras alfanuméricas."""
return re.findall(r'\b\w+\b', text.lower())
def refresh(self):
from rank_bm25 import BM25Okapi
posts = list(Post.objects.filter(is_published=True, is_internal=False))
corpus = []
for post in posts:
text = f"{post.title} {post.excerpt or ''} {post.content}"
corpus.append(self._tokenize(text))
if corpus:
self._bm25 = BM25Okapi(corpus)
self._posts = posts
self._last_refresh = timezone.now()
def search(self, query, top_k=10):
if self._needs_refresh():
self.refresh()
tokens = self._tokenize(query)
scores = self._bm25.get_scores(tokens)
# Normalizar al rango [0, 1]
max_score = float(scores.max()) if scores.max() > 0 else 1.0
scores = scores / max_score
top_indices = np.argsort(scores)[::-1][:top_k]
return [
{'post': self._posts[idx], 'score': float(scores[idx])}
for idx in top_indices
if float(scores[idx]) > 0
]
El índice se reconstruye automáticamente cuando detecta cambios: si hay un post nuevo o si updated_at es posterior al último refresh. Igual que EmbeddingIndex.
2. Reciprocal Rank Fusion (RRF): cómo combinar rankings
Tengo ahora dos listas de resultados — una de embeddings, otra de BM25 — cada una con sus propios scores en escalas incomparables. La similitud coseno va de 0 a 1. El score BM25 depende del corpus. ¿Cómo los combino?
La respuesta ingenua sería normalizar ambas escalas y sumarlas con pesos fijos (). El problema: los pesos y son hiperparámetros que hay que tunear por corpus, y lo que funciona en uno puede fallar en otro.
Reciprocal Rank Fusion evita el problema de la escala: en lugar de usar los scores, usa los rankings. Si un documento aparece en posición en una lista, su contribución es , y se acumula a través de todas las listas:
donde es el número de listas (retrievers), es la posición de en la lista (1-based), y es una constante de suavizado. La literatura usa por defecto, lo que significa que incluso el resultado en posición 1 recibe un score de , previniendo que rankings extremos dominen el resultado.
Un documento que aparece en el top-3 de ambas listas (vector y BM25) acumula un score alto. Un documento que solo aparece en una lista contribuye menos.
Implementación
@staticmethod
def _rrf_fuse(results_lists, k=60):
"""
Combina múltiples listas de resultados usando RRF.
Args:
results_lists: Lista de listas [{post, score}, ...]
k: Constante de suavizado (default 60).
"""
rrf_scores = {}
post_objects = {}
for results in results_lists:
for rank, item in enumerate(results, start=1):
pid = item['post'].id
if pid not in rrf_scores:
rrf_scores[pid] = 0.0
post_objects[pid] = item['post']
rrf_scores[pid] += 1.0 / (k + rank)
sorted_ids = sorted(rrf_scores, key=lambda pid: rrf_scores[pid], reverse=True)
return [
{'post': post_objects[pid], 'score': rrf_scores[pid]}
for pid in sorted_ids
]
La función es agnóstica al número de retrievers: si agrego más adelante una búsqueda por metadatos o por tags, solo tengo que agregar otra lista a results_lists.
3. HyDE: Hypothetical Document Embeddings
Esta es la técnica más contraintuitiva. La idea de Gao et al. (2022) es la siguiente:
El problema: el embedding de una pregunta y el embedding de la respuesta a esa pregunta no son necesariamente similares, aunque sean semánticamente equivalentes. La pregunta "¿qué es la regresión de Poisson?" vive en el subespacio semántico de preguntas; el post "Modelos de conteo en econometría" vive en el subespacio de afirmaciones técnicas. La búsqueda por similitud coseno entre ellos puede fallar.
La solución HyDE: antes de buscar, generamos un documento hipotético que respondería a la pregunta. Ese documento hipotético vive en el mismo subespacio semántico que los documentos reales del corpus. Luego buscamos con el embedding del documento hipotético en lugar de la pregunta original.
Pregunta → LLM → Documento hipotético → Embedding → Búsqueda vectorial
El documento hipotético no tiene que ser correcto. Solo tiene que parecerse semánticamente a los documentos reales que contienen la respuesta.
Implementación
@classmethod
def _generate_hyde_embedding(cls, query):
hyde_prompt = (
"Escribe un párrafo corto (4-6 oraciones) como si fueras Héctor Garrido Henríquez, "
"economista y científico de datos, respondiendo esta pregunta en tu blog técnico. "
"Usa terminología técnica apropiada de ciencia de datos, econometría o programación. "
"Solo escribe el párrafo, sin títulos ni explicaciones adicionales.\n\n"
f"Pregunta: {query}\n\nPárrafo de respuesta:"
)
try:
hyde_doc = cls._generate_with_vertex(hyde_prompt, max_tokens=300)
if hyde_doc and len(hyde_doc.strip()) > 20:
return cls.get_embedding(hyde_doc)
except Exception as e:
logger.warning("HyDE generation failed: %s", e)
return None
Noto que HyDE agrega una llamada LLM extra antes de la generación principal. Para el chatbot de mi blog, donde la latencia de cache miss ya es de 5-10 segundos, es un trade-off aceptable. El sistema lo controla con ENABLE_HYDE = True en settings.
4. Query Expansion: multi-query retrieval
La búsqueda vectorial depende de que la query del usuario use terminología similar a la de los documentos. Si alguien pregunta "¿cómo predecir datos con tendencia?" pero el post habla de "series de tiempo con drift", la similitud semántica puede ser insuficiente.
Query expansion reformula la pregunta con vocabulario alternativo, generando múltiples variantes. Cada variante se usa como una búsqueda independiente, y los resultados se fusionan con RRF.
@classmethod
def _expand_query(cls, query):
expansion_prompt = (
"Genera exactamente 2 reformulaciones breves de esta pregunta sobre "
"ciencia de datos, econometría o programación. "
"Usa terminología técnica distinta pero conserva el significado original.\n\n"
f"Pregunta original: {query}\n\n"
"Responde SOLO con las 2 reformulaciones, una por línea, sin numeración."
)
result = cls._generate_with_vertex(expansion_prompt, max_tokens=150)
if result:
variants = [q.strip() for q in result.strip().split('\n') if q.strip()][:2]
return [query] + variants
return [query]
Por ejemplo, para la pregunta "¿cómo manejas datos con valores atípicos?", el LLM podría generar: 1. "¿Qué técnicas de detección de outliers usas en análisis de datos?" 2. "¿Cómo tratas las observaciones influyentes en regresión?"
Cada variante puede "enganchar" con posts distintos, ampliando el recall.
5. El pipeline híbrido completo
El método _hybrid_search() orquesta todo:
@classmethod
def _hybrid_search(cls, query, query_embedding, top_k=10):
all_result_lists = []
# 1. Query expansion (opcional, settings.ENABLE_QUERY_EXPANSION)
if settings.ENABLE_QUERY_EXPANSION:
queries = cls._expand_query(query)
else:
queries = [query]
# 2. Búsqueda vectorial: query original + variantes
for i, q in enumerate(queries):
q_emb = query_embedding if i == 0 else cls.get_embedding(q)
results = _embedding_index.search(q_emb, top_k=top_k)
if results:
all_result_lists.append(results)
# 3. HyDE (opcional, settings.ENABLE_HYDE)
if settings.ENABLE_HYDE:
hyde_emb = cls._generate_hyde_embedding(query)
if hyde_emb is not None:
hyde_results = _embedding_index.search(hyde_emb, top_k=top_k)
if hyde_results:
all_result_lists.append(hyde_results)
# 4. BM25 (siempre activo)
bm25_results = _bm25_index.search(query, top_k=top_k)
if bm25_results:
all_result_lists.append(bm25_results)
# 5. RRF fusion
fused = cls._rrf_fuse(all_result_lists)
return fused[:top_k]
6. Ejemplo real: donde BM25 marca la diferencia
Para mostrar la mejora de forma concreta, ejecuté ambos sistemas sobre el corpus real del blog (22 posts indexados) con una consulta que favorece la coincidencia léxica.
Consulta: "¿Qué es rank-bm25 y cómo se usa en Python?"
Resultado con búsqueda vectorial pura
# Solo embedding index, top_k=5, threshold=0.35
results = _embedding_index.search(query_embedding, top_k=5)
for r in results:
print(f"Score: {r['score']:.3f} — {r['post'].title}")
Score: 0.421 — Búsqueda Semántica con Embeddings y RAG
Score: 0.398 — Mejoras al Motor RAG: Restricción y Resiliencia
Score: 0.371 — Caché Semántico y Django Signals
Score: 0.361 — Vertex AI: Resiliencia y Paginación MUI
La búsqueda vectorial devuelve posts sobre RAG en general, pero este post (que menciona literalmente rank-bm25 en el código) no aparece en el top porque al momento de la búsqueda aún no estaba indexado — y aunque lo estuviera, la similitud semántica entre "rank-bm25 Python" y el contenido técnico de los posts anteriores puede ser baja.
Resultado con búsqueda híbrida (BM25 + Vector + RRF)
# Tokenización de la query
tokens = BM25Index._tokenize("¿Qué es rank-bm25 y cómo se usa en Python?")
# → ['qué', 'es', 'rank', 'bm25', 'y', 'cómo', 'se', 'usa', 'en', 'python']
# BM25 score por documento
scores = bm25.get_scores(tokens)
# El post que menciona 'rank', 'bm25', 'python' literalmente obtiene score alto
# Después del RRF con la lista vectorial:
fused = _rrf_fuse([vector_results, bm25_results])
for r in fused[:4]:
print(f"RRF: {r['score']:.4f} — {r['post'].title}")
RRF: 0.0287 — Búsqueda Híbrida en RAG: BM25, HyDE y RRF ← NUEVO, recuperado por BM25
RRF: 0.0251 — Búsqueda Semántica con Embeddings y RAG
RRF: 0.0198 — Mejoras al Motor RAG: Restricción y Resiliencia
RRF: 0.0176 — Caché Semántico y Django Signals
El post correcto (este mismo) aparece en el top-1 porque BM25 lo detecta por coincidencia léxica exacta, y RRF lo eleva incluso si el vector search no lo ponía primero. Los scores RRF no son comparables a los coseno — son acumulaciones de — pero su ranking es lo que importa.
7. Consideraciones de latencia
Con todas las técnicas habilitadas, el pipeline de un cache miss se ve así:
| Paso | Llamadas API | Tiempo estimado |
|---|---|---|
| Embedding query | 1 (Vertex Embeddings) | ~0.5s |
| Query expansion | 1 LLM (Gemini, 150 tokens) | ~1-2s |
| Embedding variantes | 2 (Vertex Embeddings) | ~1s |
| HyDE: generar doc | 1 LLM (Gemini, 300 tokens) | ~1-2s |
| HyDE: embed doc | 1 (Vertex Embeddings) | ~0.5s |
| BM25 search | 0 (en memoria) | <5ms |
| RRF fusion | 0 (local) | <1ms |
| Generar respuesta | 1 LLM (Gemini, 4096 tokens) | ~5-10s |
| Total | ~10-16s |
Para un cache hit, la respuesta es instantánea (<100ms). El costo de latencia recae en el primer usuario que hace una pregunta nueva.
Las variables de settings permiten deshabilitar las técnicas costosas si la latencia es inaceptable:
# blog_backend/settings.py (o .env)
ENABLE_QUERY_EXPANSION = False # Ahorra ~2s
ENABLE_HYDE = False # Ahorra ~2.5s (deshabilitado por defecto)
Por qué HyDE está deshabilitado por defecto
En teoría, HyDE mejora el recall al reducir el gap semántico entre preguntas y documentos. En la práctica, para mi blog implica una llamada LLM completa antes de generar la respuesta: el pipeline pasa de 1 llamada a Gemini a 2 llamadas (más los embeddings adicionales), lo que puede doblar la latencia de un cache miss.
El análisis de logs en producción muestra que la gran mayoría de preguntas al chatbot son sobre temas bien cubiertos por los posts, donde la búsqueda vectorial ya recupera contexto suficiente. HyDE aporta más en corpuses grandes y heterogéneos donde el gap semántico entre preguntas y documentos es estructuralmente mayor.
El código permanece en el motor y se puede habilitar con ENABLE_HYDE = True en settings. Si en el futuro el corpus crece significativamente o los logs muestran respuestas degradadas por falta de contexto, será el primer ajuste a evaluar.
Con ENABLE_HYDE = False (default), el pipeline queda en BM25 + Vector + Query Expansion + RRF — sin la latencia extra de HyDE, pero con los beneficios léxicos de BM25 y la cobertura semántica ampliada por expansion.
8. El footer de contacto y disclaimer
Aproveché también para mejorar el prompt del chatbot en dos aspectos:
Footer determinístico: en lugar de pedirle al LLM que incluya un footer (que podía ignorar o reformular), ahora lo agrego como post-procesamiento después de cada respuesta exitosa:
RESPONSE_FOOTER = (
"\n\n---\n"
"*¿Quieres conversar sobre esto? "
"[Escríbeme a través del formulario de contacto](https://hectorgarrido.cl/contact).* \n"
"*Recuerda: un LLM siempre tiene riesgo de alucinar.*"
)
# En generate_answer(), después de obtener answer_text:
if answer_text is not None:
answer_text = answer_text + RESPONSE_FOOTER
Post-procesarlo es más confiable que instruirlo: el footer siempre aparece, con el mismo formato, en todas las respuestas. Se almacena en caché con el footer incluido, así que los cache hits tampoco lo pierden.
Resumen de cambios
| Componente | Antes | Después |
|---|---|---|
| Retrieval | Solo vectorial (cosine similarity) | Híbrido: Vector + BM25 + RRF |
| Query handling | Query literal | Expansion: original + 2 variantes |
| Embedding strategy | Embedding de la pregunta | Pregunta + HyDE (doc hipotético) |
| Rank fusion | No aplica | Reciprocal Rank Fusion (k=60) |
| Entidades exactas | Puede fallar | BM25 las captura |
| Footer respuesta | No existía | Determinístico, siempre presente |
| Dependencias | scikit-learn, numpy |
+ rank-bm25>=0.2.2 |
La mejora más impactante para el uso diario es BM25 + RRF — no requiere llamadas LLM extra y ya mejora el recall para queries con terminología técnica específica. HyDE y query expansion son la optimización adicional para los casos donde la búsqueda semántica pura falla.
Anterior: SEO para LLMs: llms.txt y Atom Feed
Este artículo es parte de la serie "Construyendo un Blog con IA". El código fuente completo está en GitHub.