Ir al contenido principal
Español— Elegir un idioma
Menú

Recuperación y generación

Lección 13 de 18 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Del vector a la respuesta
  2. Construcción del prompt de RAG
  3. Generación de la respuesta
  4. Encapsulamiento del flujo en una clase
  5. Tres variantes de prompt según el caso de uso
  6. Puntos clave

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 RAGPipeline encapsula el flujo completo: recuperar, generar, preguntar
  • Gestiona los casos en los que el contexto carece de información suficiente