Build AI Workflows with n8n (2026 Guide)

# docker-compose.yml
version: "3.8"

services:
  n8n:
    image: n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=your-domain.com
      - N8N_PROTOCOL=https
      - N8N_PORT=5678
      - WEBHOOK_URL=https://your-domain.com/
      - EXECUTIONS_MODE=queue          # Enable queue mode for long-running jobs
      - QUEUE_BULL_REDIS_HOST=redis
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=${DB_PASSWORD}
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - EXECUTIONS_TIMEOUT=600         # 10 minute timeout for agent workflows
      - EXECUTIONS_TIMEOUT_MAX=1800    # 30 minute absolute max
    volumes:
      - n8n_data:/home/node/.n8n

  n8n-worker:
    image: n8nio/n8n:latest
    command: worker
    restart: always
    environment:
      - EXECUTIONS_MODE=queue
      - QUEUE_BULL_REDIS_HOST=redis
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=${DB_PASSWORD}
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
    scale: 3  # Run 3 workers for parallel execution

  redis:
    image: redis:7-alpine
    restart: always
    volumes:
      - redis_data:/data

  postgres:
    image: postgres:15-alpine
    restart: always
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  n8n_data:
  redis_data:
  postgres_data:

# Start n8n with queue mode
docker compose up -d

# Check worker status
docker compose logs n8n-worker

You are a customer support agent for Acme SaaS.
Your goal is to resolve customer issues efficiently.

You have access to tools that let you:
- Search the knowledge base for FAQ answers
- Look up customer account details by email
- Create support tickets for complex issues
- Send notification emails

Guidelines:
- Always search the knowledge base before answering policy questions
- Look up the customer account when they ask about billing or their plan
- Create a ticket if you cannot resolve the issue after 2 attempts
- Be concise — customers want answers, not explanations

{
  "name": "search_knowledge_base",
  "description": "Search the support knowledge base. Use for policy questions, how-to guides, and troubleshooting. Input: natural language question.",
  "method": "GET",
  "url": "https://api.your-kb.com/search",
  "queryParameters": {
    "q": "={{ $fromAI('query', 'The search query', 'string') }}",
    "limit": "5"
  },
  "authentication": "Generic Credential Type",
  "headers": {
    "Authorization": "Bearer {{ $credentials.kbApiKey }}"
  }
}

// Tool: classify_ticket
// Description: Classify a support ticket by category and priority.
// Input: ticket_text (string) - the customer's message

const ticketText = $fromAI('ticket_text', 'The customer message to classify', 'string');

// Classification logic
const categories = {
  billing: ['invoice', 'charge', 'payment', 'refund', 'subscription'],
  technical: ['error', 'bug', 'crash', 'not working', 'broken', 'failed'],
  account: ['password', 'login', 'access', 'email', '2fa'],
  feature: ['request', 'suggestion', 'would like', 'can you add'],
};

const priorities = {
  urgent: ['outage', 'down', 'cannot access', 'all users', 'production'],
  high: ['broken', 'failed', 'not working', 'urgent', 'asap'],
  medium: ['slow', 'issue', 'problem', 'not as expected'],
  low: ['question', 'how to', 'documentation', 'suggestion'],
};

const textLower = ticketText.toLowerCase();

let category = 'general';
let maxMatches = 0;
for (const [cat, keywords] of Object.entries(categories)) {
  const matches = keywords.filter(k => textLower.includes(k)).length;
  if (matches > maxMatches) {
    maxMatches = matches;
    category = cat;
  }
}

let priority = 'low';
for (const [prio, keywords] of Object.entries(priorities)) {
  if (keywords.some(k => textLower.includes(k))) {
    priority = prio;
    break;
  }
}

return { category, priority, word_count: ticketText.split(' ').length };

-- Tool: lookup_customer_account
-- Description: Look up customer account by email address. Returns plan, status, and billing info.
-- Input: customer_email (string)

SELECT
  account_id,
  email,
  plan_name,
  account_status,
  billing_date,
  monthly_spend,
  support_tier
FROM customers
WHERE email = '{{ $fromAI("customer_email", "Customer email address", "string") }}'
LIMIT 1;

[Webhook Trigger]
    |
    v
[Respond to Webhook]  ← Send immediate 202 response with job_id
    |
    v
[AI Agent Node]       ← Runs asynchronously in worker queue
    |
    v
[Switch: Success/Error]
    |           |
    v           v
[HTTP Request]  [HTTP Request]
(callback URL)  (error webhook)

{
  "statusCode": 202,
  "body": {
    "status": "processing",
    "job_id": "={{ $execution.id }}",
    "message": "Your request is being processed. You will receive a callback when complete.",
    "estimated_time_seconds": 30
  }
}

{
  "method": "POST",
  "url": "={{ $json.callback_url }}",
  "body": {
    "job_id": "={{ $execution.id }}",
    "status": "completed",
    "result": "={{ $json.output }}",
    "tools_used": "={{ $json.intermediateSteps.length }}"
  }
}

[HTTP Request Tool: search_kb]
    |                    |
    v (success)          v (error)
[AI Agent]           [Set: error_context]
                         |
                         v
                     [AI Agent]  ← Retry with error context in prompt

// In the Error Trigger workflow - Code node
const error = $json.error;
const workflowName = $json.workflow.name;
const executionId = $json.execution.id;

// Send to Slack
const slackMessage = {
  text: `Agent workflow failed: ${workflowName}`,
  blocks: [
    {
      type: "section",
      text: {
        type: "mrkdwn",
        text: `*Workflow:* ${workflowName}\n*Error:* ${error.message}\n*Execution:* ${executionId}`
      }
    }
  ]
};

return slackMessage;