Die n8n MCP-Revolution: KI-Agenten mit Produktions-Workflows verbinden 2026

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "n8n:execute_workflow",
    "arguments": {
      "workflow_id": "12345",
      "data": {
        "email": "[email protected]",
        "subject": "Wochenbericht"
      }
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Workflow erfolgreich ausgeführt. Ausführungs-ID: exec_abc123"
      }
    ],
    "isError": false
  }
}

┌─────────────────────────────────────────────────────────────┐
│                      KI-Agent-Client                         │
│  (Claude Desktop, Cursor, ChatGPT, Benutzerdefinierte Clients)│
└──────────────────────┬──────────────────────────────────────┘
                       │ MCP-Protokoll (stdio / HTTP/SSE)
                       ▼
┌─────────────────────────────────────────────────────────────┐
│                    n8n MCP-Server                            │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Schema   │  │   Tools    │  │     Ressourcen      │ │
│  │  Registry  │  │  Registry   │  │      Provider       │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└──────────────────────┬──────────────────────────────────────┘
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
┌──────────────┐ ┌──────────┐ ┌──────────────┐
│   Workflow   │ │ Ausführ- │ │  Zugangsdaten│
│    Engine    │ │  Engine  │ │    Store     │
└──────────────┘ └──────────┘ └──────────────┘

# MCP-Server aktivieren
N8N_MCP_SERVER_ENABLED=true

# Transportmodus: 'stdio' (Standard) oder 'http'
N8N_MCP_TRANSPORT=stdio

# HTTP-Transport-Einstellungen (bei Verwendung des HTTP-Modus)
N8N_MCP_HTTP_PORT=5679
N8N_MCP_HTTP_PATH=/mcp

# Authentifizierung für HTTP-Modus
N8N_MCP_AUTH_TOKEN=ihr-sicheres-zufälliges-token-hier

# Logging-Level: 'debug', 'info', 'warn', 'error'
N8N_MCP_LOG_LEVEL=info

# Ratenbegrenzung
N8N_MCP_RATE_LIMIT_REQUESTS=100
N8N_MCP_RATE_LIMIT_WINDOW=60000  # Millisekunden

# Workflow-Ausführungslimits über MCP
N8N_MCP_MAX_CONCURRENT_EXECUTIONS=50
N8N_MCP_EXECUTION_TIMEOUT=300000  # 5 Minuten

version: '3.8'
services:
  n8n:
    image: n8nio/n8n:1.50.0
    environment:
      - N8N_MCP_SERVER_ENABLED=true
      - N8N_MCP_TRANSPORT=http
      - N8N_MCP_HTTP_PORT=5679
      - N8N_MCP_AUTH_TOKEN=${MCP_AUTH_TOKEN}
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=${N8N_USER}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
    ports:
      - "5678:5678"  # n8n Web-UI
      - "5679:5679"  # MCP HTTP-Endpunkt
    volumes:
      - ~/.n8n:/home/node/.n8n
    networks:
      - n8n-network

# Überprüfen, ob MCP-Server läuft
n8n mcp:status

# Erwartete Ausgabe:
# MCP-Server-Status: Aktiv
# Transport: stdio
# Verbundenene Clients: 0
# Laufzeit: 2h 34m

curl -X POST http://localhost:5679/mcp \
  -H "Authorization: Bearer your-token" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/list",
    "id": 1
  }'

~/Library/Application Support/Claude/claude_desktop_config.json

%APPDATA%\Claude\claude_desktop_config.json

~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "n8n-local": {
      "command": "n8n",
      "args": ["mcp:start"],
      "env": {
        "N8N_MCP_SERVER_ENABLED": "true"
      }
    }
  }
}

{
  "mcpServers": {
    "n8n-cloud": {
      "url": "https://your-instance.n8n.cloud/mcp",
      "headers": {
        "Authorization": "Bearer your-token-here"
      }
    }
  }
}

Benutzer: Erstelle einen n8n-Workflow, der mir eine Slack-Nachricht sendet, 
immer wenn eine neue Zeile zu meinem Google Sheet hinzugefügt wird.

Claude: Ich werde diesen Workflow für Sie erstellen. Lassen Sie mich den 
Trigger und Aktionsknoten einrichten.

[Claude verwendet create_workflow-Tool mit der folgenden Struktur]

Workflow erfolgreich erstellt! 

ID: 67890
Name: "Google Sheets zu Slack Benachrichtigung"
Knoten: 
  - Google Sheets Trigger (prüft jede Minute)
  - Slack-Nachricht senden
  - Set-Knoten für Nachrichtenformatierung

Der Workflow ist gespeichert, aber noch nicht aktiviert. Möchten Sie, 
dass ich ihn aktiviere?

Benutzer: Mein "Kunden-Onboarding"-Workflow ist heute 3 Mal fehlgeschlagen. 
Kannst du prüfen, warum?

Claude: Lassen Sie mich diese fehlgeschlagenen Ausführungen für Sie untersuchen.

[Claude verwendet get_execution_logs-Tool mit Filter für Fehlerstatus]

Ich habe das Problem gefunden. Der Workflow scheitert am Knoten 
"Willkommens-E-Mail senden", weil die SMTP-Zugangsdaten Authentifizierungsfehler 
verursachen. Die Fehlermeldung zeigt: "535 5.7.8 Authentifizierungsdaten ungültig"

Empfehlungen:
1. Aktualisieren Sie die SMTP-Zugangsdaten in n8n
2. Prüfen Sie, ob Ihr E-Mail-Anbieter App-spezifische Passwörter erfordert
3. Überprüfen Sie, ob die E-Mail-Adresse zum Senden berechtigt ist

Möchten Sie, dass ich Ihnen bei der Aktualisierung der 
Zugangsdatenkonfiguration helfe?

{
  "name": "n8n-workflows",
  "command": "n8n mcp:start --transport stdio",
  "transport": "stdio"
}

{
  "name": "n8n-cloud",
  "url": "https://your-instance.n8n.cloud/mcp",
  "headers": {
    "Authorization": "Bearer your-token"
  }
}

Entwickler: Ich muss einen API-Endpunkt für Kundenanmeldungen erstellen 
und einen entsprechenden n8n-Workflow, der Willkommens-E-Mails sendet 
und ihr Profil in unserem CRM erstellt.

Cursor: Ich helfe Ihnen, sowohl den API-Endpunkt als auch den n8n-Workflow 
zu erstellen. Lassen Sie mich mit dem Workflow beginnen.

[Cursor verwendet MCP-Tool für create_workflow]

Workflow erstellt mit:
- Webhook-Trigger (wartet auf Aufruf durch Ihre API)
- E-Mail-Senden-Knoten mit Vorlage
- CRM-Integration für Profilerstellung
- Fehlerbehandlung und Retry-Logik

Nun lasse ich den API-Endpunkt-Code generieren:

[Cursor generiert FastAPI/Python-Code]

```python
from fastapi import FastAPI, HTTPException
import httpx

app = FastAPI()

@app.post("/api/customers/signup")
async def customer_signup(email: str, name: str):
    try:
        # n8n-Workflow auslösen
        async with httpx.AsyncClient() as client:
            response = await client.post(
                "https://your-instance.n8n.cloud/webhook/signup",
                json={"email": email, "name": name}
            )
            return {"status": "success", "workflow_id": response.json()["executionId"]}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

#### Szenario: Datenbank-Schema-Migration mit automatisierten Backups

{
  "name": "Datenbank-Backup vor Migration",
  "nodes": [
    {
      "type": "n8n-nodes-base.manualTrigger",
      "name": "Backup starten"
    },
    {
      "type": "n8n-nodes-base.postgres",
      "name": "Backup erstellen",
      "operation": "executeQuery",
      "query": "SELECT pg_dump..."
    },
    {
      "type": "n8n-nodes-base.s3",
      "name": "Zu S3 hochladen",
      "operation": "upload",
      "bucket": "backups"
    },
    {
      "type": "n8n-nodes-base.slack",
      "name": "Abschluss benachrichtigen",
      "text": "✅ Datenbank-Backup abgeschlossen: {{$json.fileName}}"
    }
  ]
}

### Best Practices für Cursor + n8n MCP

1. **.cursorrules-Datei verwenden**: n8n-spezifischen Kontext hinzufügen

2. **Versionskontrolle-Integration**: Workflows zu JSON exportieren und zusammen mit dem Code committen:
```bash
# Zu package.json-Skripten hinzufügen
"n8n:export": "n8n export:workflow --all --output ./workflows/"

{
  "type": "object",
  "required": ["customer_email", "order_id"],
  "properties": {
    "customer_email": {
      "type": "string",
      "format": "email",
      "description": "Kunden-E-Mail-Adresse für Benachrichtigungen"
    },
    "order_id": {
      "type": "string",
      "description": "Eindeutige Bestellidentifikation"
    },
    "priority": {
      "type": "string",
      "enum": ["low", "normal", "high"],
      "default": "normal",
      "description": "Prioritätsstufe für die Verarbeitung"
    }
  }
}

{
  "status": "success|error",
  "message": "Menschlich lesbare Ergebnisbeschreibung",
  "data": {
    "reference_id": "Tracking-Identifikator",
    "processing_time": "Dauer in ms"
  }
}

{
  "nodes": [
    {
      "type": "n8n-nodes-base.webhook",
      "name": "API-Einstiegspunkt",
      "path": "universal-handler"
    },
    {
      "type": "n8n-nodes-base.switch",
      "name": "Nach Aktion routen",
      "rules": {
        "rules": [
          {
            "value": "process_payment",
            "output": 0
          },
          {
            "value": "create_invoice",
            "output": 1
          },
          {
            "value": "update_inventory",
            "output": 2
          }
        ]
      }
    }
  ]
}

{
  "nodes": [
    {
      "type": "n8n-nodes-base.webhook",
      "name": "Trigger"
    },
    {
      "type": "n8n-nodes-base.set",
      "name": "Logeintrag Start",
      "values": {
        "string": [
          {
            "name": "audit_log",
            "value": "={{JSON.stringify({ timestamp: $now, workflow_id: $workflow.id, status: 'started', inputs: $input.all() })}}"
          }
        ]
      }
    },
    {
      "type": "n8n-nodes-base.code",
      "name": "Daten verarbeiten"
    },
    {
      "type": "n8n-nodes-base.set",
      "name": "Logeintrag Abschluss",
      "values": {
        "string": [
          {
            "name": "audit_log",
            "value": "={{JSON.stringify({ timestamp: $now, workflow_id: $workflow.id, status: 'completed', outputs: $input.all() })}}"
          }
        ]
      }
    }
  ]
}

{
  "nodes": [
    {
      "type": "n8n-nodes-base.webhook",
      "name": "Rückerstattungsanfrage"
    },
    {
      "type": "n8n-nodes-base.slack",
      "name": "Genehmigung anfordern",
      "text": "Rückerstattungsanfrage: {{$json.amount}} für Bestellung {{$json.order_id}}. Antworten Sie 'APPROVE' zum Fortfahren."
    },
    {
      "type": "n8n-nodes-base.wait",
      "name": "Auf Antwort warten",
      "webhookSuffix": "approval-response"
    },
    {
      "type": "n8n-nodes-base.if",
      "name": "Genehmigung prüfen",
      "conditions": {
        "string": [
          {
            "value1": "={{$json.message.text}}",
            "operation": "equal",
            "value2": "APPROVE"
          }
        ]
      }
    }
  ]
}

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Agent A   │     │   Agent B   │     │   Agent C   │
│  (Forschung)│     │ (Analyse)   │     │  (Aktion)   │
└──────┬──────┘     └──────┬──────┘     └──────┬──────┘
       │                   │                   │
       └───────────────────┼───────────────────┘
                           │
                    ┌───────▼────────┐
                    │   n8n MCP      │
                    │  Orchestrator  │
                    └───────┬────────┘
                            │
              ┌─────────────┼─────────────┐
              ▼             ▼             ▼
        ┌─────────┐   ┌─────────┐   ┌─────────┐
        │ Workflow│   │ Workflow│   │ Workflow│
        │   #1    │   │   #2    │   │   #3    │
        └─────────┘   └─────────┘   └─────────┘

{
  "name": "Multi-Agent-Task-Router",
  "nodes": [
    {
      "type": "n8n-nodes-base.webhook",
      "name": "Agent-Anfrage",
      "path": "agent-router"
    },
    {
      "type": "n8n-nodes-base.switch",
      "name": "Nach Agent-Rolle routen",
      "rules": {
        "rules": [
          {
            "value": "research",
            "output": 0
          },
          {
            "value": "analysis",
            "output": 1
          },
          {
            "value": "action",
            "output": 2
          }
        ]
      }
    },
    {
      "type": "n8n-nodes-base.executeWorkflow",
      "name": "Forschungs-Workflow ausführen",
      "workflowId": "wf-research-template"
    },
    {
      "type": "n8n-nodes-base.executeWorkflow",
      "name": "Analyse-Workflow ausführen",
      "workflowId": "wf-analysis-template"
    },
    {
      "type": "n8n-nodes-base.executeWorkflow",
      "name": "Aktions-Workflow ausführen",
      "workflowId": "wf-action-template"
    }
  ]
}

// MCP-Tool-Aufruf für create_workflow
{
  "name": "create_workflow",
  "arguments": {
    "name": "Generated-Social-Campaign-2026-06-18",
    "description": "Auto-generierter Workflow für Social-Media-Kampagne",
    "nodes": [
      // Dynamisch konstruiert basierend auf Kampagnenanforderungen
    ],
    "tags": ["generated", "campaign", "temporary"]
  }
}

┌──────────────┐
│   Ausführen  │
│   Workflow   │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  Analysieren │
│  Leistung    │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  Engpässe    │
│  identifizieren│
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  Verbesserungen│
│  vorschlagen │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│  Workflow    │
│  aktualisieren│
└──────────────┘

{
  "name": "Selbstoptimierende Daten-Pipeline",
  "nodes": [
    {
      "type": "n8n-nodes-base.scheduleTrigger",
      "name": "Tägliche Analyse",
      "rule": "0 2 * * *"
    },
    {
      "type": "n8n-nodes-base.httpRequest",
      "name": "Metriken abrufen",
      "url": "http://prometheus:9090/api/v1/query",
      "sendQueryParams": true,
      "queryParameters": {
        "parameters": [
          {
            "name": "query",
            "value": "n8n_execution_duration_seconds{workflow=\"data-pipeline\"}"
          }
        ]
      }
    },
    {
      "type": "n8n-nodes-base.code",
      "name": "Leistung analysieren",
      "jsCode": "const metrics = $input.first().json.data.result;\nconst avgDuration = metrics.reduce((sum, m) => sum + parseFloat(m.value[1]), 0) / metrics.length;\n\nreturn [{\n  json: {\n    avgDuration,\n    needsOptimization: avgDuration > 30,\n    suggestedBatchSize: avgDuration > 60 ? 100 : 500\n  }\n}];"
    },
    {
      "type": "n8n-nodes-base.if",
      "name": "Optimierung nötig?",
      "conditions": {
        "number": [
          {
            "value1": "={{$json.needsOptimization}}",
            "operation": "equal",
            "value2": true
          }
        ]
      }
    },
    {
      "type": "n8n-nodes-base.n8n",
      "name": "Workflow aktualisieren",
      "operation": "update",
      "workflowId": "data-pipeline"
    }
  ]
}

# nginx.conf mit Sicherheitsheadern
server {
    listen 5679 ssl http2;
    server_name n8n-mcp.yourdomain.com;

    ssl_certificate /etc/ssl/certs/n8n.crt;
    ssl_certificate_key /etc/ssl/private/n8n.key;
    ssl_protocols TLSv1.3;
    ssl_ciphers 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256';

    location /mcp {
        # Ratenbegrenzung
        limit_req zone=mcp_limit burst=20 nodelay;
        
        # IP-Whitelist
        allow 10.0.0.0/8;
        allow 172.16.0.0/12;
        deny all;

        proxy_pass http://n8n:5679/mcp;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        
        # Sicherheitsheader
        add_header X-Frame-Options "SAMEORIGORIN" always;
        add_header X-Content-Type-Options "nosniff" always;
        add_header X-XSS-Protection "1; mode=block" always;
    }
}

#!/bin/bash
# rotate-mcp-token.sh

OLD_TOKEN=$(grep N8N_MCP_AUTH_TOKEN .env | cut -d= -f2)
NEW_TOKEN=$(openssl rand -hex 32)

# n8n aktualisieren
sed -i "s/N8N_MCP_AUTH_TOKEN=.*/N8N_MCP_AUTH_TOKEN=$NEW_TOKEN/" .env

# Clients aktualisieren
# - Claude Desktop-Konfiguration
# - Cursor MCP-Einstellungen
# - Benutzerdefinierte Clients

# Graceful-Restart
docker-compose restart n8n

# Rotation protokollieren
echo "$(date): MCP-Token rotiert" >> /var/log/n8n-mcp-audit.log

{
  "workflowId": "sensitive-hr-workflow",
  "permissions": {
    "mcp_clients": {
      "allow": ["hr-assistant-claude"],
      "deny": ["general-purpose-claude"]
    }
  }
}

# Docker Compose mit isolierten Netzwerken
version: '3.8'
services:
  n8n-mcp-executor:
    image: n8nio/n8n:1.50.0
    networks:
      - mcp-isolated
      - no-external-internet  # Nur interne Services
    security_opt:
      - no-new-privileges:true
    read_only: true
    tmpfs:
      - /tmp:noexec,nosuid,size=100m

// n8n-Konfiguration
{
  "logging": {
    "level": "debug",
    "output": "console",
    "mcp": {
      "audit": {
        "enabled": true,
        "includeRequestBody": false,  // Keine sensiblen Daten protokollieren
        "includeResponseBody": false,
        "retentionDays": 90
      }
    }
  }
}

{
  "timestamp": "2026-06-18T10:23:45Z",
  "event": "mcp_tool_call",
  "client_id": "claude-desktop-v1.2.3",
  "tool": "execute_workflow",
  "workflow_id": "12345",
  "execution_id": "exec_abc123",
  "duration_ms": 5234,
  "status": "success",
  "ip_address": "10.0.1.15",
  "user_agent": "MCP-Client/1.0"
}

// MCP-Tool-Antwort für credentials/list
{
  "credentials": [
    {
      "id": "creds-123",
      "name": "Produktions-Datenbank",
      "type": "postgres",
      "nodeAccess": ["postgres", "timescaledb"],
      "lastUsed": "2026-06-17T15:30:00Z",
      // KEINE tatsächliche Verbindungszeichenfolge hier!
    }
  ]
}

{
  "nodes": [
    {
      "type": "n8n-nodes-base.set",
      "name": "PII maskieren",
      "values": {
        "string": [
          {
            "name": "email_masked",
            "value": "={{ $json.email.replace(/(.{2}).*(@.*)/, '$1***$2') }}"
          },
          {
            "name": "phone_masked",
            "value": "={{ $json.phone.replace(/\d(?=\d{4})/g, '*') }}"
          }
        ]
      }
    }
  ]
}

# docker-compose.production.yml
version: '3.8'
services:
  n8n-api:
    image: n8nio/n8n:1.50.0
    environment:
      - N8N_MCP_SERVER_ENABLED=false
    command: webhook
    deploy:
      replicas: 2

  n8n-mcp:
    image: n8nio/n8n:1.50.0
    environment:
      - N8N_MCP_SERVER_ENABLED=true
      - N8N_MCP_TRANSPORT=http
      - N8N_MCP_HTTP_PORT=5679
      - N8N_MCP_AUTH_TOKEN=${MCP_TOKEN}
    command: mcp:start
    deploy:
      replicas: 3
      resources:
        limits:
          memory: 2G
          cpus: '1.0'

  n8n-worker:
    image: n8nio/n8n:1.50.0
    environment:
      - N8N_MCP_SERVER_ENABLED=false
      - N8N_MODE=webhook
    command: worker
    deploy:
      replicas: 5

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  EU-Region      │    │  US-Region      │    │  APAC-Region    │
│  ┌───────────┐  │    │  ┌───────────┐  │    │  ┌───────────┐  │
│  │ n8n MCP   │  │    │  │ n8n MCP   │  │    │  │ n8n MCP   │  │
│  │  Server   │  │    │  │  Server   │  │    │  │  Server   │  │
│  │  (Frankfurt)│  │    │  │  (Virginia)│  │    │  │(Singapur)│  │
│  └─────┬─────┘  │    │  └─────┬─────┘  │    │  └─────┬─────┘  │
│        │        │    │        │        │    │        │        │
│  Lokale │ Clients│    │  Lokale │ Clients│    │  Lokale │ Clients│
└────────┼────────┘    └────────┼────────┘    └────────┼────────┘
         │                      │                      │
         └──────────────────────┼──────────────────────┘
                                │
                         ┌──────┴──────┐
                         │ Global Load │
                         │   Balancer  │
                         └─────────────┘

# Terraform für AWS-Deployment
resource "aws_lb" "n8n_mcp" {
  name               = "n8n-mcp-lb"
  internal           = true
  load_balancer_type = "application"
  
  health_check {
    path                = "/health"
    port                = 5678
    protocol            = "HTTP"
    healthy_threshold   = 2
    unhealthy_threshold = 3
    timeout             = 5
    interval            = 30
  }
}

resource "aws_lb_target_group" "n8n_mcp" {
  name     = "n8n-mcp-tg"
  port     = 5679
  protocol = "HTTP"
  vpc_id   = aws_vpc.main.id

  health_check {
    path                = "/mcp/health"
    matcher             = "200"
    interval            = 30
    timeout             = 5
    healthy_threshold   = 2
    unhealthy_threshold = 3
  }
}

# prometheus-metrics.yml
- name: n8n_mcp_requests_total
  help: Gesamte MCP-Anfragen nach Tool
  type: counter
  labels: [tool, status]

- name: n8n_mcp_request_duration_seconds
  help: MCP-Anfrage-Latenz
  type: histogram
  buckets: [0.1, 0.5, 1, 2, 5, 10, 30]

- name: n8n_mcp_active_connections
  help: Anzahl aktiver MCP-Verbindungen
  type: gauge

- name: n8n_mcp_workflow_executions_triggered
  help: Über MCP ausgelöste Workflows
  type: counter
  labels: [workflow_id, status]

# alertmanager-rules.yml
groups:
  - name: n8n_mcp_alerts
    rules:
      - alert: MCPHighErrorRate
        expr: rate(n8n_mcp_requests_total{status="error"}[5m]) > 0.1
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hohe MCP-Fehlerrate erkannt"
          
      - alert: MCPConnectionSpike
        expr: n8n_mcp_active_connections > 100
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Ungewöhnliche Anzahl MCP-Verbindungen"
          
      - alert: MCPWorkflowExecutionSlow
        expr: histogram_quantile(0.95, rate(n8n_mcp_request_duration_seconds_bucket[5m])) > 30
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "MCP-Workflow-Ausführungen sind langsam"

#!/bin/bash
# backup-mcp-config.sh

BACKUP_DIR="/backups/n8n/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR

# Workflow-Definitionen sichern
docker exec n8n n8n export:workflow --all --output /tmp/workflows.json
docker cp n8n:/tmp/workflows.json $BACKUP_DIR/

# MCP-Konfiguration sichern
docker exec n8n cat /home/node/.n8n/config | grep -i mcp > $BACKUP_DIR/mcp-config.txt

# Zugangsdaten-Metadaten sichern (nicht Geheimnisse!)
docker exec n8n n8n export:credentials --all --output /tmp/credentials.json
docker cp n8n:/tmp/credentials.json $BACKUP_DIR/

# Zu S3 synchronisieren
aws s3 sync $BACKUP_DIR s3://n8n-backups/mcp/$(date +%Y%m%d)/

# Alte Backups bereinigen (30 Tage aufbewahren)
find /backups/n8n -type d -mtime +30 -exec rm -rf {} +

#!/bin/bash
# mcp-failover.sh

PRIMARY_REGION="eu-central-1"
FAILOVER_REGION="us-east-1"

# Primären MCP-Health prüfen
if ! curl -sf http://n8n-mcp.$PRIMARY_REGION.internal:5679/health; then
  echo "Primärer MCP nicht gesund, Failover initiieren..."
  
  # DNS auf Failover aktualisieren
  aws route53 change-resource-record-sets \
    --hosted-zone-id $ZONE_ID \
    --change-batch file://failover-to-us.json
    
  # On-Call benachrichtigen
  curl -X POST $PAGERDUTY_WEBHOOK \
    -H "Content-Type: application/json" \
    -d '{"event_action":"trigger","payload":{"summary":"n8n MCP Failover aktiviert"}}'
fi

// MCP v1 (Aktuell)
{
  "jsonrpc": "2.0",
  "method": "tools/list",
  "id": 1
}

// MCP v2 (Kommend)
{
  "jsonrpc": "2.0",
  "method": "tools/list",
  "id": 1,
  "context": {
    "session_id": "sess_abc123",  // Explizite Kontextübergabe
    "capabilities": ["streaming", "batch"],
    "auth_token": "token_here"
  }
}

{
  "extensions": [
    {
      "name": "n8n-advanced",
      "version": "2.0.0",
      "capabilities": [
        "workflow-versioning",
        "execution-streaming",
        "credential-validation"
      ]
    }
  ]
}

// Langlaufenden Workflow initiieren
{
  "jsonrpc": "2.0",
  "method": "tasks/create",
  "params": {
    "tool": "n8n:execute_workflow",
    "arguments": { "workflow_id": "long-running-etl" },
    "timeout": 3600  // 1 Stunde
  },
  "id": 1
}

// Antwort
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "task_id": "task_789",
    "status": "pending",
    "estimated_completion": "2026-07-28T15:30:00Z"
  }
}

// Status abfragen
{
  "jsonrpc": "2.0",
  "method": "tasks/get",
  "params": { "task_id": "task_789" },
  "id": 2
}

# n8n-mcp-app.yml
app:
  name: "n8n-enterprise"
  version: "1.0.0"
  description: "Enterprise-Workflow-Automatisierung"
  
  tools:
    - name: "create_workflow"
      description: "Neuen Workflow erstellen"
      input_schema: {...}
      
    - name: "execute_workflow"
      description: "Vorhandenen Workflow ausführen"
      input_schema: {...}
      
  resources:
    - uri: "n8n://workflows"
      mimeType: "application/json"
      description: "Liste verfügbarer Workflows"
      
    - uri: "n8n://executions/{id}"
      mimeType: "application/json"
      description: "Ausführungsdetails"
      
  prompts:
    - name: "workflow_best_practices"
      description: "Richtlinien für robuste Workflow-Erstellung"
      content: "Beim Erstellen von Workflows immer Fehlerbehandlung einbeziehen..."

{
  "security": {
    "oauth2": {
      "authorization_url": "https://n8n.example.com/oauth/authorize",
      "token_url": "https://n8n.example.com/oauth/token",
      "scopes": [
        "workflows:read",
        "workflows:write",
        "executions:read",
        "executions:execute"
      ]
    }
  }
}

{
  "inputSchema": {
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "type": "object",
    "properties": {
      "workflow_id": {
        "type": "string",
        "pattern": "^[a-z0-9_-]+$"
      },
      "data": {
        "type": "object",
        "unevaluatedProperties": false
      }
    },
    "if": {
      "properties": { "priority": { "const": "critical" } }
    },
    "then": {
      "required": ["escalation_contact"]
    }
  }
}

N8N_MCP_PROTOCOL_VERSION=2

KI-Agent (Claude) → MCP → n8n Workflows

Morgenroutine:
1. Agent erhält Alarm: "Täglicher Compliance-Bericht fällig in 2 Stunden"
2. Agent fragt MCP: "Liste verfügbare Compliance-Datenquellen"
3. Agent entdeckt: Core Banking, Trading, KYC, AML Workflows
4. Agent erstellt Bericht-Workflow über create_workflow-Tool
5. Workflow führt Daten aus allen Systemen zusammen
6. Agent validiert Ausgaben gegen regulatorische Vorlagen
7. Agent reicht über sicheren Kanal ein, protokolliert Abschluss

// KI-Agent-Logik
async function optimizePricing() {
  // Aktuellen Preis-Workflow abrufen
  const workflows = await mcpClient.call('list_workflows', {
    tag: 'pricing'
  });
  
  // Wettbewerberdaten abrufen
  const competitorPrices = await fetchCompetitorData();
  
  // Optimale Strategie bestimmen
  const strategy = await analyzeOptimalStrategy(competitorPrices);
  
  // Preis-Workflow aktualisieren
  await mcpClient.call('update_workflow', {
    workflow_id: workflows[0].id,
    nodes: [
      // Dynamische Preisregeln basierend auf aktuellem Markt
    ]
  });
  
  // Aktualisierte Preisgestaltung ausführen
  await mcpClient.call('execute_workflow', {
    workflow_id: workflows[0].id
  });
}

Patientenentlassung → KI-Agent → MCP → n8n

1. Entlassungsereignis löst MCP-Workflow aus
2. Agent bewertet Patientenrisikoprofil
3. Agent plant Nachsorgetermine
4. Agent organisiert häusliche Pflege falls erforderlich
5. Agent sendet Medikamentenerinnerungen
6. Agent überwacht verpasste Termine
7. Agent eskaliert Hochrisikofälle

#!/bin/bash
# benchmark-mcp.sh

N8N_URL="http://localhost:5679"
TOKEN="your-token"

# Workflow-Erkennung testen
echo "Teste Workflow-Erkennung..."
time curl -s -X POST $N8N_URL/mcp \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"jsonrpc":"2.0","method":"tools/list","id":1}' | jq '.result.tools | length'

# Workflow-Ausführungslatenz testen
echo "Teste Ausführungslatenz..."
for i in {1..100}; do
  curl -s -X POST $N8N_URL/webhook/test \
    -d '{"test": true}' &
done
wait
echo "100 parallele Anfragen abgeschlossen"

# Speichernutzung
echo "Speichernutzung:"
docker stats n8n --no-stream --format "table {{.MemUsage}}"

// MCP-Client mit Pooling
const { Pool } = require('mcp-client-pool');

const mcpPool = new Pool({
  maxConnections: 20,
  minConnections: 5,
  connectionTimeout: 5000,
  idleTimeout: 30000,
  serverUrl: 'http://n8n:5679/mcp',
  authToken: process.env.MCP_TOKEN
});

// Verwendung
const client = await mcpPool.acquire();
try {
  const result = await client.call('execute_workflow', {...});
} finally {
  await mcpPool.release(client);
}

const NodeCache = require('node-cache');
const workflowCache = new NodeCache({ stdTTL: 300 }); // 5 Minuten

async function getWorkflow(id) {
  let workflow = workflowCache.get(id);
  if (!workflow) {
    workflow = await mcpClient.call('get_workflow', { workflow_id: id });
    workflowCache.set(id, workflow);
  }
  return workflow;
}

// Statt 100 individueller Aufrufe
const promises = ids.map(id => mcpClient.call('get_execution_status', { execution_id: id }));
const results = await Promise.all(promises);

// MCP v2 wird native Batch-Unterstützung bieten:
const results = await mcpClient.call('batch', {
  operations: ids.map(id => ({
    method: 'get_execution_status',
    params: { execution_id: id }
  }))
});

-- Indizes für MCP-Abfragen hinzufügen
CREATE INDEX CONCURRENTLY idx_executions_mcp ON execution_entity(workflowId, status, startedAt);
CREATE INDEX CONCURRENTLY idx_workflows_mcp ON workflow_entity(updatedAt, active);

-- Ausführungs-Logs partitionieren
CREATE TABLE execution_entity_partitioned (
  LIKE execution_entity INCLUDING ALL
) PARTITION BY RANGE (startedAt);

-- Monatliche Partitionen erstellen
CREATE TABLE execution_entity_y2026m06 PARTITION OF execution_entity_partitioned
  FOR VALUES FROM ('2026-06-01') TO ('2026-07-01');

# docker-compose.scale.yml
version: '3.8'
services:
  n8n-mcp:
    deploy:
      replicas: 2
      resources:
        limits:
          memory: 2G
          cpus: '1.0'

  n8n-worker:
    deploy:
      replicas: 10
      resources:
        limits:
          memory: 4G
          cpus: '2.0'

// mcp-load-test.js
import http from 'k6/http';
import { check } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 10 },
    { duration: '5m', target: 50 },
    { duration: '10m', target: 100 },
    { duration: '5m', target: 200 },
    { duration: '2m', target: 0 },
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],
    http_req_failed: ['rate<0.01'],
  },
};

export default function () {
  const payload = JSON.stringify({
    jsonrpc: '2.0',
    method: 'tools/call',
    params: {
      name: 'execute_workflow',
      arguments: {
        workflow_id: __ENV.WORKFLOW_ID,
        data: { test: true }
      }
    },
    id: 1
  });

  const res = http.post('http://n8n:5679/mcp', payload, {
    headers: { 
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${__ENV.MCP_TOKEN}`
    },
  });

  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });
}

k6 run --env WORKFLOW_ID=12345 --env MCP_TOKEN=secret mcp-load-test.js

# Prüfen, ob MCP-Server läuft
curl http://localhost:5679/mcp/health

# Port-Binding überprüfen
netstat -tlnp | grep 5679

# Firewall-Regeln prüfen
sudo iptables -L | grep 5679

# Mit ausführlicher Ausgabe testen
curl -v -X POST http://n8n:5679/mcp \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"jsonrpc":"2.0","method":"tools/list","id":1}'

# Token in n8n-Logs prüfen
docker logs n8n | grep -i "mcp.*auth"

# Ausführungsstatus in n8n prüfen
docker exec n8n n8n list:executions --status=running

# n8n-Worker-Prozesse überwachen
docker top n8n

# Datenbankverbindungs-Pool prüfen
docker exec n8n n8n db:status

# Speicher über Zeit überwachen
docker stats n8n --no-stream

# Auf Speicherlecks in Logs prüfen
docker logs n8n | grep -i "memory\|heap"

# Node.js-Speicher profilen
docker exec n8n kill -USR1 1  # Heap-Dump generieren

N8N_LOG_LEVEL=debug
N8N_MCP_LOG_LEVEL=debug
N8N_LOG_OUTPUT=console

docker logs -f n8n | jq 'select(.module == "mcp")'

Benutzer: "Erstelle einen Workflow, der Kundensentiment über alle Social-Channels 
hinweg überwacht, negative Erwähnungen an den Support eskaliert und unsere 
Produkt-Roadmap basierend auf wiederkehrenden Themen aktualisiert."

KI-Agent: "Ich erstelle das für Sie. Basierend auf Ihren Anforderungen entwerfe 
ich einen Workflow mit:

1. Social Listening-Knoten (Twitter, LinkedIn, Reddit)
2. Sentiment-Analyse mit Ihrem KI-Modell
3. Bedingte Weiterleitung für Sentiment < -0.5
4. Support-Ticket-Erstellung in Zendesk
5. Themen-Extraktion und Clustering
6. Monday.com-Integration für Roadmap-Updates

Der Workflow beinhaltet Fehlerbehandlung, Ratenbegrenzung und Audit-Logging. 
Geschätzte Ausführungszeit: 2-3 Minuten pro Batch."

┌──────────────┐         ┌──────────────┐         ┌──────────────┐
│  Vertriebs   │◄───────►│  n8n MCP     │◄───────►│  Support     │
│   Agent      │   MCP   │ Orchestrator │   MCP   │   Agent      │
│  (Claude)    │         │              │         │  (Claude)    │
└──────────────┘         └──────┬───────┘         └──────────────┘
                                │
                       ┌────────┴────────┐
                       │  Operations    │
                       │   Agent        │
                       │  (OpenClaw)    │
                       └─────────────────┘

// Zukünftiger n8n-Knoten: Auto-Optimizer
{
  "type": "n8n-nodes-base.autoOptimizer",
  "name": "Leistungsoptimierer",
  "configuration": {
    "targetMetric": "execution_time",
    "optimizationStrategy": "ml_reinforcement_learning",
    "constraints": [
      "maintain_data_integrity",
      "respect_rate_limits",
      "minimize_cost"
    ]
  }
}