Este curso intensivo de 30 horas (impartido en directo por streaming) está diseñado para ingenieros y desarrolladores con experiencia en Python que quieran dominar la creación de agentes inteligentes usando el framework LangGraph. A lo largo del curso, los participantes aprenderán desde los fundamentos del ciclo agente (pensamiento, acción, observación) hasta patrones avanzados con flujos grafos, persistencia de estado, integración de herramientas externas, coordinación multiagente y despliegue en producción. Se realizarán ejercicios prácticos guiados, mini-proyectos y sesiones de revisión de código en vivo.
Objetivos del curso
Al finalizar, los participantes serán capaces de:
- Comprender los conceptos fundamentales de los agentes inteligentes (loops agente, memoria, herramientas).
- Diseñar agentes modulares y componibles usando LangGraph.
- Implementar ciclos de decisión (Thought-Action-Observation) y patrones ReAct u otros patrones modernos para agentes.
- Gestionar estado persistente dentro de agentes (memoria, contexto entre interacciones).
- Integrar APIs, herramientas externas y bases de datos con agentes.
- Diseñar arquitecturas multiagente y orquestar la colaboración entre agentes.
- Evaluar, depurar y optimizar agentes para rendimiento, control y seguridad.
- Preparar un despliegue de agente en entorno productivo (microservicio, contenedores o arquitectura serverless).
- Aplicar buenas prácticas de gobernanza, seguridad de agentes y mecanismos de “human-in-the-loop”.
Contenidos (módulos / bloques)
- Introducción a los agentes inteligentes
- Qué es un agente (distinción con chatbots tradicionales, automatización vs agente).
- Ciclo agente (pensamiento, acción, observación).
- Patrones clásicos: ReAct, Reflex vs deliberativo, loop TAO.
- Casos de uso y aplicaciones reales.
- Fundamentos de LangGraph y su ecosistema
- Conceptos clave: nodos, aristas, grafos de flujo, memoria, persistencia.
- Comparativa con LangChain: cuándo usar LangGraph.
- Arquitectura interna de LangGraph.
- Primer agente simple: de cero en Python, y luego versión con LangGraph
- Construcción de agentes paso a paso
- División de responsabilidades entre LLM y código auxiliar.
- Diseño de flujos con nodos de decisión, nodos de acción, nodos de observación.
- Manejo de memoria local y global dentro del grafo.
- Incorporación de “tool calls” (llamadas a funciones o APIs) desde agentes.
- Persistencia, estado y contexto continuo
- Técnicas para almacenamiento de estado (bases de datos, caché, persistencia interacciones).
- Recuperación de contexto entre sesiones.
- Gestión de versiones de estado.
- Control de consistencia y concurrencia en agentes que operan múltiples hilos o peticiones.
- Integración con APIs y herramientas externas
- Diseño de “wrappers” de herramientas (por ejemplo, consulta de APIs, lectura/escritura de datos).
- Mecanismos seguros de acceso a herramientas (autenticación, límites).
- Validación de salidas y control de errores (fallas de API, respuestas inesperadas).
- Ejemplos prácticos: agente que consulta bases de datos, agente de scraping, agente de envío de emails.
- Patrones avanzados y arquitecturas multiagente
- Coordinación entre agentes (delegación de tareas, orquestadores).
- Comunicación entre agentes (mensajes, colas).
- Enrutamiento dinámico de tareas.
- Patrones de supervisión (metagent, vigilancia, fallback agent).
- Escenarios colaborativos o competitivos entre agentes.
- Evaluación, depuración y optimización
- Métricas clave: latencia, coste de tokens, éxito de objetivos.
- Estrategias de pruebas unitarias y de integración para agentes.
- Logging, trazabilidad y visualización del grafo de decisiones.
- Técnicas de optimización (cachés, poda de estado, límites de paso).
- Seguridad y control: evitar loops dañinos, polarización, abusos de recurso.
- Despliegue y arquitectura para producción
- Arquitecturas posibles: microservicios, contenedores (Docker), serverless.
- Escalabilidad y tolerancia: balanceo, escalado automático.
- Monitoreo, alertas y métricas en producción.
- Versionado de agente, retroalimentación continua y actualizaciones.
- Mecanismos de “human-in-the-loop” y gobernanza de agentes.
- Proyecto final guiado
- Definición del problema a resolver con agente (por ejemplo: asistente de investigación, sistema de automatización, agente de soporte).
- Diseño colectivo del flujo, nodos, herramientas.
- Implementación paso a paso en sesiones en vivo.
- Revisión cruzada de código, pruebas y puesta en marcha parcial.
- Presentación final, discusión de mejoras y retos.
- Tendencias futuras, novedades y retos abiertos
- Avances recientes en aprendizaje por refuerzo para agentes (p.ej. “Agent Lightning”)
- Aprendizaje continuo, adaptación del agente en el tiempo.
- Ética, seguridades y riesgos en agentes autónomos.
- Integración con otras tecnologías emergentes.
- Cómo evolucionará LangGraph / frameworks similares.