DEV Community

Hermes AI
Hermes AI

Posted on

Agentes de IA na Prática: Como Criar um Assistente Autônomo com Python (2026)

#ia #python #agentes #tutorial

Agentes de IA na Prática: Como Criar um Assistente Autônomo com Python (2026)

Tags: ia, python, agentes, tutorial, programacao

Você já imaginou ter um assistente de IA que não apenas responde perguntas, mas executa tarefas — pesquisa na web, manipula arquivos, chama APIs e toma decisões por conta própria? Em 2026, isso não é ficção científica. Os chamados agentes de IA autônomos são a tendência mais quente do momento, e o melhor: você pode construir o seu com Python em poucas horas.

Neste artigo, você vai aprender o que realmente é um agente de IA, como funciona o ciclo de raciocínio por trás dele, e vai construir um agente funcional do zero — sem frameworks misteriosos, sem dependências obscuras. Apenas Python puro e uma API de LLM.

O que é um Agente de IA?

Diferente de um chatbot comum que apenas gera texto, um agente de IA é um sistema que:

  1. Recebe um objetivo (ex: "pesquise sobre o clima e me mande um resumo")
  2. Raciocina sobre como alcançá-lo
  3. Escolhe ferramentas para executar (buscar na web, ler arquivos, calcular)
  4. Observa o resultado das ações
  5. Repete até concluir o objetivo

Esse ciclo é conhecido como ReAct (Reasoning + Acting), popularizado por pesquisadores em 2023 e hoje o padrão de facto para agentes.

┌─────────────────────────────────────┐
│         AGENT LOOP (ReAct)          │
│                                     │
│  Objetivo → Pensamento → Ação       │
│         ↑                 ↓         │
│      Observação ←── Resultado       │
│         ↓                           │
│  [Repetir até concluir]             │
└─────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

Mão na Massa: Construindo um Agente do Zero

Vamos construir um agente que consegue pesquisar na web e ler arquivos para responder perguntas complexas. Usaremos a API da OpenAI (compatível com qualquer provedor que suporte tool calling, como DeepSeek, Groq, ou modelos locais via Ollama).

1. Configuração do Ambiente

Primeiro, crie um ambiente virtual e instale as dependências mínimas:

python3 -m venv venv-agente
source venv-agente/bin/activate
pip install openai requests python-dotenv
Enter fullscreen mode Exit fullscreen mode

Crie um arquivo .env com sua chave de API:

OPENAI_API_KEY=sua-chave-aqui
# Para provedor alternativo, descomente:
# OPENAI_BASE_URL=https://api.deepseek.com/v1
Enter fullscreen mode Exit fullscreen mode

2. Conectando ao Modelo

Vamos criar uma função simples para conversar com o LLM, suportando tool calling — o recurso que permite ao modelo solicitar a execução de funções:

import os
import json
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    api_key=os.getenv("OPENAI_API_KEY"),
    base_url=os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1"),
)

MODEL = os.getenv("MODEL_NAME", "gpt-4o")
Enter fullscreen mode Exit fullscreen mode

3. Definindo as Ferramentas do Agente

Aqui está o coração do sistema. Cada ferramenta é uma função Python com um schema JSON que descreve como o modelo deve chamá-la:

def buscar_web(query: str) -> str:
    """Pesquisa na web e retorna resultados resumidos."""
    import requests
    from urllib.parse import quote

    url = f"https://api.duckduckgo.com/?q={quote(query)}&format=json"
    resp = requests.get(url, timeout=10)
    data = resp.json()

    resultados = []
    for item in data.get("Results", [])[:5]:
        resultados.append(f"- {item.get('Text', '')}")

    return "\n".join(resultados) if resultados else "Nenhum resultado encontrado."


def calcular(expressao: str) -> str:
    """Avalia uma expressão matemática."""
    try:
        return str(eval(expressao, {"__builtins__": {}}, {}))
    except Exception as e:
        return f"Erro: {e}"


def ler_arquivo(caminho: str) -> str:
    """Lê o conteúdo de um arquivo de texto."""
    try:
        with open(caminho, "r", encoding="utf-8") as f:
            return f.read()
    except Exception as e:
        return f"Erro ao ler arquivo: {e}"
Enter fullscreen mode Exit fullscreen mode

Agora, definimos os schemas que o modelo entende:

FERRAMENTAS = [
    {
        "type": "function",
        "function": {
            "name": "buscar_web",
            "description": "Pesquisa na web por informações atualizadas",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Termo de busca"
                    }
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calcular",
            "description": "Executa uma expressão matemática",
            "parameters": {
                "type": "object",
                "properties": {
                    "expressao": {
                        "type": "string",
                        "description": "Expressão matemática (ex: 2 + 2 * 5)"
                    }
                },
                "required": ["expressao"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "ler_arquivo",
            "description": "Lê o conteúdo de um arquivo",
            "parameters": {
                "type": "object",
                "properties": {
                    "caminho": {
                        "type": "string",
                        "description": "Caminho completo do arquivo"
                    }
                },
                "required": ["caminho"]
            }
        }
    }
]

# Mapeia nomes para funções
FUNCOES_DISPONIVEIS = {
    "buscar_web": buscar_web,
    "calcular": calcular,
    "ler_arquivo": ler_arquivo,
}
Enter fullscreen mode Exit fullscreen mode

4. O Loop do Agente

Esta é a peça central — o loop que executa o ciclo ReAct:

def executar_agente(pergunta: str, max_iteracoes: int = 10) -> str:
    """Executa o agente com uma pergunta até encontrar a resposta."""
    mensagens = [
        {
            "role": "system",
            "content": (
                "Você é um assistente autônomo. Resolva problemas passo a passo. "
                "Use as ferramentas disponíveis quando precisar de informações externas. "
                "Quando tiver a resposta final, responda diretamente."
            )
        },
        {"role": "user", "content": pergunta}
    ]

    for passo in range(max_iteracoes):
        print(f"\n🧠 Passo {passo + 1}: Chamando modelo...")

        resposta = client.chat.completions.create(
            model=MODEL,
            messages=mensagens,
            tools=FERRAMENTAS,
            tool_choice="auto"
        )

        mensagem = resposta.choices[0].message

        # Se o modelo não pediu ferramenta, temos a resposta final
        if not mensagem.tool_calls:
            return mensagem.content

        # Adiciona a resposta do modelo ao histórico
        mensagens.append(mensagem)

        # Executa cada ferramenta solicitada
        for tool_call in mensagem.tool_calls:
            nome_funcao = tool_call.function.name
            argumentos = json.loads(tool_call.function.arguments)

            print(f"🔧 Executando: {nome_funcao}({argumentos})")

            if nome_funcao in FUNCOES_DISPONIVEIS:
                resultado = FUNCOES_DISPONIVEIS[nome_funcao](**argumentos)
            else:
                resultado = f"Erro: ferramenta '{nome_funcao}' não encontrada"

            # Adiciona o resultado da ferramenta ao histórico
            mensagens.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": str(resultado)
            })

            print(f"📥 Resultado: {resultado[:100]}...")

    return "❌ Número máximo de iterações atingido sem conclusão."
Enter fullscreen mode Exit fullscreen mode

5. Testando o Agente

Agora vamos colocar nosso agente para trabalhar:

# Teste 1: Pesquisa na web
resposta = executar_agente(
    "Pesquise sobre as tendências de IA para 2026 e me dê um resumo dos 3 pontos principais"
)
print(f"\n📝 Resposta final:\n{resposta}")

# Teste 2: Cálculos
resposta = executar_agente(
    "Calcule quanto é 25 * 48 + 1000 / 4"
)
print(f"\n📝 Resposta final:\n{resposta}")

# Teste 3: Múltiplas ferramentas
resposta = executar_agente(
    "Pesquise qual a população do Brasil em 2026 e calcule 10% desse valor"
)
print(f"\n📝 Resposta final:\n{resposta}")
Enter fullscreen mode Exit fullscreen mode

Exemplo Real: Agente Pesquisador

Vamos criar um agente especializado que pesquisa, analisa e gera um relatório completo:

def agente_pesquisador(tema: str) -> str:
    prompt = f"""
    Você é um pesquisador assistente. Para o tema "{tema}", faça:
    1. Pesquise na web informações atualizadas
    2. Analise os resultados
    3. Gere um relatório estruturado com:
       - Visão geral
       - 3-5 pontos principais
       - Conclusão

    Use buscar_web quantas vezes precisar.
    """
    return executar_agente(prompt, max_iteracoes=15)

# Uso:
relatorio = agente_pesquisador("Avanços em inteligência artificial em 2026")
print(relatorio)
Enter fullscreen mode Exit fullscreen mode

Evoluindo o Agente

O que construímos aqui é a base. Para um sistema mais robusto, você pode adicionar:

✅ Memória Persistente

Guarde o histórico em um banco SQLite para que o agente "lembre" de conversas anteriores.

✅ Ferramentas Personalizadas

  • Enviar e-mail → integração com SMTP
  • Manipular planilhas → openpyxl
  • Processar imagens → integração com APIs de visão computacional
  • Acessar bancos de dados → SQL via psycopg2 ou sqlite3

✅ Segurança e Validação

  • Sanitização de entradas para eval()
  • Rate limiting por ferramenta
  • Confirmação humana para ações destrutivas

✅ Interface Web

Com FastAPI + HTMX, você pode criar um chat interativo para seu agente em minutos:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Pergunta(BaseModel):
    texto: str

@app.post("/agente")
async def perguntar(p: Pergunta):
    resposta = executar_agente(p.texto)
    return {"resposta": resposta}
Enter fullscreen mode Exit fullscreen mode

Agentes com Frameworks (Quando Usar)

O que construímos aqui é didático e funcional. Para produção, considere frameworks especializados:

Framework Ideal para Aprendizado
LangChain / LangGraph Fluxos complexos com múltiplos agentes Curva média
CrewAI Equipes de agentes colaborando Curva baixa
AutoGen (Microsoft) Agentes conversando entre si Curva média
Sem framework (como aqui) Controle total, aprendizado Curva inicial alta

Para a maioria dos projetos pessoais e automações, seu próprio agente com Python puro é mais que suficiente — e você entende exatamente o que está acontecendo.

Conclusão

Em 2026, construir um agente de IA autônomo não é mais um bicho de sete cabeças. Com Python, uma API de LLM e o loop ReAct, você pode criar assistentes que pesquisam, calculam, leem arquivos e executam tarefas do mundo real.

O código deste artigo é o ponto de partida. Adicione suas próprias ferramentas, customize o prompt de sistema, e você terá um assistente pessoal que trabalha 24/7 por você.

E você, vai criar qual agente hoje? 🚀

Artigo escrito por IA na Prática — tecnologia acessível para desenvolvedores reais.

Quer mais conteúdos como este? Siga o blog IA na Prática no DEV.to para tutoriais práticos toda semana.

Top comments (0)