Cómo elegir el tamaño de chunk y el solapamiento para RAG

Por Sayaib SarkarActualizado el 6 min de lectura

En esta página 7 secciones

Respuesta corta: empieza con una división recursiva que respete la estructura, de unos 200–500 tokens por chunk y un 10–20 % de solapamiento, y luego mide. Escribe 20–50 preguntas reales junto con los documentos que las responden, compara dos o tres configuraciones de chunking por tasa de aciertos y recall, y quédate con la que recupera el pasaje correcto más a menudo. No hay un tamaño ideal universal: depende de tus documentos, de tu modelo de embeddings y de las preguntas que hace la gente.

El chunking es la primera decisión en un pipeline de generación aumentada por recuperación (RAG), y es fácil equivocarse sin darse cuenta. El modelo sigue respondiendo, solo que con el contexto equivocado. Esta guía explica qué cambian el tamaño de chunk y el solapamiento, qué problemas buscar y cómo comparar configuraciones con tus propios datos. Los ejemplos usan las herramientas RAG locales de DevSnip Pro en VS Code, pero el método sirve con cualquier stack.

Qué cambia el tamaño de chunk

Cada chunk se convierte en un embedding, y la recuperación devuelve chunks completos.

  • Los chunks pequeños (unos 100–250 tokens) son precisos: el embedding trata una sola idea, así que una pregunta que encaja lo encuentra. Pero una respuesta que abarca dos párrafos puede quedar repartida entre chunks, y el modelo solo ve la mitad.
  • Los chunks grandes (unos 500–1000 tokens) llevan más contexto, pero mezclan varios temas en un embedding. La coincidencia se debilita y cada chunk recuperado ocupa más de la ventana de contexto.
  • Los chunks muy grandes no caben: la mayoría de los modelos de embeddings truncan la entrada más allá de su límite, que suele ser de unos pocos miles de tokens. El texto que supera el límite sencillamente no queda representado en el vector.

Las preguntas sobre datos concretos («¿Cuál es el límite de peticiones de la API de búsqueda?») suelen preferir chunks pequeños. Las que necesitan explicación («¿Cómo funciona la facturación?») prefieren chunks grandes.

Qué hace el solapamiento

El solapamiento repite el final de un chunk al principio del siguiente, para que una frase que cae en un límite aparezca completa en al menos un chunk. Un 10–20 % del tamaño del chunk es un punto de partida habitual.

Más no es mejor. Por encima de un 30 %, sobre todo pagas por generar el embedding y almacenar el mismo texto dos veces, y la recuperación devuelve chunks casi duplicados que desplazan otros resultados. Algunos estudios apenas encuentran beneficio en el solapamiento, así que incluye el 0 % en tu comparación.

Divide primero según la estructura

Cómo divides importa tanto como el tamaño:

  • La división recursiva prueba primero los saltos de párrafo, luego las líneas y luego las frases, y solo corta a mitad de frase como último recurso. Es una buena opción por defecto para texto en prosa.
  • La división por secciones de Markdown mantiene un encabezado con su contenido y registra la ruta de encabezados (por ejemplo Install > Configure) como metadatos, que puedes mostrar en las citas o usar como filtro.
  • La división de tamaño fijo ignora la estructura. Es sencilla, pero corta frases, código y tablas.

Mantén los bloques de código y las tablas en una pieza siempre que puedas. Media tabla genera un mal embedding.

Mira los chunks antes de generar los embeddings

La mayoría de los problemas de chunking se ven si miras. En VS Code, abre un documento típico y ejecuta DevSnip Pro: Chunking Tester. Elige una estrategia (recursiva, secciones de Markdown, frases o tamaño fijo), una unidad (tokens o caracteres), un tamaño y un solapamiento. Obtienes cada chunk con su tamaño y su sección, además de avisos sobre:

  • chunks mucho más pequeños que el objetivo, como un encabezado suelto, que se recuperan mal;
  • chunks duplicados, que deberían eliminarse antes de generar los embeddings;
  • un solapamiento superior al 30 %;
  • chunks de más de 8K tokens, que la mayoría de los modelos de embeddings truncan.

Exporta chunks.jsonl con un id, el texto y los metadatos de cada chunk:

JSON
{"id":"docs_install.md#1","text":"## Configure\n\nSet PORT in .env. The default is 3000.","metadata":{"source":"docs/install.md","chunk_index":1,"headings":"Install > Configure","tokens":16}}

Antes de indexar todo un corpus, Near-Duplicate Chunk Finder detecta el texto repetitivo (pies de página, avisos de cookies, navegación), y Chunk Metadata Validator comprueba que cada registro tiene los campos por los que filtra tu recuperador.

Mide con tus propias preguntas

La intuición sobre el tamaño de chunk no es fiable. Un pequeño conjunto etiquetado lo resuelve:

  1. Escribe 20–50 preguntas que hacen los usuarios reales y, para cada una, anota el id del documento o chunk que la responde.
  2. Indexa tus documentos con la configuración A, pasa cada pregunta por tu recuperador y anota los ids que devuelve, por orden.
  3. Repítelo con la configuración B (y C).
  4. Compara las puntuaciones.

Retrieval Evaluation de DevSnip Pro recibe una línea por pregunta, con el formato query | relevant ids | retrieved ids in rank order, o en JSON Lines:

Text
reset password  | d3     | d3, d7, d1
refund policy   | d9, d2 | d4, d2, d9
export to csv   | d5     | d8, d6, d1
api rate limits | d11    | d11, d12, d4

Con k = 3 da una tasa de aciertos de 0,75 (tres de las cuatro preguntas encontraron un documento relevante), un recall de 0,75, un MRR de 0,625 y un nDCG de 0,67, e indica que «export to csv» no encontró nada relevante. Ese fallo es lo útil: mira el chunk que debería haber coincidido y normalmente verás por qué. Puede que esté dividido en el lugar equivocado, enterrado en un chunk más grande o redactado de forma distinta a la pregunta. Las preguntas con muchas palabras clave como esta suelen funcionar mejor con búsqueda híbrida, que Hybrid Search Fusion (RRF) te ayuda a probar.

Las métricas, en resumen:

MétricaPregunta que responde
Tasa de aciertos@k¿Algún chunk relevante quedó entre los k primeros?
Recall@k¿Qué parte de los chunks relevantes quedó entre los k primeros?
Precisión@k¿Qué parte de los k primeros es relevante?
MRR¿A qué altura aparece, de media, el primer chunk relevante?
nDCG@k¿Están los chunks relevantes cerca de arriba?

Para RAG, lo que más importa son la tasa de aciertos y el recall: si no se recupera el pasaje correcto, el modelo no puede usarlo.

Comprueba el coste de una configuración

Chunks más pequeños significan más vectores. Chunk & Index Size Calculator convierte el tamaño del corpus, el tamaño del chunk y el solapamiento en el número de chunks, el coste de los embeddings, el coste mensual, el almacenamiento vectorial y la memoria del índice HNSW, para que veas lo que cuesta una configuración antes de elegirla. Context Window Budget muestra cuántos chunks recuperados de ese tamaño caben junto a tu prompt del sistema, el historial del chat, la pregunta y la respuesta.

Un proceso razonable

  1. Empieza con una división recursiva o por Markdown de unos 300 tokens y un 10–15 % de solapamiento.
  2. Revisa algunos documentos en Chunking Tester y corrige los problemas evidentes (chunks diminutos, tablas rotas, texto repetitivo).
  3. Crea un conjunto de prueba de 20–50 preguntas.
  4. Compara tu punto de partida con un tamaño menor y otro mayor, y con un 0 % de solapamiento.
  5. Quédate con el ganador y vuelve a pasar el conjunto de prueba cada vez que cambies el modelo de embeddings, el divisor o los documentos.

Pruébalo en tu propio editor

Gratis, sin cuenta y en local. Para VS Code 1.93+ e IDE de JetBrains en Windows, macOS o Linux.

code --install-extension sayaib.hue-console