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

Agentes avançados · Capítulo 3 de 10

Subgrafos e equipes

Monte equipes de agentes com subgrafos, decida como elas compartilham o estado, leia seus namespaces no stream e compare padrões multiagente por chamadas ao modelo e tokens.

20 minutos0 de 4 objetivos concluídos

Objetivos

  • Execute uma equipe de equipes e leia os namespaces do seu stream.A fazer
  • Pause dentro de uma equipe e abra o estado dela.A fazer
  • Compare subagentes com repasses em chamadas ao modelo e tokens.A fazer
  • Preveja o que um subgrafo emite no stream.A fazer

Passo 1 de 4: A leitura

Subgrafos

Um grafo compilado pode ser um nó de outro grafo: um subgrafo. Quando os dois compartilham uma chave de estado, o subgrafo compilado é o nó, como em addNode("research_team", researchTeam). Ele lê as chaves que compartilha com o pai, o que ele escreve nelas volta, e as chaves que só ele tem ficam lá dentro.

Sem nenhuma chave compartilhada, chame o subgrafo a partir de um nó envoltório que converte o estado do pai na entrada do subgrafo, e a saída dele de volta em uma atualização. Passe { subgraphs: [team] } para addNode para que getGraphAsync e getState continuem encontrando o subgrafo.

Namespaces e streaming

Cada execução de um subgrafo salva seus checkpoints em um namespace próprio dentro da thread do pai, nomeado pelo seu nó e pela sua tarefa: research_team:<task id>. stream(input, { streamMode: "updates", subgraphs: true }) produz pares [namespace, update], com [] para o grafo de cima. getGraphAsync({ xray: true }) desenha os nós próprios dos subgrafos, como research_team:lead.

Enquanto uma execução está pausada dentro de um subgrafo, getState(config, { subgraphs: true }) também devolve o estado próprio do subgrafo. Em um navegador, interrupt() não pode rodar, porque precisa de AsyncLocalStorage, então este laboratório pausa com interruptBefore e passa config para cada subgrafo à mão.

Equipes de equipes e repasses

Um supervisor pode comandar outros supervisores. No laboratório, um chefe de suporte roteia com Command({ goto }) para duas equipes, e o líder de cada equipe distribui partes do trabalho entre seus workers. Um nó dentro de um subgrafo também pode passar o controle para um nó do pai: new Command({ graph: Command.PARENT, goto: "writer", update }). Isso é um repasse: o próximo agente assume com o histórico que você colocou em update.

Escolher um padrão

A documentação de JS do LangChain nomeia cinco padrões multiagente. Subagentes: um agente principal chama outros agentes como ferramentas e recebe cada resultado de volta. Repasses: o agente no comando muda. Skills: um agente carrega prompts de especialista quando precisa deles. Router: uma etapa classifica a entrada e a envia para agentes. Fluxo personalizado: o seu próprio grafo do LangGraph. O capítulo 5 de Sistemas de agentes chamou de repasses as suas chamadas transfer_to_<agent>, mas o supervisor dele usava subagentes: cada resultado voltava para ele.

A documentação os compara (lida em 2026-11-04): uma solicitação de uma só vez leva 4 chamadas ao modelo com subagentes e 3 com repasses; uma pergunta sobre três domínios leva 5 chamadas e cerca de 9K tokens com subagentes, e 7+ chamadas e cerca de 14K+ com repasses. No laboratório você executa um mesmo trabalho dos dois jeitos e conta.

Passo 2 de 4: Experimente: Uma equipe de equipes

Uma equipe de equipes

Três etapas: execute uma equipe de equipes e leia o stream dela, pause dentro de uma equipe para abrir o estado dela e depois execute o mesmo trabalho como subagentes e como repasses.

Modo:RealSimuladoReal: o LangGraph.js 1.5.1 roda nesta página: os subgrafos, o stream com namespaces, as pausas, getState e Command.PARENT. Simulado: as decisões dos modelos são roteirizadas e os dados são fictícios, então as chamadas e os tokens são os da execução roteirizada, com os tokens estimados como caracteres / 4.

Passo 3 de 4: Verificação

Verificação

Código
const Team = Annotation.Root({
  ...MessagesAnnotation.spec,
  notes: Annotation({ reducer: (a, b) => a.concat(b), default: () => [] }),
});
const team = new StateGraph(Team)
  .addNode("work", () => ({ notes: ["n1"], messages: [{ role: "assistant", content: "done" }] }))
  .addEdge(START, "work")
  .compile();
const top = new StateGraph(MessagesAnnotation)
  .addNode("team", team)
  .addEdge(START, "team")
  .compile();

const input = { messages: [{ role: "user", content: "go" }] };
for await (const [ns, update] of await top.stream(input, { streamMode: "updates", subgraphs: true })) {
  const [node, values] = Object.entries(update)[0];
  console.log(ns.length ? "inside" : "top", node, Object.keys(values));
}
A equipe compartilha messages com o grafo de cima; notes é a chave própria dela. O que o loop imprime?

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

O que você já sabe fazer

  • Adicionar um subgrafo como nó quando ele compartilha chaves, ou chamá-lo a partir de um nó envoltório que converte o estado.
  • Fazer streaming com subgraphs: true e ler o namespace de cada atualização; ler o estado de um subgrafo pausado com getState.
  • Passar o controle para um nó do grafo pai com Command.PARENT, e construir supervisores de supervisores.
  • Escolher entre subagentes, repasses, skills, um router e um fluxo personalizado pelas chamadas ao modelo e pelos tokens.