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

Agentes avançados · Capítulo 2 de 10

Command e Send

Um nó pode atualizar o estado e escolher o próximo nó em um só passo com Command, e distribuir o trabalho entre workers em paralelo com Send, quantos o modelo pedir.

20 minutos0 de 4 objetivos concluídos

Objetivos

  • Execute um nó roteador que atualiza o estado e salta com Command.A fazer
  • Distribua com Send em tantas verificações quantas o modelo roteirizado escolher, para dois tickets.A fazer
  • Retome a execução: o reducer reuniu os resultados, e um nó os resume.A fazer
  • Preveja com o que o nó que reúne é executado.A fazer

Passo 1 de 4: A leitura

Command: atualizar e rotear em um só return

Um nó costuma devolver uma atualização do estado, e as arestas do grafo decidem o que roda em seguida. Em vez disso, um nó pode devolver new Command({ update, goto }). update é escrito no estado como um return comum seria, e goto nomeia o próximo nó, escolhido enquanto o nó roda. Um roteador pode classificar um ticket, guardar a classe e saltar para o nó certo em um só passo.

Declare para onde um Command pode ir com ends: addNode("triage", triage, { ends: ["plan", "reply"] }). compile() usa ends para verificar que todo nó pode ser alcançado: aqui plan e reply não têm outra entrada, então sem ends ele lança UnreachableNodeError. getGraphAsync() desenha ends como arestas. Um goto se soma às arestas estáticas do nó; não as substitui, então um nó que devolve Command normalmente não tem nenhuma.

Send: quantos workers o modelo pedir

new Send("check", { ticket, check }) inicia uma execução de um nó, chamada tarefa, com sua própria entrada em vez do estado do grafo. Uma aresta condicional que devolve uma lista de Sends distribui o trabalho: todas essas tarefas rodam no próximo superstep, ao mesmo tempo. A lista pode vir do modelo, então a largura é decidida em tempo de execução: três verificações para um ticket, cinco para outro. O goto do Command também aceita Sends.

Reunir os resultados

Todas as tarefas escrevem a mesma chave, então essa chave precisa de um reducer, como no capítulo anterior. No fim do superstep, o reducer mescla as escritas na ordem das tarefas, que é a ordem dos Sends, seja qual for a ordem em que as tarefas terminaram. Um nó com uma aresta vinda dos workers roda então uma vez, no próximo superstep, e lê todas elas. Isso é map-reduce em um grafo.

Repasses, e este laboratório

Dentro de um subgrafo, new Command({ graph: Command.PARENT, goto }) salta para um nó do grafo pai. É assim que um agente passa trabalho para outro; o próximo capítulo monta equipes com isso.

No laboratório, a central de tickets da Halden, a loja fictícia do capítulo anterior, roda um só grafo: triage roteia cada ticket, plan deixa o modelo roteirizado escolher as verificações, e summarise escreve a resposta. A página pausa as execuções com interruptAfter e interruptBefore, passados para stream(), porque interrupt() precisa de AsyncLocalStorage, que a versão para navegador do LangGraph.js não tem.

Passo 2 de 4: Experimente: Rotear, distribuir, reunir

Rotear, distribuir, reunir

Três passos em um mesmo grafo do LangGraph.js: roteie um ticket com Command, distribua nas verificações que o modelo escolhe e depois retome a execução para reunir e resumir.

Modo:RealSimuladoReal: o LangGraph.js 1.5.1 roda nesta página. Simulado: as decisões do modelo e quanto tempo leva cada consulta são roteirizados, e os tickets e os registros da loja são fictícios.

Passo 3 de 4: Verificação

Verificação

Código
// findings: a ReducedValue whose
// reducer concatenates lists.
// plan returns { checks:
//   ["order", "shipping", "stock"] }
new StateGraph(State)
  .addNode("plan", plan)
  .addNode("check", async ({ check }) =>
    ({ findings: [check] }))
  .addNode("summarise", (s) => ({
    answer: s.findings.join(" + "),
  }))
  .addEdge(START, "plan")
  .addConditionalEdges("plan", (s) =>
    s.checks.map((c) =>
      new Send("check", { check: c })),
    ["check"])
  .addEdge("check", "summarise")
  .addEdge("summarise", END)
  .compile();
O modelo roteirizado escolheu três verificações, e cada verificação leva um tempo diferente. Quantas vezes summarise roda, e o que ele escreve?

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

O que você já sabe fazer

  • Rotear e atualizar o estado em um só passo devolvendo Command de um nó, com seus destinos declarados em ends.
  • Distribuir com Send em uma largura que o modelo escolhe em tempo de execução.
  • Reunir resultados paralelos com um reducer, e prever a ordem deles e quando o próximo nó roda.