Módulo 1 · Parte B de 3

O ciclo ReAct

Um agente baseado em um grande modelo de linguagem executa o mesmo ciclo perceber-raciocinar-agir que qualquer outra coisa, com um detalhe que dá nome ao padrão: o modelo raciocina em palavras entre as ações que ele toma. Yao et al. (2022) chamou isso de ReAct, de raciocinar e agir. Os autores descobriram que intercalar traços de raciocínio curtos com o uso de ferramentas lida com muitas tarefas de forma mais confiável do que planejar tudo primeiro ou agir sem um passo de raciocínio.

Uma ferramenta é um trecho de código que o harness de execução pode executar para o modelo: uma função nomeada com uma descrição, um esquema de entrada e um valor de retorno. Uma chamada de ferramenta é a solicitação estruturada do modelo para esse código. O harness de execução analisa a solicitação, executa a função, anexa o resultado e chama o modelo novamente.

Esse ciclo é a base sobre a qual a maioria dos frameworks de agentes de propósito geral é construída, incluindo o createReactAgent da LangChain, e o restante desse módulo trabalha em direção a ele.

O ciclo permanece o mesmo. Com um grande modelo de linguagem na etapa de raciocínio, o agente lê os resultados e age chamando ferramentas.

O único campo que informa ao ciclo o que fazer em seguida

Todas as respostas de chat-completions carregam um campo finish_reason que informa por que o modelo parou de gerar. Dentro de um ciclo de agente, este é o único sinal de que você precisa para decidir o que fazer em seguida: executar uma ferramenta, retornar a resposta ao usuário ou lidar com um erro. Antes de ler o que seus valores significam, faça duas chamadas e observe o campo mudar.

A primeira chamada respondeu sozinha e retornou "stop". A segunda recebeu uma ferramenta e uma pergunta que os dados de treinamento não podem responder. Em vez de parar, ela retornou "tool_calls", entregando ao código o nome da função a executar. Esses dois valores cobrem a ramificação comum. O restante sinaliza problemas que roteiam o ciclo para um fluxo de fallback do harness, no qual o agente pode tentar novamente a chamada ou passar a conversa para um humano.

"stop" significa que o modelo escreveu sua resposta final e o ciclo pode retornar content ao usuário.
"tool_calls" significa que o modelo está pedindo ao seu código para executar uma função nomeada e anexar o resultado antes de chamar novamente.
"length" significa que o orçamento de tokens esgotou antes que a resposta terminasse.
"content_filter" significa que um classificador de segurança parou a saída.

No ReAct moderno, um roteador curto lê esse campo. Se o modelo pediu uma ferramenta, o roteador executa a sua função, anexa o resultado e chama o modelo novamente. Se o modelo parou, o roteador retorna a resposta.

Esse arranjo funciona bem porque o modelo nunca fica preso ao plano inicial. Quando uma ferramenta retorna algo inesperado, o resultado entra na próxima rodada de raciocínio, e o modelo pode reavaliar a situação antes de decidir o que fazer.

Aplicado · AnatomiaRelacionar o modelo, a memória, as ferramentas e o roteador?

As peças de um agente de LLM

Amplie o agente e você encontrará a decomposição que Lilian Weng apresentou em 2023. Um grande modelo de linguagem está no centro. Ao redor dele estão memória, planejamento, ferramentas e as ações que interagem com o mundo.

O agente mínimo deste curso preenche cada componente com a solução mais simples que funciona:

Memória é o array messages[].
Planejamento é o roteador finish_reason.
Ferramentas são as funções que o harness de execução expõe.
Ação é a chamada de ferramenta que o harness de execução executa.

Nenhum desses componentes vive dentro do modelo. Eles fazem parte do harness de execução construído em torno de uma única chamada de texto para texto.

Depois de Lilian Weng (2023): o modelo é o controlador central do agente, com memória, planejamento, ferramentas e ação conectados ao redor dele.

Os módulos são independentes. Você pode substituir o modelo ou as ferramentas ou o roteador por conta própria, e desde que cada um ainda honre o contrato que os outros esperam dele, o resto do ciclo do agente continua funcionando.

Essa independência também importa para como você lê o código de um agente que você não escreveu. Qualquer que seja o framework que o envolva, qualquer agente baseado em LLM deve conter essas quatro peças, e quando algo quebra a causa é geralmente uma delas:

o modelo retornando o finish_reason errado,
uma mensagem ausente no array,
o executor de ferramentas devolvendo um valor inesperado,
ou o roteador lendo o sinal de forma errada.

A estrutura de quatro peças fornece uma lista de verificação que se aplica independentemente de como o código circundante é organizado.

Construindo o ciclo do agente a partir do zero com uma ferramenta

Como um exercício, podemos tentar criar um ciclo simples do agente a partir do zero. Tudo o que precisamos é de uma única ferramenta chamada get_current_time mais um prompt do sistema e um ciclo while. Execute-o com "Que horas são em UTC?" para começar e veja o que mais você pode perguntar:

O fluxo é curto: o modelo solicita a ferramenta, o aplicativo executor anexa a marca de tempo como uma mensagem com o papel tool, o modelo lê essa marca de tempo e o ciclo termina quando finish_reason lê "stop".

Pense, aja, observe, repita. O ciclo termina quando finish_reason é "stop".

O que acabou de acontecer dentro do array de mensagens.
O ciclo adicionou quatro itens a state.messages:

o prompt do sistema (turno 0),
a pergunta do usuário (turno 1),
uma mensagem de assistente com um campo tool_calls (turno 2, a solicitação),
e uma mensagem com o papel tool que contém o valor de retorno da função (turno 3).

A segunda chamada do LLM leu todas as quatro, incluindo o novo resultado da ferramenta, e escreveu a resposta final. O array crescente é a única "memória" que este agente tem. Se você salvar esse array em disco e recarregá-lo na semana seguinte, o modelo retomará a conversa sem notar a lacuna.

Aplicado · OperaçãoRevisar evidências e mitigações da degradação do contexto?

Degradação do contexto: por que um ciclo mais longo lê pior

Este problema se torna mais provável à medida que o contexto cresce. Degradação do contexto é a tendência de contradições, observações desatualizadas e convenções pobres se acumularem no histórico do prompt até prejudicar a próxima decisão do modelo. O efeito também tem um componente posicional: Liu et al. (2023) mostraram que os modelos podem subutilizar informações enterradas no meio de um contexto longo. Quanto mais um sinal importante se afasta do turno atual, mais fácil é para o ciclo ignorá-lo ou contradizê-lo.

Recriado a partir de Liu et al. (2023). À medida que o ciclo anexa turnos, a resposta que você precisa se afasta para o meio fraco.

Mitigações comuns mantêm cada decisão próxima às evidências de que precisa:

planeje antes que o ciclo acumule observações,
delegue subtarefas para que cada subagente trabalhe em um contexto curto,
ou resuma turnos anteriores antes que eles se tornem um passivo.

Cada mitigação tem custos de latência, fidelidade ou complexidade e deve ser avaliada diante da tarefa em questão.

O mesmo ciclo, pré-construído e apontado para este curso

O ciclo acima fixa diretamente uma pequena ferramenta. O createReactAgent da LangChain generaliza a mesma maquinaria para suportar mais ferramentas, interfaces padrão e integrações de observabilidade. Uma instância desta classe é conectada abaixo a uma única ferramenta, read_course_page, que fornece ao agente qualquer página deste curso como markdown. O modelo decide quais páginas ler para responder à sua pergunta; experimente.

A célula produz um artefato. Quando você executa, obtém um painel de chat funcional em vez de uma parede de logs, renderizado a partir do próprio código do agente, com o qual você pode manter uma conversa. A palavra em si é mais antiga do que seu uso atual, pois pipelines de build e execuções de treinamento de machine learning produziram "artefatos" e "artefatos de modelo" por anos. O recente artefato ao vivo da Anthropic aprimorou a ideia para agentes, onde um artefato se torna uma superfície HTML interativa persistente que o agente constrói e que você continua usando muito tempo após a resposta que o produziu. O painel abaixo constrói um em pequena escala, e um agente que pode fornecer uma interface completa em vez de texto simples é uma linha de raciocínio que perpassa o restante deste curso.

Execute a célula para construir o painel e converse com ele. Fixe uma ou mais páginas com os chips Páginas para fundamentar cada resposta nelas, ou não fixe nenhuma e deixe o agente escolher o que ler. A resposta é renderizada como markdown, com um chip para cada fonte consultada; expanda-o para ver o texto recuperado. Você também recebe o rastreamento do raciocínio e o uso de tokens. O painel preserva a conversa. Edite a célula e execute novamente para reconstruir o artefato.

Antes de continuar

Cada pergunta pode ser respondida editando as entradas no canvas acima e executando novamente.

Force o modelo a chamar a ferramenta mesmo quando não precisa. Tente uma pergunta que a ferramenta genuinamente não possa responder ("capital da França?") e observe finish_reason na etapa 1. Foi "stop" ou "tool_calls"? Agora edite o prompt do sistema para exigir uma chamada de ferramenta antes de responder ("Você deve sempre chamar get_current_time uma vez, então responder."). O modelo atende? O que isso revela sobre o quanto o prompt do sistema consegue direcionar um modelo que confia em seus dados de treinamento para outra resposta?
Conte as etapas em uma pergunta que realmente precisa de uma ferramenta. "Quantos minutos até 17:00 UTC?" leva mais de uma chamada de ferramenta. Execute algumas vezes. O modelo chamou get_current_time uma vez, duas vezes ou três vezes? Por que um modelo rechamaria uma ferramenta cuja saída ele já tem, e como você desencorajaria isso no prompt do sistema?

Profundo · FontesRastrear esses mecanismos até as fontes primárias?

Referências

Yao et al., ReAct: Synergizing Reasoning and Acting in Language Models (2022). O padrão original de pensamento alternado / ação / observação; a figura acima é redesenhada a partir deste artigo.
Wei et al., Chain-of-Thought Prompting (2022). A metade "raciocínio" do ReAct; o que o modelo está fazendo dentro de reasoning_content quando ele delibera antes de agir.
Lilian Weng, LLM Powered Autonomous Agents (2023). A decomposição que a figura acima adapta: um modelo de linguagem como o controlador central do agente, cercado por memória, planejamento e uso de ferramentas.
Xu et al., ReWOO: Decoupling Reasoning from Observations (2023). Um contraste deliberado com o ReAct: o modelo escreve todo o plano antecipadamente e um executor separado o executa sem reconsultar o modelo entre as etapas. Comparar os dois revela a troca entre replanejamento reativo e execução pré-comprometida.
Schick et al., Toolformer (2023). Coberto novamente nas referências do 1c; revista aqui para o mecanismo subjacente que o ciclo do ReAct explora.

Lista abrangente em Ir Além · Referências.

← Módulo 1a: O Agente Módulo 1c: Ferramentas em Escala →