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

Fragmentación: división inteligente de documentos

Lección 12 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. ¿Por qué dividir los documentos?
  3. Estrategia 1: Fragmentación de tamaño fijo
  4. Estrategia 2: Fragmentación basada en separadores
  5. Estrategia 3: Fragmentación por secciones Markdown
  6. Estrategia 4: Fragmentación semántica
  7. Enriquecimiento de fragmentos con contexto
  8. ¿Qué tamaño de fragmento debes elegir?
  9. 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)VentajasDesventajas
100–200Muy preciso, buena granularidadPierde contexto
300–500Buen compromisoEstándar
500–1000Contexto ricoMenos preciso, costoso
1000+Máximo contextoDiluye 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