---
title: "Chunk size y overlap en RAG: recuperación y costo | BroadRouter"
description: "Cómo el tamaño de chunk y el solapamiento cambian el recall de RAG, el índice, el costo de embeddings y los tokens por consulta al LLM, con pruebas publicadas."
url: https://broadrouter.com/es/blog/rag-chunk-size-overlap/
lang: es
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/rag-chunk-size-overlap/) (actualizado el 2026-11-16).

# 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 2026-11-15 · Actualizado 2026-11-16

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.

## Puntos clave

-   La entrada por consulta es aproximadamente top-k × tamaño de chunk + prompt. Pasar de 5 × 400 a 8 × 1,024 tokens envía unas 3.4 veces más entrada en cada consulta.
-   El solapamiento infla el índice por tamaño ÷ (tamaño − solapamiento): un 15% añade hasta alrededor de un 18% (un 17% en los documentos de 10,000 tokens medidos aquí), y un 50% lo duplica.
-   En la evaluación de Chroma de 2024, chunks de 200 a 400 tokens sin solapamiento igualaron o superaron a chunks de 800 tokens con 400 de solapamiento, el valor por defecto de la búsqueda de archivos de OpenAI.
-   Las pruebas de NVIDIA de 2025 no encontraron un único tamaño óptimo: las preguntas factuales favorecieron 256 a 512 tokens; las analíticas, 1,024 tokens o una página.
-   Mida el tamaño de chunk en tokens de su modelo de embeddings. Algunos splitters cuentan caracteres por defecto.

**En esta página**

1.  ¿Qué cambian el tamaño de chunk y el solapamiento?
2.  ¿Qué dicen las pruebas publicadas sobre el tamaño de chunk?
3.  ¿Cuánto infla el solapamiento el índice?
4.  ¿Qué hace el tamaño de chunk con la factura del LLM?
5.  ¿Cómo dividir por tokens sin cortar palabras?
6.  ¿Cómo elegir los números para sus datos?
7.  Dónde encaja BroadNet Inference

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](https://broadrouter.com/es/blog/long-context-vs-rag/). Para documentos en árabe, lea [RAG en árabe](https://broadrouter.com/es/blog/arabic-rag-search/) y [normalización de texto árabe](https://broadrouter.com/es/blog/arabic-text-normalization-search/) 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](https://broadrouter.com/tools/embedding-cost-calculator/).

## ¿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](https://broadrouter.com/es/models/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](https://broadrouter.com/es/models/qwen3.8-27b/) ($0.175 de entrada) o [GLM 5.3](https://broadrouter.com/es/models/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é](https://broadrouter.com/es/blog/cached-input-tokens-explained/) 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](https://broadrouter.com/es/blog/long-context-vs-rag/), y esa comparación tiene sus propias cuentas. La [calculadora de chunking para RAG](https://broadrouter.com/tools/rag-chunking-calculator/) 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](https://broadrouter.com/es/blog/tokens-per-word-arabic-english/). 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.

```python
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](https://broadrouter.com/es/blog/evaluate-llm-before-switching/) 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](https://broadrouter.com/es/blog/estimate-llm-api-cost-before-launch/).

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](https://broadrouter.com/es/blog/long-context-vs-rag/) puede superar por completo al chunking.

Herramientas gratuitas sobre este tema (en inglés)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

[Token](https://broadrouter.com/es/glossary/token/)

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

[Embeddings (vectores de texto)](https://broadrouter.com/es/glossary/embeddings/)

Los embeddings son listas de números de punto flotante (vectores) que un modelo produce para representar un texto, una imagen u otra entrada. Las entradas de significado parecido obtienen vectores cercanos, así que la distancia entre vectores sirve para ordenar resultados de búsqueda, agrupar documentos o encontrar elementos relacionados.

[Chunking (fragmentación de documentos en RAG)](https://broadrouter.com/es/glossary/chunking/)

El chunking es el paso de un pipeline de recuperación que divide los documentos en piezas más pequeñas, llamadas chunks o fragmentos, antes de convertirlas en embeddings e indexarlas. El tamaño del chunk fija cuánto texto contiene cada pieza, y el solapamiento repite parte del texto entre fragmentos vecinos para que no se pierdan las ideas cortadas en un límite.

[RAG (generación aumentada por recuperación)](https://broadrouter.com/es/glossary/rag/)

RAG (generación aumentada por recuperación) es un patrón en el que una aplicación primero recupera, de un almacén externo como un índice de búsqueda o vectorial, fragmentos relevantes para una pregunta, y luego los agrega al prompt para que un modelo de lenguaje responda con ese texto y no solo de memoria.

[Prompt de sistema (system prompt)](https://broadrouter.com/es/glossary/system-prompt/)

Un prompt de sistema es el texto de instrucciones que una aplicación envía a un modelo de lenguaje antes de la conversación, normalmente como mensaje con el rol system o developer. Define el rol, las reglas, el tono y el formato de salida del modelo, que debe priorizarlo sobre mensajes del usuario que lo contradigan.

[Evaluación de LLM (eval)](https://broadrouter.com/es/glossary/eval/)

Una eval (abreviatura de evaluation, evaluación) es una prueba repetible de un modelo de lenguaje o de un prompt: un conjunto fijo de entradas, una descripción de cómo es una buena salida y un calificador (código, una persona u otro modelo) que puntúa cada salida para poder comparar versiones.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

[Normalización de texto árabe](https://broadrouter.com/es/glossary/arabic-text-normalization/)

La normalización de texto árabe es el paso que lleva las variantes ortográficas de una misma palabra a una sola forma antes de compararlas: quitar diacríticos y tatweel, unificar las formas de alef y, a menudo, convertir ى en ي y ة en ه. Se aplica a claves de búsqueda y evaluación, no al texto que se muestra.

## 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.

## Siga leyendo

-   [Contexto largo vs RAG: cuándo 1M de tokens reemplaza la base vectorial](https://broadrouter.com/es/blog/long-context-vs-rag/)
-   [RAG en árabe: normalización, chunking y recuperación que funciona](https://broadrouter.com/es/blog/arabic-rag-search/)
-   [Normalización de texto árabe para búsqueda y RAG: qué cambiar y qué no](https://broadrouter.com/es/blog/arabic-text-normalization-search/)
-   [Cómo estimar el costo de una API de LLM antes de lanzar una función](https://broadrouter.com/es/blog/estimate-llm-api-cost-before-launch/)
-   [Tokens de entrada en caché: cómo reducir la factura de una API de LLM](https://broadrouter.com/es/blog/cached-input-tokens-explained/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

[Comenzar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-rag-chunk-size-overlap&utm_content=page-cta) ·

**Fuentes**

-   [Smith y Troynikov, Evaluating Chunking Strategies for Retrieval, informe técnico de Chroma, julio de 2024 (consultado el 2026-11-15)](https://research.trychroma.com/evaluating-chunking)
-   [Blog técnico de NVIDIA, Finding the Best Chunking Strategy for Accurate AI Responses, junio de 2025 (consultado el 2026-11-15)](https://developer.nvidia.com/blog/finding-the-best-chunking-strategy-for-accurate-ai-responses/)
-   [Guía de recuperación de OpenAI: chunks por defecto de 800 tokens con 400 de solapamiento, límites de chunking\_strategy (consultado el 2026-11-15)](https://developers.openai.com/api/docs/guides/retrieval)
-   [Documentación de LangChain, RecursiveCharacterTextSplitter: tamaño de chunk medido con length\_function, en caracteres por defecto (consultado el 2026-11-15)](https://docs.langchain.com/oss/python/integrations/splitters/recursive_text_splitter)
-   [Precios y referencia de la API de BroadNet Inference: modelos, longitudes de contexto, entrada en caché (consultado el 2026-11-15) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-rag-chunk-size-overlap&utm_content=sources)
