Práctica: Construye un agente básico que use una API

Concepto clave

En LangGraph, un agente es un sistema de IA que toma decisiones secuenciales usando herramientas externas y mantiene contexto a través de ciclos de conversación. Piensa en él como un asistente virtual que, en lugar de solo responder preguntas, puede ejecutar acciones como consultar APIs, procesar datos y recordar interacciones previas para ofrecer respuestas contextualizadas.

La arquitectura se basa en grafos dirigidos donde los nodos representan estados o acciones, y las aristas definen transiciones condicionales. Esto permite modelar flujos complejos donde el agente decide qué hacer a continuación basado en el estado actual, similar a cómo un conductor navega usando señales de tráfico y mapas en tiempo real.

Cómo funciona en la práctica

Para construir un agente básico que use una API, sigue estos pasos:

1. Define el estado del grafo con variables como messages (historial) y next (siguiente acción).
2. Crea nodos para funciones clave: call_api (llamada a la API), process_response (análisis de datos), y decide_next (decisión condicional).
3. Conecta los nodos con aristas que evalúen condiciones, por ejemplo, si la API devuelve un error, redirige a un nodo de manejo de fallos.
4. Implementa herramientas usando decoradores de LangGraph para integrar APIs externas, asegurando que el agente pueda acceder a datos en tiempo real.

Ejemplo de un flujo simplificado:

from langgraph.graph import StateGraph, END
# 1. Definir estado
class AgentState(TypedDict):
    query: str
    api_response: Optional[dict]
    next_step: str
# 2. Crear nodos
def call_api(state):
    # Lógica para llamar a la API
    return {"api_response": data}
# 3. Construir grafo
graph = StateGraph(AgentState)
graph.add_node("call_api", call_api)
graph.add_edge("call_api", END)
graph.set_entry_point("call_api")
app = graph.compile()

Caso de estudio

Imagina un agente para un sistema de recomendación de películas que use la API de TMDB (The Movie Database). El agente recibe una consulta como "recomiéndame películas de acción recientes", y ejecuta:

1. Llama a la API de TMDB con parámetros de género y fecha.
2. Procesa la respuesta para extraer títulos, calificaciones y enlaces.
3. Decide si mostrar resultados o pedir más detalles al usuario, basado en la completitud de los datos.
4. Almacena la interacción en memoria para refinar futuras recomendaciones.

Datos de ejemplo de la API:

En producción, este agente reduciría el tiempo de respuesta de 30 segundos (manual) a 2 segundos (automático), mejorando la experiencia del usuario.

Errores comunes

• No manejar errores de API: Si la API falla, el agente puede bloquearse. Solución: Implementa reintentos y nodos de fallback en el grafo.
• Estado sobredimensionado: Incluir demasiadas variables en el estado ralentiza el agente. Solución: Usa solo campos esenciales como messages y tools.
• Falta de condiciones claras: Aristas sin lógica condicional llevan a bucles infinitos. Solución: Define reglas explícitas, por ejemplo, if response.status == 200: proceed else: retry.
• Ignorar la memoria: Sin historial, el agente no contextualiza. Solución: Integra un nodo que actualice memory después de cada interacción.
• Tool mal configurada: APIs con parámetros incorrectos devuelven datos erróneos. Solución: Valida esquemas de entrada y usa tipos de datos estrictos.

Checklist de dominio

1. ¿Puedes definir un grafo en LangGraph con al menos 3 nodos y aristas condicionales?
2. ¿Integraste una API externa usando herramientas de LangGraph, manejando autenticación y parámetros?
3. ¿Implementaste memoria que persista entre ciclos de conversación?
4. ¿Diseñaste condiciones que dirijan el flujo basado en respuestas de API (éxito/error)?
5. ¿Probaste el agente con consultas reales y mediste latencia?
6. ¿Documentaste el flujo del grafo y las dependencias de herramientas?
7. ¿Optimizaste el estado para evitar redundancias y mejorar rendimiento?

Construye un agente de clima con la API de OpenWeatherMap

En este ejercicio, crearás un agente que consulta el clima actual usando LangGraph y la API de OpenWeatherMap. Sigue estos pasos:

1. Regístrate en OpenWeatherMap para obtener una API key gratuita (límite de 60 llamadas/minuto).
2. Define un estado de agente con campos: city (string), weather_data (dict), y next_action (string).
3. Crea un nodo fetch_weather que llame a la API de OpenWeatherMap con la ciudad del estado. Usa el endpoint: https://api.openweathermap.org/data/2.5/weather?q={city}&appid={API_KEY}&units=metric.
4. Añade un nodo parse_response que extraiga temperatura, humedad y descripción del JSON de respuesta.
5. Conecta los nodos: de fetch_weather a parse_response si la API responde con código 200, o a un nodo handle_error si hay error.
6. Implementa memoria almacenando la última consulta en el estado para referencias futuras.
7. Prueba el agente con ciudades como "Madrid" o "Bogotá" y verifica que devuelva datos estructurados.

Entrega: Código en Python con el grafo compilado y una captura de salida de ejemplo.

• Usa la librería requests para llamadas HTTP en el nodo fetch_weather, manejando excepciones con try-except.
• En parse_response, accede a los datos con claves como 'main.temp' y 'weather[0].description' del JSON.
• Para memoria, añade un campo 'history' al estado que acumule consultas previas.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.