Más allá del RAG ingenuo
Conozca las limitaciones de la recuperación básica.
Más allá del RAG ingenuo es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.
Qué hace Naive RAG
Naive RAG es la línea base: dividir los documentos en chunks, generar sus embeddings, almacenar los vectores, generar el embedding de la consulta, recuperar los top-k por similitud coseno, insertar los chunks en el prompt y generar la respuesta. Es un punto de partida sólido, pero falla de formas previsibles a escala.
Comprender esos modos de fallo es un requisito previo para las técnicas avanzadas (re-ranking, compresión y reescritura de consultas) que se tratan en este curso.
def naive_rag(query, k=5):
q = embed(query)
chunks = vector_store.search(q, k) # top-k by cosine
context = '\n\n'.join(c.text for c in chunks)
return llm('Context:\n' + context + '\n\nQ: ' + query)Recall y precisión de la recuperación
El top-k ingenuo optimiza la similitud vectorial bruta, que confunde la relevancia con la cercanía semántica superficial. Se enfrenta a una tensión: un k pequeño puede hacer que no se encuentre la respuesta (bajo recall); un k grande inunda el contexto de elementos distractores (baja precisión).
La similitud de embeddings que dirige la recuperación es un indicador aproximado de la relevancia real y constituye la raíz de varios problemas posteriores.
# The core dilemma
# small k -> may miss the gold chunk (recall problem)
# large k -> distractors crowd context (precision + cost problem)
# Advanced RAG decouples 'retrieve many' from 'use few'El problema del desajuste de embeddings
Las consultas y los documentos suelen estar escritos en registros lingüísticos distintos: una pregunta breve frente a un pasaje declarativo extenso. Los embeddings de un bi-encoder pueden situar una respuesta relevante lejos de la pregunta porque están redactadas de forma diferente (el problema del desajuste de vocabulario).
Esto impulsa técnicas como la reescritura de consultas y HyDE, que transforman la consulta para que coincida con el espacio de documentos antes de la recuperación.
# Query: 'how do I revoke a token?'
# Doc: 'Token invalidation is performed via the /sessions endpoint.'
# Lexically and semantically distant -> bi-encoder may miss it
sim = cos(embed('how do I revoke a token?'),
embed('Token invalidation via /sessions')) # may be lowPerdido en el medio
Incluso cuando se recupera el chunk correcto, insertar muchos chunks provoca el efecto lost-in-the-middle: el modelo presta menos atención al contenido situado en el centro de un contexto largo. Un chunk correcto enterrado en la posición 3 de 10 puede ignorarse en la práctica.
Esto motiva el re-ranking (colocar el mejor chunk donde el modelo presta atención) y la compresión (reducir el contexto para que nada quede enterrado).
# Retrieval rank != attention rank
# Place the highest-relevance chunk at the START or END,
# never stranded in the middle of a large concatenation.Sensibilidad a los distractores
Los LLM son sensibles al contexto irrelevante. Añadir chunks plausibles pero incorrectos puede desviar la respuesta, incluso cuando el chunk correcto también está presente. Recuperar más contexto no siempre mejora el resultado.
Por eso la precisión es importante: un contexto reducido, reordenado mediante re-ranking y comprimido suele superar a un volcado grande de chunks vagamente relacionados.
# Empirically: appending a single highly-similar but WRONG chunk
# can flip a previously-correct answer. RAG quality depends on
# keeping distractors OUT, not just getting the gold chunk IN.Problemas del chunking
El chunking de tamaño fijo divide las ideas a mitad de una frase, separa una afirmación de sus pruebas y elimina el contexto estructural (de qué sección y de qué documento procede). Un chunk que se lee de forma coherente por sí solo puede resultar inútil o engañoso sin su contexto.
Las canalizaciones avanzadas utilizan chunking basado en la estructura, solapamiento, expansión al documento padre y metadatos para preservar el significado.
def structure_aware_chunks(doc, max_tokens=400, overlap=50):
sections = split_by_headings(doc) # respect document structure
chunks = []
for sec in sections:
for c in sliding_window(sec.text, max_tokens, overlap):
chunks.append(Chunk(c, meta={'section': sec.title}))
return chunksLimitaciones de la recuperación solo semántica
La recuperación densa pura no cubre bien las necesidades de coincidencia exacta: identificadores, códigos de error, nombres propios poco frecuentes y nombres de API. Precisamente en estos casos los usuarios esperan precisión literal. La recuperación híbrida combina señales densas (semánticas) y dispersas (BM25/palabras clave) para cubrir ambos tipos.
La fusión de rangos recíprocos es una forma sencilla y sólida de combinar las dos listas ordenadas sin ajustar un peso.
def rrf(dense_ranks, sparse_ranks, k0=60):
scores = {}
for ranks in (dense_ranks, sparse_ranks):
for rank, doc_id in enumerate(ranks):
scores[doc_id] = scores.get(doc_id, 0) + 1.0 / (k0 + rank)
return sorted(scores, key=scores.get, reverse=True)Contexto obsoleto y no verificable
Naive RAG no tiene noción de actualidad ni de procedencia. Puede recuperar documentos obsoletos y no ofrece una forma integrada de atribuir las afirmaciones a sus fuentes, lo que debilita la confianza y dificulta detectar alucinaciones.
Los sistemas avanzados adjuntan metadatos (marca de tiempo, fuente y versión), aplican filtros basados en ellos y exigen que el generador cite los ID de los chunks para que las respuestas se puedan verificar.
def filtered_retrieve(q, after_date):
cands = vector_store.search(embed(q), k=50)
fresh = [c for c in cands if c.meta['date'] >= after_date]
return fresh # then re-rank; generator must cite c.idSin retroalimentación, no hay adaptación
Naive RAG recupera información a ciegas: no puede detectar cuándo ha fallado la recuperación, no puede decidir que no se necesita recuperar información y no puede iterar. Los patrones avanzados añaden una comprobación de relevancia, recuperación condicional y recuperación de varios pasos (agéntica), que reformula la consulta cuando los resultados parecen débiles.
La canalización se convierte en un bucle con autoevaluación, en lugar de una única pasada hacia delante.
def adaptive_rag(q):
chunks = retrieve(q)
if relevance_score(q, chunks) < 0.4:
q2 = rewrite_query(q) # reformulate and retry
chunks = retrieve(q2)
if relevance_score(q, chunks) < 0.4:
return 'I could not find this in the sources.'
return generate(q, chunks)El stack avanzado de RAG
Al reunir los distintos fallos, una canalización avanzada combina: chunking basado en la estructura con metadatos, recuperación híbrida con alto recall, un re-ranker basado en cross-encoder para mejorar la precisión, compresión del contexto para que quepa y se enfoque, reescritura de consultas / HyDE para corregir el desajuste y una compuerta de relevancia con citas.
Las próximas lecciones desarrollan cada capa. La idea central es recuperar ampliamente y después filtrar y refinar de forma agresiva.
def advanced_rag(q):
cands = hybrid_retrieve(rewrite_query(q), k=50) # high recall
top = rerank(q, cands)[:8] # precision
ctx = compress(q, top) # focus + fit
return generate_with_citations(q, ctx) # verifiableMida antes de optimizar
Diagnostique qué fallo tiene realmente antes de añadir más mecanismos. Mida el recall@k de la recuperación (si el chunk de referencia se recupera) por separado de la precisión de la respuesta (si el generador lo utiliza). Un problema de recall y uno de precisión requieren soluciones diferentes.
Instrumente ambas partes; no añada un re-ranker cuando el problema real sea el chunking o el desajuste de la consulta.
def diagnose(eval_set):
return {
'recall@5': recall_at_k(eval_set, k=5), # retrieval health
'recall@50': recall_at_k(eval_set, k=50), # ceiling with rerank
'answer_acc': answer_accuracy(eval_set), # generation health
}Comprobación rápida
Diagnostique un modo de fallo de RAG.
Resumen
Conclusiones clave:
- Naive RAG (dividir en chunks, generar embeddings, aplicar top-k, insertar y generar) es una línea base sólida con fallos previsibles.
- La similitud del bi-encoder es un indicador aproximado de relevancia; el desajuste entre el registro de la consulta y el del documento perjudica el recall.
- Más contexto no es necesariamente mejor: la sensibilidad a los distractores y el efecto lost-in-the-middle degradan las respuestas a medida que aumenta k.
- Los problemas de chunking, las limitaciones de la recuperación solo semántica, la obsolescencia y la falta de retroalimentación limitan Naive RAG.
- El RAG avanzado recupera ampliamente y después filtra: recuperación híbrida, re-ranking, compresión, reescritura de consultas y compuertas de relevancia. Mida por separado el recall y la precisión de la respuesta antes de optimizar.
Aprende AI Prompt Engineering con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 53
- Lecciones
- 199
Preguntas frecuentes
¿La lección «Más allá del RAG ingenuo» es gratis?
Sí — el texto completo de «Más allá del RAG ingenuo» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.
¿Qué aprenderé en «Más allá del RAG ingenuo»?
Conozca las limitaciones de la recuperación básica. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Prompt Engineering?
No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Más allá del RAG ingenuo»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?
Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Más allá del RAG ingenuo
- Reordenación de fragmentos recuperados
- Compresión del contexto
- Reescritura de consultas y HyDE