Introdução ao agente ReAct: raciocínio e ação em loops com LLMs

1. O que é o padrão ReAct e por que ele importa

O padrão ReAct (Reasoning + Acting) representa uma abordagem inovadora para a utilização de Modelos de Linguagem de Grande Escala (LLMs). Diferentemente dos LLMs tradicionais, que geram respostas baseadas exclusivamente em seu conhecimento interno, os agentes ReAct operam em um loop contínuo de raciocínio e ação. Esse ciclo permite que o modelo interaja com o mundo externo, executando ações como consultas a APIs, cálculos matemáticos ou pesquisas na web, e utilizando os resultados dessas ações para refinar seu raciocínio.

A principal diferença entre um LLM tradicional e um agente ReAct está na capacidade de execução dinâmica e feedback externo. Enquanto um LLM convencional responde "Qual é a capital do país com maior PIB da América do Sul?" com base em seu conhecimento pré-treinado, um agente ReAct pode primeiro pesquisar os PIBs dos países sul-americanos, identificar o maior, depois buscar sua capital, garantindo precisão factual.

Os casos de uso mais relevantes incluem:
- Busca dinâmica de informações em bases de dados ou na web
- Cálculos complexos que exigem precisão matemática
- Integração com APIs externas para obter dados em tempo real
- Sistemas de recomendação que combinam conhecimento interno com dados atualizados

2. Arquitetura fundamental do agente ReAct

A arquitetura de um agente ReAct é composta por três componentes essenciais:

  1. LLM (Modelo de Linguagem): Responsável pelo raciocínio e pela geração de ações
  2. Ferramentas (Tools): Funções externas que o agente pode invocar (calculadora, buscador, APIs)
  3. Memória de curto prazo: Histórico de interações que alimenta o loop de raciocínio

O ciclo fundamental do ReAct segue esta sequência:

Observação → Pensamento → Ação → Observação

Exemplo de fluxo de raciocínio em texto:

Pensamento: Preciso descobrir qual país da América do Sul tem o maior PIB. Vou pesquisar os dados mais recentes.
Ação: buscar_dados("PIB países América do Sul 2024")
Observação: Brasil: R$ 8,9 trilhões, Argentina: R$ 3,2 trilhões, Chile: R$ 1,8 trilhões...

Pensamento: O Brasil tem o maior PIB. Agora preciso saber sua capital.
Ação: buscar_dados("capital do Brasil")
Observação: Brasília

Pensamento: A capital do país com maior PIB da América do Sul é Brasília.
Resposta Final: Brasília

3. Implementação passo a passo do loop ReAct

A implementação de um agente ReAct envolve três etapas principais:

Estrutura do prompt

O prompt deve conter instruções claras sobre o formato de saída esperado:

Você é um agente ReAct. Seu objetivo é responder perguntas usando raciocínio e ações.
Formato de saída:
- Pensamento: [seu raciocínio]
- Ação: [nome_da_ferramenta]([argumentos])
- Observação: [resultado da ação]
- Resposta Final: [resposta final para o usuário]

Exemplos:
Pergunta: Quanto é 2 + 3 * 4?
Pensamento: Preciso calcular 2 + 3 * 4. Primeiro multiplicação, depois adição.
Ação: calculadora("3 * 4")
Observação: 12
Pensamento: Agora adiciono 2 ao resultado.
Ação: calculadora("2 + 12")
Observação: 14
Resposta Final: 14

Parsing da saída do LLM

def extrair_acao(saida_llm):
    if "Ação:" in saida_llm:
        inicio = saida_llm.index("Ação:") + len("Ação:")
        fim = saida_llm.index("\n", inicio) if "\n" in saida_llm[inicio:] else len(saida_llm)
        acao_texto = saida_llm[inicio:fim].strip()
        return acao_texto
    return None

Execução de ferramentas

def executar_ferramenta(acao_texto):
    if "calculadora" in acao_texto:
        expressao = acao_texto.split("(")[1].split(")")[0]
        resultado = eval(expressao)
        return f"Resultado: {resultado}"
    elif "buscar_dados" in acao_texto:
        termo = acao_texto.split("(")[1].split(")")[0]
        return buscar_na_base(termo)
    else:
        return "Ferramenta não reconhecida"

4. Ferramentas e acoplamento com o mundo externo

As ferramentas são o mecanismo pelo qual o agente ReAct interage com o mundo externo. Exemplos típicos:

Ferramentas disponíveis:
1. calculadora(expressao_matematica) - Para cálculos aritméticos
2. buscar_dados(termo_de_busca) - Para pesquisar em base de conhecimento
3. converter_moeda(valor, de, para) - Para conversão de moedas
4. obter_data_atual() - Para obter a data e hora atuais

O registro de ferramentas pode ser feito através de um dicionário:

ferramentas = {
    "calculadora": {"funcao": calcular, "descricao": "Calcula expressões matemáticas"},
    "buscar_dados": {"funcao": buscar, "descricao": "Pesquisa em base de conhecimento"}
}

Tratamento de erros é crucial:

def executar_com_tratamento(acao):
    try:
        resultado = executar_ferramenta(acao)
        return f"Observação: {resultado}"
    except Exception as e:
        return f"Observação: Erro ao executar ação: {str(e)}"

5. Estratégias de parada e iteração controlada

Para evitar loops infinitos e degradação de qualidade, são necessários critérios de término:

MAX_ITERACOES = 10
iteracao = 0
historico = []

while iteracao < MAX_ITERACOES:
    resposta = llm.gerar(historico)
    if "Resposta Final:" in resposta:
        break
    acao = extrair_acao(resposta)
    if acao:
        observacao = executar_ferramenta(acao)
        historico.append(observacao)
    iteracao += 1

if iteracao >= MAX_ITERACOES:
    print("Aviso: Número máximo de iterações atingido")

Logging do histórico de raciocínio:

def log_raciocinio(iteracao, pensamento, acao, observacao):
    print(f"Iteração {iteracao}:")
    print(f"  Pensamento: {pensamento}")
    print(f"  Ação: {acao}")
    print(f"  Observação: {observacao}")

6. Otimizações de prompt e contexto para ReAct

O gerenciamento da janela de contexto é crítico para o desempenho do agente:

def gerenciar_contexto(historico, max_tokens=4000):
    """Mantém apenas as últimas interações relevantes"""
    while len(tokenizar(historico)) > max_tokens:
        historico.pop(0)
    return historico

Few-shot dinâmico com exemplos relevantes:

def selecionar_exemplos(pergunta, banco_exemplos):
    """Seleciona exemplos similares à pergunta atual"""
    exemplos_relevantes = []
    for exemplo in banco_exemplos:
        if similaridade(pergunta, exemplo["pergunta"]) > 0.7:
            exemplos_relevantes.append(exemplo)
    return exemplos_relevantes[:3]

System prompt para definir comportamento:

System: Você é um agente ReAct especializado em responder perguntas factuais.
Você DEVE usar ferramentas quando não tiver certeza da resposta.
Nunca invente fatos. Sempre verifique informações usando as ferramentas disponíveis.
Se uma ferramenta falhar, tente uma abordagem alternativa.

7. Limitações e boas práticas ao usar ReAct

Problemas comuns:
- Alucinação em ações: O LLM pode "inventar" resultados de ferramentas
- Deriva de raciocínio: O agente pode perder o foco da pergunta original
- Custo computacional: Múltiplas chamadas ao LLM aumentam o custo

Quando evitar ReAct:
- Tarefas puramente textuais ou criativas
- Perguntas que o LLM já responde com alta precisão
- Cenários com restrições severas de tempo ou custo

Combinação com outras técnicas:
- Chain-of-Thought: Útil para raciocínio sem ações externas
- Toolformer: Abordagem para treinar LLMs a usar ferramentas automaticamente
- Reflexão: Adicionar etapa de verificação após cada ação

8. Exemplo completo: agente ReAct com busca e cálculo

Consulta: "Qual é a capital do país com maior PIB da América do Sul?"

Iteração 1:
Pensamento: Preciso identificar o país com maior PIB da América do Sul.
Ação: buscar_dados("PIB nominal países América do Sul 2024")
Observação: Brasil: $2.17 trilhões, Argentina: $640 bilhões, Chile: $345 bilhões, Colômbia: $334 bilhões, Peru: $264 bilhões

Iteração 2:
Pensamento: O Brasil tem o maior PIB. Agora preciso descobrir sua capital.
Ação: buscar_dados("capital do Brasil")
Observação: A capital do Brasil é Brasília.

Iteração 3:
Pensamento: Encontrei a resposta. O país com maior PIB é o Brasil e sua capital é Brasília.
Resposta Final: A capital do país com maior PIB da América do Sul é Brasília, capital do Brasil.

Análise do raciocínio:
1. O agente identificou a necessidade de dados externos
2. Executou a ação de busca corretamente
3. Interpretou o resultado e formulou nova ação
4. Combinou as informações para chegar à resposta final
5. Apresentou a resposta com a devida fundamentação

Este exemplo demonstra como o loop ReAct permite que o LLM supere suas limitações de conhecimento, combinando raciocínio interno com dados externos atualizados.

Referências