Recuperación y generación
En esta página
Del vector a la respuesta
Ya sabes cómo indexar documentos y recuperar los más cercanos a una pregunta. Solo falta un paso: convertir una lista de fragmentos en una respuesta legible. Esto implica inyectar el contexto recuperado en un prompt para que el LLM formule una respuesta basada en tus datos y no en los recuerdos de su entrenamiento. Solo hacen falta unas pocas líneas de código, pero marcan una diferencia decisiva en la calidad. Un contexto bien presentado y una instrucción clara importan tanto como la precisión de la recuperación.
Construcción del prompt de RAG
La estructura del prompt es sencilla, pero cada elección tiene consecuencias. Numera los fragmentos y anota su fuente para que el modelo pueda citar con precisión. Sepáralos con un delimitador visible, ---, para que el modelo no fusione dos documentos contradictorios en una única afirmación. Lo más importante: la instrucción debe restringir explícitamente la respuesta al contexto proporcionado y permitir que el modelo diga que no lo sabe. Sin ese permiso, un LLM al que se le pregunta sobre información faltante rellenará el hueco con lo que le parezca plausible. Ese es precisamente el mecanismo de la alucinación.
def build_rag_prompt(question, retrieved_chunks):
"""Construye el prompt de RAG con el contexto recuperado."""
# Formatea el contexto
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "fuente desconocida")
context_parts.append(f"[Documento {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""Eres un asistente experto. Responde a la pregunta usando
ÚNICAMENTE el contexto proporcionado a continuación. Si la información no está en el
contexto, dilo claramente.
## Contexto
{context}
## Pregunta
{question}
## Respuesta"""
return prompt
Generación de la respuesta
La llamada de generación es directa: un mensaje de sistema que reitera el rol y un mensaje de usuario que lleva el prompt ensamblado. Presta atención al parámetro temperature, establecido aquí en 0,1. En la escritura creativa buscas variedad; en RAG, buscas lo contrario. Quieres que el modelo se ciña lo máximo posible a lo que dice el contexto y que dos ejecuciones sobre la misma pregunta produzcan la misma respuesta. Una temperatura alta empujaría al modelo a reformular, extrapolar y desviarse de la fuente.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Genera una respuesta de RAG con Mistral."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "Eres un asistente preciso que responde basándose en el contexto proporcionado."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Temperatura baja para respuestas factuales
)
return response.choices[0].message.content
# Ejemplo
question = "¿Cuáles son los pasos principales de RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
Encapsulamiento del flujo en una clase
Las funciones dispersas sirven para la exploración, no para la puesta en producción. La clase RAGPipeline agrupa el estado —los fragmentos, la matriz de embeddings y el índice FAISS construido una sola vez en la instanciación— y tres operaciones: retrieve codifica la pregunta y consulta el índice, generate ensambla el prompt y llama al modelo, y ask encadena ambas. Fíjate en qué devuelve ask: no una cadena, sino un diccionario que contiene la respuesta, la lista de fuentes y el número de fragmentos utilizados. Esta trazabilidad es lo que separa un asistente auditable de una caja negra. El día que un usuario cuestione una respuesta, sabrás en qué pasajes se basó.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Pipeline completo de RAG con Mistral y FAISS."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Crear el índice FAISS
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""Paso 1: recuperar los fragmentos relevantes."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[question],
)
query_vector = np.array(
[response.data[0].embedding], dtype=np.float32
)
distances, indices = self.index.search(query_vector, k)
results = []
for dist, idx in zip(distances[0], indices[0]):
if idx >= 0:
results.append({
"text": self.chunks[idx]["text"],
"source": self.chunks[idx].get("source", ""),
"distance": float(dist),
})
return results
def generate(self, question, context_chunks):
"""Paso 2: generar la respuesta con contexto."""
prompt = build_rag_prompt(question, context_chunks)
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=3):
"""Pipeline completo: pregunta -> respuesta con fuentes."""
# Recuperación
context = self.retrieve(question, k=k)
# Generación
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Uso
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("¿Cómo funciona la indexación en FAISS?")
print(f"Pregunta: {result['question']}")
print(f"Respuesta: {result['answer']}")
print(f"Fuentes: {result['sources']}")
Tres variantes de prompt según el caso de uso
Puedes especializar el prompt base dependiendo de lo que esperes del asistente. Si tus usuarios deben verificar cada afirmación, pide explícitamente citas entre corchetes. El modelo adjuntará entonces cada frase a un documento numerado. Si la respuesta alimenta una interfaz o un informe, un formato estructurado impone secciones estables: una respuesta concisa, detalles, fuentes y un nivel de confianza que refleje cuán bien cubre el contexto la pregunta. La tercera variante desempeña un papel distinto: enseña al modelo a desglosar la incertidumbre distinguiendo lo que puede afirmar, lo que falta y dónde buscar a continuación. Esto suele producir los asistentes más útiles en la práctica, porque «me falta X» es mejor que una respuesta segura pero errónea.
# 1. Prompt con instrucción de citación
prompt_cite = """Responde citando los documentos fuente entre corchetes.
Ejemplo: "RAG mejora la precisión [Documento 1]."
Contexto: {context}
Pregunta: {question}"""
# 2. Prompt con formato estructurado
prompt_structured = """Responde en el siguiente formato:
**Respuesta**: [tu respuesta concisa]
**Detalles**: [explicación detallada]
**Fuentes**: [lista de documentos utilizados]
**Confianza**: [alta/media/baja según la cobertura del contexto]
Contexto: {context}
Pregunta: {question}"""
# 3. Prompt con gestión de información faltante
prompt_honest = """Si el contexto no contiene suficiente información para
responder completamente, indica claramente:
- Qué puedes afirmar con certeza
- Qué falta en el contexto
- Sugerencias para obtener la información faltante
Contexto: {context}
Pregunta: {question}"""
En cuanto a los parámetros de llamada, tres configuraciones gobiernan el comportamiento de RAG. Una temperatura baja fija la salida factual, max_tokens evita respuestas que derivan en ensayos y un top_p conservador restringe el vocabulario muestreado a las continuaciones más probables.
# Para RAG, usa una temperatura baja
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Factual, baja creatividad
max_tokens=1024, # Limitar la longitud de la respuesta
top_p=0.95, # Muestreo de núcleo conservador
)
Puntos clave
- El prompt de RAG inyecta el contexto recuperado antes de la pregunta
- Usa una temperatura baja (0,1–0,3) para respuestas factuales
- Pide al modelo que cite las fuentes para garantizar la trazabilidad
- La clase
RAGPipelineencapsula el flujo completo: recuperar, generar, preguntar - Gestiona los casos en los que el contexto carece de información suficiente