RAG explicado: Añade tus propios datos a aplicaciones LLM

Has creado un chatbot utilizando un LLM potente como GPT-4 o Claude, pero da respuestas genéricas y no conoce los documentos internos de tu empresa. ¿Cómo haces que responda preguntas sobre tus propios datos? El fine-tuning es caro y estático. La solución es Retrieval-Augmented Generation (RAG).

En este artículo, explicaremos RAG en términos prácticos, te mostraremos cómo implementarlo paso a paso y compartiremos las mejores prácticas para construir aplicaciones LLM fiables que aprovechen tus datos privados.

¿Qué es RAG?

RAG combina dos técnicas potentes: recuperación (encontrar información relevante en una base de conocimiento) y generación (usar un LLM para producir una respuesta). En lugar de depender únicamente del conocimiento preentrenado del LLM, RAG obtiene dinámicamente documentos relevantes y los incluye en el prompt, fundamentando la respuesta del modelo en tus datos.

Piensa en ello como un examen a libro abierto para la IA: puede buscar la respuesta en tus documentos antes de responder.

¿Por qué usar RAG?

• Información actualizada: Actualiza tu base de conocimiento sin reentrenar el modelo.
• Rentable: No necesitas fine-tuning costoso ni ventanas de contexto grandes.
• Precisión: Reduce las alucinaciones al fundamentar las respuestas en hechos recuperados.
• Privacidad: Tus datos permanecen en tu base de datos vectorial; solo se envían fragmentos relevantes al LLM.
• Flexibilidad: Funciona con cualquier LLM (OpenAI, Anthropic, modelos locales) y cualquier tipo de documento.

Cómo funciona RAG: Componentes principales

Un sistema RAG típico tiene cuatro partes principales:

1. Ingesta de documentos: Carga y preprocesa tus documentos (PDFs, páginas web, bases de datos).
2. Modelo de embedding: Convierte fragmentos de texto en vectores numéricos que capturan el significado semántico.
3. Base de datos vectorial: Almacena e indexa estos vectores para una búsqueda de similitud rápida.
4. LLM: Genera respuestas utilizando el contexto recuperado.

Paso a paso: Construyendo un pipeline RAG

1. Prepara tus documentos

Reúne tus fuentes de datos: PDFs, archivos Markdown, páginas de Confluence o tablas SQL. Limpia el texto (elimina encabezados, pies de página, texto repetitivo) y divídelo en fragmentos de 200 a 500 palabras con cierto solapamiento (por ejemplo, 50 palabras) para preservar el contexto.

Ejemplo usando Python:

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
chunks = text_splitter.split_text(your_document)

2. Genera embeddings

Utiliza un modelo de embedding como text-embedding-3-small de OpenAI o modelos de código abierto como all-MiniLM-L6-v2 para convertir cada fragmento en un vector.

from openai import OpenAI
client = OpenAI()

def get_embedding(text):
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

3. Almacena en una base de datos vectorial

Elige una base de datos vectorial: Pinecone, Weaviate, Qdrant o incluso PostgreSQL con pgvector. Almacena el embedding de cada fragmento junto con metadatos (fuente, número de página).

import pinecone
pinecone.init(api_key="YOUR_KEY", environment="us-west1-gcp")
index = pinecone.Index("rag-demo")

vectors = [(f"chunk-{i}", get_embedding(chunk), {"text": chunk}) for i, chunk in enumerate(chunks)]
index.upsert(vectors=vectors)

4. Recupera los fragmentos relevantes

Cuando un usuario hace una pregunta, convierte la consulta en embedding y busca los k fragmentos más similares.

query_embedding = get_embedding(user_question)
results = index.query(vector=query_embedding, top_k=3, include_metadata=True)
context = "\n\n".join([match.metadata["text"] for match in results.matches])

5. Genera la respuesta

Construye un prompt que incluya el contexto recuperado y pide al LLM que responda basándose en él.

prompt = f"""Answer the question based only on the following context:
{context}

Question: {user_question}
Answer:"""

response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}]
)
print(response.choices[0].message.content)

RAG vs Fine-Tuning

Mejores prácticas para RAG

• Divide sabiamente: Solapa los fragmentos para evitar cortar frases; considera la división semántica.
• Usa búsqueda híbrida: Combina búsqueda vectorial con búsqueda por palabras clave (BM25) para mejor recuperación.
• Reordena los resultados: Usa un cross-encoder para reordenar los fragmentos recuperados por relevancia.
• Cuida el prompt: Indica al LLM que cite fuentes y diga "No lo sé" si el contexto es insuficiente.
• Monitorea y evalúa: Registra consultas y respuestas; usa métricas como tasa de aciertos y relevancia de respuestas.

Errores comunes y cómo evitarlos

• Recuperación deficiente: Si los embeddings no capturan el significado específico del dominio, prueba ajustar el modelo de embedding o usar uno específico del dominio.
• Límites de longitud del contexto: No incluyas demasiados fragmentos; prioriza los mejores resultados y mantén los prompts concisos.
• Alucinaciones: Incluso con contexto, los LLM pueden inventar hechos. Usa prompts estrictos y considera un paso de verificación.
• Índice obsoleto: Configura un pipeline para volver a generar embeddings cuando los documentos cambien.

Preguntas frecuentes

¿Cuál es la diferencia entre RAG y fine-tuning?

RAG recupera información relevante en el momento de la inferencia y la incluye en el prompt, mientras que el fine-tuning ajusta los pesos del modelo para aprender nuevos patrones. RAG es mejor para conocimiento dinámico y factual; el fine-tuning es mejor para adaptación de estilo o dominio.

¿Necesito una base de datos vectorial para RAG?

No estrictamente: puedes usar cualquier índice de búsqueda (por ejemplo, Elasticsearch) o incluso similitud coseno en memoria para conjuntos de datos pequeños. Pero bases de datos vectoriales como Pinecone o Qdrant están optimizadas para búsqueda de similitud rápida y escalable.

¿Cómo evalúo un sistema RAG?

Mide la calidad de la recuperación (precisión@k, recall) y la calidad de la generación (relevancia de la respuesta, fidelidad). Herramientas como Ragas o TruLens pueden ayudar a automatizar la evaluación.

Conclusión

RAG es una forma práctica y rentable de añadir tus propios datos a aplicaciones LLM. Siguiendo los pasos anteriores y adhiriéndote a las mejores prácticas, puedes construir asistentes de IA que respondan preguntas con precisión utilizando tu base de conocimiento privada. Empieza poco a poco, itera y evalúa siempre.

Al preparar documentos para tu pipeline RAG, a menudo necesitarás combinar varios PDFs en un solo archivo para facilitar la ingesta. Usa nuestro PDF Merger gratuito para combinar PDFs de forma rápida y segura.