Como Criar um Agente de IA com LangChain em Python? Resposta Direta
Criar um agente de IA em Python com LangChain leva cinco passos e aproximadamente 20 linhas de código: instale o framework e o provider de LLM, configure o modelo com sua chave de API, defina as ferramentas que o agente pode usar com o decorador @tool, crie o agente com create_agent() e execute com invoke(). O LangChain cuida de todo o ciclo ReAct — o modelo pensa, decide qual ferramenta chamar, observa o resultado e repete até concluir a tarefa.
A função create_agent(model, tools, system_prompt) é o coração do processo, conforme a documentação oficial do LangChain. Ela aceita três parâmetros obrigatórios — o modelo de linguagem, a lista de ferramentas e um prompt de sistema opcional — e devolve um agente pronto para execução.
Se você ainda não leu o guia completo de implementação de agentes de IA na sua empresa, vale a pena começar por lá para entender o contexto mais amplo antes de mergulhar no código.
O que é o LangChain e Por Que Usá-lo para Criar Agentes de IA?
LangChain é um framework de orquestração open source para aplicações com LLMs, disponível em Python e JavaScript. A IBM define o LangChain como "um framework de orquestração que fornece abstrações prontas para models, prompts, chains, indexes, memory, tools e agents". Ele foi projetado especificamente para simplificar a criação de agentes de IA que precisam raciocinar, usar ferramentas e manter contexto.
Por que usar LangChain em vez de escrever a lógica manualmente? A documentação de overview do LangChain mostra que é possível construir agentes funcionais em menos de 10 linhas de código. O framework lida com parsing de respostas do LLM, seleção de ferramentas e gerenciamento de estado — coisas que você não quer implementar na mão.
O LangChain oferece integrações com dezenas de providers — OpenAI, Anthropic, Google Gemini, Ollama, AWS Bedrock e Hugging Face, entre outros — todos com a mesma interface padronizada. Você pode trocar de modelo sem reescrever o código do agente.
Segundo a IBM, agentes de IA são "sistemas autônomos que realizam tarefas projetando workflows com ferramentas disponíveis". O LangChain materializa essa definição na prática: você dá ao agente um modelo pra pensar, ferramentas pra agir e um prompt pra direcionar o comportamento.
Passo 1: Instalação e Configuração do Ambiente Python
O primeiro passo é preparar o ambiente. Você precisa de Python 3.9+ e de uma chave de API de algum provider de LLM — OpenAI, Anthropic ou Google.
# Instalação dos pacotes necessários
# pip install langchain langchain-openai python-dotenv
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
# Carrega a API key do arquivo .env
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
# Verifica se a chave foi carregada
if not openai_api_key:
raise ValueError("OPENAI_API_KEY não encontrada. Crie um arquivo .env com a chave.")
O tutorial oficial do LangChain recomenda instalar o pacote base langchain junto com o provider específico — langchain-openai, langchain-anthropic ou langchain-google-genai. A instalação separada evita baixar dependências desnecessárias.
Crie um arquivo .env na raiz do projeto:
OPENAI_API_KEY=sk-sua-chave-aqui
Se quiser tracing e debug, configure também o LangSmith:
LANGSMITH_TRACING=true
LANGSMITH_API_KEY=sua-chave-langsmith
O LangSmith é uma plataforma de observabilidade que registra cada chamada do agente — útil quando o comportamento não sai como esperado. A documentação de overview menciona que o LangSmith é a ferramenta recomendada para debugging de agentes em produção.
Passo 2: Escolher e Configurar o Modelo de Linguagem (LLM)
Com o ambiente pronto, o próximo passo é configurar o modelo. A vantagem do LangChain é a interface unificada: todos os providers seguem o mesmo padrão de chamada — invoke(), stream(), batch().
from langchain_openai import ChatOpenAI
# Configura o modelo com temperatura baixa para comportamento determinístico
llm = ChatOpenAI(
model="gpt-4", # ou "gpt-4o", "gpt-4o-mini"
temperature=0, # 0 = mais determinístico, recomendado para agentes
max_tokens=2000, # limite de tokens na resposta
max_retries=2 # tentativas em caso de falha
)
A documentação do LangChain ressalta que temperature=0 é a configuração recomendada para agentes. Isso reduz a variabilidade nas escolhas de ferramentas — você não quer que o agente "invente" uma ferramenta diferente a cada execução para a mesma pergunta.
Para usar outros providers, a troca é direta. O LangChain suporta múltiplos modelos com a mesma interface:
# Anthropic
# from langchain_anthropic import ChatAnthropic
# llm = ChatAnthropic(model="claude-sonnet-4-6", temperature=0)
# Google
# from langchain_google_genai import ChatGoogleGenerativeAI
# llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash", temperature=0)
A função init_chat_model() do LangChain permite ainda selecionar o modelo por uma string única como "openai:gpt-4o", facilitando a troca via variável de ambiente.
Passo 3: Definir as Ferramentas (Tools) do Agente
Sem ferramentas, o LLM só responde com o que sabe do treinamento. Com tools, ele pode consultar APIs, buscar informações na web, fazer cálculos ou interagir com sistemas externos.
from langchain.tools import tool
@tool
def get_weather(city: str) -> str:
"""Get the current weather for a given city."""
# Aqui você chamaria uma API real de clima
return f"The weather in {city} is currently sunny, 22°C"
@tool
def search_web(query: str) -> str:
"""Search the web for current information on a topic."""
# Aqui você usaria DuckDuckGoSearch ou outra API
return f"Search results for '{query}': [simulated results]"
tools = [get_weather, search_web]
O decorador @tool transforma qualquer função Python em uma ferramenta chamável pelo agente. A documentação do LangChain explica que a docstring da função é crucial — o LLM a lê para decidir quando chamar aquela tool. A IBM destaca que o LangChain oferece tanto o decorador @tool quanto a classe Tool para criação de ferramentas. Além das tools customizadas, existem dezenas de ferramentas pré-construídas disponíveis — como WikipediaQueryRun, YouTubeSearchTool, DuckDuckGoSearch e OpenWeatherMap.
O tutorial da IBM sobre LangChain tools menciona ferramentas como YouTubeSearchTool e OpenWeatherMap como exemplos de integrações que já vêm prontas no ecossistema LangChain.
A assinatura da função (nome + parâmetros tipados) define como o LLM chama a tool. Se você declarar get_weather(city: str), o modelo sabe que precisa fornecer uma string com o nome da cidade. response_format="content_and_artifact" permite que a tool retorne tanto texto para o LLM quanto artefatos para o desenvolvedor.
Passo 4: Criar o Agente com create_agent (Código Completo)
Agora vamos juntar o modelo e as ferramentas em um agente funcional.
from langchain.agents import create_agent
# Cria o agente com modelo, ferramentas e instruções de sistema
agent = create_agent(
model=llm,
tools=tools,
system_prompt=(
"You are a helpful weather and search assistant. "
"When the user asks about weather, use the get_weather tool. "
"When they ask for information, use the search_web tool. "
"Always use the appropriate tool before answering."
)
)
# Executa o agente com uma pergunta
result = agent.invoke(
{"messages": [
{"role": "user", "content": "What's the weather in São Paulo today?"}
]}
)
# Exibe a resposta final
print(result["messages"][-1].content)
A documentação oficial mostra que create_agent(model, tools, system_prompt) é a função principal para construir agentes. Ela encapsula a lógica de criação do grafo de execução, o ciclo ReAct e o gerenciamento de estado.
A arquitetura de agentes no framework segue o padrão: modelo de linguagem + ferramentas + prompt de sistema. O create_agent orquestra esses três componentes automaticamente.
Diferente de chains — que seguem uma sequência fixa de passos — agentes decidem dinamicamente qual caminho seguir. A IBM descreve o tool calling como o mecanismo pelo qual o LLM retorna o nome da ferramenta e os argumentos para execução, sem que o desenvolvedor precise pré-definir a ordem das chamadas.
Passo 5: Executar o Agente e o Ciclo ReAct (Tool Calling)
Chamar invoke() dispara o ciclo ReAct internamente. Cada iteração segue este fluxo: Thought → Action → Observation → repete ou responde.
# Execução com streaming para ver cada etapa do raciocínio
print("=== Agente pensando em tempo real ===\n")
for event in agent.stream(
{"messages": [
{"role": "user", "content": "Qual a previsão do tempo no Rio de Janeiro?"}
]},
stream_mode="values",
):
event["messages"][-1].pretty_print()
print("---")
A saída no terminal mostra o ciclo completo. Primeiro o modelo identifica que precisa da ferramenta de clima (Thought). Depois gera uma chamada para get_weather com o argumento "Rio de Janeiro" (Action). A tool retorna o resultado simulado (Observation). Com a informação em mãos, o modelo formula a resposta final.
O conceito de ReAct (Reasoning + Acting) foi formalizado no artigo de referência de Lilian Weng sobre agentes autônomos com LLM. Ela descreve o ReAct como a "integração de raciocínio e ação dentro do LLM, estendendo o espaço de ações para incluir chamadas de ferramentas".
A IBM destaca o ReAct como um dos principais paradigmas de raciocínio para agentes de IA. O ciclo Thought-Action-Observation permite que o agente planeje seus passos, execute ações e aprenda com os resultados em tempo real.
O tutorial da IBM explica que você também pode usar bind_tools como alternativa — um método que passa a lista de ferramentas diretamente ao LLM sem usar create_agent. A diferença é que create_agent já embute o ciclo ReAct completo, enquanto bind_tools exige que você gerencie o loop manualmente.
Por padrão, o agente tem um limite de iterações (max_iterations) para evitar loops infinitos. Quando o limite é atingido, o comportamento é definido por early_stopping_method — configurável entre "force" (para forçadamente) e "generate" (tenta gerar uma resposta mesmo sem conclusão).
Adicionando Memória ao Agente LangChain
Agentes sem memória tratam cada interação como se fosse a primeira. Se você quer conversas com múltiplas trocas, precisa adicionar memória explicitamente.
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True
)
# Ao criar o agente, passe o memory
agent_with_memory = create_agent(
model=llm,
tools=tools,
system_prompt="You are a helpful assistant.",
memory=memory
)
A IBM aponta que a memória é um dos componentes centrais do LangChain, ao lado de models, prompts, chains, tools e agents. O framework oferece diferentes tipos: ConversationBufferMemory (histórico completo), ConversationSummaryMemory (resumo para economizar tokens) e VectorStoreMemory (memória de longo prazo com busca semântica).
Lilian Weng, em seu artigo sobre agentes autônomos, distingue dois tipos de memória: curto prazo (in-context learning, o histórico dentro da janela de contexto do modelo) e longo prazo (informações persistentes armazenadas em vector stores para recuperação posterior).
A IBM também menciona que o ciclo ReAct pode incluir uma etapa de aprendizado e reflexão, onde o agente avalia suas ações passadas para melhorar decisões futuras — um uso avançado de memória que vai além do simples armazenamento de histórico.
Melhores Práticas e Próximos Passos com LangChain Agents
Levar agentes LangChain para produção exige alguns cuidados. Comece com temperature=0 para chamadas de ferramentas — isso reduz alucinações e mantém o comportamento previsível. A documentação de overview recomenda configurar max_iterations entre 10 e 20 para evitar loops infinitos, e usar early_stopping='generate' para que o agente tente formular uma resposta mesmo quando atinge o limite.
Configure o LangSmith para tracing desde o início. A ferramenta fornece observabilidade completa — cada chamada de tool, cada decisão do modelo, cada ciclo ReAct fica registrado para debug.
Próximos passos: Para cenários mais complexos, explore o LangGraph — o framework de orquestração baseado em grafos que o LangChain usa internamente. Com ele você cria agentes especializados, fluxos com human-in-the-loop e sistemas multi-agente colaborativos. O protocolo MCP (Model Context Protocol) permite conectar seus agentes LangChain a ferramentas externas via langchain-mcp-adapters, expandindo significativamente o que eles podem fazer.
Se você está decidindo entre frameworks, vale conferir o comparativo de frameworks para agentes de IA incluindo LangChain — o LangChain é frequentemente comparado com CrewAI e AutoGen na escolha da ferramenta certa para cada projeto.
A IBM recomenda implementar human-in-the-loop para ações críticas, interrompendo a execução para aprovação humana antes de chamar ferramentas com efeitos colaterais — como envio de emails ou alterações em bancos de dados.
FAQ: Perguntas Frequentes sobre Agentes LangChain
Como criar um agente de IA com LangChain em Python?
Instale o LangChain e o provider (pip install langchain langchain-openai), configure o modelo com sua API key, defina ferramentas com o decorador @tool, crie o agente com create_agent(model, tools, system_prompt) e execute com invoke(). O ciclo ReAct acontece automaticamente — o agente pensa, age, observa e repete até responder. Tudo em aproximadamente 20 linhas de código.
O que é create_agent no LangChain?
create_agent é a função principal do LangChain para construir agentes. Ela recebe três parâmetros: o modelo de linguagem, uma lista de ferramentas e um prompt de sistema opcional. Internamente ela orquestra o ciclo ReAct usando LangGraph como executor subjacente, gerenciando estado, decisões de ferramentas e fluxo de execução automaticamente.
Quais ferramentas (tools) posso usar com LangChain?
Você pode criar tools personalizadas com @tool — qualquer função Python vira uma ferramenta. Também existem dezenas de ferramentas pré-construídas: WikipediaQueryRun, YouTubeSearchTool, DuckDuckGoSearch, OpenWeatherMap e SQLDatabase, entre outras. O tutorial da IBM mostra exemplos práticos de implementação.
Qual a diferença entre LangChain agent e chain?
Uma chain segue uma sequência fixa de passos — você define a ordem exata das chamadas. Um agente decide dinamicamente qual ferramenta usar com base na entrada do usuário. Enquanto chains são lineares e previsíveis, agentes podem escolher entre múltiplas ferramentas, observar resultados e ajustar o caminho em tempo real.
Como o ciclo ReAct funciona no LangChain?
O ciclo ReAct (Thought-Action-Observation) funciona em loop: o LLM primeiro pensa sobre o que precisa fazer (Thought), depois chama uma ferramenta com argumentos específicos (Action), recebe o resultado (Observation) e decide se precisa de mais iterações ou se já pode responder. O LangChain gerencia todo esse fluxo automaticamente quando você usa create_agent + invoke() (artigo de Lilian Weng sobre agentes autônomos).
Preciso de GPU para rodar agentes LangChain?
Não. Agentes LangChain rodam inteiramente via API. As chamadas ao LLM vão para servidores remotos (OpenAI, Anthropic, Google). Seu computador só precisa de conexão com a internet e Python 3.9+. O custo é por token consumido, não por hardware local.