La frontera: GraphRAG, RAG multimodal i cap on anem
GraphRAG i recuperació multimodal amb ColPali: quan un document és més que text.
Tot el que hi ha a les parts 1–15 comparteix una suposició tan profunda que no ha calgut formular-la: un document és text, i la rellevància és una distància entre dos vectors. Chunking, cerca híbrida, reranking, recuperació contextual, autocorrecció amb agents — tot és una lluita per situar el tram correcte de caràcters entre els primers k resultats. Totes les tècniques d'aquesta guia fins ara milloren la punteria. Cap no canvia la diana.
Aquesta part cobreix les dues tècniques que canvien la diana, i trenquen la suposició en direccions oposades:
- GraphRAG rebutja la idea que la rellevància sigui una puntuació. Materialitza relacions simbòliques exactes entre entitats i recupera recorrent-les. Respon una classe de pregunta que la cerca vectorial no pot respondre amb cap
k, cap model d'embeddings ni cap pressupost. - El RAG multimodal (ColPali) rebutja la idea que un document sigui text. Renderitza cada pàgina com a imatge, genera l'embedding de la imatge i dona les imatges de pàgina recuperades a un model amb ulls. Recupera informació que el teu pipeline destrueix actualment durant la ingesta, abans que s'executi la recuperació.
Després, una síntesi final: quines van ser realment les quatre eres del camp, quines de les sis tècniques avançades són base i quines són frontera i — dit clarament — quines parts d'aquesta frontera el material original afirma però no demostra mai.
En el model mental de dues fases de la part 1, aquestes són exactament les caselles que modifica cadascuna:
| Tècnica | Fase A (índex) | Fase B (consulta) | Impacte pressupostari |
|---|---|---|---|
| GraphRAG | Afegeix extracció d'entitats i relacions amb LLM, construcció del graf, detecció de comunitats i resums de comunitats — després de carregar, substituint dividir→generar embeddings com a índex principal | Substitueix Retrieve per identificació d'entitats + recorregut; conserva la cerca vectorial al costat | Diners i latència, en temps d'indexació |
| Multimodal / ColPali | Elimina del tot Split; Embed es converteix en un model de visió amb GPU sobre pàgines renderitzades | Retrieve retorna imatges de pàgina; Generate ha de ser un LLM amb visió | Diners, en temps de consulta (~10×) |
Totes dues són històries de la invariant 3 en sentit invers. GraphRAG desplaça una quantitat enorme de feina cap a l'esquerra, a l'índex de cost únic — per això queda descartat per a corpus en temps real. El multimodal desplaça el cost cap a la dreta, a totes i cadascuna de les peticions — per això queda descartat per a aplicacions amb molt trànsit i sensibles al cost. Cap no és gratuïta ni una opció per defecte.
1 · GraphRAG: les preguntes que la cerca vectorial no pot respondre estructuralment
Microsoft va introduir GraphRAG com una correcció de la recuperació només vectorial 07:04:45. El plantejament importa: no substitueix RAG i — tot i el que suggereix el nom — no és «grafs en lloc de vectors». És un mecanisme de recuperació diferent incorporat al mateix pipeline per a una classe concreta de consultes.
La manera de fallar: els fragments són illes
El RAG estàndard recupera fragments aïllats. Els fragments retornats no estan correlacionats; no hi ha cap relació entre ells, cap aresta, res que connecti el fet A del fragment 3 amb el fet B del fragment 47. Cada fragment recuperat és una illa puntuada independentment, i els primers k resultats són una bossa d'illes 07:04:45.
Això va perfectament bé mentre tots els fets que necessita una resposta visquin dins d'un sol fragment. Tan bon punt la resposta és una composició de fets que viuen en fragments diferents, la cerca vectorial no té cap mecanisme per compondre'ls. La similitud de cosinus no té operador de combinació relacional.
La consulta que motiva l'exemple del formador 07:04:45:
«Quins són els competidors de les empreses que John assessora?»
Mira què passa. El recuperador troba fragments sobre John. Troba fragments sobre competidors. Totes dues meitats de la resposta són a la finestra de context. I el sistema encara falla — perquè la combinació entre elles no s'ha materialitzat enlloc. «No pot connectar John amb els competidors de cap manera.»
Amb un graf, la mateixa consulta recorre en lloc de puntuar: John → ADVISES → TechCorp → COMPETES_WITH → DataTech Inc. La sortida no és només «DataTech Inc.», sinó la cadena que l'ha produït — el que el formador anomena respondre «amb un camí de raonament real» 07:05:47. Aquesta derivació és el lliurable, i la cadena de confiança de la part 1 (fonts → citacions → verificabilitat) n'explica el motiu: una resposta que no pots auditar és una resposta que no pots publicar.
El nus de la qüestió, en sis paraules
La mateixa demostració del curs concreta el mecanisme amb precisió contundent. Corpus de cinc frases, una consulta — és codi real del fitxer de la lliçó:
# fcc-production-rag-part-6/05_graphrag_intro.py — demonstrate_multihop_problem(), lines 41-49
documents = [
"John Smith is the CEO of TechCorp. He joined the company in 2015.",
"Sarah Johnson is John Smith's executive assistant. She manages his calendar.",
"Sarah Johnson works in the Executive department on the 5th floor.",
"The Executive department also includes Mike Brown and Lisa Chen.",
"Mike Brown is the Chief Financial Officer. Lisa Chen is the Chief Legal Officer.",
]
query = "Who works in the same department as the CEO's assistant?"
Respondre-ho exigeix quatre salts 07:12:58:
- Trobar el director general → John Smith.
- Trobar l'assistent del director general → Sarah Johnson.
- Trobar el departament de Sarah → Executive.
- Trobar altres persones del departament → Mike Brown, Lisa Chen (i el mateix John).
La cerca vectorial podria recuperar els documents 3 i 4 perquè contenen la paraula «department». No farà mai el salt 1→2→3, i el motiu és la frase més transferible del capítol 07:13:59:
«El nom de Sarah no és a la consulta.»
La similitud d'embeddings només pot coincidir amb significat present al text de la consulta. L'entitat pont és desconeguda en temps de consulta — per definició, perquè trobar-la és la pregunta. Cap model d'embeddings no pot recuperar un fragment basat en un nom que la consulta no conté. No és un problema de qualitat que puguis resoldre ajustant paràmetres; és una propietat estructural de la recuperació per veïns més propers.
La lliçó anomena tres condicions en què GraphRAG és «especialment potent» 07:09:52, i val la pena llegir-les com una conjunció, no com un menú: preguntes complexes que exigeixen raonament, conjunts de dades amb moltes entitats interconnectades i —
«Preguntes sobre relacions, no només sobre fets.» 07:09:52
L'última és la prova d'una línia. Si no pots assenyalar trànsit real que pregunta sobre relacions, les altres dues no importen.
El mètode: quatre passos
El mecanisme de GraphRAG, tal com s'ensenya [07:06:49–07:09:52]:
- Extreure entitats i relacions dels documents. Les entitats són «els noms, les persones, les coses» — una persona, una empresa, un producte, un lloc, un concepte. Les relacions són com es connecten aquestes entitats. Un LLM fa aquesta passada, tot i que les regles, el reconeixement d'entitats i la curació manual són alternatives que el curs esmenta però no enumera mai 07:17:01.
- Construir el graf de coneixement. Les entitats es converteixen en nodes; les relacions, en arestes. El formador insisteix que és un graf en sentit matemàtic — vèrtexs i arestes, no una metàfora 07:07:51.
- Recórrer-lo per raonar amb diversos salts. Des de qualsevol node, saltes per les arestes per arribar a fets que no contenia cap fragment individual.
- Recuperació híbrida — combinar el recorregut del graf amb la cerca vectorial per produir la resposta final. «El pas quatre és la màgia» 07:09:52.
El pas 4 és el que la gent oblida. GraphRAG no és graf en lloc de vectors; l'estructura de producció és recorregut de graf més cerca vectorial alimentant una resposta. Tractar el graf com un substitut complet del magatzem vectorial sacrifica sensibilitat de recuperació en totes les consultes no relacionals del trànsit.
Si has llegit la part 15, el pas 2 et resultarà familiar, i el formador ho diu en veu alta mentre afegeix arestes 07:11:56:
«Això és molt semblant a LangGraph, oi? Increïble — el mateix, fem servir nodes, el mateix concepte. Gràcies, matemàtiques.»
Val la pena interioritzar aquest comentari. Un graf d'agent de LangGraph i un graf de coneixement són el mateix objecte subjacent — nodes més arestes. Només canvia la semàntica del node: un pas d'un flux de treball enfront d'una entitat del món.
Construir el graf: codi real
La demostració fa servir NetworkX «perquè té totes les peces per crear xarxes simples i complexes» 07:10:55 — uv add networkx i res més. Sis nodes, sis arestes, un graf dirigit:
# fcc-production-rag-part-6/05_graphrag_intro.py — build_knowledge_graph(), lines 97-124
# Create a directed graph
G = nx.DiGraph()
# Add entities (nodes)
entities = [
("John Smith", {"type": "Person", "role": "CEO"}),
("Sarah Johnson", {"type": "Person", "role": "Executive Assistant"}),
("Mike Brown", {"type": "Person", "role": "CFO"}),
("Lisa Chen", {"type": "Person", "role": "CLO"}),
("TechCorp", {"type": "Organization"}),
("Executive Department", {"type": "Department", "floor": "5th"}),
]
for entity, attrs in entities:
G.add_node(entity, **attrs)
# Add relationships (edges)
relationships = [
("John Smith", "TechCorp", {"relation": "CEO_OF"}),
("Sarah Johnson", "John Smith", {"relation": "ASSISTANT_TO"}),
("Sarah Johnson", "Executive Department", {"relation": "WORKS_IN"}),
("Mike Brown", "Executive Department", {"relation": "WORKS_IN"}),
("Lisa Chen", "Executive Department", {"relation": "WORKS_IN"}),
("John Smith", "Executive Department", {"relation": "WORKS_IN"}),
]
for source, target, attrs in relationships:
G.add_edge(source, target, **attrs)
Hi ha tres coses fonamentals en aquell llistat, i només una és evident.
Els nodes porten atributs tipats, no només noms. {"type": "Person", "role": "CEO"} és el que fa possible el salt 1 — el recorregut troba el director general filtrant per un atribut, no comparant una cadena. {"type": "Department", "floor": "5th"} mostra el mateix espai contenint metadades arbitràries. És l'equivalent en grafs de la lliçó de la part 4 segons la qual la capacitat de filtratge es decideix en indexar: no pots recórrer segons un atribut que no has extret.
Les arestes tenen tipus. CEO_OF, ASSISTANT_TO, WORKS_IN — etiquetes de relació en majúscules i amb guions baixos. El recorregut filtra per la cadena exacta de relació; per tant, etiquetes vagues o lliures trenquen silenciosament tots els salts que en depenen. Per això el prompt d'extracció de més endavant exigeix tipus de relació específics.
Les arestes són fets exactes, i aquesta és tota la idea 07:15:01:
«Aquestes relacions que veieu aquí són relacions exactes contingudes estructuralment al graf.»
Una puntuació de similitud és una estimació difusa i probabilística de si dos textos tracten del mateix. Una aresta de graf és una afirmació simbòlica determinista. Els diversos salts funcionen perquè pots encadenar afirmacions deterministes sense acumular error; encadenar puntuacions de similitud acumula error fins que el resultat és soroll.
Hi ha dues imprecisions terminològiques de la narració que val la pena no repetir. El formador anomena aquesta estructura «un arbre» 07:15:01 — és un graf dirigit, i els grafs dirigits poden contenir cicles i en contenen; aquest simplement té aparença d'arbre. I a 07:08:52 descriu salts enrere per les arestes («si som aquí, podem tornar aquí») sobre un DiGraph, on el recorregut invers exigeix tractament explícit — in_edges en lloc d'out_edges, com fa la reescriptura següent. Tots dos lapsus són inofensius en una demostració i cars en un esquema.
Recórrer-lo
Quatre salts, quatre bucles. Aquest és el codi tal com es distribueix:
# fcc-production-rag-part-6/05_graphrag_intro.py — traverse_graph_for_answer(), lines 159-175
# Step 1: Find the CEO
print("\nStep 1: Find the CEO")
ceo = None
for node, attrs in G.nodes(data=True):
if attrs.get("role") == "CEO":
ceo = node
print(f" Found: {ceo}")
break
# Step 2: Find the CEO's assistant
print("\nStep 2: Find the CEO's assistant")
assistant = None
for source, target, attrs in G.edges(data=True):
if target == ceo and attrs["relation"] == "ASSISTANT_TO":
assistant = source
print(f" Found: {assistant} --[ASSISTANT_TO]--> {ceo}")
break
Els passos 3 i 4 tenen la mateixa estructura: recórrer G.edges(data=True) buscant source == assistant and relation == "WORKS_IN" per obtenir el departament, i després tornar-lo a recórrer buscant target == department and relation == "WORKS_IN", excloent l'assistent, per reunir els companys.
Recorregut complet, passos 3–4 i resposta composta (línies 177–200)
# fcc-production-rag-part-6/05_graphrag_intro.py
# Step 3: Find the assistant's department
print("\nStep 3: Find the assistant's department")
department = None
for source, target, attrs in G.edges(data=True):
if source == assistant and attrs["relation"] == "WORKS_IN":
department = target
print(f" Found: {assistant} --[WORKS_IN]--> {department}")
break
# Step 4: Find others in that department
print("\nStep 4: Find others in the same department")
coworkers = []
for source, target, attrs in G.edges(data=True):
if target == department and attrs["relation"] == "WORKS_IN":
if source != assistant: # Exclude the assistant themselves
coworkers.append(source)
print(f" Found: {source} --[WORKS_IN]--> {department}")
print("\n" + "-" * 60)
print("ANSWER:")
print("-" * 60)
print(f"The CEO's assistant is {assistant}.")
print(f"{assistant} works in the {department}.")
print(f"Others in the same department: {', '.join(coworkers)}")
Sortida a 07:16:01: l'assistent és Sarah Johnson, treballa al departament executiu i els altres que hi treballen són John Smith, Mike Brown i Lisa Chen. Fixa't que la resposta porta la seva pròpia derivació — el camí de raonament —, que és el que el formador vol dir amb «tot el context que en surt» 07:05:47.
El formador ho assenyala immediatament, i has de conservar l'advertiment 07:11:56:
«Recordeu que això només és una simulació… només serveix per mostrar com funciona un graf de coneixement.»
El recorregut és una estructura didàctica, no un recuperador. Està fixat al codi per a una sola pregunta; res no analitza llenguatge natural per convertir-lo en un patró de graf. Però el codi distribuït també té quatre defectes que val la pena anomenar, perquè són els que tindrà el teu primer recuperador de graf:
- Sense gestió de casos no trobats. Si cap node no té
role == "CEO",ceoes queda aNone, cap filtre posterior no troba res i la funció imprimeix alegrementThe CEO's assistant is None.No llança mai cap excepció. És la invariant 4 en la forma més pura — un recuperador de graf falla tan silenciosament com un de vectorial. breaka la primera coincidència a tot arreu. El codi suposa exactament un director general i exactament un assistent. Els organigrames reals no tenen cap de les dues propietats.attrs["relation"]provocarà unKeyErrora qualsevol aresta afegida sense una claurelation— també pel teu extractor LLM en un mal dia. Fes servirattrs.get("relation").- O(E) per salt. Cada pas recorre totes les arestes del graf. Amb sis arestes és invisible; amb sis milions és el pressupost de latència.
Aquesta és la reescriptura idiomàtica. NetworkX dona directament vistes de les arestes incidents, cosa que és més ràpida i més llegible — és una correcció de la font, no codi extret d'ella:
# Idiomatic NetworkX rewrite of the four hops — not from the course repo.
# Uses incident-edge views (O(degree) per hop) instead of full edge scans (O(E)).
import networkx as nx
def find_coworkers_of_ceos_assistant(G: nx.DiGraph) -> dict | None:
ceos = [n for n, a in G.nodes(data=True) if a.get("role") == "CEO"]
if not ceos:
return None # signal not-found; never fabricate "None" into an answer
ceo = ceos[0]
# who points AT the ceo with ASSISTANT_TO?
assistants = [s for s, _t, a in G.in_edges(ceo, data=True)
if a.get("relation") == "ASSISTANT_TO"]
if not assistants:
return None
assistant = assistants[0]
departments = [t for _s, t, a in G.out_edges(assistant, data=True)
if a.get("relation") == "WORKS_IN"]
if not departments:
return None
department = departments[0]
coworkers = [s for s, _t, a in G.in_edges(department, data=True)
if a.get("relation") == "WORKS_IN" and s != assistant]
return {
"assistant": assistant,
"department": department,
"coworkers": coworkers,
# the reasoning path is the product, not a debug artefact
"path": [f"{assistant} --[ASSISTANT_TO]--> {ceo}",
f"{assistant} --[WORKS_IN]--> {department}"]
+ [f"{c} --[WORKS_IN]--> {department}" for c in coworkers],
}
Automatitzar l'extracció: la peça que permet escalar
En producció no escrius els nodes a mà. Un LLM llegeix cada document i emet entitats i arestes. Aquest és el prompt d'extracció, literal de la lliçó:
# fcc-production-rag-part-6/05_graphrag_intro.py — extract_entities_with_llm(), lines 218-246
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
extraction_prompt = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are an expert at extracting knowledge graph elements from text.
Given a text, extract:
1. ENTITIES: People, organizations, places, concepts
2. RELATIONSHIPS: How entities are connected
Output in this exact format:
ENTITIES:
- [TYPE] Name: description
RELATIONSHIPS:
- Source --[RELATION]--> Target
Be specific about relationship types (WORKS_FOR, MANAGES, LOCATED_IN, etc.)""",
),
(
"human",
"""Extract entities and relationships from this text:
{text}""",
),
]
)
Quatre instruccions, cadascuna amb una feina: anomenar la tasca, enumerar les dues classes de sortida, fixar un format de sortida exacte i exigir tipus de relació específics. L'última clàusula no és un consell d'estil — el recorregut filtra per la cadena exacta de relació; per tant, WORKS_FOR i «més o menys treballa per a» són arestes diferents i una és inabastable.
L'entrada de demostració és un comunicat d'Acme Corporation (línies 248–254) que esmenta el nomenament de Jennifer Lee com a directora de tecnologia, que reporta al director general Marcus Chen, abans dirigia la recerca d'IA a DataTech Inc. a Boston, amb la seu a San Francisco i un equip d'enginyeria de 50 desenvolupadors. El model emet entitats tipades — Organization (Acme, DataTech), Person (Jennifer Lee, Marcus Chen), Location (Boston, San Francisco) — i després, crucialment, Concepts: «Chief Technology Officer», «research team», «engineering team» [07:17:01–07:18:02].
Els conceptes són entitats de ple dret. Un graf de coneixement no és un directori de persones i llocs; rols, equips, polítiques i línies de producte es converteixen en nodes que pots recórrer.
La cadena mateixa són dues línies:
# fcc-production-rag-part-6/05_graphrag_intro.py — lines 259-266
chain = extraction_prompt | llm
result = chain.invoke({"text": sample_text})
print(f"\nExtracted knowledge graph elements:")
print("-" * 60)
print(result.content)
return result.content
La solució de (2) és la important, i marca la diferència entre una demostració i un pipeline d'ingesta: no demanis a un LLM que formati text; demana-li un esquema. Fes servir sortida estructurada sobre un model Pydantic perquè l'extractor retorni objectes que puguis passar directament a G.add_node / G.add_edge:
# Structured-output version of the extractor — not from the course repo.
# Replaces free-text formatting instructions with a schema the model must satisfy.
import networkx as nx
from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field
class Entity(BaseModel):
name: str
type: str = Field(description="Person | Organization | Location | Concept | Department")
description: str = ""
class Relationship(BaseModel):
source: str
relation: str = Field(description="SCREAMING_SNAKE_CASE, e.g. WORKS_FOR, MANAGES, LOCATED_IN")
target: str
class GraphChunk(BaseModel):
entities: list[Entity]
relationships: list[Relationship]
extractor = ChatOpenAI(model="gpt-4o-mini", temperature=0).with_structured_output(GraphChunk)
def ingest(doc_text: str, G: nx.DiGraph) -> None:
out = extractor.invoke(f"Extract entities and relationships from:\n\n{doc_text}")
for e in out.entities:
G.add_node(e.name, type=e.type, description=e.description)
for r in out.relationships:
G.add_edge(r.source, r.target, relation=r.relation)
Aquesta versió té un defecte que el curs no esmenta mai i que serà el primer que fallarà al teu corpus: la resolució d'entitats. En deu documents, l'extractor produirà "John Smith", "J. Smith", "Mr. Smith" i "the CEO" com a quatre nodes separats, i el recorregut no els trobarà connectats. Eliminar duplicats i donar una forma canònica a les entitats — per similitud d'embeddings, taules d'àlies o una passada de fusió amb LLM — és una etapa obligatòria de qualsevol ingesta GraphRAG real i no es cobreix enlloc del material original. Pressuposta-la.
L'arquitectura completa: què fa realment GraphRAG en producció
La demostració cobreix extracció → graf → recorregut. GraphRAG real té dues etapes d'indexació més, totes dues impreses a l'arquitectura ASCII de la lliçó [07:18:02–07:19:03]:
Fase d'indexació
- Ingerir documents.
- Extracció amb LLM → entitats i relacions.
- Construir el graf de coneixement.
- Detecció de comunitats — agrupar el conjunt d'entitats en subgrups d'entitats densament relacionades. El llindar que dona el formador perquè això valgui la pena: «podria haver-hi 100 entitats» 07:19:03. Un conjunt gran i pla d'entitats no es pot utilitzar de manera global; les comunitats et donen un índex general sobre el graf.
- Generar resums de comunitat — un LLM escriu un resum de cada comunitat detectada.
Fase de consulta
- Identificar les entitats esmentades a la consulta entrant. (Això ancora una pregunta en llenguatge natural al graf i és exactament el pas que se salta la demostració escrita a mà.)
- Recórrer el graf a partir d'aquestes entitats.
- Generar la resposta a partir del subgraf recorregut — o, per a preguntes temàtiques, dels resums de comunitats.
Això porta a la distinció que defineix GraphRAG, impresa literalment al fitxer de la lliçó:
# fcc-production-rag-part-6/05_graphrag_intro.py — show_graphrag_architecture(), lines 322-332
TWO QUERY MODES:
LOCAL SEARCH (Multi-hop reasoning):
- Identify entities in query
- Traverse relationships to find answers
- Good for: specific questions about connections
GLOBAL SEARCH (Holistic understanding):
- Use community summaries
- Aggregate knowledge across documents
- Good for: "What are the main themes?" type questions| Cerca local | Cerca global | |
|---|---|---|
| Mecanisme | Identificar entitats → recórrer arestes | Llegir resums de comunitats → agregar |
| Llegeix | El graf | Els resums construïts en indexar |
| Respon | «Qui treballa amb l'assistent del director general?» | «Quins són els temes principals del conjunt d'aquests documents?» |
| També anomenada | Raonament de diversos salts 07:19:03 | Comprensió global 07:20:05 |
Les preguntes puntuals recorren arestes; les temàtiques llegeixen resums. Aquesta frase és la idea més transferible del capítol de GraphRAG i es generalitza més enllà de GraphRAG: qualsevol pregunta sobre tot el corpus («què ha canviat aquest trimestre», «de què es queixa la gent») és un problema de resum disfressat de recuperació, i recuperar els primers k resultats és l'eina equivocada independentment de la pila.
El capítol no mostra mai un encaminador que triï local o global per consulta. A la pràctica, exposes el mode com a paràmetre d'API o classifiques la consulta amb un model barat — la mateixa estructura que l'encaminador multimodal tractat més endavant en aquesta part.
Opcions d'implementació
La lliçó n'imprimeix quatre; el formador en narra dues i passa de llarg de les altres dues [07:20:05–07:21:06]. Val la pena tenir-les totes quatre, perquè l'opció 4 és la recepta concreta darrere de l'afirmació híbrida «el pas quatre és la màgia».
| Opció | Estructura | Avantatges | Inconvenients |
|---|---|---|---|
| 1. Microsoft GraphRAG | pip install graphrag, indexació + consulta des de la CLI | Complet, ben documentat, a punt per a producció | Pesant; necessita molt còmput per indexar |
| 2. LangGraph + Neo4j | Neo4jGraph + GraphCypherQAChain | Control total, s'integra amb un Neo4j existent | Tu gestiones Neo4j; extracció manual d'entitats |
3. KnowledgeGraphIndex de LlamaIndex (en pantalla, mai narrat) | .from_documents(..., max_triplets_per_chunk=10, include_embeddings=True) | Fàcil d'utilitzar, bona integració amb LlamaIndex | «Menys potent que GraphRAG complet» |
| 4. Híbrid de vectors + graf (en pantalla, mai narrat) | cerca vectorial → extreure entitats dels resultats → recórrer → l'LLM sintetitza | «El millor dels dos mons» | Més complex d'implementar |
L'opció 1 és la recomanació del formador, dues vegades [07:20:05, 07:23:07]:
«Microsoft GraphRAG és la implementació de referència per a producció.»
Tota la interfície, tal com es mostra, són tres ordres — i fixa't que la separació local/global és literalment una opció de la CLI:
# fcc-production-rag-part-6/05_graphrag_intro.py — show_implementation_options(), lines 356-363
pip install graphrag
# Index documents
graphrag index --root ./my_docs
# Query
graphrag query --method local "Who works with the CEO?"
graphrag query --method global "What are the main themes?"
Opcions 2–4 tal com s'imprimeixen al fitxer de la lliçó (línies 369–416), amb correccions
# fcc-production-rag-part-6/05_graphrag_intro.py — OPTION 2: LangGraph + Neo4j
from langchain_community.graphs import Neo4jGraph
from langchain.chains import GraphCypherQAChain
graph = Neo4jGraph(url="bolt://localhost:7687")
chain = GraphCypherQAChain.from_llm(
llm=ChatOpenAI(),
graph=graph,
verbose=True
)
result = chain.invoke("Who reports to the CEO?")
# fcc-production-rag-part-6/05_graphrag_intro.py — OPTION 3: LlamaIndex
from llama_index.core import KnowledgeGraphIndex
kg_index = KnowledgeGraphIndex.from_documents(
documents,
max_triplets_per_chunk=10,
include_embeddings=True
)
query_engine = kg_index.as_query_engine()
response = query_engine.query("Who works in Engineering?")
OPCIÓ 4 — Híbrid de vectors + graf (prosa del fitxer, línies 405–416):
- Cerca vectorial per trobar documents rellevants.
- Extreure entitats dels documents recuperats.
- Recórrer el graf per raonar amb diversos salts.
- L'LLM sintetitza la resposta final.
Correccions que necessites abans d'executar res d'això:
- Tant
from langchain_community.graphs import Neo4jGraphcomfrom langchain.chains import GraphCypherQAChains'han traslladat. El paquet mantingut éslangchain-neo4j:from langchain_neo4j import Neo4jGraph, GraphCypherQAChain. Neo4jGraph(url="bolt://localhost:7687")no passa credencials. El constructor recorre a les variables d'entornNEO4J_USERNAME/NEO4J_PASSWORDi llança una excepció si no hi són ni aquestes ni arguments explícits — per tant, la línia només «funciona» en una màquina que ja té l'entorn correcte exportat. Passa-les explícitament o publicaràs una dependència de configuració que no has documentat mai.- Seguretat:
GraphCypherQAChaingenera i executa Cypher derivat de l'entrada de l'usuari. El LangChain actual exigeix que ho autoritzis amballow_dangerous_requests=Trueprecisament per aquest motiu. Connecta'l només a un compte Neo4j de lectura — és injecció de prompts amb una base de dades al darrere (part 12). - Des d'aleshores, LlamaIndex ha orientat els usuaris de
KnowledgeGraphIndexcap aPropertyGraphIndex.
Cap d'aquestes quatre correccions no prové del curs; verifica-les amb la documentació actual de la biblioteca abans de comprometre't amb una versió.
Fixa't també que requirements.txt fixa pyvis>=0.3.2 — presumiblement per representar el graf —, però cap fitxer del repositori no l'importa mai. Visualitzar el graf extret és l'eina de depuració més barata que trobaràs per a un pipeline d'extracció; la dependència ja hi és.
Quan fer-lo servir i quan és sobreenginyeria
La lliçó imprimeix la decisió en dues llistes de quatre punts [07:21:06–07:22:07]:
| ✅ Fes servir GraphRAG quan | ❌ Prescindeix de GraphRAG quan |
|---|---|
| Els documents descriuen relacions (organigrames, articles de recerca) | Recuperació simple de fets — fes servir RAG estàndard |
| Les consultes necessiten raonament de diversos salts | Conjunts petits de documents (< 100 documents) |
| Preguntes de «qui / què està connectat amb X?» | Requisits d'indexació en temps real |
| Necessites resums globals de diversos documents | Aplicacions sensibles al cost (indexar és car) |
Cal explicar el criteri excloent del temps real, perquè el capítol l'afirma sense explicar-lo. L'índex de GraphRAG no facilita afegir-hi dades: un document nou pot introduir entitats que pertanyen a comunitats existents, cosa que invalida els resums d'aquelles comunitats, que són el que llegeix la cerca global. Afegir un document pot exigir, per tant, tornar a detectar comunitats i regenerar resums. Combina-ho amb una crida a l'LLM per fragment per a l'extracció, i «indexar és car» deixa de ser un advertiment vague i es converteix en una factura concreta i recurrent. El graf de demostració, per la seva banda, viu a la memòria de NetworkX durant la vida del procés — persistència, actualitzacions incrementals i reindexació no es cobreixen mai.
La lliçó acaba amb set idees clau, impreses a __main__ (línies 466–476); es poden comprimir en cinc que val la pena memoritzar:
1. El RAG tradicional falla en raonament de diversos salts. 2. GraphRAG construeix grafs de coneixement a partir de documents. 3. Entitats (nodes) + relacions (arestes) = estructura que es pot recórrer. 4. La cerca local recorre el graf per obtenir respostes concretes; la global utilitza resums de comunitats per als temes. 5. Fes-lo servir quan importen les relacions i s'esperen consultes de diversos salts — «per sota d'això, no cal implementar GraphRAG» 07:23:07.
2 · RAG multimodal: quan el significat és als píxels
El pont cap a aquest material és una frase 07:24:09:
«El món no és només text.»
Totes les tècniques d'aquesta guia fins ara — chunking, cerca híbrida, reranking, recuperació contextual, GraphRAG — suposen que el corpus és text. Els documents reals són PDF amb taules, gràfics, escanejos i diagrames. Un pipeline amb «extreure el text» com a primer pas ja ha decidit que tot allò no textual és soroll, i pren aquesta decisió durant la ingesta, abans que s'executin la recuperació o la generació. Cap quantitat de reranking ni d'enginyeria de prompts posterior no ho recupera.
ColPali es defineix en una clàusula 07:24:31:
«ColPali és un model de visió i llenguatge que crea embeddings a partir d'imatges de documents, no de text extret.»
Tota la tècnica és el desenvolupament d'aquesta frase: la unitat d'indexació passa d'un fragment de caràcters a una imatge d'una pàgina.
La demostració: extreure és una operació amb pèrdua
La lliçó imprimeix una taula i després el que PyPDF o pdfminer en fan habitualment. Totes dues són cadenes reals del fitxer font:
# fcc-production-rag-part-6/06_multimodal_rag.py — demonstrate_extraction_problem(), lines 44-64
# Simulated table in a PDF
original_table = """
┌─────────────────────────────────────────────────────────┐
│ Q1 2025 Sales by Region │
├─────────────┬─────────────┬─────────────┬───────────────┤
│ Region │ Q1 Target │ Q1 Actual │ Variance │
├─────────────┼─────────────┼─────────────┼───────────────┤
│ North │ $2.5M │ $2.8M │ +12% ✓ │
│ South │ $1.8M │ $1.5M │ -17% ✗ │
│ East │ $3.2M │ $3.4M │ +6% ✓ │
│ West │ $2.1M │ $2.0M │ -5% │
├─────────────┼─────────────┼─────────────┼───────────────┤
│ TOTAL │ $9.6M │ $9.7M │ +1% │
└─────────────┴─────────────┴─────────────┴───────────────┘
"""
# What text extraction often produces
extracted_text = """
Q1 2025 Sales by Region Region Q1 Target Q1 Actual Variance
North $2.5M $2.8M +12% South $1.8M $1.5M -17% East $3.2M $3.4M +6%
West $2.1M $2.0M -5% TOTAL $9.6M $9.7M +1%
"""
En aquella transformació han mort exactament quatre coses [07:26:51–07:27:04]:
- Estructura de la taula — files i columnes queden barrejades en una sola línia contínua.
- Indicadors visuals — els símbols ✓ i ✗ poden desaparèixer del tot.
- Alineació — ja no pots saber quina xifra correspon a quina regió.
- Context — «el sud té un rendiment deficient» és visualment evident a la pàgina i completament absent de la cadena.
La capçalera de la lliçó és contundent, i és l'etiqueta mental correcta: «L'EXTRACCIÓ DE TEXT ÉS UNA OPERACIÓ AMB PÈRDUA!»
Ara augmenta la dificultat 07:27:14. Informes financers complexos amb taules niades. Gràfics de tendències. Diagrames amb fletxes i connexions. Diagrames de flux i organigrames. En qualsevol d'aquests casos, un pipeline centrat en el text no és només subòptim — descarta la major part de la informació de la pàgina i després respon amb confiança a partir de la resta.
Els dos pipelines
La lliçó els dibuixa de costat, i el diagrama és l'artefacte més clar del fitxer:
ASCII original
# fcc-production-rag-part-6/06_multimodal_rag.py — explain_colpali_approach(), lines 109-139
TRADITIONAL RAG PIPELINE:
┌─────────┐ ┌──────────────┐ ┌─────────────┐ ┌───────────┐
│ PDF │───▶│ Extract Text │───▶│ Chunk Text │───▶│ Embed │
│ │ │ (PyPDF) │ │ │ │ (OpenAI) │
└─────────┘ └──────────────┘ └─────────────┘ └───────────┘
│
❌ INFORMATION LOST HERE
COLPALI / VISION RAG PIPELINE:
┌─────────┐ ┌──────────────┐ ┌─────────────┐ ┌───────────┐
│ PDF │───▶│ Convert to │───▶│ Embed Images│───▶│ Store in │
│ │ │ Images │ │ (ColPali) │ │ Vector DB │
└─────────┘ └──────────────┘ └─────────────┘ └───────────┘
│
✓ VISUAL INFO PRESERVED
AT QUERY TIME:
┌─────────┐ ┌──────────────┐ ┌─────────────┐ ┌───────────┐
│ Query │───▶│ Embed Query │───▶│ Find Similar│───▶│ Return │
│ │ │ (ColPali) │ │ Pages │ │ PAGE IMAGES│
└─────────┘ └──────────────┘ └─────────────┘ └───────────┘
│
▼
┌───────────┐
│ Vision LLM│
│ (GPT-4V) │
│ "Sees" the│
│ table! │
└───────────┘D'aquella imatge se'n desprenen dos fets estructurals, tots dos amb conseqüències que perduren més enllà de la tècnica.
No hi ha cap pas de chunking. Una pàgina és l'àtom. Tot el que la part 3 t'ha ensenyat sobre mida de fragment, solapament i límits de divisió simplement s'evapora — juntament amb tota la classe d'errors que provoca. És un benefici real i poc valorat: no pots dividir una taula entre dos fragments si no divideixes mai res. També és una limitació real: no tens granularitat inferior a la pàgina, i una pregunta amb resposta repartida en dues pàgines no té cap mecanisme per combinar-les.
La recuperació et dona una imatge; per tant, el generador ha de tenir ulls 07:28:43. Triar ColPali per a la recuperació obliga a utilitzar un model amb visió per generar. Aquest acoblament és d'on ve el cost de 10× — no és un detall d'implementació que puguis optimitzar més endavant.
Davant de les quatre pèrdues anteriors, el camí de visió ofereix quatre garanties simètriques [07:25:21–07:25:33]: les taules continuen sent taules, els gràfics continuen sent gràfics, es conserva el context de disposició visual i no hi ha errors d'extracció de text — no pots deformar el que no has analitzat. L'última és discretament la més forta, perquè els errors d'extracció són silenciosos: una columna mal interpretada produeix una frase ben formada amb una xifra equivocada, i res de la pila no llança cap excepció. La síntesi del formador, i el nucli retòric del capítol 07:26:12:
«Per això el multimodal és realment el rei.»
I la regla de simetria d'embeddings de la part 4 torna amb més força 07:28:00:
«Recordeu que hem de fer servir el mateix model que ha generat els embeddings dels documents.»
Aquí la consulta és text i els documents són imatges. Només un espai d'embeddings conjunt de visió i llenguatge fa que aquesta comparació tingui sentit. No pots barrejar vectors de document de text-embedding-3-small amb vectors de consulta de ColPali — i, segons la invariant 2, el desajust de dimensions és la fallada sorollosa. La perillosa és el desajust semàntic silenciós en què els nombres encaixen i els resultats són soroll.
Què és realment ColPali — i on s'equivoca el curs
El bloc de resum de la mateixa lliçó:
# fcc-production-rag-part-6/06_multimodal_rag.py — lines 142-150
COLPALI KEY INSIGHT:
─────────────────────────────────────────────────────────────────
ColPali (Contextual Late-interaction for Pali) creates embeddings
that capture BOTH text AND visual layout in a single vector.
- Based on PaliGemma (Google's vision-language model)
- One embedding per document image
- Query embedding matches against document images
- No text extraction needed!Tres dels quatre punts són correctes. L'afirmació d'«un sol vector» és errònia, i és l'error amb més probabilitats de costar-te diners.
Aquesta correcció té tres conseqüències que has de planificar, i cap no és al capítol:
- Emmagatzematge. Pressuposta ~10³ vectors petits per pàgina, no un. En un corpus de 10,000 pàgines són milions de vectors, i l'empremta per pàgina és el que canvia el model d'emmagatzematge — no el nombre de pàgines.
- El magatzem. Necessites puntuació nativa de múltiples vectors / MaxSim, no només una columna que accepti un array de floats. Si el magatzem no la té, l'alternativa estàndard és en dues etapes: conservar un vector agregat per pàgina per generar candidats a baix cost i després tornar a puntuar una selecció amb MaxSim al teu procés. La primera etapa de vegades descartarà una pàgina que MaxSim hauria trobat — però aquesta pèrdua queda localitzada en una etapa que pots mesurar, i això marca la diferència entre un compromís d'enginyeria i un misteri.
- La implementació de referència següent. La seva agregació per mitjana
mean(dim=1)és aquest vector agregat — i, utilitzada tota sola, sense una etapa MaxSim posterior, descarta precisament allò que fa funcionar ColPali.
La implementació de referència, llegida críticament
Tot el codi de ColPali de la lliçó viu dins d'una cadena amb cometes triples que s'imprimeix i no s'executa mai [07:29:56–07:30:19]. No hi ha cap importació de colpali_engine, torch, PIL ni pdf2image a la part executable del fitxer. Tracta el que segueix com a pseudocodi que comunica l'estructura del pipeline — l'estructura és correcta, la interfície d'API no. (Els llistats següents ometen les línies # ───── que el fitxer fa servir com a separadors de secció; no s'omet res més.)
# fcc-production-rag-part-6/06_multimodal_rag.py — show_colpali_implementation(), lines 278-314
# Installation (requires GPU for optimal performance)
# pip install colpali-engine pdf2image pillow
from colpali_engine import ColPali
from pdf2image import convert_from_path
import torch
# 1. INITIALIZE COLPALI
model = ColPali.from_pretrained(
"vidore/colpali-v1.2",
torch_dtype=torch.bfloat16,
device_map="cuda" # Requires GPU
)
processor = model.processor
# 2. CONVERT PDF TO IMAGES
def pdf_to_images(pdf_path: str) -> list:
"""Convert each PDF page to an image."""
images = convert_from_path(pdf_path, dpi=150)
return images
# 3. CREATE IMAGE EMBEDDINGS
def embed_document_images(images: list) -> list:
"""Create ColPali embeddings for each page image."""
embeddings = []
for image in images:
inputs = processor(images=image, return_tensors="pt")
inputs = {k: v.to(model.device) for k, v in inputs.items()}
with torch.no_grad():
embedding = model(**inputs).last_hidden_state.mean(dim=1)
embeddings.append(embedding.cpu().numpy())
return embeddings
Cada paràmetre d'aquell bloc és una decisió:
| Paràmetre | Valor | Per què importa |
|---|---|---|
| identificador del model | vidore/colpali-v1.2 | vidore/ és l'organització de Hugging Face (ViDoRe = Visual Document Retrieval). El mateix formador assenyala els canvis de versió: «això pot haver canviat quan ho mireu» 07:30:06. Fixa'n la versió i torna a comprovar la documentació. |
torch_dtype | torch.bfloat16 | Mitja precisió. Redueix la VRAM a la meitat respecte de fp32 amb una pèrdua negligible de qualitat de recuperació. |
device_map | "cuda" | GPU fixada al codi. Sense alternativa amb CPU ni gestió d'errors si no hi ha GPU. |
dpi | 150 | L'únic paràmetre de renderització que es dona, i un ajust de precisió no comentat — consulta el requadre següent. |
torch.no_grad() | — | Només inferència: sense graf d'autograd, molta menys VRAM. Obligatori a escala de pàgina. |
| agregació | .last_hidden_state.mean(dim=1) | Aquest és el defecte. Fer la mitjana redueix els vectors de les regions a un de sol i destrueix la interacció tardana. Útil com a generador de candidats de primera etapa; tot sol no és recuperació ColPali. |
.cpu().numpy() | — | Treu els resultats de la GPU abans de desar-los. Bon hàbit, incorporat. |
La consulta és la imatge especular del costat del document — mateix objecte model, mateixa agregació —, que és la regla de simetria feta concreta al codi. La recuperació és un producte escalar simple amb un valor per defecte de k=3 i retorna números de pàgina i imatges PIL:
# fcc-production-rag-part-6/06_multimodal_rag.py — lines 316-351 (inside the string literal)
# 4. EMBED QUERY
def embed_query(query: str):
"""Create ColPali embedding for text query."""
inputs = processor(text=query, return_tensors="pt")
inputs = {k: v.to(model.device) for k, v in inputs.items()}
with torch.no_grad():
embedding = model(**inputs).last_hidden_state.mean(dim=1)
return embedding.cpu().numpy()
# 5. SEARCH AND RETRIEVE
def search_documents(query: str, document_embeddings: list, images: list, k: int = 3):
"""Find most relevant page images for the query."""
query_embedding = embed_query(query)
# Calculate similarities
similarities = []
for i, doc_emb in enumerate(document_embeddings):
sim = np.dot(query_embedding.flatten(), doc_emb.flatten())
similarities.append((i, sim))
# Sort by similarity
similarities.sort(key=lambda x: x[1], reverse=True)
# Return top-k page images
results = []
for idx, score in similarities[:k]:
results.append({
"page_number": idx + 1,
"score": score,
"image": images[idx]
})
return results
Fixa't en el guany gratuït amagat a "page_number": idx + 1: com que la unitat de recuperació és una pàgina, la granularitat de citació surt de franc. «Pàgina 7» no és una cosa que hagis de reconstruir a partir de metadades de fragment — és la clau primària. És un avantatge real respecte del parany de desfasament d'una unitat entre page/page_label del RAG textual de la part 2.
Dos defectes d'aquell bloc: np no s'importa enlloc del fragment i — com s'ha establert abans — un producte escalar en brut sense normalitzar sobre vectors agregats per mitjana no és com ColPali puntua res.
L'etapa final serialitza les imatges PIL recuperades com a URL de dades base64 i les incorpora totes a un missatge:
answer_with_vision i el programa de principi a fi (línies 355–407)
# fcc-production-rag-part-6/06_multimodal_rag.py — inside the string literal
# 6. ANSWER WITH VISION LLM
def answer_with_vision(query: str, page_images: list):
"""Send retrieved page images to GPT-4V for analysis."""
import base64
from io import BytesIO
# Convert PIL images to base64
image_contents = []
for result in page_images:
buffered = BytesIO()
result["image"].save(buffered, format="PNG")
img_str = base64.b64encode(buffered.getvalue()).decode()
image_contents.append({
"type": "image_url",
"image_url": {"url": f"data:image/png;base64,{img_str}"}
})
# Call GPT-4V
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": f"Based on these document pages, answer: {query}"},
*image_contents
]
}
]
)
return response.choices[0].message.content
# FULL PIPELINE
def multimodal_rag_query(pdf_path: str, query: str):
"""Complete multimodal RAG pipeline."""
# 1. Convert PDF to images
images = pdf_to_images(pdf_path)
# 2. Create embeddings (do once, store in vector DB)
embeddings = embed_document_images(images)
# 3. Search for relevant pages
results = search_documents(query, embeddings, images, k=3)
# 4. Answer with vision LLM
answer = answer_with_vision(query, results)
return answer
El comentari del pas 2 — # 2. Create embeddings (do once, store in vector DB) — és la frase que fa comprensible la taula de costos. Els embeddings de pàgina s'amortitzen; la crida de visió no.
Advertiment sobre la pila: aquest fragment recupera amb colpali-engine + torch, però respon amb l'SDK d'OpenAI directe, mentre que la part executable del mateix fitxer fa servir langchain_openai.ChatOpenAI. Tria una pila per al teu codi; barrejar-les implica dos camins d'autenticació, dues polítiques de reintents i dos llocs per instrumentar (part 7).
El parany de l'estructura del missatge
La lliçó també conté, comentada, la crida que anomena de «producció» amb una imatge real:
# fcc-production-rag-part-6/06_multimodal_rag.py — demo_vision_llm_analysis(), lines 206-210
# In production with actual image:
# response = llm.invoke([
# {"type": "text", "text": query},
# {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}}
# ])
La demostració i el seu buit d'honestedat
L'única crida en directe de tota la lliçó pregunta a GPT-4o «Quina regió té un rendiment deficient i en quina mesura?» i obté 07:29:20:
«La regió sud té un rendiment deficient, amb vendes reals de $1.5M respecte d'un objectiu de $1.8M, cosa que representa una desviació del -17%.»
I després el contrast «KEY ADVANTAGE», que és el més útil del capítol [07:29:27–07:29:55]:
- Amb extracció de text tens:
"South $1.8M $1.5M -17%"— una cadena que «no té gaire context» i «posaria força difícil la feina al gran model de llenguatge». - Amb visió, el model pot veure: la X vermella que indica fallada; el context de les altres regions amb bon rendiment; la jerarquia visual que mostra el sud com a excepció; qualsevol línia de tendència o gràfic que doni suport a l'anàlisi.
La idea generalitzable: el canal visual transporta judici, no només dades. Una X vermella és el veredicte d'un analista humà codificat en píxels. L'extracció de text descarta el veredicte i conserva la xifra en brut — i després demana a un model de llenguatge que torni a deduir el judici a partir d'una cadena aplanada.
El que sí que val la pena adoptar literalment d'aquella funció és el prompt de sistema, que és, de fet, una instrucció de «com llegir una pàgina financera» per a un model de visió:
# fcc-production-rag-part-6/06_multimodal_rag.py — demo_vision_llm_analysis(), lines 215-226
(
"system",
"""You are analyzing a financial document. The user will describe
what's in the document image, and you should answer their question based on
the visual information described.
Focus on:
- Specific numbers and percentages
- Visual indicators (colors, checkmarks, X marks)
- Trends shown in charts
- Relationships between data points""",
),
Canvia el primer paràgraf per «Analitzes les imatges adjuntes de pàgines de documents» i els quatre punts es converteixen en una instrucció de lectura VLM reutilitzable. Importen perquè un model de visió deixat al seu aire descriurà una pàgina; tu vols que la interrogui.
Quan RAG multimodal compensa el cost
Les dues llistes de la lliçó, amb el motiu de cada punt [07:30:19–07:31:48]:
| ✅ Ideal per a | Perquè |
|---|---|
| Informes financers | Taules complexes amb capçaleres niades, gràfics de tendències, notes al peu i anotacions |
| Documentació tècnica | Diagrames d'arquitectura, diagrames de flux, codi amb ressaltat de sintaxi |
| Articles científics | Figures i gràfics, equacions matemàtiques, visualitzacions de dades |
| Documents legals | «El format és important» — contractes amb format, taules de condicions, pàgines de signatures |
| Històries clíniques | Imatges de diagnòstic, taules de resultats de laboratori, gràfics clínics |
| ❌ No cal per a | Perquè |
|---|---|
| Documents de text pla | Novel·les, articles, poemes — no es perd res aplanant-los |
| Dades estructurades simples | El contingut de tipus CSV sobreviu intacte a l'extracció |
| Documents on l'extracció de text ja funciona bé | «No cal passar-se» 07:31:22 |
| Aplicacions en temps real | «Els models de visió són més lents perquè hi ha molt processament» 07:31:31 |
| Aplicacions sensibles al cost | GPT-4o amb imatges costa força més |
L'àmbit jurídic rep les paraules més contundents del capítol 07:30:51: «sobretot, perquè el format és important». En un contracte, on se situa una clàusula i què està ratllat tenen efecte jurídic. Una cadena plana ho perd, i un model més intel·ligent posterior no pot recuperar aquesta pèrdua.
Fixa't que no apareix cap xifra de latència enlloc del capítol. «Més lent» és només un advertiment qualitatiu — preveu mesurar-ho tu (la part 7 dona la instrumentació per fer-ho).
El cost, i què valen les xifres
La lliçó imprimeix aquesta comparació [07:31:50–07:32:41]:
| Pipeline | Embedding | Consulta |
|---|---|---|
| RAG textual | ~$0.0001 per pàgina | ~$0.01 per consulta (GPT-4o-mini) |
| RAG multimodal | ~$0.001 per pàgina (ColPali + GPU) | ~$0.10 per consulta (GPT-4o amb imatges) |
| Proporció | 10× | 10× |
«~10x més car, però necessari per al contingut visual!» 07:32:19
Dues coses que el capítol no diu i que canvien com hauries de llegir aquella taula.
Primer, sigues honest sobre la procedència. El mateix formador ho matisa — «Només són xifres aproximades per donar-vos una idea» 07:31:50 —, i fa bé. Cap de les quatre xifres no té font, i la línia de ColPali ni tan sols és del mateix tipus que les altres: ColPali s'executa a la teva GPU; per tant, «$0.001 per pàgina» és maquinari amortitzat, no una tarifa d'API. Conserva la direcció de l'afirmació (RAG amb visió costa força més, aproximadament un ordre de magnitud) i tracta els dígits concrets com a il·lustratius. No els posis en un estudi de viabilitat de negoci.
Segon, fes la multiplicació que el capítol omet. Les dues línies es comporten de manera completament diferent sota càrrega, cosa que torna a ser la invariant 3:
- $0.001/pàgina en indexar és un cost únic. Un corpus de 10,000 pàgines costa ~$10 d'indexar, per sempre.
- $0.10/consulta és recurrent i escala linealment amb el trànsit. Amb 10,000 consultes/dia són ~$1,000/dia enfront de ~$100/dia del RAG textual — aproximadament $27,000/mes de diferència, per al mateix corpus.
La llista de comprovació — i l'encaminador que el curs no construeix mai
La llista d'implementació de cinc punts [07:33:46–07:34:32], impresa al final de la lliçó:
- ☐ GPU per als embeddings de ColPali — «o podeu fer servir una GPU al núvol, la podeu contractar».
- ☐ pdf2image per convertir PDF → imatge.
- ☐ Una base de dades vectorial que admeti embeddings d'imatge — «no totes les bases de dades vectorials admeten embeddings d'imatge».
- ☐ GPT-4o o Claude per respondre amb visió — «o GPT-5 o 10, segons quan mireu aquest vídeo».
- ☐ Alternativa de RAG textual per a documents simples.
Quatre coses sobre aquesta llista:
El punt 1 és un requisit estricte, i els materials del mateix curs es contradiuen. La llista diu que necessites una GPU. device_map="cuda" està fixat al codi. requirements.txt manté colpali-engine>=0.3.0 i pdf2image>=1.17.0 comentats amb # Uncomment if you have GPU, i només inclou pillow>=11.0.0. Però les preguntes freqüents del README afirmen «Necessito una GPU? No. Tot el codi funciona amb CPU. La secció de RAG multimodal de la part 6 esmenta GPU per a ColPali, però és opcional.» Totes dues afirmacions només són tècnicament certes perquè el codi de ColPali no s'executa enlloc del curs. Si realment executes ColPali, necessites la GPU.
El punt 2 té una dependència absent que el curs no esmenta mai. pdf2image és un embolcall de poppler (pdftoppm), un binari de sistema. pip install pdf2image no l'instal·la, i la conversió fallarà en una màquina neta o en un contenidor lleuger. A Debian/Ubuntu és apt-get install poppler-utils; afegeix-lo al Dockerfile en els termes de la part 13.
El punt 3 és una restricció de contractació presentada com un comentari de passada. «No totes les bases de dades vectorials admeten embeddings d'imatge» 07:34:10 — i, un cop acceptes la correcció de múltiples vectors anterior, el requisit és més estricte del que implica el capítol: necessites un magatzem que admeti puntuació de múltiples vectors amb interacció tardana, no només un que accepti un array de floats derivat d'una imatge. Això pot descartar retroactivament el magatzem que has triat a les parts 4 i 10 — Chroma, utilitzat al llarg de tot el curs, no té comparador MaxSim. El capítol no anomena cap base de dades que ho compleixi; per tant, és una pregunta que has de respondre amb la documentació dels proveïdors abans de dissenyar l'arquitectura; l'alternativa de dues etapes anterior és el recurs quan la resposta és no.
El punt 5 és una instrucció d'arquitectura disfressada de detall amable. «De vegades podeu tenir una barreja de tipus de documents diferents i, per tant, ho heu de tenir previst» 07:34:26. La majoria de corpus reals són mixtos. Sense encaminador només tens dues opcions, totes dues dolentes: pagar el preu de visió per cada PDF de text pla o perdre totes les taules. El capítol no mostra cap codi, heurística ni classificador per a això. És el buit més gran sense omplir del material multimodal; aquesta és l'estructura que hauria de tenir:
# Text-vs-vision routing for a mixed corpus — not from the course repo.
# Runs at INDEX time (per document), not per query: the decision is a property
# of the document, and re-deciding it per request is pure recurring cost.
# Needs PyMuPDF (`pip install pymupdf`); `find_tables` requires >= 1.23.
import pymupdf # historically imported as `fitz`; both names still work
def route_document(pdf_path: str) -> str:
"""Return 'vision' or 'text' for one PDF. Cheap, deterministic, auditable."""
chars = images = tables = 0
with pymupdf.open(pdf_path) as doc:
pages = max(doc.page_count, 1)
for page in doc:
chars += len(page.get_text("text"))
images += len(page.get_images(full=True))
tables += len(page.find_tables().tables)
# 1. Almost no extractable text => scanned document. Vision, no debate.
if chars / pages < 200:
return "vision"
# 2. Any real table or figure density => layout carries meaning.
if (tables + images) / pages >= 1.0:
return "vision"
# 3. Otherwise the meaning survives flattening.
return "text"
Encamina una vegada durant la ingesta, desa la decisió a les metadades del document i indexa cada document pel camí assignat. Després, en consultar, cerques als dos índexs i fusiones (l'RRF de la part 6 s'aplica sense canvis), o encamines la consulta segons l'índex a què apuntin els seus filtres. Els llindars anteriors són punts de partida per calibrar amb el teu corpus, no constants — però un encaminador rudimentari mesurat és millor que un d'elegant suposat.
Les sis idees clau de la mateixa lliçó [07:32:43–07:33:43], impreses al final del fitxer:
1. L'extracció de text perd taules, gràfics i diagrames. 2. ColPali genera embeddings d'IMATGES de documents, no de text extret. 3. Els LLM amb visió (GPT-4o, Claude) poden «veure» els documents. 4. Ideal per a informes financers, documentació tècnica i qualsevol contingut visual. 5. Compromís: ~10× més car, però conserva informació. 6. «El futur: els documents són imatges, no text.»
Ofereix la sisena com a tema de debat, no com a fet — «és una cosa per pensar-hi i potser començar a discutir-la» 07:33:39 —, i aquest és el plantejament correcte. L'afirmació és interessant com a direcció i no té cap evidència a la font. Tracta-la com una hipòtesi que pots provar al teu corpus amb un conjunt d'avaluació, cosa que el capítol no arriba a fer.
3 · Cap on anem
Els tres últims capítols de la font són una recapitulació, una cronologia i una sola paraula. Junts duren uns tres minuts i mig i no contenen codi nou — però són els capítols que et diuen què has de fer realment; per tant, tracta cada línia com a fonamental.
Les sis tècniques avançades en una sola taula de decisió
Aquesta és la taula resum de la part 6 que el formador llegeix a [07:34:48–07:36:50], amb les xifres dels capítols on es van establir realment. Fixa't en l'estructura del seu pensament: cada fila respon «quan faig servir això?». Res no es classifica com «el millor».
| # | Tècnica | Text de la diapositiva | Què fa | Quan fer-la servir | Evidència (del seu propi capítol) |
|---|---|---|---|---|---|
| 1 | Context llarg enfront de RAG | OPTIMITZACIÓ DEL COST | Triar l'enfocament correcte | RAG per a cost + escala; context llarg per a conjunts petits i estàtics | ~10¢/consulta enfront de gairebé zero; latència de ~1 s enfront de ~45 s; 25× a l'exemple resolt del mateix curs (el «més de 1,200×» oral no es dedueix mai — part 14); la fiabilitat del context llarg es degrada al voltant del 60–70% del límit declarat |
| 2 | Recuperació contextual | FINESTRES DE CONTEXT DINÀMIQUES | Afegir context escrit per un LLM a cada fragment abans de generar-ne l'embedding | Sempre — l'única fila incondicional | 49% menys de fallades de recuperació entre els primers 20 resultats (embeddings contextuals més BM25 contextual, que el curs etiqueta erròniament com a «sols»), 67% amb reranking afegit; 1¢–5¢ per document, una sola vegada (part 14) |
| 3 | Chunking tardà | MILLOR COHERÈNCIA I FLUÏDESA | Primer generar embeddings, després fragmentar | Documents amb referències (anàfores, no bibliografies) | +10–12% de precisió; els fragments contextuals creixen un 20–30%; enfocaments combinats 25–30% (part 14) |
| 4 | RAG amb agents | RAONAMENT AUTÒNOM EN DIVERSOS PASSOS | Recuperació amb autocorrecció | Sistemes de producció | Bucle d'avaluació → reescriptura → reintent amb LangGraph; max_retries habitualment 2–5 (part 15) |
| 5 | GraphRAG | EXPLORACIÓ DE CONEIXEMENT ESTRUCTURAT | Raonament amb graf de coneixement: entitats + relacions, recorregudes | Preguntes de diversos salts | Prescindeix-ne per sota de 100 documents; la detecció de comunitats val la pena al voltant de 100 entitats (aquesta part) |
| 6 | Multimodal / ColPali | INTEGRACIÓ D'IMATGE + TEXT + ÀUDIO | Recuperació basada en visió | Documents amb taules, gràfics i imatges | «Molt potent, però car, com heu vist» — ~10× (aquesta part) |
La capçalera de la diapositiva és «La pila RAG de producció de 2026» — pila, no menú. Aquesta tria de paraula és l'argument, i la llista de comprovació següent el fa efectiu.
El mot «estàtic» de la fila 1 té més pes del que sembla i és fàcil passar-lo per alt: el factor determinant no és només la mida del corpus, sinó la freqüència de canvi. Un corpus petit que canvia constantment també afavoreix el context llarg, perquè evita haver de tornar a generar embeddings. I la fila 1 no planteja una disjuntiva excloent: la fórmula abreujada «RAG per cost i escala» es pot llegir com «no facis servir mai context llarg», però això no és el que defensa la part 14. Tria segons la càrrega de treball; tots dos poden conviure en un mateix producte.
La fila 2 és l'única recomanació incondicional de tot el curs. A la pregunta de quan cal fer servir recuperació contextual, la resposta és «Doncs sempre», i la justificació és immediata 07:34:48:
«Per què? Perquè hi ha un 67% menys d'errors. Val la pena l'esforç, si m'ho permeteu.»
«Val la pena l'esforç» és el judici decisiu, i admet que hi ha un esforç: una crida a l'LLM per fragment durant la indexació, fragments un 20–30% més grans, més emmagatzematge i més latència d'indexació. El veredicte és que un cost puntual d'indexació compensa una taxa d'errors recurrent. Hi ha dos matisos que la recapitulació omet i que tu has de tenir presents: el 67% prové del benchmark d'Anthropic, no del teu, i és una xifra del conjunt de tècniques, no d'una tècnica aïllada: la part 14 la desglossa en embeddings contextuals més BM25 contextual, que arriben al 49%, i reranking, que aporta la resta. Si elimines la cerca híbrida o el reranker, ja no et pots comparar amb aquest 67%. Els capítols de la part 14 també repeteixen que «ho has de provar pel teu compte». No deixis que un «67%» sense matisos es converteixi en una garantia.
Quatre etapes, i el fet que cap no s'hagi acabat
La cronologia de la diapositiva de tancament 07:37:02:
| Etapa | Nom | Què va aportar |
|---|---|---|
| 2023 | RAG ingenu | fragmentar → generar embeddings → recuperar → generar. Un sol intent, sense puntuació, sense retroacció i sense mecanisme de reserva. |
| 2024 | RAG optimitzat | Cerca híbrida (densa + BM25 fusionades amb RRF), reranking, «i altres tècniques». La mateixa estructura de pipeline, amb una qualitat de recuperació millor. |
| 2025 | RAG intel·ligent | Recuperació contextual i comportament autocorrectiu. La primera etapa en què el recuperador deixa de ser una funció sense capacitat de decisió. |
| 2026 i més enllà | RAG agèntic | Autònom, multimodal i enriquit amb grafs. El flux de control passa del teu codi a l'agent. |
Les etapes són acumulatives, no substitucions successives, i la llista de comprovació següent ho demostra: el reranking és una tècnica del 2024 que ocupa el lloc número 2 de la llista del 2026. Prescindir de la cerca híbrida i del reranking perquè has afegit un agent és una regressió disfressada de modernització.
La llista de quatre requisits per a producció
El contingut essencial de tota la seqüència final [07:37:02–07:38:03]. L'ordre és el de l'instructor i expressa prioritats:
- Recuperació contextual: «com a mínim». No és una optimització; és un requisit d'entrada. «Com a mínim, necessites recuperació contextual.» Coherent amb la recapitulació: «Quan s'ha de fer servir? Doncs sempre».
- Reranking. Una segona passada de puntuació de rellevància sobre els candidats recuperats.
- Patrons agèntics: «aquest és el nucli». Un agent que avalua els resultats, decideix si són prou bons, reformula i ho torna a provar. L'argument és precís 07:37:02:
«Un sistema robust que no depengui de tu o només del codi que has posat en producció.»
En un pipeline amb regles fixes, qualsevol mode de fallada que no hagis previst abans del desplegament és un error permanent. Amb un agent, les decisions de recuperació es prenen en temps d'execució, mitjançant un component capaç d'examinar els resultats i reaccionar-hi. Fixa't en l'abast, perquè és fàcil interpretar-lo de manera massa àmplia: les decisions a què es refereix són «decisions crítiques relatives a la recuperació» 07:37:02 —si aquest conjunt de candidats és prou bo, si cal reformular la consulta, si cal tornar-ho a provar—, no pas una autonomia sense límits sobre el producte. I, dins de l'àmbit agèntic, destaca una capacitat 07:38:03: «l'autocorrecció, que és la part més important».
- Suport multimodal. La justificació parteix de les dades, no de les capacitats: el teu corpus ja conté imatges, gràfics i taules que el pipeline de només text descarta silenciosament durant la ingesta. Aquí la diapositiva va més enllà de la narració: la targeta diu «INTEGRACIÓ D'IMATGE + TEXT + ÀUDIO». No redueixis «multimodal» a tractar els PDF com a imatges.
Hi ha un pas 0 implícit amagat a la cronologia: es dona per fet que ja disposes de cerca híbrida com a base. Fer reranking sense res de bo per reordenar és pura escenificació.
La llista es presenta com un criteri durador, no lligat a una versió: «aquest any, l'any que ve i els anys vinents» 07:37:02. És el plantejament adequat. Cap dels quatre punts no esmenta un model, una versió de biblioteca ni un proveïdor. Això és el que li permet perdurar: tots els detalls concrets d'aquesta guia quedaran obsolets; aquest ordre de prioritats, no.
Fixa't en què no hi ha a la llista, i considera-ho una mancança de la font: l'avaluació. No hi ha cap punt que digui «mesura la qualitat de la recuperació», cap punt sobre un conjunt d'avaluació ni cap sobre proves de regressió, tot i que totes les recomanacions anteriors depenen d'una mètrica («comença amb la fragmentació recursiva, mesura la qualitat de la recuperació»; «fes les teves pròpies proves»). Una llista de quatre punts que et diu que afegeixis recuperació contextual, reranking, un agent i visió, però no que mesuris si han servit de res, descriu un sistema incapaç d'indicar quan ha empitjorat. Aquesta és la funció de les parts 7 i 15, i hauria de figurar en aquesta llista.
El veredicte i una visió honesta de l'estat de la qüestió
Les dues frases de tancament del curs queden repartides entre dos capítols. L'últim dels 32 capítols és literalment una paraula —RAG., tres segons a 07:38:37—, perquè el marcador de YouTube a 07:38:35 cau al mig de l'última frase. No hi ha cap pantalla final, cap recapitulació, cap pas següent ni cap URL de repositori; el vídeo es talla de cop a 07:38:38, la seva durada total. Això vol dir que la font no ofereix una conclusió que puguem reprendre, i que l'únic que ens deixa és aquest judici final:
«Per tant, l'estratègia ingènua de fragmentar i resar és morta. Doncs benvinguts al futur del RAG.» [07:38:31–07:38:39]
«Fragmentar i resar» és l'expressió pejorativa adequada per a la pràctica adequada: dividir en fragments de mida fixa, generar embeddings, seleccionar els top-k, esperar que hi aparegui el fragment correcte, posar-ho en producció i no disposar d'instrumentació per saber quan falla. Això ja no és un disseny defensable per a producció, i aquesta guia ha dedicat quinze parts a explicar-ne els motius.
Però cal veure amb claredat quines parts d'aquest «futur» ofereix realment el material, perquè la distància és gran i ser-ne conscient marca la diferència entre construir un sistema i imitar-ne les formes sense entendre'l:
| Afirmació | Estat a la font | Què has d'aportar tu |
|---|---|---|
| GraphRAG respon consultes de diversos salts | Demostrat: amb un graf de 6 nodes creat manualment i un recorregut fixat al codi | Extracció real, resolució d'entitats, persistència del graf i anàlisi de consultes per passar de llenguatge natural a patrons de graf |
| GraphRAG automatitza la construcció del graf amb un LLM | Demostrat a mitges: l'extractor s'executa, però res no converteix la seva sortida en nodes i arestes | Sortida estructurada, un carregador i deduplicació |
| Cerca local i cerca global | Explicat, però mai implementat | Un encaminador, o bé exposar el mode com a paràmetre |
| ColPali preserva allò que l'extracció destrueix | Afirmat, però mai demostrat: l'única crida real envia text, no una imatge | Una execució real de ColPali de principi a fi sobre el teu corpus, abans d'assignar-hi pressupost |
| ColPali proporciona «un embedding per imatge» | Incorrecte: fa servir interacció tardana multivectorial (una graella de vectors de regions d'imatge per pàgina, puntuats amb MaxSim) | Un magatzem capaç de fer puntuació multivectorial, o un recuperador de dues etapes amb agregació primer i MaxSim després |
| Què vol dir «interacció tardana» | Esmentat a l'acrònim, però mai explicat: no hi ha cap explicació de ColBERT, de MaxSim ni de l'enfocament multivectorial | Entendre el mecanisme abans de dimensionar l'emmagatzematge o triar un magatzem |
| La multimodalitat costa ~10× més | Estimació aproximada, sense font, tal com reconeix el mateix instructor | La teva pròpia mesura; la tendència és encertada, però les xifres no estan justificades |
| «Recórrer al RAG de text per als documents senzills» | Esmentat com a punt d'una llista de comprovació, sense codi | L'encaminador (més amunt n'hi ha un esbós) |
| Precisió del RAG visual respecte del RAG de text | No hi ha cap benchmark: ni xifres de ViDoRe ni diferència quantificada | El teu propi conjunt d'avaluació |
| Latència de la generació d'embeddings visuals i de les respostes | «Més lent.» Cap xifra. | La teva pròpia mesura |
| Dimensionament de la GPU que justifica «$0.001 per pàgina» | Mai calculat: no s'indica cap targeta, cap taxa de processament ni cap cost en $/hora | Un benchmark amb la GPU que realment pots llogar |
| Llicència de PaliGemma i condicions d'allotjament | No s'esmenten en cap moment | Una revisió de la llicència abans d'un desplegament comercial |
Entorn i versions fixades per al codi de la part 6 (tots dos fitxers d'aquesta part)
Els dos fitxers de les lliçons són al segon repositori, fcc-production-rag-part-6, el que inicialitzes separadament a la part 2. L'entorn declarat és aquest:
pyproject.toml:requires-python = ">=3.13", amb.python-versionfixat a3.13. A la pantalla del curs es veu clarament que s'executa Python 3.12.2 (a la barra d'estat de VS Code durant tot el capítol 29), i el README del repositori afirma que n'hi ha prou amb 3.10+. Tres respostes diferents; refia't del codi que pots executar.- El repositori conté dos fitxers de dependències que discrepen, cosa que ja és tota una lliçó:
requirements.txtés el més ampli (langchain>=1.2.0,<2.0.0,langchain-core>=1.3.0,<2.0.0,langchain-openai>=1.1.0,<2.0.0,langchain-chroma>=1.1.0,<2.0.0—nolangchain-community, segons un comentari explícit del fitxer—,chromadb>=1.5.0,<2.0.0,langgraph>=1.1.0,<2.0.0,langchain-text-splitters>=1.0.0,<2.0.0,tiktoken>=0.12.0,pypdf>=6.0.0,python-dotenv>=1.0.0);pyproject.tomlenumera un subconjunt més reduït de vuit paquets i hi afegeixopenai>=2.32.0, querequirements.txtno esmenta mai. Instal·la les dependències a partir d'un dels dos fitxers, no de tots dos. - GraphRAG (lliçó 6.5):
networkx>=3.3arequirements.txt,networkx>=3.6.1apyproject.toml, méspyvis>=0.3.2, amb la versió fixada per a la visualització de grafs, només arequirements.txt, i sense que cap fitxer l'importi mai. - Multimodalitat (lliçó 6.6): només s'instal·la
pillow>=11.0.0.colpali-engine>=0.3.0ipdf2image>=1.17.0estan comentats amb# Uncomment if you have GPU. La part executable del fitxer no importa cap dels dos; per això tota la lliçó de 526 línies s'executa en 2 segons i fa exactament una crida a l'API. - També hi són:
sentence-transformers>=5.0.0(reranking, opcional),langchain-classic>=1.0.0(recuperadors antics),langchain-anthropic>=0.4.0(recuperació contextual, part 14).
Identificadors de model als sis fitxers de la part 6: gpt-4o-mini a les lliçons 1, 2, 4 i 5; gpt-4o a la lliçó 6; text-embedding-3-small a les lliçons 1–4. La lliçó 1 també fa referència a gpt-5.4-nano en els càlculs de cost. Cap fitxer del repositori no té proves, comprovació de tipus, reintents al nivell de l'API, espera progressiva, temps d'espera màxim ni protecció del pressupost de tokens: cada crida a l'LLM és un simple chain.invoke(...). L'únic try/except dels sis fitxers (lliçó 4, línia 191) protegeix una conversió amb float() de la sortida d'un avaluador, no una crida de xarxa; el max_retries de la lliçó 4 limita el bucle de recuperació, no les fallades de l'API. Aquesta és la distància entre el codi del curs i la paraula «producció» del títol, i les parts 11–13 d'aquesta guia existeixen per reduir-la.
Res d'això no invalida les tècniques. Les situa a la frontera, que és precisament el títol d'aquesta part. La postura honesta per a un enginyer d'infraestructura és aquesta: els mecanismes són reals i els modes de fallada que aborden també ho són; les demostracions són limitades i les xifres, orientatives. Construeix primer la infraestructura d'avaluació, incorpora després una tècnica cada vegada i conserva la que millori la mètrica.
Decisions que cal prendre
Resol-les en aquest ordre. Cadascuna és una bifurcació que has de triar conscientment, en lloc de deixar-te portar per l'opció predeterminada.
Tens realment un problema de diversos salts?
- Extreu 100 consultes reals dels registres. Classifica-les una per una: per respondre-hi, cal encadenar fets de dos documents o més? Si menys del ~10% són de diversos salts, atura't: no necessites un graf, i les parts 6 i 14 et donaran més rendiment.
- Comprova el patró de fallada abans de construir res: els fragments correctes eren dins del context i, tot i així, la resposta era incorrecta? Això és una manca d'enllaç entre fets, no una manca de cobertura de recuperació. Si els fragments correctes no eren al context, arregla primer la recuperació.
- Comprova l'escala: amb menys de 100 documents, prescindeix de GraphRAG. Amb menys de 50,000 tokens en total, considera el context llarg com a alternativa (part 14).
- Comprova la freqüència de canvi: si el corpus necessita indexació gairebé en temps real, GraphRAG queda descartat. L'extracció i la regeneració dels resums de les comunitats no s'adapten bé a la simple addició de contingut.
Si construeixes el graf:
- Tria la implementació: Microsoft GraphRAG si vols una implementació completa amb decisions de disseny ja preses (cost computacional elevat d'indexació); Neo4j +
GraphCypherQAChainsi ja utilitzes Neo4j i vols control (credencials de només lectura iallow_dangerous_requests=Trueentès com l'advertiment que és); LlamaIndexPropertyGraphIndexper al camí més senzill; híbrid vectorial + graf si vols conservar el recuperador existent i afegir-hi recorreguts del graf. - Dissenya el vocabulari de relacions abans de fer l'extracció, en
SCREAMING_SNAKE_CASE, i fixa'l al prompt d'extracció. Els recorreguts exigeixen coincidència exacta amb les cadenes de les relacions. - Fes servir sortida estructurada (Pydantic) per a l'extracció, en lloc d'instruccions de format en text lliure. Necessites objectes, no prosa.
- Preveu explícitament el cost de la resolució d'entitats. No és opcional i la font no l'esmenta mai.
- Decideix com faràs persistent el graf i com l'actualitzaràs incrementalment. NetworkX en memòria és una demostració.
- Retorna el camí de raonament amb cada resposta del graf. És la teva citació.
- Mantén la cerca vectorial al costat del graf. El pas 4 és híbrid; un recuperador basat només en el graf perd cobertura en totes les consultes que no són relacionals.
Tens un problema que requereixi visió?
- Obre deu documents aleatoris del corpus i processa'ls amb l'extractor actual. Si les taules i les figures es conserven com a text aprofitable, atura't: no necessites aquesta solució.
- Classifica segons el tipus de document: financer / tècnic / científic / jurídic / mèdic → probablement sí. Novel·les, articles, formats semblants a CSV → no.
- Fes els càlculs abans de comprometre-t'hi:
queries/day × $0.10en comparació ambqueries/day × $0.01. Amb 10k consultes al dia, la diferència és d'uns $27k al mes. El corpus ho justifica? - Comprova el pressupost de latència. Els models de visió són més lents i ningú no t'ha dit quant.
- Demostra la premissa abans de finançar-la. Agafa vint pàgines que l'extractor malmeti, fes-hi una recuperació real amb ColPali i genera una resposta real amb un model de visió, i compara els resultats amb els del pipeline de text per a les mateixes preguntes. Ningú de la cadena de fonts no ho ha fet; tota la tesi continua sense contrastar fins que tu la posis a prova.
Si construeixes la via de visió:
- Assegura't de disposar d'una GPU, local o al núvol. La GPU no és opcional, digui el que digui el README.
- Instal·la poppler (
poppler-utils) juntament ambpdf2image. És un paquet del sistema. - Verifica que el magatzem vectorial admet puntuació multivectorial amb interacció tardana, no simplement «embeddings d'imatge». Fes-ho abans de dissenyar l'arquitectura. Si no ho admet, decideix ara si canviaràs de magatzem o construiràs el recuperador de dues etapes, amb agregació primer i MaxSim després; en qualsevol cas, dimensiona l'emmagatzematge per a ~10³ vectors per pàgina.
- Fixa
vidore/colpali-v1.2i posa't un recordatori per tornar a revisar la fitxa del model. Els identificadors de model queden obsolets. - Calibra
dpi. El valor predeterminat és 150; prova 200–300 a les pàgines més denses i examina en què s'equivoca el model. - No deixis mai que un vector agregat per mitjana determini la puntuació final. L'agregació és una primera etapa legítima; acabar aquí vol dir haver invertit en un pipeline de visió i haver-ne desaprofitat la qualitat de recuperació.
- Construeix l'encaminador entre text i visió durant la indexació, desa la decisió a les metadades i mantén operatives totes dues vies.
- Reutilitza la instrucció de lectura per a VLM de quatre punts (xifres, indicadors visuals, tendències dels gràfics i relacions entre punts de dades) com a prompt del sistema. Un model de visió sense instruccions específiques descriurà la pàgina en lloc d'analitzar-la per respondre la consulta.
- Aprofita la granularitat de citació que obtens sense cost afegit: les imatges de pàgina et donen «pàgina 7» com a clau primària, sense haver-la de reconstruir.
Abans de donar-ho per acabat:
- Aplica al teu sistema la llista de comprovació del 2026, en aquest ordre: recuperació contextual (el mínim) → reranking → patrons agèntics (el nucli, amb l'autocorrecció que inclouen) → suport multimodal. Confirma que no has descartat res de les etapes anteriors pel camí: la cerca híbrida i el reranking continuen sent necessaris quan arriba un agent.
- Afegeix el punt que la llista de la font omet: un conjunt d'avaluació i un control de regressió. Totes les tècniques d'aquesta part exigeixen que les provis pel teu compte. Sense una mesura, no pots distingir una incorporació útil d'un afegit decoratiu; i, segons l'invariant 4, res no llançarà una excepció per avisar-te'n.