AI Automation: automatize processos reais com IA

Por que n8n e não só Python?

80% das automações de negócio não precisam de código. O n8n permite construir fluxos complexos com lógica visual, conectar mais de 400 serviços com um clique e fazer deploy self-hosted sem depender de um vendor. O desenvolvedor de automações não substitui o engenheiro — ele tem um mercado próprio: as PMEs que precisam de resultados hoje, não daqui a seis meses.

A decisão de arquitetura mais importante: n8n vs Make vs Zapier

• n8n (self-hosted): controle total, sem limite de operações, código JavaScript nos nós, ideal para dados sensíveis ou fluxos complexos. Requer uma VPS (~$5/mês).
• Make (antigo Integromat): visual avançado, melhor para fluxos de dados não lineares, preço por operação. Bom para clientes que não querem self-host.
• Zapier: o mais simples, o mais caro por operação. Só para integrações simples de 2–3 passos, em que a velocidade de setup importa mais que o custo.

Anatomia de um fluxo n8n em produção

Componente	Descrição	Quando usar
Trigger	Webhook, Cron ou evento de app externo	Sempre — todo fluxo começa aqui
HTTP Request	Chamada a qualquer API REST	Quando não existe nó nativo
AI Agent	LLM com tools e memória nativa no n8n	Raciocínio e decisões dinâmicas
Code (JS)	JavaScript para transformação de dados	Lógica que os nós não cobrem
If / Switch	Roteamento condicional do fluxo	Múltiplos caminhos por tipo de input
Error Trigger	Captura erros do fluxo inteiro	Sempre em fluxos de produção

Fluxo n8n: stack-setup.json (n8n workflow)

{
  "name": "M1 · StackSetup — Webhook → AI → Supabase",
  // Patrón base que todos los flujos del proyecto usarán

  "nodes": [
    {
      "type": "n8n-nodes-base.webhook",
      "name": "Webhook Entry",
      // Recibe POST desde WhatsApp, formularios, o cualquier fuente
      "parameters": {
        "httpMethod": "POST",
        "path": "flowbot-entry",
        "responseMode": "responseNode"
      }
    },
    {
      "type": "n8n-nodes-base.code",
      "name": "Validate & Normalize",
      // Siempre valida el input antes de pasar al LLM
      "parameters": {
        "jsCode": "
const { body } = $input.first().json;

// Regla de oro: nunca confíes en el input sin validar
if (!body?.message || typeof body.message !== 'string') {
  throw new Error('INPUT_INVALID: campo message requerido');
}

return [{
  json: {
    message: body.message.trim().slice(0, 2000),
    user_id: body.user_id || 'anonymous',
    channel: body.channel || 'webhook',
    timestamp: new Date().toISOString(),
    trace_id: crypto.randomUUID()
  }
}];"
      }
    },
    {
      "type": "@n8n/n8n-nodes-langchain.lmChatAnthropic",
      "name": "Claude (STANDARD)",
      "parameters": {
        "model": "claude-3-5-sonnet-20241022",
        "options": { "temperature": 0.3 }
      }
    },
    {
      "type": "n8n-nodes-base.supabase",
      "name": "Log to Supabase",
      // Todo flujo de prod logea inputs y outputs
      "parameters": {
        "operation": "insert",
        "tableId": "automation_logs"
      }
    }
  ]
}

Para se aprofundar: n8n docs · Supabase quickstart · Anthropic pricing

O prompt é o contrato com o modelo

Em automações de negócio, o output do LLM não é lido por um humano — ele é processado pelo próximo nó do fluxo. Isso muda completamente a forma de escrever um prompt. Você não busca "uma boa resposta", busca um JSON parseável, um booleano ou uma categoria de um enum. Ambiguidade no prompt é bug de produção.

Estrutura de prompt para automações (4 seções)

• PAPEL + TAREFA: quem o modelo é e exatamente o que ele deve fazer. Sem ambiguidade.
• CONTEXTO DINÂMICO: variáveis que mudam a cada request (dados do usuário, histórico, catálogo). Injetadas em tempo de execução.
• RESTRIÇÕES: o que ele NÃO pode fazer. Tão importante quanto o que ele pode.
• OUTPUT FORMAT: o formato exato da resposta. Para fluxos: sempre JSON válido com schema explícito.

Output estruturado — a técnica mais importante para o n8n

Técnica	Quando usar	Risco
JSON direto	Classificação, extração de dados, roteamento	O modelo pode adicionar texto antes do JSON
XML tags (<output>)	Quando você precisa separar o raciocínio da resposta	É preciso fazer parse do XML
Structured Outputs API	Claude/OpenAI suportam JSON schema nativo	Só funciona com certos modelos
Few-shot + formato	Quando o formato é complexo e o modelo erra	Adiciona tokens e custo

Fluxo n8n: llm-wrapper.json (n8n workflow)

// Nodo Code en n8n: LLM wrapper con output estructurado garantizado

const systemPrompt = `
ROL: Eres un clasificador de intenciones para un bot de soporte de PyME.
TAREA: Analiza el mensaje del usuario y devuelve una clasificación.

CATEGORÍAS DISPONIBLES:
- "product_inquiry": pregunta sobre producto, precio, disponibilidad
- "order_status": consulta sobre estado de pedido
- "complaint": queja o problema con producto/servicio
- "general": saludo, despedida, o conversación fuera de scope

RESTRICCIONES:
- Devuelve SOLO el JSON especificado. Sin texto adicional.
- No inventes categorías fuera de las 4 definidas.
- confidence debe ser un número entre 0.0 y 1.0.

OUTPUT FORMAT (devuelve EXACTAMENTE este JSON):
{
  "intent": "product_inquiry|order_status|complaint|general",
  "confidence": 0.0-1.0,
  "key_entities": ["entidad1", "entidad2"],
  "requires_human": true|false
}
`;

// Llamada con retry automático y validación de output
async function classifyWithRetry(message, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await $node["Claude API"].call({
      messages: [{ role: "user", content: message }],
      system: systemPrompt,
      max_tokens: 150  // output pequeño = más rápido y barato
    });

    try {
      // Limpia posibles decoradores del modelo antes de parsear
      const clean = response.text
        .replace(/```json\n?/g, '')
        .replace(/```/g, '')
        .trim();

      const parsed = JSON.parse(clean);

      // Valida que el schema sea correcto antes de continuar
      const validIntents = ['product_inquiry','order_status','complaint','general'];
      if (!validIntents.includes(parsed.intent)) throw new Error('INVALID_INTENT');
      if (typeof parsed.confidence !== 'number') throw new Error('INVALID_CONFIDENCE');

      return parsed;

    } catch (e) {
      if (attempt === maxRetries - 1) {
        // Último intento: devuelve fallback seguro en vez de romper el flujo
        return { intent: 'general', confidence: 0.5, key_entities: [], requires_human: true };
      }
    }
  }
}

return [{ json: await classifyWithRetry($json.message) }];

Para se aprofundar: Anthropic tool use · JSON schema validation · n8n Code node

O que é o nó AI Agent do n8n?

O nó AI Agent do n8n implementa nativamente o padrão ReAct (Reason + Act) sem precisar de código Python. O agente pode usar ferramentas (outros nós do n8n), manter memória entre turnos e decidir quando já tem informação suficiente para responder. A diferença em relação a um simples nó LLM é que o agente pode dar vários passos antes de responder.

Tools disponíveis no n8n para o AI Agent

• HTTP Request Tool: qualquer API externa. O agente decide quando chamá-la e com quais parâmetros.
• Supabase Tool: busca e escrita no banco de dados. O agente pode consultar informações do cliente sem que você faça isso explicitamente.
• Vector Store Tool: busca semântica em documentos. Base do padrão RAG.
• Code Tool: JavaScript executável. Para cálculos ou transformações que o LLM faria mal.
• Think Tool: permite que o agente raciocine em voz alta antes de agir. Melhora a qualidade em casos complexos.

O risco mais crítico: loops infinitos

Sem a configuração correta, um agente pode chamar a mesma ferramenta em ciclo se o output não satisfizer seus critérios internos. O n8n não impede isso por padrão.

Fluxo n8n: agent-flow.json (configuración AI Agent node)

// Configuración del nodo AI Agent en n8n (parámetros clave)

{
  "type": "@n8n/n8n-nodes-langchain.agent",
  "parameters": {
    "agentType": "toolsAgent",  // ReAct nativo
    "maxIterations": 6,          // CRÍTICO: previene loops infinitos
    "returnIntermediateSteps": false,  // true solo para debugging

    "systemMessage": "
Eres FlowBot, asistente de soporte de {{company_name}}.

CAPACIDADES:
✓ Consultar estado de pedidos (usa search_orders)
✓ Buscar información de productos (usa search_catalog)
✓ Crear tickets de soporte (usa create_ticket)
✗ NO puedes: modificar pedidos, aplicar descuentos, acceder a datos de pago

REGLAS DE COMPORTAMIENTO:
- Responde siempre en el idioma en que te hablan
- Si la confianza es menor a 0.7, pide clarificación antes de actuar
- Si el problema requiere acción humana, escala sin intentar resolver tú

ESCALACIÓN INMEDIATA cuando:
- El cliente está molesto después de 2 intentos de resolución
- La consulta es sobre devolución de dinero
- El cliente pregunta explícitamente por un humano

OUTPUT: Siempre respuestas cortas (máx 3 oraciones para chat)
",

    "tools": [
      {
        "name": "search_orders",
        "description": "Busca pedidos del cliente. Usa order_id o email del cliente.",
        "node": "Supabase - Orders"
      },
      {
        "name": "search_catalog",
        "description": "Busca información de productos en el catálogo. Usa el nombre o descripción del producto.",
        "node": "Vector Store - Catalog"
      },
      {
        "name": "create_ticket",
        "description": "Crea un ticket de soporte. Úsalo cuando no puedas resolver el problema directamente.",
        "node": "HTTP - CRM Create Ticket"
      }
    ]
  }
}

Para se aprofundar: n8n AI Agent docs · ReAct paper · Tool calling Anthropic

RAG em termos de negócio

RAG (Retrieval-Augmented Generation) é a técnica que permite ao bot responder perguntas usando o conhecimento específico do seu cliente — catálogo, FAQs, políticas — sem precisar de fine-tuning. O fluxo é simples: o usuário faz uma pergunta → o sistema busca os documentos mais relevantes → o LLM responde usando esses documentos como contexto.

Os 4 passos do pipeline RAG no n8n

• Ingestão (offline): documento → split em chunks (400-600 tokens) → embedding (OpenAI ou Anthropic) → salvar no Supabase pgvector com metadata.
• Retrieval (online): query do usuário → embedding → busca por similaridade de cosseno → top-5 chunks mais relevantes.
• Augmentation: chunks recuperados → injetar como contexto no prompt do agente com a instrução "Use só esta informação para responder".
• Citation check: a resposta do LLM está respaldada pelos chunks? Se não houver chunks relevantes, o agente deve admitir isso em vez de alucinar.

Fluxo n8n: rag-pipeline.sql + n8n workflow

-- 1. Tabla de documentos con vector en Supabase
CREATE TABLE knowledge_base (
  id          uuid DEFAULT gen_random_uuid() PRIMARY KEY,
  content     text              NOT NULL,
  embedding   vector(1536),       -- OpenAI ada-002 / text-3-small
  source      text,             -- "catalog", "faq", "policy"
  metadata    jsonb,            -- producto_id, categoria, etc.
  created_at  timestamptz DEFAULT now()
);

-- 2. Función de búsqueda semántica (llama desde n8n HTTP Request)
CREATE OR REPLACE FUNCTION search_knowledge(
  query_embedding vector(1536),
  match_threshold float DEFAULT 0.78,
  match_count     int   DEFAULT 5
)
RETURNS TABLE(content text, similarity float, source text)
LANGUAGE sql STABLE AS $$
  SELECT content, 1 - (embedding <=> query_embedding) AS similarity, source
  FROM knowledge_base
  WHERE 1 - (embedding <=> query_embedding) > match_threshold
  ORDER BY similarity DESC
  LIMIT match_count;
$$;

-- 3. En n8n: nodo Code para preparar el contexto RAG
const chunks = $json.chunks;  // resultado de search_knowledge

if (chunks.length === 0) {
  return [{ json: { context: "", has_context: false } }];
}

const context = chunks
  .map((c, i) => `[Fuente ${i+1}]: ${c.content}`)
  .join('\n\n');

return [{ json: {
  context,
  has_context: true,
  sources: chunks.map(c => c.source)
}}];

Para se aprofundar: pgvector docs · n8n Vector Store node · OpenAI embeddings

WhatsApp como canal principal na América Latina

Na América Latina, o WhatsApp é o canal de comunicação padrão das PMEs. Mais de 90% dos clientes preferem resolver problemas pelo WhatsApp a usar email ou formulário web. Um bot de WhatsApp que funciona bem gera ROI imediato e visível: o dono do negócio percebe isso na redução das mensagens que precisa responder manualmente.

Os 3 estados de uma conversa no WhatsApp

• Automatizada: o bot cuida de tudo. Vale para 70% das consultas repetitivas (preço, horários, status do pedido).
• Assistida (HITL): o bot propõe, o humano aprova antes de enviar. Para orçamentos ou alterações de pedido.
• Escalonada: o bot detecta que não consegue resolver e transfere para um humano no Chatwoot. Para reclamações ou casos complexos.

Fluxo n8n: whatsapp-flow.json (Evolution API → n8n → Chatwoot)

// Flujo: mensaje WhatsApp → bot → respuesta automática o escalación

// PASO 1: Webhook de Evolution API (entrada)
// POST /webhook → { data: { key: { remoteJid }, message: { conversation } } }

const phone = $json.data.key.remoteJid.replace('@s.whatsapp.net', '');
const message = $json.data.message?.conversation
              || $json.data.message?.extendedTextMessage?.text
              || '';

// PASO 2: Recuperar o crear sesión del usuario
const session = await $node["Supabase - Get Session"].run({
  phone,
  create_if_missing: true
});

// PASO 3: Pasar al AI Agent con contexto completo
return [{ json: {
  phone,
  message,
  session_id: session.id,
  history: session.messages.slice(-10),  // últimos 10 mensajes
  channel: 'whatsapp'
}}];

// ─────────────────────────────────────────
// PASO 5: Enviar respuesta via Evolution API

const agentResponse = $json.output;
const shouldEscalate = $json.escalate === true;

if (shouldEscalate) {
  // Crear conversación en Chatwoot con contexto completo
  await $node["HTTP - Chatwoot Create Conv"].run({
    phone,
    initial_message: `[BOT escaló] Razón: ${$json.escalation_reason}\n\nHistorial:\n${session.history_text}`
  });
  // Notificar al cliente
  return [{ json: { text: "Te conecto con un asesor ahora mismo, espera un momento" }}];
}

return [{ json: { text: agentResponse }}];

Para se aprofundar: Evolution API docs · Chatwoot API · n8n WhatsApp node

O pipeline de vendas automatizado

Um lead entra pelo WhatsApp ou por um formulário → o sistema qualifica automaticamente (BANT: Budget, Authority, Need, Timeline) → enriquece o perfil com informações públicas → agenda o follow-up → atualiza o CRM. O vendedor só mexe nos leads qualificados.

• Qualificação com LLM: o agente extrai o BANT do texto da conversa. Score de 0 a 10. Se <5, nurturing automático. Se ≥5, atribui a um vendedor.
• Lead enrichment: com o email ou telefone, busca informações públicas (LinkedIn, Google) usando nós HTTP Request.
• CRM sync: o n8n tem nós nativos para HubSpot, Pipedrive, Salesforce e Twenty CRM (self-hosted). Um lead qualificado é criado automaticamente com todas as suas propriedades.
• Follow-up scheduler: se não houver resposta em 24h, o n8n envia uma mensagem de acompanhamento. Ele para automaticamente quando o lead responde.

Conteúdo gerado com aprovação humana — o padrão correto

Publicar conteúdo gerado por IA diretamente, sem revisão humana, é o antipadrão mais comum e mais caro. O padrão correto é: geração automática → revisão humana em 1 clique → publicação agendada. O n8n implementa isso nativamente com o nó "Wait for Webhook", que pausa o fluxo até receber a aprovação.

• Geração: a partir de um brief, keywords ou dados do produto → o LLM gera variantes de post para Instagram, LinkedIn, WhatsApp.
• Revisão (HITL): o n8n envia as variantes por email ou Slack com botões Aprovar/Rejeitar/Editar. O fluxo espera (máx. 24h).
• Publicação agendada: ao aprovar, o n8n usa as APIs nativas de cada rede social (ou Buffer/Later como proxy) para publicar no horário ideal.
• Reaproveitamento: posts com bom engajamento são salvos como few-shot examples para melhorar a geração futura.

Suporte automatizado que não frustra o cliente

O bot de suporte precisa cumprir uma regra simples: se consegue resolver o problema na primeira tentativa, resolve. Se não consegue, escala rápido e com contexto. 70% das consultas de suporte em uma PME são repetitivas (status do pedido, horários, preços). Automatizá-las libera a equipe para os casos que realmente precisam de atenção humana.

• Classificação de urgência: o agente detecta se a consulta é crítica (produto com defeito, pagamento não processado) e escala imediatamente, sem tentar resolver.
• Resolução com RAG: para perguntas sobre produtos, políticas ou FAQ, o agente usa a knowledge base do M4 antes de responder.
• Criação automática de tickets: qualquer consulta que o bot não consiga resolver gera um ticket no CRM com categoria, prioridade e resumo do problema.
• CSAT automático: 30 minutos depois de encerrar uma conversa, o bot envia uma pergunta de satisfação (1-5). Os resultados são salvos para análise.

O sistema nunca deve quebrar em silêncio

Em produção, os fluxos falham. A API do WhatsApp cai, o Supabase dá timeout, o LLM retorna rate limit. O trabalho do automatizador não é evitar todas as falhas (impossível) — é garantir que, quando elas acontecem, o sistema responda com elegância e alerte a pessoa certa.

As 4 técnicas de resiliência para automatizadores

• Error Trigger node: captura qualquer erro no fluxo, salva o contexto completo no Supabase e envia um alerta por WhatsApp/Telegram ao operador.
• Retry com backoff: o nó HTTP Request do n8n tem retry nativo. Configure 3 tentativas com backoff exponencial (1s, 2s, 4s) para APIs instáveis.
• Fallback estático: se o LLM falhar depois de 3 tentativas, o fluxo envia uma mensagem pré-escrita ao usuário e cria um ticket automaticamente.
• Circuit breaker manual: se uma ferramenta externa falhar mais de N vezes em 1 hora, desative esse nó automaticamente e notifique o operador antes que ele continue causando erros.

Fluxo n8n: resilience-layer.json (Error Trigger + fallback)

// Error Trigger — nodo especial que captura fallos de cualquier flujo
// Se configura como "Error Workflow" en los settings del flujo principal

{
  "type": "n8n-nodes-base.errorTrigger",
  "name": "FlowBot Error Catcher"
}

// Al activarse, recibe: execution, workflowData, error
// Nodo Code a continuación:

const { execution, error } = $json;

// 1. Log completo en Supabase para debugging
const errorLog = {
  execution_id: execution.id,
  workflow_name: execution.workflowData.name,
  error_message: error.message,
  error_node: error.node,
  input_data: JSON.stringify(execution.data.resultData?.lastNodeExecuted),
  timestamp: new Date().toISOString()
};
// → Supabase insert en tabla error_logs

// 2. Alerta inmediata por WhatsApp al operador
const alertMessage = `FlowBot Error
Flujo: ${execution.workflowData.name}
Error: ${error.message}
Nodo: ${error.node}
ID: ${execution.id}`;
// → HTTP Request POST a Evolution API

// 3. Si el error fue en conversación de usuario, enviar fallback
const userPhone = execution.data?.startData?.destinationNode?.phone;
if (userPhone) {
  // → Respuesta al usuario: "Lo siento, estamos teniendo problemas técnicos..."
  // → Crear ticket automático en CRM para dar seguimiento
}

return [{ json: { logged: true, alerted: true } }];

Para se aprofundar: n8n Error workflows · Supabase functions

Do fluxo local ao sistema em produção para um cliente

Deploy não é só subir o código. É configurar o ambiente do cliente, documentar o sistema para que ele consiga operá-lo sem você e definir o modelo de preços para que a automação seja rentável no longo prazo.

• Infraestrutura mínima: VPS de $10/mês (Hetzner, Hostinger, DigitalOcean) + Docker Compose com n8n, Redis e Evolution API. O Supabase pode ficar no tier gratuito para começar.
• Variáveis de ambiente por cliente: nunca coloque API keys hardcoded nos fluxos. Use o sistema de credenciais do n8n, separado por workspace por cliente.
• Documentação do sistema: cada fluxo deve ter uma nota interna no n8n explicando o que faz, o que pode falhar e como reiniciá-lo. O cliente ou você vão ler isso em um incidente às 2h da manhã.
• Modelo de preços: setup fee único ($500-$3000) + manutenção mensal ($100-$300/mês) + custo do LLM repassado com margem (cobrar 2x o custo real dos tokens).

Para se aprofundar: n8n self-host docs · Docker Compose reference · Hetzner VPS pricing