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

Agentes avançados · Capítulo 4 de 10

Viagem no tempo

Cada superstep salva um checkpoint, então você pode ler o histórico de uma execução, repetir a partir de um passo passado, editar um estado passado e bifurcar um segundo final.

20 minutos0 de 4 objetivos concluídos

Objetivos

  • Execute um grafo de cinco nós em um thread e leia o histórico de checkpoints dele.A fazer
  • Volte ao passo 3 e repita a partir dele.A fazer
  • Edite o estado no passo 3, bifurque e compare os dois finais.A fazer
  • Coloque os passos de uma bifurcação em ordem.A fazer

Passo 1 de 4: A leitura

Um thread é uma linha do tempo

Compile um grafo com um checkpointer, execute-o com um thread_id, e o LangGraph salva um checkpoint do estado inteiro depois de cada superstep, como na trilha Sistemas de agentes. Cada checkpoint tem o próprio checkpoint_id, um step e um source nos metadados (o step -1 é a entrada), e um parentConfig que aponta o checkpoint anterior. Ligados pelos pais, os checkpoints de um thread formam uma linha do tempo, e uma linha do tempo pode se ramificar.

Ler o passado

getStateHistory({ configurable: { thread_id } }) lista todos os checkpoints do thread, do mais novo para o mais antigo. Cada item é um snapshot do estado: values, next (os nós que devem rodar), config e metadata. getState com um checkpoint_id na config lê um deles. Isso é voltar no tempo: você olha um estado passado e não muda nada.

Repetir e bifurcar

invoke(null, config), com uma config que aponta um checkpoint passado, repete a partir dele. Os nós antes desse checkpoint não rodam de novo; os depois dele rodam, então um modelo real pode responder diferente na segunda vez. Os novos checkpoints crescem em um novo ramo que começa com uma cópia cujo source é fork. Os antigos continuam lá.

updateState(config, values, asNode) muda o passado sem apagá-lo. Ele escreve um novo checkpoint, com source update, em cima daquele que config aponta, como se o nó asNode tivesse retornado values, e retorna a config do novo checkpoint. Rode invoke(null, thatConfig) e o thread se bifurca: o primeiro final continua no histórico e um segundo cresce a partir da sua edição. getState sem checkpoint_id lê o checkpoint mais novo, que agora é o fim da bifurcação.

Durabilidade

A opção durability de uma execução decide quando os checkpoints são escritos. "async", o padrão, salva cada um enquanto o próximo superstep roda; "sync" salva antes de o próximo superstep começar; "exit" salva só quando a execução termina. "exit" escreve menos, mas não deixa nenhum passo passado para onde voltar, nem nada de onde retomar se o processo cair no meio.

Neste lab

A verificação de reembolso da Halden para o ticket T-48213 executa cinco nós em sequência: read_ticket, classify, list_charges, decide e draft_reply. O LangGraph.js 1.5.1 e o MemorySaver dele rodam nesta página, e classify, decide e draft_reply consultam um modelo roteirizado. A versão para navegador do LangGraph.js não tem AsyncLocalStorage, então cada nó passa a config dele para o modelo de forma explícita.

Passo 2 de 4: Experimente: Um trilho de checkpoints

Um trilho de checkpoints

Três passos: execute o grafo e leia os checkpoints dele, volte ao passo 3 e repita, depois edite o passo 3, bifurque e compare os dois finais.

Modo:RealSimuladoReal: o LangGraph.js 1.5.1 roda nesta página, com o MemorySaver, getStateHistory, getState, updateState e a repetição dele. Simulado: as decisões do modelo são roteirizadas, e o ticket e as cobranças são fictícios.

Passo 3 de 4: Verificação

Verificação

Coloque em ordem os passos para bifurcar uma execução a partir de um checkpoint passado.

Arraste os itens, ou use os botões de seta, para colocá-los em ordem.

  1. Posição 1: Execute o grafo com um checkpointer e um thread_id.
  2. Posição 2: Chame invoke(null, config) com a config que updateState retornou.
  3. Posição 3: Escolha pelo checkpoint_id o checkpoint para onde voltar.
  4. Posição 4: Liste os checkpoints do thread com getStateHistory.
  5. Posição 5: Compare o final da bifurcação com o primeiro, que continua no histórico.
  6. Posição 6: Chame updateState com a config desse checkpoint e os novos valores.

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

O que você já sabe fazer

  • Ler os checkpoints de um thread com getStateHistory, e um deles com getState e o checkpoint_id dele.
  • Repetir uma execução a partir de um checkpoint passado, e dizer quais nós rodam de novo.
  • Editar um estado passado com updateState, bifurcar o thread e comparar os dois finais.
  • Escolher um modo de durabilidade sabendo para onde cada um deixa você voltar.