🐍 Exemplos de Código•6 min de leitura
Criando um Agente de IA Autônomo com Python
Exemplo completo de um agente de IA autônomo que planeja, executa ações e usa ferramentas para resolver tarefas complexas de forma independente.
#agente-ia#python#langchain#automação#llm
O que vamos construir
Um agente de IA autônomo capaz de:
- Receber um objetivo em linguagem natural
- Decompor o objetivo em sub-tarefas
- Usar ferramentas (busca web, calculadora, sistema de arquivos)
- Executar as tarefas de forma sequencial e adaptativa
- Reportar os resultados
Conceitos Fundamentais
Um agente é composto por:
- LLM (cérebro): decide o que fazer a cada passo
- Ferramentas: ações que o agente pode executar
- Memória: histórico de ações e resultados
- Loop de execução: ciclo de pensar → agir → observar
Código Completo
1. Definindo as Ferramentas
"""
agente_autonomo.py - Agente de IA com ferramentas customizadas
"""
import os
import json
import math
import requests
from datetime import datetime
from typing import Callable, Any
from dataclasses import dataclass, field
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
@dataclass
class Tool:
"""Representa uma ferramenta que o agente pode usar."""
name: str
description: str
parameters: dict
function: Callable
class ToolRegistry:
"""Registro de ferramentas disponíveis para o agente."""
def __init__(self):
self.tools: dict[str, Tool] = {}
def register(self, name: str, description: str, parameters: dict):
"""Decorator para registrar ferramentas."""
def decorator(func: Callable) -> Callable:
self.tools[name] = Tool(
name=name,
description=description,
parameters=parameters,
function=func,
)
return func
return decorator
def get_schemas(self) -> list[dict]:
"""Retorna schemas das ferramentas para a API da OpenAI."""
return [
{
"type": "function",
"function": {
"name": tool.name,
"description": tool.description,
"parameters": tool.parameters,
}
}
for tool in self.tools.values()
]
def execute(self, name: str, arguments: dict) -> str:
"""Executa uma ferramenta pelo nome."""
if name not in self.tools:
return f"Erro: ferramenta '{name}' não encontrada"
try:
result = self.tools[name].function(**arguments)
return str(result)
except Exception as e:
return f"Erro ao executar {name}: {str(e)}"
# Criar registro de ferramentas
registry = ToolRegistry()
@registry.register(
name="calcular",
description="Executa cálculos matemáticos. Aceita expressões Python válidas.",
parameters={
"type": "object",
"properties": {
"expressao": {
"type": "string",
"description": "Expressão matemática em Python (ex: '2**10', 'math.sqrt(144)')"
}
},
"required": ["expressao"]
}
)
def calcular(expressao: str) -> str:
"""Calcula expressão matemática de forma segura."""
allowed_names = {
'math': math, 'abs': abs, 'round': round,
'min': min, 'max': max, 'sum': sum,
'pow': pow, 'int': int, 'float': float,
}
result = eval(expressao, {"__builtins__": {}}, allowed_names)
return f"Resultado: {result}"
@registry.register(
name="buscar_web",
description="Busca informações na web. Use para perguntas sobre fatos atuais.",
parameters={
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Termo de busca"
}
},
"required": ["query"]
}
)
def buscar_web(query: str) -> str:
"""Simula busca web (em produção, use API do Google/Bing)."""
# Em produção, integre com uma API de busca real
return (
f"Resultados simulados para '{query}':\n"
f"1. Informação relevante sobre {query} encontrada em fonte confiável.\n"
f"2. Dados atualizados de {datetime.now().strftime('%Y-%m-%d')} disponíveis."
)
@registry.register(
name="ler_arquivo",
description="Lê o conteúdo de um arquivo de texto.",
parameters={
"type": "object",
"properties": {
"caminho": {
"type": "string",
"description": "Caminho do arquivo para ler"
}
},
"required": ["caminho"]
}
)
def ler_arquivo(caminho: str) -> str:
"""Lê conteúdo de um arquivo."""
try:
with open(caminho, 'r', encoding='utf-8') as f:
conteudo = f.read(5000) # Limitar tamanho
return f"Conteúdo de '{caminho}':\n{conteudo}"
except FileNotFoundError:
return f"Arquivo '{caminho}' não encontrado"
except Exception as e:
return f"Erro ao ler arquivo: {e}"
@registry.register(
name="escrever_arquivo",
description="Escreve conteúdo em um arquivo de texto.",
parameters={
"type": "object",
"properties": {
"caminho": {
"type": "string",
"description": "Caminho do arquivo"
},
"conteudo": {
"type": "string",
"description": "Conteúdo para escrever"
}
},
"required": ["caminho", "conteudo"]
}
)
def escrever_arquivo(caminho: str, conteudo: str) -> str:
"""Escreve conteúdo em um arquivo."""
with open(caminho, 'w', encoding='utf-8') as f:
f.write(conteudo)
return f"Arquivo '{caminho}' salvo com sucesso ({len(conteudo)} caracteres)"
@registry.register(
name="obter_data_hora",
description="Retorna a data e hora atuais.",
parameters={
"type": "object",
"properties": {},
}
)
def obter_data_hora() -> str:
"""Retorna data e hora atuais."""
now = datetime.now()
return (
f"Data: {now.strftime('%d/%m/%Y')}\n"
f"Hora: {now.strftime('%H:%M:%S')}\n"
f"Dia da semana: {now.strftime('%A')}"
)
2. O Agente
class Agent:
"""Agente de IA autônomo com loop de execução."""
def __init__(
self,
model: str = "gpt-4o-mini",
max_steps: int = 10,
verbose: bool = True,
):
self.model = model
self.max_steps = max_steps
self.verbose = verbose
self.history: list[dict] = []
self.step_count = 0
self.system_prompt = """Você é um agente de IA autônomo e eficiente.
REGRAS:
1. Analise o objetivo do usuário com cuidado
2. Decomponha tarefas complexas em sub-tarefas simples
3. Use as ferramentas disponíveis para executar cada sub-tarefa
4. Se uma ação falhar, tente uma abordagem alternativa
5. Quando concluir o objetivo, forneça um resumo claro dos resultados
6. Responda sempre em português brasileiro
7. Seja conciso nas suas respostas finais
FERRAMENTAS DISPONÍVEIS:
- calcular: para cálculos matemáticos
- buscar_web: para buscar informações atuais
- ler_arquivo: para ler arquivos
- escrever_arquivo: para criar/editar arquivos
- obter_data_hora: para saber data/hora atual"""
def _log(self, message: str):
"""Log para modo verbose."""
if self.verbose:
print(message)
def run(self, objective: str) -> str:
"""Executa o agente para alcançar um objetivo."""
self._log(f"\n🎯 OBJETIVO: {objective}")
self._log("=" * 60)
self.history = [
{"role": "system", "content": self.system_prompt},
{"role": "user", "content": objective},
]
while self.step_count < self.max_steps:
self.step_count += 1
self._log(f"\n📍 Passo {self.step_count}/{self.max_steps}")
# Chamar o LLM
response = client.chat.completions.create(
model=self.model,
messages=self.history,
tools=registry.get_schemas(),
tool_choice="auto",
temperature=0.3,
)
message = response.choices[0].message
# Se o modelo quer usar ferramentas
if message.tool_calls:
self.history.append(message)
for tool_call in message.tool_calls:
func_name = tool_call.function.name
func_args = json.loads(tool_call.function.arguments)
self._log(f" 🔧 Usando: {func_name}({func_args})")
# Executar ferramenta
result = registry.execute(func_name, func_args)
self._log(f" 📋 Resultado: {result[:200]}...")
# Adicionar resultado ao histórico
self.history.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": result,
})
# Se o modelo respondeu sem usar ferramentas (objetivo concluído)
else:
final_response = message.content
self._log(f"\n✅ CONCLUÍDO em {self.step_count} passos")
self._log(f"\n{final_response}")
return final_response
return "⚠️ Limite de passos atingido. O objetivo pode não ter sido completamente alcançado."
3. Executando o Agente
def main():
agent = Agent(model="gpt-4o-mini", max_steps=10, verbose=True)
# Exemplo 1: Cálculo complexo
print("\n" + "=" * 60)
print("EXEMPLO 1: Cálculo Financeiro")
print("=" * 60)
agent.run(
"Calcule quanto terei se investir R$ 10.000 a uma taxa de "
"12% ao ano durante 5 anos com juros compostos. "
"Depois, salve o resultado em um arquivo 'investimento.txt'."
)
# Exemplo 2: Pesquisa e relatório
print("\n" + "=" * 60)
print("EXEMPLO 2: Pesquisa")
print("=" * 60)
agent2 = Agent(model="gpt-4o-mini", max_steps=10, verbose=True)
agent2.run(
"Que dia é hoje? Busque informações sobre as últimas "
"tendências em IA e escreva um resumo de 3 parágrafos "
"no arquivo 'tendencias_ia.txt'."
)
if __name__ == "__main__":
main()
Como Rodar
# Instalar dependências
pip install openai
# Configurar API key
export OPENAI_API_KEY="sk-..."
# Executar
python agente_autonomo.py
Saída Esperada
🎯 OBJETIVO: Calcule quanto terei se investir R$ 10.000 a uma taxa de 12% ao ano...
============================================================
📍 Passo 1/10
🔧 Usando: calcular({"expressao": "10000 * (1 + 0.12) ** 5"})
📋 Resultado: Resultado: 17623.416832...
📍 Passo 2/10
🔧 Usando: escrever_arquivo({"caminho": "investimento.txt", "conteudo": "..."})
📋 Resultado: Arquivo 'investimento.txt' salvo com sucesso...
📍 Passo 3/10
✅ CONCLUÍDO em 3 passos
Investindo R$ 10.000 a 12% ao ano por 5 anos com juros compostos,
você terá R$ 17.623,42. O resultado foi salvo em 'investimento.txt'.
Expansões Possíveis
- Memória persistente: salvar histórico entre sessões com SQLite
- Mais ferramentas: API de clima, envio de e-mails, execução de código
- Multi-agentes: múltiplos agentes colaborando (pesquisador + escritor + revisor)
- Guardrails: limitar ações perigosas e adicionar confirmação humana
- Interface web: criar frontend com Streamlit ou Gradio
Este agente é a base para sistemas muito mais complexos. A partir dele, você pode construir assistentes especializados para qualquer domínio. 🤖