Agentic RAG: Más allá de los simples chatbots

La palabra de moda "agente de IA" está en todas partes. Pero, ¿qué significa realmente y por qué debería importarle?

Los chatbots simples que utilizan RAG (Generación Aumentada de Recuperación) básico son limitados: responden preguntas estáticas a partir de una base de conocimientos fija. No pueden razonar a partir de múltiples fuentes, planificar una secuencia de acciones o corregirse cuando algo sale mal.

Agentic RAG ​​cambia eso. Les brinda a los LLM la capacidad de pensar, planificar, recuperar, actuar y autocorregirse, lo que los hace capaces de manejar flujos de trabajo complejos de varios pasos que van mucho más allá de los robots de preguntas frecuentes.

Este artículo es su guía práctica para crear agentes de IA que realmente funcionen en producción.

Table of Contents

• Por qué el RAG simple se queda corto
• La arquitectura RAG Agentic
• Bloques de construcción: marcos y herramientas
  • 1. LangGraph (por LangChain)
  • 2. LlamaIndex + AgentWorkflow
  • 3. Personalizado con contornos
• Un ejemplo completo: agente de atención al cliente
• Patrones avanzados
  • Encadenamiento de herramientas y transferencia de datos
  • Gestión de memoria y contexto
  • Colaboración entre múltiples agentes
  • Humano en el circuito
• Lista de verificación de preparación para la producción
• Cuándo NO utilizar agentes
• El resultado final
• Conclusiones clave
• ¿Necesita ayuda para crear agentes

Por qué el RAG simple se queda corto

!Agentic RAG system architecture: retrieval, reasoning, action, and memory components

RAG básico funciona así:

1. El usuario hace una pregunta
2. El sistema recupera documentos relevantes de una base de datos vectorial
3. LLM genera una respuesta basada en esos documentos.
4. Devolver respuesta

Es excelente para preguntas frecuentes, pero frágil para cualquier cosa que requiera:

• Razonamiento de varios pasos: "¿Cuál es el mejor proveedor de nube para una aplicación de transmisión de video que también necesita capacitación en aprendizaje automático y cumplimiento del RGPD?" requiere comparar AWS, GCP y Azure en tres dimensiones.
• Uso de herramientas: "Resérvame el vuelo de ida y vuelta más barato a Tokio la próxima semana que llegue antes de las 10 a.m. y tenga asiento junto a la ventana". necesita búsqueda de vuelos, comparación de precios, selección de asientos.
• Memoria y estado: "Según mis pedidos anteriores, ¿qué producto debo considerar a continuación?" necesita acceso al historial de pedidos.
• Recuperación de errores: si una búsqueda web falla o devuelve basura, un sistema RAG simple simplemente se da por vencido. Un agente puede volver a intentarlo con una consulta diferente o recurrir a un resultado almacenado en caché.

La arquitectura RAG Agentic

Un sistema agente agrega tres capas además del RAG básico:

A continuación se muestra un flujo de agente típico:

Usuario: "¿Cuál será el tiempo en Tokio la próxima semana? ¿Debería llevar un paraguas?"

Agente (planificador):
  Paso 1: Obtenga el pronóstico del tiempo para Tokio
  Paso 2: según el pronóstico, determine si se necesita paraguas

Agente (Paso 1 del Ejecutor):
  - Búsqueda web: "Previsión del tiempo en Tokio la próxima semana"
  - Analizar resultados, extraer temperaturas y precipitaciones.

Agente (Paso 2 del Ejecutor):
  - Si precipitación > 30% → "Sí, empacar paraguas"
  - Más → "No se necesita paraguas"

Agente (crítico):
  - Verificar: ¿Conseguimos las fechas correctamente? (la próxima semana = ¿7 días a partir de hoy?)
  - Verificar: ¿Analizamos los números correctamente? (¿Umbral del 30% arbitrario?)
  - Si no está seguro, pregunte al usuario: "¿Quiere un pronóstico detallado día a día?"

Respuesta final: "Tokio estará mayormente soleado con un 20% de probabilidad de lluvia. No se necesita paraguas".

Bloques de construcción: marcos y herramientas

No es necesario crear esto desde cero. Varios marcos de código abierto admiten flujos de trabajo agentes:

1. LangGraph (por LangChain)

LangGraph le permite definir gráficos cíclicos donde los nodos son llamadas o herramientas de LLM. Perfecto para agentes que necesitan realizar un bucle hasta que se cumpla una condición.

desde langgraph.graph importar StateGraph, FIN
desde langchain_core.messages importar HumanMessage

clase EstadoAgente(TypedDict):
    mensajes: lista[MensajeHumano]
    siguiente: str

def recuperar_nodo(estado: EstadoAgente):
    consulta = estado['mensajes'][-1].content
    documentos = vector_db.search(consulta)
    return {"mensajes": [SystemMessage(content=f"Context: {docs}")]}

def nodo_razonamiento(estado: EstadoAgente):
    respuesta = llm.invoke(estado['mensajes'])
    devolver {"mensajes": [respuesta]}

def debería_continuar(estado: AgentState) -> cadena:
    último = estado['mensajes'][-1].content
    si "Necesito más información" al final:
        devolver "recuperar"
    más:
        devolver "fin"

flujo de trabajo = StateGraph(AgentState)
flujo de trabajo.add_node("recuperar", recuperar_nodo)
flujo de trabajo.add_node("razón", razonamiento_nodo)
flujo de trabajo.add_conditional_edges("razón", debería_continuar, {"retrieve": "retrieve", "end": END})
flujo de trabajo.set_entry_point("recuperar")
agente = flujo de trabajo.compilar()

LangGraph maneja la persistencia del estado, los puntos de control y la interrupción humana en el circuito.

2. LlamaIndex + AgentWorkflow

La clase AgentWorkflow de LlamaIndex facilita la colaboración entre múltiples agentes:

desde llama_index.core.agent.workflow importar AgentWorkflow
desde llama_index.core.tools importar FunctionTool

def search_knowledge_base(consulta: str) -> str:
    """Buscar en la base de conocimientos interna."""
    devolver vector_db.query (consulta)

def search_web(consulta: str) -> str:
    """Busca en la web información actual."""
    devolver web_search(consulta)

def ejecutar_sql(consulta: str) -> str:
    """Ejecutar consultas SQL en la base de datos de análisis."""
    devolver sql_db.execute (consulta)

flujo de trabajo = AgentWorkflow.from_tools_or_functions(
    [base_conocimiento_búsqueda, web_búsqueda, ejecutar_sql],
    llm=OpenAI(modelo="gpt-4-turbo"),
    system_prompt="Eres un asistente útil que puede buscar bases de datos de conocimientos, web y analíticas."
)

respuesta = await flowflow.run(user_msg="¿Cuáles fueron nuestras ventas del primer trimestre en Europa y cómo se comparan con las tendencias de la industria?")

El agente decide automáticamente qué herramientas utilizar y en qué orden.

3. Personalizado con contornos

Para obtener un control total, use Outlines para forzar la salida estructurada (esquema JSON, expresiones regulares) del LLM, luego diríjalo a las herramientas según la respuesta estructurada.

importar esquemas
de Pydantic importar modelo base, campo

clase ToolCall (Modelo base):
    herramienta: str = Campo(descripción="Nombre de la herramienta a llamar")
    argumentos: dict = Campo(descripción="Argumentos para la herramienta")

modelo = contornos.modelos.transformers("meta-llama/Llama-3-70b-chat-hf")
mensaje = f"""
Usuario: {user_query}

Herramientas disponibles: search_web, query_db, send_email

Decide qué herramienta utilizar y con qué argumentos. Salida JSON.
"""

resultado = contornos.generar.json(mensaje, esquema=ToolCall, modelo=modelo)
## resultado: {"tool": "search_web", "arguments": {"query": "foo"}}

Un ejemplo completo: agente de atención al cliente

Construyamos un agente que pueda:

1. Consultar el historial de pedidos
2. Verificar el inventario
3. Encuentre políticas relevantes
4. Genere una respuesta útil (o escale)

desde llama_index.core.agent.workflow importar AgentWorkflow
desde llama_index.core.tools importar FunctionTool
desde llama_index.llms.openai importar OpenAI

def get_order_history(user_id: str) -> dict:
    """Recuperar el historial de pedidos del usuario de la base de datos."""
    consulta = f "SELECCIONAR * DE pedidos DONDE user_id = '{user_id}' ORDEN POR creado_en DESC LIMIT 10"
    devolver sql_db.execute (consulta)

def check_inventory(sku: str) -> dict:
    """Comprueba si un producto está en stock."""
    devolver inventario_db.lookup(sku)

def search_knowledge_base(consulta: str) -> str:
    """Buscar documentos de ayuda, políticas e información de envío."""
    devolver vector_db.search(consulta)

def create_ticket(user_id: str, problema: str) -> str:
    """Abrir un ticket de soporte para seguimiento humano."""
    ticket_id = zendesk.create_ticket(user_id, problema)
    return f"Ticket creado: {ticket_id}"

flujo de trabajo = AgentWorkflow.from_tools_or_functions(
    herramientas=[get_order_history, check_inventory, search_knowledge_base, create_ticket],
    llm=OpenAI(modelo="gpt-4-turbo"),
    sistema_prompt="""
Usted es un agente de atención al cliente de Acme E-commerce.

Su objetivo: resolver el problema del usuario utilizando las herramientas disponibles.
Reglas:
- Siempre verifique primero el historial de pedidos si el usuario menciona un pedido
- Si el producto está agotado, ofrecer alternativas o fecha de reabastecimiento
- Si el tema es complejo o emocional, crea un ticket para seguimiento humano.
- Sea cortés, conciso y servicial.
"""
)

## Ejecutar
user_query = "Pedí SKU-12345 la semana pasada pero no he recibido confirmación de envío. Mi número de pedido es ABC-789."
respuesta = esperar flujo de trabajo.run(user_msg=user_query)
imprimir (respuesta)

El agente:

1. Llame a get_order_history con el ID de usuario derivado del número de pedido
2. Verifique que el pedido esté "procesándose" pero no enviado
3. Llame a search_knowledge_base para conocer la política de envío ("El procesamiento del pedido demora entre 1 y 3 días hábiles")
4. Genere una respuesta: "Su pedido ABC-789 aún se está procesando. El envío suele tardar entre 1 y 3 días hábiles. Recibirá un número de seguimiento por correo electrónico cuando se envíe".

Si el pedido ya pasó la ventana de envío, podría llamarse "create_ticket".

Patrones avanzados

Encadenamiento de herramientas y transferencia de datos

Los agentes pueden encadenar herramientas donde la salida de una se convierte en entrada de la siguiente. El marco de trabajo maneja esto automáticamente cuando estructura el historial de conversaciones correctamente.

Gestión de memoria y contexto

Para conversaciones largas, es necesario comprimir o resumir el historial para que se ajuste a la ventana contextual. Técnicas:

• Búferes de resumen: resume periódicamente los mensajes antiguos y conserva solo los recientes + resumen
• Puntuación de relevancia: almacena todas las interacciones pasadas en una base de datos vectorial y recupera solo las relevantes en cada turno.
• Estado de la sesión: mantenga el estado estructurado (por ejemplo, current_order_id, user_name) en un almacén separado e inyecte en el mensaje en cada paso

Colaboración entre múltiples agentes

Las tareas complejas se pueden dividir entre agentes especializados, coordinados por un supervisor:

Agente supervisor
  ├─ Agente de investigación (búsquedas en la web, base de conocimientos)
  ├─ Agente de datos (ejecuta SQL, analiza datos)
  └─ Escribir Agente (genera respuesta final)

LangGraph admite esto de forma nativa: cada nodo puede ser un flujo de trabajo de agente completo.

Humano en el circuito

Los agentes deben saber cuándo detenerse y preguntarle a un humano. Agregue una herramienta ask_human(question) que detenga la ejecución y envíe la pregunta a un canal o panel de Slack. Cuando el humano responde, el agente continúa.

Lista de verificación de preparación para la producción

Cuándo NO utilizar agentes

Los agentes son poderosos pero añaden complejidad. Evítelos cuando:

• La tarea consiste en responder preguntas sencillas a partir de una base de conocimientos estática (el RAG básico es suficiente)
• Necesita una latencia ultrabaja (< 200 ms): los agentes agregan entre 1 y 3 pasos de sobrecarga
• El costo de las llamadas LLM adicionales supera el beneficio
• No se pueden definir herramientas claras con resultados deterministas.
• El cumplimiento normativo requiere total previsibilidad (los agentes no son deterministas)

El resultado final

Agentic RAG va más allá de los simples chatbots hacia sistemas de razonamiento de varios pasos que pueden planificar, recuperar, actuar y autocorregirse. Marcos como LangGraph, LlamaIndex y Outlines lo hacen accesible.

Empiece poco a poco: elija un único flujo de trabajo de alto valor (atención al cliente, análisis de datos, asistente de investigación) y cree un agente para él. Mida el éxito por la reducción de las escaladas humanas, no solo por la calidad de las respuestas.

El futuro de las aplicaciones de IA no son sólo mejores indicaciones: es inteligencia orquestada.

Conclusiones clave

• RAG simple se limita a preguntas y respuestas estáticas; Los agentes añaden planificación, uso de herramientas, memoria y autocorrección.
• Frameworks principales: LangGraph (gráficos cíclicos), LlamaIndex (AgentWorkflow), Outlines (salida estructurada)
• Crear agentes para flujos de trabajo de varios pasos: atención al cliente, análisis de datos, investigación.
• Preparación para la producción: tiempos de espera, reintentos, controles de costos, observabilidad, barreras de seguridad
• Saber cuándo NO utilizar agentes (tareas simples, baja latencia, determinismo estricto)

¿Necesita ayuda para crear agentes?

Diseñamos e implementamos agentes de IA de nivel de producción que se integran con sus datos, herramientas y flujos de trabajo. Póngase en contacto para un taller técnico.

<a href="/get-started/" class="btn btn-primary">Programar taller</a>

Recuento de palabras: ~1050
Idiomas de destino: Inglés (fuente), árabe, español, alemán, francés