Pular para o conteúdo
Voltar para Agentes avançados

Agentes avançados · Capítulo 5 de 10

Loops que resistem

Políticas de nova tentativa, timeouts, handlers de erro e checkpoints mantêm uma execução longa de pé quando uma ferramenta falha ou o processo para.

20 minutos0 de 4 objetivos concluídos

Objetivos

  • Injete uma ferramenta instável e observe as novas tentativas.A fazer
  • Envie a falha para uma etapa de compensação.A fazer
  • Pare a execução no meio e retome-a a partir do checkpoint.A fazer
  • Preveja as tentativas e o caminho.A fazer

Passo 1 de 4: A leitura

Novas tentativas e timeouts

Uma chamada de ferramenta pode falhar por um momento: um 503 de um serviço ocupado, ou nenhuma resposta. No LangGraph.js 1.5.1, um nó pode ter uma retryPolicy: maxAttempts (a primeira tentativa conta), initialInterval e backoffFactor para as esperas entre tentativas, e retryOn para escolher os erros que valem outra tentativa. Um timeout transforma uma chamada travada em uma tentativa que falhou. runTimeout limita o tempo total de uma tentativa; idleTimeout limita o tempo sem progresso, como uma escrita de estado, um evento de callback ou uma chamada a heartbeat(). Os dois lançam NodeTimeoutError, que a política de nova tentativa trata como qualquer outro erro.

Handlers de erro e compensação

Quando as tentativas acabam, o errorHandler do nó, adicionado no LangGraph.js 1.4, roda em vez de fazer a execução falhar. Ele recebe o estado de entrada do nó e um NodeError, que contém o nome do nó e o erro, e retorna uma atualização de estado ou um Command({ goto }). Enviar a execução para uma compensação é o padrão saga: uma etapa que desfaz o trabalho feito antes da falha, como liberar um quarto que foi reservado mas nunca pago.

Parar e retomar

Com um checkpointer, cada superstep termina salvando um checkpoint na thread. Passe um RunControl na config da execução e chame requestDrain(): os nós que já estão rodando terminam, o checkpoint é salvo e a execução lança GraphDrained. Invocar de novo com entrada null no mesmo thread_id começa no próximo nó; os nós que terminaram não rodam de novo. Com um checkpointer que salva em um banco de dados em vez da memória, isso funciona também a partir de um processo novo.

Uma queda não dá esse aviso. O nó que estava rodando perde suas escritas e roda de novo ao retomar, então uma chamada com efeitos colaterais deve levar uma chave de idempotência: uma chave que o serviço lembra, para que uma requisição repetida receba o primeiro resultado em vez de agir duas vezes.

Neste lab

Um grafo de reservas: o modelo planeja a viagem, e depois reserve, charge e confirm chamam cada um um serviço. Os navegadores não têm AsyncLocalStorage, então interrupt() e o task() da API funcional não podem rodar aqui. O lab usa a API de grafos e passa a config para cada chamada à mão. O segundo processo é um grafo novo sobre o mesmo MemorySaver em memória, e puxar o plugue aborta o AbortSignal da execução.

Passo 2 de 4: Experimente: Falhar, recuperar, retomar

Falhar, recuperar, retomar

Deixe uma ferramenta instável e observe as novas tentativas, derrube o serviço de pagamento e siga o caminho até a compensação, depois pare o processo e retome a thread.

Modo:RealSimuladoReal: o LangGraph.js 1.5.1 roda nesta página, com retryPolicy, timeouts, errorHandler, checkpoints do MemorySaver, o drain do RunControl e a retomada. Simulado: as decisões do modelo são roteirizadas; os serviços de hotel, pagamento e e-mail e suas falhas rodam na página; o segundo processo é um grafo novo sobre o mesmo MemorySaver em memória, e puxar o plugue aborta o AbortSignal da execução.

Passo 3 de 4: Verificação

Verificação

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 lança um 503 em toda chamada. O que acontece quando isto roda?

Passo 4 de 4: O que você já sabe fazer

O que você já sabe fazer

  • Dar a um nó uma retryPolicy e um timeout, e prever quantas tentativas ele faz.
  • Enviar a última falha de um nó para uma etapa de compensação com errorHandler e Command.
  • Parar uma execução com RunControl.requestDrain e retomá-la a partir do checkpoint sem repetir os nós que terminaram.
  • Usar chaves de idempotência para que um nó que roda de novo depois de uma queda não aja duas vezes.