Prompting aumentado con recuperación
En esta página
Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI:
temperatureytop_psolo se aceptan con un esfuerzo de razonamiento denone, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificarreasoning={"effort": "none"}(API de Responses) oreasoning_effort="none"(Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.
Prompting aumentado con recuperación
El Prompting Aumentado con Recuperación (RAP, por sus siglas en inglés) combina la búsqueda de documentos con el prompting para proporcionar al modelo un contexto relevante y actualizado. Es la evolución natural del anclaje factual: en lugar de inyectar contexto manualmente, automatizas la búsqueda de pasajes relevantes antes de cada llamada al LLM.
La diferencia se hace evidente a escala. Pegar manualmente tres párrafos útiles de tu documentación funciona para una demostración; pero cuando tu base documental alcanza unas pocas cientos de páginas y las preguntas llegan de forma continua, nadie sabe ya qué pasajes pegar. RAP delega esta elección en un componente automático, invocado antes de cada generación, cuya única función es encontrar qué incluir en el prompt.
Arquitectura de un sistema RAP
Una canalización RAP se divide en tres pasos que operan a distintas velocidades y costes. La indexación transforma tus documentos en incrustaciones vectoriales (embeddings); esto ocurre una sola vez, fuera de línea, convirtiendo cada documento en un vector numérico que codifica su significado, almacenado junto al texto original. La recuperación, por el contrario, se ejecuta en cada pregunta: transformas la pregunta en un vector usando el mismo modelo de incrustación y luego buscas los vectores de documento más cercanos. Finalmente, el aumento es simplemente un prompting estándar: construyes un prompt de sistema que contiene los pasajes recuperados e instruyes al modelo para que no se salga de este ámbito.
Recuerda esta división: todo lo costoso ocurre durante la indexación, donde puedes permitirte ser exigente, mientras que todo lo que se repite para cada pregunta debe permanecer rápido. El siguiente código implementa los dos primeros pasos utilizando la similitud del coseno como medida de proximidad.
from openai import OpenAI
import numpy as np
client = OpenAI()
# Paso 1: Generar incrustaciones de documentos
def embed_texts(texts: list[str]) -> list[list[float]]:
"""Genera incrustaciones para una lista de textos."""
response = client.embeddings.create(
model="text-embedding-3-large",
input=texts
)
return [item.embedding for item in response.data]
# Paso 2: Búsqueda por similitud del coseno
def cosine_similarity(a: list[float], b: list[float]) -> float:
"""Calcula la similitud del coseno entre dos vectores."""
a, b = np.array(a), np.array(b)
return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))
def retrieve(query: str, documents: list[str],
doc_embeddings: list[list[float]],
top_k: int = 3) -> list[str]:
"""Devuelve los top_k documentos más relevantes."""
query_emb = embed_texts([query])[0]
scores = [
(i, cosine_similarity(query_emb, doc_emb))
for i, doc_emb in enumerate(doc_embeddings)
]
scores.sort(key=lambda x: x[1], reverse=True)
return [documents[i] for i, _ in scores[:top_k]]
Canalización completa
Ensamblar estos bloques de construcción da como resultado una clase que cabe en unas treinta líneas. La mayoría de las decisiones ocurren en el prompt de sistema generado, y vale la pena leerlo línea por línea. El modelo recibe primero la orden de responder SOLO basándose en los pasajes proporcionados, lo que limita las respuestas alucinadas cuando la documentación guarda silencio. A continuación, recibe la instrucción de citar el número de pasaje para cada afirmación, y esto es lo que hace posible la verificación: un revisor puede rastrear la fuente de un vistazo. Una temperature de 0,1 completa la configuración; en una respuesta anclada en documentos, la creatividad es un error.
class RAGPipeline:
"""Canalización RAP minimalista."""
def __init__(self, documents: list[str]):
self.documents = documents
self.embeddings = embed_texts(documents)
def query(self, question: str, top_k: int = 3) -> str:
"""Responde a una pregunta basándose en los documentos."""
# Recuperación
relevant_docs = retrieve(
question, self.documents,
self.embeddings, top_k
)
# Aumento del prompt
context = "\n\n---\n\n".join(
f"[Pasaje {i+1}]\n{doc}"
for i, doc in enumerate(relevant_docs)
)
system = f"""Eres un asistente técnico.
Responde SOLO basándote en los pasajes proporcionados.
Si los pasajes no contienen la respuesta, dilo.
Cita el número de pasaje para cada afirmación.
PASAJES RELEVANTES:
{context}"""
# Generación
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requiere effort none
instructions=system,
input=question,
temperature=0.1
)
return response.output_text
Fragmentación: división de documentos
Dividir los documentos en fragmentos (chunks) es crucial para la calidad de la recuperación. Si los fragmentos son demasiado grandes, ahogan la información relevante; si son demasiado pequeños, pierden contexto. Un manual de API dividido en bloques de diez páginas devolverá siempre el mismo bloque genérico, independientemente de la pregunta formulada. Dividido en frases aisladas, devolverá una frase que empieza con «este método» sin que el modelo sepa a qué método se refiere. La superposición mitiga específicamente este riesgo: cada fragmento repite el final del anterior, de modo que la información que atraviesa un límite permanece legible desde al menos un lado.
Cuando tus documentos tienen una estructura de encabezados, la fragmentación basada en secciones es casi siempre superior a la fragmentación de tamaño fijo: una sección de «Autenticación» permanece intacta, con su introducción y ejemplos.
def chunk_document(text: str, chunk_size: int = 500,
overlap: int = 50) -> list[str]:
"""Divide el texto en fragmentos con superposición."""
words = text.split()
chunks = []
for i in range(0, len(words), chunk_size - overlap):
chunk = " ".join(words[i:i + chunk_size])
if chunk.strip():
chunks.append(chunk)
return chunks
def chunk_by_sections(text: str) -> list[str]:
"""Divide por secciones (encabezados Markdown)."""
sections = []
current = []
for line in text.split("\n"):
if line.startswith("## ") and current:
sections.append("\n".join(current))
current = [line]
else:
current.append(line)
if current:
sections.append("\n".join(current))
return sections
Estrategias avanzadas de recuperación
Reordenación (Reranking)
Tras la recuperación inicial, utiliza el LLM para reordenar los resultados. La lógica es la de un embudo: la búsqueda vectorial es rápida pero aproximada, recuperando una docena de candidatos plausibles; el modelo, más lento pero más matizado, vuelve a leer estos candidatos conociendo la pregunta y los clasifica. Luego conservas solo la parte superior de la lista para la generación. La ganancia es más visible en preguntas donde varios pasajes hablan del mismo tema pero solo uno responde realmente: tres secciones mencionan la palabra «cuota», pero solo una explica cómo aumentarla.
def rerank(question: str, passages: list[str]) -> list[str]:
"""Reordena los pasajes por relevancia usando el LLM."""
prompt = f"""Pregunta: {question}
Aquí tienes pasajes candidatos. Ordénalos del más relevante
al menos relevante para responder a la pregunta.
Devuelve solo los números en orden (p. ej., 3, 1, 2).
{chr(10).join(f"[{i+1}] {p[:200]}" for i, p in enumerate(passages))}"""
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requiere effort none
input=prompt,
temperature=0.0
)
# Analizar el orden devuelto y reorganizar
return response.output_text
Incrustación de Documentos Hipotéticos (HyDE)
Genera un documento hipotético ideal y luego busca documentos similares. El problema que resuelve esta técnica es la discordancia de vocabulario: una pregunta formulada en lenguaje cotidiano no se parece, vectorialmente, a un párrafo de documentación técnica. Al pedir primero al modelo que escriba la respuesta que imagina, obtienes un texto escrito en el registro de tus documentos, y es este texto el que utilizas como consulta. No importa si el párrafo hipotético contiene aproximaciones: nunca sirve como respuesta, solo como sonda.
def hyde_retrieve(question: str, documents: list[str],
doc_embeddings: list[list[float]]) -> list[str]:
"""Recuperación mediante HyDE."""
# Generar un pasaje hipotético
hypo_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requiere effort none
input=f"Escribe un párrafo técnico breve que respondería perfectamente "
f"a esta pregunta: {question}",
temperature=0.5
)
hypothetical_doc = hypo_response.output_text
# Buscar documentos similares al pasaje hipotético
return retrieve(hypothetical_doc, documents,
doc_embeddings, top_k=3)
Uso de la búsqueda de archivos nativa de OpenAI
Para un despliegue rápido, la API ofrece recuperación integrada. Subes el archivo, creas un almacén vectorial, adjuntas el archivo a él y declaras la herramienta file_search en la llamada: la fragmentación, la incrustación y la búsqueda se gestionan en el servidor. Esta es la elección correcta cuando tus documentos son estándar y no te importa dónde residen los datos. La canalización propia mantiene la ventaja tan pronto como necesitas dominar la fragmentación, alojar el índice tú mismo o conectar una reordenación específica.
# Subir archivo
file = client.files.create(
file=open("documentation.pdf", "rb"),
purpose="assistants"
)
# Crear un almacén vectorial
vector_store = client.vector_stores.create(
name="Documentación técnica"
)
client.vector_stores.files.create(
vector_store_id=vector_store.id,
file_id=file.id
)
# Consulta con búsqueda de archivos
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Responde basándote en la documentación proporcionada.",
input="¿Cómo configuro la autenticación?",
tools=[{
"type": "file_search",
"vector_store_ids": [vector_store.id]
}]
)
Establecer una línea base
Toma de cinco a diez páginas de documentación técnica e implementa la canalización completa, desde la fragmentación hasta la generación. Escribe diez preguntas cuyas respuestas estén en los documentos, ejecuta la canalización en cada una y repite con la reordenación activada: es observando en qué preguntas cambia la clasificación como entenderás qué se le escapa a la búsqueda vectorial por sí sola. Termina midiendo el porcentaje de respuestas correctamente ancladas, aquellas donde cada afirmación se refiere efectivamente a un pasaje proporcionado. Esta cifra es tu punto de partida; todas las optimizaciones posteriores se juzgarán frente a ella, no frente a la impresión que dejan dos o tres respuestas leídas al azar.
Puntos clave
- RAP automatiza la inyección de contexto relevante en el prompt
- La fragmentación es crítica: experimenta con diferentes tamaños
- La reordenación con el LLM mejora significativamente la relevancia
- HyDE es útil cuando la pregunta difiere mucho del vocabulario de los documentos
- La búsqueda de archivos de OpenAI simplifica el despliegue para casos estándar