┌─────────────────────────────────────────────────────────────────────────────────┐
│          Traditionelle n8n-Entwicklung vs. n8n-mcp KI-gestützte Entwicklung      │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Traditioneller Ansatz (Pre-MCP):                 KI-gestützter Ansatz:        │
│   ┌─────────────────────────────────┐              ┌─────────────────────────┐ │
│   │  1. n8n-Editor öffnen           │              │  1. Claude/Cursor öffnen│ │
│   │  2. Knoten aus Palette ziehen     │              │  2. Workflow beschreiben│ │
│   │  3. Jeden Knoten einzeln          │              │     "Erstelle einen Workflow│ │
│   │     konfigurieren                 │              │     der Datenbank-Änderungen│ │
│   │  4. Knoten manuell verbinden    │              │     überwacht, an Slack │ │
│   │  5. Ausdrücke schreiben           │              │     postet und Fehler   │ │
│   │  6. Testen und Debuggen           │              │     behandelt"          │ │
│   │  7. Exportieren und deployen      │              │  3. KI generiert        │ │
│   │                                   │              │     kompletten Workflow │ │
│   │  Zeit: 2-4 Stunden                │              │  4. Überprüfen und      │ │
│   │  Fähigkeit: Hoch (Ausdrücke,      │              │     verfeinern          │ │
│   │         Knoten-Konfiguration)    │              │  5. Deployen            │ │
│   │                                   │              │                         │ │
│   └─────────────────────────────────┘              │  Zeit: 10-20 Minuten   │ │
│                                                    │  Fähigkeit: Konversationell│ │
│   Ergebnis: Technischer Engpass                   └─────────────────────────┘ │
│           für Nicht-Experten                    Ergebnis: Demokratisierte      │
│                                                          Automatisierung      │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    MCP-Architektur-Übersicht                                    │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   ┌──────────────────────┐                    ┌──────────────────────┐         │
│   │     MCP Host         │◄──────────────────►│    MCP Server        │         │
│   │  (KI-Anwendung)      │    stdio / HTTP    │   (Tool-Anbieter)    │         │
│   │                      │    (bidirektional) │                      │         │
│   │  • Claude Desktop    │                    │  • n8n-mcp           │         │
│   │  • Claude Code       │                    │  • Datenbank-Server  │         │
│   │  • Cursor            │                    │  • GitHub MCP        │         │
│   │  • Windsurf          │                    │  • Slack MCP         │         │
│   └──────────────────────┘                    └──────────────────────┘         │
│                                                                                 │
│   Kommunikationsfluss:                                                          │
│   ┌────────────────────────────────────────────────────────────────────────┐ │
│   │  1. Host entdeckt verfügbare Tools/Resources vom Server                 │ │
│   │  2. Host sendet Tool-Aufruf-Anfragen mit Parametern                    │ │
│   │  3. Server führt Operation aus und gibt Ergebnisse zurück             │ │
│   │  4. Host integriert Ergebnisse in KI-Kontext                            │ │
│   └────────────────────────────────────────────────────────────────────────┘ │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    n8n-mcp Systemarchitektur                                  │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Layer 1: KI-Coding-Assistenten (MCP Hosts)                                   │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │
│   │ Claude Code  │  │   Cursor     │  │  Windsurf    │  │Claude Desktop│       │
│   │              │  │              │  │              │  │              │       │
│   │ • Terminal   │  │ • IDE-Editor │  │ • KI-Native  │  │ • Chat-App   │       │
│   │ • Dateisys   │  │ • Code-Gen   │  │ • Code-Edit  │  │ • Desktop    │       │
│   └──────┬───────┘  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘       │
│          │                 │                 │                 │               │
│          └─────────────────┴─────────────────┴─────────────────┘               │
│                                    │                                            │
│                                    ▼                                            │
│   Layer 2: Model Context Protocol (stdio/HTTP-Transport)                       │
│   ┌────────────────────────────────────────────────────────────────────────┐  │
│   │  • JSON-RPC 2.0 Nachrichtenformat                                         │  │
│   │  • Tool/Resource-Discovery                                              │  │
│   │  • Bidirektionales Streaming                                            │  │
│   │  • Authentifizierung: API-Schlüssel, OAuth oder Bearer-Token           │  │
│   └────────────────────────────────────────────────────────────────────────┘  │
│                                    │                                            │
│                                    ▼                                            │
│   Layer 3: n8n-mcp Server                                                       │
│   ┌────────────────────────────────────────────────────────────────────────┐  │
│   │  Verfügbare Tools:                                                        │  │
│   │  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────────────┐   │  │
│   │  │ create_workflow │ │ update_workflow │ │ get_workflow            │   │  │
│   │  │                 │ │                 │ │                         │   │  │
│   │  │ list_workflows  │ │ delete_workflow │ │ duplicate_workflow      │   │  │
│   │  └─────────────────┘ └─────────────────┘ └─────────────────────────┘   │  │
│   │  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────────────┐   │  │
│   │  │ execute_workflow│ │ activate_workflow│ │ deactivate_workflow    │   │  │
│   │  │                 │ │                 │ │                         │   │  │
│   │  │ get_execution   │ │ search_workflows│ │ export_workflow         │   │  │
│   │  └─────────────────┘ └─────────────────┘ └─────────────────────────┘   │  │
│   │                                                                         │  │
│   │  Verfügbare Resources:                                                  │  │
│   │  • workflow://{id} — Workflow-JSON lesen                               │  │
│   │  • execution://{id} — Ausführungsergebnisse lesen                      │  │
│   │  • node-types — Verfügbare n8n-Knotentypen auflisten                    │  │
│   └────────────────────────────────────────────────────────────────────────┘  │
│                                    │                                            │
│                                    ▼                                            │
│   Layer 4: n8n REST API Integration                                             │
│   ┌────────────────────────────────────────────────────────────────────────┐  │
│   │  • n8n-Instanz-URL-Konfiguration                                        │  │
│   │  • API-Schlüssel-Authentifizierung                                      │  │
│   │  • Webhook-Trigger-Unterstützung                                        │  │
│   │  • Fehlerbehandlung und Retry-Logik                                     │  │
│   └────────────────────────────────────────────────────────────────────────┘  │
│                                    │                                            │
│                                    ▼                                            │
│   Layer 5: Ziel-n8n-Instanz                                                     │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │
│   │   n8n        │  │   n8n        │  │   n8n        │  │   n8n        │       │
│   │  Cloud       │  │ Self-Hosted  │  │ Enterprise   │  │ Embedded     │       │
│   │              │  │              │  │              │  │              │       │
│   └──────────────┘  └──────────────┘  └──────────────┘  └──────────────┘       │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

# Setzen Sie die Umgebungsvariable für die API-Authentifizierung
export N8N_API_KEY="your-secure-api-key-here"

# Oder konfigurieren Sie in Ihrer docker-compose.yml
environment:
  - N8N_API_KEY=${N8N_API_KEY}

# Globale Installation (empfohlen für Claude Desktop)
npm install -g @n8n/mcp-server

# Oder verwenden Sie npx (keine Installation erforderlich)
npx -y @n8n/mcp-server

# Lokale Installation (für Cursor/Windsurf-Projekte)
cd your-project
npm install --save-dev @n8n/mcp-server

# Konfigurationsverzeichnis erstellen, falls es nicht existiert
mkdir -p ~/.config/claude-code

# Die MCP-Einstellungsdatei bearbeiten
nano ~/.config/claude-code/settings.json

# Konfigurationspfad
%APPDATA%\Claude\settings.json

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "https://your-n8n-instance.n8n.cloud",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "http://localhost:5678",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

# Claude Code starten
claude

# In der Claude Code-Sitzung, überprüfen Sie, ob MCP-Tools verfügbar sind
/mcp

# Sie sollten n8n-Tools aufgelistet sehen:
# - create_workflow
# - update_workflow
# - get_workflow
# - list_workflows
# - execute_workflow
# - etc.

User: Erstelle einen n8n-Workflow, der einen Webhook-Endpunkt überwacht,
      den Payload validiert und eine Benachrichtigung an Slack sendet,
      wenn die Daten ein Fehler-Flag enthalten.

Claude: Ich erstelle diesen Webhook-Überwachungsworkflow für Sie. Lassen Sie mich
        ihn mit ordnungsgemäßer Validierung und Slack-Benachrichtigung erstellen.

[Claude verwendet n8n-mcp create_workflow Tool]

Claude: ✅ Workflow "Webhook-Überwachung mit Slack-Alerts" erstellt (ID: 1234)

   Der Workflow enthält:
   • Webhook-Trigger-Knoten, der auf /webhook/monitor lauscht
   • IF-Knoten zur Validierung der Payload-Struktur
   • Slack-Nachrichten-Knoten für Fehlerbenachrichtigungen
   • Fehlerbehandlung mit automatischen Wiederholungsversuchen
   
   Webhook-URL: https://your-instance.n8n.cloud/webhook/monitor
   
   Möchten Sie:
   1. Den Workflow jetzt aktivieren?
   2. Zusätzliche Validierungsregeln hinzufügen?
   3. Andere Benachrichtigungskanäle konfigurieren?

User: Aktiviere ihn und zeige mir, wie ich ihn testen kann.

Claude: [Verwendet activate_workflow und erklärt den Testprozess]

# Bitten Sie Claude, einen bestehenden Workflow zu analysieren
claude

User: Analysiere Workflow-ID 5678 und schlage Optimierungen für die Fehlerbehandlung vor.

Claude: [Verwendet get_workflow, um die JSON zu lesen, analysiert sie, schlägt Verbesserungen vor]

Claude: Ich habe mehrere Bereiche für Verbesserungen gefunden:
   • Keine Fehlerbehandlung am HTTP-Request-Knoten (Zeile 45)
   • Fehlende Retry-Logik für externe API-Aufrufe
   • Keine Benachrichtigung bei Workflow-Fehlern
   
   Sollen ich den Workflow mit diesen Verbesserungen refactoren?

User: Ja, implementiere alle diese Verbesserungen.

Claude: [Verwendet update_workflow, um Änderungen anzuwenden]

# Erstellen Sie mehrere verwandte Workflows
User: Erstelle drei Workflows für meine Datenpipeline:
   1. Extrahiere Daten stündlich aus PostgreSQL
   2. Transformiere und validiere die Daten
   3. Lade in das Data Warehouse
   
   Sie sollten verbunden sein, sodass Workflow 2 nach Abschluss von 1 auslöst.

Claude: [Erstellt alle drei Workflows mit ordnungsgemäßen Verbindungen und Fehlerbehandlung]

Cursor-Menü → Einstellungen → Cursor-Einstellungen → MCP

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "https://your-n8n-instance.n8n.cloud",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

{
  "servers": [
    {
      "name": "n8n",
      "command": "npx -y @n8n/mcp-server",
      "env": {
        "N8N_HOST": "${N8N_HOST}",
        "N8N_API_KEY": "${N8N_API_KEY}"
      }
    }
  ]
}

N8N_HOST=https://your-n8n-instance.n8n.cloud
N8N_API_KEY=n8n_api_your_api_key_here

You: @n8n Erstelle einen Workflow, der sich mit meinem GitHub-Repository verbindet,
      nach neuen Issues sucht und eine Aufgabe in meiner Notion-Datenbank
      mit den Issue-Details erstellt.

Cursor: Ich erstelle einen GitHub-zu-Notion-Integrations-Workflow für Sie.

[Cursor ruft n8n-mcp-Tools über die Chat-Oberfläche auf]

Cursor: ✅ Workflow "GitHub Issues to Notion" erstellt

   Komponenten:
   • GitHub Trigger: Prüft alle 5 Minuten auf neue Issues
   • Set-Knoten: Formatiert Issue-Daten für Notion
   • Notion-Knoten: Erstellt Datenbankeintrag
   • Fehlerbehandlung: Benachrichtigt bei Fehlern
   
   Erforderliche Anmeldedaten:
   • GitHub OAuth (nicht konfiguriert)
   • Notion Integration Token (nicht konfiguriert)
   
   Soll ich Ihnen bei der Einrichtung dieser Anmeldedaten helfen?

You: @n8n Erstelle mir einen kompletten E-Commerce-Bestellabwicklungs-Workflow, der:
   1. Webhook von Shopify bei neuen Bestellungen empfängt
   2. Bestand in PostgreSQL validiert
   3. Versandkosten über ShipEngine API berechnet
   4. Rechnung in QuickBooks erstellt
   5. Bestätigungsmail über SendGrid sendet
   6. Fehler bei jedem Schritt mit Slack-Benachrichtigungen behandelt

Cursor Agent: [Arbeitet 2-3 Minuten autonom]
   • Webhook-Endpunkt erstellen
   • Datenbankabfrage-Knoten einrichten
   • API-Integrationen konfigurieren
   • Fehlerbehandlungs-Zweige hinzufügen
   • Konnektivität testen

Cursor: ✅ Kompletter E-Commerce-Workflow mit 12 Knoten erstellt!
   
   📊 Workflow-Zusammenfassung:
   • 1 Webhook-Trigger
   • 2 Datenbankoperationen
   • 3 API-Integrationen
   • 4 E-Mail-Vorlagen
   • 2 Fehlerbehandlungs-Zweige
   
   Alle Knoten mit ordnungsgemäßen Anmeldedaten konfiguriert.
   Bereit zur Aktivierung, wenn Sie es sind.

You: @n8n Zeige mir Workflow-ID 7890

Cursor: [Zeigt Workflow-JSON inline an]

   Hier ist der Webhook-Überwachungs-Workflow:
   
   ```json
   {
     "name": "Webhook überwachen",
     "nodes": [
       {
         "type": "n8n-nodes-base.webhook",
         "name": "Webhook",
         ...
       }
     ]
   }

**Kontextbewusste Workflow-Generierung:**

Wenn Sie an einem Projekt mit bestehendem Code arbeiten, kann Cursor Workflows erstellen, die Ihren Mustern entsprechen:

---

## Windsurf-Integration

Windsurf ist der neueste KI-gestützte IDE mit tiefen agentischen Fähigkeiten, entwickelt für autonome Softwareentwicklung. Seine Cascade-Funktion ermöglicht mehrstufigen Workflow-Aufbau mit n8n-mcp.

### Konfiguration

**Schritt 1: Windsurf-Einstellungen öffnen**

**Schritt 2: n8n-mcp konfigurieren**

Fügen Sie Ihrer Windsurf-MCP-Konfiguration hinzu:

```json
{
  "mcpServers": {
    "n8n": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "https://your-n8n-instance.n8n.cloud",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

You: @n8n Erstelle einen umfassenden Marketing-Automatisierungs-Workflow, der:
   1. Google Sheets auf neue Leads überwacht
   2. Leads mit Clearbit-Daten anreichert
   3. Leads basierend auf firmografischen Kriterien bewertet
   4. Heiße Leads an Salesforce weiterleitet
   5. Warme Leads zu Mailchimp-Nurturing-Sequenz hinzufügt
   6. Alles zu Airtable für Berichterstattung protokolliert

Windsurf Cascade: 
   🔄 Schritt 1/6: Google Sheets-Trigger erstellen...
   ✅ Google Sheets-Trigger konfiguriert
   
   🔄 Schritt 2/6: Clearbit-Anreicherung einrichten...
   ✅ Clearbit-API-Integration hinzugefügt
   
   🔄 Schritt 3/6: Lead-Scoring-Logik erstellen...
   ✅ IF-Knoten für Bewertungskriterien konfiguriert
   
   🔄 Schritt 4/6: Salesforce-Routing konfigurieren...
   ✅ Salesforce-Knoten mit Feld-Mapping
   
   🔄 Schritt 5/6: Mailchimp-Sequenz einrichten...
   ✅ Mailchimp-Automatisierungs-Trigger konfiguriert
   
   🔄 Schritt 6/6: Airtable-Logging hinzufügen...
   ✅ Airtable-Logging mit Fehlerbehandlung
   
✅ Kompletter Marketing-Automatisierungs-Workflow erstellt!

   📈 Workflow-Statistiken:
   • 8 Knoten insgesamt
   • 3 externe APIs integriert
   • 2 bedingte Verzweigungen
   • 100% Fehlerabdeckung
   
   Geschätzte Zeiteinsparung: 15 Stunden/Woche

You: @n8n Hier ist eine Spezifikation für meinen Datensynchronisations-Workflow:

   SPEZIFIKATION: Kundendaten-Synchronisation
   
   Trigger: Stündlich via Cron
   Quelle: PostgreSQL customers table (last_modified > ${lastRun})
   Transformation:
     - Telefonnummern normalisieren
     - E-Mail-Format validieren
     - full_name in first_name, last_name aufteilen
   Ziel: HubSpot Contacts API
   Fehlerbehandlung: 
     - 3 Versuche mit exponentiellem Backoff
     - Slack #data-ops bei Fehlern benachrichtigen
     - Alle Fehler in Fehlerverfolgungstabelle protokollieren
   
   Bauen Sie dies genau nach Spezifikation.

Windsurf: [Folgt Spezifikation präzise, stellt klärende Fragen wo nötig,
           implementiert kompletten Workflow entsprechend den Anforderungen]

You: @n8n Aktualisiere den Workflow, den wir gestern erstellt haben, um
      Zendesk-Integration für Support-Tickets hinzuzufügen.

Windsurf: [Erinnert sich an vorherigen Workflow-Kontext, ruft ihn ab,
           fügt Zendesk-Knoten mit ordnungsgemäßem Feld-Mapping hinzu]

# Claude Desktop-Konfiguration bearbeiten
nano ~/Library/Application\ Support/Claude/config.json

# Konfiguration bearbeiten unter
%APPDATA%\Claude\config.json

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "https://your-n8n-instance.n8n.cloud",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

Erstelle einen Support-Ticket-Automatisierungs-Workflow, der:
1. Webhooks von Zendesk bei neuen Tickets empfängt
2. KI verwendet, um Dringlichkeit zu klassifizieren (Kritisch/Hoch/Mittel/Niedrig)
3. Kundenplan in der Datenbank nachschlägt (Free/Pro/Enterprise)
4. Kritisch + Enterprise an Senior-Support-Slack weiterleitet
5. Hoch + Pro/Enterprise an Standard-Support weiterleitet
6. Jira-Issue für Bugs erstellt, Feature-Request in Productboard
7. Sendet Auto-Response-E-Mail über SendGrid
8. Protokolliert alles mit Ausführungs-Metadaten

{
  "name": "Intelligent Support Ticket Routing",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "zendesk-ticket-webhook",
        "responseMode": "responseNode"
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 300],
      "webhookId": "zendesk-incoming",
      "name": "Zendesk Webhook"
    },
    {
      "parameters": {
        "jsCode": "// AI Classification Logic\nconst ticket = $json.body.ticket;\nconst subject = ticket.subject.toLowerCase();\nconst description = ticket.description.toLowerCase();\n\nlet urgency = 'Low';\nconst criticalKeywords = ['outage', 'down', 'crash', 'security', 'breach', 'urgent'];\nconst highKeywords = ['broken', 'error', 'not working', 'bug', 'issue'];\n\nif (criticalKeywords.some(k => subject.includes(k) || description.includes(k))) {\n  urgency = 'Critical';\n} else if (highKeywords.some(k => subject.includes(k) || description.includes(k))) {\n  urgency = 'High';\n} else if (ticket.priority === 'urgent') {\n  urgency = 'Critical';\n}\n\nreturn [{\n  json: {\n    ...$json,\n    urgency,\n    customer_id: ticket.requester.external_id,\n    ticket_id: ticket.id,\n    subject: ticket.subject\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [450, 300],
      "name": "AI Urgency Classifier"
    },
    {
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT plan_type, account_manager FROM customers WHERE id = $1",
        "parameters": ["={{ $json.customer_id }}"]
      },
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2,
      "position": [650, 300],
      "name": "Lookup Customer Plan",
      "credentials": {
        "postgres": {
          "id": "cred-postgres-prod",
          "name": "Production DB"
        }
      }
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict"
          },
          "conditions": [
            {
              "id": "critical-enterprise",
              "leftValue": "={{ $json.urgency + '-' + $json.plan_type }}",
              "rightValue": "Critical-Enterprise",
              "operator": {
                "type": "string",
                "operation": "equals"
              }
            },
            {
              "id": "high-tier",
              "leftValue": "={{ $json.urgency }}",
              "rightValue": "High",
              "operator": {
                "type": "string",
                "operation": "equals"
              }
            },
            {
              "id": "enterprise-any",
              "leftValue": "={{ $json.plan_type }}",
              "rightValue": "Enterprise",
              "operator": {
                "type": "string",
                "operation": "equals"
              }
            }
          ],
          "combinator": "or"
        }
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2,
      "position": [850, 300],
      "name": "Priority Router"
    },
    {
      "parameters": {
        "channel": "#support-senior",
        "text": "🚨 *Critical Enterprise Ticket*\n*Customer:* {{ $json.customer_id }}\n*Plan:* {{ $json.plan_type }}\n*Urgency:* {{ $json.urgency }}\n*Subject:* {{ $json.subject }}\n*Ticket:* https://company.zendesk.com/agent/tickets/{{ $json.ticket_id }}",
        "blocks": [
          {
            "type": "section",
            "text": {
              "type": "mrkdwn",
              "text": "🚨 *Critical Enterprise Ticket Requires Immediate Attention*"
            }
          },
          {
            "type": "section",
            "fields": [
              {
                "type": "mrkdwn",
                "text": "*Customer:*\n{{ $json.customer_id }}"
              },
              {
                "type": "mrkdwn",
                "text": "*Plan:*\n{{ $json.plan_type }}"
              },
              {
                "type": "mrkdwn",
                "text": "*Urgency:*\n{{ $json.urgency }}"
              },
              {
                "type": "mrkdwn",
                "text": "*Account Manager:*\n{{ $json.account_manager }}"
              }
            ]
          },
          {
            "type": "actions",
            "elements": [
              {
                "type": "button",
                "text": {
                  "type": "plain_text",
                  "text": "View Ticket"
                },
                "url": "https://company.zendesk.com/agent/tickets/{{ $json.ticket_id }}"
              }
            ]
          }
        ]
      },
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [1050, 200],
      "name": "Senior Support Alert"
    },
    {
      "parameters": {
        "channel": "#support-standard",
        "text": "📋 New {{ $json.urgency }} Priority Ticket\n*Subject:* {{ $json.subject }}\n*Plan:* {{ $json.plan_type }}"
      },
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [1050, 350],
      "name": "Standard Support Alert"
    },
    {
      "parameters": {
        "resource": "issue",
        "operation": "create",
        "project": "SUP",
        "summary": "={{ $json.subject }}",
        "description": "={{ $json.body.ticket.description }}",
        "issuetype": "Bug",
        "fields": {
          "priority": "={{ $json.urgency === 'Critical' ? 'Highest' : $json.urgency === 'High' ? 'High' : 'Medium' }}",
          "labels": ["zendesk-auto", "{{ $json.plan_type }}"]
        }
      },
      "type": "n8n-nodes-base.jira",
      "typeVersion": 1,
      "position": [1250, 250],
      "name": "Create Jira Bug"
    },
    {
      "parameters": {
        "from": "[email protected]",
        "to": "={{ $json.body.ticket.requester.email }}",
        "subject": "Re: {{ $json.subject }} - We've received your request",
        "text": "Hi there,\n\nThank you for contacting support. We've received your ticket and classified it as {{ $json.urgency }} priority.\n\nExpected response time: {{ $json.plan_type === 'Enterprise' ? '1 hour' : $json.plan_type === 'Pro' ? '4 hours' : '24 hours' }}\n\nTicket reference: #{{ $json.ticket_id }}\n\nBest regards,\nSupport Team",
        "options": {
          "categories": ["Support"]
        }
      },
      "type": "n8n-nodes-base.sendGrid",
      "typeVersion": 1,
      "position": [1450, 300],
      "name": "Auto-Response Email"
    },
    {
      "parameters": {
        "operation": "insert",
        "table": "support_automation_log",
        "columns": {
          "ticket_id": "={{ $json.ticket_id }}",
          "customer_id": "={{ $json.customer_id }}",
          "urgency": "={{ $json.urgency }}",
          "plan_type": "={{ $json.plan_type }}",
          "routed_to": "={{ $json.urgency === 'Critical' && $json.plan_type === 'Enterprise' ? 'senior' : 'standard' }}",
          "jira_issue": "={{ $('Create Jira Bug').item.json.key }}",
          "email_sent": "={{ $('Auto-Response Email').item.json.success }}",
          "created_at": "={{ $now }}"
        }
      },
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2,
      "position": [1650, 300],
      "name": "Log Execution"
    }
  ],
  "connections": {
    "Zendesk Webhook": {
      "main": [[{"node": "AI Urgency Classifier", "type": "main", "index": 0}]]
    },
    "AI Urgency Classifier": {
      "main": [[{"node": "Lookup Customer Plan", "type": "main", "index": 0}]]
    },
    "Lookup Customer Plan": {
      "main": [[{"node": "Priority Router", "type": "main", "index": 0}]]
    },
    "Priority Router": {
      "main": [
        [{"node": "Senior Support Alert", "type": "main", "index": 0}],
        [{"node": "Standard Support Alert", "type": "main", "index": 0}]
      ]
    },
    "Senior Support Alert": {
      "main": [[{"node": "Create Jira Bug", "type": "main", "index": 0}]]
    },
    "Standard Support Alert": {
      "main": [[{"node": "Create Jira Bug", "type": "main", "index": 0}]]
    },
    "Create Jira Bug": {
      "main": [[{"node": "Auto-Response Email", "type": "main", "index": 0}]]
    },
    "Auto-Response Email": {
      "main": [[{"node": "Log Execution", "type": "main", "index": 0}]]
    }
  },
  "settings": {
    "executionOrder": "v1",
    "errorWorkflow": "error-handler-workflow-id"
  }
}

Baue einen ELT-Pipeline-Workflow, der:
1. Täglich um 2 Uhr morgens UTC via Cron läuft
2. Transaktionen aus PostgreSQL extrahiert (letzte 24 Stunden)
3. Benutzerereignisse aus MongoDB extrahiert (letzte 24 Stunden)
4. Wechselkurse von externer API extrahiert
5. Daten transformiert: Währung normalisieren, Gebühren berechnen, mit Benutzerdaten anreichern
6. Validiert: auf Nullwerte, Duplikate, Ausreißer prüfen
7. In Snowflake Data Warehouse lädt
8. Bei Validierungsfehler: schlechte Datensätze in Quarantäne, Daten-Team benachrichtigen
9. Bei Erfolg: Analytics Slack benachrichtigen, Airflow DAG-Status aktualisieren
10. Vollständiges Audit-Log aller Operationen führt

{
  "name": "Daily ELT Data Pipeline",
  "trigger": {
    "type": "n8n-nodes-base.cron",
    "cronExpression": "0 2 * * *",
    "timezone": "UTC"
  },
  "nodes": [
    {
      "name": "Pipeline Orchestrator",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// Calculate time window for extraction\nconst now = new Date();\nconst yesterday = new Date(now - 24 * 60 * 60 * 1000);\nconst timeWindow = {\n  start: yesterday.toISOString(),\n  end: now.toISOString(),\n  date_only: yesterday.toISOString().split('T')[0]\n};\n\nreturn [{\n  json: {\n    pipeline_id: $execution.id,\n    run_date: timeWindow.date_only,\n    extraction_window: timeWindow,\n    status: 'started',\n    started_at: now.toISOString()\n  }\n}];"
      }
    },
    {
      "name": "Extract Transactions",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT t.*, u.email, u.tier FROM transactions t JOIN users u ON t.user_id = u.id WHERE t.created_at >= $1 AND t.created_at < $2 AND t.status = 'completed'",
        "parameters": ["={{ $json.extraction_window.start }}", "={{ $json.extraction_window.end }}"]
      }
    },
    {
      "name": "Extract Events",
      "type": "n8n-nodes-base.mongoDb",
      "parameters": {
        "operation": "find",
        "collection": "user_events",
        "options": "{ \"timestamp\": { $gte: new Date('{{ $json.extraction_window.start }}'), $lt: new Date('{{ $json.extraction_window.end }}') } }"
      }
    },
    {
      "name": "Fetch Exchange Rates",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://api.exchangerate.host/latest",
        "query": {
          "base": "USD",
          "symbols": "EUR,GBP,JPY,CAD,AUD"
        },
        "options": {
          "timeout": 30000
        }
      }
    },
    {
      "name": "Transform & Enrich",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// Data transformation logic\nconst transactions = $('Extract Transactions').all()[0].json;\nconst events = $('Extract Events').all()[0].json;\nconst rates = $('Fetch Exchange Rates').all()[0].json.rates;\n\nconst enriched = transactions.map(t => {\n  const rate = rates[t.currency] || 1;\n  const usdAmount = t.amount / rate;\n  const fee = calculateFee(usdAmount, t.tier);\n  \n  return {\n    ...t,\n    usd_amount: usdAmount,\n    exchange_rate: rate,\n    fee_usd: fee,\n    net_amount: usdAmount - fee,\n    event_count: events.filter(e => e.user_id === t.user_id).length,\n    _validation_status: 'pending'\n  };\n});\n\nfunction calculateFee(amount, tier) {\n  const rates = { free: 0.029, pro: 0.019, enterprise: 0.009 };\n  return amount * (rates[tier] || rates.free);\n}\n\nreturn enriched.map(e => ({ json: e }));"
      }
    },
    {
      "name": "Data Validator",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// Validation rules\nconst records = $input.all();\nconst valid = [];\nconst invalid = [];\n\nfor (const record of records) {\n  const errors = [];\n  const r = record.json;\n  \n  // Rule 1: No null critical fields\n  if (!r.user_id || !r.amount || !r.currency) {\n    errors.push('MISSING_CRITICAL_FIELDS');\n  }\n  \n  // Rule 2: Amount range check\n  if (r.amount < 0 || r.amount > 1000000) {\n    errors.push('AMOUNT_OUT_OF_RANGE');\n  }\n  \n  // Rule 3: Duplicate check\n  const isDuplicate = valid.some(v => v.json.transaction_id === r.transaction_id);\n  if (isDuplicate) {\n    errors.push('DUPLICATE_TRANSACTION');\n  }\n  \n  // Rule 4: Outlier detection (amount > 5 std dev from mean)\n  const amounts = records.map(rec => rec.json.usd_amount);\n  const mean = amounts.reduce((a, b) => a + b, 0) / amounts.length;\n  const std = Math.sqrt(amounts.reduce((sq, n) => sq + Math.pow(n - mean, 2), 0) / amounts.length);\n  if (r.usd_amount > mean + 5 * std) {\n    errors.push('STATISTICAL_OUTLIER');\n  }\n  \n  if (errors.length > 0) {\n    invalid.push({\n      json: { ...r, _validation_errors: errors, _quarantine_reason: errors.join(', ') }\n    });\n  } else {\n    valid.push(record);\n  }\n}\n\nreturn [valid, invalid];",
        "mode": "runOnceForEachItem"
      }
    },
    {
      "name": "Load to Snowflake",
      "type": "n8n-nodes-base.snowflake",
      "parameters": {
        "operation": "insert",
        "table": "TRANSACTIONS_DAILY",
        "columns": "={{ Object.keys($json).join(', ') }}",
        "data": "={{ $json }}"
      }
    },
    {
      "name": "Quarantine Bad Records",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "insert",
        "table": "data_quality_quarantine",
        "columns": {
          "pipeline_id": "={{ $json.pipeline_id }}",
          "record_data": "={{ JSON.stringify($json) }}",
          "validation_errors": "={{ $json._validation_errors.join(', ') }}",
          "quarantine_date": "={{ $now }}"
        }
      }
    },
    {
      "name": "Data Quality Alert",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#data-quality",
        "blocks": [
          {
            "type": "header",
            "text": {
              "type": "plain_text",
              "text": "⚠️ Data Quality Alert"
            }
          },
          {
            "type": "section",
            "text": {
              "type": "mrkdwn",
              "text": "Records failed validation and were quarantined."
            }
          }
        ]
      }
    },
    {
      "name": "Pipeline Complete",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// Final status and metrics\nconst validCount = $('Load to Snowflake').all().length;\nconst invalidCount = $('Quarantine Bad Records').all().length;\nconst total = validCount + invalidCount;\n\nreturn [{\n  json: {\n    pipeline_id: $json.pipeline_id,\n    status: 'completed',\n    run_date: $json.run_date,\n    metrics: {\n      total_records: total,\n      valid_records: validCount,\n      invalid_records: invalidCount,\n      success_rate: ((validCount / total) * 100).toFixed(2) + '%'\n    },\n    completed_at: new Date().toISOString()\n  }\n}];"
      }
    },
    {
      "name": "Notify Analytics Team",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#analytics",
        "text": "✅ Daily ELT Complete\nDate: {{ $json.run_date }}\nRecords: {{ $json.metrics.total_records }}\nSuccess Rate: {{ $json.metrics.success_rate }}"
      }
    },
    {
      "name": "Audit Log",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "insert",
        "table": "pipeline_audit_log",
        "columns": {
          "pipeline_id": "={{ $json.pipeline_id }}",
          "run_date": "={{ $json.run_date }}",
          "status": "={{ $json.status }}",
          "metrics": "={{ JSON.stringify($json.metrics) }}",
          "created_at": "={{ $now }}"
        }
      }
    }
  ]
}

Erstelle einen ausgeklügelten Marketing-Automatisierungs-Workflow, der:
1. Auslöst, wenn ein Kunden seinen Warenkorb abbricht (via Shopify-Webhook)
2. Kundenlebenszeitwert (CLV) und Engagement-Score prüft
3. Für hochwertige Kunden: sofortige persönliche Kontaktaufnahme via SMS
4. Für mittelwertige Kunden: E-Mail-Sequenz (sofort + 24h + 72h)
5. Für niedrigwertige Kunden: einzelne E-Mail mit Rabattcode
6. Dynamische Produktempfehlungen basierend auf Warenkorb + Kaufhistorie enthält
7. Konversionen verfolgt und korrekter Kampagne zuordnet
8. Sequenz stoppt, wenn Kunde den Kauf abschließt
9. A/B-Tests für Betreffzeilen für E-Mail-Varianten durchführt
10. Tägliche Metriken an Marketing-Dashboard berichtet

{
  "name": "Abandoned Cart Recovery - Personalized",
  "nodes": [
    {
      "name": "Shopify Cart Abandoned",
      "type": "n8n-nodes-base.webhook",
      "parameters": {
        "httpMethod": "POST",
        "path": "cart-abandoned",
        "responseMode": "responseNode"
      }
    },
    {
      "name": "Enrich Customer Data",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT c.*, COUNT(o.id) as total_orders, COALESCE(SUM(o.total), 0) as lifetime_value, MAX(o.created_at) as last_order_date FROM customers c LEFT JOIN orders o ON o.customer_id = c.id WHERE c.id = $1 GROUP BY c.id",
        "parameters": ["={{ $json.customer_id }}"]
      }
    },
    {
      "name": "Calculate Engagement Score",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const customer = $json;\nconst daysSinceLastOrder = Math.floor((new Date() - new Date(customer.last_order_date)) / (1000 * 60 * 60 * 24));\nconst orderFrequency = customer.total_orders / Math.max(1, Math.floor(daysSinceLastOrder / 30));\n\nlet engagementScore = 0;\nengagementScore += Math.min(customer.lifetime_value / 100, 50); // Max 50 points\nengagementScore += Math.min(customer.total_orders * 5, 30); // Max 30 points\nengagementScore += orderFrequency > 1 ? 20 : orderFrequency * 10; // Max 20 points\n\nlet segment = 'low';\nif (engagementScore >= 70) segment = 'high';\nelse if (engagementScore >= 40) segment = 'medium';\n\nreturn [{\n  json: {\n    ...customer,\n    engagement_score: Math.round(engagementScore),\n    segment,\n    days_since_order: daysSinceLastOrder\n  }\n}];"
      }
    },
    {
      "name": "Segment Router",
      "type": "n8n-nodes-base.switch",
      "parameters": {
        "rules": {
          "rules": [
            { "value": "high", "output": 0 },
            { "value": "medium", "output": 1 },
            { "value": "low", "output": 2 }
          ]
        }
      }
    },
    {
      "name": "High-Value: Send SMS",
      "type": "n8n-nodes-base.twilio",
      "parameters": {
        "operation": "send",
        "to": "={{ $json.phone }}",
        "from": "+1234567890",
        "body": "Hi {{ $json.first_name }}, you left items in your cart! Complete your order now: https://shop.com/cart/{{ $json.cart_id }}?discount=VIP10"
      }
    },
    {
      "name": "High-Value: Mark VIP",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "update",
        "table": "customers",
        "columns": {
          "priority": "vip_abandoned_cart",
          "last_touch": "={{ $now }}"
        },
        "where": "id = {{ $json.id }}"
      }
    },
    {
      "name": "Medium-Value: A/B Test",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// 50/50 A/B test\nconst variant = Math.random() < 0.5 ? 'A' : 'B';\nconst subjects = {\n  A: "Don't miss out on your cart, {{ $json.first_name }}!",\n  B: "Your items are waiting (and selling fast)"\n};\n\nreturn [{\n  json: {\n    ...$json,\n    ab_variant: variant,\n    subject_line: subjects[variant]\n  }\n}];"
      }
    },
    {
      "name": "Medium: Send Email 1",
      "type": "n8n-nodes-base.sendGrid",
      "parameters": {
        "from": "[email protected]",
        "to": "={{ $json.email }}",
        "subject": "={{ $json.subject_line }}",
        "html": "<html><body><h1>Hi {{ $json.first_name }}</h1><p>You left items in your cart. <a href='https://shop.com/cart/{{ $json.cart_id }}'>Complete your order</a></p></body></html>"
      }
    },
    {
      "name": "Medium: Wait 24h",
      "type": "n8n-nodes-base.wait",
      "parameters": {
        "amount": 24,
        "unit": "hours"
      }
    },
    {
      "name": "Check Purchase Status",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT COUNT(*) as purchased FROM orders WHERE customer_id = $1 AND created_at > $2",
        "parameters": ["={{ $json.id }}", "={{ $json.last_touch }}"]
      }
    },
    {
      "name": "Still Abandoned?",
      "type": "n8n-nodes-base.if",
      "parameters": {
        "conditions": {
          "number": [
            { "value1": "={{ $json.purchased }}", "value2": 0 }
          ]
        }
      }
    },
    {
      "name": "Medium: Send Email 2",
      "type": "n8n-nodes-base.sendGrid",
      "parameters": {
        "from": "[email protected]",
        "to": "={{ $json.email }}",
        "subject": "Still thinking it over? Here's 10% off",
        "html": "<html><body><h1>Your cart misses you</h1><p>Use code COMEBACK10 for 10% off your order: <a href='https://shop.com/cart/{{ $json.cart_id }}?discount=COMEBACK10'>Complete Purchase</a></p></body></html>"
      }
    },
    {
      "name": "Low-Value: Discount Email",
      "type": "n8n-nodes-base.sendGrid",
      "parameters": {
        "from": "[email protected]",
        "to": "={{ $json.email }}",
        "subject": "Complete your order with 15% off",
        "html": "<html><body><h1>Special offer for you</h1><p>Use code SAVE15 for 15% off: <a href='https://shop.com/cart/{{ $json.cart_id }}?discount=SAVE15'>Shop Now</a></p></body></html>"
      }
    },
    {
      "name": "Track Campaign Touch",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "insert",
        "table": "marketing_touches",
        "columns": {
          "customer_id": "={{ $json.id }}",
          "campaign": "abandoned_cart_recovery",
          "segment": "={{ $json.segment }}",
          "channel": "email",
          "sent_at": "={{ $now }}"
        }
      }
    },
    {
      "name": "Daily Report",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#marketing-metrics",
        "text": "📊 Daily Cart Recovery Summary\nHigh-value SMS sent: X\nMedium-value emails: Y\nLow-value emails: Z\nConversions attributed: W"
      }
    }
  ]
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    n8n-mcp Sicherheitsarchitektur                               │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Layer 1: KI-Tool-Authentifizierung                                            │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  • Verwenden Sie dedizierte API-Schlüssel pro KI-Tool-Instanz         │  │
│   │  • Rotieren Sie Schlüssel alle 90 Tage                                │  │
│   │  • Speichern Sie Schlüssel in Umgebungsvariablen, nie in Konfig-Dateien│  │
│   │  • Verwenden Sie separate n8n-Instanzen für dev/staging/production      │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Layer 2: MCP-Server-Sicherheit                                                │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  • Führen Sie n8n-mcp in isoliertem Container aus                       │  │
│   │  • Beschränken Sie Netzwerkzugriff auf n8n-Instanz                    │  │
│   │  • Aktivieren Sie Anfragen-Logging und -Monitoring                      │  │
│   │  • Implementieren Sie Rate-Limiting (100 req/min empfohlen)           │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Layer 3: n8n API-Sicherheit                                                   │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  • Verwenden Sie API-Schlüssel mit minimalen Berechtigungen            │  │
│   │  • Aktivieren Sie IP-Allowlisting                                       │  │
│   │  • Implementieren Sie Workflow-Level-Zugriffskontrollen               │  │
│   │  • Auditieren Sie alle API-Aufrufe                                      │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Layer 4: Workflow-Sicherheit                                                  │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  • Überprüfen Sie KI-generierte Workflows vor der Aktivierung          │  │
│   │  • Implementieren Sie Credential-Vaulting (nie hartkodierte Secrets)   │  │
│   │  • Fügen Sie Fehlerbehandlung hinzu, um Datenlecks zu verhindern       │  │
│   │  • Verwenden Sie separate Anmeldedaten für dev/production             │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

# Verwenden Sie Umgebungsvariablen für Anmeldedaten
export N8N_API_KEY="n8n_api_$(cat /secure/path/to/key)"
export N8N_HOST="https://your-instance.n8n.cloud"

# Starten Sie Claude Code mit eingeschränkten Berechtigungen
claude --allow-read ./project --allow-write ./project

# Überprüfen Sie alle MCP-Tool-Aufrufe vor der Ausführung
# Claude Code wird bei destruktiven Operationen nach Bestätigung fragen

// .cursor/settings.json
{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "${N8N_HOST}",
        "N8N_API_KEY": "${N8N_API_KEY}"
      }
    }
  },
  // Bestätigungsaufforderungen aktivieren
  "mcp.confirmDestructiveOperations": true,
  "mcp.showToolCallsInChat": true
}

// .windsurf/settings.json
{
  "mcpServers": {
    "n8n": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "${N8N_HOST}",
        "N8N_API_KEY": "${N8N_API_KEY}"
      }
    }
  },
  // Sicherheitseinstellungen
  "mcp.requireConfirmation": true,
  "mcp.auditLogPath": "./logs/mcp-audit.json"
}

☐ Keine hartkodierten Anmeldedaten im Workflow-JSON
☐ Keine PII in Testdaten oder Ausdrücken
☐ Fehlerbehandlung verhindert Datenlecks
☐ API-Schlüssel verwenden geringstes Privileg
☐ Webhook-Endpunkte verwenden Authentifizierung
☐ Workflow vor Aktivierung von Mensch überprüft
☐ Rollback-Plan dokumentiert
☐ Monitoring und Alerting konfiguriert

Ziele:
• n8n-mcp mit 2-3 Power-Usern validieren
• 5-10 Beispiel-Workflows erstellen
• Interne Best Practices dokumentieren
• Sicherheitsanforderungen identifizieren

Lieferobjekte:
• Pilot-Bericht mit Metriken
• Sicherheitsüberprüfung abgeschlossen
• Erste Schulungsmaterialien
• Go/No-Go-Entscheidung für Phase 2

Ziele:
• Auf das gesamte Automatisierungsteam ausweiten
• Workflow-Bibliothek erstellen (20+ Vorlagen)
• Governance-Framework implementieren
• Team-Leads schulen

Lieferobjekte:
• Workflow-Katalog mit Dokumentation
• Governance-Richtliniendokument
• Schulungsabschluss für 20+ User
• Support-Prozess etabliert

Ziele:
• Multi-Abteilungs-Deployment
• 100+ KI-unterstützte Workflows
• Automatisierte Tests und Deployment
• Vollständige Monitoring- und Beobachtbarkeit

Lieferobjekte:
• Enterprise-Workflow-Standards
• Automatisierte CI/CD für Workflows
• Analytics-Dashboard
• ROI-Messung

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    KI-generierter Workflow-Governance                          │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Entwickler erstellt Workflow via KI                                          │
│          │                                                                      │
│          ▼                                                                      │
│   ┌─────────────────────┐                                                    │
│   │ Automatisiertes     │                                                    │
│   │ Scanning            │                                                    │
│   │ • Sicherheitsprüfung│                                                    │
│   │ • Credential-Scan   │                                                    │
│   │ • Policy-Compliance │                                                    │
│   └──────────┬──────────┘                                                    │
│              │                                                                  │
│     ┌────────┴────────┐                                                       │
│     ▼                 ▼                                                       │
│  Pass            Fail                                                         │
│     │                 │                                                       │
│     ▼                 ▼                                                       │
│ Review            Rückgabe mit                                                │
│ Queue             erforderlichen Fixes                                        │
│     │                                                                       │
│     ▼                                                                       │
│ Technischer                                                                   │
│ Review                                                                        │
│ (Senior Dev)                                                                  │
│     │                                                                       │
│     ▼                                                                       │
│   ┌─────────────────────┐                                                    │
│   │ Production Deploy   │                                                    │
│   │ • Versionskontrolle│                                                    │
│   │ • Monitoring        │                                                    │
│   │ • Rollback-Plan     │                                                    │
│   └─────────────────────┘                                                    │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    Multi-Agent-Workflow-Entwicklung                          │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Architekt-Agent (Claude Code)                                               │
│   • Entwirft Workflow-Struktur                                                │
│   • Definiert Knoten-Anforderungen                                            │
│   • Erstellt Dokumentation                                                      │
│          │                                                                      │
│          ▼                                                                      │
│   Implementierungs-Agent (Cursor)                                               │
│   • Generiert Workflow-JSON                                                     │
│   • Konfiguriert Knoten und Ausdrücke                                         │
│   • Fügt Fehlerbehandlung hinzu                                                 │
│          │                                                                      │
│          ▼                                                                      │
│   Review-Agent (Windsurf)                                                     │
│   • Validiert gegen Best Practices                                            │
│   • Schlägt Optimierungen vor                                                 │
│   • Prüft Sicherheits-Compliance                                              │
│          │                                                                      │
│          ▼                                                                      │
│   Test-Agent (Claude Code)                                                    │
│   • Erstellt Testszenarien                                                    │
│   • Führt Validierung durch                                                   │
│   • Meldet Issues                                                               │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

# Workflow-Repository-Struktur
n8n-workflows/
├── workflows/
│   ├── support-automation.json
│   ├── data-pipeline.json
│   └── marketing-campaigns/
│       ├── abandoned-cart.json
│       └── welcome-series.json
├── docs/
│   ├── support-automation.md  # KI-generierte Dokumentation
│   └── data-pipeline.md
├── tests/
│   └── workflow-validator.js
└── .cursor/
    └── mcp.json

# Workflow: Support-Ticket-Automatisierung

## Übersicht
Leitet Support-Tickets automatisch basierend auf Dringlichkeit und Kundenstufe weiter.

## Trigger
- Webhook: `/webhook/support-incoming`
- Quelle: Zendesk

## Datenfluss
[Diagramm oder Schritt-für-Schritt-Beschreibung]

## Abhängigkeiten
| Dienst | Zweck | Anmeldedaten | Besitzer |
|---------|---------|------------|-------|
| | | | |

## Fehlerbehandlung
- Retry-Richtlinie: [z.B. 3 Versuche mit exponentiellem Backoff]
- Fallback: [was passiert, wenn Workflow fehlschlägt]
- Eskalation: [wer wird benachrichtigt]

## Monitoring
- Dashboard: [Link]
- Alerting: [Slack-Kanal/PagerDuty]
- SLO: [99,9% Erfolgsrate, <5s Latenz]

## Runbook
[Schritte zur Fehlerbehebung bei häufigen Problemen]

// KI-generierte Testsuite für n8n-Workflow

describe('Support Ticket Automation', () => {
  test('Critical + Enterprise routes to senior support', async () => {
    const result = await executeWorkflow({
      ticket: {
        subject: 'URGENT: System outage',
        priority: 'urgent',
        requester: { external_id: 'ENT-123' }
      }
    });
    
    expect(result.routing).toBe('senior');
    expect(result.slack_channel).toBe('#support-senior');
  });
  
  test('Low priority + Free tier routes to standard', async () => {
    const result = await executeWorkflow({
      ticket: {
        subject: 'Feature question',
        priority: 'low',
        requester: { external_id: 'FREE-456' }
      }
    });
    
    expect(result.routing).toBe('standard');
  });
  
  test('Missing customer ID handles gracefully', async () => {
    const result = await executeWorkflow({
      ticket: {
        subject: 'Help needed',
        requester: { external_id: null }
      }
    });
    
    expect(result.error).toBeDefined();
    expect(result.error_handled).toBe(true);
  });
});

# 1. Überprüfen Sie, ob n8n-mcp installiert ist
npm list -g @n8n/mcp-server

# 2. Testen Sie MCP-Server manuell
npx @n8n/mcp-server

# 3. Überprüfen Sie Umgebungsvariablen
echo $N8N_HOST
echo $N8N_API_KEY

# 4. Überprüfen Sie n8n API-Zugänglichkeit
curl -H "X-N8N-API-KEY: $N8N_API_KEY" \
     "$N8N_HOST/api/v1/workflows"

# 5. Überprüfen Sie KI-Tool-Logs auf Fehler
# Claude Code: ~/.claude/logs/
# Cursor: View → Output → MCP

// Häufige Ursachen und Fixes:

// 1. Ungültiger Knotentyp
// Fix: Verwenden Sie korrekten Knotentyp aus n8n-Dokumentation
"type": "n8n-nodes-base.httpRequest" // Korrekt
"type": "http-request" // Falsch

// 2. Fehlende erforderliche Parameter
// Fix: Prüfen Sie Knotenschema auf erforderliche Felder
{
  "parameters": {
    "url": "={{ $json.endpoint }}", // Erforderlich
    "method": "POST", // Erforderlich
    // "headers" ist optional
  }
}

// 3. Ungültiges JSON in Ausdrücken
// Fix: Verwenden Sie korrekte JSON-Syntax
"query": "={{ JSON.stringify($json.params) }}"

// 4. Credential-Referenzfehler
// Fix: Überprüfen Sie, ob Credential-ID existiert
"credentials": {
  "slackApi": {
    "id": "valid-credential-id-here"
  }
}

# 1. Überprüfen Sie, ob Anmeldedaten in n8n existieren
n8n credential:list

# 2. Überprüfen Sie Anmeldedaten-Berechtigungen
# Stellen Sie sicher, dass API-Schlüssel erforderliche Scopes haben

# 3. Testen Sie Anmeldedaten in n8n-UI zuerst
# Manueller Test vor KI-generiertem Workflow

# 4. Aktualisieren Sie Credential-Referenz im Workflow
# KI braucht möglicherweise explizite Credential-ID

User: "Füge eine Verzögerung zwischen den E-Mail- und SMS-Knoten hinzu,
        und ändere die Verzögerung von 1 Stunde auf 30 Minuten."

KI: [Lokalisiert Workflow, identifiziert Knoten, aktualisiert Verzögerungskonfiguration,
     behält alle anderen Einstellungen bei, committet Änderung]

KI: "Ich bemerke, dass dieser HTTP-Knoten keine Fehlerbehandlung hat.
     Basierend auf der API-Dokumentation hat er eine 2%-Fehlerrate.
     Soll ich automatische Retry-Logik hinzufügen?"

KI: "Ich habe Ihre 47 Workflows analysiert. Ich habe 12 gefunden, die dieselbe
     Datenbanktabelle abfragen. Ich kann diese in eine einzelne optimierte
     Daten-Pipeline kombinieren, die API-Aufrufe um 65% reduziert.
     Möchten Sie den Vorschlag sehen?"

User: [Sprache] "Erstelle einen Workflow, der unsere API-Gesundheit alle fünf
               Minuten überwacht und das Team paget, wenn die
               Antwortzeit zwei Sekunden überschreitet."

KI: [Transkribiert, interpretiert, generiert kompletten Workflow]

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    MCP-Protokoll-Nachrichtenfluss                             │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Phase 1: Server-Discovery und Initialisierung                                 │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │                                                                         │  │
│   │  Host ────────────► Server                                               │  │
│   │        initialize                                                       │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "method": "initialize",                                        │  │
│   │          "params": {                                                    │  │
│   │            "protocolVersion": "2025-11-25",                             │  │
│   │            "capabilities": {                                            │  │
│   │              "tools": { "listChanged": true },                          │  │
│   │              "resources": { "subscribe": true }                         │  │
│   │            }                                                            │  │
│   │          }                                                              │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   │  Host ◄─────────── Server                                               │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "result": {                                                    │  │
│   │            "protocolVersion": "2025-11-25",                             │  │
│   │            "serverInfo": {                                              │  │
│   │              "name": "n8n-mcp",                                         │  │
│   │              "version": "1.0.0"                                         │  │
│   │            },                                                           │  │
│   │            "capabilities": {                                            │  │
│   │              "tools": {                                                   │  │
│   │                "create_workflow": { ... },                            │  │
│   │                "execute_workflow": { ... }                              │  │
│   │              },                                                           │  │
│   │              "resources": {                                             │  │
│   │                "workflow://{id}": { ... }                             │  │
│   │              }                                                          │  │
│   │            }                                                            │  │
│   │          }                                                              │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Phase 2: Tool-Aufruf                                                         │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │                                                                         │  │
│   │  Host ────────────► Server                                               │  │
│   │        tools/call                                                         │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "method": "tools/call",                                        │  │
│   │          "params": {                                                    │  │
│   │            "name": "create_workflow",                                   │  │
│   │            "arguments": {                                               │  │
│   │              "name": "Webhook Monitor",                                 │  │
│   │              "nodes": [...],                                              │  │
│   │              "connections": {...}                                       │  │
│   │            }                                                            │  │
│   │          },                                                             │  │
│   │          "id": 1                                                        │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   │  Host ◄─────────── Server                                               │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "result": {                                                    │  │
│   │            "content": [                                                   │  │
│   │              {                                                          │  │
│   │                "type": "text",                                          │  │
│   │                "text": "Workflow created successfully. ID: 12345"       │  │
│   │              }                                                          │  │
│   │            ],                                                           │  │
│   │            "isError": false                                             │  │
│   │          },                                                             │  │
│   │          "id": 1                                                        │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Phase 3: Resource-Zugriff                                                       │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │                                                                         │  │
│   │  Host ────────────► Server                                               │  │
│   │        resources/read                                                     │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "method": "resources/read",                                    │  │
│   │          "params": {                                                    │  │
│   │            "uri": "workflow://12345"                                    │  │
│   │          },                                                             │  │
│   │          "id": 2                                                        │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   │  Host ◄─────────── Server                                               │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "result": {                                                    │  │
│   │            "contents": [{                                                │  │
│   │              "uri": "workflow://12345",                                 │  │
│   │              "mimeType": "application/json",                            │  │
│   │              "text": "{...full workflow JSON...}"                     │  │
│   │            }]                                                           │  │
│   │          },                                                             │  │
│   │          "id": 2                                                        │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

// stdio-Transport-Eigenschaften:
// - Geringste Latenz
// - Prozess-Isolation
// - Automatische Bereinigung beim Beenden des Parents
// - Keine Netzwerk-Exposition

// Beispiel stdio-Konfiguration:
{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "transport": "stdio"  // Explizit, obwohl Standard
    }
  }
}

// SSE-Transport-Eigenschaften:
// - Netzwerk-zugänglich
// - Unterstützt mehrere gleichzeitige Clients
// - Erfordert Authentifizierung
// - Ermöglicht zentrales Logging

// Beispiel SSE-Konfiguration:
{
  "mcpServers": {
    "n8n-enterprise": {
      "url": "https://mcp-gateway.company.com/n8n",
      "transport": "sse",
      "headers": {
        "Authorization": "Bearer ${MCP_TOKEN}"
      }
    }
  }
}

// Fehlerbehandlungs-Wrapper für n8n-mcp-Aufrufe
async function callN8nMcpWithRetry(toolName, args, maxRetries = 3) {
  const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const result = await callMcpTool('n8n', toolName, args);
      
      // Überprüfe auf MCP-Level-Fehler
      if (result.isError) {
        throw new MCPError(result.content[0].text, result.errorCode);
      }
      
      return result;
      
    } catch (error) {
      const isRetryable = [
        '-32603',  // Interner Fehler (könnte transient sein)
        '1003',    // Rate limitiert
        'ECONNRESET',
        'ETIMEDOUT'
      ].includes(error.code);
      
      if (!isRetryable || attempt === maxRetries) {
        throw error;
      }
      
      // Exponentielles Backoff
      const waitTime = Math.pow(2, attempt) * 1000;
      console.log(`Versuch ${attempt} fehlgeschlagen, Wiederholung in ${waitTime}ms...`);
      await delay(waitTime);
    }
  }
}

// Statt von Grund auf neu zu bauen, verwenden Sie vorvalidierte Vorlagen
const workflowTemplates = {
  'webhook-processing': {
    nodes: ['webhook', 'code', 'if', 'slack'],
    defaultConfig: { ... }
  },
  'scheduled-etl': {
    nodes: ['cron', 'postgres', 'transform', 'snowflake'],
    defaultConfig: { ... }
  }
};

// KI füllt Spezifika aus, während bewährte Struktur beibehalten wird
function generateFromTemplate(templateName, customizations) {
  const base = workflowTemplates[templateName];
  return merge(base, customizations);
}

Statt: "Erstelle einen 50-Knoten-Workflow"

Verwenden: "Erstelle den Trigger-Knoten"
     → "Füge die Datenextraktions-Knoten hinzu"
     → "Füge Transformationslogik hinzu"
     → "Füge Output-Knoten hinzu"
     → "Verbinde alles"

Ergebnis: Schnellere Generierung, einfacheres Debugging

// Generieren Sie unabhängige Zweige parallel
const [branchA, branchB, branchC] = await Promise.all([
  generateBranch('validation'),
  generateBranch('processing'),
  generateBranch('notification')
]);

// In einen einzelnen Workflow mergen
return mergeWorkflows([branchA, branchB, branchC]);

// Vorher: Sequentielle Ausführung
const results = [];
for (const item of items) {
  const result = await processItem(item);
  results.push(result);
}

// Nachher: Batch-Verarbeitung
const batches = chunk(items, 100);
const results = await Promise.all(
  batches.map(batch => processBatch(batch))
);

// Vorher: N+1 Queries
const users = await getAllUsers();
for (const user of users) {
  const orders = await getUserOrders(user.id);  // N Queries
}

// Nachher: Einzelner JOIN-Query
const usersWithOrders = await query(`
  SELECT u.*, json_agg(o.*) as orders
  FROM users u
  LEFT JOIN orders o ON o.user_id = u.id
  WHERE u.id IN (${userIds.join(',')})
  GROUP BY u.id
`);

{
  "name": "SOX Compliance Data Change Tracking",
  "trigger": {
    "type": "n8n-nodes-base.postgresTrigger",
    "event": [
      "INSERT",
      "UPDATE",
      "DELETE"
    ],
    "schema": "public",
    "table": "financial_records"
  },
  "nodes": [
    {
      "name": "Capture Change",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const change = $json;\nconst changeType = change.__operation === 'INSERT' ? 'CREATE' : change.__operation === 'UPDATE' ? 'MODIFY' : 'DELETE';\n\nreturn [{\n  json: {\n    change_id: generateUUID(),\n    table: change.__table,\n    record_id: change.id,\n    change_type: changeType,\n    old_values: changeType === 'CREATE' ? null : change.__old,\n    new_values: changeType === 'DELETE' ? null : change.__new,\n    changed_by: change.__user,\n    changed_at: change.__timestamp,\n    requires_approval: changeType === 'DELETE' || (changeType === 'MODIFY' && change.amount !== change.__old.amount)\n  }\n}];"
      }
    },
    {
      "name": "Risk Assessment",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const change = $json;\nlet riskLevel = 'LOW';\n\n// High-risk indicators\nif (change.change_type === 'DELETE') riskLevel = 'CRITICAL';\nelse if (Math.abs(change.new_values.amount - (change.old_values?.amount || 0)) > 10000) riskLevel = 'HIGH';\nelse if (change.changed_at.getHours() < 6 || change.changed_at.getHours() > 22) riskLevel = 'MEDIUM';\n\nreturn [{\n  json: {\n    ...change,\n    risk_level: riskLevel,\n    auto_approved: riskLevel === 'LOW' && change.change_type !== 'DELETE'\n  }\n}];"
      }
    },
    {
      "name": "Route by Risk",
      "type": "n8n-nodes-base.switch",
      "parameters": {
        "rules": {
          "rules": [
            { "value": "CRITICAL", "output": 0 },
            { "value": "HIGH", "output": 1 },
            { "value": "MEDIUM", "output": 2 },
            { "value": "LOW", "output": 3 }
          ]
        }
      }
    },
    {
      "name": "Critical Alert",
      "type": "n8n-nodes-base.pagerduty",
      "parameters": {
        "operation": "create",
        "incident": {
          "title": "CRITICAL: Financial Record Deleted",
          "service": "compliance",
          "urgency": "high"
        }
      }
    },
    {
      "name": "Require Approval",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#compliance-approvals",
        "blocks": [
          {
            "type": "section",
            "text": { "type": "mrkdwn", "text": "Approval Required" }
          }
        ]
      }
    },
    {
      "name": "Auto-Log",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "insert",
        "table": "sox_audit_log",
        "columns": { /* ... */ }
      }
    }
  ]
}

{
  "name": "IoT Predictive Maintenance",
  "trigger": {
    "type": "n8n-nodes-base.mqtt",
    "topics": ["sensors/+/telemetry"],
    "qos": 1
  },
  "nodes": [
    {
      "name": "Parse Telemetry",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const payload = JSON.parse($json.payload);\nconst sensorId = $json.topic.split('/')[1];\n\nreturn [{\n  json: {\n    sensor_id: sensorId,\n    temperature: payload.temp,\n    vibration: payload.vib,\n    pressure: payload.pressure,\n    timestamp: payload.ts,\n    facility: payload.facility_id,\n    equipment_type: payload.equipment_type\n  }\n}];"
      }
    },
    {
      "name": "Anomaly Detection",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://ml-api.company.com/predict",
        "method": "POST",
        "body": {
          "sensor_data": "={{ $json }}"
        }
      }
    },
    {
      "name": "Check Thresholds",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const reading = $json;\nconst thresholds = {\n  temperature: { warn: 80, critical: 95 },\n  vibration: { warn: 5, critical: 10 },\n  pressure: { warn: 150, critical: 200 }\n};\n\nconst alerts = [];\nfor (const [metric, value] of Object.entries(reading)) {\n  if (thresholds[metric]) {\n    if (value >= thresholds[metric].critical) {\n      alerts.push({ metric, level: 'CRITICAL', value });\n    } else if (value >= thresholds[metric].warn) {\n      alerts.push({ metric, level: 'WARNING', value });\n    }\n  }\n}\n\nreturn [{\n  json: {\n    ...reading,\n    alerts,\n    requires_action: alerts.some(a => a.level === 'CRITICAL')\n  }\n}];"
      }
    },
    {
      "name": "Maintenance Prediction",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT AVG(days_to_failure) as avg_days FROM maintenance_history WHERE equipment_type = $1 AND sensor_readings \u003c@ $2::jsonb",
        "parameters": ["={{ $json.equipment_type }}", "={{ JSON.stringify({temp: $json.temperature, vib: $json.vibration}) }}"]
      }
    },
    {
      "name": "Create Work Order",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://cmms.company.com/api/workorders",
        "method": "POST",
        "body": {
          "equipment_id": "={{ $json.sensor_id }}",
          "priority": "={{ $json.alerts[0].level }}",
          "predicted_failure": "={{ $json.avg_days }} days",
          "description": "AI-predicted maintenance required"
        }
      }
    }
  ]
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    Workflow-Migrations-Bewertung                               │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Schritt 1: Inventarisierung                                                  │
│   • Exportieren Sie alle bestehenden Workflows                                  │
│   • Dokumentieren Sie Trigger-Typen und -Frequenzen                            │
│   • Katalogisieren Sie alle Integrationen und Anmeldedaten                     │
│   • Identifizieren Sie Fehlerraten und Zuverlässigkeitsprobleme                │
│                                                                                 │
│   Schritt 2: Priorisierung                                                        │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  Bewerten Sie jeden Workflow auf:                                       │  │
│   │  • Komplexität (1-10) — Höher = besser für KI                           │  │
│   │  • Geschäftsimpakt (1-10) — Beginnen Sie mit hohem Impact              │  │
│   │  • Änderungshäufigkeit (1-10) — Häufige Änderungen profitieren am meisten│  │
│   │  • Fehlerrate (1-10) — Defekte Workflows brauchen zuerst Aufmerksamkeit │  │
│   │                                                                          │  │
│   │  Prioritätsscore = Komplexität × 0,3 + Impact × 0,4 +                   │  │
│   │                   ChangeFreq × 0,2 + ErrorRate × 0,1                    │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Schritt 3: Migrationswellen                                                   │
│   • Welle 1: Einfach, geringes Risiko (1-2 Wochen)                              │
│   • Welle 2: Mittlere Komplexität (3-4 Wochen)                                   │
│   • Welle 3: Komplex, kritisch (6-8 Wochen)                                       │
│                                                                                 │
│   Schritt 4: Validierung                                                        │
│   • Paralleles Laufen (alt + neu)                                               │
│   • Output-Vergleich                                                            │
│   • Stakeholder-Sign-off                                                        │
│   • Schrittweise Traffic-Umschaltung                                            │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

{
  "name": "Customer Onboarding (Legacy)",
  "nodes": [
    { "type": "webhook", "name": "Webhook" },
    { "type": "postgres", "name": "CreateUser" },
    { "type": "httpRequest", "name": "SendWelcomeEmail" },
    { "type": "slack", "name": "NotifySales" },
    // ... 8 weitere Knoten
  ]
}