Por qué RAG sigue dando respuestas incorrectas: Búsqueda híbrida, reclasificación y Recall@K
Los fragmentos limpios no garantizan respuestas correctas. Vea dónde falla la recuperación de vectores y cómo la fusión, un reclasificador de codificador cruzado, HyDE y la medición Recall@K lo solucionan.
Fuentes: The AI Series: The Hardest Part of RAG, Part 2 — Why Perfect Chunks Still Give You Bad Retrieval
Un patrón común en los proyectos RAG: el trabajo de análisis ya está terminado. Los fragmentos están limpios, las tablas se generan en formato Markdown, y cada fragmento incluye un número de página y un título de sección. Sin embargo, los usuarios en entornos de producción siguen recibiendo respuestas incorrectas a preguntas que el sistema debería resolver sin dificultad. Los fragmentos no son el problema; el sistema de recuperación simplemente sigue obteniendo los incorrectos.
Un buen análisis genera datos de calidad, pero los datos buenos no garantizan una buena recuperación. Se trata de problemas separados, y al segundo se le presta mucho menos atención de la que merece.
Qué hace realmente la búsqueda de similitud
Muchos equipos tratan similarity_search() como una caja negra, por lo que echar un vistazo rápido al interior ayuda. Un modelo de embedding convierte el texto en una lista de números, un vector, que es un punto en un espacio con entre 384 y 3072 dimensiones según el modelo. Los textos con significados similares deben quedar cerca unos de otros, mientras que los textos no relacionados quedan muy separados.
Una versión simplificada con solo 4 dimensiones permite que los números sean fáciles de leer:
"How do I reset my password?" → [0.81, 0.12, -0.44, 0.09]
"Steps to change your password" → [0.79, 0.15, -0.41, 0.11]
"How do I cancel my subscription?"→ [0.22, 0.68, 0.05, -0.39]
Se comparan dos vectores mediante la similitud coseno, la cual mide cuán cerca apuntan en la misma dirección, ignorando su longitud. Una puntuación de 1.0 indica la misma dirección, 0 significa que no están relacionados y los valores negativos indican direcciones opuestas.
from numpy import dot
from numpy.linalg import norm
def cosine_similarity(a, b):
return dot(a, b) / (norm(a) * norm(b))
query = [0.80, 0.13, -0.42, 0.10] # "reset my password"
print(cosine_similarity(query, [0.81, 0.12, -0.44, 0.09])) # 0.998 - very close
print(cosine_similarity(query, [0.22, 0.68, 0.05, -0.39])) # 0.310 - far apart
Detrás de la frase “La IA entiende la pregunta” no hay nada más que eso. Se trata de geometría y no de comprensión, y la geometría explica los fallos: no puede darse cuenta de que “no permitido” invierte el significado de “permitido”, ni de que “Error 4092” es una cadena literal que el usuario necesita que se coincida.
Cuatro formas en que falla la recuperación
Reducir un párrafo a un solo punto hace que se pierda información. Una vez que el sistema sale del ámbito de demostración, siguen apareciendo los mismos cuatro fallos.
- Desequilibrio léxico. Alguien busca un código de error o un ID de producto exacto; el modelo lo trata como un token ordinario y el fragmento que contiene esa cadena precisa no entra entre los 10 mejores resultados.
- Ceguera a la negación. Una política que establece que los reembolsos cesan después de un mes y una pregunta sobre cómo obtener un reembolso tras ese plazo comparten la mayor parte del vocabulario, por lo que pueden aparecer preocupantemente cerca el uno del otro aunque sus significados sean contradictorios.
- Aislamiento de bloques. La respuesta abarca dos bloques: un número en uno de ellos y la etiqueta que lo explica en el anterior, y el sistema de recuperación devuelve solo uno de ellos.
- Confusión por recencia. Un índice vectorial no tiene concepto de que un documento esté desactualizado, por lo que las versiones antiguas y nuevas de una misma política suelen obtener una puntuación de relevancia similar.
Una demostración con 20 documentos no revela ninguno de estos problemas. Estos solo surgen cuando el corpus contiene verdadera duplicación, superposición y ambigüedad, algo que caracteriza a cualquier sistema en producción.
Un pipeline en lugar de una sola llamada
Una sola llamada a un almacén de vectores no constituye un sistema de recuperación. Uno resistente cuenta con varias etapas:
Cada etapa existe porque la anterior por sí sola resulta insuficiente. Ese es el cambio mental más importante entre una demostración de RAG y su uso en producción: cada etapa corrige una debilidad específica en las fases anteriores, y ninguna de ellas es meramente decorativa.
Búsqueda híbrida con fusión de rangos
La búsqueda de vectores maneja mal las coincidencias exactas, mientras que la búsqueda por palabras clave (BM25) maneja mal las coincidencias conceptuales. En lugar de elegir solo uno de los métodos, se ejecutan ambos y se fusionan sus resultados.
La Fusión de Rangos Recíprocos es la forma más sencilla de combinar dos listas ordenadas cuando sus puntuaciones no están en una escala común. Una implementación típica se ve así:
from collections import defaultdict
def reciprocal_rank_fusion(result_lists, k=60):
scores = defaultdict(float)
for result_list in result_lists:
for rank, doc_id in enumerate(result_list):
scores[doc_id] += 1 / (k + rank + 1)
return sorted(scores, key=scores.get, reverse=True)
vector_ids = [d.metadata["chunk_id"] for d in vector_store.similarity_search(query, k=20)]
bm25_ids = [d.metadata["chunk_id"] for d in bm25_index.search(query, k=20)]
final_ranking = reciprocal_rank_fusion([vector_ids, bm25_ids])
Un error común al principio es concatenar las dos listas de resultados sin fusionarlas. La lista que se presenta primero domina silenciosamente el contexto final, lo cual anula el propósito de utilizar dos estrategias.
Reclasificación
La etapa más difícil en el análisis de texto es la extracción de tablas, mientras que en la recuperación de información lo es la reclasificación. Los modelos de embedding codifican de forma independiente una consulta y cada documento, comparando los resultados posteriormente. Un reclasificador, normalmente un cross-encoder, lee conjuntamente la consulta y los fragmentos de documentos candidatos y genera directamente una puntuación de relevancia. Esto requiere más tiempo, por lo que solo se aplica a los 20 a 50 mejores candidatos después de la fusión, nunca a todo el índice.
from sentence_transformers import CrossEncoder
reranker = CrossEncoder("BAAI/bge-reranker-base")
def rerank(query, candidates, top_n=5):
pairs = [(query, c["text"]) for c in candidates]
scores = reranker.predict(pairs)
for c, s in zip(candidates, scores):
c["rerank_score"] = float(s)
return sorted(candidates, key=lambda c: c["rerank_score"], reverse=True)[:top_n]
En un sistema interno de búsqueda de soporte, la inserción de un reordenador después de la fusión elevó el Recall@5 de aproximadamente el 61 % al 84 %, sin modificar el modelo de embedding ni el tamaño de los fragmentos. Ese único cambio superó en efectividad al resto de los pasos del proceso combinados, lo que lo convierte en la primera sugerencia habitual cuando las respuestas de RAG parecen cercanas pero no del todo correctas.
Cerrando la brecha léxica
A veces el índice está en buen estado y el verdadero problema radica en la redacción. Los usuarios escriben de forma informal (“¿Por qué no me deja iniciar sesión?”), mientras que la documentación es formal (“Pueden producirse fallos de autenticación cuando caducan los tokens de sesión”).
Existen dos técnicas para abordarlo. La reescritura de consultas consiste en que un LLM reformule una pregunta vaga de manera más similar a la redacción del material de origen. HyDE (Hypothetical Document Embeddings) va un paso más allá: el LLM elabora una breve respuesta imaginaria, y ese texto, y no la pregunta original, es el que se incrusta y se busca, ya que una respuesta plausible se encuentra mucho más cerca de las respuestas reales en el espacio vectorial que la pregunta misma.
def hyde_retrieve(query, llm, vector_store, k=5):
hypothetical = llm.invoke(f"Write a short passage answering: {query}")
return vector_store.similarity_search(hypothetical, k=k)
Un sistema de tickets de soporte que adoptó este enfoque recuperó una parte significativa de las consultas que no habían devuelto información útil, simplemente porque los usuarios y la documentación utilizan dialectos diferentes.
Medir directamente la recuperación
Un atajo tentador es juzgar la recuperación según si la respuesta final del LLM suena correcta. Eso no revela casi nada sobre qué etapa falló.
Lo que se necesita es un pequeño conjunto etiquetado, incluso de 50 a 100 pares de consulta y fragmento correcto, para poder medir el Recall@K antes de que intervenga el LLM. El Recall@K pregunta: de los fragmentos que realmente contienen la respuesta, ¿cuántos terminaron entre los K primeros?
def recall_at_k(retrieved_ids, relevant_ids, k):
top_k = set(retrieved_ids[:k])
return len(top_k & relevant_ids) / len(relevant_ids) if relevant_ids else 0.0
Sin ello, cada cambio en el tamaño de los bloques, en el modelo de incrustación o en el reordenador de resultados es una suposición disfrazada de mejora.
Problemas comunes y una arquitectura sensata
Aumentar el valor de k rara vez soluciona problemas de recuperación deficiente, ya que principalmente proporciona al LLM más distracciones. Pasar la primera semana ajustando el tamaño de los bloques también es una mala inversión en comparación con los avances que ofrece un reordenador de resultados. Finalmente, construya el conjunto de evaluación antes de que surjan quejas, porque diagnosticar los problemas de recuperación posteriormente desperdicia todo un ciclo de trabajo.
Una arquitectura razonable para desarrollar esta capa desde cero: Qdrant para búsquedas vectoriales, BM25 a través de OpenSearch combinado con RRF, un reordenador de resultados BGE autohospedado con Cohere Rerank como opción alternativa hospedada, y HyDE reservado para tráfico de consultas conversacionales.
De dónde proviene realmente la calidad de las respuestas
Los debates suelen centrarse en qué LLM genera la respuesta final más fluida, pero el verdadero factor determinante se encuentra antes del modelo: ¿se recuperaron realmente los fragmentos adecuados? Un modelo brillante, ante un contexto incorrecto, produce siempre una respuesta brillante, segura, pero errónea.
El análisis sintáctico introduce los datos en el sistema, mientras que la recuperación determina si la parte correcta de esos datos llega al modelo. Cuando alguno de estos procesos falla, la ingeniería de prompts posteriores no puede salvar la respuesta. Una vez que existe una recuperación fiable, la pregunta siguiente es cómo verificar de forma automática, de extremo a extremo, que el sistema razona adecuadamente sobre lo que ha obtenido, en lugar de inspeccionar las salidas una por una.
Leer más
- RAG en tiempos de consulta con diez millones de documentos: embudos de recuperación, enrutadores, agentes y evaluaciones — Un embudo de recuperación en menos de 200 ms con filtros SQL, búsqueda híbrida y reclasificación, además de enrutamiento de consultas, orquestación de agentes, métricas de evaluación y un script de pipeline de Qdrant.
- Receta de Spring AI: Filtrado de resultados de RAG con metadatos por título del juego — Una guía paso a paso de Spring AI que etiqueta los documentos con un título, utiliza un LLM para seleccionar el valor adecuado a partir de la pregunta y filtra la búsqueda vectorial en función de él.