Agente ReAct do LangChain: Guia Completo de Implementação + Exemplos Funcionais para 2025

O Agente ReAct do LangChain é uma estrutura de resolução de problemas que combina raciocínio e ação em um processo passo a passo. Ao alternar entre analisar uma tarefa e usar ferramentas como calculadoras, busca na web ou bancos de dados, ele divide problemas complexos em etapas gerenciáveis. Essa abordagem garante precisão e clareza, especialmente para fluxos de várias etapas, como pesquisa, análise de dados ou cálculos financeiros. A implementação do LangChain se destaca por seu processo de raciocínio rastreável, que é inestimável para depurar e aprimorar o desempenho. Para tarefas mais simples, porém, essa complexidade pode não ser necessária.

Plataformas como a Latenode simplificam esses fluxos ao oferecer uma interface visual para criar processos de raciocínio e ação. Com design de arrastar e soltar, mais de 300 integrações pré-criadas e preços previsíveis, a Latenode é ideal para automatizar tarefas sem a necessidade de uma engenharia de prompts complexa. Por exemplo, você pode automatizar tarefas como atualizar bancos de dados, formatar relatórios financeiros ou integrar APIs de forma fluida. Enquanto o LangChain se destaca no raciocínio avançado em linguagem natural, a Latenode oferece uma solução mais acessível e eficiente para necessidades de automação empresarial.

Prompting ReAct no LangChain: tutorial de Python para prompts avançados de IA

Como criar um Agente ReAct do LangChain

Criar um Agente ReAct do LangChain envolve preparar seu ambiente, configurar ferramentas e elaborar prompts eficazes. Cada etapa é essencial para criar um agente funcional e eficiente.

Preparando o ambiente

Comece preparando seu ambiente com as dependências, chaves de API e credenciais necessárias. Instale a versão mais recente do LangChain e todos os pacotes necessários usando um gerenciador de pacotes como o pip. Verifique se você possui chaves de API válidas para o provedor de modelo de linguagem escolhido e configure as credenciais de todas as ferramentas externas que pretende usar. É uma boa ideia isolar as dependências do projeto em um ambiente virtual para evitar conflitos.

Usando create_react_agent

A função create_react_agent atua como o núcleo do seu Agente ReAct do LangChain. Para usá-la, você precisará de três entradas principais: uma instância de modelo de linguagem, uma lista de ferramentas e um modelo de prompt.

Cada ferramenta deve ser definida com um nome exclusivo, uma descrição concisa e uma assinatura de função clara. A descrição deve especificar quando a ferramenta deve ser usada, não apenas o que ela faz. Por exemplo, em vez de dizer “pesquisa na web”, explique que ela “pesquisa na web quando são necessárias informações atualizadas que não estão disponíveis nos dados de treinamento”.

Depois de definir suas ferramentas, você pode inicializar o agente com uma chamada simples como esta:

create_react_agent(llm=your_model, tools=your_tools, prompt=your_prompt)

Essa função retorna um agente que você pode executar usando o AgentExecutor do LangChain. Para evitar loops infinitos, defina um limite máximo de iterações ao configurar o agente.

Dicas de engenharia de prompts

Criar prompts eficazes é fundamental para um desempenho confiável do agente. Estruture seu prompt com seções distintas, como uma descrição clara da tarefa, uma lista de ferramentas, um formato de raciocínio e exemplos. Por exemplo, você pode instruir o agente a estruturar sua saída com linhas como “Pensamento: …”, seguidas de “Ação: …” e “Entrada da Ação: …”.

Inclua contraexemplos para ajudar o agente a evitar chamadas desnecessárias de ferramentas. Incentive o raciocínio passo a passo, mantendo a concisão para equilibrar profundidade e eficiência. Teste seus prompts com diversos casos extremos, incluindo entradas ambíguas ou situações em que as chamadas de ferramentas possam falhar. Esse processo ajuda a criar um agente mais confiável e adaptável.

Depuração e tratamento de erros

A depuração é essencial para lidar com problemas comuns, como loops de raciocínio, uso incorreto de ferramentas ou erros de análise. Ative logs detalhados para rastrear cada etapa do processo de tomada de decisão do agente, incluindo chamadas de ferramentas e seus resultados.

Configure mecanismos de timeout tanto para ferramentas individuais quanto para a execução geral do agente, a fim de evitar atrasos. Se uma chamada de ferramenta falhar, o agente deverá tratar o erro de forma adequada e ajustar sua estratégia. Fique atento a padrões repetitivos, como chamadas repetidas com os mesmos parâmetros, que podem indicar um loop de raciocínio. Implemente estratégias de contingência para sair desses loops e garantir uma operação fluida.

Otimização de desempenho e custos

Como os agentes ReAct operam de forma iterativa, gerenciar desempenho e custos é fundamental. Diferentes modelos de linguagem oferecem diferentes equilíbrios entre custo e desempenho, então escolha um que esteja alinhado às suas necessidades e ao seu orçamento.

Mantenha as descrições das ferramentas concisas para minimizar o uso de tokens sem perder clareza. Use técnicas como armazenar em cache os resultados de operações caras para evitar chamadas redundantes de API. Durante o desenvolvimento, comece com um limite de iterações conservador e aumente-o gradualmente se necessário, monitorando o uso de tokens para identificar áreas de otimização.

A Latenode oferece um design visual de fluxos que simplifica a depuração e a otimização em comparação com implementações programáticas tradicionais de ReAct. Essa abordagem ajuda a agilizar o processo de desenvolvimento, reduzindo muitos dos desafios normalmente associados à criação de agentes ReAct. Com essas etapas concluídas, seu agente estará pronto para testes e aprimoramentos nas próximas fases.

Exemplos de código: implementação de um Agente ReAct do LangChain

Agentes ReAct prontos para produção exigem atenção meticulosa ao tratamento de erros, à integração de ferramentas e à otimização de prompts para garantir um funcionamento fluido.

Exemplo completo de código

Este exemplo de código demonstra um fluxo completo para configurar um agente ReAct do LangChain. Ele inclui elementos essenciais, como tratamento robusto de erros, proteções de execução e integração de ferramentas personalizadas. A implementação foi projetada para lidar de forma eficaz com situações do mundo real.

import os
import getpass
import logging
from langchain.agents import create_react_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.tools import Tool
from langchain_core.prompts import PromptTemplate
from langchain.memory import ConversationBufferWindowMemory

# Configure logging for debugging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Set up environment variables
os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter OpenAI API key: ")
os.environ["TAVILY_API_KEY"] = getpass.getpass("Enter Tavily API key: ")

# Initialize the language model with specific parameters
llm = ChatOpenAI(
    model="gpt-4",
    temperature=0.1,  # Low temperature for consistent reasoning
    max_tokens=2000,
    timeout=30
)

# Define custom tools with detailed descriptions
def calculate_percentage(base_number: str, percentage: str) -> str:
    """Calculate percentage of a number. Input should be 'number,percentage'."""
    try:
        num, pct = map(float, base_number.split(','))
        result = (num * pct) / 100
        return f"{pct}% of {num} is {result}"
    except Exception as e:
        return f"Error calculating percentage: {str(e)}"

def format_currency(amount: str) -> str:
    """Format number as US currency. Input should be a number."""
    try:
        num = float(amount)
        return f"${num:,.2f}"
    except Exception as e:
        return f"Error formatting currency: {str(e)}"

# Create tool instances with optimized descriptions
search_tool = TavilySearchResults(
    max_results=3,
    description=(
        "Search the web for current information when the query requires up-to-date data not available in training. "
        "Use this tool for recent events, current prices, or real-time information."
    )
)

calculator_tool = Tool(
    name="percentage_calculator",
    func=calculate_percentage,
    description=(
        "Calculate what percentage of a number equals. Input format: 'base_number,percentage'. "
        "Example: '1000,15' calculates 15% of 1000."
    )
)

currency_tool = Tool(
    name="currency_formatter",
    func=format_currency,
    description=(
        "Format numbers as US dollar currency with proper comma separators and decimal places. "
        "Input should be a numeric value."
    )
)

tools = [search_tool, calculator_tool, currency_tool]

# Create optimized prompt template
react_prompt = PromptTemplate.from_template("""
You are a helpful assistant that can reason step-by-step and use tools to solve problems.

Available tools:
{tools}

Tool descriptions:
{tool_names}

Use the following format for your responses:

Question: the input question you must answer
Thought: think about what you need to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation sequence can repeat as needed)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Important guidelines:
- Only use tools when necessary.
- If you can answer from existing knowledge, do so directly.
- Always provide a clear final answer.
- If a tool fails, try an alternative approach.

Question: {input}
{agent_scratchpad}
""")

# Create the ReAct agent with error handling
try:
    agent = create_react_agent(
        llm=llm,
        tools=tools,
        prompt=react_prompt
    )

    # Configure agent executor with safety limits
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        max_iterations=5,
        max_execution_time=60,        # 60-second timeout
        handle_parsing_errors=True,
        return_intermediate_steps=True
    )

    logger.info("ReAct agent created successfully")

except Exception as e:
    logger.error(f"Failed to create agent: {str(e)}")
    raise

# Executing the Agent Query with Robust Error Handling
def run_agent_query(query: str):
    """Execute agent query with comprehensive error handling."""
    try:
        logger.info(f"Processing query: {query}")
        result = agent_executor.invoke({"input": query})
        return {
            "success": True,
            "answer": result["output"],
            "steps": result.get("intermediate_steps", []),
            "iterations": len(result.get("intermediate_steps", []))
        }
    except Exception as e:
        logger.error(f"Agent execution failed: {str(e)}")
        return {
            "success": False,
            "error": str(e),
            "answer": "I encountered an error while processing your request."
        }

# Test the agent with sample queries
if __name__ == "__main__":
    test_queries = [
        "What is 25% of $50,000 formatted as currency?",
        "Find the current stock price of Apple and calculate what 10% of that price would be",
        "What's the weather like in New York today?"
    ]

    for query in test_queries:
        print(f"{'='*50}")
        print(f"Query: {query}")
        print(f"{'='*50}")

        result = run_agent_query(query)

        if result["success"]:
            print(f"Answer: {result['answer']}")
            print(f"Iterations used: {result['iterations']}")
        else:
            print(f"Error: {result['error']}")

Essa configuração incorpora vários recursos essenciais:

• Modelo de prompt: As instruções são explicitamente formatadas para reduzir erros de análise.
• Ferramentas personalizadas: As ferramentas são projetadas com descrições claras para tarefas como cálculos de porcentagem e formatação de moeda.
• Configuração do executor do agente: Limites de iteração e timeouts de execução são definidos para evitar loops infinitos de raciocínio ou processamento excessivo.

Testes e validação

Para garantir que a implementação seja confiável, é essencial ter um processo estruturado de testes. Veja algumas etapas práticas para avaliar o desempenho do agente:

• Crie uma suíte de testes abrangente que inclua consultas factuais diretas e situações complexas de várias etapas.
• Examine as etapas intermediárias para confirmar que o processo de raciocínio está alinhado ao comportamento esperado.
• Monitore o consumo de tokens e as contagens de iteração para identificar áreas de otimização.
• Teste casos extremos e entradas inesperadas para verificar os recursos de tratamento de erros do agente.

Essas medidas ajudarão a validar o desempenho do agente e garantir que ele atenda aos padrões de produção.

sbb-itb-23997f1

Agentes ReAct vs. outros tipos de agentes do LangChain

Os agentes ReAct são uma parte distinta do conjunto de arquiteturas de agentes do LangChain, cada uma adaptada a estilos específicos de raciocínio e necessidades operacionais. Comparar os agentes ReAct com outros tipos evidencia seus pontos fortes e limitações, ajudando os usuários a escolher a ferramenta certa para cada tarefa.

Recursos e complexidade

Os agentes ReAct se destacam por sua capacidade de dividir problemas complexos em etapas menores e acionáveis por meio de sequências explícitas de pensamento e ação. Isso os torna particularmente eficazes para situações complexas de resolução de problemas nas quais entender o processo de raciocínio é essencial. Sua abordagem iterativa permite análises detalhadas e decisões precisas, diferentemente de arquiteturas mais simples que tentam resolver problemas em uma única etapa.

Os agentes conversacionais, por outro lado, se destacam em manter o contexto ao longo de várias interações, tornando-os ideais para interações baseadas em chat. No entanto, eles geralmente têm desempenho inferior em situações que exigem muitas ferramentas, nas quais os agentes ReAct prosperam.

Os agentes zero-shot são projetados para simplicidade, exigindo configuração mínima e obtendo bons resultados em tarefas diretas. Embora esses agentes sejam eficientes para consultas básicas, eles não têm os recursos de raciocínio detalhado e em camadas dos agentes ReAct, que dependem de engenharia de prompts e integração de ferramentas mais avançadas.

Custo e desempenho

Os ciclos iterativos de raciocínio dos agentes ReAct levam a um maior uso de tokens, o que pode aumentar os custos, especialmente em tarefas simples que não exigem raciocínio detalhado. Isso os torna menos econômicos para consultas básicas em comparação com tipos de agentes mais leves.

Além disso, os agentes ReAct tendem a levar mais tempo para serem executados devido à sua abordagem passo a passo. Embora isso possa resultar em maior confiabilidade para tarefas de várias etapas, também introduz mais sobrecarga computacional. No entanto, seu processo estruturado de seleção de ferramentas geralmente resulta em maior precisão, tornando-os uma escolha confiável para fluxos complexos.

Escalabilidade e casos de uso

Para tarefas que envolvem grandes volumes de consultas diretas, arquiteturas de agentes mais simples geralmente oferecem melhor eficiência de custos e processamento mais rápido. Em contraste, os agentes ReAct se destacam em situações que exigem análise aprofundada ou resolução de problemas, nas quais seu processo de raciocínio transparente se torna uma vantagem essencial.

Em ambientes empresariais, a capacidade dos agentes ReAct de fornecer um raciocínio claro e auditável torna-os muito valiosos para solucionar problemas e realizar auditorias em ambientes de produção. Para o suporte ao cliente, agentes conversacionais geralmente são suficientes para lidar com perguntas rotineiras, mas questões técnicas mais complexas se beneficiam da abordagem sistemática e passo a passo dos agentes ReAct.

Os agentes ReAct são particularmente eficazes para tarefas de pesquisa e análise que exigem sintetizar informações de múltiplas fontes em conclusões coerentes. Sua capacidade de lidar com fluxos de várias etapas com clareza e precisão reforça sua adequação a desafios complexos e imprevisíveis. Em última análise, a escolha do tipo de agente depende das necessidades específicas da tarefa: agentes mais simples podem ser mais eficientes em situações previsíveis, enquanto os agentes ReAct justificam sua sobrecarga adicional em casos que exigem raciocínio avançado e transparência.

Usando a Latenode para fluxos visuais de raciocínio e ação

Os agentes ReAct do LangChain geralmente exigem engenharia meticulosa de prompts e integração manual de código, o que pode consumir tempo e ser complexo. Plataformas como a Latenode simplificam esse processo ao permitir fluxos de raciocínio e ação por meio de uma interface visual de design. Essa abordagem permite que as equipes desenvolvam processos de resolução de problemas em várias etapas sem precisar gerenciar modelos complexos de prompts de agentes, criando uma experiência de design mais intuitiva e acessível.

Criador visual de fluxos da Latenode

O criador visual de fluxos da Latenode transforma os padrões complexos de raciocínio e ação dos agentes ReAct em fluxos intuitivos de arrastar e soltar. Esse design elimina a necessidade de depurar modelos de prompt complexos ou gerenciar erros de chamadas de ferramentas. Em vez disso, as equipes podem mapear visualmente fluxos de várias etapas, tornando cada ponto de decisão claro e mais fácil de aprimorar.

Um recurso de destaque é o AI Code Copilot, que gera código JavaScript diretamente nos fluxos. Isso elimina a necessidade de escrever do zero códigos personalizados de integração de ferramentas, mantendo os recursos de resolução sistemática de problemas. As equipes se beneficiam de feedback imediato, obtendo uma visão clara de como os dados fluem entre as etapas, onde as decisões ocorrem e como as ferramentas são utilizadas — transparência que muitas vezes falta em configurações tradicionais de agentes.

Além disso, os recursos de ramificações e lógica condicional permitem que os fluxos se adaptem dinamicamente com base em dados em tempo real. Essa capacidade reproduz o raciocínio flexível dos agentes ReAct, mas evita a complexidade da engenharia de prompts.

Principais recursos para automação empresarial

A Latenode oferece vários recursos que a tornam uma plataforma ideal para automação empresarial:

• Automação com navegador headless: As equipes podem automatizar sites, extrair dados e preencher formulários diretamente nos fluxos, eliminando a necessidade de código personalizado para ferramentas. Isso reduz significativamente o esforço e o custo associados à integração de ferramentas.
• Funcionalidade de banco de dados integrada: Ao contrário dos agentes ReAct, que frequentemente têm dificuldades para manter o contexto em várias interações, os fluxos da Latenode podem armazenar, consultar e atualizar dados estruturados de forma fluida, garantindo memória persistente entre sessões.
• Integrações abrangentes: Com suporte para mais de 300 integrações de aplicativos e mais de 200 modelos de IA, a Latenode oferece a diversidade necessária para automação sem exigir desenvolvimento personalizado de APIs.
• Histórico de execução e reexecuções de fluxos: Depurar fluxos se torna muito mais simples do que solucionar loops de raciocínio de agentes ReAct. As equipes podem rastrear e entender facilmente as decisões dentro dos fluxos.
• Preços econômicos: Os preços da Latenode são baseados no tempo de execução, e não no uso de tokens, oferecendo custos previsíveis. Os planos variam de US$ 19 a US$ 299 por mês, com visibilidade clara sobre o consumo de recursos.

Comparação com agentes ReAct do LangChain

Embora os agentes ReAct sejam conhecidos por sua capacidade de lidar com raciocínio linguístico complexo, a Latenode oferece uma alternativa estruturada e visual particularmente adequada para tarefas de automação empresarial. Veja uma comparação direta entre os dois:

Os fluxos visuais da Latenode oferecem um nível de transparência que simplifica a depuração e está alinhado às necessidades da automação empresarial. Essa clareza é especialmente valiosa em ambientes de produção, nos quais compreender os processos de tomada de decisão é crucial para conformidade e auditoria. Embora os agentes ReAct forneçam rastros de raciocínio, a abordagem visual da Latenode torna todo o processo imediatamente compreensível para as partes interessadas não técnicas.

Para tarefas que exigem raciocínio avançado em linguagem natural, os agentes ReAct mantêm uma vantagem. No entanto, para a maioria das necessidades de automação empresarial — como processamento sistemático de dados, interações com APIs e lógica condicional — a Latenode oferece funcionalidades comparáveis com muito menos complexidade e esforço de manutenção.

Dicas e considerações finais

Criar agentes ReAct do LangChain prontos para produção envolve planejamento cuidadoso, especialmente em relação ao design de prompts, ao gerenciamento de custos e aos desafios de escalabilidade.

Dicas para agentes ReAct

• Defina um limite de max_iterations: Configurar esse parâmetro, por exemplo, como 5 evita que os agentes entrem em loops infinitos de raciocínio. Isso não só evita o uso excessivo de APIs como também mantém os custos sob controle[1].
• Seja preciso nas descrições das ferramentas: Evite instruções vagas como “ferramenta de busca”. Em vez disso, forneça diretrizes claras, como “Use a ferramenta WebSearch apenas para perguntas que exigem informações atuais”.[2] Isso garante que o agente selecione as ferramentas certas e evita confusões.
• Mantenha o conjunto de ferramentas pequeno: Limite o número de ferramentas a três ou menos, cada uma com uma finalidade bem definida. Ferramentas demais podem sobrecarregar os agentes, levando à paralisia de decisão ou a erros no uso das ferramentas[2]. Um conjunto menor e focado reduz a complexidade dos prompts e melhora a confiabilidade.
• Ative o modo detalhado e logs estruturados: Isso ajuda a acompanhar etapas de raciocínio, uso de ferramentas e desempenho geral. Ao analisar métricas como etapas médias de raciocínio, frequência de chamadas de ferramentas e custo por interação em USD, você pode identificar pontos fracos nos prompts e otimizar os processos com mais eficácia[1].

Limitações dos agentes ReAct

• Custos imprevisíveis: Cada etapa de raciocínio e chamada de ferramenta gera taxas de uso de LLM, que podem aumentar rapidamente, especialmente em tarefas complexas. Diferentemente de aplicativos tradicionais com consumo fixo de recursos, os agentes ReAct podem variar significativamente em custo por consulta conforme as exigências da tarefa[1].
• Desafios de escalabilidade: Conforme a complexidade aumenta, o desempenho pode diminuir. Agentes encarregados de escolher entre várias ferramentas ou de lidar com consultas ambíguas geralmente exigem uma engenharia extensa de prompts, tornando-os menos adequados para situações dinâmicas[2].
• Questões de confiabilidade: Casos extremos ou entradas inesperadas podem fazer os agentes falharem ou produzirem resultados inconsistentes. Resolver esses problemas exige testes rigorosos e mecanismos de contingência para garantir desempenho consistente em produção[2].
• Dificuldades de manutenção: Adaptar agentes ReAct às necessidades empresariais em evolução pode consumir tempo. Mesmo pequenas alterações em prompts ou lógica podem causar consequências não intencionais, exigindo testes completos para manter a estabilidade.

Esses desafios revelam os benefícios de explorar abordagens alternativas, como ferramentas visuais de fluxo, para gerenciar processos de raciocínio e ação.

Quando usar a Latenode

Considerando as limitações dos agentes ReAct, a Latenode oferece uma alternativa prática e fácil de usar para gerenciar tarefas de raciocínio e automação.

• Design transparente de fluxos: A interface visual da Latenode simplifica a criação e a modificação de processos de raciocínio e ação. As equipes podem entender e ajustar fluxos facilmente sem exigir conhecimento técnico avançado, reduzindo a necessidade de depuração e integração extensivas.
• Automação empresarial simplificada: A Latenode oferece visibilidade clara dos processos de tomada de decisão, permitindo que partes interessadas não técnicas participem do desenvolvimento dos fluxos. Sua abordagem passo a passo oferece suporte a prototipagem rápida e esforços colaborativos.
• Custos previsíveis: Com preços baseados no tempo de execução, e não no uso de tokens, a Latenode ajuda as equipes a evitar despesas inesperadas causadas por loops de raciocínio extensos. Os planos que variam de US$ 19 a US$ 299 por mês oferecem estruturas de custo claras, tornando o gerenciamento do orçamento mais simples.
• Modificações rápidas: Diferentemente dos agentes ReAct, que podem exigir longos ciclos de ajustes e testes de prompts, a Latenode permite edição visual em tempo real. Isso permite que as equipes implementem mudanças imediatamente, economizando tempo e esforço ao se adaptar a novos requisitos.

Muitas equipes descobriram que a Latenode oferece recursos comparáveis de raciocínio e ação, ao mesmo tempo em que proporciona maior transparência e flexibilidade. Seu design visual é especialmente adequado para tarefas de automação empresarial que não exigem processamento complexo de linguagem natural, tornando-a uma excelente escolha para organizações que priorizam simplicidade e eficiência.