Evalúa tu comprensión de grafos y herramientas

Evaluación de Conceptos: Grafos, Estados y Herramientas en LangGraph

Bienvenido a esta lección de evaluación integral. Aquí no presentaremos conceptos nuevos, sino que pondremos a prueba tu comprensión de los fundamentos de LangGraph y la arquitectura de agentes. Considera esta lección como un simulacro práctico donde conectaremos todos los puntos: el grafo como orquestador, el estado como memoria contextual y las herramientas como capacidades de acción. Un agente avanzado no es la suma de sus partes, sino la integración fluida y robusta de todas ellas. Esta evaluación está diseñada para que identifiques fortalezas y áreas de oportunidad en tu dominio de la construcción de sistemas de IA autónomos.

El enfoque será aplicado. Analizaremos un problema complejo, desglosaremos los requisitos en componentes de LangGraph, y luego implementaremos y criticaremos una solución. A lo largo del camino, te haré preguntas implícitas sobre tus decisiones de diseño. ¿Priorizas la simplicidad del grafo o la expresividad del estado? ¿Cómo manejas el fallo de una herramienta? ¿Dónde resides la lógica de negocio? Tus respuestas mentales a estas preguntas, comparadas con el contenido que sigue, serán tu verdadera métrica de evaluación.

Concepto Clave: El Agente como un Sistema Cibernético

Para evaluar tu comprensión, es crucial internalizar una analogía poderosa: un agente de LangGraph es un sistema cibernético. La cibernética es la ciencia de la comunicación y el control en sistemas complejos. En este modelo, el Grafo es el sistema de control (el cerebro que toma decisiones y enruta), el Estado es la memoria sensorial y de trabajo (la conciencia del contexto y la historia), y las Herramientas son los efectores (las manos que interactúan con el mundo exterior). La calidad del agente no se mide por la sofisticación individual de cada componente, sino por la eficiencia y resiliencia del bucle de feedback que los conecta: percibir (estado), decidir (grafo), actuar (herramienta), y aprender (actualizar el estado).

Piensa en un piloto de avión experimentado. Su estado incluye el conocimiento del plan de vuelo, los instrumentos del panel (datos en tiempo real) y su experiencia previa. Su grafo mental es el conjunto de procedimientos y reglas de decisión ("si la presión de aceite cae, entonces revisa el motor X y notifica a torre"). Sus herramientas son los controles de la cabina, la radio y los sistemas de la aeronave. Un buen piloto integra estos elementos sin problemas. Un agente de LangGraph debe hacer lo mismo: mantener un estado coherente, tomar decisiones de enrutamiento inteligentes basadas en él, y utilizar herramientas de manera efectiva, manejando las incertidumbres propias de la ejecución en el mundo real.

Cómo Funciona en la Práctica: Desglose de un Caso de Uso Complejo

Vamos a evaluar tu habilidad para traducir un problema del mundo real a una arquitectura LangGraph. Imagina que debemos construir un Agente Investigador de Mercado. Sus requisitos son: 1) Recibir una consulta del usuario sobre un producto o industria. 2) Buscar noticias recientes y datos financieros en la web. 3) Analizar el sentimiento de la información recopilada. 4) Sintetizar un informe breve. 5) Si el informe menciona empresas específicas, buscar su cotización bursátil actual. 6) Mantener un historial de la conversación para seguir preguntas del usuario.

Tu evaluación comienza aquí. ¿Cómo modelarías el estado? Un novicio podría crear un diccionario enorme. Un practicante avanzado definiría un StateGraph con un esquema TypedDict claro, tal vez con campos como `query`, `news_results`, `sentiment_analysis`, `report`, `stock_prices`, y `conversation_history`. ¿Y el grafo? Necesitarás nodos para "buscar", "analizar_sentimiento", "sintetizar_informe", "obtener_cotizaciones" y un nodo especial de "enrutador" para decidir si buscar cotizaciones o no después de tener el informe. Las aristas definirán el flujo: ¿es lineal o condicional? La herramienta de búsqueda web y la de APIs financieras deben ser robustas y manejar errores. El paso de síntesis probablemente involucre al LLM directamente. Tu capacidad para visualizar este flujo y anticipar puntos de fallo es lo que se evalúa.

Código en Acción: Implementación y Análisis Crítico

A continuación, presentamos una implementación de referencia para el Agente Investigador. Estudia este código detenidamente. Luego, más allá de entender su sintaxis, evalúa su arquitectura. ¿Es resiliente? ¿Es eficiente? ¿Podría escalar? Identifica sus fortalezas y sus debilidades potenciales. Este es el núcleo de tu evaluación práctica.

Definición del Estado y las Herramientas

from typing import TypedDict, List, Annotated
from langgraph.graph import StateGraph, END
from langchain_community.tools import TavilySearchResults
from langchain_community.utilities import AlphaVantageAPI
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
import operator

# 1. Definición del Esquema del Estado
class AgentState(TypedDict):
    """Esquema que representa el estado completo del agente."""
    query: str
    news_results: List[dict]
    sentiment: str
    report: str
    stock_prices: dict
    conversation_history: Annotated[List[str], operator.add]  # Campo especial para acumulación
    next_step: str  # Campo para control de flujo

# 2. Definición de Herramientas (Simuladas para claridad)
search_tool = TavilySearchResults(max_results=3)
# Herramienta ficticia para ejemplo. En la práctica, necesitarías una API key.
financial_tool = AlphaVantageAPI()

def search_news(query: str) -> List[dict]:
    """Función de herramienta para búsqueda de noticias."""
    # En la práctica, esto envolvería a `search_tool`
    print(f"[HERRAMIENTA] Buscando noticias para: {query}")
    # Simulación de resultados
    return [
        {"title": "Nueva tecnología revoluciona el sector", "snippet": "Sentimiento positivo...", "url": "..."},
        {"title": "Preocupaciones regulatorias en aumento", "snippet": "Sentimiento negativo...", "url": "..."}
    ]

def get_stock_prices(symbols: List[str]) -> dict:
    """Función de herramienta para obtener cotizaciones."""
    print(f"[HERRAMIENTA] Obteniendo cotizaciones para: {symbols}")
    # Simulación de resultados
    return {symbol: 150.0 + i*10 for i, symbol in enumerate(symbols)}

# 3. Inicialización del LLM
llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)

Construcción del Grafo del Agente

# 4. Definición de las Funciones/Nodos del Grafo
def retrieve_node(state: AgentState) -> AgentState:
    """Nodo: Recupera información de la web."""
    print("[NODO] Ejecutando: retrieve_node")
    news = search_news(state["query"])
    return {"news_results": news, "next_step": "analyze"}

def analyze_node(state: AgentState) -> AgentState:
    """Nodo: Analiza el sentimiento de los resultados."""
    print("[NODO] Ejecutando: analyze_node")
    snippets = " ".join([item["snippet"] for item in state["news_results"]])
    # Uso del LLM para análisis simple
    prompt = f"""Clasifica el sentimiento general de estos textos en 'POSITIVO', 'NEUTRAL' o 'NEGATIVO':
    Textos: {snippets}
    Sentimiento:"""
    response = llm.invoke([HumanMessage(content=prompt)])
    sentiment = response.content.strip()
    return {"sentiment": sentiment, "next_step": "synthesize"}

def synthesize_node(state: AgentState) -> AgentState:
    """Nodo: Sintetiza un informe basado en query, noticias y sentimiento."""
    print("[NODO] Ejecutando: synthesize_node")
    news_summary = "\n".join([f"- {item['title']}: {item['snippet']}" for item in state["news_results"]])
    prompt = f"""Como analista de mercado, escribe un informe conciso (3-4 frases) que responda a la consulta del usuario.
    Consulta: {state['query']}
    Información Recopilada:
    {news_summary}
    Sentimiento General Identificado: {state['sentiment']}
    Informe:"""
    response = llm.invoke([HumanMessage(content=prompt)])
    report = response.content
    # Heurística simple: si el informe menciona 'Apple' o 'Tesla', busca cotizaciones
    next_step = "get_stocks" if any(company in report for company in ["Apple", "Tesla", "Google"]) else "end"
    return {"report": report, "next_step": next_step}

def get_stocks_node(state: AgentState) -> AgentState:
    """Nodo: Obtiene cotizaciones bursátiles si son relevantes."""
    print("[NODO] Ejecutando: get_stocks_node")
    # En un caso real, extraerías símbolos del informe con un LLM o NER
    symbols_to_check = ["AAPL", "TSLA"]  # Simplificado para el ejemplo
    prices = get_stock_prices(symbols_to_check)
    return {"stock_prices": prices, "next_step": "end"}

def update_history_node(state: AgentState) -> AgentState:
    """Nodo: Actualiza el historial de conversación."""
    print("[NODO] Ejecutando: update_history_node")
    new_entry = f"Usuario preguntó: {state['query']}. Se generó informe."
    return {"conversation_history": [new_entry]}

# 5. Construcción y Compilación del Grafo
workflow = StateGraph(AgentState)

# Añadir nodos
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("analyze", analyze_node)
workflow.add_node("synthesize", synthesize_node)
workflow.add_node("get_stocks", get_stocks_node)
workflow.add_node("update_history", update_history_node)

# Definir el punto de entrada
workflow.set_entry_point("retrieve")

# Añadir aristas condicionales y fijas
workflow.add_conditional_edges(
    "synthesize",
    lambda state: state["next_step"],
    {
        "get_stocks": "get_stocks",
        "end": "update_history"
    }
)
workflow.add_edge("retrieve", "analyze")
workflow.add_edge("analyze", "synthesize")
workflow.add_edge("get_stocks", "update_history")
workflow.add_edge("update_history", END)

# Compilar el grafo
app = workflow.compile()

Ejecución y Evaluación del Flujo

# 6. Ejecución del Agente
print("=== INICIANDO EJECUCIÓN DEL AGENTE INVESTIGADOR ===")
initial_state = {
    "query": "¿Cuáles son las últimas tendencias en vehículos eléctricos y cómo afectan a Tesla?",
    "news_results": [],
    "sentiment": "",
    "report": "",
    "stock_prices": {},
    "conversation_history": [],
    "next_step": ""
}

# Ejecutar el grafo
try:
    final_state = app.invoke(initial_state)
    print("\n=== INFORME FINAL ===")
    print(final_state["report"])
    print(f"\nSentimiento: {final_state['sentiment']}")
    print(f"Cotizaciones: {final_state['stock_prices']}")
    print(f"Historial: {final_state['conversation_history']}")
except Exception as e:
    print(f"\n[ERROR CRÍTICO] El grafo falló: {e}")
    # Un agente robusto debería tener manejo de errores en cada nodo.

Este código representa una implementación funcional pero perfectible. Como evaluador avanzado, deberías notar que el campo `next_step` es usado para control de flujo, una práctica común. Sin embargo, la heurística en `synthesize_node` para decidir buscar acciones es frágil (búsqueda de palabras clave). Una solución más robusta usaría un LLM para decidir o un nodo enrutador dedicado. Además, el manejo de errores es mínimo; en producción, cada nodo debería tener `try-catch` para fallos de herramientas o LLM. El estado se actualiza de manera atómica por nodo, lo cual es correcto. ¿Ves algún otro punto de mejora?

Tip de Evaluación: La verdadera prueba de un grafo no es su ejecución en el camino feliz, sino su comportamiento cuando una herramienta falla, cuando el LLM devuelve un formato inesperado, o cuando el estado llega a un valor no previsto. Siempre pregúntate: "¿Qué podría salir mal en este nodo?".

Errores Comunes y Cómo Evitarlos

Tras analizar el código de ejemplo, es momento de evaluar tu capacidad para reconocer y prevenir errores de diseño comunes en LangGraph. Estos no son errores de sintaxis, sino de arquitectura y concepto que limitan la robustez y escalabilidad de tus agentes.

1. Estado Sobrediseñado o Subdiseñado: Un error común es definir un estado con decenas de campos "por si acaso", volviéndolo opaco y difícil de depurar. El contrario, un estado demasiado escueto, fuerza a los nodos a hacer malabares con información contextual no estructurada. Cómo evitarlo: Sigue el principio de mínima representación suficiente. Tu TypedDict debe contener solo lo que múltiples nodos necesitan leer o escribir. Usa `Annotated` con `operator.add` para listas de historial, pero sé conservador con otros campos.

2. Lógica de Negocio Esparcida en los Nodos: Cuando la regla de decisión "¿busco cotizaciones?" está incrustada en el nodo `synthesize`, como en nuestro ejemplo, violas la separación de preocupaciones. Cómo evitarlo: Centraliza la lógica de enrutamiento en nodos dedicados de "enrutador" o "orquestador" que solo deciden el camino. Los nodos de acción (`retrieve`, `analyze`) deben ser lo más puros posibles: toman estado, actúan, devuelven actualizaciones al estado.

3. Falta de Manejo de Errores y Timeouts: Asumir que las herramientas (APIs web, LLMs) siempre responden es un error garantizado en producción. Un fallo en cualquier nodo detiene todo el grafo. Cómo evitarlo: Implementa un patrón de "nodo seguro". Envuelve la lógica principal de cada nodo en bloques `try-except`. Actualiza el estado con un campo como `error` o `last_error` y diseña aristas condicionales que puedan enrutar a un nodo de "recuperación" o "reintento" basado en ese campo.

4. Grafos con Ciclos Accidentales o Puntos Muertos: Al añadir aristas condicionales complejas, es posible crear un bucle infinito (nodo A -> nodo B -> nodo A) o un camino que llega a un nodo sin aristas de salida (punto muerto). Cómo evitarlo: Dibuja tu grafo en papel o con una herramienta de diagramación antes de codificar. Usa `workflow.add_edge(node, END)` explícitamente para nodos finales. LangGraph te alertará de algunos de estos problemas al compilar, pero no de todos. La simulación mental del flujo es clave.

5. Herramientas sin Validación de Entrada/Salida: Pasar cadenas sin formato directamente de un LLM a una herramienta que espera un JSON estricto o un parámetro numérico causará fallos. Cómo evitarlo: Nunca confíes en la salida del LLM. Usa funciones de análisis (como Pydantic) o prompts con formato de respuesta estricto (JSON Schema) para garantizar que la salida del LLM sea usable por la herramienta. Además, valida los parámetros de entrada de la herramienta antes de invocarla.

Checklist de Dominio de Fundamentos de LangGraph

Utiliza esta lista para autoevaluar tu comprensión. Si puedes verificar con confianza cada ítem, dominas los fundamentos. Si hay dudas, es la oportunidad para repasar las lecciones anteriores.

• Puedo definir un esquema de estado TypedDict que capture todos los datos necesarios para mi flujo de agente, usando `Annotated` para campos acumulativos cuando sea necesario.
• Puedo diferenciar claramente entre un Nodo, una Herramienta y una Arista. Un nodo es una función que lee/escribe el estado; una herramienta es una API o función que interactúa con el exterior; una arista define la transición entre nodos.
• Puedo construir un grafo con flujo condicional utilizando `add_conditional_edges`, donde la función de enrutamiento inspecciona el estado para decidir el siguiente nodo.
• Puedo diseñar herramientas con manejo de errores integrado y pensar en cómo su fallo afectaría el estado y el flujo del grafo, planeando nodos de recuperación.
• Puedo explicar el ciclo de vida de una invocación del grafo: inicialización del estado, entrada al nodo inicial, ejecución secuencial/condicional de nodos, actualización del estado tras cada nodo, terminación en END.
• Puedo identificar cuándo una pieza de lógica debe ir en el estado, en un nodo o en una herramienta, aplicando el principio de separación de preocupaciones para un diseño limpio.
• Puedo prever y evitar ciclos infinitos y puntos muertos en el diseño de mi grafo, asegurando que todos los caminos posibles lleven a END o a un estado de error manejado.
• Puedo criticar una implementación de agente existente, como la de esta lección, señalando sus fortalezas arquitectónicas y sus debilidades potenciales en cuanto a robustez, mantenibilidad y escalabilidad.

Esta lección de evaluación no tenía una respuesta única correcta. Su objetivo era activar tu pensamiento crítico y tu capacidad para analizar sistemas de agentes de IA de manera integral. Has revisado un caso práctico, un código funcional, errores típicos y un checklist de dominio. Tu habilidad para interactuar con este material, cuestionar las decisiones tomadas en el código de ejemplo y planificar mejoras es el verdadero indicador de tu comprensión avanzada de los fundamentos de LangGraph. Continúa con este espíritu analítico en los siguientes módulos, donde construiremos sobre estos cimientos con patrones más complejos y técnicas de optimización.