Como Criar um Agente de IA do Zero: Tutorial Prático em Python + n8n

Quem busca como criar um agente de IA do zero em 2026 acha 90% de tutorial em inglês ou vídeo de 40 min no YouTube. Este artigo entrega dois caminhos paralelos para o mesmo agente — um assistente de pesquisa que recebe um tema, busca na web e devolve resumo de 200 palavras. Caminho 1: Python com OpenAI function calling, 50 linhas, US$ 0,002 por execução. Caminho 2: n8n no-code com AI Agent node, sem escrever uma linha de código. Escolhe o que prefere. Os dois ficam funcionais em menos de uma hora.

Resposta rápida (Featured Snippet):

1. Defina o objetivo: uma tarefa específica que o agente vai executar.

2. Escolha o LLM: GPT-4o-mini (barato, US$ 0,15/1M tokens) ou Claude Sonnet 4 (premium).

3. Defina as tools: funções que o agente pode chamar (busca web, leitura de arquivo, API).

4. Implemente o loop ReAct: o agente raciocina, escolhe tool, executa, repete até terminar.

5. Teste e calcule custo: rode 10 execuções, meça tokens e estime custo mensal.

O que é um agente de IA (e por que não é só um chatbot)

Um agente de IA é um LLM com 3 coisas a mais: memória (lembra do contexto), tools (funções que pode chamar) e um loop de raciocínio (decide o que fazer próximo). A diferença prática para um chatbot:

• Chatbot: você pergunta, ele responde uma vez. Fim.
• Agente: você dá um objetivo. Ele decide qual tool usar, executa, vê o resultado, decide de novo. Repete até atingir o objetivo.

O pattern padrão de agente é o ReAct (Reason + Act), descrito por Yao et al. em paper de 2022 e que virou base de praticamente todo framework moderno.

Pré-requisitos

Antes de começar a criar um agente de IA:

• Caminho 1 (Python): Python 3.10+, conta na OpenAI com US$ 5 de crédito, conta na Serper.dev (busca web, free 2.500 consultas).
• Caminho 2 (n8n): conta n8n Cloud (Starter €20/mês) ou n8n self-hostado em VPS, mesma conta OpenAI e Serper.
• Tempo estimado: 30–60 min para o caminho 1; 45 min para o caminho 2.
• Conhecimento mínimo: se já abriu terminal e instalou pacote Python, segue tranquilo no caminho 1. Se nunca, vai pelo caminho 2.

Cotação base: US$ 1 = R$ 5,40 (junho/2026).

Arquitetura do agente que vamos construir

Antes do código, o diagrama lógico (igual nos dois caminhos):

[Input: tema da pesquisa]
        ↓
[Agente IA — loop ReAct]
   ↓ pensa: preciso de informação atual
   ↓ escolhe tool: "buscar_web"
   ↓ executa busca → recebe 5 resultados
   ↓ pensa: já tenho informação suficiente
   ↓ executa tool: "resumir" (interno)
        ↓
[Output: resumo de 200 palavras + fontes]

A tool buscar_web é a única externa. O resto é o agente raciocinando.

Caminho 1 — Python + OpenAI (com código)

Instalação

pip install openai requests python-dotenv

Crie um arquivo .env:

OPENAI_API_KEY=sk-...
SERPER_API_KEY=...

Código completo (agente.py)

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

load_dotenv()
client = OpenAI()

# --- Tool: busca web via Serper ---
def buscar_web(query: str) -> str:
    r = requests.post(
        "https://google.serper.dev/search",
        headers={"X-API-KEY": os.getenv("SERPER_API_KEY")},
        json={"q": query, "gl": "br", "hl": "pt-br"}
    )
    results = r.json().get("organic", [])[:5]
    return json.dumps([{"titulo": x["title"], "url": x["link"], "snippet": x["snippet"]} for x in results])

# --- Schema da tool (function calling) ---
tools = [{
    "type": "function",
    "function": {
        "name": "buscar_web",
        "description": "Busca informação atual na web. Retorna 5 resultados.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    }
}]

SYSTEM_PROMPT = """Você é um pesquisador. Receba um tema, use buscar_web para coletar informação atual, e devolva resumo de exatamente 200 palavras com 3 fontes (URLs) citadas ao final. Não invente dados."""

def rodar_agente(tema: str) -> str:
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": f"Pesquise: {tema}"}
    ]
    for _ in range(5):  # loop ReAct com limite
        r = client.chat.completions.create(
            model="gpt-4o-mini", messages=messages, tools=tools
        )
        msg = r.choices[0].message
        messages.append(msg)
        if not msg.tool_calls:
            return msg.content
        for call in msg.tool_calls:
            result = buscar_web(**json.loads(call.function.arguments))
            messages.append({"role": "tool", "tool_call_id": call.id, "content": result})
    return "Limite de iterações atingido."

if __name__ == "__main__":
    print(rodar_agente("agentes de IA em 2026"))

Rodar

python agente.py

Saída esperada: resumo de 200 palavras sobre agentes de IA com 3 URLs. Em ~15 segundos. Custo da execução: ≈US$ 0,002 (≈R$ 0,011).

Caminho 2 — n8n no-code (com JSON exportável)

Se você não quer mexer em Python, o n8n entrega o mesmo agente em canvas visual. O n8n AI Agent node roda LangChain por baixo — para entender o framework, vale ver o comparativo LangChain vs CrewAI vs AutoGen.

JSON do workflow (importe em Workflows → Import from File):

{
  "name": "Agente Pesquisador",
  "nodes": [
    {"name": "Manual Trigger", "type": "n8n-nodes-base.manualTrigger",
     "position": [200, 300]},
    {"name": "AI Agent", "type": "@n8n/n8n-nodes-langchain.agent",
     "parameters": {
       "agent": "openAiFunctionsAgent",
       "options": {"systemMessage": "Você é um pesquisador. Use a tool de busca web para coletar informação atual e devolva resumo de 200 palavras com 3 fontes."}},
     "position": [450, 300]},
    {"name": "OpenAI Chat Model", "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
     "parameters": {"model": "gpt-4o-mini"}, "position": [400, 500]},
    {"name": "Serper Tool", "type": "@n8n/n8n-nodes-langchain.toolSerpApi",
     "parameters": {"options": {"gl": "br", "hl": "pt-br"}}, "position": [550, 500]}
  ],
  "connections": {
    "Manual Trigger": {"main": [[{"node": "AI Agent", "type": "main", "index": 0}]]},
    "OpenAI Chat Model": {"ai_languageModel": [[{"node": "AI Agent", "type": "ai_languageModel", "index": 0}]]},
    "Serper Tool": {"ai_tool": [[{"node": "AI Agent", "type": "ai_tool", "index": 0}]]}
  }
}

Configure suas credenciais OpenAI e Serper nos nós correspondentes. Aperte “Execute Workflow” e veja o resumo aparecer no AI Agent.

Para entender quando faz sentido cada plataforma de automação, veja o comparativo n8n vs Zapier.

Custo real (tokens)

Para o agente acima rodando 1.000 vezes/mês:

Para protótipo, Python sai praticamente de graça. Para produção com schedule, monitoramento e UI, n8n compensa o overhead.

Erros comuns e como resolver

1. Loop infinito (agente chama tool sem parar) Adicione limite de iterações (no código acima é range(5)). Em n8n, configure max iterations no AI Agent node.

2. Custo estourando Use sempre gpt-4o-mini para protótipo. Só troque para Claude Sonnet 4 ou GPT-5 quando precisar. Adicione max_tokens na chamada.

3. Tool não é chamada O agente ignora a tool. Causas: descrição da função muito vaga, system prompt não menciona a tool, ou modelo muito fraco. Reescreva a description com verbo de ação + caso de uso.

4. Resposta em inglês quando você quer português Force no system prompt: “Responda SEMPRE em português brasileiro.” Funciona melhor que ajustar gl ou parâmetro de país.

5. Tool retorna erro 401/403 Chave API errada ou sem créditos. Verifique .env e billing na OpenAI/Serper.

Próximos passos

Depois que esse primeiro agente está rodando, três upgrades naturais:

1. Memória persistente — em vez do array messages em RAM, salve em Redis ou PostgreSQL. Agente lembra de conversas anteriores.
2. Multi-agente — vários agentes com papéis diferentes (pesquisador + redator + revisor). Para isso, considere CrewAI ou LangGraph (cobertos no comparativo de frameworks).
3. Produção — adicione observability (LangSmith ou OpenTelemetry), rate limit, retries com backoff e logging estruturado. Sem isso, debugar agente em produção é tortura.

Veredicto do V. Santos

Construí os agentes que rodam este blog (CortexIA) misturando os dois caminhos. Para protótipo rápido — testar se a ideia faz sentido — vou de Python puro com openai lib, ~50 linhas, US$ 5 de crédito resolve. Para colocar em produção com schedule, webhook, integração com WordPress e Slack — migrei tudo para n8n self-hostado em VPS de R$ 32/mês na Hostinger.

A regra que sigo: se a tarefa cabe em 1 script Python rodado manualmente, fica em Python. Se precisa de trigger automático, vários sistemas conectados, time de não-devs olhando — vai para n8n.

Erro mais comum de quem está começando a criar agente de IA: pular o protótipo Python e ir direto para n8n no-code. O n8n esconde o que está acontecendo por baixo (loop ReAct, function calling, tokens consumidos). Quando dá problema, você não sabe onde olhar. Sofra 30 minutos no Python primeiro, depois suba para n8n com a cabeça clara.

FAQ

O que é um agente de IA? LLM + memória + tools + loop de raciocínio. Diferente de chatbot porque executa tarefas em vez de só responder.

Preciso saber programar para criar agente IA? Não. O caminho 2 deste tutorial usa n8n (no-code, canvas visual). Para entender o que está acontecendo por baixo, vale aprender Python básico.

Qual a melhor ferramenta para criar agente IA? Para começar: OpenAI function calling em Python (mais barato e didático) ou n8n AI Agent node (no-code). Para produção: LangGraph, CrewAI ou n8n self-host.

Quanto custa criar um agente IA? Protótipo: US$ 5 de crédito OpenAI cobre 500 execuções. Produção (1k exec/mês): entre R$ 1 (Python self-host) e R$ 117 (n8n Cloud).

Como funciona o ReAct pattern? Loop: o agente pensa (reason), escolhe uma tool (act), recebe resultado, decide se terminou ou repete. Paper de Yao et al. (2022) introduziu o padrão.

Posso criar agente IA grátis? Self-host total: n8n grátis em VPS de R$ 32/mês + modelos locais via Ollama (Llama 3, Mistral) = R$ 32/mês fixo, zero custo de tokens. Qualidade menor que GPT-4o, mas funciona.

Agente de IA substitui funcionário? Não, em geral. Substitui tarefas repetitivas e estruturadas dentro do trabalho da pessoa. Quem antes gastava 4h/dia triando email passa a gastar 30 min revisando o trabalho do agente.

Próximo passo: clona o repo do agente em git clone, roda o script Python e vê funcionando. Depois importa o JSON no n8n e compara. Se quer aprofundar em frameworks específicos, vai para o comparativo de LangChain/CrewAI/AutoGen. Se quer pôr em produção com WhatsApp ou CRM, vê o artigo sobre n8n vs Zapier para escolher a stack.

Status: Entregue. Próximo: /revisor.