Agentic RAG en local: cuándo vale la peine

#El agentic RAG en resumen

Un RAG clásico sigue un camino fijo: la pregunta desencadena una búsqueda, los pasajes encontrados van al prompt y el modelo responde. El agentic RAG sustituye ese camino por un bucle. El modelo dispone de herramientas de búsqueda y decide por sí mismo si las llama, con qué consulta y cuántas veces, hasta considerar que puede responder o que debe desistir.

El curso AI Agents for Beginners de Microsoft lo describe como un funcionamiento en el que el modelo planifica sus próximos pasos mientras busca información en fuentes externas, con un bucle de tipo «maker-checker»: producir, verificar, corregir. Ese mismo curso recuerda el límite de esta autonomía: se ejerce dentro de la tarea y de las herramientas que le hayas proporcionado.

La conclusión práctica cabe en una frase. Si tu RAG falla porque una sola búsqueda no puede reunir toda la respuesta, un bucle puede ayudar. Si falla porque la ingesta o la fragmentación son deficientes, el bucle solo repetirá el problema, más lentamente.

#Agentic RAG o RAG de una sola pasada: la diferencia

Los componentes básicos siguen siendo los mismos: embeddings, base de datos vectorial y modelo de generación. Si no te resultan familiares, empieza por la introducción al RAG local. Lo que cambia es quién decide la secuencia. En un RAG clásico, es tu código; en un RAG agéntico, es el modelo, dentro de los límites que le impone el código.

Consulta

RAG clásico: la pregunta del usuario, a veces reescrita una vez. Agéntico: el modelo formula sus propias consultas y puede descomponer una pregunta en varias.

Número de búsquedas

RAG clásico: una, conocida de antemano. Agéntico: variable de una pregunta a otra, acotada por un límite que tú fijas.

Fuentes

RAG clásico: por lo general, un solo índice. Agéntico: varias herramientas posibles (índice vectorial, búsqueda por palabras clave, base SQL), entre las que elige el modelo.

Control del resultado

RAG clásico: ninguno, el modelo redacta con lo que ha recibido. Agéntico: el modelo puede considerar insuficientes los fragmentos y volver a buscar, lo cual no es una garantía: también puede equivocarse en ese juicio.

Exigencia para el modelo

RAG clásico: cualquier modelo capaz de redactar a partir de fragmentos. Agéntico: un modelo que gestione correctamente la llamada a herramientas.

Previsibilidad

RAG clásico: tiempo de respuesta bastante regular. Agéntico: tiempo variable y recorrido que hay que controlar en las trazas.

Tres mecanismos componen el bucle. La planificación: descomponer la pregunta en subpreguntas. El uso de herramientas: traducir cada subpregunta en una llamada. La repetición: leer el resultado y decidir si hay que reformular o concluir. Para la arquitectura general de un agente (memoria, salvaguardas, supervisión), consulta la guía dedicada: aquí solo nos interesa el bucle de búsqueda.

También existe una opción intermedia que a menudo se olvida: el pipeline de etapas fijas. Una reescritura de la consulta, una búsqueda híbrida y luego un reranker se ejecutan siempre en el mismo orden, sin que el modelo decida nada. Esto no es agéntico, y suele ser lo primero que conviene probar.

#Cuándo vale la pena el agentic RAG

El criterio correcto es la forma de tus preguntas, no el nivel de sofisticación que quieras alcanzar. Observa los fallos reales de tu RAG actual y luego clasifícalos.

Preguntas de varios saltos

La respuesta a una primera búsqueda determina la segunda: encontrar al proveedor de un contrato y luego la cláusula que se aplica a ese proveedor.

Comparaciones entre documentos

«Compara el plazo de preaviso de los contratos A y B» requiere dos búsquedas distintas. Una sola consulta puede devolver cinco pasajes del mismo contrato.

Varias fuentes de distinta naturaleza

Una cifra en una base SQL y una explicación en varios PDF. El modelo elige la herramienta según la pregunta, como describe el curso de Microsoft para las interacciones complejas con una base de datos.

Tolerancia a la espera

Búsqueda documental, preparación de un expediente, procesamiento en segundo plano: unas decenas de segundos más no molestan a nadie si el resultado se revisa.

Corrección prioritaria sobre la velocidad

Cuando una respuesta incompleta sale cara, un paso de verificación tiene sentido, siempre que mantengas una revisión humana de las decisiones importantes.

En cambio, quédate con un RAG simple en estas situaciones:

Preguntas frecuentes y preguntas de una sola fuente

La respuesta se encuentra en un fragmento: basta con una búsqueda, y un bucle solo añade espera.

Asistente conversacional en hardware modesto

El usuario espera una respuesta rápida y el modelo ya funciona cerca de sus límites.

Búsqueda que no encuentra los fragmentos correctos

Corrige primero la división en fragmentos, los embeddings y la búsqueda híbrida. Repetir una búsqueda mal ajustada da otros malos resultados.

Cálculo exacto sobre datos estructurados

Una consulta SQL escrita y probada es más fiable que un agente que improvisa una.

Múltiples vínculos entre entidades en todo el corpus

Si lo que necesitas es recorrer relaciones a gran escala, un enfoque basado en grafos responde a otro problema: consulta la guía GraphRAG.

#El costo en latencia y en modelo

En la nube, cada vuelta del bucle se nota en la factura. En local, se nota en el reloj y en la memoria. Hay tres partidas que importan.

#La latencia se multiplica

Para N búsquedas, el modelo genera N + 1 veces: una vez antes de cada búsqueda y una última para la respuesta. Un RAG de una sola pasada genera solo una vez. Como el prompt se alarga en cada turno, cada generación relee más texto, salvo lo que la caché de contexto del runtime permita reutilizar. El tiempo total depende del modelo, de la cuantización y de la máquina; mídelo en tu equipo en lugar de fiarte de una cifra general.

#El contexto se llena rápido

Cálculo ilustrativo: 4 pasajes de 1 200 caracteres representan unos 1 400 tokens, a razón de 3 a 4 caracteres por token. Por tanto, cinco búsquedas añaden unos 7 000 tokens, sin contar la pregunta, las instrucciones ni los razonamientos del modelo. Con num_ctx en 8192, el margen casi ha desaparecido. Ollama trunca entonces el contexto, y los primeros resultados, a veces las instrucciones, pueden quedar fuera de la ventana sin que la aplicación lo indique claramente.

Aumentar num_ctx consume más memoria y ralentiza las vueltas siguientes. Suele ser mejor devolver menos pasajes o resumir su contenido antes de volver a inyectarlo.

#El modelo debe poder sostener el bucle

El modelo debe generar llamadas a herramientas bien formadas y luego juzgar si lo que ha leído es suficiente. Comprueba la compatibilidad con ollama show: la sección Capabilities debe mencionar tools. Esta comprobación indica que el formato es compatible, no que el modelo tome buenas decisiones.

RTX 3060 12 GB o RTX 4070 12 GB

Un modelo de 7 a 9B en Q4_K_M (referencia del sitio: 7B ≈ 5 GB) deja espacio para el contexto y el embedding. Es el punto de partida del siguiente ejemplo, con qwen3.5:9b.

RTX 4080 16 GB

Un 14B en Q4_K_M (≈ 9 GB) cabe con un margen más cómodo para un contexto ampliado.

RTX 4090 24 GB o M4 Pro de 24 a 48 GB

Un modelo más grande pasa a ser una opción, como qwen3.8:27b (unos 18 GB). Con 24 GB, vigila cuánto queda libre una vez ampliado el contexto.

#Elegir un orquestador

El orquestador ejecuta el bucle: transmite las llamadas a herramientas, devuelve los resultados al modelo y aplica los límites. Existen tres vías, todas compatibles con un modelo local.

Bucle escrito a mano

Una veintena de líneas en torno a la API de chat de Ollama y su parámetro tools. Sirve para entender el mecanismo o para un caso muy simple. Tendrás que escribir tú mismo los límites y las trazas.

LangGraph

El bucle es un grafo explícito de nodos y aristas, con estado, límite de recursión y streaming de los pasos. Buena opción si quieres controlar cada transición. Es la de nuestro ejemplo.

LlamaIndex

Interesante si tu ingesta y tus índices ya están ahí: sus agentes reutilizan tus motores de consulta como herramientas.

No elijas por popularidad. Si tu pipeline ya funciona con un framework, quédate con él. En cualquier caso, fija tus versiones: estas bibliotecas evolucionan rápido y sus funciones preconstruidas cambian. Por eso nuestro ejemplo escribe el grafo de forma explícita, lo que además hace que el bucle sea legible.

#Prerrequisitos

Ollama

Instalado y a la escucha en http://localhost:11434.

Python

Un entorno virtual reciente. Comprueba la versión que exigen los paquetes en el momento de la instalación.

Documentos

Algunos archivos Markdown o de texto en una carpeta mes_documents. Para archivos PDF, retoma la ingesta del tutorial de ChromaDB.

Memoria

Unos 6 GB libres para un modelo de 9B y su contexto, más si amplías num_ctx.

#Ejemplo de agentic RAG con LangGraph y Ollama

El ejemplo construye un agente que dispone de una sola herramienta de búsqueda, montada sobre un índice local de ChromaDB. Es deliberadamente minimalista para que el bucle quede a la vista.

#Paso 1: instalar los modelos y los paquetes

ollama pull qwen3.5:9b
ollama pull nomic-embed-text
ollama show qwen3.5:9b

python -m venv .venv
source .venv/bin/activate
pip install langgraph langchain-ollama chromadb ollama
pip freeze > requirements.txt

#Paso 2: indexar los documentos

La división por caracteres solo sirve para que el ejemplo sea breve. En un corpus real, usa una división que respete la estructura y un modelo de embedding validado con tus textos en francés.

from pathlib import Path

import chromadb
import ollama

EMBED_MODEL = "nomic-embed-text"

client = chromadb.PersistentClient(path="./chroma_db")
collection = client.get_or_create_collection(
    "docs", metadata={"hnsw:space": "cosine"}
)


def decouper(texte, taille=1200, recouvrement=150):
    pas = taille - recouvrement
    return [texte[i:i + taille] for i in range(0, len(texte), pas)]


for fichier in Path("mes_documents").glob("*.md"):
    morceaux = decouper(fichier.read_text(encoding="utf-8"))
    if not morceaux:
        continue
    vecteurs = ollama.embed(model=EMBED_MODEL, input=morceaux)["embeddings"]
    collection.upsert(
        ids=[f"{fichier.name}-{i}" for i in range(len(morceaux))],
        documents=morceaux,
        embeddings=vecteurs,
        metadatas=[{"source": fichier.name} for _ in morceaux],
    )

print(collection.count(), "passages indexés")

#Paso 3: escribir la herramienta y el bucle

La descripción de la herramienta importa: es lo que lee el modelo para decidir si la llama. La instrucción del sistema obliga a buscar antes de responder, a separar las subpreguntas y a admitir la falta de información.

import chromadb
import ollama
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_core.tools import tool
from langchain_ollama import ChatOllama
from langgraph.graph import START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode, tools_condition

EMBED_MODEL = "nomic-embed-text"
collection = chromadb.PersistentClient(path="./chroma_db").get_collection("docs")


@tool
def chercher_documents(requete: str) -> str:
    """Cherche dans les documents internes. Utiliser une requête courte
    portant sur un seul sujet. Renvoie des passages précédés de leur source."""
    vecteur = ollama.embed(model=EMBED_MODEL, input=requete)["embeddings"][0]
    res = collection.query(query_embeddings=[vecteur], n_results=4)
    passages = zip(res["documents"][0], res["metadatas"][0])
    return "\n\n".join(f"[{m['source']}] {d}" for d, m in passages) or "Aucun passage."


outils = [chercher_documents]
llm = ChatOllama(model="qwen3.5:9b", temperature=0, num_ctx=8192).bind_tools(outils)

CONSIGNE = SystemMessage(content=(
    "Tu réponds uniquement à partir des résultats de chercher_documents. "
    "Si la question porte sur plusieurs sujets, fais une recherche par sujet. "
    "Si les passages ne suffisent pas, reformule une fois puis dis clairement "
    "ce que tu n'as pas trouvé. Cite la source entre crochets."
))


def agent(state: MessagesState):
    return {"messages": [llm.invoke([CONSIGNE] + state["messages"])]}


graphe = StateGraph(MessagesState)
graphe.add_node("agent", agent)
graphe.add_node("tools", ToolNode(outils))
graphe.add_edge(START, "agent")
graphe.add_conditional_edges("agent", tools_condition)
graphe.add_edge("tools", "agent")
app = graphe.compile()

if __name__ == "__main__":
    question = "Compare la durée de préavis du contrat A et du contrat B."
    entree = {"messages": [HumanMessage(content=question)]}
    for etape in app.stream(entree, {"recursion_limit": 12}, stream_mode="values"):
        etape["messages"][-1].pretty_print()

#Paso 4: leer la traza

La ventaja de stream_mode="values" es que muestra cada mensaje. Lee la traza antes de la respuesta final, con la ayuda de esta tabla:

1. 01
   ¿El modelo llama a la herramienta?

   Si responde directamente, no está buscando: refuerza la instrucción o cambia de modelo.
2. 02
   ¿Tienen sentido las consultas?

   Para la comparación, lo ideal es esperar una consulta por contrato. Una sola consulta que repita toda la pregunta indica que la descomposición no se está haciendo.
3. 03
   ¿Los pasajes responden a la pregunta?

   Si los extractos no tienen relación con el tema, el problema está en el índice, no en el agente.
4. 04
   ¿La respuesta se basa en los extractos?

   Comprueba cada cita entre corchetes en el pasaje correspondiente.

#Paso 5: acotar el bucle

Cada búsqueda consume dos pasos del grafo (agente y luego herramienta). Por tanto, un límite de 12 permite cinco búsquedas y después la respuesta final. Más allá de eso, LangGraph lanza un error GraphRecursionError (módulo langgraph.errors): captúralo en tu aplicación y devuelve un mensaje explícito, en lugar de dejar al usuario frente a una traza de error.

#Errores que evitar y solución de problemas

El modelo nunca llama a la herramienta

Comprueba tools en ollama show, reformula la descripción de la herramienta y prueba otro modelo. No lo compenses con una instrucción cada vez más larga.

Repite la misma búsqueda

El modelo da vueltas en círculo. Baja el límite y, en la herramienta, devuelve un mensaje claro cuando la consulta ya se haya hecho.

La respuesta olvida los primeros resultados

Señal probable de contexto truncado. Reduce n_results, divide en fragmentos más pequeños o aumenta num_ctx si la memoria lo permite.

Las respuestas se vuelven muy lentas

Mira ollama ps: quizá una parte del modelo esté en el procesador, o los modelos se estén turnando en la memoria. Cuenta también el número de vueltas en la traza.

Inventa aunque no ha encontrado nada

El bucle no impide que el modelo invente. Controla las citas por programa: cada fuente citada debe figurar en los resultados de herramientas de la conversación.

Una herramienta demasiado potente

Un agente que lee documentos también recibe su contenido, posiblemente hostil. Dale herramientas de solo lectura y una validación humana para cualquier acción que modifique algo.

#Decidir a partir de tus propias preguntas

Las cifras publicadas en otros lugares se refieren a otros corpus, otros modelos y otros ajustes. Solo una comparación con tus datos permite decidir, y no requiere mucho hardware.

1. 01
   Crear un conjunto de preguntas

   Toma preguntas reales cuya respuesta y pasajes fuente conozcas, combinando preguntas simples y preguntas de varios saltos. Lleva un registro del tipo de cada pregunta.
2. 02
   Establecer una referencia

   Pásalas por tu RAG actual, sin agente. Anota si se recuperó el pasaje correcto, si la respuesta es correcta y el tiempo total.
3. 03
   Cambiar una sola cosa

   Ejecuta el mismo conjunto con el agente, con el mismo índice y el mismo modelo, en la misma máquina.
4. 04
   Leer por tipo de pregunta

   Mira el resultado por separado para las preguntas simples y las complejas, y anota el número de búsquedas por pregunta. Una media global puede ocultar una ganancia en unas y una pérdida de tiempo en otras.
5. 05
   Conservar lo que se justifica

   Si solo algunas preguntas se benefician, puede bastar con un enrutamiento: RAG directo por defecto y bucle para las preguntas detectadas como complejas.

Para automatizar la parte de calidad de esta comparación, la guía dedicada a Ragas presenta métricas adecuadas. Anota también la versión de los paquetes, el modelo, la cuantización y num_ctx: sin eso, tu resultado no será comparable el mes siguiente.

#Para ir más allá

El agentic RAG se apoya en un RAG que ya funciona. Estas guías cubren la base que debes estabilizar primero, los enfoques afines y la arquitectura de agentes.