Estrategias de Chunking para RAG que Sobreviven a Producción (2026)

1. El Problema: Buenos Documentos, Chunks Rotos

El chunking decide la calidad de recuperación antes de que tu modelo de embeddings vea el texto. Si un chunk mezcla dos temas, su vector cae a mitad de camino y no matchea bien ninguna query. Si contiene “el límite” sin antecedente, el embedder no puede desambiguar cuál límite. Y si una tabla se corta entre filas, los fragmentos son inútiles al generar. La guía de Weaviate de septiembre 2025 lo cuantifica: hasta 9% de brecha en recall entre el mejor y el peor chunking sobre el mismo corpus con el mismo retriever.

Esta guía te da un camino defendible: empezá con splits recursivos de 512 tokens, ajustá el tamaño a tu tipo de query, y pasá a chunking semántico, tardío o contextual solo cuando tus propias métricas justifiquen el costo extra. Cada número abajo viene de un benchmark publicado en Fuentes — tratá los números de vendors como direccionales y tus propios scores RAGAS como desempate.

2. Conceptos Mínimos: Seis Estrategias en Cinco Minutos

En 2026 realmente hay solo seis jugadas, y cada una ataca una falla distinta: coherencia (un tema por chunk), autocontención (sin referencias colgadas) y granularidad de recall (lo bastante chico para que la respuesta domine el vector del chunk). Este es el menú completo antes de medir nada.

3. Tamaño de Chunk y Overlap: Lo Que Dicen los Números

El tamaño de chunk es el hiperparámetro de mayor leverage del pipeline — la investigación de NVIDIA encontró que errarle por un bracket degrada la precisión de contexto 15–30%. El overlap, en cambio, perdió su estatus de “siempre agregalo”: un análisis sistemático de enero 2026 no encontró beneficio medible en recuperación dispersa, solo mayor costo de indexado. Tratá ambos como ajustables con los rangos de abajo.

4. Tutorial: De Docs Crudos a Chunks Medidos

Hasta acá la teoría. El flujo de abajo corre sobre tu corpus en una tarde: armá un golden set de 50 preguntas desde logs reales, barré tamaños recursivos, compará contra semántico y quedate con el que gane en tus métricas — no en el chart de un vendor. Si usás LlamaIndex en vez de LangChain, el punto de entrada equivalente es SentenceSplitter desde llama_index.core.node_parser con los mismos argumentos chunk_size y chunk_overlap.

Código 1 — Barrido recursivo de tamaños (LangChain)

from langchain_text_splitters import RecursiveCharacterTextSplitter

with open("docs/manual.txt", encoding="utf-8") as f:
    text = f.read()

for chunk_size, chunk_overlap in [(256, 25), (512, 50), (1024, 100)]:
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=chunk_overlap,
        length_function=len,
    )
    chunks = splitter.split_text(text)
    sizes = [len(c.split()) for c in chunks]
    avg = sum(sizes) / len(sizes)
    print(f"{chunk_size}/{chunk_overlap} -> {len(chunks)} chunks, avg {avg:.0f} words")

Código 2 — Desafiante semántico (langchain-text-splitters)

from langchain_text_splitters import SemanticChunker  # core desde PR #35668; la ruta langchain_experimental es legacy
from langchain_openai.embeddings import OpenAIEmbeddings

splitter = SemanticChunker(
    OpenAIEmbeddings(model="text-embedding-3-small"),
    breakpoint_threshold_type="percentile",
    breakpoint_threshold_amount=95,
)
docs = splitter.create_documents([text])
print(f"Semantic chunking produced {len(docs)} chunks")
for i, doc in enumerate(docs[:3]):
    print(f"--- chunk {i} ({len(doc.page_content)} chars) ---")

5. Contextual Retrieval y Late Chunking en la Práctica

Cuando el barrido se estanca, estas dos técnicas atacan los fallos restantes desde lados opuestos. Contextual retrieval fuerza la autocontención con un preámbulo LLM de 50–100 tokens por chunk; late chunking obtiene contexto intra-documento gratis embebiendo todo el documento antes de agrupar en chunks. Combinan bien — primero late-chunk, después anteponé contexto — y ninguna agrega latencia por query porque todo el trabajo ocurre al ingerir.

Código 3 — La misma idea en LlamaIndex

from llama_index.core import Document
from llama_index.core.node_parser import SentenceSplitter

splitter = SentenceSplitter(chunk_size=512, chunk_overlap=50)
nodes = splitter.get_nodes_from_documents([Document(text=text)])
chunks = [n.text for n in nodes]
print(f"SentenceSplitter produced {len(chunks)} chunks")

Código 4 — Patrón de preámbulo contextual (receta Anthropic)

CONTEXT_PROMPT = (
    "<document>{doc}</document>
"
    "Here is the chunk to situate within the whole document.
"
    "<chunk>{chunk}</chunk>
"
    "Reply with a 50-100 token context for this chunk."
)

# Prepend before BOTH embedding and BM25 indexing
contextualized = context + "

" + chunk

6. Camino de Decisión: Qué Estrategia para Tus Docs

No hay un ganador universal — la victoria recursiva de FloTorch, la corona de recall semántico de Chroma y el triunfo de page-level de NVIDIA salieron de distintos corpus. Recorré el camino de abajo en orden y frená en el primer paso cuya evidencia matchee tus documentos.

7. Errores Comunes Que Matan la Recuperación

En cada post-mortem de benchmarks 2026 que leí, los mismos cinco fallos aparecían una y otra vez. Todos son baratos de evitar una vez que los viste nombrados — y caros de depurar como “los embeddings deben estar mal”.

Conclusión

La evidencia 2026 apunta en una dirección: empezá con splits recursivos de 512 tokens contados por un tokenizer real, dimensioná los chunks a tu tipo de query, y agregá maquinaria semántica, tardía o contextual solo cuando tu propio golden set diga que el costo extra compra accuracy. La escalera 35 → 49 → 67% de contextual retrieval y la correferencia gratis de late chunking son herramientas reales, no magia — reproducilas sobre tus datos.

Corré tu primer barrido esta semana: 50 preguntas, tres tamaños, una tarde. Los equipos que miden chunking dejan de apagar incendios de recuperación en producción — y todo lo downstream, del reranking a la generación, mejora gratis.

Fuentes