Fragmentación: división inteligente de documentos
En esta página
- Objetivos
- ¿Por qué dividir los documentos?
- Estrategia 1: Fragmentación de tamaño fijo
- Estrategia 2: Fragmentación basada en separadores
- Estrategia 3: Fragmentación por secciones Markdown
- Estrategia 4: Fragmentación semántica
- Enriquecimiento de fragmentos con contexto
- ¿Qué tamaño de fragmento debes elegir?
- Resumen
Objetivos
- Comprender por qué la fragmentación es crítica para la calidad del RAG
- Dominar diferentes estrategias de división
- Elegir el tamaño de fragmento y la superposición adecuados
¿Por qué dividir los documentos?
Los modelos de incrustación tienen un límite de tokens: 8.191 para OpenAI. Este límite es la primera razón para dividir los documentos, pero no es la más importante. Incluso un documento muy por debajo del techo produce resultados pobres cuando se codifica como un único bloque, porque el vector resultante promedia todo el contenido y pierde detalles. Toma un manual de recursos humanos de 40 páginas que cubre políticas de vacaciones, trabajo remoto, informes de gastos y seguro de salud: su única incrustación no se parece realmente a ninguno de estos cuatro temas, y una búsqueda de «cuántos días de vacaciones» lo clasificará por debajo de un documento mucho más corto pero mucho más específico.
La fragmentación resuelve este problema al dividir el documento en piezas coherentes, cada una capturando una idea o párrafo específico. Este es el paso donde una canalización RAG gana o pierde la mayor calidad, incluso antes de elegir un modelo de incrustación.
Estrategia 1: Fragmentación de tamaño fijo
El método más simple cuenta palabras y corta a intervalos regulares. Ignora completamente la estructura del texto, lo que lo hace brutal, pero requiere solo tres líneas de código y sirve como línea de base esencial: cualquier estrategia más sofisticada debe demostrar que funciona mejor que esta.
def chunker_fixed_size(
text: str,
size: int = 500,
overlap: int = 100
) -> list[str]:
"""Divide el texto en fragmentos de tamaño fijo con superposición."""
words = text.split()
chunks = []
for i in range(0, len(words), size - overlap):
chunk = " ".join(words[i:i + size])
if chunk.strip():
chunks.append(chunk)
return chunks
long_text = "Un documento muy largo... " * 500
chunks = chunker_fixed_size(long_text, size=300, overlap=50)
print(f"{len(chunks)} fragmentos generados")
El parámetro overlap merece atención. Sin superposición, un corte acabará aterrizando en medio de una explicación: la frase «el periodo de preaviso es de tres meses» termina en un fragmento, y «excepto durante el periodo de prueba» en el siguiente. Ninguno responde correctamente a la pregunta, y el segundo es incluso engañoso. Al superponer los fragmentos entre un 10 % y un 20 % de su tamaño, garantizas que cada idea exista intacta al menos una vez en algún lugar del índice. Este es un buen punto de partida; ajústalo más tarde según la densidad de tus documentos.
Estrategia 2: Fragmentación basada en separadores
En lugar de cortar palabra por palabra, puedes respetar los límites naturales del texto. La idea es probar primero el separador más fuerte —el doble salto de línea que separa dos párrafos— y luego bajar a separadores progresivamente más débiles mientras la pieza resultante supere el tamaño máximo. Así, una entrada de blog se dividirá párrafo a párrafo, y solo un párrafo monstruoso se fragmentará por oraciones.
import re
def chunker_separators(
text: str,
separators: list[str] = ["\n\n", "\n", ". ", " "],
max_size: int = 1000
) -> list[str]:
"""Divide el texto respetando los separadores naturales."""
chunks = []
current_chunk = ""
# Dividir primero por el separador más fuerte
segments = [text]
for sep in separators:
new_segments = []
for segment in segments:
parts = segment.split(sep)
for part in parts:
if len(part.split()) > max_size:
new_segments.append(part)
else:
if (current_chunk and
len((current_chunk + sep + part).split()) > max_size):
chunks.append(current_chunk.strip())
current_chunk = part
else:
current_chunk = (
current_chunk + sep + part
if current_chunk else part
)
segments = new_segments
if current_chunk.strip():
chunks.append(current_chunk.strip())
return chunks
Estrategia 3: Fragmentación por secciones Markdown
Cuando tu corpus consiste en documentación estructurada, los encabezados ya hacen el trabajo por ti: el autor ya ha delimitado las unidades de significado. Dividir en los niveles de encabezado # y ## produce fragmentos que corresponden exactamente a las secciones, y la función siguiente mantiene el encabezado junto al texto, lo cual usaremos inmediatamente después para el enriquecimiento.
def chunker_markdown(text: str, max_level: int = 2) -> list[dict]:
"""Divide un documento Markdown por secciones."""
chunks = []
current_section = {"title": "", "content": "", "level": 0}
for line in text.split("\n"):
# Detectar encabezados
match = re.match(r"^(#{1,6})\s+(.+)$", line)
if match:
level = len(match.group(1))
title = match.group(2)
if level <= max_level and current_section["content"].strip():
chunks.append({
"title": current_section["title"],
"text": current_section["content"].strip(),
"level": current_section["level"]
})
if level <= max_level:
current_section = {
"title": title,
"content": "",
"level": level
}
else:
current_section["content"] += line + "\n"
else:
current_section["content"] += line + "\n"
if current_section["content"].strip():
chunks.append({
"title": current_section["title"],
"text": current_section["content"].strip(),
"level": current_section["level"]
})
return chunks
Estrategia 4: Fragmentación semántica
Para texto sin estructura explícita —un resumen de reunión, una transcripción de llamada—, ni el tamaño ni los separadores saben dónde cambia el tema. Las incrustaciones sí. Codificas cada oración, comparas cada oración con la anterior y cortas donde colapsa la similitud: ahí es exactamente donde el hablante pasó del presupuesto a la contratación. Ten en cuenta que text-embedding-3-small es suficiente aquí, ya que no buscas precisión absoluta, sino una ruptura relativa.
from openai import OpenAI
import numpy as np
client = OpenAI()
def chunker_semantic(
text: str,
similarity_threshold: float = 0.75,
min_sentence_length: int = 20
) -> list[str]:
"""Agrupa oraciones por similitud semántica."""
# Dividir en oraciones
sentences = re.split(r"(?<=[.!?])\s+", text)
sentences = [s for s in sentences if len(s) > min_sentence_length]
if len(sentences) <= 1:
return [text]
# Incrustaciones para cada oración
resp = client.embeddings.create(
input=sentences,
model="text-embedding-3-small" # small es suficiente aquí
)
embs = np.array([d.embedding for d in sorted(resp.data, key=lambda x: x.index)])
# Encontrar puntos de ruptura
chunks = []
chunk_sentences = [sentences[0]]
for i in range(1, len(sentences)):
sim = float(np.dot(embs[i], embs[i - 1]))
if sim < similarity_threshold:
# Ruptura semántica detectada
chunks.append(" ".join(chunk_sentences))
chunk_sentences = [sentences[i]]
else:
chunk_sentences.append(sentences[i])
if chunk_sentences:
chunks.append(" ".join(chunk_sentences))
return chunks
Enriquecimiento de fragmentos con contexto
Un fragmento aislado a menudo pierde la información que lo hacía interpretable. «La duración es de tres años» no significa nada si el lector —o el modelo de incrustación— no sabe que proviene del capítulo de garantía del fabricante. Anteponer a cada fragmento el título del documento y el título de la sección restaura este contexto directamente en el propio vector, y una búsqueda de «duración de la garantía» encontrará entonces el pasaje.
def enrich_chunk(chunk: str, doc_title: str, section: str = "") -> str:
"""Añade contexto al fragmento para una mejor incrustación."""
prefix = f"Document: {doc_title}"
if section:
prefix += f" | Section: {section}"
return f"{prefix}\n\n{chunk}"
¿Qué tamaño de fragmento debes elegir?
La elección implica un equilibrio entre precisión y contexto: un fragmento corto apunta con fineza pero está amputado, mientras que un fragmento largo lo entiende todo pero diluye la señal.
| Tamaño (tokens) | Ventajas | Desventajas |
|---|---|---|
| 100–200 | Muy preciso, buena granularidad | Pierde contexto |
| 300–500 | Buen compromiso | Estándar |
| 500–1000 | Contexto rico | Menos preciso, costoso |
| 1000+ | Máximo contexto | Diluye la información |
No existe un valor universal: el tamaño ideal depende de tus documentos y consultas. El único método fiable es indexar el mismo corpus con dos o tres tamaños y luego medir usando las métricas de la lección 10 sobre un conjunto de preguntas reales. Una base de conocimientos de soporte compuesta por respuestas cortas tolera 200 tokens; un corpus jurídico requerirá 800.
Resumen
- La fragmentación es el paso con mayor impacto en la canalización RAG
- Usa el tamaño fijo como línea de base y los separadores para respetar la estructura
- La fragmentación semántica detecta automáticamente los cambios de tema
- La superposición y el enriquecimiento contextual mejoran la calidad
- Prueba diferentes tamaños y mide con métricas de búsqueda