AI Automation: automate real processes with AI

Why n8n and not just Python?

80% of business automations don't need code. n8n lets you build complex flows with visual logic, connect 400+ services with one click, and deploy self-hosted without depending on a vendor. The automation developer doesn't replace the engineer — they have a market of their own: small businesses that need results today, not in six months.

The most important architecture decision: n8n vs Make vs Zapier

• n8n (self-hosted): full control, no operation limits, JavaScript code in nodes, ideal for sensitive data or complex flows. Requires a VPS (~$5/month).
• Make (formerly Integromat): advanced visual builder, better for non-linear data flows, priced per operation. Good for clients who don't want to self-host.
• Zapier: the simplest, and the most expensive per operation. Only for simple 2–3 step integrations where setup speed matters more than cost.

Anatomy of an n8n flow in production

Component	Description	When to use it
Trigger	Webhook, Cron, or an event from an external app	Always — every flow starts here
HTTP Request	A call to any REST API	When there's no native node
AI Agent	LLM with tools and native memory in n8n	Reasoning and dynamic decisions
Code (JS)	JavaScript for data transformation	Logic the nodes don't cover
If / Switch	Conditional routing of the flow	Multiple paths by input type
Error Trigger	Catches errors from the whole flow	Always in production flows

n8n flow: 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"
      }
    }
  ]
}

Go deeper: n8n docs · Supabase quickstart · Anthropic pricing

The prompt is the contract with the model

In business automations, the LLM's output isn't read by a human — it's processed by the next node in the flow. That completely changes how you write a prompt. You're not looking for "a good answer", you're looking for parseable JSON, a boolean, or a category from an enum. Ambiguity in the prompt is a production bug.

Prompt structure for automations (4 sections)

• ROLE + TASK: who the model is and exactly what it must do. No ambiguity.
• DYNAMIC CONTEXT: variables that change per request (user data, history, catalog). Injected at runtime.
• CONSTRAINTS: what it can NOT do. Just as important as what it can do.
• OUTPUT FORMAT: the exact format of the response. For flows: always valid JSON with an explicit schema.

Structured output — the most important technique for n8n

Technique	When to use it	Risk
Plain JSON	Classification, data extraction, routing	The model may add text before the JSON
XML tags (<output>)	When you need to separate reasoning from the answer	You have to parse the XML
Structured Outputs API	Claude/OpenAI support native JSON schema	Only works with certain models
Few-shot + format	When the format is complex and the model fails	Adds tokens and cost

n8n flow: 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) }];

Go deeper: Anthropic tool use · JSON schema validation · n8n Code node

What is n8n's AI Agent node?

n8n's AI Agent node natively implements the ReAct pattern (Reason + Act) without any Python code. The agent can use tools (other n8n nodes), keep memory across turns, and decide when it has enough information to answer. The difference from a plain LLM node is that the agent can take multiple steps before answering.

Tools available in n8n for the AI Agent

• HTTP Request Tool: any external API. The agent decides when to call it and with which parameters.
• Supabase Tool: database reads and writes. The agent can look up customer information without you doing it explicitly.
• Vector Store Tool: semantic search over documents. The basis of the RAG pattern.
• Code Tool: executable JavaScript. For calculations or transformations the LLM would get wrong.
• Think Tool: lets the agent reason out loud before acting. Improves quality in complex cases.

The most critical risk: infinite loops

Without the right configuration, an agent can call the same tool in a loop if the output doesn't meet its internal criteria. n8n doesn't prevent this by default.

n8n flow: agent-flow.json (AI Agent node configuration)

// 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"
      }
    ]
  }
}

Go deeper: n8n AI Agent docs · ReAct paper · Anthropic tool calling

RAG in business terms

RAG (Retrieval-Augmented Generation) is the technique that lets the bot answer questions using your client's specific knowledge — catalog, FAQs, policies — without any fine-tuning. The flow is simple: the user asks a question → the system finds the most relevant documents → the LLM answers using those documents as context.

The 4 steps of the RAG pipeline in n8n

• Ingestion (offline): document → split into chunks (400-600 tokens) → embedding (OpenAI or Anthropic) → store in Supabase pgvector with metadata.
• Retrieval (online): user query → embedding → cosine similarity search → top-5 most relevant chunks.
• Augmentation: retrieved chunks → injected as context into the agent's prompt with the instruction "Use only this information to answer".
• Citation check: is the LLM's answer backed by the chunks? If there are no relevant chunks, the agent must admit it instead of hallucinating.

n8n flow: 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)
}}];

Go deeper: pgvector docs · n8n Vector Store node · OpenAI embeddings

WhatsApp as the main channel in Latin America

In Latin America, WhatsApp is the default communication channel for small businesses. 90%+ of customers would rather solve problems over WhatsApp than by email or a web form. A WhatsApp bot that works well delivers immediate, visible ROI: the business owner sees it in the drop in messages they have to answer by hand.

The 3 states of a WhatsApp conversation

• Automated: the bot handles everything. Applies to the 70% of repetitive questions (price, hours, order status).
• Assisted (HITL): the bot proposes, a human approves before sending. For quotes or order changes.
• Escalated: the bot detects it can't resolve the issue and hands off to a human in Chatwoot. For complaints or complex cases.

n8n flow: 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 }}];

Go deeper: Evolution API docs · Chatwoot API · n8n WhatsApp node

The automated sales pipeline

A lead comes in through WhatsApp or a form → the system qualifies it automatically (BANT: Budget, Authority, Need, Timeline) → enriches the profile with public information → schedules a follow-up → updates the CRM. The salesperson only touches qualified leads.

• Qualification with an LLM: the agent extracts BANT from the conversation text. Score 0-10. If <5, automatic nurturing. If ≥5, assigned to a salesperson.
• Lead enrichment: with the email or phone number, it looks up public information (LinkedIn, Google) using HTTP Request nodes.
• CRM sync: n8n has native nodes for HubSpot, Pipedrive, Salesforce, and Twenty CRM (self-hosted). A qualified lead is created automatically with all its properties.
• Follow-up scheduler: if there's no reply within 24h, n8n sends a follow-up message. It stops automatically when the lead replies.

Generated content with human approval — the right pattern

Publishing AI-generated content directly without human review is the most common and most expensive anti-pattern. The right pattern is: automatic generation → 1-click human review → scheduled publishing. n8n implements this natively with the "Wait for Webhook" node, which pauses the flow until approval comes in.

• Generation: from a brief, keywords or product data → the LLM generates post variants for Instagram, LinkedIn, WhatsApp.
• Review (HITL): n8n sends the variants by email or Slack with Approve/Reject/Edit buttons. The flow waits (max 24h).
• Scheduled publishing: on approval, n8n uses each social network's native APIs (or Buffer/Later as a proxy) to publish at the optimal time.
• Recycling: posts with good engagement are saved as few-shot examples to improve future generation.

Automated support that doesn't frustrate the customer

The support bot has to follow one simple rule: if it can solve the problem on the first try, it does. If it can't, it escalates fast and with context. 70% of support questions at a small business are repetitive (order status, hours, prices). Automating those frees the team for the cases that really need human attention.

• Urgency classification: the agent detects whether the request is critical (defective product, payment not processed) and escalates immediately without trying to solve it.
• Resolution with RAG: for questions about products, policies or FAQs, the agent uses the knowledge base from M4 before answering.
• Automatic ticket creation: any request the bot can't resolve creates a ticket in the CRM with the category, priority and a summary of the problem.
• Automatic CSAT: 30 minutes after a conversation is closed, the bot sends a satisfaction question (1-5). The results are stored for analysis.

The system must never fail silently

In production, flows fail. The WhatsApp API goes down, Supabase times out, the LLM returns a rate limit. The automator's job isn't to prevent every failure (impossible) — it's to make sure that when things fail, the system responds gracefully and alerts the right person.

The 4 resilience techniques for automators

• Error Trigger node: catches any error in the flow, saves the full context in Supabase, and sends an alert to the operator via WhatsApp/Telegram.
• Retry with backoff: n8n's HTTP Request node has built-in retry. Set 3 attempts with exponential backoff (1s, 2s, 4s) for unstable APIs.
• Static fallback: if the LLM fails after 3 attempts, the flow sends the user a pre-written message and creates a ticket automatically.
• Manual circuit breaker: if an external tool fails more than N times in 1 hour, disable that node automatically and notify the operator before it causes more errors.

n8n flow: 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 } }];

Go deeper: n8n Error workflows · Supabase functions

From a local flow to a production system for a client

Deploying isn't just uploading the code. It's setting up the client's environment, documenting the system so they can run it without you, and defining the pricing model so the automation stays profitable over the long run.

• Minimum infrastructure: a $10/month VPS (Hetzner, Hostinger, DigitalOcean) + Docker Compose with n8n, Redis and Evolution API. Supabase can start on the free tier.
• Per-client environment variables: never hardcode API keys in the flows. Use n8n's credentials system, separated by workspace per client.
• System documentation: every flow should have an internal note in n8n explaining what it does, what can fail, and how to restart it. The client or you will read it during an incident at 2am.
• Pricing model: one-time setup fee ($500-$3000) + monthly maintenance ($100-$300/month) + LLM cost passed through with a margin (charge 2x the real token cost).

Go deeper: n8n self-host docs · Docker Compose reference · Hetzner VPS pricing