Um agente de IA com Python pode ir além de responder perguntas: ele pode utilizar ferramentas, consultar informações e executar tarefas de acordo com o objetivo recebido.
Neste tutorial, vamos criar um agente simples usando Python e LangChain. O projeto terá duas ferramentas: uma para consultar informações sobre produtos e outra para calcular descontos. Assim, o modelo poderá decidir qual função utilizar de acordo com a solicitação do usuário.
1. O que diferencia um agente de um chatbot?
Um chatbot tradicional geralmente responde com base na conversa e nas informações disponíveis para o modelo. Um agente, por outro lado, pode escolher ferramentas para realizar ações e utilizar os resultados dessas ferramentas para construir sua resposta.
Uma arquitetura básica envolve três componentes:
- LLM: interpreta a solicitação e decide qual ferramenta utilizar.
- Ferramentas: funções Python que executam tarefas específicas.
- Orquestração: coordena a interação entre o modelo, as ferramentas e a resposta final.
2. Preparando o projeto
Instale as bibliotecas necessárias:
pip install -U langchain langchain-openaiConfigure também a variável de ambiente OPENAI_API_KEY com uma chave válida da API da OpenAI.
3. Criando as ferramentas em Python
Vamos criar duas funções que o agente poderá utilizar: uma consulta de produtos fictícios e uma calculadora de descontos.
from langchain.tools import tool
PRODUTOS = {
"notebook": 3500.00,
"monitor": 1200.00,
"teclado": 250.00
}
@tool
def consultar_preco(produto: str) -> str:
"""Consulta o preço de um produto pelo nome."""
nome = produto.lower().strip()
if nome not in PRODUTOS:
return f"Produto '{produto}' não encontrado."
return f"O preço do {nome} é R$ {PRODUTOS[nome]:.2f}."
@tool
def calcular_desconto(
valor: float,
percentual: float
) -> str:
"""Calcula o preço final após um desconto percentual."""
if valor < 0 or not 0 <= percentual <= 100:
return "Valor ou percentual de desconto inválido."
final = valor * (1 - percentual / 100)
return f"Preço final: R$ {final:.2f}."O decorador @tool permite que o LangChain exponha as funções ao modelo, incluindo suas descrições e os argumentos esperados. Isso ajuda o LLM a entender quando cada ferramenta pode ser útil.
4. Criando o agente
Agora vamos conectar as ferramentas a um modelo de linguagem.
from langchain.agents import create_agent
agente = create_agent(
model="openai:gpt-4.1-mini",
tools=[consultar_preco, calcular_desconto],
system_prompt=(
"Você é um assistente de vendas. "
"Use as ferramentas disponíveis para consultar "
"preços e calcular descontos. "
"Não invente preços nem resultados."
)
)
resposta = agente.invoke({
"messages": [
{
"role": "user",
"content": (
"Quanto custa um notebook e quanto fica "
"com 10% de desconto?"
)
}
]
})
print(resposta["messages"][-1].content)O exemplo utiliza create_agent, a interface atual do LangChain para criar agentes com ferramentas. O modelo pode solicitar a consulta do preço e, com o resultado, utilizar a calculadora para responder à pergunta completa. <Cite refs={[“turn122620search0”]}/>
O modelo precisa ter suporte ao uso de ferramentas, e o identificador deve corresponder a um modelo disponível para sua conta.
5. Como funciona o Function Calling?
Quando recebe uma solicitação, o modelo avalia as ferramentas disponíveis e pode retornar uma chamada estruturada com o nome da função e seus argumentos.
O LangChain executa a função correspondente e devolve o resultado ao modelo. Em seguida, o modelo utiliza esse retorno para produzir a resposta final.
Esse processo pode acontecer várias vezes durante a mesma execução, permitindo que o agente combine ferramentas para resolver tarefas com múltiplas etapas. <Cite refs={[“turn122620search7″,”turn122620search0”]}/>
É importante entender que o LLM não executa diretamente o código Python: o sistema de orquestração é responsável por executar a ferramenta solicitada.
6. Adicionando memória e contexto
Para manter o histórico entre mensagens, o agente pode utilizar um mecanismo de persistência. No LangChain, um checkpointer permite armazenar o estado de uma conversa e recuperá-lo em chamadas posteriores.
Por exemplo:
from langgraph.checkpoint.memory import InMemorySaver
agente = create_agent(
model="openai:gpt-4.1-mini",
tools=[consultar_preco, calcular_desconto],
system_prompt="Você é um assistente de vendas.",
checkpointer=InMemorySaver()
)
config = {
"configurable": {
"thread_id": "cliente_001"
}
}
resposta = agente.invoke(
{"messages": [
{"role": "user", "content": "Quanto custa um monitor?"}
]},
config=config
)Ao utilizar o mesmo thread_id em chamadas posteriores, o agente pode recuperar o histórico daquela conversa. O exemplo usa memória em processo, adequada para testes; aplicações em produção geralmente precisam de armazenamento persistente. <Cite refs={[“turn122620search1″,”turn122620search9”]}/>
7. Testes, limitações e próximos passos
Antes de colocar o agente em produção, teste solicitações válidas, produtos inexistentes, argumentos inválidos e perguntas ambíguas. Verifique se as ferramentas retornam os resultados esperados e se o modelo não inventa informações.
Também é importante limitar permissões, controlar custos e exigir confirmação humana para ações sensíveis, como pagamentos, exclusão de dados ou envio de mensagens.
A partir desse projeto, você pode evoluir o agente com:
- RAG: consultar documentos e bases de conhecimento próprias.
- APIs externas: acessar sistemas empresariais e serviços de terceiros.
- Múltiplas etapas: combinar ferramentas para executar tarefas mais complexas.
- Múltiplos agentes: dividir processos entre agentes especializados.
Aprenda mais sobre agentes de IA
Este projeto é um ponto de partida para entender como combinar LLMs, ferramentas e Python na construção de agentes inteligentes.
Se você quer aprofundar seus conhecimentos e desenvolver aplicações práticas com IA generativa, conheça a Trilha de IA Generativa da IA Expert Academy.
Explore conceitos, tecnologias e projetos para avançar do uso de modelos de linguagem à construção de soluções com agentes de IA.
