A estrutura ReAct: pensar, agir, observar
Entenda o ciclo ReAct, no qual o modelo gera um Thought, escolhe uma Action, recebe uma Observation e repete o processo até chegar a uma Final Answer.
A estrutura ReAct: pensar, agir, observar é uma aula grátis de AI Engineering Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Engineering Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Engineering Academy inclui 4 aulas no total.
O que é a estrutura ReAct
ReAct (Raciocínio + Ação) é uma estrutura de prompts que intercala o raciocínio interno do modelo com ações externas. Em vez de produzir imediatamente uma resposta final, o modelo gera um Pensamento, escolhe uma Ação, recebe uma Observação da execução dessa ação e repete o ciclo até poder fornecer uma Resposta final.
O ciclo Pensar-Agir-Observar
Cada iteração do ciclo ReAct tem três fases:
- Pensamento: o modelo raciocina sobre o que sabe e o que precisa descobrir em seguida.
- Ação: o modelo chama uma ferramenta, como uma pesquisa na web, uma calculadora ou uma consulta a um banco de dados.
- Observação: o resultado da chamada da ferramenta é retornado e acrescentado ao contexto do modelo.
O ciclo continua até o modelo emitir Final Answer: com sua conclusão.
Exemplo de rastreamento do ReAct
A seguir, veja um rastreamento concreto de um agente ReAct respondendo a “Qual é a população de Tóquio?” usando uma ferramenta de pesquisa. Observe como cada etapa se baseia na observação anterior.
# ReAct trace (pseudocode showing the reasoning loop)
# Iteration 1
Thought_1 = 'I need to find the current population of Tokyo. I will search for it.'
Action_1 = 'search("Tokyo population 2024")'
Observation_1 = 'According to the 2023 census, Tokyo has approximately 13.96 million people in the city proper.'
# Iteration 2
Thought_2 = 'I have the population. I can now give a final answer.'
Final_Answer = 'The population of Tokyo is approximately 13.96 million people.'Por que o ReAct supera os prompts diretos
Os prompts diretos pedem que o modelo responda com base na memória, o que leva a alucinações em perguntas factuais. Os prompts de raciocínio em cadeia melhoram o raciocínio, mas ainda não conseguem acessar informações externas. O ReAct combina os dois: rastreamentos explícitos de raciocínio, como os do raciocínio em cadeia, e a capacidade de obter informações atualizadas por meio de chamadas de ferramentas.
Estrutura do prompt ReAct
O prompt do sistema ReAct ensina ao modelo o formato exato que deve ser usado. Ele lista as ferramentas disponíveis com suas descrições e mostra exemplos do padrão Pensamento/Ação/Observação/Resposta final. A partir do prompt, o modelo aprende a seguir esse formato com precisão.
REACT_SYSTEM_PROMPT = '''You are an AI assistant with access to these tools:
- search(query: str): Search the web for up-to-date information.
- calculator(expression: str): Evaluate a mathematical expression.
- lookup(topic: str): Look up a topic in the knowledge base.
Always follow this exact format:
Thought: [your reasoning about what to do next]
Action: tool_name(arguments)
Observation: [result of the action, provided by the system]
... (repeat as needed)
Final Answer: [your final response to the user]
Begin!'''Analisando Pensamento, Ação e Observação
O código da sua aplicação atua como o ambiente de execução do ciclo ReAct. Após cada resposta do modelo, analise a saída para extrair o nome e os argumentos da ação, execute a função Python correspondente, formate o resultado como uma observação, acrescente-o ao histórico de mensagens e chame o modelo novamente.
import re
def parse_react_output(text: str):
'''Extract action name and argument from a ReAct model output.'''
action_match = re.search(r'Action:\s*(\w+)\((.*)\)', text)
if action_match:
tool_name = action_match.group(1)
tool_input = action_match.group(2).strip('\"\' ')
return tool_name, tool_input
if 'Final Answer:' in text:
answer = text.split('Final Answer:')[-1].strip()
return 'final', answer
return None, NoneO ciclo de execução do agente
O ciclo de execução chama o LLM, analisa a saída, encaminha a ferramenta, acrescenta a observação e repete o processo. Uma proteção max_iterations impede ciclos infinitos quando o modelo não consegue resolver uma tarefa.
from openai import OpenAI
client = OpenAI()
def run_react_agent(user_query: str, tools: dict, max_iterations: int = 10) -> str:
messages = [
{'role': 'system', 'content': REACT_SYSTEM_PROMPT},
{'role': 'user', 'content': user_query}
]
for i in range(max_iterations):
resp = client.chat.completions.create(model='gpt-4o', messages=messages)
output = resp.choices[0].message.content
messages.append({'role': 'assistant', 'content': output})
tool_name, tool_input = parse_react_output(output)
if tool_name == 'final':
return tool_input
if tool_name and tool_name in tools:
observation = tools[tool_name](tool_input)
messages.append({'role': 'user', 'content': f'Observation: {observation}'})
else:
messages.append({'role': 'user', 'content': 'Observation: Tool not found.'})
return 'Max iterations reached without a final answer.'Registrando ferramentas simples
Ferramentas são simplesmente funções Python. Você as registra em um dicionário que associa o nome da ferramenta à função. As funções recebem um argumento de texto e retornam um resultado de texto, o que mantém a interface simples e consistente com o que o modelo espera receber como observações.
import math
def calculator_tool(expression: str) -> str:
try:
# Restrict to safe math expressions
allowed_names = {k: v for k, v in math.__dict__.items() if not k.startswith('_')}
result = eval(expression, {'__builtins__': {}}, allowed_names)
return str(result)
except Exception as e:
return f'Error: {e}'
def search_tool(query: str) -> str:
# Stub — replace with real web search API
return f'Top result for "{query}": [placeholder result]'
# Register tools
tools = {
'calculator': calculator_tool,
'search': search_tool
}Raciocínio em múltiplas etapas com ReAct
O ReAct se destaca em perguntas de múltiplas etapas que exigem a combinação de várias informações. Por exemplo: “Quem é o CEO da empresa que desenvolve o GPT-4 e em que ano essa empresa foi fundada?” Primeiro, o agente pesquisa o CEO e depois usa esse resultado para descobrir o ano de fundação da empresa: duas chamadas de ferramentas distintas encadeadas pelo raciocínio.
ReAct versus raciocínio em cadeia puro
Chain-of-Thought (CoT) melhora o raciocínio fazendo o modelo pensar passo a passo, mas não permite acessar informações externas. O ReAct adiciona ações ao CoT, permitindo que o modelo obtenha dados reais, execute cálculos e verifique fatos. A desvantagem é que o ReAct é mais lento (várias chamadas de API), mas muito mais preciso em tarefas que exigem conhecimento atual ou especializado.
Depurando o ReAct com rastreamentos
Quando um agente ReAct produz uma resposta incorreta, inspecione todo o rastreamento de Pensamento/Ação/Observação. Padrões comuns de falha incluem: o modelo inventar uma observação em vez de chamar a ferramenta, erros de análise que impedem a execução da ferramenta e raciocínio incorreto na etapa de Pensamento, levando à escolha de uma ação errada.
- Registre cada mensagem acrescentada ao contexto
- Verifique se a saída da ferramenta foi realmente acrescentada antes da próxima chamada ao modelo
- Confirme se a expressão regular da ação corresponde ao formato da saída do modelo
Verificação rápida
Teste sua compreensão da estrutura ReAct.
Recapitulação da lição
Nesta lição, você aprendeu que: o ReAct intercala Pensamento, Ação e Observação em um ciclo, o código da sua aplicação atua como o ambiente de execução que executa ferramentas e acrescenta observações e as proteções max_iterations impedem ciclos infinitos do agente. A seguir, aprenderemos a definir ferramentas personalizadas para que seu agente faça exatamente o que sua aplicação precisa.
Perguntas Frequentes
A aula “A estrutura ReAct: pensar, agir, observar” é grátis?
Sim — o texto completo de “A estrutura ReAct: pensar, agir, observar” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Engineering Academy, atualize para CoddyKit PRO. O curso de AI Engineering Academy inclui 4 aulas no total.
O que vou aprender em “A estrutura ReAct: pensar, agir, observar”?
Entenda o ciclo ReAct, no qual o modelo gera um Thought, escolhe uma Action, recebe uma Observation e repete o processo até chegar a uma Final Answer. Você pratica AI Engineering Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Engineering Academy?
Nenhuma experiência prévia é necessária. AI Engineering Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “A estrutura ReAct: pensar, agir, observar”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Engineering Academy?
Sim. Cada aula de AI Engineering Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- A estrutura ReAct: pensar, agir, observar
- Definindo ferramentas para seu Agent
- Criando um Agent ReAct com LangChain
- Como lidar com falhas e loops de agentes