oriolrius.me Production RAGGuía de referencia
Parte 14·Avanzado y frontera

Retrieval avanzado: contexto largo, contextual retrieval y late chunking

Long context frente a RAG, contextual retrieval y late chunking: arreglar lo que significa cada chunk.

47 min de lectura 34 secciones Avanzado y frontera
Resumen en audio · 6:47 · ES
Retrieval avanzado: contexto largo, contextual retrieval y late chunking

Todo lo visto hasta aquí iba de hacer funcionar un pipeline convencional: dividir bien, generar embeddings de forma coherente, recuperar en amplitud, hacer reranking, observar, cachear, desplegar. En esta parte el curso se vuelve hacia la frontera de 2026, y arranca atacando la premisa de toda la guía.

Tres técnicas, tres cajas distintas del modelo mental:

  • El contexto largo (long context) se pregunta si la Phase A (index) tiene siquiera que existir. Si el modelo puede

leer un millón de tokens, ¿para qué dividir, generar embeddings y almacenar nada? La respuesta es aritmética, no ideología.

  • El contextual retrieval modifica el paso [Contextualize] de la Phase A, la única caja del

diagrama que hasta ahora estaba vacía. Cambia el texto del que generas el embedding.

  • El late chunking modifica el orden Split → Embed de la Phase A. Cambia **cuándo se

calcula el embedding**.

Las tres se rigen por el invariante 3: el coste en tiempo de indexación es único y se amortiza; el coste en tiempo de query se repite en cada request. El contextual retrieval y el late chunking son apuestas puras sobre ese invariante: gastan mucho en el camino de escritura y nada en el de lectura. El contexto largo es la apuesta contraria: te saltas por completo el camino de escritura y pagas para siempre en el de lectura. Ese es todo el argumento de esta parte en tres frases.

El código está en el segundo repo, fcc-production-rag-part-6 (las lecciones 6.1–6.3 de «Advanced RAG 2026»): 01_long_context_vs_rag.py, 02_contextual_retrieval.py, 03_late_chunking.py. Los capítulos 24, 25 y 26 de la fuente los cubren de 06:06:09 → 06:42:04. Tres filas de la tabla de seis filas de la Part 6 del README del repo pertenecen a esta parte:

TécnicaQué resuelveMejora declarada
Contexto largo frente a RAGCuándo usar ventanas de 1M de tokens y cuándo retrievalOptimización de costes
Contextual RetrievalChunks que pierden el contexto del documento67% menos fallos de retrieval
Late ChunkingContexto entre chunks que se pierde en los embeddings10–12% más de precisión

No te aferres a esos dos porcentajes. Al final de esta parte sabrás de dónde sale cada uno, qué configuración mide en realidad y por qué el propio instructor del curso te dice dos veces que los ignores y midas los tuyos.

1. ¿Ha muerto RAG? La cuestión del contexto largo

1.1 La pregunta y el cambio de enfoque

06:06:15 El capítulo empieza a mitad de frase con la pregunta que el instructor recibe con más frecuencia: con modelos como Gemini que ya ofrecen ventanas de un millón de tokens, ¿seguimos necesitando RAG? Su respuesta es negarse a responder la pregunta tal como se plantea, y lo repite tres veces en ocho minutos:

«No descartes una en favor de la otra. Simplemente averigua cuándo usar cada una». 06:11:20

El propio script imprime el cambio de enfoque como un banner antes de hacer nada más:

Python
# fcc-production-rag-part-6/01_long_context_vs_rag.py — __main__ banner
print("\nThe question isn't 'Is RAG dead?'")
print("It's 'When should I use RAG vs Long Context?'")

Define los términos con precisión, porque si no la comparación no significa nada. Contexto largo, tal como se usa aquí, significa meter el corpus entero en la ventana del prompt en cada query, sin ningún paso de retrieval: sin splitter, sin embeddings, sin vector store. RAG significa recuperar de cuatro a ocho chunks (~2K tokens) y enviar solo esos. Es una comparación entre dos arquitecturas, no entre dos modelos.

1.2 La tabla comparativa tal como se dice en el vídeo

DimensiónRAGContexto largo
Coste por queryno se dice ninguna cifra: «muy insignificante por query»~$0.10
Latencia~1 segundo~45 segundos
Escalado«ilimitado, de verdad»límite de ~1M de tokens
Titular«RAG es más de 1,200 veces más barato» 06:06:15—

No hay captura de pantalla del capítulo 24 (INDEX.md lo incluye explícitamente en «capítulos sin captura»), así que todas las cifras de arriba salen de la transcripción automática, y la celda de coste de RAG nunca se lee en voz alta. Ese número, sencillamente, se pierde. El par 1 s frente a 45 s y la proporción de 1,200× proceden de la transcripción y no tienen fuente; tómalos como orientativos.

«Es la diferencia entre tener un producto viable y la bancarrota». 06:07:16

1.3 La aritmética de costes, y por qué imprime 25× y no 1,200×

calculate_costs() es aritmética pura. No hace ninguna llamada a la API. Eso importa: puedes ejecutarla, cambiar sus constantes y razonar sobre tus propias cifras sin gastar un céntimo.

Python
# fcc-production-rag-part-6/01_long_context_vs_rag.py — calculate_costs(), abridged:
# the print() calls that only echo these values are omitted.
# Docstring pricing: GPT-4o (April 2026) — input $2.50 / 1M, output $10.00 / 1M.

# Scenario: Query against 100K tokens of documentation
doc_tokens = 100_000
query_tokens = 100
output_tokens = 500

# Long Context approach - stuff everything
long_context_input = doc_tokens + query_tokens
long_context_cost = (long_context_input * 2.50 / 1_000_000) + (
    output_tokens * 10.00 / 1_000_000
)

# RAG approach - retrieve 4 chunks of ~500 tokens each
rag_chunks = 4
tokens_per_chunk = 500
rag_input = (rag_chunks * tokens_per_chunk) + query_tokens
rag_cost = (rag_input * 2.50 / 1_000_000) + (output_tokens * 10.00 / 1_000_000)

print(f"RAG is {long_context_cost / rag_cost:.0f}x cheaper per query!")

queries_per_day = 10_000
print(
    f"  Monthly savings with RAG: ${(long_context_cost - rag_cost) * queries_per_day * 30:.2f}"
)

Hazla a mano, porque la aritmética es la lección:

MagnitudContexto largoRAG (4 × 500)
Tokens de entrada100,1002,100
Coste de entrada @ $2.50/1M$0.25025$0.00525
Coste de salida (500 tok @ $10/1M)$0.00500$0.00500
Coste por query$0.25525$0.01025
Con 10,000 queries/día$2,552.50/día$102.50/día
Diferencia mensual (×30)—$73,500.00 ahorrados

06:11:20 Lee en pantalla la línea impresa: «RAG is 25x cheaper per query» (0.25525 / 0.01025 = 24.9, formateado con :.0f). Pero la diapositiva que enseñó cinco minutos antes decía más de 1,200×. Las dos cifras se dan en los mismos ocho minutos y nunca se concilian.

Dos trampas más de esta función con las que te toparás al minuto de ejecutarla:

1.4 La demo de latencia, y por qué no deberías citarla

compare_latency() es la única función del archivo que hace llamadas reales a la API. Cronometra dos llamadas a llm.invoke(), una con un contexto de una frase y otra con la misma frase repetida 50 veces.

Python
# fcc-production-rag-part-6/01_long_context_vs_rag.py — compare_latency()
small_context = (
    "The company's return policy allows returns within 30 days with receipt."
)
large_context = (small_context + "\n\n") * 50  # ~2500 tokens

query = "What is the return policy?"

start = time.time()
response_small = llm.invoke(f"Context: {small_context}\n\nQuestion: {query}")
small_time = time.time() - start

start = time.time()
response_large = llm.invoke(f"Context: {large_context}\n\nQuestion: {query}")
large_time = time.time() - start

print(f"\nSmall context (~50 tokens): {small_time:.2f}s")
print(f"Large context (~2500 tokens): {large_time:.2f}s")
print(
    f"Difference: {large_time - small_time:.2f}s ({large_time/small_time:.1f}x slower)"
)
print("\nNote: At 100K+ tokens, latency difference is much more dramatic!")

La ejecución en directo 06:12:23 dio 1.45 s en pequeño y 1.16 s en grande: una diferencia de −0.29 s y un «0.8x slower» impreso. Las propias cifras de la demo dicen que el contexto largo fue más rápido.

1.5 El techo de fiabilidad: una ventana de 1M no son 1M de tokens utilizables

06:07:16 La afirmación no monetaria más importante del capítulo:

«estos modelos se vuelven poco fiables en torno al 60 a 70% de ese límite». 06:07:16

La capacidad efectiva y fiable es aproximadamente el 60–70% de la ventana anunciada: unos 600K–700K tokens en un modelo de 1M de tokens. Más allá, el retrieval dentro del contexto se degrada: la familia de fallos «lost in the middle» / context rot, en la que el modelo deja de forma demostrable de prestar atención al material que se le dio. Su planteamiento: «esto no va solo de dinero o de economía»; aunque tuvieras presupuesto infinito, la precisión por sí sola ya es un argumento contra meterlo todo a lo bruto.

Lo afirma como «un hecho conocido» y no cita ningún paper ni ningún benchmark. Es coherente con la literatura publicada sobre contexto largo, pero tal como se presenta en este curso es una afirmación sin fuente. Trata el 60–70% como una heurística de planificación, no como una especificación: una ventana de un millón de tokens te da 600–700K tokens de atención fiable, así que presupuesta contra el límite efectivo, no contra el de marketing.

Las listas habladas: dónde gana de verdad cada enfoque

Antes del framework impreso, narra dos listas informales. En algunos puntos difieren del recuadro que imprime el script, y merece la pena tener las dos.

Dónde gana de verdad el contexto largo 06:07:16: «seamos justos, hay casos en los que los modelos de contexto largo son realmente buenos»:

  1. Documentos pequeños: documentos más pequeños en general.
  2. Menos de 100K tokens: *«si tienes menos de 100k tokens, esa será una buena forma de

abordarlo»*. (El recuadro impreso dice <50K. Las dos cifras están en la lección).

  1. Tareas estáticas y acotadas: una tarea cuya entrada no crece y cuyo alcance es fijo.
  2. Necesitas todo el contexto a la vez: razonamiento sobre el documento entero, donde cualquier frontera

de chunk destruiría la respuesta: resume este contrato, encuentra contradicciones en todo el documento.

Dónde gana RAG 06:08:17:

  1. Base de conocimiento grande: *«muchos documentos, mucha información que estás metiendo

en una base de datos vectorial»*.

  1. Contenido dinámico y actualizado con frecuencia: «RAG es muy bueno en eso». (Contradice el

recuadro impreso; mira el callout de abajo).

  1. Rentabilidad: «si tu sistema es sensible al coste, RAG es el camino».
  2. Precisión: *«si quieres un sistema muy preciso y muy específico, entonces

RAG gana la carrera sin duda», con el condicional crucial «si todo se monta correctamente»*.

1.6 El framework de decisión

print_decision_framework() imprime un recuadro ASCII (es una sentencia print del script, no una diapositiva) y es el artefacto reutilizable de todo el capítulo. Reproducido fielmente, con las variantes habladas anotadas:

Usa contexto largo cuandoUsa RAG cuando
El corpus es pequeño (<50K tokens); en voz alta dice <100K en 06:07:16El corpus es grande (>100K tokens)
El volumen de queries es bajo (<100 queries/día)El volumen de queries es alto (miles/día); en voz alta dice «cientos» 06:13:23
Necesitas analizar el documento ENTEROLos usuarios preguntan por temas concretos, no por un análisis del documento entero
Los documentos cambian a menudo (sin overhead de embeddings)Los documentos son relativamente estables
Simplicidad > optimización de costesEl coste y la latencia importan
—Necesitas citas / trazabilidad de fuentes

Overhead de embeddings, definido: el coste, la latencia y la carga operativa de generar embeddings e indexar cada versión de cada documento en el vector store, y de repetirlo cada vez que un documento cambia. Es justo lo que el contexto largo te permite saltarte por completo.

Dos asimetrías más que conviene decir claramente, porque el recuadro impreso solo las insinúa:

  • Las citas salen gratis por estructura en RAG y son difíciles por estructura en contexto largo. En RAG

sabes qué chunk produjo la respuesta porque lo pusiste tú. Mete 100K tokens en un solo bloque y la atribución se convierte en una segunda tarea del LLM, poco fiable.

  • La precisión de RAG es condicional. *«RAG aporta mucha precisión **si todo se monta

correctamente**»* 06:08:17. Esa cláusula condicional son las Partes 3 a 9 de esta guía. RAG no gana en precisión por defecto; gana en precisión cuando su pipeline está bien construido.

1.7 El enfoque híbrido: RAG selecciona, el contexto largo lee

La síntesis, en la frontera entre capítulos 06:14:29:

«No separes las dos cosas, RAG frente a contexto largo. Di RAG Y contexto largo».

Y la frase con la que cierra: «En resumen, RAG no ha muerto». El mecanismo tiene dos pasos y es la forma hacia la que deberían converger la mayoría de los sistemas reales:

  1. RAG recupera documentos candidatos: no chunks con los que responder, sino documentos que leer.
  2. Carga esos documentos completos en la context window para la respuesta detallada.

La forma de query que necesita ambas cosas: «háblame de X, Y y Z, y luego analiza a fondo esta parte del corpus». RAG reduce el corpus de diez mil documentos a uno; después, el contexto largo hace la lectura minuciosa de lo que ha sobrevivido.

demo_hybrid_approach() es la cuarta llamada de __main__, así que sí se ejecuta, pero la narración se detiene tras el framework de decisión y nunca la comenta, de modo que este es el único sitio donde el lector la verá explicada. El detalle clave es k=1:

Python
# fcc-production-rag-part-6/01_long_context_vs_rag.py — demo_hybrid_approach()
# Step 1: Create vector store for RAG retrieval
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(
    documents=documents, embedding=embeddings, collection_name="hybrid_demo"
)

query = "What's the policy on working from home and what equipment do I get?"

# Step 3: RAG retrieves relevant document
retriever = vectorstore.as_retriever(search_kwargs={"k": 1})
relevant_docs = retriever.invoke(query)
print(f"Retrieved: {relevant_docs[0].metadata['source']}")

# Step 4: Load FULL document into context (hybrid part)
full_doc = relevant_docs[0].page_content

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            """You are a helpful HR assistant. Use the full policy document
        below to give a comprehensive answer. Include all relevant details from
        the document.

        Policy Document:
        {document}""",
        ),
        ("human", "{query}"),
    ]
)

chain = prompt | llm
response = chain.invoke({"document": full_doc, "query": query})

# Cleanup
vectorstore.delete_collection()

k=1 hace algo inusual y deliberado: aquí el retrieval elige el documento, no la respuesta. Los tres documentos de la demo están escritos como políticas completas con Secciones 1–4 (remote_work_policy.pdf, expense_policy.pdf, pto_policy.pdf), todos etiquetados con doc_type: "policy", así que «cargar el documento completo» es un acto con sentido. La query (*teletrabajo y qué equipo me dan*) abarca a propósito la Sección 2 y la Sección 3 de un mismo documento, que es exactamente la pregunta que un retrieval top-k de chunks responde mal y una lectura del documento entero responde a la perfección.

El corpus sintético de RR. HH., por si quieres reproducir la ejecución

Son valores de fixture, no parámetros de RAG, pero reprodúcelos exactamente si quieres el mismo comportamiento del retrieval.

  • Remote Work Policy: elegibilidad tras un periodo de prueba de 90 días (tiempo parcial, caso por

caso); teletrabajo hasta 3 días/semana; horario núcleo de 10am–3pm hora local; se proporcionan portátil + monitor, el empleado paga internet, $500 anuales de ayuda para la oficina en casa; localizable en Slack durante el horario núcleo, cámara encendida en las reuniones de equipo, expectativa de respuesta en 30 minutos.

  • Expense Reimbursement Policy: los gastos de más de $500 necesitan aprobación previa del manager,

los viajes de más de $2,000 necesitan aprobación de un VP; recibos obligatorios a partir de $25 (se aceptan digitales, los extractos de tarjeta por sí solos no); presentar en 30 días, fuera de plazo requiere aprobación de un director; reembolso en 10 días laborables por transferencia.

  • PTO and Leave Policy: 15 días de PTO/año, +1 día por año de antigüedad hasta

25; 10 días de baja por enfermedad, no acumulables, justificante médico a partir de 3 días; 10 festivos pagados; excedencia no retribuida de hasta 12 semanas por motivos familiares/médicos, se aplican las reglas de la FMLA.

Fíjate en vectorstore.delete_collection() al final. Cada demo de esta parte destruye su colección de Chroma, y es un hábito que conviene copiar: estos scripts tienen los collection_names fijados en el código, y un fallo a mitad de ejecución deja una colección poblada a la que la siguiente ejecución añade datos, corrompiendo la comparación en silencio.

Los beneficios impresos: 1. RAG encuentra rápido el documento CORRECTO. 2. El contexto del documento completo garantiza que no se pierde nada. 3. Sigue siendo más barato que meter TODOS los documentos. 4. Ideal para: «Encuentra el documento relevante y luego analízalo a fondo».

1.8 La lección de fondo: piensa a escala, no a tamaño de prototipo

06:12:23 es el párrafo del que dice que es «exactamente lo que quiero enseñarte»: cuando empiezas a construir RAG, los volúmenes de datos son minúsculos y todas las cifras parecen ridículamente pequeñas, así que nunca te das cuenta de la arquitectura con la que te estás comprometiendo.

«Así que piensa siempre en escala, no en números pequeños». 06:12:23

Se aplica dos veces en este capítulo y merece la pena interiorizar las dos:

  • Coste. $0.255 frente a $0.010 por query parece nada. Multiplícalo por 10,000 queries/día

y 30 días y son $73,500/mes de gasto evitable.

  • Latencia. Una demo de 2,500 tokens no muestra ninguna diferencia (incluso una negativa). Con 100K+

tokens se convierte en el 1 s frente a 45 s de la tabla inicial.

Conclusiones clave, tal como las imprime el script:

  1. RAG NO ha muerto: es una cuestión de coste y latencia a escala.
  2. El contexto largo gana con documentos pequeños, poco volumen y análisis del documento entero.
  3. RAG gana con corpus grandes, mucho volumen y queries concretas.
  4. Enfoque híbrido: RAG para encontrar documentos, contexto largo para analizarlos.
  5. El futuro es usar AMBOS de forma estratégica.

2. Contextual retrieval: arregla el chunk antes de generar su embedding

2.1 La enfermedad

La Parte 3 estableció que el chunking es arquitectura. Esto es la secuela: incluso un chunk dividido correctamente puede ser irrecuperable, porque dividir separa al chunk del documento que le daba sentido.

«cuando haces chunking, cada uno de estos chunks pierde su contexto». 06:15:33

Su ejemplo canónico: un chunk que dice «la política de la empresa establece…»: ¿qué empresa? ¿qué política? El docstring del archivo lo plantea como «La empresa se fundó en 1994»: ¿qué empresa? ¿De qué documento sale esto? El chunk es cierto en los hechos y completamente imposible de atribuir.

El fallo es mecánico, no misterioso. 06:20:42 Un usuario pregunta «¿Cuáles son los ingresos de ACME?» El chunk que contiene la respuesta dice:

«Los ingresos del ejercicio fiscal 2025 alcanzaron los $4.2 mil millones, lo que supone un aumento del 15% respecto al año anterior».

El token ACME no aparece nunca. Ni el matching léxico ni el semántico tienen nada a lo que agarrarse. Los pronombres y las descripciones definidas («la empresa», «ellos», «lo») son la forma general de este bug, y están por todas partes en los corpus reales: informes anuales, manuales de políticas, documentación técnica, cualquier cosa con un título que el cuerpo del texto nunca repite.

demonstrate_context_loss() imprime la enfermedad sin ninguna llamada a la API: un ACME Corporation Annual Report 2025 con tres secciones (Company Overview / Financial Highlights / Future Outlook), reducido a tres chunks huérfanos a propósito:

  1. «La empresa está especializada en fabricar equipos industriales para el sector minero».

→ ¿qué empresa?

  1. *«Los ingresos del ejercicio fiscal 2025 alcanzaron los $4.2 mil millones, lo que supone un aumento del 15% respecto al

año anterior».* → ¿de qué empresa?

  1. «La empresa planea expandirse a equipos de energías renovables en 2026». → ¿los planes de qué

empresa?

Los dos documentos de la demo, completos: reprodúcelos para obtener las mismas cifras

Documento 1: el ACME Corporation Annual Report 2025 (lo usan demonstrate_context_loss(), demonstrate_contextual_retrieval() y compare_retrieval()):

text
ACME Corporation Annual Report 2025

Company Overview:
ACME Corporation was founded in 1994 in San Francisco. The company
specializes in manufacturing industrial equipment for the mining sector.

Financial Highlights:
Revenue for fiscal year 2025 reached $4.2 billion, representing a 15%
increase from the previous year. The company's profit margin improved
to 18%, up from 14% in 2024.

Future Outlook:
The company plans to expand into renewable energy equipment in 2026.
A new manufacturing facility will open in Austin, Texas. The company
expects revenue growth of 20% in the coming fiscal year.

(El «revenue for fiscal year 2005» de la transcripción es un error de audición de 2025).

Documento 2: la nota de prensa de la Series B de TechStartup Inc. (la usa demo_production_pipeline(), metadata={"title": "TechStartup Inc. Series B Announcement", "source": "press_release.pdf"}): una empresa de infraestructura de IA con sede en Seattle cierra una Series B de $45 millones liderada por Sequoia Capital con participación de Andreessen Horowitz; la CEO Jane Smith prevé duplicar la plantilla antes de que acabe 2026; el producto estrella, AIFlow, ayuda a las empresas a desplegar y gestionar LLMs en producción y da servicio a más de 200 clientes enterprise.

Fíjate en cómo están escritos los dos documentos: el nombre de la entidad aparece una vez, en el primer párrafo, y todas las frases siguientes dicen «la empresa». No es un artificio: así es como se escriben de verdad los informes anuales, las notas de prensa y los manuales de políticas.

2.2 El mecanismo, y las dos palabras que importan

El contextual retrieval lo publicó Anthropic a finales de 2024 06:17:36. La técnica cabe en una frase:

«usa un LLM para anteponer contexto a cada uno de estos chunks antes de generar el embedding. La clave aquí es antes de generar el embedding». 06:16:35

Ese es todo el detalle clave de la lección. El contexto añadido:

  • lo genera un LLM, no sale de una plantilla de metadatos: el modelo lee el documento entero

y escribe una frase que sitúa el chunk;

  • se concatena al texto del chunk antes de la llamada de embedding, de modo que el propio vector

codifica los hechos a nivel de documento.

Lo que lleva el prefijo: información a nivel de documento (título, nombre del informe, año, organización) e información a nivel de sección (en qué parte del documento está este chunk), además de resolver las entidades a las que apuntan los pronombres del chunk. La unidad recuperable ya responde por sí sola a «¿qué empresa?».

2.3 La función principal, completa

Esta es la técnica entera. Es un prompt template y una chain LCEL de dos nodos: aquí no hay ningún subsistema a medida.

Python
# fcc-production-rag-part-6/02_contextual_retrieval.py — add_contextual_prefix()
def add_contextual_prefix(
    chunk: str, full_document: str, document_title: str, llm: ChatOpenAI
) -> str:
    """
    Use LLM to generate a contextual prefix for a chunk.

    This is the core of Contextual Retrieval:
    - Give the LLM the full document and the specific chunk
    - Ask it to write a brief context that situates the chunk
    - Prepend this context to the chunk before embedding
    """

    prompt = ChatPromptTemplate.from_messages(
        [
            (
                "system",
                """You are an expert at adding context to document chunks.

Given a document and a specific chunk from that document, write a SHORT
context (1-2 sentences) that helps situate the chunk within the document.

The context should include:
- The document title/source if relevant
- Key entities mentioned earlier in the document
- Any important context that helps understand this chunk

Keep it brief - just enough to disambiguate the chunk.
Output ONLY the contextual prefix, nothing else.""",
            ),
            (
                "human",
                """Document Title: {title}

Full Document:
{document}

Chunk to contextualize:
{chunk}

Write a brief contextual prefix for this chunk:""",
            ),
        ]
    )

    chain = prompt | llm
    response = chain.invoke(
        {"title": document_title, "document": full_document, "chunk": chunk}
    )

    return response.content

Tres cosas de ese prompt son clave y merece la pena copiarlas literalmente:

  • «1-2 sentences» y «Keep it brief»: el prefijo infla cada chunk, así que su

longitud es un coste que pagas para siempre (mira el §2.7).

  • «Key entities mentioned earlier in the document»: esta es la instrucción que

resuelve la correferencia. Es la razón por la que «the company» se convierte en «ACME Corporation».

  • «Output ONLY the contextual prefix, nothing else.»: sin ella, un modelo charlatán

devuelve «Sure! Here's a context for that chunk:» y ese preámbulo se queda embebido como ruido, para siempre, en tu índice.

Las dos instancias de ChatOpenAI del archivo usan model="gpt-4o-mini", temperature=0. Aquí el determinismo importa: generar el contexto es una tarea de extracción, no creativa, y temperature=0 significa que reindexar el mismo corpus produce prefijos casi idénticos en lugar de un conjunto de vectores nuevo cada vez.

Y la única línea que es la técnica; aparece dos veces en el archivo, una en la demo (línea 201, como contextualized) y otra en la función de producción (línea 330, como contextualized_content):

Python
# fcc-production-rag-part-6/02_contextual_retrieval.py:201
contextualized = f"{context_prefix} {chunk}"

La frase original nunca se reescribe ni se destruye. El prefijo es puramente aditivo, y eso es lo que hace que todo sea auditable.

Ejecutarlo sobre los chunks de ACME produce prefijos como estos 06:20:42:

  • Chunk 1 → *«En la sección Company Overview del ACME Corporation Annual Report 2025,

el documento presenta a ACME…»* + texto original

  • Chunk 2 → «…sección Financial Highlights del ACME Corporation…» + texto original
  • Chunk 3 → «En la sección Future Outlook del ACME Corporation Annual Report…» + original

texto

2.4 La función de producción

create_contextual_chunks() sustituye directamente a tu paso de splitter. Es lo que de verdad pones en producción.

Python
# fcc-production-rag-part-6/02_contextual_retrieval.py — create_contextual_chunks()
def create_contextual_chunks(
    documents: list[Document],
    llm: ChatOpenAI,
    chunk_size: int = 500,
    chunk_overlap: int = 100,
) -> list[Document]:
    """
    Production-ready function to create contextualized chunks.

    This is the function you'd use in a real RAG pipeline.
    Note: This adds latency and cost during indexing, but it's a one-time cost.
    """

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=chunk_overlap,
        separators=["\n\n", "\n", ". ", " ", ""],
    )

    contextualized_docs = []

    for doc in documents:
        full_content = doc.page_content
        doc_title = doc.metadata.get(
            "title", doc.metadata.get("source", "Unknown Document")
        )

        chunks = text_splitter.split_text(full_content)

        for i, chunk in enumerate(chunks):
            context_prefix = add_contextual_prefix(
                chunk=chunk,
                full_document=full_content,
                document_title=doc_title,
                llm=llm,
            )

            contextualized_content = f"{context_prefix} {chunk}"

            contextualized_docs.append(
                Document(
                    page_content=contextualized_content,
                    metadata={
                        **doc.metadata,
                        "chunk_index": i,
                        "original_chunk": chunk,
                        "context_prefix": context_prefix,
                    },
                )
            )

    return contextualized_docs

Lee con atención el dict metadata: es la buena idea menos explicada del capítulo:

ClavePor qué existe
**doc.metadatael source, la page y el title del padre se conservan en cada chunk (invariante de la Parte 2: semántica de split_documents, hecha aquí a mano)
chunk_indexposición dentro del padre, para ordenar y expandir a los vecinos
original_chunkel texto sin prefijo, para que puedas generar el embedding de la versión contextualizada pero mostrar y citar la original
context_prefixla cadena exacta que se inventó el LLM, para que puedas auditarla, compararla entre reindexaciones y detectar un modelo que haya empezado a alucinar la procedencia

Fíjate en la cadena de fallback del título: metadata["title"] → metadata["source"] → "Unknown Document". Si tu loader no rellena ninguna de las dos claves, todos los prefijos de tu índice se generarán contra la cadena «Unknown Document»: una regresión de calidad silenciosa sin ningún error asociado.

Los valores por defecto son chunk_size=500, chunk_overlap=100 (un overlap limpio del 20%, en línea con la regla del 10–20% de la Parte 3). La demo de producción la llama con chunk_size=200, chunk_overlap=50 sobre una única nota de prensa de la Series B de TechStartup Inc. y produce 7 chunks 06:23:45. Fíjate en la jerarquía del splitter ["\n\n", "\n", ". ", " ", ""] (párrafos, líneas, frases, palabras, caracteres): el valor por defecto recursivo de la Parte 3.

La parte de retrieval no cambia en absoluto:

Python
# fcc-production-rag-part-6/02_contextual_retrieval.py — demo_production_pipeline()
contextualized_docs = create_contextual_chunks(
    documents=documents, llm=llm, chunk_size=200, chunk_overlap=50
)
print(f"Created {len(contextualized_docs)} contextualized chunks")

vectorstore = Chroma.from_documents(
    documents=contextualized_docs,
    embedding=embeddings,
    collection_name="contextual_demo",
)

query = "How much funding did the Seattle AI company raise?"
results = vectorstore.similarity_search(query, k=2)

Esa query está bien elegida: «the Seattle AI company» no nombra ni a la empresa ni la ronda. Solo un chunk contextualizado puede salvar ese hueco.

El contextual retrieval es un cambio en tu job de indexación, no en tu camino de query. Todos los retrievers, rerankers, chains y prompts posteriores quedan intactos.

2.5 El A/B medido, y cómo leer los scores

compare_retrieval() construye dos colecciones de Chroma a partir de los mismos tres chunks de ACME (una en bruto y otra contextualizada) y lanza las mismas tres queries contra ambas con k=1.

Python
# fcc-production-rag-part-6/02_contextual_retrieval.py — compare_retrieval()
orig_results = vs_original.similarity_search_with_score(query, k=1)
orig_doc, orig_score = orig_results[0]

ctx_results = vs_contextual.similarity_search_with_score(query, k=1)
ctx_doc, ctx_score = ctx_results[0]

# Lower score = better match in Chroma
if ctx_score < orig_score:
    improvement = ((orig_score - ctx_score) / orig_score) * 100
    print(f"\n  -> Contextual retrieval {improvement:.1f}% better match!")
QueryScore originalScore contextualMejora
«What is ACME's revenue?»≈1.14 (dicho en voz alta: «algo más de uno»)0.556%
«What does ACME Corporation manufacture?»1.33≈0.51 (deducido)61.4%
«What are ACME's expansion plans?»≈1.42 (deducido)0.750.6%

Dos de las seis celdas de score nunca se leyeron en voz alta y se han despejado a partir de los porcentajes impresos: están marcadas como deducidas, no leídas en pantalla. Vuelve a ejecutar el script si necesitas los valores exactos.

El patrón que quiere que recuerdes no es un rescate espectacular: las tres queries mejoraron entre un 50 y un 61%, incluidas las dos cuyos chunks objetivo ya compartían vocabulario con la query («manufacture»/«manufacturing», «expansion plans»/«plans to expand»). Añadir los nombres del documento y de la sección ayuda incluso cuando el solapamiento léxico ya existía.

2.6 Las cifras del benchmark, y la corrección que el curso no hace

06:17:36 Dos cifras, atribuidas a la propia investigación de Anthropic:

  • Contextual retrieval solo: 49% menos de fallos de retrieval en el top-20.
  • Contextual retrieval + reranking: 67% menos.

Fallo de retrieval en el top-20, definido: el pasaje correcto no aparece en ninguno de los 20 primeros resultados recuperados. Los porcentajes son reducciones de la tasa de ese evento, no scores de precisión.

Matiza las cifras dos veces, a propósito, y el matiz es la lección más valiosa:

«Recuerda que estas cifras son benchmarks que se sacaron ellos. Podría ser más, podría ser menos». 06:19:40

«Son solo benchmarks. Así que tienes que probarlo por tu cuenta». 06:24:26

2.7 Consideraciones de producción: el camino de escritura lo paga todo

El script imprime cuatro, y son la contabilidad honesta de costes de la técnica:

ConsideraciónCifraDónde recae
Coste$0.01–$0.05 por documento para generar el contextoúnico, en la indexación
Latencia1–2 s por chunk durante la indexaciónúnico, en la indexación: procesa en batch offline
Latencia de queryningún impactoel camino de lectura no se toca
Almacenamientolos chunks son ~20–30% más grandes«impacto mínimo en los costes de la base de datos vectorial»

«Es un coste único en tiempo de indexación, que sale mucho más barato que los fallos de retrieval». 06:23:45

El argumento económico es el correcto: pagas una vez por documento, para siempre, frente a pagar una y otra vez en respuestas erróneas, escalados a soporte y confianza erosionada. Y la asimetría es total: todo el coste y toda la latencia recaen en el camino de escritura.

Sobre el crecimiento del 20–30% 06:24:26: el LLM añade texto literalmente, así que los chunks crecen. El almacenamiento crece; la dimensión del embedding, que es lo que domina el coste de la base de datos vectorial, no. Por eso dice que el impacto en almacenamiento es mínimo. Lo que no menciona es el coste del lado del prompt: un retrieval top-5 mete ahora ~25% más de texto en cada prompt de respuesta, en cada request, para siempre. Ese sí que recae, al final, en el camino de lectura.

2.8 Cuándo activarlo

Tres disparadores 06:24:26. Si se cumple cualquiera de ellos, probablemente el contextual retrieval compensa su llamada al LLM por chunk; si no se cumple ninguno, probablemente no.

  1. El contexto importante vive en cabeceras/títulos (nombres de informes, encabezados de sección, fechas)

que el cuerpo del chunk nunca repite.

  1. Se hace referencia a las entidades con pronombres o descripciones definidas: «la empresa»,

«ellos», «lo».

  1. Los documentos vienen de varias fuentes, así que un chunk por sí solo no puede identificar su propia

procedencia y los resultados de corpus distintos se mezclan.

Las seis conclusiones clave impresas (te dice que pares el vídeo y las leas):

  1. Los chunks pierden el contexto al separarlos de los documentos.
  2. El Contextual Retrieval añade contexto ANTES de generar el embedding.
  3. Usa un LLM para generar un prefijo de contexto de 1–2 frases.
  4. Coste único en la indexación, mejora permanente del retrieval.
  5. Anthropic reporta 67% menos fallos de retrieval.
  6. Combínalo con búsqueda híbrida BM25 para obtener los mejores resultados.

La conclusión 6 remite directamente a la Parte 6. En el diseño original de Anthropic, la técnica es «Contextual Embeddings + Contextual BM25»: indexas el texto contextualizado tanto de forma léxica como vectorial. Si construiste el retriever híbrido de la Parte 6, aliméntalo con el texto contextualizado en las dos ramas; eso es lo que mide realmente la cifra del 49%.

3. Late chunking: primero el embedding, después la división

3.1 El giro

«El late chunking es una técnica más reciente que le da la vuelta al chunking tradicional». 06:25:30

Esa es toda la idea, y merece la pena apreciar lo pequeña que es:

  • Chunking temprano / tradicional: divides el texto → generas el embedding de cada chunk de forma independiente.
  • Late chunking: generas el embedding del documento entero en un solo forward pass → después divides los

token embeddings resultantes por posición → haces pooling de cada tramo en un único vector de chunk.

No cambia nada más. El mismo vector store, el mismo retriever, el mismo k, el mismo reranker, los mismos prompts. El índice incluso parece idéntico: el mismo número de vectores, las mismas dimensiones. Solo cambian los números dentro de los vectores.

La diapositiva dibujada a mano que se queda en pantalla durante todo el segmento conceptual. Fíjate en qué se diferencian realmente las dos mitades: en la fila de arriba, cada uno de los tres chunks tiene su propio cerebro, dibujado por separado, con un eslabón de cadena roto («context lost»); la fila de abajo tiene un solo cerebro dentro de la caja «Embed ALL tokens first», con flechas que salen de cada token hacia todos los demás: ese abanico es la self-attention, y es todo el mecanismo. La fila He / John / It / Project bajo los chunks divididos es la recompensa: la correferencia se resuelve antes de la división, así que sobrevive a ella.
Figura 1La diapositiva dibujada a mano que se queda en pantalla durante todo el segmento conceptual. Fíjate en qué se diferencian realmente las dos mitades: en la fila de arriba, cada uno de los tres chunks tiene su propio cerebro, dibujado por separado, con un eslabón de cadena roto («context lost»); la fila de abajo tiene un solo cerebro dentro de la caja «Embed ALL tokens first», con flechas que salen de cada token hacia todos los demás: ese abanico es la self-attention, y es todo el mecanismo. La fila He / John / It / Project bajo los chunks divididos es la recompensa: la correferencia se resuelve antes de la división, así que sobrevive a ella.

Por qué funciona se explica con una frase de mecánica de transformers. Cuando el modelo hace un forward pass sobre el documento entero, la atención permite que cada token vea a todos los demás. El token «He» del párrafo tres se calcula en presencia de «Steve Jobs» del párrafo uno, así que su vector ya lleva esa asociación. Divide esos vectores de token después y el vector agregado de cada chunk hereda un contexto de todo el documento que un embedding independiente del mismo texto nunca podría tener.

«cada uno de estos chunks o vectores, porque ahora son embeddings, conoce el documento entero». 06:33:38

Hacen falta dos términos, porque el curso los usa sin definirlos. Los token embeddings (embeddings a nivel de token) son los vectores por token que un transformer produce internamente, antes de que el modelo los agregue en el único vector que te devuelve una API de embeddings. El pooling es esa reducción: promediar (o combinar de otro modo) los vectores de token que caen dentro del tramo de un chunk en un único vector de chunk. En el diagrama ASCII del script, los late chunks se etiquetan como Vector 1 (pooled), Vector 2 (pooled), Vector 3 (pooled): la división produce embeddings, y cada grupo se agrega mediante pooling en un vector de chunk, que es lo que acaba en la base de datos.

La mejora declarada: +10–12% de precisión en tareas de retrieval. Esa cifra aparece en el recuadro verde de la diapositiva, en el docstring del módulo, en la tabla comparativa y en la conclusión n.º 4. En 06:27:31 dice «del 10 al 20%» una vez: un lapsus verbal que contradice todos los materiales escritos, probablemente mezclado con el +15–20% del contextual retrieval. Usa 10–12%.

3.2 El fallo que corrige, hecho contable

Lo mejor de este capítulo es una demo que demuestra el fallo con una comprobación de subcadena y sin ninguna llamada a la API. El documento de prueba es una biografía de Steve Jobs diseñada para que el párrafo 1 lo nombre y los párrafos 2–4 empiecen todos por «He».

Python
# fcc-production-rag-part-6/03_late_chunking.py — demonstrate_early_chunking_problem()
# (the document literal keeps the source file's 4-space indentation — those spaces are
#  part of the text and they count toward chunk_size)
document = """
    Steve Jobs was born in San Francisco in 1955. He was adopted
    by Paul and Clara Jobs shortly after birth.

    He co-founded Apple Computer in 1976 with Steve Wozniak.
    The company started in his parents' garage. He served as CEO
    until 1985 when he was ousted from the company he created.

    He then founded NeXT Computer and acquired Pixar Animation Studios.
    These ventures would later prove instrumental in his return to Apple.

    He returned to Apple in 1997 and transformed it into one of the
    most valuable companies in the world. He introduced the iPod, iPhone,
    and iPad, revolutionizing multiple industries.
    """

# Simulate early chunking
splitter = RecursiveCharacterTextSplitter(
    chunk_size=200,
    chunk_overlap=0,  # No overlap to show the problem clearly
    separators=["\n\n", "\n", ". ", " "],
)

chunks = splitter.split_text(document)

for i, chunk in enumerate(chunks, 1):
    # Check if "Steve Jobs" appears in this chunk
    has_name = "Steve Jobs" in chunk
    pronoun_count = chunk.lower().count(" he ")

    print(f"\nChunk {i}:")
    print(f'  "{chunk.strip()[:80]}..."')
    print(
        f"  Contains 'Steve Jobs': {'Yes' if has_name else 'NO - Just pronouns!'}"
    )
    print(f"  Pronoun 'he' count: {pronoun_count}")

La ejecución produce cuatro chunks 06:30:34–06:31:35:

ChunkTexto inicialContiene «Steve Jobs»Recuento de " he "
1«Steve Jobs was born in San Francisco in 1955…»Sí1
2«He co-founded Apple Computer in 1976 with Steve Wozniak…»NO – ¡Solo pronombres!3
3«He then founded NeXT Computer and acquired Pixar…»NO0
4«He returned to Apple in 1997…»NO1

Tres de cada cuatro chunks no se pueden encontrar por el nombre. El argumento impreso:

text
Chunks 2, 3, 4 only contain "he" - no "Steve Jobs"!

When embedding these chunks separately:
- Query: "What companies did Steve Jobs found?"
- Chunk 2 mentions "co-founded Apple" but says "He co-founded"
- Embedding of "He co-founded" won't match "Steve Jobs founded"

The pronoun "he" loses its referent when chunked separately.

La información está en el corpus y aun así no se puede recuperar. Es el fallo silencioso del invariante 4 en su forma más pura: nada da error, nada queda en los logs, el usuario simplemente recibe una respuesta peor. La versión genérica que narra en 06:26:31 (solo hablada, sin ningún material detrás) es un comunicado corporativo cortado de modo que un chunk empieza por «Dijo que entraría en vigor de inmediato» mientras el CEO que lo dijo está en el chunk anterior. Es el mismo bug, y es la forma que producen la mayoría de los corpus reales.

3.3 Los dos flujos, uno al lado del otro

visualize_chunking_approaches() imprime la diapositiva como un par de diagramas de flujo ASCII. Aquí se condensa en una línea por etapa: las etiquetas son literales del script, el dibujo de las cajas no:

Figura 2Early vs late chunking: hacer embedding de cada chunk aislado o con el contexto del documento entero
ASCII original
EARLY CHUNKING (Traditional):
Full Document ─► [Split Text] ─► Chunk 1 | Chunk 2 | Chunk 3
                                    │        │        │
                                 [Embed]  [Embed]  [Embed]
                                    ▼        ▼        ▼
                                Vector 1 | Vector 2 | Vector 3

"Each chunk embedded INDEPENDENTLY - no cross-chunk context!"

LATE CHUNKING (Context-Preserving):
Full Document ─► [Embed FULL Document]
                      ▼
        Full Document Token Embeddings
        [tok1] [tok2] [tok3] ... [tok_n]
        "Each token has FULL document context via attention"
                      ▼
        [Split Embeddings by Position]
                      ▼
          Vector 1  |  Vector 2  |  Vector 3
          (pooled)     (pooled)     (pooled)

"Each chunk vector KNOWS about the whole document!"
"'He' in chunk 2 is embedded with knowledge that 'He' = 'Steve Jobs'"

«Cada chunk, como digo aquí, es su propia entidad. Su embedding se genera de forma independiente. Así que no hay contexto entre chunks». 06:32:36

El aislamiento es la causa raíz y es estructural. Ninguna mejora del retrieval (ni un reranker, ni reescribir la query, ni k=50) arregla un embedding que se calculó a ciegas. Es otra vez el invariante 1: la calidad se hereda hacia delante y nunca se recupera aguas abajo.

La ley general que extrae de ello, en dos citas cortas 06:27:31:

«todo está ligado al contexto, porque los modelos de lenguaje grandes necesitan contexto».

«da igual lo superior que sea el modelo, siempre acabarás con resultados subóptimos».

La calidad del modelo no sustituye a la calidad del contexto. Y el modelo mental con el que quedarte: «piensa en ello como tener las ideas correctas, los pensamientos completos, en cada uno de los chunks».

3.4 La simulación, y lo que demuestra y no demuestra

Aquí el curso choca con una limitación dura y, hay que reconocérselo, lo dice en voz alta. La API de embeddings de OpenAI no expone los token embeddings. Obtienes un único vector agregado por cada cadena de entrada. Por tanto, el late chunking de verdad es imposible con ella. Así que el script simula el efecto anteponiendo una cadena de contexto y volviendo a generar el embedding:

Python
# fcc-production-rag-part-6/03_late_chunking.py — simulate_late_chunking()
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

chunk1 = "Steve Jobs was born in San Francisco in 1955. He was adopted by Paul and Clara Jobs shortly after birth."
chunk2 = "He co-founded Apple Computer in 1976 with Steve Wozniak. The company started in his parents' garage."

query = "What company did Steve Jobs found?"

# Early chunking: embed chunks separately
chunk2_embedding_early = embeddings.embed_query(chunk2)
query_embedding = embeddings.embed_query(query)
similarity_early = np.dot(chunk2_embedding_early, query_embedding)

# Late chunking simulation: embed chunk WITH context prepended
chunk2_with_context = (
    f"[Context: This is about Steve Jobs, founder of Apple] {chunk2}"
)
chunk2_embedding_late = embeddings.embed_query(chunk2_with_context)
similarity_late = np.dot(chunk2_embedding_late, query_embedding)

improvement = ((similarity_late - similarity_early) / similarity_early) * 100
print(f"\nImprovement: {improvement:.1f}%")

print("NOTE: This is a SIMULATION using context prepending.")
print("True late chunking uses token-level embeddings from")
print("models like Jina that support this natively.")

El resultado 06:34:39: 0.6857 → 0.6871, impreso como Improvement: 0.2%.

«Hay una pequeña mejora. Aun así, sigue siendo una mejora del 0.2%». 06:34:39

(La función también define una cadena document y un chunk1 y no usa ninguno de los dos: son decorado. Solo se generan embeddings de chunk2 y de query).

Su explicación de en qué consiste realmente la mejora, en 06:33:38: la query decía «Steve Jobs», no «he», y aun así el retrieval encontró el match, porque el vector del chunk sabe que «he» se refiere a Steve Jobs.

3.5 Implementarlo de verdad

show_implementation_options() imprime cuatro opciones. Dos de ellas tienen problemas reales con las versiones actuales de las librerías y una ni siquiera es late chunking, así que lee el código y después lee las correcciones.

Opción 1: embeddings de Jina, late chunking nativo. Tal como lo imprime el script:

Python
# fcc-production-rag-part-6/03_late_chunking.py — OPTION 1, AS PRINTED (see warning below)
from langchain_community.embeddings import JinaEmbeddings

embeddings = JinaEmbeddings(
    model_name="jina-embeddings-v3",
    late_chunking=True  # Enable late chunking
)

Pros: soporte nativo, la mejor calidad. Contras: otro modelo, puede requerir una API key.

Fíjate también en la restricción que el capítulo nunca menciona:

Opción 2: contextual retrieval (§2 de esta parte), reproducida aquí como alternativa agnóstica del modelo: context = generate_context(chunk, full_document), contextualized_chunk = f"{context} {chunk}", y generas el embedding de eso. Pros: funciona con cualquier embedding model. Contras: coste de LLM añadido en tiempo de indexación.

Opción 3: Parent Document Retriever. El fragmento impreso tiene un import obsoleto:

Python
# fcc-production-rag-part-6/03_late_chunking.py — OPTION 3, AS PRINTED. Import is WRONG for LangChain 1.x
from langchain.retrievers import ParentDocumentRetriever

En LangChain 1.2.7, el paquete langchain solo expone agents, chat_models, embeddings, messages, rate_limiters y tools: no existe langchain.retrievers. El import que funciona, y una construcción que funciona, vienen del otro repo:

Python
# production-course-main-code/advanced_rag.py — the CORRECT import and a real working setup
from langchain_classic.retrievers import ParentDocumentRetriever
from langchain_classic.storage import InMemoryStore

parent_splitter = RecursiveCharacterTextSplitter(chunk_size=800, chunk_overlap=100)
child_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=20)

vectorstore = Chroma(
    collection_name="parent_child_demo",
    embedding_function=OpenAIEmbeddings(model="text-embedding-3-small"),
)
store = InMemoryStore()

retriever = ParentDocumentRetriever(
    vectorstore=vectorstore,
    docstore=store,
    child_splitter=child_splitter,
    parent_splitter=parent_splitter,
)

retriever.add_documents([long_doc])

# Search finds a SMALL child chunk...
child_docs = vectorstore.similarity_search(query, k=1)
# ...but the retriever returns the LARGE parent
parent_docs = retriever.invoke(query)

Los hijos pequeños dan un matching preciso; el padre grande le da al LLM espacio para razonar. Su descripción 06:37:42: el retriever recorre la jerarquía padre→hijo y devuelve el padre, que lleva el contexto más completo. (Él lo llama «árbol»; la implementación de LangChain es en realidad un docstore indexado por el id del padre, no una estructura de árbol).

Opción 4: overlap + cabeceras de resumen. La versión de andar por casa, y la que ya deberías estar haciendo:

Python
# fcc-production-rag-part-6/03_late_chunking.py — OPTION 4
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=100  # Overlap captures some context
)

# Add document summary to each chunk
for chunk in chunks:
    chunk.page_content = f"[From: {doc_title}] {chunk.page_content}"

Pros: sencilla, sin coste extra. Contras: preservación del contexto limitada. Fíjate en que esto es contextual retrieval con una plantilla en lugar de un LLM: mete gratis el título del documento en el vector, y nada más. Merece la pena hacerlo el primer día de cualquier proyecto, porque cuesta un formateo de cadena y te resuelve la mitad «¿qué documento?» del problema.

4. El marcador: cinco enfoques, y por qué apilarlos

4.1 La tabla comparativa

La comparación que print_comparison() muestra en el terminal, no una diapositiva; por eso puedes reproducirla en local con uv run python 03_late_chunking.py. Lee las dos columnas como calidad frente a qué tipo de coste: las tres últimas filas tienen tres estrellas en calidad, y solo se diferencian en la moneda con la que te cobran: dólares por documento, dependencia de un modelo o almacenamiento.
Figura 3La comparación que print_comparison() muestra en el terminal, no una diapositiva; por eso puedes reproducirla en local con uv run python 03_late_chunking.py. Lee las dos columnas como calidad frente a qué tipo de coste: las tres últimas filas tienen tres estrellas en calidad, y solo se diferencian en la moneda con la que te cobran: dólares por documento, dependencia de un modelo o almacenamiento.
EnfoqueCalidad del contextoCoste de implementación
Chunking temprano (tradicional)★☆☆ Mala: pronombres huérfanos★★★ Gratis: enfoque estándar
Chunks con overlap★★☆ Mejor: se conserva algo de contexto★★★ Gratis: solo un cambio de configuración
Contextual retrieval★★★ Excelente: el LLM añade contexto★★☆ Coste de LLM ~$0.01/doc
Late chunking (nativo)★★★ Excelente: contexto del documento entero★★☆ Modelo especial: Jina o similar
Retriever padre-hijo★★★ Excelente: devuelve el documento padre★★☆ Almacenamiento extra: 2× vector store

Su explicación de huérfano 06:36:42: «no están vinculados a un padre… no tienen ninguna correlación que apunte al otro fragmento de datos con el que están conectados por contexto». Sobre los chunks con overlap: «Es mejor porque conservamos algo de contexto. El coste de implementación también es gratis: solo tienes que configurar un par de cosas». Sobre la columna de coste del late chunking: el precio es la dependencia del modelo (vendor lock-in), no dólares.

4.2 El marcador de precisión

Las cuatro cifras que esta parte existe para entregar. La que debería cambiar tu plan es la última: +25–30% combinadas, que es más que cualquier técnica por separado y que, como señalan las notas del capítulo, el curso afirma y nunca demuestra ni mide en ningún sitio.
Figura 4Las cuatro cifras que esta parte existe para entregar. La que debería cambiar tu plan es la última: +25–30% combinadas, que es más que cualquier técnica por separado y que, como señalan las notas del capítulo, el curso afirma y nunca demuestra ni mide en ningún sitio.
TécnicaMejora de precisión frente al chunking tradicional
Chunks con overlap+3–5%
Contextual retrieval+15–20%
Late chunking+10–12%
Enfoques combinados+25–30%

Fíjate en que el +15–20% de aquí es más alto que nada de lo que el capítulo 25 narró sobre el contextual retrieval: las dos lecciones citan métricas distintas (reducción de fallos de retrieval allí, ganancia de precisión aquí) y nunca las concilian. Dos observaciones que el curso no hace de forma explícita, y las dos cambian lo que deberías construir:

4.3 Apila, no elijas

«No se trata de elegir una sola estrategia o enfoque y tirar con eso». 06:38:42

06:38:42 Su planteamiento estratégico: a nivel de producción quieres elegir todas estas estrategias, para acabar con un sistema híbrido que las use todas. La fila del +25–30% es el argumento.

El orden de recomendación del propio código, que es el material más accionable del capítulo:

  1. Empieza por el Contextual Retrieval (lección 6.2): funciona con cualquier embedding model.
  2. Si usas Jina, activa el late chunking nativo.
  3. Combínalo con el Parent Document Retriever para obtener los mejores resultados.
  4. Usa siempre un chunk overlap significativo (10–20%).

Léelo como un orden de construcción, no como un menú. El paso 4 es gratis y ya deberías tenerlo desde la Parte 3. El paso 1 es un cambio en tu job de indexación. El paso 3 es un cambio en tu retriever. El paso 2 es un cambio de proveedor de embeddings, el cambio más invasivo de la lista, y por eso es condicional y está en penúltimo lugar.

La pantalla de cierre de la lección. Merece la pena fijarse en el detalle del pie: fcc-production-rag on main took 4s; toda esta lección se ejecuta en cuatro segundos porque solo simulate_late_chunking() toca una API. La lección de contextual retrieval anterior tardó 19s, y esa diferencia es el perfil de costes de la técnica en miniatura.
Figura 5La pantalla de cierre de la lección. Merece la pena fijarse en el detalle del pie: fcc-production-rag on main took 4s; toda esta lección se ejecuta en cuatro segundos porque solo simulate_late_chunking() toca una API. La lección de contextual retrieval anterior tardó 19s, y esa diferencia es el perfil de costes de la técnica en miniatura.

Las seis conclusiones clave, literales de la pantalla:

  1. El chunking temprano pierde las referencias de los pronombres («he», «the company»).
  2. El late chunking genera el embedding del documento completo y después divide los embeddings.
  3. El embedding de cada chunk «conoce» el documento entero.
  4. 10–12% de mejora de precisión en tareas de retrieval.
  5. Opciones: Jina nativo, Contextual Retrieval, padre-hijo.
  6. Combina varios enfoques para obtener los mejores resultados.

4.4 Dónde pasa el testigo

El capítulo de la fuente se sale de su propio tema: los últimos dos minutos y medio del capítulo 26 (06:39:44–06:42:04) ya son la diapositiva conceptual de Agentic RAG, y se corta a mitad de frase («Cuando llega la query, el…»), que retoma el capítulo siguiente. Ese material pertenece a las partes agénticas de esta guía, no a esta, pero merece la pena llevarse el adelanto de una línea:

«Hoy en día el RAG en producción no es solo un pipeline fijo que va A, B, C… ahora en el centro de todo tienes un agente». 06:39:44

Todo lo de la Parte 14 sigue siendo un pipeline fijo: decides en tiempo de indexación qué técnica aplicar, y el camino de query ejecuta los mismos pasos cada vez. La siguiente frontera es un bucle de retrieval que evalúa sus propios resultados y vuelve a lanzar la query cuando son malos, que es hacia donde va esta guía a continuación.

5. Diagnósticos que puedes ejecutar esta semana

Dos procedimientos, ambos baratos, ambos te dan pruebas en lugar de intuiciones.

5.1 Cuenta los huérfanos de tu propio corpus

Generalizado a partir de la demo de Steve Jobs. No cuesta nada: ninguna llamada a la API.

  1. Divide un documento representativo con la configuración de splitter de producción (no con el

chunk_overlap=0 de la demo).

  1. Para cada chunk, comprueba si aparece en él el nombre canónico de la entidad.
  2. Cuenta los pronombres y las referencias definidas en columnas separadas: he, him, his, she,

her, they, them, it, the company, the report. Usa una regex con límites de palabra, no count(" he "): mira el bug del §3.2.

  1. Cualquier chunk con pronombres pero sin el nombre es un chunk que tus embeddings no pueden encontrar por el nombre.

En la demo son 3 de 4. Si es una fracción significativa de tu corpus, el contextual retrieval se pagará solo.

5.2 Simula el beneficio antes de comprar un embedding model nuevo

  1. Elige un chunk que empiece por un pronombre y una query que nombre a la entidad.
  2. Genera el embedding de la query y del chunk aislado; calcula el producto escalar → línea base.
  3. Antepón una cadena de contexto de una línea, vuelve a generar el embedding y calcula otra vez el producto escalar.
  4. improvement = ((late - early) / early) * 100.
  5. Espera una cifra pequeña (0.2% en la ejecución del curso). Esto solo demuestra la dirección. Si

quieres la magnitud, ejecuta un eval de retrieval real sobre un conjunto etiquetado de queries/pasajes (la disciplina de medición de la Parte 7), no un producto escalar de un solo par.

5.3 Reproduce las tres lecciones

bash
cd fcc-production-rag-part-6           # requires OPENAI_API_KEY in .env
uv run python 01_long_context_vs_rag.py   # cost math, latency, framework, hybrid demo
uv run python 02_contextual_retrieval.py  # ~19s, real LLM + embedding calls
uv run python 03_late_chunking.py         # ~4s, three embed_query calls in the simulation

Entorno, sacado de los metadatos del repo y no del README (que dice Python 3.10+ y se equivoca): .python-version = 3.13 y pyproject.toml requires-python >= 3.13, que fija langchain>=1.2.0,<2.0.0, langchain-openai>=1.1.0, langchain-chroma>=1.1.0, langchain-text-splitters>=1.1.2, openai>=2.32.0, tiktoken>=0.12.0, networkx, python-dotenv. requirements.txt añade lo que pyproject.toml omite (chromadb>=1.5.0, langchain-classic>=1.0.0, langgraph>=1.1.0) e incluye en la cabecera la regla «use langchain-chroma, NOT langchain-community» para el vector store. La grabación de pantalla muestra Python 3.12.2 en VS Code, así que el README, pyproject.toml y el entorno grabado no coinciden entre sí. Fíate de pyproject.toml.

6. Decisiones que tomar

Recorre esta lista en orden. Cada fila es una decisión con un valor por defecto, no una sugerencia.

#DecisiónPor defecto / disparador
1¿RAG o contexto largo para este corpus?Corpus de <50K tokens y <100 queries/día y preguntas sobre el documento entero → contexto largo. Si no, RAG. Ante cualquier ambigüedad → RAG, porque se degrada con elegancia a medida que crece el corpus.
2Haz la aritmética de escala antes de comprometerte.Calcula el coste/query y luego ×volumen×30. Si la diferencia mensual es menor que una hora de ingeniero, cualquiera de los dos diseños vale; en cuanto deja de serlo, la arquitectura es una decisión financiera, no de gustos.
3Presupuesta contra el límite de contexto *efectivo*.60–70% de la ventana anunciada. Con un modelo de 1M, planifica para 600–700K.
4Añade el patrón de selector híbrido.Si los usuarios hacen preguntas sobre el documento entero acerca de uno entre muchos documentos: retrieval con k=1 → carga el documento completo → responde. La gran mejora más barata de esta parte.
5Haz el recuento de huérfanos (§5.1).Si una minoría importante de chunks lleva pronombres sin su referente, activa el contextual retrieval. Mide la fracción; no la adivines.
6Activa el contextual retrieval si salta cualquier disparador.Contexto en cabeceras/títulos · entidades referidas con pronombres · corpus de varias fuentes.
7Presupuesta la contextualización con honestidad.$0.01–$0.05/doc es un suelo. Coste real ≈ chunks × longitud del documento en tokens de entrada. Añade prompt caching y batch APIs antes de ejecutarlo sobre un corpus grande: el curso no cubre ninguna de las dos cosas.
8Haz la contextualización asíncrona.1–2 s/chunk. Mételo en una cola. Nunca lo hagas en línea dentro de una request de subida.
9Guarda original_chunk y context_prefix en los metadatos.Genera el embedding del texto contextualizado, cita el original, audita el prefijo. Innegociable.
10Rellena title o source en cada documento cargado.create_contextual_chunks() recurre a la cadena literal «Unknown Document» y genera todos los prefijos contra ella. Es silencioso y envenena el índice entero.
11Indexa también el texto contextualizado en BM25.Conclusión n.º 6. La cifra del 49% de Anthropic corresponde a embeddings + BM25 contextual, no a embeddings solos.
12Prevé un crecimiento del 20–30% de los chunks.El impacto en almacenamiento es mínimo; en el prompt, no. Un retrieval top-5 mete ahora ~25% más de texto en cada prompt de respuesta. Revisa el presupuesto de tokens de la Parte 9.
13Late chunking: solo con un modelo que lo soporte de verdad.Comprueba que el cuerpo de la request lleva de verdad late_chunking. El wrapper comunitario de LangChain lo descarta en silencio.
14Comprueba que tus documentos caben en la ventana del embedder.El late chunking necesita el documento entero en un solo forward pass. Lee la model card para conocer el límite real; si lo superas, vuelves a estar segmentando y eligiendo fronteras de segmento.
15Pon el padre-hijo encima de lo que hayas elegido.Corrige otro eje (lo que se devuelve) y cuesta 2× de almacenamiento vectorial. Usa langchain_classic.retrievers, no langchain.retrievers.
16Mantén siempre un chunk overlap del 10–20%.+3–5% por un cambio de configuración. No hay ningún argumento en contra.
17Mide tus propias cifras.Todas las cifras de esta parte (1,200×, 25×, 49%, 67%, +10–12%, +15–20%, +25–30%) son orientativas. «Son solo benchmarks. Así que tienes que probarlo por tu cuenta». 06:24:26

Las tres técnicas de esta parte compran lo mismo: un chunk que se puede encontrar con una pregunta formulada como la formularía una persona. El contexto largo lo compra no dividiendo nunca. El contextual retrieval lo compra escribiendo las palabras que faltan. El late chunking lo compra generando el embedding antes de dividir. Elige por coste y por restricciones, no por novedad, y recuerda que la opción aburrida y gratuita, un overlap del 10–20%, ya está en el marcador.