Los agentes de Inteligencia Artificial son el paso natural después de los chatbots. Mientras un chatbot responde preguntas, un agente toma decisiones, usa herramientas externas y ejecuta tareas complejas de múltiples pasos de manera autónoma. En 2026, LangChain y LangGraph son los frameworks estándar para construirlos — y en esta guía vas a aprender cómo hacerlo desde cero con código real.
¿Qué es un agente de IA y en qué se diferencia de un chatbot?
Un chatbot recibe un input y genera un output. El ciclo termina ahí. Un agente, en cambio, recibe un objetivo y puede tomar múltiples acciones para lograrlo: buscar información en internet, consultar una base de datos, ejecutar código, llamar a una API externa, y decidir cuál es el siguiente paso basándose en los resultados intermedios.
La diferencia clave es el ciclo de razonamiento. Los agentes operan en un loop Reason → Act → Observe (Razonar → Actuar → Observar) que se repite hasta resolver el objetivo original. Este patrón se conoce como ReAct (Reasoning + Acting) y es la base de la mayoría de los agentes modernos.
Un chatbot responde. Un agente resuelve. La diferencia es que el agente puede hacer llamadas a herramientas, tomar decisiones intermedias y adaptar su plan según los resultados que va obteniendo.
Casos de uso de agentes IA en el mundo de datos
Los agentes son especialmente poderosos para equipos de datos. Estos son los casos de uso más comunes y de mayor impacto:
- ▸Agente de monitoreo de calidad de datos: detecta anomalías en pipelines, identifica la causa raíz consultando logs y métricas, y crea un ticket automático con el diagnóstico
- ▸Agente analista de datos: recibe una pregunta en lenguaje natural, escribe la query SQL, la ejecuta, analiza los resultados y devuelve un resumen con insights
- ▸Agente de documentación: navega el código de un repositorio, lee esquemas de tablas y genera documentación técnica actualizada automáticamente
- ▸Agente de reportes: cada lunes recopila datos de múltiples fuentes, genera un reporte y lo envía por email a los stakeholders
- ▸Agente de soporte de datos: responde preguntas del equipo sobre datasets usando documentación interna como base de conocimiento (RAG)
LangChain: el framework base para apps con LLMs
LangChain es el framework más utilizado en el ecosistema de IA para construir aplicaciones con LLMs. Provee abstracciones para los componentes más comunes: prompts, modelos, herramientas, memoria y chains (cadenas de procesamiento). Es el punto de partida ideal antes de pasar a LangGraph.
Instalación y configuración básica
# Instalación
pip install langchain langchain-openai langchain-community
# Variables de entorno en .env
# OPENAI_API_KEY=sk-...
# ANTHROPIC_API_KEY=sk-ant-...Tu primer agente con LangChain Tools
El concepto de "tools" (herramientas) es central en LangChain. Las tools son funciones que el LLM puede decidir llamar para obtener información o ejecutar acciones. El LLM analiza el objetivo, decide qué tool usar, la llama, recibe el resultado, y decide si necesita más acciones o si puede responder.
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import tool
from langchain import hub
@tool
def consultar_base_datos(query: str) -> str:
"""Ejecuta una query SQL en la base de datos analítica y retorna los resultados."""
return f"Revenue total Q1 2026: $2.3M, productos vendidos: 45.230"
@tool
def buscar_documentacion(tema: str) -> str:
"""Busca en la documentación interna de la empresa sobre un tema específico."""
return f"El KPI de conversión se calcula como (ventas/visitantes)*100"
llm = ChatOpenAI(model="gpt-4o", temperature=0)
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm=llm, tools=[consultar_base_datos, buscar_documentacion], prompt=prompt)
agent_executor = AgentExecutor(agent=agent, tools=[consultar_base_datos, buscar_documentacion], verbose=True)
resultado = agent_executor.invoke({
"input": "¿Cuál fue el revenue del Q1 2026 y cómo se calcula el KPI de conversión?"
})
print(resultado["output"])¿Querés aprender esto desde cero con proyectos reales? En DataPath tenemos el curso Creación de Agentes con LangChain y el Taller de Agentes con LangChain para que empieces a construir en horas.
LangGraph: agentes con flujos de trabajo complejos y estado
LangGraph extiende LangChain para construir agentes que requieren flujos de trabajo más complejos: condicionales, loops, estado persistente entre pasos, y múltiples agentes que colaboran. Se basa en el concepto de grafos dirigidos donde cada nodo es una función que puede leer y modificar un estado compartido.
La diferencia principal con un agente simple de LangChain es que LangGraph te da control total sobre el flujo: podés definir exactamente qué pasos se ejecutan, en qué orden, y bajo qué condiciones. Esto es fundamental para sistemas de producción que necesitan ser predecibles y auditables.
Conceptos clave de LangGraph
- ▸State: el estado compartido que todos los nodos pueden leer y modificar. Se define como un TypedDict
- ▸Nodes: funciones que reciben el estado actual y retornan actualizaciones al estado
- ▸Edges: conexiones entre nodos, pueden ser fijas o condicionales
- ▸Graph: el flujo completo compilado y listo para ejecutar
- ▸Checkpointing: persistencia del estado para reanudar ejecuciones o hacer rollback
Agente de análisis de datos con LangGraph
from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
import operator
class EstadoAgente(TypedDict):
pregunta: str
query_sql: str
resultados: str
analisis: str
mensajes: Annotated[list, operator.add]
llm = ChatOpenAI(model="gpt-4o", temperature=0)
def generar_query(state: EstadoAgente) -> dict:
respuesta = llm.invoke([HumanMessage(content=f"Genera SQL para: {state['pregunta']}")])
return {"query_sql": respuesta.content}
def ejecutar_query(state: EstadoAgente) -> dict:
return {"resultados": "Tech: $450K | Ropa: $280K | Hogar: $190K"}
def analizar_resultados(state: EstadoAgente) -> dict:
respuesta = llm.invoke([HumanMessage(content=f"Analiza: {state['resultados']}")])
return {"analisis": respuesta.content}
grafo = StateGraph(EstadoAgente)
grafo.add_node("generar_query", generar_query)
grafo.add_node("ejecutar_query", ejecutar_query)
grafo.add_node("analizar", analizar_resultados)
grafo.set_entry_point("generar_query")
grafo.add_edge("generar_query", "ejecutar_query")
grafo.add_edge("ejecutar_query", "analizar")
grafo.add_edge("analizar", END)
agente = grafo.compile()
resultado = agente.invoke({
"pregunta": "¿Cuáles son las categorías con mayor revenue este mes?",
"query_sql": "", "resultados": "", "analisis": "", "mensajes": []
})
print(resultado["analisis"])En DataPath tenemos el curso Creación de Agentes con LangGraph y el Taller de Agentes con LangGraph — ambos con proyectos reales para tu portfolio.
Flujos condicionales: el poder real de LangGraph
def verificar_anomalia(state: EstadoAgente) -> str:
if "anomalía" in state["resultados"].lower():
return "investigar_anomalia"
return "generar_reporte"
grafo.add_conditional_edges(
"ejecutar_query",
verificar_anomalia,
{
"investigar_anomalia": "investigar_anomalia",
"generar_reporte": "analizar"
}
)¿Cuándo usar LangChain vs LangGraph?
Usá LangChain cuando:
- ▸El flujo es lineal: pregunta → tool → respuesta
- ▸Estás prototipando rápido y querés iterar con velocidad
- ▸El agente tiene menos de 3-4 tools y el flujo es simple
- ▸No necesitás persistir el estado entre conversaciones
Usá LangGraph cuando:
- ▸El flujo tiene ramificaciones condicionales (if/else basado en resultados)
- ▸Necesitás múltiples agentes que colaboran en un mismo workflow
- ▸Querés persistir el estado para retomar conversaciones o hacer rollback
- ▸El sistema va a producción y necesitás observabilidad y control total del flujo
El mejor momento para aprender a construir agentes de IA fue ayer. El segundo mejor momento es hoy. El mercado de 2026 paga muy bien a quienes saben construirlos.
¿Querés construir agentes IA desde cero con guía de expertos?
En DataPath tenemos el Programa de Inteligencia Artificial para Developers y cursos específicos de LangChain y LangGraph donde construís agentes reales desde el primer día. También podés comenzar con el Taller de Agentes con LangChain si preferís empezar rápido. Explorá el catálogo completo en nuestros cursos de IA.