BroadRouter

Tamaño de chunk y solapamiento en RAG: efecto en recuperación y costo

Por el equipo de BroadNet Inference · 7 min de lectura · Publicado · Actualizado

Empiece con chunks de unos 256 a 512 tokens, un solapamiento del 0 al 15% y un top-k ajustado con sus propias consultas. Los chunks más grandes aumentan los tokens que cada consulta envía al LLM. El solapamiento multiplica los tokens que se embeben y almacenan por tamaño ÷ (tamaño − solapamiento), así que un 50% duplica el índice. Pruebas publicadas vieron que chunks pequeños o sin solapamiento suelen recuperar igual o mejor.

El tamaño de chunk y el solapamiento son los dos números que todo pipeline de RAG fija al principio y rara vez revisa. Deciden cuántos vectores almacena, cuántos tokens embebe, cuántos tokens envía cada pregunta al LLM y si se llega a encontrar el pasaje correcto. Este artículo muestra lo que encontraron las pruebas publicadas y después hace las cuentas de tokens para que vea el costo de cada configuración antes de embeber nada.

Si aún está decidiendo si usar RAG, empiece por contexto largo frente a RAG. Para documentos en árabe, lea RAG en árabe y normalización de texto árabe junto con este artículo.

¿Qué cambian el tamaño de chunk y el solapamiento?

  • El tamaño de chunk es cuántos tokens van en cada fragmento que embebe y recupera.
  • El solapamiento (overlap) es cuántos tokens comparten chunks consecutivos, para que una frase cortada en un límite aparezca entera en al menos un chunk.
  • Top-k es cuántos chunks recupera por pregunta.

Juntos determinan cuatro cosas:

Cantidad Fórmula (documentos largos)
Chunks almacenados tokens del corpus ÷ (tamaño − solapamiento)
Tokens embebidos tokens del corpus × tamaño ÷ (tamaño − solapamiento)
Contexto por consulta top-k × tamaño
Entrada al LLM por consulta top-k × tamaño + prompt de sistema + pregunta

Las dos primeras se pagan una vez por indexación, y otra vez cada vez que cambia el chunking. La última se paga en cada pregunta, para siempre.

¿Qué dicen las pruebas publicadas sobre el tamaño de chunk?

Conviene conocer dos evaluaciones públicas, porque midieron cosas distintas.

Chroma (Smith y Troynikov, julio de 2024) midió la recuperación a nivel de token: cuánto del texto relevante se recuperó (recall) y cuánto de lo recuperado era relevante. Usó cinco chunks recuperados y text-embedding-3-large de OpenAI. Filas seleccionadas:

Splitter Tamaño (tokens) Solapamiento Recall IoU
Recursive 800 400 85.4% 1.5%
Token 800 400 87.9% 1.4%
Recursive 400 200 88.1% 3.3%
Recursive 400 0 89.5% 3.6%
Recursive 200 0 88.1% 6.9%

El IoU (intersección sobre unión) mide qué parte del texto recuperado era relevante, así que sirve también como medida de tokens desperdiciados. Las filas 800/400 coinciden con el valor por defecto de OpenAI para la búsqueda de archivos; suponiendo un splitter por tokens, Chroma vio que esa configuración daba un recall algo inferior a la media y las puntuaciones más bajas en las demás métricas. Los chunks más pequeños sin solapamiento recuperaban lo mismo o más y llevaban mucho menos texto irrelevante.

NVIDIA (junio de 2025) midió la precisión de la respuesta de extremo a extremo en cinco conjuntos de datos, con chunks de 128 a 2,048 tokens y un 15% de solapamiento, además de chunking por página y por sección. El chunking por página tuvo la mayor precisión media (0.648) y la menor varianza. El mejor tamaño en tokens dependía de las preguntas: los conjuntos factuales favorecían 256 a 512 tokens; los analíticos, 1,024 tokens o páginas completas. Los dos extremos, 128 y 2,048, solían rendir peor.

Ambas coinciden en una cosa: no existe un tamaño óptimo universal, y los chunks muy grandes con mucho solapamiento rara vez son el valor por defecto adecuado.

¿Cuánto infla el solapamiento el índice?

Cada chunk avanza tamaño − solapamiento tokens, así que el índice contiene tamaño ÷ (tamaño − solapamiento) copias del corpus. Para un corpus de 2,000,000 de tokens formado por documentos de 10,000 tokens:

Tamaño Solapamiento Chunks Tokens embebidos Inflación
200 0 10,000 2,000,000 1.00×
400 0 5,000 2,000,000 1.00×
512 77 (15%) 4,600 2,338,800 1.17×
1,024 154 (15%) 2,400 2,338,800 1.17×
800 400 (50%) 4,800 3,840,000 1.92×
400 200 (50%) 9,800 3,920,000 1.96×

Los documentos cortos se inflan algo menos, porque el último chunk de cada uno es parcial. La fórmula da el límite: un 15% de solapamiento cuesta alrededor de un 18% más, y un 50% cerca de un 100% más, en tokens de embeddings, almacenamiento de vectores y tiempo de reindexación.

El solapamiento también cuesta en la consulta. Con un 50%, dos chunks vecinos recuperados para la misma pregunta repiten la mitad de su texto. Usted paga esos tokens duplicados, y además dejan fuera del top-k otros pasajes relevantes.

BroadNet no vende embeddings, así que esta parte de la factura va a su proveedor de embeddings. Calcúlela con la calculadora de costo de embeddings.

¿Qué hace el tamaño de chunk con la factura del LLM?

Cada pregunta envía top-k chunks más el prompt. Suponga 100,000 preguntas al mes, 600 tokens de prompt de sistema y pregunta, y la misma respuesta de 300 tokens cada vez:

Tamaño × top-k Contexto por consulta Entrada por consulta Entrada al mes
200 × 10 2,000 2,600 260 millones
400 × 5 2,000 2,600 260 millones
512 × 5 2,560 3,160 316 millones
800 × 5 4,000 4,600 460 millones
1,024 × 5 5,120 5,720 572 millones
1,024 × 8 8,192 8,792 879 millones

La salida es de 30 millones de tokens al mes en todas las filas, así que solo cambia la entrada. Con un precio por 1M de tokens, el costo mensual de entrada son los millones de la última columna por ese precio. En Gemma 4 VL 26B, a $0.10 por 1M de tokens de entrada, la configuración 1,024 × 8 cuesta 879 × $0.10 al mes en entrada, frente a 260 × $0.10 con 400 × 5. Es 3.4 veces más, por una configuración que las pruebas publicadas no muestran que recupere mejor. En Qwen3.8 27B ($0.175 de entrada) o GLM 5.3 ($0.78 de entrada), la proporción es la misma y los totales, mayores.

Hay dos palancas que mueven esta cifra más que el precio del modelo:

  1. Baje k cuando suba el tamaño. 200 × 10 y 400 × 5 envían el mismo contexto. Mantenga el contexto por consulta más o menos fijo mientras prueba tamaños, para comparar la calidad de recuperación y no el presupuesto de contexto.
  2. Cachee la parte fija. Ponga el prompt de sistema primero y manténgalo idéntico byte a byte, para que pueda facturarse a la tarifa de entrada en caché en los modelos que la tienen. Los chunks recuperados cambian con cada pregunta y rara vez se cachean.

Los límites de contexto también importan. Gemma 4 VL 26B acepta 32,768 tokens por petición, de sobra para cualquier fila anterior. Si lleva k × tamaño hacia decenas de miles de tokens, ha pasado de RAG a algo cercano al contexto largo, y esa comparación tiene sus propias cuentas. La calculadora de chunking para RAG aplica estas fórmulas a su corpus, tamaño de chunk, solapamiento y top-k.

¿Cómo dividir por tokens sin cortar palabras?

Cuente en tokens, pero corte por la estructura. El RecursiveCharacterTextSplitter de LangChain mide el tamaño con su length_function, que por defecto es la longitud en caracteres. Un «tamaño» de 512 son entonces 512 caracteres, unos 100 a 150 tokens en inglés, y otra cifra distinta en árabe; vea tokens por palabra en árabe. Los límites de embeddings y las facturas del LLM van en tokens.

Este chunker agrupa párrafos completos hasta un presupuesto de tokens y arrastra los últimos párrafos como solapamiento. Cortar en los límites de párrafo evita partir palabras o caracteres árabes multibyte, algo que pueden hacer las ventanas de tokens en bruto.

import tiktoken

enc = tiktoken.get_encoding("o200k_base")    # an estimate: count with your embedder's tokenizer
count = lambda s: len(enc.encode(s))

def chunk(text, size=512, overlap=64):
    """Pack whole paragraphs up to `size` tokens; repeat trailing paragraphs up to `overlap` tokens."""
    chunks, cur, cur_len = [], [], 0
    for para in (p.strip() for p in text.split("\n\n")):
        if not para:
            continue
        n = count(para)
        if cur and cur_len + n > size:
            chunks.append("\n\n".join(cur))
            tail, t = [], 0
            for q in reversed(cur):                  # carry the end of this chunk forward
                if t + count(q) > overlap:
                    break
                tail.insert(0, q); t += count(q)
            cur, cur_len = tail, t
        cur.append(para); cur_len += n              # a paragraph over `size` stays whole
    if cur:
        chunks.append("\n\n".join(cur))
    return chunks

def plan(corpus_tokens, size, overlap, k, queries_per_month, prompt_tokens=600):
    index_tokens = corpus_tokens * size / (size - overlap)   # long-document limit
    per_query = k * size + prompt_tokens
    return {"chunks": round(index_tokens / size), "tokens_to_embed": round(index_tokens),
            "input_per_query": per_query, "input_per_month": per_query * queries_per_month}

print(plan(2_000_000, 512, 64, 5, 100_000))
# {'chunks': 4464, 'tokens_to_embed': 2285714, 'input_per_query': 3160, 'input_per_month': 316000000}

Aquí el solapamiento es «hasta»: un párrafo más largo que el presupuesto de solapamiento no se repite. Un párrafo más largo que size se mantiene entero; divida antes esos párrafos por frases si sus documentos las tienen. Anteponga a cada chunk el título del documento y el encabezado de la sección, para que un chunk recuperado siga diciendo de qué trata. Eso añade unos pocos tokens por chunk y a menudo ayuda más que el solapamiento.

¿Cómo elegir los números para sus datos?

  1. Cree un conjunto de evaluación. De 50 a 200 preguntas reales, cada una con el pasaje que la responde. La guía de evaluación de LLM explica cómo puntuar.
  2. Fije el presupuesto de contexto. Mantenga k × tamaño cerca de un valor, como 2,000 tokens, mientras compara tamaños.
  3. Pruebe tres tamaños y dos solapamientos. Por ejemplo 256, 512 y 1,024 tokens, cada uno con 0 y 15% de solapamiento. Mida el recall del pasaje correcto en k.
  4. Pruebe la estructura. Si sus documentos tienen páginas o secciones numeradas, compare chunks por página o por sección con los tamaños en tokens. NVIDIA vio que el nivel de página era el más consistente.
  5. Elija la configuración más barata a uno o dos puntos del mejor recall, y después póngale precio con su volumen de consultas usando el método de costo mensual.

Hágalo con una muestra antes de embeber el corpus completo. Cambiar el chunking después implica volver a embeberlo todo.

Dónde encaja BroadNet Inference

BroadNet Inference sirve el paso de respuesta de RAG, no la recuperación. No vende embeddings ni almacenamiento vectorial, así que combínelo con el proveedor de embeddings y la base de datos vectorial que prefiera. Para la respuesta, Gemma 4 VL 26B es la opción de bajo costo y funciona con el crédito inicial de $5. Qwen3.8 27B (contexto de 262,144 tokens) y GLM 5.3 (1,048,576) se adaptan a un top-k mayor o a documentos largos, tras una recarga. Los prompts y los pasajes recuperados no se conservan después de la petición. Si su corpus es lo bastante pequeño y estable para caber en la ventana de contexto, el contexto largo puede superar por completo al chunking.

Preguntas frecuentes

¿Cuál es un buen tamaño de chunk para RAG?

Empiece en torno a 256 a 512 tokens y pruebe. La evaluación de Chroma vio que 200 a 400 tokens sin solapamiento funcionaban bien. NVIDIA vio que 256 a 512 tokens convenían a las preguntas factuales, mientras que las analíticas iban mejor con chunks de 1,024 tokens o de nivel de página.

¿Cuánto solapamiento entre chunks debo usar?

Menos que la mayoría de los valores por defecto. NVIDIA encontró que el 15% era el mejor entre el 10%, 15% y 20% que probó en un conjunto de datos. Chroma vio que las configuraciones sin solapamiento a menudo puntuaban igual o mejor. Cada punto de solapamiento añade tokens que embeber, almacenar y enviar.

¿Un tamaño de chunk mayor cuesta más?

En embeddings no, si no hay solapamiento: el corpus tiene los mismos tokens. Sí cuesta más por consulta, porque cada chunk recuperado es más largo y top-k × tamaño de chunk crece. Baje k cuando suba el tamaño.

¿El tamaño de chunk se mide en tokens o en caracteres?

Depende del splitter. El RecursiveCharacterTextSplitter de LangChain mide con su length_function, que por defecto es la longitud en caracteres. Los límites de embeddings y las facturas del LLM van en tokens, así que pásele un contador de tokens.

¿Tengo que volver a generar los embeddings al cambiar el tamaño de chunk?

Sí. Los nuevos límites crean chunks nuevos, y cada uno necesita un vector nuevo. Volver a embeber cuesta todo el índice otra vez, así que fije el chunking con una muestra antes de embeber el corpus completo.

Leer en MarkdownPreguntar a ChatGPTPreguntar a ClaudePreguntar a Perplexity