Preparar los datos
En esta página
La calidad del RAG depende de tus datos
Una canalización RAG solo es tan buena como los datos que indexa. Puedes diseñar el prompt perfecto y seleccionar el mejor modelo de generación, pero si el fragmento recuperado corta una definición por la mitad o arrastra un pie de página repetitivo en lugar de texto útil, tu respuesta se resentirá. La preparación ocurre en tres etapas: obtener los datos donde residen, eliminar todo lo que carezca de significado y dividirlos en fragmentos optimizados para la indexación.
Obtención de los datos
Los corpus del mundo real rara vez son homogéneos. Normalmente tendrás documentación en Markdown en un repositorio, algunas páginas de un sitio web público y un puñado de PDF normativos. Cada fuente necesita su propio cargador, pero todos deben producir la misma estructura —contenido, fuente y tipo— para que el resto de la canalización sea agnóstica al origen del texto.
Para los archivos de texto, un recorrido recursivo del directorio es suficiente, y filtrar por extensión evita cargar accidentalmente archivos binarios.
import os
def load_text_files(directory, extensions=(".txt", ".md", ".rst")):
"""Cargar todos los archivos de texto de un directorio."""
documents = []
for root, dirs, files in os.walk(directory):
for f in files:
if any(f.endswith(ext) for ext in extensions):
filepath = os.path.join(root, f)
with open(filepath, "r", encoding="utf-8") as fh:
content = fh.read()
documents.append({
"content": content,
"source": filepath,
"type": "text",
})
return documents
docs = load_text_files("./data/")
print(f"{len(docs)} documents loaded")
Las páginas web llegan mediante HTTP, pero lo que obtienes es HTML. La extracción siguiente elimina las etiquetas usando expresiones regulares y colapsa los múltiples espacios. Esto es suficiente para un prototipo, pero el comentario te recuerda que, en producción, BeautifulSoup hará un trabajo mucho mejor con tablas y listas anidadas.
import requests
def fetch_web_page(url):
"""Obtener el contenido de texto de una página web."""
response = requests.get(url)
response.raise_for_status()
# Extracción básica de texto (usar BeautifulSoup para producción)
text = response.text
# Eliminar etiquetas HTML
import re
text = re.sub(r'<[^>]+>', ' ', text)
text = re.sub(r'\s+', ' ', text).strip()
return {
"content": text,
"source": url,
"type": "web",
}
# Ejemplo
page = fetch_web_page("https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt")
print(f"Content: {len(page['content'])} characters")
Los PDF merecen un tratamiento especial. En lugar de concatenar todo el documento, mantén una entrada por página y codifica el número de página en la fuente como file.pdf#page=12. Cuando tu asistente cite este pasaje, el usuario sabrá exactamente dónde verificarlo.
# pip install PyPDF2
from PyPDF2 import PdfReader
def load_pdf(filepath):
"""Extraer texto de un PDF."""
reader = PdfReader(filepath)
pages = []
for i, page in enumerate(reader.pages):
text = page.extract_text()
if text.strip():
pages.append({
"content": text,
"source": f"{filepath}#page={i+1}",
"type": "pdf",
"page": i + 1,
})
return pages
Limpieza de los datos
La limpieza es crítica para la calidad de la recuperación porque cada carácter extraño consume espacio en el fragmento y enturbia el vector resultante. La siguiente función encadena cuatro tratamientos: elimina los caracteres de control sobrantes de las conversiones de formato, normaliza las secuencias de saltos de línea y espacios, borra los marcadores de paginación típicos de los PDF y reemplaza las URLs interminables por un marcador de posición simple para que no se coman un fragmento entero.
import re
def clean_text(text):
"""Limpiar texto para indexación RAG."""
# Eliminar caracteres de control
text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)
# Normalizar espacios y saltos de línea
text = re.sub(r'\n{3,}', '\n\n', text)
text = re.sub(r' {2,}', ' ', text)
# Eliminar cabeceras/pies de página repetitivos (PDF)
text = re.sub(r'Page \d+ of \d+', '', text)
# Eliminar URLs muy largas
text = re.sub(r'https?://\S{100,}', '[URL]', text)
return text.strip()
# Aplicar limpieza
for doc in docs:
doc["content"] = clean_text(doc["content"])
Estrategias de fragmentación
La fragmentación es el paso más importante de la preparación: el tamaño del fragmento y el método impactan directamente en la calidad de la recuperación. Existen tres enfoques, que van desde lo mecánico hasta lo consciente de la estructura.
La fragmentación de tamaño fijo avanza por el texto en rodajas regulares. Ignora por completo el significado, lo que la hace aplicable a cualquier fuente, pero a menudo corta las frases por la mitad. El solapamiento corrige parcialmente este defecto: con overlap=200, el final de cada fragmento se repite al inicio del siguiente, asegurando que una idea dividida permanezca completa en al menos una de las dos piezas.
def chunk_fixed_size(text, chunk_size=2048, overlap=200):
"""Fragmentación de tamaño fijo con solapamiento."""
chunks = []
start = 0
while start < len(text):
end = min(start + chunk_size, len(text))
chunk = text[start:end]
if chunk.strip():
chunks.append(chunk.strip())
start += chunk_size - overlap
return chunks
La fragmentación basada en párrafos, recomendada para documentación, se basa en los límites naturales del texto. Acumula párrafos mientras se mantengan por debajo de max_size y luego abre un nuevo fragmento. El umbral min_size evita indexar un encabezado huérfano o una línea aislada, lo que produciría un vector sin contenido utilizable.
def chunk_by_paragraphs(text, max_size=1500, min_size=100):
"""Fragmentación inteligente basada en párrafos."""
paragraphs = text.split("\n\n")
chunks = []
current = ""
for para in paragraphs:
para = para.strip()
if not para:
continue
if len(current) + len(para) + 2 <= max_size:
current = current + "\n\n" + para if current else para
else:
if len(current) >= min_size:
chunks.append(current)
current = para
if current and len(current) >= min_size:
chunks.append(current)
return chunks
La fragmentación por secciones de Markdown aprovecha la información que el autor ya proporcionó: sus encabezados. Cada sección se convierte en un fragmento independiente, garantizando que una pregunta sobre «autenticación» recupere toda la sección en lugar de un fragmento. Las secciones que son demasiado largas recurren a la fragmentación por párrafos, asegurando que ningún fragmento exceda el límite.
def chunk_by_markdown_sections(text, max_size=2000):
"""Fragmentación por encabezados Markdown (## y ###)."""
sections = re.split(r'\n(?=##\s)', text)
chunks = []
for section in sections:
section = section.strip()
if not section:
continue
if len(section) <= max_size:
chunks.append(section)
else:
# Sub-fragmentar secciones excesivamente largas
sub_chunks = chunk_by_paragraphs(section, max_size=max_size)
chunks.extend(sub_chunks)
return chunks
Canalización completa de preparación
Finalmente, encadena las tres operaciones y elige la estrategia de fragmentación según el tipo de archivo: los archivos .md pasan por secciones, todo lo demás por párrafos. Cada fragmento lleva entonces sus metadatos: fuente, posición en el documento y número total de fragmentos de ese documento. Sin esto, no podrás atribuir la fuente de una respuesta. Las dos últimas líneas muestran la tasa de expansión y el tamaño promedio: si este promedio cae muy por debajo de tu chunk_size, el documento está más fragmentado de lo esperado y necesitas revisar tu estrategia de fragmentación.
def prepare_documents(raw_docs, chunk_size=1500, overlap=200):
"""Canalización completa: limpiar, fragmentar, enriquecer con metadatos."""
all_chunks = []
for doc in raw_docs:
# 1. Limpiar
clean = clean_text(doc["content"])
# 2. Fragmentar según el tipo
if doc.get("source", "").endswith(".md"):
chunks = chunk_by_markdown_sections(clean, max_size=chunk_size)
else:
chunks = chunk_by_paragraphs(clean, max_size=chunk_size)
# 3. Enriquecer con metadatos
for i, chunk in enumerate(chunks):
all_chunks.append({
"text": chunk,
"source": doc["source"],
"chunk_index": i,
"total_chunks": len(chunks),
})
return all_chunks
# Ejecución
chunks = prepare_documents(docs)
print(f"{len(docs)} documents -> {len(chunks)} chunks")
print(f"Average size: {sum(len(c['text']) for c in chunks) / len(chunks):.0f} characters")
Puntos clave
- La calidad del RAG depende directamente de la calidad de los datos y de la estrategia de fragmentación
- Limpia los datos antes de indexarlos (elimina caracteres extraños, URLs largas, duplicados)
- La fragmentación por párrafos o por secciones de Markdown preserva la coherencia semántica
- Un solapamiento del 10–15 % entre fragmentos evita dividir ideas
- Mantén los metadatos (fuente, página, posición) para la trazabilidad de las respuestas