Saltar al contenido
Volver a Agentes avanzados

Agentes avanzados · Capítulo 5 de 10

Bucles que sobreviven

Las políticas de reintento, los timeouts, los manejadores de errores y los checkpoints mantienen en marcha una ejecución larga cuando una herramienta falla o el proceso se detiene.

20 minutos0 de 4 objetivos hechos

Objetivos

  • Inyecta una herramienta inestable y mira los reintentos.Pendiente
  • Envía el fallo a un paso de compensación.Pendiente
  • Detén la ejecución a la mitad y reanúdala desde su checkpoint.Pendiente
  • Predice los intentos y la ruta.Pendiente

Paso 1 de 4: La lectura

Reintentos y timeouts

Una llamada a una herramienta puede fallar por un momento: un 503 de un servicio ocupado, o ninguna respuesta. En LangGraph.js 1.5.1 un nodo puede llevar una retryPolicy: maxAttempts (el primer intento cuenta), initialInterval y backoffFactor para las esperas entre intentos, y retryOn para elegir los errores que merecen otro intento. Un timeout convierte una llamada colgada en un intento fallido. runTimeout limita el tiempo total de un intento; idleTimeout limita el tiempo sin progreso, como una escritura de estado, un evento de callback o una llamada a heartbeat(). Ambos lanzan NodeTimeoutError, que la política de reintento trata como cualquier otro error.

Manejadores de errores y compensación

Cuando se agotan los intentos, el errorHandler del nodo, añadido en LangGraph.js 1.4, se ejecuta en lugar de hacer fallar la ejecución. Recibe el estado de entrada del nodo y un NodeError, que contiene el nombre del nodo y el error, y devuelve una actualización de estado o un Command({ goto }). Enviar la ejecución a una compensación es el patrón saga: un paso que deshace el trabajo hecho antes del fallo, como liberar una habitación que se reservó pero nunca se pagó.

Detener y reanudar

Con un checkpointer, cada superstep termina guardando un checkpoint en el thread. Pasa un RunControl en la config de la ejecución y llama a requestDrain(): los nodos que ya se están ejecutando terminan, se guarda el checkpoint y la ejecución lanza GraphDrained. Si vuelves a invocar con entrada null en el mismo thread_id, empieza en el nodo siguiente; los nodos que terminaron no se vuelven a ejecutar. Con un checkpointer que guarda en una base de datos en lugar de en memoria, esto funciona también desde un proceso nuevo.

Una caída no avisa así. El nodo que se estaba ejecutando pierde sus escrituras y se vuelve a ejecutar al reanudar, así que una llamada con efectos secundarios debería llevar una clave de idempotencia: una clave que el servicio recuerda, para que una solicitud repetida reciba el primer resultado en lugar de actuar dos veces.

En este laboratorio

Un grafo de reservas: el modelo planifica el viaje, y luego reserve, charge y confirm llaman cada uno a un servicio. Los navegadores no tienen AsyncLocalStorage, así que interrupt() y task() de la API funcional no pueden ejecutarse aquí. El laboratorio usa la API de grafos y pasa la config a cada llamada a mano. Su segundo proceso es un grafo nuevo sobre el mismo MemorySaver en memoria, y desenchufar aborta el AbortSignal de la ejecución.

Paso 2 de 4: Pruébalo: Fallar, recuperarse, reanudar

Fallar, recuperarse, reanudar

Vuelve inestable una herramienta y mira los reintentos, deja caído el servicio de pagos y sigue la ruta hasta la compensación, y luego detén el proceso y reanuda el thread.

Modo:RealSimuladoReal: LangGraph.js 1.5.1 se ejecuta en esta página, con su retryPolicy, sus timeouts, errorHandler, los checkpoints de MemorySaver, el drain de RunControl y la reanudación. Simulado: las decisiones del modelo siguen un guion; los servicios de hotel, pagos y correo y sus fallos se ejecutan en la página; el segundo proceso es un grafo nuevo sobre el mismo MemorySaver en memoria, y desenchufar aborta el AbortSignal de la ejecución.

Paso 3 de 4: Comprobación

Comprobación

Código
const graph = new StateGraph(Trip)
  .addNode("reserve", reserve)
  .addNode("charge", charge, {
    retryPolicy: {
      maxAttempts: 2,
      initialInterval: 100,
    },
    errorHandler: () =>
      new Command({ goto: "release" }),
  })
  .addNode("release", release)
  .addEdge(START, "reserve")
  .addEdge("reserve", "charge")
  .addEdge("charge", END)
  .addEdge("release", END)
  .compile();

await graph.invoke(input);
charge_card lanza un 503 en cada llamada. ¿Qué pasa cuando se ejecuta esto?

Paso 4 de 4: Lo que ya puedes hacer

Lo que ya puedes hacer

  • Dar a un nodo una retryPolicy y un timeout, y predecir cuántos intentos hace.
  • Enviar el último fallo de un nodo a un paso de compensación con errorHandler y Command.
  • Detener una ejecución con RunControl.requestDrain y reanudarla desde su checkpoint sin repetir los nodos terminados.
  • Usar claves de idempotencia para que un nodo que se vuelve a ejecutar tras una caída no actúe dos veces.