oriolrius.me Production RAGGuia de referència
Part 14·Avançat i frontera

Recuperació avançada: context llarg, recuperació contextual i chunking tardà

Context llarg i RAG, recuperació contextual i late chunking: millora què representa cada fragment.

45 min de lectura 34 seccions Avançat i frontera
Resum en àudio · 3:20 · CA
Recuperació avançada: context llarg, recuperació contextual i chunking tardà

Tot el que hem fet fins aquí ha tractat de fer funcionar un pipeline convencional: dividir bé, generar embeddings coherents, recuperar amb amplitud, reordenar, observar, desar en memòria cau i publicar. En aquesta part, el curs gira cap a la frontera de 2026 i comença qüestionant la premissa de tota la guia.

Tres tècniques, tres caselles diferents del model mental:

  • El context llarg pregunta si cal que existeixi la fase A (índex). Si el model pot

llegir un milió de tokens, per què dividir, generar embeddings i emmagatzemar res? La resposta és aritmètica, no ideologia.

  • La recuperació contextual modifica el pas [Contextualize] de la fase A — l'única casella del

diagrama que havia estat buida fins ara. Canvia el text del qual generes l'embedding.

  • El chunking tardà modifica l'ordre Split → Embed de la fase A. Canvia **quan es

calcula l'embedding**.

Totes tres es regeixen per la invariant 3: el cost d'indexació és únic i s'amortitza; el de consulta es repeteix a cada petició. La recuperació contextual i el chunking tardà són apostes pures per aquesta invariant — gasten molt al camí d'escriptura i res al de lectura. El context llarg és l'aposta contrària: saltar-se del tot el camí d'escriptura i pagar per sempre al de lectura. Aquest és tot l'argument d'aquesta part en tres frases.

El codi viu al segon repositori, fcc-production-rag-part-6 (les lliçons 6.1–6.3 d'«Advanced RAG 2026»): 01_long_context_vs_rag.py, 02_contextual_retrieval.py, 03_late_chunking.py. Els capítols 24, 25 i 26 de la font les cobreixen de 06:06:09 a 06:42:04. Tres files de la taula de sis files de la part 6 del README del repositori corresponen a aquesta part:

TècnicaQuè resolMillora declarada
Context llarg enfront de RAGQuan fer servir finestres d'1M de tokens en lloc de recuperacióOptimització de costos
Recuperació contextualFragments que perden el context del document67% menys de fallades de recuperació
Chunking tardàContext entre fragments que es perd als embeddingsMillora de precisió del 10–12%

Pren aquests dos percentatges amb cautela. Al final d'aquesta part sabràs d'on surt cadascun, quina configuració mesura realment i per què el mateix formador del curs et diu dues vegades que els ignoris i mesuris els teus.

1. RAG ha mort? La qüestió del context llarg

1.1 La pregunta i el replantejament

06:06:15 El capítol comença a mitja frase amb la pregunta més habitual que rep el formador: amb models com Gemini que ofereixen finestres d'un milió de tokens, encara necessitem RAG? La seva resposta és negar-se a respondre la pregunta tal com està formulada, repetit tres vegades en vuit minuts:

«No en descartis un en favor de l'altre. Esbrina quan cal fer servir cadascun.» 06:11:20

El mateix script imprimeix el replantejament com a capçalera abans de fer res 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?'")

Defineix els termes amb precisió, perquè altrament la comparació no té sentit. Context llarg, tal com s'utilitza aquí, vol dir ficar tot el corpus a la finestra del prompt a cada consulta, sense cap pas de recuperació — sense divisor, embeddings ni magatzem vectorial. RAG vol dir recuperar de quatre a vuit fragments (~2K tokens) i enviar només això. És una comparació de dues arquitectures, no de dos models.

1.2 La taula comparativa tal com s'explica oralment

DimensióRAGContext llarg
Cost per consultano es diu cap xifra — «molt insignificant per consulta»~$0.10
Latència~1 segon~45 segons
Escalat«il·limitat, de debò»límit de ~1M de tokens
Titular«RAG és més de 1,200 vegades més barat» 06:06:15—

No hi ha cap captura del capítol 24 — INDEX.md l'enumera explícitament a «capítols sense captura» —; per tant, totes les xifres anteriors provenen de la transcripció automàtica, i la cel·la del cost de RAG no es llegeix mai en veu alta. Aquesta xifra s'ha perdut. La parella 1 s enfront de 45 s i la proporció 1,200× deriven de la transcripció i no tenen citació; pren-les com a orientatives.

«És la diferència entre tenir un producte viable i la fallida.» 06:07:16

1.3 L'aritmètica del cost, i per què imprimeix 25× i no 1,200×

calculate_costs() és aritmètica pura. No fa cap crida d'API. Això importa: pots executar-la, canviar-ne les constants i raonar sobre les teves pròpies xifres sense gastar ni un cèntim.

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}"
)

Calcula-ho a mà, perquè l'aritmètica és la lliçó:

MagnitudContext llargRAG (4 × 500)
Tokens d'entrada100,1002,100
Cost d'entrada a $2.50/1M$0.25025$0.00525
Cost de sortida (500 tokens a $10/1M)$0.00500$0.00500
Cost per consulta$0.25525$0.01025
Amb 10,000 consultes/dia$2,552.50/dia$102.50/dia
Diferència mensual (×30)—$73,500.00 d'estalvi

06:11:20 Llegeix la línia impresa en pantalla: «RAG és 25x més barat per consulta» (0.25525 / 0.01025 = 24.9, formatat amb :.0f). Però la diapositiva que havia mostrat cinc minuts abans deia més de 1,200×. Totes dues xifres es diuen en els mateixos vuit minuts i no es reconcilien mai.

Dos paranys més d'aquesta funció que el lector trobarà al cap d'un minut d'executar-la:

1.4 La demostració de latència, i per què no l'hauries de citar

compare_latency() és l'única funció del fitxer que fa crides reals a l'API. Cronometra dues crides llm.invoke(), una amb un context d'una frase i una amb la mateixa frase repetida 50 vegades.

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!")

L'execució en directe 06:12:23 ha produït 1.45 s amb el petit i 1.16 s amb el gran — una diferència de −0.29 s i un missatge imprès de «0.8x més lent». Les xifres de la mateixa demostració diuen que el context llarg ha estat més ràpid.

1.5 El sostre de fiabilitat: una finestra d'1M no són 1M de tokens utilitzables

06:07:16 L'afirmació no monetària més important del capítol:

«Aquests models es tornen poc fiables al voltant del 60 al 70% d'aquest límit.» 06:07:16

La capacitat efectiva i fiable és aproximadament el 60–70% de la finestra anunciada — uns 600K–700K tokens en un model d'1M de tokens. Més enllà, la recuperació dins del context es degrada: la família de fallades de «pèrdua al mig» o deteriorament del context, en què es demostra que el model deixa de prestar atenció a material que ha rebut. El seu plantejament: «això no és només qüestió de diners o d'economia» — fins i tot amb un pressupost infinit, la precisió tota sola ja desaconsella omplir el prompt ingènuament.

Ho afirma com un «fet conegut» i no esmenta cap article ni cap prova comparativa. És coherent amb la literatura publicada sobre context llarg, però, tal com es presenta al curs, és una afirmació sense citació. Pren el 60–70% com una heurística de planificació, no una especificació: una finestra d'un milió de tokens et compra 600–700K tokens d'atenció fiable; per tant, pressuposta amb el límit efectiu, no amb el de màrqueting.

Les llistes orals — on guanya realment cada enfocament

Abans del marc imprès, narra dues llistes informals. En alguns punts difereixen del requadre imprès de l'script, i val la pena tenir-les totes dues.

On guanya realment el context llarg 06:07:16 — «siguem justos, hi ha casos en què els models de context llarg són realment bons»:

  1. Documents petits — documents més petits en conjunt.
  2. Menys de 100K tokens — *«si tens menys de 100k tokens, és una bona manera de

tractar-ho»*. (El requadre imprès diu <50K. Totes dues xifres són a la lliçó.)

  1. Tasques estàtiques i acotades — una tasca amb una entrada que no creix i un abast fix.
  2. Necessites tot el context alhora — raonament sobre el document sencer en què qualsevol límit de fragment

destruiria la resposta: resumeix aquest contracte, troba contradiccions al llarg de tot el document.

On guanya RAG 06:08:17:

  1. Base de coneixement gran — *«molts documents, molta informació que poses

en una base de dades vectorial»*.

  1. Contingut dinàmic i actualitzat sovint — «RAG és realment bo en això». (Contradiu el

requadre imprès; consulta el requadre explicatiu següent.)

  1. Eficiència de costos — «si el sistema és sensible al cost, RAG és el camí».
  2. Precisió — *«si vols un sistema molt precís i molt específic, llavors

RAG guanya clarament» — amb la condició crucial «si tot està muntat correctament»*.

1.6 El marc de decisió

print_decision_framework() imprimeix un requadre ASCII — és una instrucció print de l'script, no una diapositiva —, i és l'artefacte reutilitzable de tot el capítol. Reproduït fidelment, amb les variants orals indicades:

Fes servir context llarg quanFes servir RAG quan
El corpus és petit (<50K tokens) — diu <100K en veu alta a 06:07:16El corpus és gran (>100K tokens)
El volum de consultes és baix (<100 consultes/dia)El volum de consultes és alt (1000s/dia) — diu «centenars» en veu alta a 06:13:23
Necessites analitzar el document SENCEREls usuaris pregunten sobre temes concrets, no fan anàlisi del document sencer
Els documents canvien sovint (sense sobrecàrrega d'embeddings)Els documents són relativament estables
Simplicitat > optimització del costEl cost i la latència importen
—Necessites citacions / seguiment de les fonts

Sobrecàrrega d'embeddings, definida: el cost, la latència i la càrrega operativa de generar embeddings i indexar cada versió d'un document al magatzem vectorial — i repetir-ho sempre que canvia un document. És l'única cosa que el context llarg et permet evitar del tot.

Dues asimetries més que val la pena exposar clarament, perquè el requadre imprès només les suggereix:

  • Les citacions són estructuralment gratuïtes a RAG i estructuralment difícils amb context llarg. A RAG

saps quin fragment ha produït la resposta perquè l'hi has posat tu. Introdueix 100K tokens en un sol bloc i l'atribució es converteix en una segona tasca d'LLM poc fiable.

  • La precisió de RAG és condicional. *«RAG aporta molta precisió **si tot està

muntat correctament**»* 06:08:17. Aquesta condició són les parts 3 a 9 d'aquesta guia. RAG no guanya en precisió per defecte; hi guanya quan el pipeline està ben construït.

1.7 L'enfocament híbrid: RAG selecciona, el context llarg llegeix

La síntesi, presentada al límit del capítol 06:14:29:

«No separis les dues coses — RAG contra context llarg. Digues RAG I context llarg.»

I la frase amb què acaba: «Al capdavall, RAG no ha mort.» El mecanisme té dos passos i és l'estructura cap a la qual haurien de convergir la majoria de sistemes reals:

  1. RAG recupera documents candidats — no fragments a partir dels quals respondre, sinó documents per llegir.
  2. Carrega aquests documents complets a la finestra de context per elaborar la resposta detallada.

L'estructura de consulta que necessita totes dues coses: «parla'm de X, Y i Z, i després analitza a fons aquesta part del corpus». RAG redueix el corpus de deu mil documents a un; després, el context llarg llegeix amb cura el que ha sobreviscut.

demo_hybrid_approach() és la quarta crida de __main__; per tant, sí que s'executa — però la narració s'atura després del marc de decisió i no en parla mai, de manera que aquest és l'únic lloc on el lector la veurà explicada. El detall fonamental és 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 fa una cosa poc habitual i deliberada: aquí la recuperació tria el document, no la resposta. Els tres documents de demostració estan escrits com a polítiques completes amb seccions 1–4 (remote_work_policy.pdf, expense_policy.pdf, pto_policy.pdf), tots etiquetats doc_type: "policy"; per tant, «carregar el document complet» és una acció amb sentit. La consulta — *treballar des de casa i quin equip rebo* — abasta deliberadament la secció 2 i la secció 3 d'un document, exactament la pregunta que una recuperació dels primers k fragments respon malament i una lectura del document sencer respon perfectament.

El corpus sintètic de recursos humans, per si vols reproduir l'execució

Són valors de les dades de prova, no paràmetres RAG — però reprodueix-los exactament si vols el mateix comportament de recuperació.

  • Política de teletreball — elegibilitat després d'un període de prova de 90 dies (temps parcial cas per

cas); teletreball fins a 3 dies/setmana; horari de presència obligatòria 10am–3pm local; portàtil i monitor proporcionats, l'empleat paga internet, assignació anual de $500 per a l'oficina a casa; localitzable per Slack durant l'horari obligatori, vídeo activat a les reunions d'equip, expectativa de resposta de 30 minuts.

  • Política de reemborsament de despeses — les despeses superiors a $500 necessiten aprovació prèvia del responsable,

els viatges superiors a $2,000 necessiten aprovació de vicepresidència; rebuts obligatoris per sobre de $25 (s'accepten digitals, no n'hi ha prou amb extractes de targeta); presentar en 30 dies, fora de termini cal aprovació de direcció; reemborsament en 10 dies laborables per ingrés directe.

  • Política de vacances i permisos — 15 dies de permís retribuït/any, +1 dia per any de servei fins a

25; 10 dies de baixa per malaltia, no acumulables, justificant mèdic per sobre de 3 dies; 10 festius retribuïts; permís no retribuït de fins a 12 setmanes per motius familiars o mèdics, amb les regles FMLA aplicables.

Fixa't en vectorstore.delete_collection() al final. Totes les demostracions d'aquesta part eliminen la col·lecció de Chroma, i és un hàbit que val la pena copiar: aquests scripts fixen els collection_name al codi, i una caiguda a mitja execució deixa una col·lecció poblada a la qual l'execució següent afegeix dades, corrompent silenciosament la comparació.

Els beneficis impresos: 1. RAG troba ràpidament el document CORRECTE. 2. El context del document complet garanteix que no es perdi res. 3. Continua sent més barat que introduir TOTS els documents. 4. Ideal per a: «Trobar el document rellevant i després analitzar-lo a fons.»

1.8 La lliçó de fons: pensa a escala, no amb la mida del prototip

06:12:23 és el paràgraf que diu que és «exactament el que us vull mostrar»: quan comences a construir RAG, els volums de dades són minúsculs i totes les xifres semblen trivials; per tant, no t'adones mai de l'arquitectura amb què t'estàs comprometent.

«Per tant, pensa sempre en l'escalat, no en xifres petites.» 06:12:23

S'aplica dues vegades en aquest capítol, i val la pena interioritzar totes dues aplicacions:

  • Cost. $0.255 enfront de $0.010 per consulta sembla res. Multiplica-ho per 10,000 consultes/dia

i 30 dies i són $73,500/mes de despesa evitable.

  • Latència. Una demostració de 2,500 tokens no mostra cap diferència (fins i tot en dona una de negativa). Amb 100K+

tokens es converteix en l'1 s enfront dels 45 s de la taula inicial.

Idees clau, tal com les imprimeix l'script:

  1. RAG NO ha mort — és qüestió de cost i latència a escala.
  2. El context llarg guanya amb documents petits, poc volum i anàlisi de documents complets.
  3. RAG guanya amb corpus grans, molt volum i consultes concretes.
  4. Enfocament híbrid: RAG per trobar documents, context llarg per analitzar-los.
  5. El futur és fer servir TOTS DOS estratègicament.

2. Recuperació contextual: arregla el fragment abans de generar-ne l'embedding

2.1 El problema

La part 3 ha establert que el chunking és arquitectura. Aquesta n'és la continuació: fins i tot un fragment dividit correctament pot ser irrecuperable, perquè dividir separa el fragment del document que li donava significat.

«Quan fragmentes, cadascun d'aquests fragments perd el context.» 06:15:33

El seu exemple canònic: un fragment que diu «la política de l'empresa estableix…» — quina empresa? quina política? La documentació interna del fitxer ho formula com «L'empresa es va fundar el 1994» — Quina empresa? De quin document prové? El fragment és factualment cert i completament impossible d'atribuir.

La fallada és mecànica, no misteriosa. 06:20:42 Un usuari pregunta «Quins són els ingressos d'ACME?» El fragment que conté la resposta diu:

«Els ingressos de l'exercici fiscal 2025 van arribar a $4.2 mil milions, un augment del 15% respecte de l'any anterior.»

El token ACME no apareix mai. Ni la coincidència lèxica ni la semàntica no tenen res on agafar-se. Els pronoms i les descripcions definides — «l'empresa», «ells», «això» — són la forma general d'aquest error, i són pertot arreu als corpus reals: informes anuals, manuals de polítiques, documentació tècnica, qualsevol text amb un títol que el cos no repeteix mai.

demonstrate_context_loss() mostra el problema sense cap crida d'API: un informe anual 2025 d'ACME Corporation amb tres seccions (Visió general de l'empresa / Dades financeres destacades / Perspectives de futur), reduït a tres fragments deliberadament orfes:

  1. «L'empresa s'especialitza en la fabricació d'equipament industrial per al sector miner.»

→ quina empresa?

  1. *«Els ingressos de l'exercici fiscal 2025 van arribar a $4.2 mil milions, un augment del 15% respecte de l'

any anterior.»* → de quina empresa?

  1. «L'empresa preveu expandir-se cap a l'equipament d'energies renovables el 2026.» → plans de quina

empresa?

Els dos documents de demostració, complets — reprodueix-los per obtenir les mateixes xifres

Document 1 — l'informe anual 2025 d'ACME Corporation (utilitzat per demonstrate_context_loss(), demonstrate_contextual_retrieval() i 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 «ingressos de l'exercici fiscal 2005» de la transcripció és una interpretació errònia de 2025.)

Document 2 — el comunicat de premsa de la sèrie B de TechStartup Inc. (utilitzat per demo_production_pipeline(), metadata={"title": "TechStartup Inc. Series B Announcement", "source": "press_release.pdf"}): una empresa d'infraestructura d'IA amb seu a Seattle tanca una sèrie B de $45 milions liderada per Sequoia Capital amb participació d'Andreessen Horowitz; la directora general Jane Smith preveu duplicar la plantilla abans d'acabar el 2026; el producte estrella AIFlow ajuda empreses a desplegar i gestionar LLM en producció i dona servei a 200+ clients empresarials.

Fixa't en com s'han escrit tots dos documents: el nom de l'entitat apareix una sola vegada, al primer paràgraf, i totes les frases següents diuen «l'empresa». No és un artifici — és com s'escriuen realment els informes anuals, els comunicats de premsa i els manuals de polítiques.

2.2 El mecanisme, i les dues paraules importants

La recuperació contextual la va publicar Anthropic a finals de 2024 06:17:36. La tècnica cap en una frase:

«Fes servir un LLM per anteposar context a cadascun d'aquests fragments abans de generar l'embedding. Les paraules clau són abans de generar l'embedding.» 06:16:35

Aquest és tot el detall fonamental de la lliçó. El context afegit és:

  • generat per un LLM, no construït amb una plantilla a partir de metadades — el model llegeix tot el document

i escriu una frase que situa el fragment;

  • concatenat al text del fragment abans de la crida d'embedding, perquè el vector mateix

codifiqui els fets a escala de document.

Què conté el prefix: informació del document (títol, nom de l'informe, any, organització) i de la secció (en quina part del document se situa el fragment), més la resolució de les entitats a què apunten els pronoms del fragment. Ara la unitat recuperable respon «quina empresa?» tota sola.

2.3 La funció central, completa

Aquesta és tota la tècnica. És una plantilla de prompt i una cadena LCEL de dos nodes — aquí no hi ha cap subsistema a mida.

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

Hi ha tres coses fonamentals en aquell prompt que val la pena adoptar literalment:

  • «1-2 frases» i «Sigues breu» — el prefix engrandeix cada fragment; per tant, la seva

longitud és un cost que pagues per sempre (consulta §2.7).

  • «Entitats clau esmentades abans al document» — aquesta és la instrucció que

fa la resolució de coreferències. Per això «l'empresa» es converteix en «ACME Corporation».

  • «Retorna NOMÉS el prefix contextual, res més.» — sense això, un model xerraire

retorna «És clar! Aquí tens un context per a aquest fragment:», i aquest preàmbul queda incorporat com a soroll a l'embedding, permanentment, dins de l'índex.

Totes dues instàncies de ChatOpenAI del fitxer fan servir model="gpt-4o-mini", temperature=0. El determinisme importa aquí: generar context és una tasca d'extracció, no creativa, i temperature=0 fa que reindexar el mateix corpus produeixi prefixos gairebé idèntics en lloc d'un conjunt de vectors nou cada vegada.

I l'única línia que és la tècnica — apareix dues vegades al fitxer, una a la demostració (línia 201, com a contextualized) i una a la funció de producció (línia 330, com a contextualized_content):

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

La frase original no es reescriu ni es destrueix mai. El prefix és purament additiu — això és el que fa que tot plegat sigui auditable.

Executar-ho sobre els fragments d'ACME produeix prefixos com aquests 06:20:42:

  • Fragment 1 → *«A la secció de visió general de l'empresa de l'informe anual 2025 d'ACME Corporation,

el document presenta ACME…»* + text original

  • Fragment 2 → «…secció de dades financeres destacades d'ACME Corporation…» + text original
  • Fragment 3 → «A la secció de perspectives de futur de l'informe anual d'ACME Corporation…» + text

original

2.4 La funció de producció

create_contextual_chunks() és el substitut directe del pas de divisió. És el que realment poses en servei.

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

Llegeix amb cura el diccionari metadata — és la bona idea menys explicada del capítol:

ClauPer què existeix
**doc.metadatael source, el page i el title del document pare es conserven a cada fragment (invariant de la part 2: semàntica de split_documents, feta a mà aquí)
chunk_indexposició dins del document pare, per ordenar i ampliar amb fragments veïns
original_chunkel text sense prefix — perquè puguis generar l'embedding de la versió contextualitzada, però mostrar i citar l'original
context_prefixla cadena exacta que ha inventat l'LLM — perquè la puguis auditar, comparar entre reindexacions i detectar un model que ha començat a al·lucinar la procedència

Fixa't en la cadena d'alternatives per al títol: metadata["title"] → metadata["source"] → "Unknown Document". Si el carregador no estableix cap de les dues claus, tots els prefixos de l'índex es generaran amb la cadena «Unknown Document» — una regressió silenciosa de qualitat sense cap error associat.

Els valors per defecte són chunk_size=500, chunk_overlap=100 (un solapament net del 20%, que concorda amb la regla del 10–20% de la part 3). La demostració de producció la crida amb chunk_size=200, chunk_overlap=50 sobre un únic comunicat de premsa de la sèrie B de TechStartup Inc. i produeix 7 fragments 06:23:45. Fixa't en la jerarquia del divisor ["\n\n", "\n", ". ", " ", ""] — paràgrafs, línies, frases, paraules, caràcters —, el valor recursiu per defecte de la part 3.

La recuperació no canvia gens:

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)

La consulta està ben triada: «l'empresa d'IA de Seattle» no anomena ni l'empresa ni la ronda. Només un fragment contextualitzat pot establir el vincle.

La recuperació contextual és un canvi a la tasca d'indexació, no al recorregut de consulta. Tots els recuperadors, reordenadors, cadenes i prompts posteriors queden intactes.

2.5 L'A/B mesurat, i com llegir les puntuacions

compare_retrieval() construeix dues col·leccions de Chroma amb els mateixos tres fragments d'ACME — una en brut, una contextualitzada — i executa les mateixes tres consultes contra totes dues amb 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!")
ConsultaPuntuació originalPuntuació contextualMillora
«Quins són els ingressos d'ACME?»≈1.14 (oralment: «una mica més d'un»)0.556%
«Què fabrica ACME Corporation?»1.33≈0.51 (deduïda)61.4%
«Quins són els plans d'expansió d'ACME?»≈1.42 (deduïda)0.750.6%

Dues de les sis cel·les de puntuació no es van llegir mai en veu alta i s'han calculat a partir dels percentatges impresos — estan marcades com a deduïdes, no llegides de la pantalla. Torna a executar l'script si necessites valors exactes.

El patró que vol que recordis no és un únic rescat espectacular: totes tres consultes han millorat un 50–61%, incloses les dues amb fragments objectiu que ja compartien vocabulari amb la consulta («manufacture»/«manufacturing», «expansion plans»/«plans to expand»). Afegir els noms del document i la secció ajuda fins i tot quan ja hi havia solapament lèxic.

2.6 Les xifres de les proves comparatives, i la correcció que el curs no fa

06:17:36 Dues xifres atribuïdes a la recerca d'Anthropic:

  • Recuperació contextual sola: reducció del 49% de les fallades de recuperació entre els primers 20 resultats.
  • Recuperació contextual + reranking: reducció del 67%.

Fallada de recuperació entre els primers 20 resultats, definida: el passatge correcte no apareix enlloc dels primers 20 resultats recuperats. Els percentatges són reduccions de la taxa d'aquest esdeveniment, no puntuacions de precisió.

Matisa les xifres dues vegades, deliberadament, i el matís és la lliçó més valuosa:

«Recordeu que aquestes xifres són proves comparatives que han fet ells. Podrien ser més altes o més baixes.» 06:19:40

«Només són proves comparatives. Per tant, ho heu de provar vosaltres.» 06:24:26

2.7 Consideracions de producció: el camí d'escriptura ho paga tot

L'script n'imprimeix quatre, i són la comptabilitat honesta dels costos de la tècnica:

ConsideracióXifraOn recau
Cost$0.01–$0.05 per document per generar contextuna sola vegada, indexació
Latència1–2 s per fragment durant la indexacióuna sola vegada, indexació — processament per lots fora de línia
Latència de consultacap impactecamí de lectura intacte
Emmagatzematgeels fragments són ~20–30% més grans«impacte mínim en els costos de la base de dades vectorial»

«És un cost únic en indexar, molt més barat que les fallades de recuperació.» 06:23:45

L'argument econòmic és correcte: pagues una vegada per document, per sempre, en lloc de pagar repetidament en respostes equivocades, incidències de suport escalades i confiança erosionada. I l'asimetria és total — tot el cost i tota la latència recauen al camí d'escriptura.

Sobre el creixement del 20–30% 06:24:26: l'LLM afegeix text literalment; per tant, els fragments creixen. L'emmagatzematge creix; la dimensionalitat de l'embedding — que és el que domina el cost de la base de dades vectorial — no. Per això qualifica de mínim l'impacte en l'emmagatzematge. El que no esmenta és el cost del prompt: una recuperació dels primers 5 resultats ara introdueix ~25% més de text en cada prompt de resposta, a cada petició, per sempre. Aquest cost sí que acaba al camí de lectura.

2.8 Quan activar-la

Tres desencadenants 06:24:26. Si qualsevol és cert, la recuperació contextual probablement compensa la crida a l'LLM per fragment; si no se'n compleix cap, probablement no.

  1. El context important és a les capçaleres o els títols — noms d'informe, encapçalaments de secció, dates —

que el cos del fragment no repeteix mai.

  1. Les entitats es referencien amb pronoms o descripcions definides: «l'empresa»,

«ells», «això».

  1. Els documents provenen de diverses fonts; per tant, un fragment tot sol no pot identificar la seva pròpia

procedència i els resultats de corpus diferents es confonen.

Les sis idees clau impreses (et diu que aturis el vídeo i les llegeixis):

  1. Els fragments perden context quan se separen dels documents.
  2. La recuperació contextual afegeix context ABANS de generar l'embedding.
  3. Fes servir un LLM per generar un prefix contextual d'1–2 frases.
  4. Cost únic en indexar, millora permanent de la recuperació.
  5. Anthropic informa d'un 67% menys de fallades de recuperació.
  6. Combina-la amb cerca híbrida BM25 per obtenir els millors resultats.

La idea clau 6 apunta directament a la part 6. Al disseny original d'Anthropic, la tècnica és «Embeddings contextuals + BM25 contextual» — indexes el text contextualitzat tant lèxicament com vectorialment. Si has construït el recuperador híbrid de la part 6, alimenta totes dues branques amb el text contextualitzat; això és el que mesura realment la xifra del 49%.

3. Chunking tardà: primer genera embeddings, després divideix

3.1 La inversió

«El chunking tardà és una tècnica més nova que inverteix el chunking tradicional.» 06:25:30

Aquesta és tota la idea, i val la pena apreciar com n'és de petita:

  • Chunking primerenc / tradicional: dividir el text → generar l'embedding de cada fragment independentment.
  • Chunking tardà: generar els embeddings del document sencer en una sola passada endavant → després dividir els

embeddings de tokens resultants per posició → agregar cada tram en un vector de fragment.

No canvia res més. Mateix magatzem vectorial, mateix recuperador, mateix k, mateix reordenador, mateixos prompts. Fins i tot l'índex té el mateix aspecte — mateix nombre de vectors, mateixes dimensions. Només difereixen els nombres dins dels vectors.

La diapositiva dibuixada a mà que es manté en pantalla durant tot el segment conceptual. Fixa't en què es diferencien realment les dues meitats: els tres fragments de la fila superior tenen cadascun el seu cervell, dibuixat per separat, amb una baula trencada («context lost»); la fila inferior té un sol cervell dins de la casella «Embed ALL tokens first», amb fletxes de cada token cap a tots els altres — aquest ventall és l'autoatenció, i és tot el mecanisme. La fila He / John / It / Project sota els fragments dividits n'és el benefici: coreferència resolta abans de dividir, de manera que sobreviu a la divisió.
Figura 1La diapositiva dibuixada a mà que es manté en pantalla durant tot el segment conceptual. Fixa't en què es diferencien realment les dues meitats: els tres fragments de la fila superior tenen cadascun el seu cervell, dibuixat per separat, amb una baula trencada («context lost»); la fila inferior té un sol cervell dins de la casella «Embed ALL tokens first», amb fletxes de cada token cap a tots els altres — aquest ventall és l'autoatenció, i és tot el mecanisme. La fila He / John / It / Project sota els fragments dividits n'és el benefici: coreferència resolta abans de dividir, de manera que sobreviu a la divisió.

Per què funciona es resumeix en una frase de mecànica dels transformers. Quan el model fa una passada endavant sobre tot el document, l'atenció permet que cada token vegi tots els altres. El token «He» del tercer paràgraf es calcula en presència de «Steve Jobs» al primer; per tant, el seu vector ja porta aquesta associació. Divideix després aquests vectors de tokens i el vector agregat de cada fragment hereta context de tot el document que un embedding independent del mateix text no podria tenir mai.

«Cadascun d'aquests fragments o vectors, perquè ara són embeddings, coneix tot el document.» 06:33:38

Calen dos termes, perquè el curs els fa servir sense definir-los. Els embeddings a escala de token són els vectors per token que un transformer produeix internament, abans que el model els agregui en el vector únic que retorna una API d'embeddings. El pooling és aquesta reducció: fer la mitjana (o combinar d'una altra manera) dels vectors dels tokens que cauen dins del tram d'un fragment per obtenir un vector de fragment. Al diagrama ASCII de l'script, els fragments tardans porten les etiquetes Vector 1 (pooled), Vector 2 (pooled), Vector 3 (pooled) — la divisió produeix embeddings, i cada grup s'agrega fins a un únic vector de fragment, que és el que arriba a la base de dades.

El benefici declarat: +10–12% de precisió en tasques de recuperació. Aquesta xifra apareix al requadre verd de la diapositiva, a la documentació interna del mòdul, a la taula comparativa i a la idea clau #4. A 06:27:31 diu «del 10 al 20%» una vegada — un lapsus que contradiu tots els artefactes escrits, probablement una barreja amb el +15–20% de la recuperació contextual. Fes servir 10–12%.

3.2 La fallada que resol, feta comptable

El millor recurs d'aquest capítol és una demostració que evidencia la fallada amb una comprovació de subcadena i zero crides d'API. El document de prova és una biografia de Steve Jobs preparada perquè el paràgraf 1 l'anomeni i els paràgrafs 2–4 comencin tots amb «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}")

L'execució produeix quatre fragments 06:30:34–06:31:35:

FragmentText inicialConté «Steve Jobs»Recompte 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 – Només pronoms!3
3«He then founded NeXT Computer and acquired Pixar…»NO0
4«He returned to Apple in 1997…»NO1

Tres de quatre fragments no es poden trobar pel nom. L'argument imprès:

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ó és dins del corpus i, tot i així, no es pot recuperar. És la fallada silenciosa de la invariant 4 en la forma més pura: res no dona error, res no queda registrat, l'usuari simplement obté una resposta pitjor. La versió genèrica que narra a 06:26:31 — només oral, sense cap artefacte al darrere — és un comunicat corporatiu dividit de manera que un fragment comença «Va dir que entraria en vigor immediatament» mentre que el director general que ho va dir és al fragment anterior. Mateix error, i és l'estructura que produeixen la majoria de corpus reals.

3.3 Els dos fluxos, de costat

visualize_chunking_approaches() imprimeix la diapositiva com una parella de diagrames de flux ASCII. Aquí es condensen en una línia per etapa — les etiquetes són literals de l'script; el dibuix de les caselles no:

Figura 2Early chunking i late chunking: embeddings de fragments aïllats o amb el context del document complet
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 fragment, com dic aquí, és una entitat pròpia. Se'n genera l'embedding independentment. Per tant, no hi ha context entre fragments.» 06:32:36

L'aïllament és la causa arrel i és estructural. Cap millora de recuperació — ni reordenador, ni reescriptura de consultes, ni k=50 — arregla un embedding calculat a cegues. Torna a ser la invariant 1: la qualitat s'hereta cap endavant i no es recupera mai més avall.

La llei general que en dedueix, en dues citacions breus 06:27:31:

«Tot està lligat al context perquè els grans models de llenguatge necessiten context.»

«Tant és com de superior sigui el model: sempre acabaràs amb resultats subòptims.»

La qualitat del model no substitueix la qualitat del context. I el model mental que cal retenir: «pensa-hi com tenir les idees correctes, els pensaments complets, a cada fragment».

3.4 La simulació, i què demostra i què no

Aquí el curs topa amb una limitació estricta i — cal reconèixer-ho — ho diu en veu alta. L'API d'embeddings d'OpenAI no exposa embeddings a escala de token. Obtens un vector agregat per cadena d'entrada. Per tant, és impossible fer-hi chunking tardà real. Així, l'script simula l'efecte anteposant una cadena de context i tornant a generar l'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 resultat 06:34:39: 0.6857 → 0.6871, imprès com a Millora: 0.2%.

«Té una petita millora. Tot i així, continua sent una millora del 0.2%.» 06:34:39

(La funció també defineix una cadena document i un chunk1 i no fa servir cap dels dos — són decorat. Només es generen embeddings de chunk2 i query.)

El seu plantejament del guany real, a 06:33:38: la consulta deia «Steve Jobs», no «he» — i la recuperació ha trobat igualment la coincidència perquè el vector del fragment sap que «he» es refereix a Steve Jobs.

3.5 Implementar-ho de debò

show_implementation_options() imprimeix quatre opcions. Dues tenen problemes reals amb les versions actuals de les biblioteques i una no és chunking tardà — per tant, llegeix el codi i després les correccions.

Opció 1 — embeddings de Jina, chunking tardà natiu. Tal com ho imprimeix l'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
)

Avantatges: suport natiu, millor qualitat. Inconvenients: model diferent, pot necessitar una clau d'API.

Fixa't també en la restricció que el capítol no exposa mai:

Opció 2 — recuperació contextual (§2 d'aquesta part), reproduïda aquí com a alternativa independent del model: context = generate_context(chunk, full_document), contextualized_chunk = f"{context} {chunk}", generar-ne l'embedding. Avantatges: funciona amb qualsevol model d'embeddings. Inconvenients: cost addicional d'LLM en indexar.

Opció 3 — recuperador de documents pare. El fragment imprès té una importació desactualitzada:

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

A LangChain 1.2.7, el paquet langchain només exposa agents, chat_models, embeddings, messages, rate_limiters, tools — no hi ha langchain.retrievers. La importació funcional i una construcció funcional provenen de l'altre repositori:

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)

Els fills petits donen coincidències precises; el pare gran dona a l'LLM espai per raonar. La seva descripció 06:37:42: el recuperador recorre la jerarquia pare→fill i retorna el pare, que porta el context més complet. (Ho anomena «arbre»; la implementació de LangChain és realment un magatzem de documents amb l'identificador del pare com a clau, no una estructura d'arbre.)

Opció 4 — solapament + capçaleres de resum. La versió econòmica, i la que ja hauries d'estar aplicant:

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}"

Avantatges: simple, sense cost addicional. Inconvenients: preservació limitada del context. Fixa't que això és recuperació contextual amb una plantilla en lloc d'un LLM — introdueix el títol del document al vector de franc, i res més. Val la pena fer-ho des del primer dia de qualsevol projecte, perquè costa donar format a una cadena i resol la meitat del problema corresponent a «quin document?».

4. La taula de resultats: cinc enfocaments i l'argument per combinar-los

4.1 La taula comparativa

La comparació representada al terminal per print_comparison(), no una diapositiva — per això la pots reproduir localment amb uv run python 03_late_chunking.py. Llegeix les dues columnes com a qualitat enfront de tipus de cost: les tres últimes files obtenen totes tres estrelles en qualitat i només difereixen en la moneda que et cobren — dòlars per document, dependència d'un model o emmagatzematge.
Figura 3La comparació representada al terminal per print_comparison(), no una diapositiva — per això la pots reproduir localment amb uv run python 03_late_chunking.py. Llegeix les dues columnes com a qualitat enfront de tipus de cost: les tres últimes files obtenen totes tres estrelles en qualitat i només difereixen en la moneda que et cobren — dòlars per document, dependència d'un model o emmagatzematge.
EnfocamentQualitat del contextCost d'implementació
Chunking primerenc (tradicional)★☆☆ Baixa — pronoms orfes★★★ Gratuït — enfocament estàndard
Fragments solapats★★☆ Millor — es conserva part del context★★★ Gratuït — només un canvi de configuració
Recuperació contextual★★★ Excel·lent — l'LLM afegeix context★★☆ Cost d'LLM ~$0.01/document
Chunking tardà (natiu)★★★ Excel·lent — context del document complet★★☆ Model especial — Jina o similar
Recuperador pare-fill★★★ Excel·lent — retorna el document pare★★☆ Emmagatzematge addicional — 2× el magatzem vectorial

La seva explicació d'orfes 06:36:42: «no estan vinculats a un pare… no tenen cap correlació que apunti a l'altra dada amb què estan connectats contextualment». Sobre els fragments solapats: «És millor perquè conservem part del context. El cost d'implementació també és gratuït — només cal configurar unes quantes coses.» Sobre la columna de cost del chunking tardà: el preu és la dependència d'un model, no els dòlars.

4.2 La taula de precisió

Les quatre xifres que aquesta part vol transmetre. La que hauria de canviar el teu pla és l'última: +25–30% combinades, superior a qualsevol tècnica individual i — tal com assenyalen les notes del capítol — afirmada al curs però mai demostrada ni mesurada enlloc seu.
Figura 4Les quatre xifres que aquesta part vol transmetre. La que hauria de canviar el teu pla és l'última: +25–30% combinades, superior a qualsevol tècnica individual i — tal com assenyalen les notes del capítol — afirmada al curs però mai demostrada ni mesurada enlloc seu.
TècnicaMillora de precisió respecte del chunking tradicional
Fragments solapats+3–5%
Recuperació contextual+15–20%
Chunking tardà+10–12%
Enfocaments combinats+25–30%

Fixa't que el +15–20% d'aquí és superior a tot el que el capítol 25 explicava sobre recuperació contextual — les dues lliçons citen mètriques diferents (allà, reducció de fallades de recuperació; aquí, guany de precisió) i no les reconcilien mai. Dues observacions que el curs no fa explícitament i que canvien què hauries de construir:

4.3 Combina, no triïs

«No es tracta simplement de triar una estratègia o un enfocament i tirar-hi endavant.» 06:38:42

06:38:42 La seva idea estratègica: en producció vols adoptar totes aquestes estratègies per acabar amb un sistema híbrid que les faci servir totes. La fila de +25–30% n'és l'argument.

L'ordre de recomanació del mateix codi — l'artefacte més directament aplicable del capítol:

  1. Comença per la recuperació contextual (lliçó 6.2) — funciona amb qualsevol model d'embeddings.
  2. Si fas servir Jina, activa el chunking tardà natiu.
  3. Combina-ho amb el recuperador de documents pare per obtenir els millors resultats.
  4. Fes servir sempre un solapament significatiu entre fragments (10–20%).

Llegeix-ho com un ordre de construcció, no com un menú. El pas 4 és gratuït i ja l'hauries de tenir de la part 3. El pas 1 és un canvi a la tasca d'indexació. El pas 3 és un canvi al recuperador. El pas 2 és un canvi de proveïdor d'embeddings — el canvi més invasiu de la llista, i per això és condicional i el penúltim.

La pantalla final de la lliçó. Val la pena fixar-se en el detall del peu: fcc-production-rag on main took 4s — tota aquesta lliçó s'executa en quatre segons perquè només simulate_late_chunking() toca una API. La lliçó anterior de recuperació contextual ha trigat 19s, i aquesta diferència és el perfil de cost de la tècnica en miniatura.
Figura 5La pantalla final de la lliçó. Val la pena fixar-se en el detall del peu: fcc-production-rag on main took 4s — tota aquesta lliçó s'executa en quatre segons perquè només simulate_late_chunking() toca una API. La lliçó anterior de recuperació contextual ha trigat 19s, i aquesta diferència és el perfil de cost de la tècnica en miniatura.

Les sis idees clau, literals de la pantalla:

  1. El chunking primerenc perd les referències pronominals («ell», «l'empresa»).
  2. El chunking tardà genera els embeddings del document complet i després els divideix.
  3. Cada embedding de fragment «coneix» tot el document.
  4. Millora de precisió del 10–12% en tasques de recuperació.
  5. Opcions: Jina natiu, recuperació contextual, pare-fill.
  6. Combina diversos enfocaments per obtenir els millors resultats.

4.4 On dona pas al següent tema

El capítol original s'allarga més enllà del seu propi tema: els últims dos minuts i mig del capítol 26 (06:39:44–06:42:04) ja mostren la diapositiva conceptual de RAG amb agents, i es talla a mitja frase — «Quan arriba la consulta, el…» —, que continua al capítol següent. Aquest material correspon a les parts d'agents d'aquesta guia, no aquí, i val la pena retenir l'avanç d'una línia:

«Actualment, RAG en producció no és només un pipeline fix que va d'A a B a C… ara al centre de tot hi ha un agent.» 06:39:44

Tot el que hi ha a la part 14 continua sent un pipeline fix: decideixes en indexar quina tècnica aplicar, i el recorregut de consulta executa els mateixos passos cada vegada. La frontera següent és un bucle de recuperació que avalua els seus propis resultats i torna a consultar quan són dolents — i és cap aquí on va ara la guia.

5. Diagnòstics que pots executar aquesta setmana

Dos procediments, tots dos barats i tots dos amb evidències en lloc de sensacions.

5.1 Compta els orfes del teu propi corpus

Generalitzat a partir de la demostració de Steve Jobs. No costa res — cap crida d'API.

  1. Divideix un document representatiu amb la configuració del divisor de producció (no amb el

chunk_overlap=0 de la demostració).

  1. Per a cada fragment, comprova si hi apareix el nom canònic de l'entitat.
  2. Compta pronoms i referències definides en columnes separades: he, him, his, she,

her, they, them, it, the company, the report. Fes servir expressions regulars amb límits de paraula, no count(" he ") — consulta l'error de §3.2.

  1. Qualsevol fragment amb pronoms però sense nom és un fragment que els embeddings no poden trobar pel nom.

A la demostració són 3 de 4. Si és una proporció significativa del corpus, la recuperació contextual s'amortitzarà.

5.2 Simula el benefici abans de comprar un model d'embeddings nou

  1. Tria un fragment que comenci amb un pronom i una consulta que anomeni l'entitat.
  2. Genera els embeddings de la consulta i del fragment independent; calcula'n el producte escalar → referència inicial.
  3. Anteposa-hi una cadena de context d'una línia, torna a generar l'embedding i calcula de nou el producte escalar.
  4. improvement = ((late - early) / early) * 100.
  5. Espera una xifra petita (0.2% a l'execució del curs). Això només demostra la direcció. Si

vols la magnitud, executa una avaluació real de recuperació sobre un conjunt etiquetat de consultes i passatges — la disciplina de mesura de la part 7 —, no el producte escalar d'una sola parella.

5.3 Reprodueix les tres lliçons

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

Entorn, a partir de les metadades del repositori i no del README (que afirma Python 3.10+ i s'equivoca): .python-version = 3.13 i pyproject.toml requires-python >= 3.13, fixant 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 afegeix allò que omet pyproject.toml — chromadb>=1.5.0, langchain-classic>=1.0.0, langgraph>=1.1.0 — i porta la regla de capçalera «fes servir langchain-chroma, NO langchain-community» per al magatzem vectorial. L'enregistrament mostra Python 3.12.2 a VS Code; per tant, el README, pyproject.toml i l'entorn enregistrat discrepen tots. Confia en pyproject.toml.

6. Decisions que cal prendre

Recorre aquesta llista en ordre. Cada fila és una decisió amb una opció per defecte, no un suggeriment.

#DecisióOpció per defecte / desencadenant
1RAG o context llarg per a aquest corpus?Corpus <50K tokens i <100 consultes/dia i preguntes sobre documents sencers → context llarg. Altrament, RAG. Qualsevol cas ambigu → RAG, perquè es degrada de manera gradual a mesura que creix el corpus.
2Fes els càlculs d'escala abans de comprometre-t'hi.Calcula el cost/consulta i després ×volum×30. Si la diferència mensual és menor que una hora d'enginyeria, tots dos dissenys van bé; quan deixa de ser-ho, l'arquitectura és una decisió financera, no de gust.
3Pressuposta segons el límit de context *efectiu*.60–70% de la finestra anunciada. En un model d'1M, planifica per a 600–700K.
4Afegeix el patró de selector híbrid.Si els usuaris fan preguntes sobre el document sencer d'un document entre molts: recuperació k=1 → carregar el document complet → respondre. El gran guany més barat d'aquesta part.
5Executa el recompte d'orfes (§5.1).Si una minoria considerable de fragments conté pronoms sense el seu referent, activa la recuperació contextual. Mesura'n la proporció; no l'endevinis.
6Activa la recuperació contextual si es compleix qualsevol desencadenant.Context a capçaleres o títols · entitats referenciades amb pronoms · corpus de diverses fonts.
7Pressuposta la contextualització honestament.$0.01–$0.05/document és un mínim. Cost real ≈ fragments × longitud del document en tokens d'entrada. Afegeix memòria cau de prompts i API per lots abans d'executar-ho sobre un corpus gran — el curs no cobreix cap de les dues coses.
8Fes la contextualització asíncrona.1–2 s/fragment. Posa-la en una cua. No l'executis mai directament dins d'una petició de càrrega.
9Persisteix original_chunk i context_prefix a les metadades.Genera l'embedding del text contextualitzat, cita l'original, audita el prefix. No és negociable.
10Defineix title o source a cada document carregat.create_contextual_chunks() recorre a la cadena literal «Unknown Document» i genera tots els prefixos a partir d'ella. Silenciós, i enverina tot l'índex.
11Indexa també el text contextualitzat a BM25.Idea clau #6. La xifra del 49% d'Anthropic correspon a embeddings + BM25 contextual, no a embeddings sols.
12Preveu un creixement dels fragments del 20–30%.L'impacte en l'emmagatzematge és mínim; en el prompt, no. Una recuperació dels primers 5 resultats ara introdueix ~25% més de text a cada prompt de resposta. Revisa el pressupost de tokens de la part 9.
13Chunking tardà: només amb un model que l'admeti realment.Verifica que el cos de la petició contingui realment late_chunking. L'embolcall comunitari de LangChain el descarta silenciosament.
14Comprova que els documents càpiguen a la finestra del model d'embeddings.El chunking tardà necessita el document sencer en una passada endavant. Llegeix la fitxa del model per saber el límit real; més enllà, tornes a segmentar i a triar límits de segments.
15Afegeix pare-fill damunt de l'opció que hagis triat.Resol un eix diferent (què es retorna) i costa 2× d'emmagatzematge vectorial. Fes servir langchain_classic.retrievers, no langchain.retrievers.
16Mantén sempre un solapament entre fragments del 10–20%.+3–5% amb un canvi de configuració. No hi ha cap argument en contra.
17Mesura les teves pròpies xifres.Totes les xifres d'aquesta part — 1,200×, 25×, 49%, 67%, +10–12%, +15–20%, +25–30% — són orientatives. «Només són proves comparatives. Per tant, ho heu de provar vosaltres.» 06:24:26

Les tres tècniques d'aquesta part compren el mateix: un fragment que es pugui trobar amb una pregunta formulada com la formularia una persona. El context llarg ho compra sense dividir mai. La recuperació contextual, escrivint-hi les paraules que falten. El chunking tardà, generant els embeddings abans de dividir. Tria pel cost i les restriccions, no per la novetat — i recorda que l'opció gratuïta i avorrida, el solapament del 10–20%, ja és a la taula de resultats.