Text Splitters

Los text splitters en LangChain son un componente estructural dentro de cualquier pipeline de RAG: determinan cómo se segmenta el conocimiento antes de ser embebido, indexado y recuperado. En sistemas en producción, esta decisión no es neutra; el splitting define directamente la calidad del retrieval, la densidad semántica de los embeddings y, en última instancia, la precisión del sistema.

A nivel de arquitectura, el flujo es conocido:

ingesta → splitting → embeddings → indexación → retrieval

ingesta → splitting → embeddings → indexación → retrieval

pero lo relevante es que el splitter introduce la primera transformación irreversible del dato. Cualquier pérdida de coherencia en esta etapa se propaga aguas abajo.

El punto de abstracción es la interfaz TextSplitter, que define un contrato simple: transformar texto en una lista de fragmentos. Sin embargo, en entornos reales, la elección de implementación no es intercambiable. El uso de CharacterTextSplitter, aunque históricamente común, ha quedado relegado a casos triviales debido a su naturaleza puramente mecánica: corta por longitud fija sin respetar unidades semánticas, lo que degrada la calidad de los embeddings y reduce la efectividad del retrieval.

El estándar de facto en producción es RecursiveCharacterTextSplitter, precisamente porque introduce una heurística jerárquica que preserva la estructura del lenguaje el mayor tiempo posible. En lugar de imponer cortes arbitrarios, aplica una estrategia de degradación progresiva: intenta dividir por párrafos, luego por saltos de línea, después por frases y, solo cuando no hay alternativa, por caracteres. Este comportamiento minimiza la fragmentación semántica sin renunciar al control sobre el tamaño del chunk.

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ".", " ", ""]
)

chunks = splitter.split_text(text)

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ".", " ", ""]
)

chunks = splitter.split_text(text)

Un aspecto clave en todos los splitters es la configuración de chunk_size y chunk_overlap, donde el primero define el tamaño del fragmento y el segundo preserva contexto entre fragmentos; en práctica profesional, valores típicos oscilan entre 500–1500 tokens con un solapamiento del 10–30%.

Los separators definen la jerarquía de cortes que el algoritmo intenta aplicar en orden, no son simplemente delimitadores; son una estrategia de degradación progresiva. En este caso, conceptualmente, le estamos diciendo a la función: “intenta dividir primero por unidades semánticas grandes; si no puedes cumplir el chunk_size, baja de nivel progresivamente hasta poder hacerlo”

El algoritmo sigue esta lógica:

1. Intenta dividir usando "\n\n" (párrafos)
2. Si los chunks siguen siendo demasiado grandes → usa "\n" (líneas)
3. Si aún no cabe → usa "." (frases)
4. Luego " " (palabras)
5. Finalmente "" (caracteres individuales, último recurso)

Splitters

TokenTextSplitter

Cuando el control fino sobre tokens es crítico (coste o límites del modelo), se utiliza TokenTextSplitter, que trabaja directamente con tokenizadores:

from langchain_text_splitters import TokenTextSplitter

splitter = TokenTextSplitter(
    chunk_size=512,
    chunk_overlap=50
)

from langchain_text_splitters import TokenTextSplitter

splitter = TokenTextSplitter(
    chunk_size=512,
    chunk_overlap=50
)

Internamente se apoya en una abstracción de Tokenizer, y también puedes usar funciones como:

from langchain_text_splitters import split_text_on_tokens

from langchain_text_splitters import split_text_on_tokens

Esto garantiza que nunca excedas el contexto real del modelo.

MarkdownHeaderTextSplitter

Más allá de longitud, LangChain introduce splitters estructurales que respetan formato del documento; por ejemplo, MarkdownHeaderTextSplitter divide en función de headers, manteniendo jerarquía lógica:

from langchain_text_splitters import MarkdownHeaderTextSplitter

splitter = MarkdownHeaderTextSplitter(
    headers_to_split_on=[("#", "h1"), ("##", "h2")]
)

docs = splitter.split_text(markdown_text)

from langchain_text_splitters import MarkdownHeaderTextSplitter

splitter = MarkdownHeaderTextSplitter(
    headers_to_split_on=[("#", "h1"), ("##", "h2")]
)

docs = splitter.split_text(markdown_text)

Esto permite que cada chunk incluya metadata semántica (sección, subsección, etc.).

HTMLHeaderTextSplitter

En HTML, el equivalente es HTMLHeaderTextSplitter, que detecta etiquetas <h1>, <h2>, etc., y genera documentos jerárquicos con metadata asociada; si no encuentra headers, devuelve el documento completo, lo cual lo hace robusto ante inputs inconsistentes.

from langchain_text_splitters import HTMLHeaderTextSplitter

splitter = HTMLHeaderTextSplitter(
    headers_to_split_on=[
        ("h1", "section"),
        ("h2", "subsection"),
    ]
)

docs = splitter.split_text(html_string)

from langchain_text_splitters import HTMLHeaderTextSplitter

splitter = HTMLHeaderTextSplitter(
    headers_to_split_on=[
        ("h1", "section"),
        ("h2", "subsection"),
    ]
)

docs = splitter.split_text(html_string)

Para casos más avanzados, HTMLSemanticPreservingSplitter mantiene estructura completa (incluyendo links, imágenes o multimedia), y solo recurre a splitting recursivo si se supera el tamaño máximo, priorizando integridad semántica.

RecursiveJsonSplitter

Cuando trabajas con datos estructurados, RecursiveJsonSplitter permite dividir JSON preservando jerarquía, lo cual es crítico en agentes que dependen de contexto estructurado:

from langchain_text_splitters import RecursiveJsonSplitter

splitter = RecursiveJsonSplitter(max_chunk_size=500)
chunks = splitter.split_json(json_data)

from langchain_text_splitters import RecursiveJsonSplitter

splitter = RecursiveJsonSplitter(max_chunk_size=500)
chunks = splitter.split_json(json_data)

Aquí el objetivo no es solo dividir, sino mantener relaciones entre claves.

Splitters específicos por lenguaje o dominio

LangChain también incluye splitters específicos por lenguaje o dominio, lo cual es clave en sistemas profesionales; por ejemplo, PythonCodeTextSplitter divide respetando sintaxis de Python (funciones, clases), mientras que JSFrameworkTextSplitter extiende el splitting recursivo para entender JSX, Vue o Svelte, detectando componentes como separadores naturales:

from langchain_text_splitters import PythonCodeTextSplitter

splitter = PythonCodeTextSplitter()
chunks = splitter.split_text(code)

from langchain_text_splitters import PythonCodeTextSplitter

splitter = PythonCodeTextSplitter()
chunks = splitter.split_text(code)

Esto evita romper bloques de código de forma incorrecta.

Splitters para procesamiento de texto

En procesamiento lingüístico más avanzado, existen integraciones con NLP clásico como SpacyTextSplitter o NLTKTextSplitter, que segmentan por oraciones usando modelos lingüísticos:

from langchain_text_splitters import SpacyTextSplitter

splitter = SpacyTextSplitter(pipeline="sentencizer")
chunks = splitter.split_text(text)

from langchain_text_splitters import SpacyTextSplitter

splitter = SpacyTextSplitter(pipeline="sentencizer")
chunks = splitter.split_text(text)

Para casos específicos, también existen splitters especializados como:

• LatexTextSplitter → divide respetando estructura LaTeX
• KonlpyTextSplitter → optimizado para coreano
• SentenceTransformersTokenTextSplitter → alineado con tokenizadores de modelos de embeddings
• ExperimentalMarkdownSyntaxTextSplitter → mantiene whitespace exacto y extrae metadata avanzada (headers, code blocks, reglas horizontales)

Text splitters de langchain

Finalmente, en sistemas complejos de agentes construidos con LangGraph, los text splitters no solo afectan al retrieval, sino a la memoria externa del agente; elegir un splitter adecuado implica decidir cómo el agente “percibe” el conocimiento disponible.