Integración de LLM en grafos para agentes que razonan

Convierte un flujo de datos en un agente que razona: integra un large language model en un grafo con LangGraph y orquesta decisiones de forma autónoma. Este enfoque combina memoria compartida, hilos y estado persistente para que los nodos no solo procesen datos, sino que piensen y actúen según el contexto acumulado.

¿Cómo convertir un flujo de datos en un agente que razona con LangGraph y LangChain?

El punto de partida es un flujo de datos sin “cerebro”: start → node1 → end. La clave es inyectar un large language model en el grafo para que el agente decida, ramifique, haga ciclos y retroceda cuando sea necesario. Puedes conectar modelos con LangChain, SDK nativo o Llama Index; lo importante es que LangGraph ejecute su motor de grafos y mantenga el estado.

• De proceso a inteligencia: pasar de transformar datos a razonar y tomar acciones.
• Nodos con estado: cada nodo puede leer y escribir en el estado compartido.
• Memoria viva por hilo: el contexto se conserva mientras mantengas el mismo ID de hilo.

¿Qué pasos de código integran el LLM y actualizan el estado compartido?

Se define el modelo, se ajusta la temperatura y se reescribe la lógica del nodo para trabajar con un new_state que consolida cambios y mensajes antes de devolver el return.

¿Cómo configurar el modelo y su temperatura?

Se inicializa el modelo con temperatura = 1 y se prepara para la invocación.

# Inicialización del modelo (ejemplo mínimo)
llm = init_model(temperature=1)

• Temperatura 1: respuestas más creativas y variadas.
• Invocación: se llamará al modelo con el historial y el mensaje actual.

¿Cómo cambia la lógica del nodo con new state?

Se crea un new_state (diccionario) y se aplica una lógica simple basada en si existe un nombre del usuario.

import random

def node1(state):
    new_state = {}

    # Si no hay nombre, asígnalo; si ya hay, actualiza edad aleatoria.
    if not state.get("customer_name"):
        new_state["customer_name"] = "John Du"  # valor capturado/derivado.
    else:
        new_state["my_age"] = random.randint(18, 80)

    # ...luego se añadirá la parte de mensajes.
    return new_state

• customer_name: primero se captura y guarda.
• my_age: se asigna solo si ya existe un nombre, usando un número aleatorio.

¿Cómo se unen mensajes y se persisten en la memoria?

Se toma el historial de mensajes del estado, se agrega la nueva respuesta de la AI y se guarda en el new_state. Al devolverlo, LangGraph actualizará la memoria compartida.

def node1(state):
    new_state = {}

    # Lógica de nombre/edad como antes...
    # ...

    # Historial existente y nueva respuesta de AI.
    history = state.get("messages", [])
    ai_reply = {"role": "ai", "content": "Hola, estoy aquí para ayudarte."}

    # Unir *arrays*: historial + [nueva respuesta].
    new_state["messages"] = history + [ai_reply]
    return new_state

• Unión de arrays: se usa history + [mensaje_ai].
• Persistencia: el historial crece con cada intercambio.

¿Cómo funcionan los hilos, la memoria compartida y la interfaz de LangGraph Studio?

Al crear un nuevo hilo, la memoria arranca en limpio; al mantener el mismo hilo, el estado persiste, incluso si recargas la UI. En LangGraph Studio es visible el view state y puedes debuggear el grafo, revisar el JSON del estado y chatear desde una interfaz de chat cuando el agente es de tipo “mensajes”.

¿Qué es un hilo y cómo persiste el estado?

• Un hilo conserva: estado, historial de mensajes y valores como customer_name.
• Mientras uses el mismo ID de hilo, la memoria compartida se mantiene.
• Ejemplo: tras “Hola, ¿cómo estás?” el agente responde “Hola, estoy aquí para ayudarte” y guarda el customer_name = John Du; luego, al decir “me llamo Nicolás”, el sistema recuerda y puede asignar my_age.

¿Qué viste en el historial de mensajes y arrays vacíos?

• Puede aparecer un mensaje “vacío” en el historial: a veces LangGraph/LangChain envían “reacciones” como “estoy pensando” o “escribiendo”.
• Puedes inspeccionar el estado en vista colapsada o de detalle, e incluso como JSON para entender cada paso.

¿Cómo aprovechar el prompt y la memoria compartida?

• Mejora el system prompt: inyecta el nombre capturado (por ejemplo, “Nicolás”) para que el modelo recuerde y responda con contexto.

• Aplica prompting basado en el estado: cualquier agente puede leer el estado compartido y continuar el trabajo desde allí.

• Más adelante, podrás montar persistencia propia y exponer una API con FastAPI.

• Reto 1: crea dos hilos en LangGraph Studio y verifica que el historial y la memoria compartida se mantengan por hilo.

• Reto 2: configura un system prompt que use datos del estado (por ejemplo, el nombre) para personalizar respuestas.

¿Te gustaría compartir cómo inyectarías el nombre del usuario en el system prompt o qué otros campos guardarías en el estado para tus agentes?