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:
- 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.
- 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?
- 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.
- Fije el presupuesto de contexto. Mantenga k × tamaño cerca de un valor, como 2,000 tokens, mientras compara tamaños.
- 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.
- 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.
- 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.
