Reescritura de consultas y HyDE
Mejore la cobertura de recuperación.
Reescritura de consultas y HyDE es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 4 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.
La consulta es el eslabón débil
La calidad de la recuperación está limitada por la consulta. Las consultas sin procesar de los usuarios suelen ser breves, ambiguas, estar llenas de pronombres o estar formuladas de manera distinta a los documentos. La transformación de consultas modifica la consulta antes de la recuperación para aumentar la recuperación y la precisión.
Es una de las mejoras más económicas y con mayor impacto frente al RAG ingenuo: corrija la consulta y todas las etapas posteriores se beneficiarán.
def transform_query(raw, history):
# Resolve references, expand, decompose, or hypothesize
# BEFORE embedding and retrieving.
return rewrite(raw, history)Reescritura de consultas
La transformación más sencilla consiste en que un LLM reescriba la consulta del usuario con una forma más clara, autónoma y adecuada para la recuperación. Corrige errores tipográficos, amplía abreviaturas y elimina el ruido conversacional.
Esto es especialmente importante en conversaciones de varios turnos, donde el último mensaje resulta ininteligible sin contexto (¿Y qué ocurre con el segundo?).
def rewrite_query(raw):
prompt = (
'Rewrite the user question into a clear, standalone search '
'query optimized for document retrieval. Keep key entities.\n'
'Question: ' + raw
)
return llm(prompt, temperature=0).strip()Condensación conversacional
En un RAG conversacional, condense el diálogo y el nuevo turno en una única pregunta independiente. Sin este paso, los pronombres y las elipsis hacen que el embedding carezca de sentido y la recuperación se desmorone.
Proporcione los turnos anteriores para que el reescritor pueda resolver expresiones como esto, eso o el anterior y convertirlas en entidades explícitas que el recuperador pueda encontrar.
def condense(history, follow_up):
prompt = (
'Given the conversation, rewrite the follow-up as a standalone '
'question with all references resolved.\nConversation:\n' +
render(history) + '\nFollow-up: ' + follow_up
)
return llm(prompt, temperature=0).strip()Expansión de consultas
La expansión genera sinónimos, términos relacionados o formulaciones alternativas para ampliar la cobertura léxica y semántica. Combate la discordancia de vocabulario: el documento dice invalidate y el usuario dice revoke.
Expanda la consulta para la recuperación y recupere después usando la unión de resultados; no muestre la forma expandida al usuario. Tenga cuidado con la expansión excesiva, que puede atraer resultados fuera de tema.
def expand(query, n=3):
prompt = (
'List ' + str(n) + ' alternative phrasings of this query using '
'synonyms and domain terms, one per line.\n' + query
)
variants = parse_lines(llm(prompt, temperature=0.5))
return [query] + variantsRecuperación multi-query
Genere varias reformulaciones diversas, recupere resultados para cada una y fusione las listas de resultados (fusión de rangos recíprocos). Las distintas formulaciones hacen aflorar fragmentos relevantes diferentes; la fusión combina sus ventajas y estabiliza la recuperación.
Esto intercambia llamadas de recuperación adicionales por robustez frente a una formulación individual defectuosa.
def multi_query(raw, n=4):
queries = expand(raw, n)
rankings = [dense_retrieve(q, 30) for q in queries]
fused = rrf(*rankings)
return dedup(fused)Descomposición de consultas
Las preguntas complejas y de varios saltos requieren una descomposición en subpreguntas, cada una recuperada por separado, para después combinarlas. No se puede responder mediante una sola recuperación a una pregunta como «¿Qué director ejecutivo de la empresa que adquirió X es mayor que...?».
Descomponga la pregunta, recupere información para cada subpregunta y permita que el generador combine las evidencias recopiladas.
def decompose_and_retrieve(question):
subs = parse_lines(llm(
'Break this into independent sub-questions, one per line.\n' +
question, temperature=0))
evidence = {s: rerank(s, dense_retrieve(s, 30))[:3] for s in subs}
return evidence # generator synthesizes the final answerHyDE: la idea central
HyDE (Hypothetical Document Embeddings, Gao et al., 2022) invierte el planteamiento. En lugar de generar el embedding de la consulta breve, solicita al LLM que genere un documento de respuesta hipotético; después genera el embedding de ese documento y lo usa para recuperar información.
El documento hipotético utiliza el mismo registro que los documentos reales, por lo que su embedding queda más cerca de las respuestas auténticas y corrige la discordancia entre la consulta y el documento.
def hyde(query):
hypo = llm(
'Write a short passage that would answer this question, as if '
'from a reference document.\nQuestion: ' + query,
temperature=0.3)
return dense_retrieve_by_vector(embed(hypo), k=30) # embed the answerPor qué HyDE mejora la recuperación
Una pregunta y su respuesta están formuladas de manera diferente; una pregunta y una respuesta ficticia pero verosímil están formuladas de manera similar a la respuesta real. HyDE aprovecha el prior generativo del LLM para salvar esa distancia, aunque el contenido hipotético contenga errores factuales.
La corrección del contenido hipotético no importa demasiado: solo necesita el vocabulario y la estructura adecuados para quedar cerca de los documentos verdaderos en el espacio de embeddings.
# Robustness: average several hypothetical docs to reduce variance
def hyde_avg(query, n=3):
vecs = [embed(llm(HYDE_PROMPT + query, temperature=0.5))
for _ in range(n)]
centroid = sum(vecs) / n
return dense_retrieve_by_vector(centroid, 30)Ventajas, desventajas y fallos de HyDE
HyDE añade una generación del LLM antes de la recuperación, lo que incrementa la latencia y el coste, y puede alucinar un contenido hipotético que se desvíe del tema. Esto perjudica la recuperación en consultas específicas o fuera de la distribución de datos que el modelo no conoce.
Mitigue este problema combinando la recuperación mediante vectores de HyDE con la recuperación basada en la consulta original mediante fusión, de modo que una hipótesis defectuosa no pueda hundir por completo la recuperación.
def hyde_hybrid(query):
a = dense_retrieve_by_vector(embed(hyde_doc(query)), 30)
b = dense_retrieve(query, 30) # raw-query fallback
return dedup(rrf(a, b)) # robust to bad hypotheticalsElección y combinación de técnicas
Estas transformaciones son complementarias. Use la condensación para conversaciones, la expansión/multi-query para las carencias de vocabulario, la descomposición para preguntas de varios saltos y HyDE cuando haya una discordancia entre el registro de la pregunta y el del documento. Muchos stacks de producción encadenan la condensación, después HyDE, luego fusionan los resultados con la consulta original y finalmente aplican el reordenamiento.
Cada transformación añadida tiene el coste de una llamada al LLM, así que actívelas según el tipo de consulta en lugar de ejecutarlas siempre todas.
def route_transform(query, history, qtype):
q = condense(history, query) if history else query
if qtype == 'multi_hop': return decompose_and_retrieve(q)
if qtype == 'mismatch': return hyde_hybrid(q)
if qtype == 'vocab_gap': return multi_query(q)
return dense_retrieve(q, 30)Evaluación de transformaciones
Mida cada transformación según la mejora que aporte al recall@k de recuperación y a la precisión de la respuesta final frente a la consulta sin transformar, usando un conjunto sin fugas. Registre la latencia adicional y el coste del LLM para conservar únicamente las transformaciones que resulten rentables.
Tenga cuidado: una transformación que mejora el recall pero añade distractores puede reducir la precisión de la respuesta si no se combina con re-ranking y compresión.
def eval_transform(name, fn, eval_set):
return {
'recall@10': recall_at_k(eval_set, retriever=fn, k=10),
'answer_acc': answer_accuracy(eval_set, retriever=fn),
'extra_latency_ms': transform_latency(fn),
}Comprobación rápida
Reflexione sobre por qué HyDE funciona a pesar de las imperfecciones de las hipótesis.
Resumen
Conclusiones clave:
- La recuperación está limitada por la consulta; transformarla es una mejora de RAG económica y de gran impacto.
- La reescritura y la condensación convierten las consultas de chat en consultas independientes; la expansión y las consultas múltiples corrigen las carencias de vocabulario.
- La descomposición gestiona las preguntas de varios saltos mediante la recuperación para cada subpregunta.
- HyDE incorpora una respuesta hipotética para salvar la diferencia de registro entre la pregunta y el documento; no es necesario que la hipótesis sea correcta.
- Combine las transformaciones según el tipo de consulta, fusiónelas con la consulta original para obtener mayor solidez y evalúe el recall, la precisión de la respuesta, la latencia y el coste.
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 «Reescritura de consultas y HyDE» es gratis?
Sí — el texto completo de «Reescritura de consultas y HyDE» 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 «Reescritura de consultas y HyDE»?
Mejore la cobertura de recuperación. 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 4 de 4.
¿Cuánto tiempo toma la lección «Reescritura de consultas y HyDE»?
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