Como Criar Agentes de IA com Claude e LangChain em 2026

Agentes de IA deixaram de ser conceito de ficção científica para se tornarem ferramentas reais de produção. Com o Claude da Anthropic como cérebro e o LangChain como framework de orquestração, qualquer desenvolvedor consegue montar agentes que raciocinam, usam ferramentas externas e resolvem tarefas complexas de forma autônoma. Neste guia prático, você vai entender a arquitetura por trás desses agentes, ver código funcional e sair pronto para criar o seu.

Trabalho com agentes de IA há mais de um ano, e posso dizer que a combinação Claude + LangChain mudou completamente minha forma de automatizar tarefas. Antes, eu montava pipelines rígidos com scripts sequenciais. Depois que comecei a usar agentes com raciocínio dinâmico, percebi que a parte mais difícil não é o código — é desenhar bem as ferramentas que o agente vai usar. Claude, em particular, tem uma capacidade de seguir instruções longas e complexas que supera o que eu conseguia com outros modelos. A diferença fica clara quando o agente precisa decidir entre múltiplas ferramentas em sequência sem perder o contexto.

O que são agentes de IA e por que eles importam

Um agente de IA é um sistema que recebe um objetivo, raciocina sobre como atingi-lo e executa ações usando ferramentas disponíveis — tudo sem intervenção humana a cada passo. Diferente de um chatbot simples que apenas responde perguntas, um agente toma decisões dinâmicas: ele pode buscar dados em uma API, processar um arquivo, executar código e combinar os resultados antes de entregar a resposta final.

O conceito ganhou tração prática em 2025 quando frameworks como LangChain tornaram acessível o que antes exigia engenharia pesada. Em 2026, segundo o relatório State of Agent Engineering da LangChain, 57% das organizações pesquisadas já implantaram agentes em produção, com outros 30% em desenvolvimento ativo. Não é mais experimento — é infraestrutura.

A arquitetura básica de um agente tem três camadas: o modelo de linguagem (LLM) como cérebro, as ferramentas como mãos, e a memória como contexto persistente. Claude se destaca na primeira camada por sua janela de contexto extensa e capacidade de seguir instruções complexas sem desviar do objetivo.

Por que Claude como LLM para agentes

Nem todo modelo funciona bem como motor de um agente. O modelo precisa ser confiável em seguir instruções, consistente no formato de saída e capaz de raciocinar sobre quando e como usar ferramentas. Claude, especialmente nas versões Opus e Sonnet, se destaca em três aspectos críticos para agentes:

• Janela de contexto massiva — com até 1 milhão de tokens no Opus 4, o agente pode manter conversas longas com histórico completo de ferramentas usadas sem perder informação.
• Aderência a instruções — Claude segue system prompts longos e detalhados com alta fidelidade, o que é essencial quando você define regras complexas de uso de ferramentas.
• Tool use nativo — a API do Claude suporta function calling nativamente, eliminando a necessidade de hacks de parsing de texto.

Além disso, a Anthropic lançou em 2026 o Claude Agent SDK, que fornece primitivas prontas para construção de agentes com subagents, sessões e suporte a MCP (Model Context Protocol). Para quem quer máxima integração com o ecossistema Claude, o SDK é o caminho direto. Mas para flexibilidade multi-modelo e observabilidade via LangSmith, LangChain continua sendo a escolha mais versátil.

LangChain e LangGraph: a evolução do framework

LangChain começou como uma biblioteca para encadear chamadas a LLMs com ferramentas. O componente original para agentes, o AgentExecutor, conectava um LLM a um conjunto de tools e gerenciava o loop de raciocínio-ação. Funcionava, mas era difícil de customizar para fluxos complexos.

Em 2025, a equipe do LangChain lançou o LangGraph, que substituiu o executor linear por uma arquitetura baseada em grafos. Cada nó do grafo representa um agente ou etapa de processamento, com controle fino sobre fluxo, retries e tratamento de erros. Para 2026, LangGraph é o padrão recomendado para agentes em produção.

A migração do AgentExecutor para LangGraph não é obrigatória para casos simples, mas qualquer agente que precise de múltiplas ferramentas coordenadas, retry inteligente ou intervenção humana condicional vai se beneficiar do modelo de grafos.

Configurando o ambiente de desenvolvimento

Antes de escrever o primeiro agente, você precisa configurar o ambiente. Aqui está o setup mínimo funcional:

pip install langchain-anthropic langchain-core langgraph python-dotenv

Crie um arquivo .env na raiz do projeto com sua chave da API Anthropic:

ANTHROPIC_API_KEY=sk-ant-sua-chave-aqui

A biblioteca langchain-anthropic (versão 1.4+ em junho de 2026) é o conector oficial entre LangChain e a API do Claude. Ela implementa a interface BaseChatModel do LangChain, o que significa que Claude funciona como drop-in replacement para qualquer outro modelo no framework.

Para verificar que tudo funciona, um teste rápido:

from langchain_anthropic import ChatAnthropic
from dotenv import load_dotenv

load_dotenv()
model = ChatAnthropic(model="claude-sonnet-4-6")
response = model.invoke("Diga olá em uma frase.")
print(response.content)

Se isso retornar uma resposta, o ambiente está pronto.

Construindo seu primeiro agente com ferramentas

O poder de um agente está nas ferramentas que ele pode usar. Vamos criar um agente simples que tem acesso a duas ferramentas: uma calculadora e um buscador de clima. O agente decide sozinho qual usar baseado na pergunta do usuário.

from langchain_anthropic import ChatAnthropic
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

@tool
def calculadora(expressao: str) -> str:
    'Calcula uma expressão matemática. Use para qualquer conta.'
    try:
        resultado = eval(expressao)  # Em produção, use um parser seguro
        return f"Resultado: {resultado}"
    except Exception as e:
        return f"Erro: {e}"

@tool
def clima_atual(cidade: str) -> str:
    'Retorna o clima atual de uma cidade brasileira.'
    # Simulação — em produção, conecte a uma API real
    climas = {"São Paulo": "22°C, nublado", "Rio de Janeiro": "28°C, ensolarado"}
    return climas.get(cidade, f"Dados não disponíveis para {cidade}")

model = ChatAnthropic(model="claude-sonnet-4-6")
agent = create_react_agent(model, [calculadora, clima_atual])

# Executar o agente
result = agent.invoke({
    "messages": [{"role": "user", "content": "Qual o clima em São Paulo? E quanto é 15% de 3500?"}]
})

for msg in result["messages"]:
    print(f"{msg.type}: {msg.content}")

O que acontece por baixo: o Claude recebe a pergunta, identifica que precisa de duas ferramentas diferentes, chama clima_atual com "São Paulo" e calculadora com "3500 * 0.15", recebe os resultados e compõe uma resposta natural combinando ambos. Tudo isso em um único fluxo de raciocínio.

Anatomia do loop ReAct

O padrão ReAct (Reasoning + Acting) é o coração da maioria dos agentes. O ciclo funciona assim: o LLM recebe o contexto, raciocina sobre o próximo passo, decide se precisa de uma ferramenta, executa a ação, observa o resultado e repete até ter informação suficiente para responder. O create_react_agent do LangGraph implementa esse loop como um grafo com dois nós — o nó do modelo e o nó de execução de ferramentas — conectados em ciclo.

Agentes avançados: memória, subagentes e MCP

Um agente básico com ferramentas já resolve muitos problemas. Mas para cenários de produção, você precisa de três capacidades adicionais: memória persistente, delegação para subagentes e integração com serviços externos via MCP.

Memória persistente com checkpointing

LangGraph suporta checkpointing nativo — a cada passo do agente, o estado é salvo em um backend (SQLite para desenvolvimento, Postgres para produção). Isso permite que o agente retome uma conversa exatamente de onde parou, mesmo após reiniciar o processo:

from langgraph.checkpoint.sqlite import SqliteSaver

memory = SqliteSaver.from_conn_string(":memory:")
agent = create_react_agent(model, tools, checkpointer=memory)

# Primeira conversa
config = {"configurable": {"thread_id": "usuario-123"}}
agent.invoke({"messages": [{"role": "user", "content": "Meu nome é Ana"}]}, config)

# Segunda conversa — o agente lembra
agent.invoke({"messages": [{"role": "user", "content": "Qual meu nome?"}]}, config)
# Resposta: "Seu nome é Ana"

Subagentes para tarefas complexas

Quando uma tarefa é grande demais para um único agente, você pode decompô-la em subagentes especializados. No LangGraph, cada subagente é um nó do grafo que pode ter suas próprias ferramentas e instruções. Um agente orquestrador decide qual subagente acionar baseado na tarefa.

Por exemplo, um agente de análise de código pode ter três subagentes: um para buscar arquivos relevantes, outro para analisar dependências e um terceiro para sugerir refatorações. O Claude Opus, com seu contexto de 1M de tokens, é particularmente eficaz como orquestrador porque consegue manter o estado completo de todos os subagentes simultaneamente.

Model Context Protocol (MCP)

O MCP é um protocolo aberto que padroniza como agentes se conectam a fontes de dados e serviços externos. Em vez de criar integrações customizadas para cada API, você expõe seus serviços como servidores MCP e o agente se conecta automaticamente. LangGraph já suporta MCP nativamente desde a versão 1.2, e o Claude Agent SDK foi construído com MCP como primitiva central.

Na prática, isso significa que um agente pode acessar bancos de dados, sistemas de arquivos, APIs internas e ferramentas de terceiros através de uma interface unificada, sem que o desenvolvedor precise escrever código de integração específico para cada um.

Boas práticas para agentes em produção

Colocar um agente em produção exige cuidados que vão além do código funcional. Aqui estão as práticas que aprendi na prática:

• Limite o número de iterações — defina um max_iterations para evitar loops infinitos. Um agente que não resolve em 10 passos provavelmente precisa de ferramentas melhores, não de mais tentativas.
• Monitore com LangSmith — a plataforma de observabilidade do LangChain permite rastrear cada passo do agente, incluindo tokens consumidos, latência de cada tool call e a cadeia de raciocínio completa. Essencial para debug em produção.
• Valide outputs de ferramentas — ferramentas podem retornar erros ou dados inesperados. Adicione validação nos retornos antes de devolvê-los ao agente.
• Use streaming para UX — agentes demoram. Streaming token por token mantém o usuário engajado enquanto o agente trabalha. LangGraph suporta streaming de eventos de ferramentas além do texto.
• Implemente circuit breakers — se uma ferramenta externa está fora do ar, o agente não deve ficar tentando indefinidamente. Configure timeouts e fallbacks.
• Teste com cenários adversariais — agentes são não-determinísticos. Crie testes que cobrem entradas ambíguas, ferramentas que falham e pedidos que o agente não deveria atender.

Claude Agent SDK vs LangChain: quando usar cada um

A escolha entre o Claude Agent SDK e LangChain não é binária — depende do seu caso de uso. Segundo uma análise comparativa publicada em março de 2026, a decisão se resume a duas perguntas: você precisa de flexibilidade multi-modelo? E quanto controle quer sobre a orquestração?

Se seu stack é 100% Claude e você quer ir rápido, o Agent SDK reduz o boilerplate significativamente. Se você precisa trocar de modelo, ter observabilidade detalhada ou criar fluxos de orquestração complexos com grafos condicionais, LangChain com LangGraph é mais adequado. Muitos times usam ambos: Agent SDK para agentes simples internos e LangGraph para pipelines complexos de produção.

Conclusão

Construir agentes de IA com Claude e LangChain não é mais uma aposta tecnológica — é uma abordagem validada por milhares de empresas em produção. O Claude fornece a capacidade de raciocínio e aderência a instruções que um agente confiável exige, enquanto LangChain e LangGraph oferecem a estrutura de orquestração para transformar esse raciocínio em ações coordenadas. O caminho mais rápido para começar é o exemplo ReAct deste artigo: defina duas ou três ferramentas reais do seu domínio, conecte ao Claude via langchain-anthropic, e deixe o agente resolver. Você vai se surpreender com o que um loop de raciocínio bem configurado consegue fazer sem que você precise codificar cada decisão.