Canalización RAG completa
En esta página
Uniendo todas las piezas
Las lecciones anteriores han cubierto cada eslabón de la cadena por separado: carga, fragmentación, codificación, indexación, recuperación y generación. Ha llegado el momento de soldarlos en un único programa completo de extremo a extremo que puedes ejecutar tal cual y adaptar después a tus propios documentos. Este script cabe en un solo archivo y requiere únicamente cuatro dependencias.
pip install mistralai faiss-cpu numpy requests
La canalización completa
Dos decisiones de diseño estructuran este código. En primer lugar, agrupamos toda la configuración al principio del archivo: los modelos, el tamaño de fragmento, el tamaño de lote y TOP_K son constantes con nombre. Esto te evita tener que buscar valores hardcodeados enterrados dentro de funciones cuando necesites ajustar el comportamiento. En segundo lugar, dividimos la lógica en seis funciones independientes, cada una correspondiente a un paso e imprimiendo su progreso como [n/6]. Este rastro no es decorativo: cuando la canalización falla o devuelve una respuesta extraña, te indica de inmediato si el problema reside en la carga, la fragmentación o la recuperación. Cada función también es sustituible de forma aislada; puedes intercambiar un cargador de PDF por load_data sin tocar el resto.
La función main encadena los pasos y luego consulta el corpus con tres preguntas sobre el ensayo de Paul Graham utilizado como nuestro conjunto de datos de demostración. Observa que la recuperación y la generación se ejecutan dentro del bucle, mientras que la indexación ocurre solo una vez antes: volver a codificar todo el corpus para cada pregunta sería absurdo tanto en coste como en latencia.
import os
import json
import numpy as np
import faiss
import requests
from mistralai.client import Mistral
# ============================================================
# Configuración
# ============================================================
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
EMBED_MODEL = "mistral-embed"
CHAT_MODEL = "mistral-large-latest"
CHUNK_SIZE = 2048
BATCH_SIZE = 25
TOP_K = 3
client = Mistral(api_key=MISTRAL_API_KEY)
# ============================================================
# Paso 1: Cargar datos
# ============================================================
def load_data(url):
"""Carga un documento de texto desde una URL."""
print("[1/6] Cargando datos...")
response = requests.get(url)
response.raise_for_status()
text = response.text
print(f" -> {len(text)} caracteres cargados")
return text
# ============================================================
# Paso 2: Crear fragmentos
# ============================================================
def create_chunks(text, chunk_size=CHUNK_SIZE):
"""Divide el texto en fragmentos."""
print("[2/6] Creando fragmentos...")
chunks = []
paragraphs = text.split("\n\n")
current = ""
for para in paragraphs:
para = para.strip()
if not para:
continue
if len(current) + len(para) + 2 <= chunk_size:
current = current + "\n\n" + para if current else para
else:
if current:
chunks.append(current)
current = para
if current:
chunks.append(current)
print(f" -> {len(chunks)} fragmentos creados (tamaño medio: {sum(len(c) for c in chunks) // len(chunks)} caracteres)")
return chunks
# ============================================================
# Paso 3: Generar incrustaciones
# ============================================================
def create_embeddings(chunks, batch_size=BATCH_SIZE):
"""Codifica los fragmentos en incrustaciones mediante mistral-embed."""
print("[3/6] Generando incrustaciones...")
all_embeddings = []
for i in range(0, len(chunks), batch_size):
batch = chunks[i:i + batch_size]
response = client.embeddings.create(
model=EMBED_MODEL,
inputs=batch,
)
all_embeddings.extend([d.embedding for d in response.data])
print(f" -> Lote {i // batch_size + 1}/{(len(chunks) - 1) // batch_size + 1} codificado")
embeddings = np.array(all_embeddings, dtype=np.float32)
print(f" -> Matriz: {embeddings.shape}")
return embeddings
# ============================================================
# Paso 4: Crear índice FAISS
# ============================================================
def create_index(embeddings):
"""Crea y rellena un índice FAISS."""
print("[4/6] Creando índice FAISS...")
dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(embeddings)
print(f" -> Índice: {index.ntotal} vectores, dimensión {dimension}")
return index
# ============================================================
# Paso 5: Recuperar fragmentos relevantes
# ============================================================
def retrieve(question, index, chunks, k=TOP_K):
"""Recupera los fragmentos más relevantes."""
print(f"[5/6] Buscando: '{question[:50]}...'")
response = client.embeddings.create(
model=EMBED_MODEL,
inputs=[question],
)
query_vector = np.array([response.data[0].embedding], dtype=np.float32)
distances, indices = index.search(query_vector, k)
results = []
for dist, idx in zip(distances[0], indices[0]):
if idx >= 0:
results.append({
"text": chunks[idx],
"distance": float(dist),
})
print(f" -> {len(results)} fragmentos recuperados")
return results
# ============================================================
# Paso 6: Generar respuesta
# ============================================================
def generate(question, context_chunks):
"""Genera la respuesta utilizando el contexto recuperado."""
print("[6/6] Generando respuesta...")
context = "\n\n---\n\n".join([c["text"] for c in context_chunks])
prompt = f"""Contexto informativo:
{context}
---
Basándote ÚNICAMENTE en el contexto anterior, responde a la siguiente pregunta con precisión y completitud.
Pregunta: {question}"""
response = client.chat.complete(
model=CHAT_MODEL,
messages=[
{"role": "system", "content": "Eres un asistente que responde basándose en el contexto proporcionado."},
{"role": "user", "content": prompt},
],
temperature=0.1,
)
answer = response.choices[0].message.content
print(f" -> Respuesta generada ({len(answer)} caracteres)")
return answer
# ============================================================
# Canalización principal
# ============================================================
def main():
"""Ejecuta la canalización RAG completa."""
# 1. Cargar
url = "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt"
text = load_data(url)
# 2. Fragmentar
chunks = create_chunks(text)
# 3. Codificar
embeddings = create_embeddings(chunks)
# 4. Indexar
index = create_index(embeddings)
# 5+6. Pregunta -> Respuesta
questions = [
"What were the two main things the author worked on before college?",
"What did the author do during their time at Y Combinator?",
"What programming language did the author learn first?",
]
for question in questions:
print(f"\n{'='*60}")
context = retrieve(question, index, chunks)
answer = generate(question, context)
print(f"\nP: {question}")
print(f"R: {answer}")
if __name__ == "__main__":
main()
Ejecución de la canalización
Guarda este código como rag_pipeline.py, exporta tu clave de API en el entorno —nunca la hardcodees en el archivo, pues acabará en un repositorio— y ejecuta el script. La salida recorre los seis pasos y procesa después las tres preguntas con sus respuestas. Si alguna respuesta parece fuera de lugar, compárala con los fragmentos mostrados en el paso 5 antes de culpar al modelo de generación.
export MISTRAL_API_KEY="your-api-key"
python rag_pipeline.py
Cinco direcciones para mejorar aún más
Esta canalización es una base, no un producto terminado, y cada una de sus limitaciones señala un siguiente paso. La más inmediata es la persistencia: en su forma actual, el script vuelve a codificar todo el corpus en cada ejecución, whereas guardar el índice FAISS y los fragmentos haría que las ejecuciones posteriores fueran casi instantáneas. La reclasificación (re-ranking) es el siguiente nivel: pasar los resultados de FAISS por un codificador cruzado que juzgue la relevancia con mucha más fineza que la sola distancia vectorial. El filtrado por metadatos aborda otra necesidad: restringir la búsqueda por fecha, categoría o autor, además de por similitud. Dos mejoras finales se centran en la experiencia de usuario: la transmisión (streaming), que muestra la respuesta a medida que se genera en lugar de tras varios segundos de silencio, y el historial de conversación, que permite a los usuarios hacer seguimientos como «¿y qué hay de la versión 2?» sin tener que repetir toda su pregunta.
# 1. Guardar el índice para evitar recalcular
faiss.write_index(index, "my_rag.index")
np.save("my_chunks.npy", np.array(chunks, dtype=object))
# 2. Añadir reclasificación (re-ranking)
# Tras la recuperación con FAISS, usar un modelo de codificador cruzado
# para reordenar los resultados por relevancia detallada
# 3. Filtrado por metadatos
# Añadir filtros (fecha, categoría, autor) además
# de la similitud vectorial
# 4. Transmisión de respuestas (streaming)
# Usar client.chat.stream() para mostrar la respuesta
# a medida que se genera
# 5. Historial de conversación
# Añadir intercambios anteriores al prompt
# para un chatbot RAG contextual
Puntos clave
- La canalización RAG completa se divide en 6 pasos: cargar, fragmentar, codificar, indexar, recuperar, generar
- Cada paso es una función independiente, fácil de probar y sustituir
- Usa
temperature=0.1para respuestas factuales - Guarda el índice FAISS y las incrustaciones para evitar recalcular en cada ejecución
- Esta canalización es un punto de partida sólido para enriquecer según tus necesidades