La frontera: GraphRAG, multimodal RAG y hacia dónde va todo esto
GraphRAG y retrieval multimodal con ColPali: cuando un documento no es solo texto.
Todo lo de las Partes 1–15 comparte un supuesto tan profundo que nunca ha hecho falta enunciarlo: un documento es texto, y la relevancia es una distancia entre dos vectores. Chunking, búsqueda híbrida, reranking, contextual retrieval, autocorrección agéntica — todo es una lucha por meter el tramo correcto de caracteres en el top-k. Todas las técnicas de esta guía hasta ahora mejoran la puntería. Ninguna cambia la diana.
Esta parte trata las dos técnicas que sí cambian la diana, y rompen el supuesto en direcciones opuestas:
- GraphRAG rechaza la idea de que la relevancia sea un score. Materializa relaciones exactas y simbólicas entre entidades y recupera recorriéndolas. Responde a un tipo de pregunta que la búsqueda vectorial no puede responder con ningún
k, con ningún embedding model y con ningún presupuesto. - Multimodal RAG (ColPali) rechaza la idea de que un documento sea texto. Renderiza cada página como imagen, hace embedding de la imagen y pasa las imágenes de página recuperadas a un modelo con ojos. Recupera información que tu pipeline está destruyendo ahora mismo en la ingesta, antes de que el retrieval llegue a ejecutarse.
Después, una síntesis final: cuáles fueron realmente las cuatro eras del campo, cuáles de las seis técnicas avanzadas son suelo y cuáles son ventaja y — dicho sin rodeos — qué partes de esta frontera afirma el material fuente sin demostrarlas nunca.
En el modelo mental de dos fases de la Parte 1, estas son exactamente las cajas que modifica cada una:
| Técnica | Phase A (índice) | Phase B (query) | Dónde golpea al presupuesto |
|---|---|---|---|
| GraphRAG | Añade extracción de entidades/relaciones con LLM, construcción del grafo, detección de comunidades y resúmenes de comunidades — después de Load, sustituyendo a Split→Embed como índice principal | Sustituye Retrieve por identificación de entidades + recorrido; mantiene la búsqueda vectorial a su lado | Dinero y latencia, en tiempo de indexación |
| Multimodal / ColPali | Elimina Split por completo; Embed pasa a ser un modelo de visión en GPU sobre páginas renderizadas | Retrieve devuelve imágenes de página; Generate tiene que ser un LLM con visión | Dinero, en tiempo de query (~10×) |
Ambas son historias del invariante 3 al revés. GraphRAG empuja una cantidad enorme de trabajo hacia la izquierda, al índice que se construye una sola vez — por eso queda descartado para corpus en tiempo real. Multimodal empuja el coste hacia la derecha, a todas y cada una de las requests — por eso queda descartado para apps de mucho tráfico y sensibles al coste. Ninguna es gratis y ninguna es la opción por defecto.
1 · GraphRAG: las preguntas que la búsqueda vectorial no puede responder por estructura
GraphRAG lo presentó Microsoft como correctivo al retrieval solo vectorial 07:04:45. El planteamiento importa: no es un sustituto del RAG y — por mucho que lo sugiera el nombre — no es «grafos en lugar de vectores». Es un mecanismo de retrieval distinto grapado al mismo pipeline, para un tipo concreto de query.
El modo de fallo: los chunks son islas
El RAG estándar recupera chunks aislados. Los chunks que vuelven no están correlacionados; no hay relación entre ellos, ni aristas, nada que conecte el hecho A del chunk 3 con el hecho B del chunk 47. Cada chunk recuperado es una isla, con su score independiente, y el top-k es una bolsa de islas 07:04:45.
Eso está perfectamente bien mientras cada hecho que necesita una respuesta viva dentro de un solo chunk. En el momento en que la respuesta es una composición de hechos que viven en chunks distintos, la búsqueda vectorial no tiene ningún mecanismo para componerlos. No existe un operador join en la similitud coseno.
La query que motiva todo, según el instructor 07:04:45:
«¿Quiénes son los competidores de las empresas a las que asesora John?»
Fíjate en lo que pasa. El retriever saca chunks sobre John. Saca chunks sobre competidores. Las dos mitades de la respuesta están en la context window. Y el sistema falla igualmente — porque el join entre ellas no se materializó en ningún sitio. «No puede conectar a John con los competidores en absoluto».
Con un grafo, la misma query recorre en lugar de puntuar: John → ADVISES → TechCorp → COMPETES_WITH → DataTech Inc. La salida no es solo «DataTech Inc.», sino la cadena que la produjo — lo que el instructor llama responder «con un camino de razonamiento real» 07:05:47. Esa derivación es el entregable, y la cadena de confianza de la Parte 1 (fuentes → citas → verificabilidad) explica por qué: una respuesta que no puedes auditar es una respuesta que no puedes poner en producción.
El quid, en seis palabras
La propia demo del curso hace el mecanismo dolorosamente preciso. Un corpus de cinco frases, una query — este es código real del archivo de la lección:
# 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?"
Responderla requiere cuatro saltos 07:12:58:
- Encontrar al CEO → John Smith.
- Encontrar a la asistente del CEO → Sarah Johnson.
- Encontrar el departamento de Sarah → Executive.
- Encontrar a los demás de ese departamento → Mike Brown, Lisa Chen (y el propio John).
La búsqueda vectorial bien podría recuperar los documentos 3 y 4, porque contienen la palabra «department». Nunca dará el salto 1→2→3, y la razón es la frase más trasladable de todo el capítulo 07:13:59:
«El nombre de Sarah no está en la query».
La similitud de embeddings solo puede emparejar significado que esté presente en el texto de la query. La entidad puente es desconocida en tiempo de query — por definición, porque encontrarla es la pregunta. Ningún embedding model puede recuperar un chunk indexado por un nombre que la query no contiene. No es un problema de calidad del que puedas salir afinando; es una propiedad estructural del retrieval por vecinos más cercanos.
La lección nombra tres condiciones en las que GraphRAG es «especialmente potente» 07:09:52, y merece la pena leerlas como una conjunción más que como un menú: preguntas complejas que requieren razonamiento, conjuntos de datos con muchas entidades interconectadas y —
«Preguntas sobre relaciones, no solo sobre hechos». 07:09:52
Esa última es la prueba en una línea. Si no puedes señalar tráfico real que pregunte por relaciones, las otras dos no importan.
El método: cuatro pasos
El mecanismo de GraphRAG, tal como se enseña [07:06:49–07:09:52]:
- Extraer entidades y relaciones de los documentos. Las entidades son «los sustantivos, las personas, las cosas» — una persona, una empresa, un producto, un lugar, un concepto. Las relaciones son cómo se conectan esas entidades. Esta pasada la hace un LLM, aunque reglas/NER/curación manual son alternativas que el curso menciona y nunca enumera 07:17:01.
- Construir el grafo de conocimiento. Las entidades se convierten en nodos y las relaciones en aristas. El instructor insiste en que es un grafo en sentido matemático — vértices y aristas, no una metáfora 07:07:51.
- Recorrer el grafo para el razonamiento multi-hop. Desde cualquier nodo saltas por las aristas hasta llegar a hechos que ningún chunk contenía por sí solo.
- Retrieval híbrido — combinar el recorrido del grafo con la búsqueda vectorial para producir la respuesta final. «El paso cuatro es la magia» 07:09:52.
El paso 4 es el que la gente olvida. GraphRAG no es grafo-en-lugar-de-vectores; la forma que tiene en producción es recorrido del grafo más búsqueda vectorial alimentando una única respuesta. Tratar el grafo como sustituto total de tu vector store tira por la borda el recall de todas las queries no relacionales de tu tráfico.
Si has leído la Parte 15, el paso 2 te sonará, y el instructor lo dice en voz alta mientras añade aristas 07:11:56:
«Esto se parece mucho a LangGraph, ¿verdad? Genial — lo mismo, estamos usando nodos, el mismo concepto. Gracias, matemáticas».
Vale la pena interiorizar ese inciso. Un grafo de agente de LangGraph y un grafo de conocimiento son el mismo objeto de fondo — nodos más aristas. Solo cambia la semántica de un nodo: un paso de un workflow frente a una entidad del mundo.
Construir el grafo: código real
La demo usa NetworkX, «porque tiene todas las piezas para crear redes simples y complejas» 07:10:55 — uv add networkx, y nada más. Seis nodos, seis aristas, un grafo dirigido:
# 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)
En ese listado hay tres cosas que sostienen todo, y solo una es obvia.
Los nodos llevan atributos tipados, no solo nombres. {"type": "Person", "role": "CEO"} es lo que hace posible el salto 1 — el recorrido encuentra al CEO filtrando por un atributo, no emparejando una cadena. {"type": "Department", "floor": "5th"} muestra el mismo hueco llevando metadatos arbitrarios. Es el equivalente en grafo de la lección de la Parte 4 de que la capacidad de filtrar se decide en tiempo de indexación: por el atributo que no hayas extraído no podrás recorrer.
Las aristas están tipadas. CEO_OF, ASSISTANT_TO, WORKS_IN — etiquetas de relación en SCREAMING_SNAKE_CASE. El recorrido filtra por la cadena de relación exacta, así que unas etiquetas de relación vagas o en formato libre rompen en silencio cada salto que dependa de ellas. Por eso el prompt de extracción insiste más adelante en tipos de relación concretos.
Las aristas son hechos exactos, y de eso se trata 07:15:01:
«Estas relaciones que ves aquí son relaciones exactas que están contenidas estructuralmente en el grafo».
Un score de similitud es una conjetura difusa y probabilística sobre si dos textos tratan de lo mismo. Una arista del grafo es una afirmación determinista y simbólica. El multi-hop funciona porque puedes encadenar afirmaciones deterministas sin acumular error; encadenar scores de similitud acumula error hasta que el resultado es ruido.
Hay dos imprecisiones terminológicas en la narración que conviene no repetir. El instructor llama a esta estructura «un árbol» 07:15:01 — es un grafo dirigido, y los grafos dirigidos pueden contener ciclos y los contienen; este simplemente tiene pinta de árbol. Y en 07:08:52 describe saltar hacia atrás por las aristas («si estamos aquí podemos volver aquí») en un DiGraph, donde el recorrido inverso requiere un tratamiento explícito — in_edges en lugar de out_edges, como hace la reescritura de más abajo. Ambos deslices son inofensivos en una demo y caros en un esquema.
Recorrerlo
Cuatro saltos, cuatro bucles. Este es el código tal como se publicó:
# 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
Los pasos 3 y 4 tienen la misma forma: recorrer G.edges(data=True) buscando source == assistant and relation == "WORKS_IN" para obtener el departamento y luego volver a recorrerlo buscando target == department and relation == "WORKS_IN", excluyendo a la asistente, para reunir a los compañeros.
Recorrido completo, pasos 3–4 y la respuesta compuesta (líneas 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)}")
Salida en 07:16:01: la asistente es Sarah Johnson, trabaja en el Executive Department y los demás de ahí son John Smith, Mike Brown y Lisa Chen. Fíjate en que la respuesta lleva su propia derivación — el camino de razonamiento —, que es lo que el instructor quiere decir con «todo el contexto que sale» 07:05:47.
El instructor lo advierte de inmediato, y deberías quedarte con la advertencia 07:11:56:
«Recordad, esto aquí es solo una simulación… es solo para enseñaros cómo funciona un grafo de conocimiento».
El recorrido es un andamiaje didáctico, no un retriever. Está hardcodeado para exactamente una pregunta; nada convierte lenguaje natural en un patrón de grafo. Pero el código publicado tiene además cuatro defectos que vale la pena nombrar, porque son los defectos que tendrá tu primer retriever de grafo:
- No gestiona el caso de no encontrar nada. Si ningún nodo tiene
role == "CEO",ceose queda enNone, ningún filtro posterior encuentra nada y la función imprime tan panchaThe CEO's assistant is None.Nunca lanza una excepción. Es el invariante 4 en estado puro — un retriever de grafo falla con el mismo silencio que uno vectorial. breaken la primera coincidencia en todas partes. El código supone exactamente un CEO y exactamente una asistente. Los organigramas reales no cumplen ninguna de las dos cosas.attrs["relation"]lanzará unKeyErrorcon cualquier arista que se añada sin la claverelation— también las que añada tu extractor LLM en un mal día. Usaattrs.get("relation").- O(E) por salto. Cada paso recorre todas las aristas del grafo. Con seis aristas no se nota; con seis millones es tu presupuesto de latencia.
Esta es la reescritura idiomática. NetworkX te da directamente vistas de las aristas incidentes, lo que es a la vez más rápido y más legible — es una corrección de la fuente, no código sacado de 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],
}
Automatizar la extracción: la pieza que lo hace escalar
En producción no escribes nodos a mano. Un LLM lee cada documento y emite entidades y aristas. Este es el prompt de extracción, tal cual aparece en la lección:
# 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}""",
),
]
)
Cuatro instrucciones, cada una con su función: nombrar la tarea, enumerar las dos clases de salida, fijar un formato de salida exacto y exigir tipos de relación concretos. Esa última cláusula no es un consejo de estilo — el recorrido filtra por la cadena de relación exacta, así que WORKS_FOR y «trabaja para, más o menos» son aristas distintas y una de ellas es inalcanzable.
La entrada de la demo es una nota de prensa de Acme Corporation (líneas 248–254) que menciona que Jennifer Lee ha sido nombrada CTO, que reporta al CEO Marcus Chen, que antes dirigía la investigación en IA de DataTech Inc. en Boston, con sede central en San Francisco y un equipo de ingeniería de 50 desarrolladores. El modelo emite entidades tipadas — Organization (Acme, DataTech), Person (Jennifer Lee, Marcus Chen), Location (Boston, San Francisco) — y después, lo que es crucial, Concepts: «Chief Technology Officer», «research team», «engineering team» [07:17:01–07:18:02].
Los conceptos son entidades de primera clase. Un grafo de conocimiento no es un directorio de personas y lugares; roles, equipos, políticas y líneas de producto se convierten todos en nodos que puedes recorrer.
La chain en sí son dos líneas:
# 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
El arreglo que importa es el de (2), y es la diferencia entre una demo y un pipeline de ingesta: no le pidas a un LLM que formatee texto, pídele un esquema. Usa structured output sobre un modelo Pydantic para que el extractor devuelva objetos que puedas pasar directamente 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)
Esa versión tiene un defecto que el curso nunca menciona y que será lo primero que se rompa con tu corpus: la resolución de entidades. A lo largo de diez documentos tu extractor producirá "John Smith", "J. Smith", "Mr. Smith" y "the CEO" como cuatro nodos separados, y tu recorrido no encontrará ninguno conectado. Deduplicar y canonizar entidades — por similitud de embeddings, con tablas de alias, con una pasada de fusión con LLM — es una etapa obligatoria de cualquier ingesta GraphRAG real y no se trata en ninguna parte del material fuente. Presupuéstalo.
La arquitectura completa: lo que hace realmente un GraphRAG en producción
La demo cubre extracción → grafo → recorrido. Un GraphRAG real tiene dos etapas de indexación más, ambas impresas en la arquitectura ASCII de la lección [07:18:02–07:19:03]:
Fase de indexación
- Ingerir los documentos.
- Extracción con LLM → entidades y relaciones.
- Construir el grafo de conocimiento.
- Detección de comunidades — agrupar el conjunto de entidades en subgrupos de entidades densamente relacionadas. El umbral que da el instructor para cuándo empieza a merecer la pena: «las entidades podrían ser 100 entidades» 07:19:03. Un conjunto de entidades grande y plano es inutilizable de forma global; las comunidades te dan un índice de grano grueso sobre el grafo.
- Generar resúmenes de comunidades — un LLM escribe un resumen de cada comunidad detectada.
Fase de query
- Identificar las entidades mencionadas en la query entrante. (Esto es lo que ancla una pregunta en lenguaje natural al grafo, y es justo el paso que se salta la demo escrita a mano.)
- Recorrer el grafo a partir de esas entidades.
- Generar la respuesta a partir del subgrafo recorrido — o, en las preguntas temáticas, a partir de los resúmenes de comunidades.
Lo que lleva a la distinción que define GraphRAG, impresa tal cual en el archivo de la lección:
# 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| Búsqueda local | Búsqueda global | |
|---|---|---|
| Mecanismo | Identificar entidades → recorrer aristas | Leer resúmenes de comunidades → agregar |
| Lee | El grafo | Los resúmenes construidos en tiempo de indexación |
| Responde a | «¿Quién trabaja con la asistente del CEO?» | «¿Cuáles son los temas principales de estos documentos?» |
| También llamado | Razonamiento multi-hop 07:19:03 | Comprensión global 07:20:05 |
Las preguntas puntuales recorren aristas; las preguntas temáticas leen resúmenes. Esa frase es la idea más trasladable del capítulo de GraphRAG, y se generaliza más allá de GraphRAG: cualquier pregunta a nivel de corpus («qué ha cambiado este trimestre», «de qué se queja la gente») es un problema de resumen disfrazado de retrieval, y el retrieval top-k es la herramienta equivocada para ella sea cual sea tu stack.
El capítulo nunca enseña un router que elija entre local y global para cada query. En la práctica, o expones el modo como parámetro de la API o clasificas la query con un modelo barato — la misma forma que el router multimodal del que se habla más adelante en esta parte.
Opciones de implementación
La lección imprime cuatro; el instructor narra dos y pasa de largo por las otras dos [07:20:05–07:21:06]. Merece la pena tener las cuatro, porque la opción 4 es la receta concreta detrás de lo de que «el paso cuatro es la magia» del enfoque híbrido.
| Opción | Forma | Pros | Contras |
|---|---|---|---|
| 1. Microsoft GraphRAG | pip install graphrag, indexación + query desde la CLI | Completo, bien documentado, listo para producción | Pesado; requiere mucha capacidad de cómputo para indexar |
| 2. LangGraph + Neo4j | Neo4jGraph + GraphCypherQAChain | Control total, se integra con un Neo4j existente | Gestionas tú Neo4j; extracción de entidades manual |
3. LlamaIndex KnowledgeGraphIndex (en pantalla, nunca narrado) | .from_documents(..., max_triplets_per_chunk=10, include_embeddings=True) | Fácil de usar, buena integración con LlamaIndex | «Menos potente que GraphRAG completo» |
| 4. Híbrido vector + grafo (en pantalla, nunca narrado) | búsqueda vectorial → extraer entidades de los resultados → recorrer → el LLM sintetiza | «Lo mejor de los dos mundos» | Más complejo de implementar |
La opción 1 es la recomendación del instructor, dos veces [07:20:05, 07:23:07]:
«Microsoft GraphRAG es la implementación de referencia para producción».
Toda su superficie, tal como se muestra, son tres comandos — y fíjate en que la separación local/global es literalmente un flag 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?"
Las opciones 2–4 tal como aparecen en el archivo de la lección (líneas 369–416), con correcciones
# 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ÓN 4 — Híbrido vector + grafo (prosa en el archivo, líneas 405–416):
- Búsqueda vectorial para encontrar los documentos relevantes.
- Extraer entidades de los documentos recuperados.
- Recorrido del grafo para el razonamiento multi-hop.
- El LLM sintetiza la respuesta final.
Correcciones que necesitas antes de ejecutar nada de esto:
from langchain_community.graphs import Neo4jGraphyfrom langchain.chains import GraphCypherQAChainse han movido los dos. Su sitio mantenido es el paquetelangchain-neo4j:from langchain_neo4j import Neo4jGraph, GraphCypherQAChain.Neo4jGraph(url="bolt://localhost:7687")no pasa credenciales. El constructor recurre a las variables de entornoNEO4J_USERNAME/NEO4J_PASSWORDy lanza un error si no están ni ellas ni los argumentos explícitos — así que la línea solo «funciona» en una máquina que ya tenga exportado el entorno correcto. Pásalas explícitamente o pondrás en producción una dependencia de configuración que nunca dejaste por escrito.- Seguridad:
GraphCypherQAChaingenera y ejecuta Cypher derivado de la entrada del usuario. El LangChain actual exige que lo actives explícitamente conallow_dangerous_requests=Trueprecisamente por eso. Apúntalo solo a una cuenta de Neo4j de solo lectura — es prompt injection con una base de datos detrás (Parte 12). - Desde entonces, LlamaIndex ha ido llevando a los usuarios de
KnowledgeGraphIndexhaciaPropertyGraphIndex.
Ninguna de esas cuatro correcciones viene del curso; verifica cada una con la documentación actual de la librería antes de comprometerte con una versión.
Fíjate también en que requirements.txt fija pyvis>=0.3.2 — presumiblemente para renderizar el grafo — y ningún archivo del repo llega a importarlo. Visualizar el grafo extraído es la herramienta de depuración más barata que vas a encontrar para un pipeline de extracción; la dependencia ya está ahí.
Cuándo usarlo, y cuándo es sobreingeniería
La lección imprime la decisión como dos listas de cuatro puntos [07:21:06–07:22:07]:
| ✅ Usa GraphRAG cuando | ❌ Descarta GraphRAG cuando |
|---|---|
| Los documentos describen relaciones (organigramas, artículos de investigación) | Recuperación de hechos simples — usa RAG estándar |
| Las queries necesitan razonamiento multi-hop | Conjuntos de documentos pequeños (< 100 docs) |
| Preguntas del tipo «¿quién / qué está conectado con X?» | Requisitos de indexación en tiempo real |
| Necesitas resúmenes globales a través de los documentos | Aplicaciones sensibles al coste (indexar es caro) |
El descarte por tiempo real merece desglosarse, porque el capítulo lo afirma sin explicarlo. El índice de GraphRAG no se lleva bien con añadir: un documento nuevo puede introducir entidades que pertenecen a comunidades existentes, lo que invalida los resúmenes de esas comunidades, que son lo que lee la búsqueda global. Añadir un solo documento puede obligar, por tanto, a volver a ejecutar la detección de comunidades y a volver a resumir. Súmale una llamada al LLM por chunk para la extracción, y «indexar es caro» deja de ser una advertencia vaga para convertirse en una factura concreta y recurrente. El grafo de la demo, por su parte, vive en memoria en NetworkX durante la vida del proceso — la persistencia, las actualizaciones incrementales y la reindexación no se tratan nunca.
La lección cierra con siete conclusiones, impresas en __main__ (líneas 466–476); se pueden comprimir en cinco que vale la pena memorizar:
1. El RAG tradicional falla en el razonamiento multi-hop. 2. GraphRAG construye grafos de conocimiento a partir de documentos. 3. Entidades (nodos) + relaciones (aristas) = estructura recorrible. 4. La búsqueda local recorre el grafo para respuestas concretas; la búsqueda global usa resúmenes de comunidades para los temas. 5. Úsalo cuando las relaciones importen y se esperen queries multi-hop — «para cualquier cosa por debajo de eso, no necesitas implementar GraphRAG» 07:23:07.
2 · Multimodal RAG: cuando el significado está en los píxeles
El puente hacia este material es una sola frase 07:24:09:
«El mundo no es solo texto».
Todas las técnicas de esta guía hasta ahora — chunking, búsqueda híbrida, reranking, contextual retrieval, GraphRAG — suponen que el corpus es texto. Los documentos reales son PDFs con tablas, gráficos, escaneos, diagramas. Un pipeline cuyo primer paso es «extrae el texto» ya ha decidido que todo lo que no es texto es ruido, y toma esa decisión en la ingesta, antes de que se ejecute el retrieval o la generación. Ninguna cantidad de reranking ni de prompt engineering aguas abajo lo recupera.
ColPali se define en una sola frase 07:24:31:
«ColPali es un modelo de visión y lenguaje que crea embeddings a partir de imágenes de documentos, no de texto extraído».
Toda la técnica es un desarrollo de esa frase: la unidad de indexación pasa de ser un chunk de caracteres a ser una imagen de una página.
La demostración: la extracción es una operación con pérdidas
La lección imprime una tabla y luego imprime lo que suelen hacer con ella PyPDF o pdfminer. Las dos son cadenas reales del archivo fuente:
# 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 esa transformación murieron exactamente cuatro cosas [07:26:51–07:27:04]:
- La estructura de la tabla — filas y columnas se revuelven en una sola línea continua.
- Los indicadores visuales — los símbolos ✓ y ✗ pueden desaparecer por completo.
- La alineación — ya no puedes saber qué número corresponde a qué región.
- El contexto — que «South va por debajo» es visualmente obvio en la página y está completamente ausente de la cadena.
El rótulo de la lección para esto es tajante, y es la etiqueta mental correcta: «¡LA EXTRACCIÓN DE TEXTO ES UNA OPERACIÓN CON PÉRDIDAS!»
Ahora sube el nivel 07:27:14. Informes financieros complejos con tablas anidadas. Gráficos que muestran tendencias. Diagramas con flechas y conexiones. Diagramas de flujo y organigramas. En cualquiera de ellos, un pipeline que empieza por el texto no es simplemente subóptimo — está descartando la mayor parte de la información de la página y luego responde con total seguridad a partir de lo que queda.
Los dos pipelines
La lección los dibuja uno al lado del otro, y el diagrama es el artefacto más claro del archivo:
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! │
└───────────┘De esa imagen salen dos hechos estructurales, y los dos tienen consecuencias que sobreviven a la técnica.
No hay paso de chunking. La página es el átomo. Todo lo que la Parte 3 te enseñó sobre chunk size, overlap y límites de división simplemente se evapora — junto con toda la clase de bugs que provoca. Es un beneficio real y poco valorado: no puedes partir una tabla en dos chunks si nunca partes nada. También es una limitación real: no tienes granularidad por debajo de la página, y una pregunta cuya respuesta abarca dos páginas no tiene ningún mecanismo para combinarlas.
El retrieval te entrega una imagen, así que el generador tiene que tener ojos 07:28:43. Elegir ColPali para el retrieval obliga a usar un modelo de visión para la generación. De ese acoplamiento sale el coste 10× — no es un detalle de implementación que puedas optimizar más adelante.
Frente a las cuatro pérdidas de arriba, el camino de visión ofrece cuatro garantías simétricas [07:25:21–07:25:33]: las tablas siguen siendo tablas, los gráficos siguen siendo gráficos, se conserva el contexto de la maquetación y no hay errores de extracción de texto — no puedes estropear lo que nunca has parseado. Esta última es, sin hacer ruido, la más fuerte, porque los errores de extracción son de los silenciosos: una columna mal parseada produce una frase bien formada con un número equivocado, y nada en todo tu stack lanza una excepción. La síntesis del instructor, y el núcleo retórico del capítulo 07:26:12:
«Por eso lo multimodal es, efectivamente, el rey».
Y la regla de simetría de embeddings de la Parte 4 vuelve con más fuerza 07:28:00:
«Recordad, tenemos que usar el mismo modelo que hizo el embedding de los documentos».
Aquí la query es texto y los documentos son imágenes. Solo un espacio de embeddings conjunto de visión y lenguaje hace que esa comparación tenga sentido. No puedes mezclar vectores de documento de text-embedding-3-small con vectores de query de ColPali — y, según el invariante 2, el desajuste de dimensiones es el fallo ruidoso. El peligroso es el desajuste semántico silencioso, en el que los números cuadran y los resultados son ruido.
Qué es realmente ColPali — y en qué se equivoca el curso
El bloque de resumen de la propia lección:
# 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 de esos cuatro puntos están bien. La afirmación del «vector único» es incorrecta, y es el error que más probablemente te cueste dinero.
Esa corrección tiene tres consecuencias que tienes que planificar, y ninguna está en el capítulo:
- Almacenamiento. Presupuesta ~10³ vectores pequeños por página, no uno. En un corpus de 10,000 páginas son millones de vectores, y lo que cambia tu modelo de almacenamiento es la huella por página — no el número de páginas.
- El store. Necesitas scoring multivector / MaxSim nativo, no simplemente una columna que acepte un array de floats. Donde tu store no lo tenga, el fallback estándar es en dos etapas: guarda un vector agregado (pooled) por página para generar candidatos de forma barata y luego vuelve a puntuar una lista corta con MaxSim en tu propio proceso. La primera etapa a veces descartará una página que MaxSim habría sacado — pero esa pérdida está localizada en una etapa que puedes medir, que es la diferencia entre un trade-off de ingeniería y un misterio.
- La implementación de referencia de más abajo. Su mean-pooling
mean(dim=1)es ese vector agregado — y usado solo, sin una etapa MaxSim detrás, tira justo lo que hace que ColPali funcione.
La implementación de referencia, leída con ojo crítico
Todo el código de ColPali de la lección vive dentro de una cadena entre triples comillas que se imprime y nunca se ejecuta [07:29:56–07:30:19]. No hay ningún import de colpali_engine, torch, PIL ni pdf2image en ningún punto de la parte ejecutable del archivo. Trata lo que sigue como pseudocódigo que comunica la forma del pipeline — la forma es correcta, la superficie de la API no. (Los listados de abajo omiten las líneas separadoras # ───── que el archivo usa entre secciones; no se ha eliminado nada 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ámetro de ese bloque es una decisión:
| Parámetro | Valor | Por qué importa |
|---|---|---|
| id del modelo | vidore/colpali-v1.2 | vidore/ es la organización de Hugging Face (ViDoRe = Visual Document Retrieval). El propio instructor advierte de los cambios de versión: «esto podría haber cambiado cuando veas esto» 07:30:06. Fíjalo y vuelve a revisar la documentación. |
torch_dtype | torch.bfloat16 | Media precisión. Reduce a la mitad la VRAM frente a fp32 con una pérdida de calidad de retrieval despreciable. |
device_map | "cuda" | GPU hardcodeada. Sin fallback a CPU y sin gestión de errores si no hay GPU. |
dpi | 150 | El único parámetro de renderizado que se da, y un ajuste de precisión que no se comenta — mira el recuadro de abajo. |
torch.no_grad() | — | Solo inferencia: sin grafo de autograd, mucha menos VRAM. Imprescindible a escala de páginas. |
| pooling | .last_hidden_state.mean(dim=1) | Este es el fallo. El mean-pooling colapsa los vectores de parche en uno y destruye la late interaction. Útil como generador de candidatos en una primera etapa; por sí solo no es retrieval de ColPali. |
.cpu().numpy() | — | Saca los resultados de la GPU antes de almacenarlos. Un buen hábito, ya incorporado. |
El lado de la query es el reflejo del lado de los documentos — el mismo objeto de modelo, el mismo pooling —, que es la regla de simetría hecha código. El retrieval es un producto escalar sin más con k=3 por defecto, y devuelve números de página e imágenes 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
Fíjate en la ventaja gratuita escondida en "page_number": idx + 1: como la unidad de retrieval es una página, la granularidad de las citas te sale gratis. «Página 7» no es algo que tengas que reconstruir a partir de los metadatos del chunk — es la clave primaria. Es una ventaja real frente a la trampa del desfase en uno entre page/page_label del RAG de texto, vista en la Parte 2.
Dos defectos en ese bloque: np no se importa en ningún punto del fragmento y — como ya se ha establecido — un producto escalar en bruto, sin normalizar, sobre vectores con mean-pooling no es como ColPali puntúa nada.
La etapa final serializa las imágenes PIL recuperadas a data URLs en base64 y las vuelca en un único mensaje:
answer_with_vision y el driver de extremo a extremo (líneas 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
Ese comentario del paso 2 — # 2. Create embeddings (do once, store in vector DB) — es la frase que hace legible la tabla de costes. El embedding de páginas se amortiza; la llamada de visión, no.
Aviso sobre el stack: este fragmento hace el retrieval con colpali-engine + torch pero responde a través del SDK de OpenAI en bruto, mientras que la parte ejecutable del mismo archivo usa langchain_openai.ChatOpenAI. Elige un solo stack para tu código; mezclarlos significa dos caminos de autenticación, dos políticas de retry y dos sitios que instrumentar (Parte 7).
La trampa de la forma del mensaje
La lección también contiene, comentada, lo que llama la llamada «de producción» con una imagen 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 demo, y su falta de honestidad
La única llamada real de toda la lección le pregunta a GPT-4o «¿Qué región va por debajo del objetivo y por cuánto?» y recibe 07:29:20:
«La región South va por debajo del objetivo, con unas ventas reales de $1.5M frente a un objetivo de $1.8M, lo que da una desviación del -17%».
Y luego el contraste de la «VENTAJA CLAVE», que es lo más útil del capítulo [07:29:27–07:29:55]:
- Con extracción de texto tienes:
"South $1.8M $1.5M -17%"— una cadena que «no tiene mucho contexto» y que «se lo pondría bastante difícil a tu modelo de lenguaje grande». - Con visión el modelo puede ver: la X roja que indica incumplimiento; el contexto de las otras regiones que van bien; la jerarquía visual que muestra a South como la anomalía; cualquier línea de tendencia o gráfico que respalde el análisis.
La idea generalizable: el canal visual transporta juicio, no solo datos. Una X roja es el veredicto de un analista humano codificado en píxeles. La extracción de texto tira el veredicto y se queda con el número en bruto — y luego le pide a un modelo de lenguaje que vuelva a deducir el juicio a partir de una cadena aplanada.
Lo que sí merece la pena llevarse tal cual de esa función es su system prompt, que en la práctica es una instrucción de «cómo leer una página financiera» para un modelo de visión:
# 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""",
),
Cambia el primer párrafo por «You are analyzing the attached document page images» y esos cuatro puntos se convierten en una instrucción de lectura reutilizable para un VLM. Importan porque un modelo de visión a su aire describirá una página; tú quieres que la interrogue.
Cuándo el multimodal RAG justifica su coste
Las dos listas de la lección, con el motivo de cada una [07:30:19–07:31:48]:
| ✅ Perfecto para | Porque |
|---|---|
| Informes financieros | Tablas complejas con cabeceras anidadas, gráficos que muestran tendencias, notas al pie y anotaciones |
| Documentación técnica | Diagramas de arquitectura, diagramas de flujo, código con resaltado de sintaxis |
| Artículos científicos | Figuras y gráficas, ecuaciones matemáticas, visualizaciones de datos |
| Documentos legales | «El formato es importante» — contratos con formato, tablas de condiciones, páginas de firma |
| Historias clínicas | Imágenes diagnósticas, tablas de resultados de laboratorio, gráficas clínicas |
| ❌ No hace falta para | Porque |
|---|---|
| Documentos de texto plano | Novelas, artículos, poemas — no se pierde nada al aplanarlos |
| Datos estructurados simples | El contenido tipo CSV sobrevive intacto a la extracción |
| Documentos en los que la extracción de texto ya funciona bien | «No hace falta pasarse» 07:31:22 |
| Aplicaciones en tiempo real | «Los modelos de visión son más lentos porque hay mucho procesamiento» 07:31:31 |
| Aplicaciones sensibles al coste | GPT-4o con imágenes cuesta bastante más |
Lo legal se lleva la formulación más contundente del capítulo 07:30:51: «y lo más importante, porque el formato es importante». En un contrato, dónde está una cláusula y qué está tachado tiene efectos jurídicos. Una cadena plana lo pierde, y esa pérdida no la recupera un modelo más listo aguas abajo.
Fíjate en que no aparece ninguna cifra de latencia en todo el capítulo. «Más lento» es solo una advertencia cualitativa — presupuesta tu propia medición (la Parte 7 te da la instrumentación para hacerla).
El coste, y lo que valen las cifras
La lección imprime esta comparación [07:31:50–07:32:41]:
| Pipeline | Embedding | Query |
|---|---|---|
| RAG de texto | ~$0.0001 por página | ~$0.01 por query (GPT-4o-mini) |
| Multimodal RAG | ~$0.001 por página (ColPali + GPU) | ~$0.10 por query (GPT-4o con imágenes) |
| Ratio | 10× | 10× |
«¡~10x más caro, pero necesario para el contenido visual!» 07:32:19
Dos cosas que el capítulo no dice, y que cambian las dos cómo deberías leer esa tabla.
Primero, sé honesto con la procedencia. El propio instructor se cubre — «Son solo cifras aproximadas para que os hagáis una idea» 07:31:50 — y hace bien. Ninguna de las cuatro cifras tiene fuente, y la línea de ColPali ni siquiera es el mismo tipo de número que las demás: ColPali se ejecuta en tu propia GPU, así que «$0.001 por página» es hardware amortizado, no una tarifa de API. Quédate con la dirección de la afirmación (el RAG con visión cuesta bastante más, más o menos un orden de magnitud) y trata los dígitos concretos como ilustrativos. No los metas en un business case.
Segundo, haz la multiplicación que el capítulo se salta. Las dos líneas se comportan de forma completamente distinta bajo carga, que es otra vez el invariante 3:
- $0.001/página en tiempo de indexación es un coste único. Indexar un corpus de 10,000 páginas cuesta ~$10, para siempre.
- $0.10/query es recurrente y escala linealmente con el tráfico. Con 10,000 queries/día son ~$1,000/día frente a ~$100/día del RAG de texto — unos $27,000/mes de diferencia, para el mismo corpus.
La checklist — y el router que el curso nunca construye
La checklist de implementación de cinco puntos [07:33:46–07:34:32], impresa al final de la lección:
- ☐ GPU para los embeddings de ColPali — «o puedes usar GPU en la nube, eso se puede comprar».
- ☐ pdf2image para la conversión PDF → imagen.
- ☐ Una base de datos vectorial que admita embeddings de imagen — «no todas las bases de datos vectoriales admiten embeddings de imagen».
- ☐ GPT-4o o Claude para responder a partir de la visión — «o GPT-5 o 10, según cuándo estés viendo este vídeo».
- ☐ Fallback a RAG de texto para los documentos planos.
Cuatro cosas sobre esa lista:
El punto 1 es un requisito duro, y los propios materiales del curso se contradicen sobre él. La checklist dice que necesitas una GPU. device_map="cuda" está hardcodeado. requirements.txt mantiene colpali-engine>=0.3.0 y pdf2image>=1.17.0 comentados con # Uncomment if you have GPU, y solo incluye pillow>=11.0.0. Pero las FAQ del README del repo afirman «¿Necesito una GPU? No. Todo el código se ejecuta en CPU. La sección de Multimodal RAG de la Parte 6 menciona una GPU para ColPali, pero es opcional». Ambas afirmaciones son técnicamente ciertas solo porque el código de ColPali no se ejecuta en ningún punto del curso. Si de verdad ejecutas ColPali, necesitas la GPU.
Al punto 2 le falta una dependencia que el curso nunca menciona. pdf2image es un wrapper de poppler (pdftoppm), un binario del sistema. pip install pdf2image no lo instala, y la conversión fallará en una máquina limpia o en un contenedor slim. En Debian/Ubuntu es apt-get install poppler-utils; añádelo a tu Dockerfile en los términos de la Parte 13.
El punto 3 es una restricción de compras presentada como un comentario de pasada. «No todas las bases de datos vectoriales admiten embeddings de imagen» 07:34:10 — y una vez que aceptas la corrección multivector de arriba, el requisito es más estricto de lo que da a entender el capítulo: necesitas un store que admita scoring multivector de late interaction, no simplemente uno que acepte un array de floats que resulta que has sacado de una imagen. Eso puede descartar con efecto retroactivo el store que elegiste en las Partes 4 y 10 — Chroma, que este curso usa de principio a fin, no tiene comparador MaxSim. El capítulo no nombra ninguna base de datos que cumpla, así que es una pregunta que tienes que responder con la documentación de los proveedores antes de diseñar la arquitectura; el fallback en dos etapas de arriba es a lo que recurres cuando la respuesta es que no.
El punto 5 es una instrucción de arquitectura vestida de detalle amable. «A veces puedes tener una mezcla de distintos tipos de documentos, así que tienes que tener eso preparado» 07:34:26. La mayoría de los corpus reales son mixtos. Sin un router tienes exactamente dos opciones, y las dos son malas: pagar el precio de la visión en cada PDF de texto plano, o perder todas las tablas. El capítulo no enseña código, ni heurística, ni clasificador para esto. Es el mayor hueco sin cubrir del material multimodal, así que esta es la forma que debería tener:
# 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"
Enruta una sola vez en la ingesta, guarda la decisión en los metadatos del documento e indexa cada documento en el camino al que se enrutó. Luego, en tiempo de query, o buscas en los dos índices y fusionas (el RRF de la Parte 6 se aplica sin cambios), o enrutas la query según el índice al que apunten sus filtros. Los umbrales de arriba son puntos de partida que hay que calibrar con tu propio corpus, no constantes — pero un router tosco y medido gana a uno elegante y supuesto.
Las seis conclusiones de la propia lección [07:32:43–07:33:43], impresas al final del archivo:
1. La extracción de texto pierde tablas, gráficos y diagramas. 2. ColPali hace embedding de IMÁGENES de documentos, no de texto extraído. 3. Los LLM con visión (GPT-4o, Claude) pueden «ver» los documentos. 4. Ideal para informes financieros, documentación técnica, cualquier cosa visual. 5. Trade-off: ~10× más caro, pero conserva la información. 6. «El futuro: los documentos son imágenes, no texto».
La sexta la plantea como tema de debate, no como un hecho — «eso es algo para que lo penséis, y quizá empecéis a debatirlo» 07:33:39 — y ese planteamiento es el correcto. La afirmación es interesante en cuanto a dirección y no tiene ninguna evidencia en la fuente. Trátala como una hipótesis que puedes probar en tu propio corpus con un conjunto de evals, que es más de lo que hace el capítulo.
3 · Hacia dónde va todo esto
Los tres últimos capítulos de la fuente son un resumen, una cronología y una sola palabra. Juntos duran unos tres minutos y medio y no contienen código nuevo — pero son los capítulos que te dicen qué hacer de verdad, así que trata cada línea como si sostuviera todo.
Las seis técnicas avanzadas, en una sola tabla de decisión
Esta es la tabla resumen de la Parte 6 que el instructor lee en [07:34:48–07:36:50], con las cifras de los capítulos en los que realmente se establecieron. Fíjate en la estructura de su propio razonamiento: cada fila responde a «¿cuándo uso esto?». Nada aparece clasificado como «lo mejor».
| # | Técnica | Rótulo de la diapositiva | Qué hace | Cuándo usarla | Evidencia (de su propio capítulo) |
|---|---|---|---|---|---|
| 1 | Contexto largo frente a RAG | COST OPTIMIZATION | Elegir el enfoque adecuado | RAG para coste + escala; contexto largo para conjuntos pequeños y estáticos | ~10¢/query frente a casi cero; latencia de ~1 s frente a ~45 s; 25× en el ejemplo resuelto del propio curso (el «más de 1,200×» que se dice de palabra nunca se deriva — Parte 14); la fiabilidad del contexto largo se degrada en torno al 60–70% del límite declarado |
| 2 | Contextual retrieval | DYNAMIC CONTEXT WINDOWS | Añadir a cada chunk contexto escrito por un LLM antes del embedding | Siempre — la única fila incondicional | 49% menos fallos de retrieval en el top-20 (contextual embeddings más contextual BM25, que el curso etiqueta erróneamente como «solo»), 67% al añadir reranking; 1¢–5¢ por documento, coste único (Parte 14) |
| 3 | Late chunking | BETTER COHERENCE & FLOW | Primero el embedding, después el chunking | Documentos con referencias (anáforas, no bibliografías) | +10–12% de precisión; los chunks contextuales crecen un 20–30%; enfoques combinados 25–30% (Parte 14) |
| 4 | Agentic RAG | AUTONOMOUS MULTI-STEP REASONING | Retrieval autocorrectivo | Sistemas en producción | Bucle grade → rewrite → retry sobre LangGraph; max_retries normalmente 2–5 (Parte 15) |
| 5 | GraphRAG | STRUCTURED KNOWLEDGE EXPLORATION | Razonamiento sobre grafos de conocimiento: entidades + relaciones, recorridas | Preguntas multi-hop | Descartar por debajo de 100 documentos; la detección de comunidades compensa a partir de unas 100 entidades (esta parte) |
| 6 | Multimodal / ColPali | IMAGE + TEXT + AUDIO INTEGRATION | Retrieval basado en visión | Documentos con tablas, gráficos, imágenes | «Muy potente pero caro, como habéis visto» — ~10× (esta parte) |
El rótulo de la propia diapositiva es «The 2026 Production RAG Stack» — stack, no menú. Esa elección de palabra es el argumento, y la checklist de abajo lo hace cumplir.
El «estáticos» de la fila 1 trabaja en silencio y es fácil pasarlo por alto: el discriminante no es solo el tamaño del corpus, es la rotación. Un corpus pequeño que cambia constantemente sigue inclinándose hacia el contexto largo, porque te ahorras el re-embed. Y la fila 1 no es un o lo uno o lo otro: la formulación comprimida «RAG para coste y escala» se lee como «no uses nunca contexto largo», y eso no es lo que defiende la Parte 14. Elige por carga de trabajo; los dos conviven en un mismo producto.
La fila 2 es la única recomendación incondicional de todo el curso. Cuando se pregunta cuándo usar contextual retrieval, la respuesta es «Pues siempre», y la justificación dura un instante 07:34:48:
«¿Por qué? Porque son un 67% menos de fallos. Eso compensa la molestia, si se me permite decirlo».
«Compensa la molestia» es el juicio operativo, y concede que hay molestia: una llamada al LLM por chunk en tiempo de indexación, chunks un 20–30% más grandes, más almacenamiento, más latencia de indexación. El veredicto es que un coste de indexación único pesa más que una tasa de fallos recurrente. Dos matices que el resumen deja caer y tú no deberías: el 67% es el benchmark de Anthropic, no el tuyo, y es una cifra del stack, no de la técnica — la Parte 14 lo desglosa como contextual embeddings más contextual BM25 llegando al 49%, y el reranking aportando el resto. Quita la búsqueda híbrida o el reranker y ya no estás midiendo contra el 67%. Los capítulos de la Parte 14 también repiten «tenéis que probarlo vosotros mismos». No dejes que un «67%» a secas se endurezca hasta convertirse en una garantía.
Cuatro eras, y el hecho de que ninguna terminó
La cronología de la diapositiva final 07:37:02:
| Era | Nombre | Qué añadió |
|---|---|---|
| 2023 | Naive RAG | chunk → embed → retrieve → generate. Una sola pasada, sin scoring, sin realimentación, sin fallback. |
| 2024 | Optimized RAG | Búsqueda híbrida (densa + BM25 fusionadas con RRF), reranking, «y demás». La misma forma de pipeline, mejor calidad del retrieval. |
| 2025 | Intelligent RAG | Contextual retrieval y comportamiento autocorrectivo. La primera era en la que el retriever deja de ser una función tonta. |
| 2026 en adelante | Agentic RAG | Autónomo, multimodal, potenciado con grafos. El flujo de control sale de tu código y pasa al agente. |
Las eras son acumulativas, no sustituciones sucesivas, y la checklist de abajo lo demuestra: el reranking es una técnica de 2024 que ocupa el puesto #2 en la lista de 2026. Quitar la búsqueda híbrida y el reranking porque has añadido un agente es una regresión disfrazada de modernización.
La checklist de producción de cuatro puntos
El meollo de toda la secuencia de cierre [07:37:02–07:38:03]. El orden es el del instructor, y codifica prioridad:
- Contextual retrieval — «como mínimo». No es una optimización; es la entrada. «Como mínimo necesitáis al menos contextual retrieval». Coherente con el «¿cuándo usarlo? Pues siempre» del resumen.
- Reranking. Una segunda pasada de scoring de relevancia sobre los candidatos recuperados.
- Patrones agénticos — «esto es el núcleo». Un agente que evalúa lo que ha vuelto, decide si es lo bastante bueno, reformula y reintenta. El argumento a favor es preciso 07:37:02:
«Un sistema robusto que no depende de ti ni solo del código que pusiste en producción».
Con un pipeline cableado, cada modo de fallo que no anticipaste antes del deploy es un bug permanente. Con un agente, las decisiones de retrieval se toman en tiempo de ejecución, por algo que puede mirar lo que ha vuelto y reaccionar. Fíjate en el alcance, porque es fácil sobreinterpretarlo: las decisiones a las que se refiere son «decisiones críticas en lo que respecta al retrieval» 07:37:02 — ¿es este conjunto de candidatos lo bastante bueno?, ¿reescribo la query?, ¿reintento? —, no una autonomía sin correa sobre tu producto. Y dentro del bloque agéntico destaca una capacidad 07:38:03: «la autocorrección, que es la parte más importante».
- Soporte multimodal. La justificación viene de los datos, no de las capacidades: tu corpus ya contiene imágenes, gráficos y tablas que tu pipeline solo de texto está descartando en silencio en la ingesta. Aquí la diapositiva va más allá que la narración — su tarjeta dice «IMAGE + TEXT + AUDIO INTEGRATION». No reduzcas «multimodal» a PDFs-como-imágenes.
En la cronología se esconde un paso 0 implícito: se da por hecho que ya tienes búsqueda híbrida por debajo. Hacer reranking sin nada bueno que reordenar es teatro.
La lista se plantea como duradera y no ligada a versiones — «este año y el que viene y los que vendrán» 07:37:02 —, que es el registro correcto. Ninguno de esos cuatro puntos nombra un modelo, una versión de librería ni un proveedor. Eso es lo que la hace sobrevivir: todos los detalles concretos de esta guía se pudrirán, y este orden no.
Fíjate en lo que no está en esa lista, y apúntaselo a la fuente: la evaluación. No hay un punto de «mide la calidad de tu retrieval», ni de conjunto de evals, ni de tests de regresión — pese a que cada recomendación de arriba depende de una métrica («empieza con recursive, mide la calidad de tu retrieval»; «pruébalo tú mismo»). Una checklist de cuatro puntos que te dice que añadas contextual retrieval, reranking, un agente y visión, pero no que midas si alguno de ellos ha servido, describe un sistema incapaz de decirte cuándo ha empeorado. Ese es el trabajo de las Partes 7 y 15, y su sitio está en esta lista.
El veredicto, y el estado honesto de la frontera
El pareado final del curso llega partido entre dos capítulos. El capítulo final de los 32 es literalmente una palabra — RAG., tres segundos en 07:38:37 — porque la marca de YouTube de 07:38:35 cae en mitad de la última frase. No hay tarjeta final, ni resumen, ni próximos pasos, ni URL del repo; el vídeo se corta en seco en 07:38:38, su duración total. Lo que significa que la fuente no aporta ninguna conclusión que heredar, y el juicio de cierre es lo único que te entrega:
«Así que la estrategia ingenua de trocear y rezar está muerta. Bueno, bienvenidos al futuro del RAG». [07:38:31–07:38:39]
«Trocear y rezar» es el término despectivo adecuado para lo adecuado: partir con un tamaño fijo, hacer embedding, coger el top-k, esperar que aparezca el chunk correcto, ponerlo en producción y no tener instrumentación para saber cuándo no aparece. Eso ya no es un diseño de producción defendible, y esta guía ha dedicado quince partes a explicar por qué.
Pero ten claro qué partes de «el futuro» entrega realmente este material, porque la brecha es amplia y conocerla es la diferencia entre construir y copiar a ciegas:
| Afirmación | Estado en la fuente | Lo que tienes que aportar tú |
|---|---|---|
| GraphRAG responde queries multi-hop | Demostrado — sobre un grafo de 6 nodos escrito a mano con un recorrido hardcodeado | Extracción real, resolución de entidades, persistencia del grafo, parsing de queries de lenguaje natural→patrón de grafo |
| GraphRAG automatiza la construcción del grafo con un LLM | Demostrado a medias — el extractor se ejecuta, pero nada convierte su salida de vuelta en nodos y aristas | Structured output, un loader, deduplicación |
| Búsqueda local frente a global | Explicado, nunca implementado | Un router, o exponer el modo como parámetro |
| ColPali conserva lo que la extracción destruye | Afirmado, nunca demostrado — la única llamada real envía texto, no una imagen | Una ejecución real de ColPali de extremo a extremo sobre tu corpus, antes de presupuestarlo |
| ColPali da «un embedding por imagen» | Incorrecto — es late interaction multivector (una cuadrícula de vectores de parche por página, puntuada con MaxSim) | Un store capaz de hacer scoring multivector, o un retriever en dos etapas: vector agregado y luego MaxSim |
| Qué significa «late interaction» | Aparece en el acrónimo, nunca se explica — ni ColBERT, ni MaxSim, ni una palabra sobre multivector en ningún sitio | El mecanismo, antes de dimensionar el almacenamiento o elegir un store |
| Multimodal cuesta ~10× | Aproximado y sin fuente, según admite el propio instructor | Tu propia medición; la dirección es correcta, los dígitos no |
| «Fallback a RAG de texto para los documentos planos» | Aparece como punto de la checklist, sin código | El router (hay un esbozo más arriba) |
| Precisión del RAG con visión frente al RAG de texto | Ningún benchmark en ningún sitio — ni cifras de ViDoRe, ni diferencia | Tu propio conjunto de evals |
| Latencia del embedding / la respuesta con visión | «Más lento». Ninguna cifra. | Tu propia medición |
| Dimensionamiento de GPU detrás de «$0.001 por página» | Nunca se deriva — ni tarjeta, ni throughput, ni $/hora | Un benchmark en la GPU que realmente puedes alquilar |
| Licencia y condiciones de hosting de PaliGemma | No se menciona en absoluto | Una revisión de la licencia antes de un despliegue comercial |
Entorno y pins de versiones del código de la Parte 6 (los dos archivos de esta parte)
Los dos archivos de la lección viven en el segundo repo, fcc-production-rag-part-6 — el que montas por separado en la Parte 2. Su entorno declarado:
pyproject.toml:requires-python = ">=3.13", con.python-versionfijado a3.13. El curso se ejecutaba a la vista con Python 3.12.2 en pantalla (barra de estado de VS Code durante todo el capítulo 29), y el README del repo dice 3.10+. Tres respuestas distintas; fíate del código que puedas ejecutar.- El repo lleva dos archivos de dependencias que no coinciden, lo cual es en sí mismo la lección:
requirements.txtes el amplio (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, según un comentario explícito del archivo —,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.tomlrecoge un subconjunto más estrecho de ocho paquetes y añadeopenai>=2.32.0, querequirements.txtnunca menciona. Instala desde uno de los dos, no desde ambos. - GraphRAG (lección 6.5):
networkx>=3.3enrequirements.txt,networkx>=3.6.1enpyproject.toml, máspyvis>=0.3.2— fijado para visualizar el grafo, solo enrequirements.txt, y que ningún archivo importa nunca. - Multimodal (lección 6.6): solo se instala
pillow>=11.0.0.colpali-engine>=0.3.0ypdf2image>=1.17.0están comentados con# Uncomment if you have GPU. Ninguno de los dos lo importa la parte ejecutable del archivo, y por eso toda la lección de 526 líneas se ejecuta en 2 segundos y hace exactamente una llamada a la API. - También están:
sentence-transformers>=5.0.0(reranking, opcional),langchain-classic>=1.0.0(retrievers heredados),langchain-anthropic>=0.4.0(contextual retrieval, Parte 14).
Ids de modelo en los seis archivos de la Parte 6: gpt-4o-mini en las lecciones 1, 2, 4 y 5; gpt-4o en la lección 6; text-embedding-3-small en las lecciones 1–4. La lección 1 también menciona gpt-5.4-nano en sus cuentas de costes. Ningún archivo del repo tiene un test, una comprobación de tipos, un retry a nivel de API, un backoff, un timeout ni un control de presupuesto de tokens — cada llamada al LLM es un chain.invoke(...) a pelo. El único try/except de los seis archivos (lección 4, línea 191) protege un parseo con float() de la salida de un grader, no una llamada de red; el max_retries de la lección 4 acota el bucle de retrieval, no los fallos de la API. Esa es la distancia entre el código de este curso y la palabra «producción» de su título, y las Partes 11–13 de esta guía existen para cerrarla.
Nada de eso hace que las técnicas sean incorrectas. Las hace frontera — que es justo como se llama esta parte. La postura honesta para un ingeniero de infraestructura es: los mecanismos son reales y los modos de fallo que atacan son reales, las demostraciones son flojas y las cifras son orientativas. Construye primero el arnés de evals, luego adopta las técnicas de una en una y quédate con la que mueva la cifra.
Decisiones que tomar
Recórrelas en orden. Cada una es una bifurcación que deberías resolver a conciencia y no por defecto.
¿Tienes siquiera un problema multi-hop?
- Saca 100 queries reales de tus logs. Etiqueta cada una: ¿responderla requiere encadenar hechos de dos o más documentos? Si menos de ~10% son multi-hop, para — no necesitas un grafo, y las Partes 6 y 14 te darán más.
- Comprueba la firma del fallo antes de construir nada: ¿estaban los chunks correctos en el contexto y aun así la respuesta era incorrecta? Eso es un join que falta, no recall que falta. Si los chunks correctos no estaban en el contexto, arregla primero el retrieval.
- Comprueba la escala: por debajo de 100 documentos, descarta GraphRAG. Por debajo de 50,000 tokens en total, plantéate el contexto largo (Parte 14).
- Comprueba la rotación: si tu corpus necesita indexación casi en tiempo real, GraphRAG queda descartado. La extracción más el re-resumen de comunidades no es una operación que se lleve bien con añadir.
Si vas a construir el grafo:
- Elige tu implementación: Microsoft GraphRAG para una implementación completa y con opiniones propias (cómputo de indexación pesado); Neo4j +
GraphCypherQAChainsi ya tienes Neo4j y quieres control (credenciales de solo lectura, yallow_dangerous_requests=Trueentendido como la advertencia que es); LlamaIndexPropertyGraphIndexpara el camino fácil; híbrido vector + grafo si quieres conservar tu retriever actual y añadir el recorrido por encima. - Diseña tu vocabulario de relaciones antes de extraer, en
SCREAMING_SNAKE_CASE, y fíjalo en el prompt de extracción. El recorrido empareja las cadenas de relación de forma exacta. - Usa structured output (Pydantic) para la extracción, no instrucciones de formato en texto libre. Necesitas objetos, no prosa.
- Presupuesta de forma explícita la resolución de entidades. No es opcional y la fuente nunca la menciona.
- Decide cómo persistes el grafo y cómo lo actualizas de forma incremental. NetworkX en memoria es una demo.
- Devuelve el camino de razonamiento con cada respuesta de grafo. Es tu cita.
- Mantén la búsqueda vectorial junto al grafo. El paso 4 es híbrido; un retriever solo de grafo pierde recall en todas las queries no relacionales.
¿Tienes un problema de visión?
- Abre diez documentos al azar de tu corpus y pásales tu extractor actual. Si las tablas y las figuras sobreviven como texto utilizable, para — no necesitas esto.
- Clasifica por tipo de documento: financiero / técnico / científico / legal / médico → probablemente sí. Novelas, artículos, contenido tipo CSV → no.
- Multiplica antes de comprometerte:
queries/day × $0.10frente aqueries/day × $0.01. Con 10k queries/día la diferencia ronda los $27k/mes. ¿Lo vale el corpus? - Revisa tu presupuesto de latencia. Los modelos de visión son más lentos y nadie te ha dicho cuánto.
- Demuestra la premisa antes de financiarla. Coge veinte páginas que tu extractor destroce, ejecuta sobre ellas un retrieval real con ColPali y una respuesta real con visión, y compáralo con tu pipeline de texto en las mismas preguntas. Nadie en la cadena de la fuente lo ha hecho; toda la tesis está sin probar hasta que la pruebes tú.
Si vas a construir el camino de visión:
- Consigue una GPU — local o en la nube. La GPU no es opcional, diga lo que diga el README.
- Instala poppler (
poppler-utils) junto apdf2image. Es un paquete del sistema. - Verifica que tu vector store admite scoring multivector de late interaction, no simplemente «embeddings de imagen». Hazlo antes de diseñar la arquitectura. Si no lo admite, decide ya entre cambiar de store y construir el retriever en dos etapas (vector agregado y luego MaxSim) — y dimensiona el almacenamiento para ~10³ vectores por página en cualquier caso.
- Fija
vidore/colpali-v1.2y ponte un recordatorio para revisar la model card. Los ids de modelo caducan. - Calibra
dpi. 150 es el valor por defecto; prueba 200–300 en tus páginas más densas y lee en qué se equivoca el modelo. - No dejes nunca que un vector con mean-pooling sea tu score final. El pooling es una primera etapa legítima; quedarte ahí significa que has comprado un pipeline de visión y has tirado su calidad de retrieval.
- Construye el router texto-frente-a-visión en tiempo de indexación, guarda la decisión en los metadatos y mantén vivos los dos caminos.
- Reutiliza como system prompt la instrucción de lectura para VLM de cuatro puntos (números, indicadores visuales, tendencias de los gráficos, relaciones entre puntos de datos). Un modelo de visión a su aire describirá la página en lugar de interrogarla.
- Aprovecha la granularidad de citas gratuita: las imágenes de página te dan «página 7» como clave primaria, no como una reconstrucción.
Antes de dar nada de esto por terminado:
- Pasa la checklist de 2026 por tu sistema, en orden: contextual retrieval (el suelo) → reranking → patrones agénticos (el núcleo, y dentro de él la autocorrección) → soporte multimodal. Confirma que no se ha perdido nada de una era anterior por el camino — la búsqueda híbrida y el reranking sobreviven a la llegada de un agente.
- Añade el punto que omite la checklist de la fuente: un conjunto de evals y una barrera de regresión. Cada técnica de esta parte es una afirmación del tipo «pruébalo tú mismo». Sin medición no puedes distinguir la adopción de la decoración — y, según el invariante 4, nada va a lanzar una excepción para avisarte.