n8n Erste-Schritte-Tutorial

n8n (ausgesprochen "n-eight-n", kurz für "nodemation") ist derzeit die von technischen Teams am meisten bevorzugte Open-Source-Plattform für Workflow-Automatisierung.

Die Kernstärken von n8n sind: visuelles Canvas + native Code-Unterstützung + vollständiges Self-Hosting – es ermöglicht Nicht-Entwicklern, per Drag-and-Drop zu erstellen, erlaubt Entwicklern, JavaScript oder Python in jedem Node zu schreiben, und kann auf eigenen Servern ausgeführt werden, wobei die Daten lokal bleiben.

n8n ist eine Workflow-Automatisierungsplattform, mit der Sie KI sicher und kontrollierbar in Ihre Arbeit und Prozesse integrieren können.

n8n kombiniert eine visuelle Entwicklungserfahrung mit Code-Funktionen – Sie können JavaScript oder Python überall im Workflow schreiben und Ergebnisse sofort neben den Ein- und Ausgaben jedes Schritts einsehen.

Unterschiede zwischen Dify und n8n

Anders als bei Dify liegt der Kern von n8n in allgemeiner Automatisierung und Systemintegration, bei der KI eine leistungsstarke Komponente ist, während der Kern von Dify in der Entwicklung von KI-Anwendungen liegt, bei der Automatisierung eine unterstützende Fähigkeit ist.

Kurz gesagt:

Wenn Sie mehrere SaaS-Systeme verbinden und Daten zwischen ihnen fließen lassen müssen: n8n ist die bessere Wahl
Wenn Sie eine Anwendung rund um KI-Konversation aufbauen müssen (Kundenservice-Bot, RAG Q&A): Dify ist die bessere Wahl

Für wen ist es gedacht?

Die visuelle Oberfläche von n8n ermöglicht Nicht-Entwicklern, Workflows schnell zu entwerfen und zu testen. Mit steigender Komplexität können Entwickler sie mit Function-Nodes, externen Skripten oder benutzerdefinierten Integrationen erweitern.

Dadurch können Teams schrittweise Struktur, Validierung und Kontrolle hinzufügen.

Die typischsten Nutzergruppen:

Nutzergruppe	Typische Szenarien
Operations-Teams	Automatisierung von CRM-Aktualisierungen, Berichtserstellung, E-Mail-Versand
Entwickler	API-Integration, Datenpipelines, Automatisierung interner Tools
Data Engineers	ETL-Pipelines, Datenbereinigung, geplante Synchronisierung
IT-Teams	Monitoring-Alarme, Incident-Response, Benutzerverwaltung
Tech-Startups	Schneller Aufbau der Backend-Automatisierungsschicht für ein MVP

Kernkonzepte

Bevor wir mit dem Lernen beginnen, wollen wir zunächst diese Kernkonzepte verstehen.

Workflow

Ein Workflow ist ein gerichteter Graph aus einer Reihe von Nodes, der die Logik definiert: "Wenn X passiert, führe Y aus, dann führe Z aus".

Ein Workflow hat zwei Zustände: Wenn er aktiv ist, reagiert er auf Trigger und läuft automatisch; wenn er inaktiv ist, kann er nur manuell zum Testen ausgeführt werden.

Knoten

Der grundlegende Baustein eines Workflows; jeder Node führt eine bestimmte Operation aus:

Node-Typ	Farbe	Beschreibung
Trigger-Node	Orange	Der Startpunkt eines Workflows, der definiert, wann er ausgelöst wird
Regulärer Node	Blau	Daten verarbeiten, APIs aufrufen, Logik ausführen
KI-bezogene Nodes	Violett	LLM-Aufrufe, Vektorspeicher, Agent

Ausführung

Ein vollständiger Durchlauf eines Workflows wird als Ausführung bezeichnet.

Das Abrechnungsmodell für Ausführungen von n8n ist: Eine Ausführung = der Workflow wird einmal ausgeführt, unabhängig davon, wie viele Schritte er enthält oder wie viele Daten er verarbeitet.

Verbindung

Pfeile zwischen Knoten definieren Datenfluss und Ausführungsreihenfolge. Ein Knoten kann mehrere Ausgaben haben, um Verzweigungslogik umzusetzen.

Zugangsdaten

Ein sicherer Container zum Speichern sensibler Informationen wie API-Schlüssel, OAuth-Token, Datenbank-Passwörter und mehr.

Zugangsdaten werden verschlüsselt gespeichert und können über mehrere Workflows hinweg geteilt werden, ohne im Workflow-JSON im Klartext offengelegt zu werden.

Ausdruck

Die dynamische Wertsyntax von n8n, eingeschlossen in doppelte geschweifte Klammern:{{ $json.fieldName }}。

Ermöglicht es Knotenparametern, auf Ausgaben vorgelagerter Knoten statt auf feste Werte zu verweisen.

Installation und Start

Fünf Installationsmethoden, vom lokalen Schnellstart bis zum Enterprise-tauglichen Hochverfügbarkeits-Deployment.

Methode 1: Schneller lokaler Test (Am schnellsten, 5 Minuten)

Verwenden Sie npx oder eine globale Installation, keine zusätzliche Konfiguration erforderlich.

# 使用 npx，无需安装（需要 Node.js 18+）
npx n8n

# 或全局安装
npm install -g n8n
n8n start

Öffnen Sie Ihren Browser und besuchen Sie http://localhost:5678, schließen Sie die Kontoregistrierung ab und schon können Sie es verwenden.

Wenn Sie Ihr E-Mail-Passwort vergessen haben, verwenden Sie den Befehlnpx n8n user-management:resetzum Zurücksetzen.

Methode 2: Docker-Einzelcontainer (Empfohlen für Einzelpersonen und kleine Teams)

Starten Sie mit einem Befehl, Daten werden in einem lokalen Verzeichnis dauerhaft gespeichert.

# 创建数据持久化目录
mkdir -p ~/.n8n

# 启动 n8n 容器
docker run -d \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  -e N8N_ENCRYPTION_KEY="your-random-32-char-secret-key" \
  docker.n8n.io/n8nio/n8n:latest

Besuchen Sie http://localhost:5678, um die Einrichtung abzuschließen.

Methode 3: Docker Compose + PostgreSQL (Empfohlen für Produktionsumgebungen)

Geeignet für Produktionsumgebungen, Daten werden in PostgreSQL gespeichert, was stabileren gleichzeitigen Zugriff unterstützt.

Erstellen Sie docker-compose.yml:

version: "3.8"

services:
  postgres:
    image: postgres:16-alpine
    restart: always
    environment:
      POSTGRES_DB: n8n
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U n8n"]
      interval: 10s
      timeout: 5s
      retries: 5

  n8n:
    image: docker.n8n.io/n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      # 数据库连接配置
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_DATABASE: n8n
      DB_POSTGRESDB_USER: n8n
      DB_POSTGRESDB_PASSWORD: ${POSTGRES_PASSWORD}
      # 安全配置
      N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY}
      N8N_SECURE_COOKIE: "false"          # 如果没有 HTTPS，设为 false
      # 访问地址（替换为你的实际域名）
      WEBHOOK_URL: https://your-domain.com
      N8N_EDITOR_BASE_URL: https://your-domain.com
      # 时区设置
      GENERIC_TIMEZONE: Asia/Shanghai
      TZ: Asia/Shanghai
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy

volumes:
  postgres_data:
  n8n_data:

Erstellen Sie eine .env-Datei:

POSTGRES_PASSWORD=your-strong-postgres-password
N8N_ENCRYPTION_KEY=your-32-char-random-encryption-key

Generieren Sie einen sicheren Verschlüsselungsschlüssel:

# 生成 24 字节的 base64 随机密钥
openssl rand -base64 24

Starten Sie den Dienst:

# 后台启动所有服务
docker compose up -d

# 查看日志，等待启动完成
docker compose logs -f n8n

Methode 4: Reverse Proxy konfigurieren (Nginx + HTTPS)

] Für die Produktionsbereitstellung wird empfohlen, Nginx für eine einfache Domainbindung und HTTPS zu konfigurieren.

server {
    listen 80;
    server_name n8n.yourdomain.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name n8n.yourdomain.com;

    # SSL 证书路径（使用 Let's Encrypt 自动签发）
    ssl_certificate     /etc/letsencrypt/live/n8n.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/n8n.yourdomain.com/privkey.pem;

    # n8n WebSocket 支持
    location / {
        proxy_pass http://localhost:5678;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 300s;
        proxy_send_timeout 300s;
    }

    # MCP SSE 端点专项配置
    location ~* ^/mcp {
        proxy_pass http://localhost:5678;
        proxy_buffering off;
        gzip off;
        chunked_transfer_encoding off;
        proxy_set_header Connection "";
    }
}

] Beantragen Sie ein SSL-Zertifikat (Let's Encrypt):

# 自动配置 Nginx 并申请 SSL 证书
certbot --nginx -d n8n.yourdomain.com

Methode 5: Kubernetes (Hochverfügbarkeit, Enterprise-tauglich)

] Für Teams, die Hochverfügbarkeit benötigen, verwenden Sie das offizielle Helm Chart.

# 添加 n8n Helm 仓库
helm repo add n8n https://n8n-helm-chart.netlify.app

# 安装 n8n，启用 PostgreSQL 和 Redis
helm install n8n n8n/n8n \
  --set n8n.encryption_key="your-key" \
  --set postgresql.enabled=true \
  --set redis.enabled=true   # 队列模式需要 Redis

] Die Hochverfügbarkeitsarchitektur erfordert die Konfiguration des "Queue Mode", die Verwendung von Redis als Nachrichtenwarteschlange, sodass mehrere Worker-Knoten Aufgaben parallel verarbeiten können.

Systemanforderungen

] Hardware-Empfehlungen für verschiedene Nutzungsszenarien:

] Szenario	CPU	] Arbeitsspeicher	] Festplatte
] Entwicklung/Tests	] 1 Kern	1 GB	10 GB
] Produktion für kleine Teams	] 2 Kerne	4 GB	20 GB
] Mittlere Last	] 4 Kerne	8 GB	50 GB

Datenbankempfehlung: n8n verwendet standardmäßig SQLite, aber für Produktionsumgebungen wird PostgreSQL dringend empfohlen. PostgreSQL bietet bessere Leistung, unterstützt gleichzeitigen Zugriff und ist einfacher zu sichern.

Tour durch die Oberfläche: n8n zum ersten Mal öffnen

Lernen Sie die wichtigsten Oberflächenbereiche von n8n kennen und starten Sie schnell.

Linke Navigationsleiste

Symbol/Bereich	Funktion
Workflow-Liste	Workflows anzeigen, suchen und erstellen
Ausführungsverlauf	Ausführungsprotokolle aller Workflows anzeigen
Zugangsdaten	Sensible Informationen wie API-Schlüssel und OAuth verwalten
Variablen	Globale Variablen (Team/Business-Funktion)
Einstellungen	Instanzkonfiguration, Benutzerverwaltung

Wir können einen API-Anbieter wie DeepSeek konfigurieren. Klicken Sie auf das Menü „Neuer Chat“, klicken Sie auf das Modell in der oberen linken Ecke und wählen Sie DeepSeek aus der Dropdown-Liste aus:

Konfigurieren Sie dann den API-Schlüssel:

Klicken Sie nach erfolgreicher Konfiguration auf das Modell in der oberen linken Ecke und wählen Sie das DeepSeek-Modell aus der Dropdown-Liste aus:

Sie können jetzt mit dem Chatten beginnen:

Workflow-Canvas

Canvas-Bedienungs-Shortcuts:

Aktion	Tastenkürzel/Methode
Node hinzufügen	Klicken Sie auf die +-Schaltfläche, um zwischen zwei Nodes hinzuzufügen
Node suchen	Ctrl+K für schnelles Suchen und Hinzufügen
Canvas verschieben	Leeren Bereich ziehen
Canvas zoomen	Mausrad
Alle Nodes auswählen	Ctrl+A
Node löschen	Drücken Sie Delete, um den ausgewählten Node zu löschen

Node-Panel

Klicken Sie auf einen beliebigen Node, um das Konfigurationspanel zu öffnen, das drei Tabs hat:

Tab	Funktion
Parameters	Hauptkonfiguration des Nodes
Einstellungen	Ausführungssteuerung (Wiederholen, Timeout, Fehlerbehandlung)
Hinweise	Beschreibungstext zum Node hinzufügen

Obere Symbolleiste

Schaltfläche	Funktion
Workflow ausführen	Eine Ausführung manuell auslösen
Save	Aktuelle Änderungen speichern
Aktiv-Schalter	Workflow aktivieren/deaktivieren

Erstellen Sie Ihren ersten Workflow

Starten Sie mit einem vollständigen Beispiel: Rufen Sie jeden Tag um 8 Uhr automatisch die Top-Artikel von Hacker News ab, formatieren Sie sie und senden Sie sie an einen Slack-Kanal.

Schritt 1: Workflow erstellen

Wählen Sie links Workflows aus, klicken Sie auf Neuer Workflow und benennen Sie ihn in "HN Morning Report" um.

Schritt 2: Schedule-Trigger hinzufügen

Klicken Sie auf die +-Schaltfläche, suchen Sie nach "Schedule" und wählen Sie Schedule Trigger aus.

Konfigurationshinweise:

Trigger Rule：0 8 * * 1-5（周一到周五早上 8 点）
或使用界面选择器：Hour → 8，Weekday → Mon to Fri

Schritt 3: HN-Daten abrufen

Klicken Sie rechts neben dem Schedule-Trigger auf +, suchen Sie nach "HTTP Request" und fügen Sie einen Node hinzu.

Konfiguration:

Method：GET
URL：https://hacker-news.firebaseio.com/v0/topstories.json

Dies gibt ein Array von IDs für die aktuellen Top-Artikel zurück (bis zu 500).

Schritt 4: Auf die ersten 5 Elemente begrenzen

Fügen Sie einen Code-Node hinzu, schreiben Sie JavaScript:

Beispiel

// Die ersten 5 Story-IDs nehmen, als einzelne JSON-Objekte zurückgeben
const topIds = $input.first().json.slice(0, 5);
return topIds.map(id => ({ json: { id } }));

Schritt 5: Details für jeden Artikel parallel abrufen

Fügen Sie einen HTTP-Request-Node hinzu.

n8n führt für jedes Element vom vorgelagerten Node automatisch parallel aus, ohne dass manuelle Schleifen geschrieben werden müssen.

Konfiguration:

URL：https://hacker-news.firebaseio.com/v0/item/{{ $json.id }}.json

Schritt 6: Nachricht formatieren

Fügen Sie einen Code-Node hinzu:

Beispiel

Schritt 7: An Slack senden

Fügen Sie einen Slack-Knoten hinzu (schließen Sie zuerst die Konfiguration der Slack-Anmeldedaten ab, siehe Kapitel zur Verwaltung der Anmeldedaten).

Konfiguration:

Resource：Message
Operation：Send
Channel：#general（或你的目标频道）
Message：{{ $json.message }}

Schritt 8: Testlauf

Klicken Sie oben auf die Schaltfläche „Workflow ausführen“ und beobachten Sie die Zahlen, die neben jedem Knoten erscheinen (sie geben die Anzahl der verarbeiteten Datenelemente an).

Klicken Sie auf einen beliebigen Knoten, um seine Eingabe- und Ausgabedaten anzuzeigen.

Schritt 9: Workflow aktivieren

Nachdem der Test bestanden wurde, schalten Sie den Schalter „Aktiv“ in der oberen rechten Ecke um. Der Workflow wechselt in den aktiven Zustand und wird jeden Werktag um 8 Uhr automatisch ausgeführt.

Detaillierte Erklärung gängiger Knoten

Meistern Sie die gängigsten Knotentypen, die drei Hauptkategorien abdecken: Trigger, Datenverarbeitung und Datenbanken.

Trigger-Knoten

Trigger sind der Ausgangspunkt eines Workflows und definieren, wann die Ausführung beginnen soll.

Knoten	Trigger-Typ	Typische Szenarien
Schedule-Trigger	Geplant (Cron-Ausdruck)	Tägliche Berichte, geplante Synchronisierung
Webhook	HTTP-Anfrage-Trigger	Stripe/GitHub-Ereignisse empfangen
Chat-Trigger	KI-Konversationsnachrichten	KI-Agent-Workflows ansteuern
E-Mail-Trigger (IMAP)	Neue E-Mail trifft ein	E-Mail-Anfragen verarbeiten
Slack-Trigger	Slack-Ereignisse	Auf Slash-Befehle antworten

Knoten zur Datenverarbeitung

HTTP Request (der zentrale Knoten)

Kann nahezu jede REST-API aufrufen:

Method: POST
URL: https://api.example.com/endpoint
Authentication: Header Auth（配合凭证使用）
Body Content Type: JSON
Body: {
  "key": "{{ $json.value }}"
}

Unterstützt automatische Paginierung, sodass Sie alle Daten abrufen können, ohne Schleifenlogik zu schreiben.

Code (JavaScript / Python)

JavaScript-Beispiel:

Beispiel

// Alle Elemente aus vorgelagerten Knoten verarbeiten
for (const item of $input.all()) {
// Verarbeitungszeitstempel zu jedem Datenelement hinzufügen
item.json.processedAt = new Date().toISOString();
}
return $input.all();

Python-Beispiel:

Beispiel

# Python unterstützt dies ebenfalls; verwenden Sie _input, um auf vorgelagerte Daten zuzugreifen
for item in _input.all():
item.json["processed"] = True
return _input.all()

Set (Variablen setzen)

Felder visuell festlegen, ändern und löschen, ohne Code zu schreiben.

字段名: fullName
值: {{ $json.firstName + " " + $json.lastName }}

IF (bedingte Verzweigung)

Daten basierend auf Bedingungen an verschiedene Zweige weiterleiten:

条件: {{ $json.status }} == "active"
True 分支 → 处理活跃用户
False 分支 → 处理非活跃用户

Switch (Mehrfachverzweigung)

Ähnlich wie IF, unterstützt aber mehrere Bedingungen (wie switch-case) und leitet Daten an verschiedene Verarbeitungspfade weiter.

Loop Over Items (Schleife)

Jedes Element in einem Array einzeln verarbeiten, geeignet für Szenarien, die Ratenkontrolle statt paralleler Verarbeitung erfordern.

Merge (kombinieren)

Daten aus mehreren Zweigen kombinieren, mit Unterstützung für Strategien wie Append, Keep Key Matches, Combine By Position.

Wait (Warten/Human-in-the-Loop)

Die Workflow-Ausführung anhalten und warten, bis die folgenden Bedingungen erfüllt sind, bevor fortgefahren wird:

Nach einer gewissen Zeit automatisch fortfahren
Nach Erhalt eines Webhook-Callbacks fortfahren (Kern von Human-in-the-Loop)
Nach dem Absenden eines bestimmten Formulars fortfahren

Auf Webhook antworten (Antwort an Webhook)

In einem Workflow, der einen Webhook empfängt, synchron eine Antwort an den Anforderer zurückgeben.

Datenbankknoten

Knoten	Unterstützte Operationen
PostgreSQL	Select / Insert / Update / Delete / Execute Query
MySQL	Select / Insert / Update / Delete / Execute Query
MongoDB	Find / Insert / Update / Delete / Aggregate
Redis	Get / Set / Delete / Incr / Expire
Supabase	Über REST- oder PostgreSQL-Knoten

Verwaltung von Anmeldedaten: Externe Dienste sicher verbinden

Anmeldedaten sind der einheitliche Mechanismus in n8n zur Verwaltung aller Authentifizierungsinformationen; alle Anmeldedaten werden mit N8N_ENCRYPTION_KEY verschlüsselt und in der Datenbank gespeichert.

Teams können Anmeldedaten gemeinsam nutzen, ohne den tatsächlichen geheimen Inhalt zu sehen.

Anmeldedaten hinzufügen

Es gibt zwei Möglichkeiten, Anmeldedaten hinzuzufügen:

Wählen Sie in der linken Navigation Anmeldedaten aus und klicken Sie dann auf Anmeldedaten hinzufügen.
Klicken Sie in der Knotenkonfiguration auf das Dropdown für Anmeldedaten und wählen Sie Neue Anmeldedaten erstellen.

Häufige Konfigurationen für Anmeldedaten

Slack（OAuth）

Rufen Sieapi.slack.com/appsauf und erstellen Sie eine App
Aktivieren Sie Bot-Token-Scopes (chat:write, channels:read)
Installieren Sie die App im Workspace und kopieren Sie das Bot-Token (beginnt mit xoxb-).
Wählen Sie in n8n Slack aus und fügen Sie das Bot-Token ein.

GitHub（Personal Access Token）

Wählen Sie in GitHub Einstellungen, gehen Sie zu Entwicklereinstellungen, wählen Sie Persönliche Zugriffstoken und klicken Sie auf Neuen Token generieren.
Wählen Sie die erforderlichen Berechtigungen aus (repo, issues usw.)
Kopieren Sie das Token und fügen Sie in n8n Anmeldedaten für GitHub hinzu.

OpenAI / Anthropic（API Key）

Rufen Sie den API Key aus der Konsole des jeweiligen Anbieters ab.
Wählen Sie in n8n Anmeldedaten, suchen Sie nach "OpenAI" oder "Anthropic" und fügen Sie den Key ein.

Allgemeiner HTTP-Header (beliebige API)

Verwenden Sie für Dienste ohne dedizierten Knoten in n8n den HTTP-Request-Knoten mit Header-Auth-Anmeldedaten:

Header Name: Authorization
Header Value: Bearer your-api-key-here

AI-Agent-Knoten: Workflows zum Denken bringen

Der native AI-Agent-Knoten von n8n ermöglicht es Ihnen, intelligente, autonome Workflows zu erstellen, die große Sprachmodelle nutzen, um Entscheidungen zu treffen, natürliche Sprache zu verarbeiten und mehrstufige Schlussfolgerungen durchzuführen.

Komponenten des AI-Agent-Knotens

Der AI-Agent-Knoten ist ein "Cluster-Knoten", der aus drei Arten von Unterknoten besteht:

AI Agent（根节点）
├── Chat Model（必需）：驱动 Agent 的 LLM
│   ├── OpenAI Chat Model
│   ├── Anthropic Chat Model
│   └── Google Gemini Chat Model
├── Memory（可选）：让 Agent 记住对话历史
│   ├── Simple Memory（会话内记忆）
│   ├── Window Buffer Memory（固定窗口）
│   └── Postgres/Redis Chat Memory（跨会话持久化）
└── Tools（可选）：Agent 可以调用的工具
    ├── 内置工具（Calculator、SerpAPI、Wikipedia）
    ├── HTTP Request Tool（调用任意 API）
    ├── n8n Workflow Tool（调用另一个工作流）
    └── MCP Client Tool（调用 MCP 服务器）

AI-Agent konfigurieren

Schritt 1: AI-Agent-Knoten hinzufügen.

Suchen Sie auf der Workflow-Leinwand nach AI Agent und wählen Sie Tools Agent (den vielseitigsten Agent-Typ).

Schritt 2: Chat-Modell hinzufügen.

Klicken Sie auf den Chat Model-Slot unten am AI-Agent-Knoten und fügen Sie das Anthropic Chat Model hinzu.

Konfiguration:

Model：claude-sonnet-4-6
凭证：选择已配置的 Anthropic 凭证

Schritt 3: System Prompt konfigurieren.

你是一个数据分析助手，帮助用户分析 {{ $json.company_name }} 公司的销售数据。

可用工具：
- 查询数据库获取历史销售数据
- 搜索互联网获取市场信息
- 计算器用于数学运算

回答要简洁、数据驱动。如果数据不足，明确说明需要哪些额外信息。

Schritt 4: Tools hinzufügen.

Klicken Sie auf Add Tool, um die erforderlichen Tool-Knoten hinzuzufügen.

Jedes Tool erfordert die Konfiguration eines Tool-Namens (der Agent verwendet diesen Namen, um zu entscheiden, wann er es aufruft) und einer Tool-Beschreibung (teilt dem Agenten mit, was dieses Tool kann).

Agent-Typ auswählen

Agent-Typ	Geeignete Szenarien
Tools Agent (empfohlen)	Allgemeiner Zweck, unterstützt Function Calling, beste Wahl für moderne LLMs
ReAct Agent	Reasoning + Acting, geeignet für Aufgaben, die mehrstufiges Schlussfolgern erfordern
Plan and Execute Agent	Zuerst einen vollständigen Plan formulieren, dann Schritt für Schritt ausführen
Conversational Agent	Konversationell, mit integriertem Gedächtnis, geeignet für Chatbots
SQL Agent	Spezialisiert auf die Verarbeitung von Datenbankabfragen
OpenAI Functions Agent	OpenAI-exklusives Function Calling

MCP-Integration: Anbindung an das KI-Ökosystem

n8n hat eine Doppelrolle im MCP-(Model Context Protocol-)Ökosystem: Es kann sowohl MCP-Dienste konsumieren (als MCP-Client) als auch Workflows als MCP-Dienste bereitstellen (als MCP-Server).

n8n als MCP-Client (Aufrufen externer Tools)

Verwenden Sie den Node MCP Client Tool, um eine Verbindung zu einem beliebigen MCP-Server herzustellen.

Der Node MCP Client Tool unterstützt die Authentifizierungsmethoden Bearer, generischer Header, mehrere Header und OAuth2.

Konfigurationsbeispiel: Verbindung zu einem GitHub MCP-Server

节点类型：MCP Client Tool
SSE Endpoint: https://mcp.github.com/sse    # 或自托管的 MCP 服务器地址
Authentication: Bearer
Bearer Token: your-github-token
Tools to Include: All（暴露所有工具给 Agent）

Verbinden Sie den Node MCP Client Tool mit dem Tools-Slot des AI Agent, und der Agent kann direkt die MCP-Tools von GitHub aufrufen (Issues auflisten, PRs erstellen, Code anzeigen usw.).

n8n als MCP-Server (Workflows bereitstellen)

Verwenden Sie den Node MCP Server Trigger, damit n8n als MCP-Server fungiert und n8n-Tools und Workflows für MCP-Clients bereitstellt.

Er stellt eine URL bereit, über die MCP-Clients interagieren können, um auf n8n-Tools zuzugreifen.

Einrichtungsschritte:

Erstellen Sie einen neuen Workflow und fügen Sie den Node MCP Server Trigger hinzu
Der Node generiert automatisch eine Test-URL und eine Produktions-URL (Format: https://your-n8n.com/mcp/xxxxxxxx)
Verbinden Sie neben dem MCP Server Trigger die Tool-Nodes, die Sie bereitstellen möchten.

MCP Server Trigger
├── Google Calendar Tool（查看/创建日程）
├── Gmail Tool（读取/发送邮件）
├── Slack Tool（发送消息）
└── Custom n8n Workflow Tool（调用其他工作流）

Workflow veröffentlichen (auf Publish klicken)

Verwendung in Claude Desktop:

Bearbeiten Sie ~/Library/Application Support/Claude/claude_desktop_config.json:

Beispiel

{
"mcpServers": {
"n8n": {
"command": "npx",
"args": [
"-y",
"mcp-remote@latest",
"https://your-n8n.com/mcp/your-mcp-path",
"--header",
"Authorization:Bearer your-bearer-token"
]
}
}
}

MCP-Server auf Instanzebene

Im April 2026 führte n8n MCP-Server auf Instanzebene ein.

Es ermöglicht KI-Clients (Claude Desktop, Cursor usw.), komplette Workflows direkt per natürlicher Sprache zu erstellen, zu validieren, zu testen und zu veröffentlichen – es ist ein Entwicklungswerkzeug, kein Laufzeitwerkzeug.

Aktivierung (selbst gehostet):

N8N_MCP_ACCESS_ENABLED=true

Nach der Aktivierung kann Ihr Claude Desktop oder ein anderer MCP-Client n8n direkt sagen: „Erstelle einen Workflow, der jeden Morgen die Liste der GitHub-PRs an Slack sendet“, und n8n erstellt diesen Workflow automatisch.

Praktisches Szenario 1: Automatische Klassifizierung und Benachrichtigung bei GitHub-Issues

Verwenden Sie AI Agent, um GitHub-Issues automatisch zu klassifizieren und sie je nach Typ an verschiedene Zuständige und Kanäle weiterzuleiten.

Geschäftsszenario

Open-Source-Projekte erhalten jeden Tag eine Vielzahl von Issues und müssen sie automatisch klassifizieren (Bug / Feature Request / Question / Docs) und die verantwortlichen Personen benachrichtigen.

Workflow-Design

Webhook（接收 GitHub Issue 事件）
  ↓
IF 节点（过滤：只处理新建的 Issue）
  ↓
AI Agent 节点（分析 Issue 内容，给出分类和优先级）
  ↓
Switch 节点（根据分类路由）
  ├── Bug → 添加 "bug" 标签 + 通知 @backend-team
  ├── Feature → 添加 "enhancement" 标签 + 通知 @product-team
  ├── Question → 添加 "question" 标签 + 自动生成初步回复
  └── Docs → 添加 "documentation" 标签 + 通知 @docs-team
  ↓
GitHub 节点（添加标签 + 发表评论）
  ↓
Slack 节点（发送通知到对应频道）

Wichtige Knotenkonfiguration

Schritt 1: GitHub-Webhook konfigurieren

Wählen Sie im GitHub-Repository Settings aus, gehen Sie zu Webhooks und klicken Sie auf Add Webhook:

Payload URL：https://your-n8n.com/webhook/github-issues
Content type：application/json
Events：Issues（只选 Issues 事件）

Fügen Sie in n8n einen Webhook-Node hinzu:

HTTP Method：POST
Path：github-issues
（记录下 Test URL，用于调试）

Schritt 2: Neue Ereignisse filtern

Fügen Sie einen IF-Node hinzu:

条件：{{ $json.action }} == "opened"

Nur Ereignisse mit action === "opened" werden weiterverarbeitet; labeled, closed und andere Ereignisse werden direkt verworfen.

Schritt 3: KI-Klassifizierungs-Node

Fügen Sie einen AI Agent-Node hinzu und konfigurieren Sie den System-Prompt:

你是一个 GitHub Issue 分类专家。分析以下 Issue，返回 JSON 格式的分类结果：

{
  "category": "bug" | "feature" | "question" | "docs",
  "priority": "P0" | "P1" | "P2" | "P3",
  "reason": "分类理由（一句话）",
  "suggested_reply": "给 Issue 作者的初步回复（仅用于 question 类型）"
}

分类标准：
- bug：描述了一个功能不正常工作的情况
- feature：要求新增功能或改进现有功能
- question：寻求帮助或解释
- docs：关于文档的问题或建议

优先级：
- P0：生产崩溃、安全漏洞
- P1：核心功能损坏
- P2：普通 Bug 或常见需求
- P3：优化建议、文档改善

Konfigurieren Sie die User-Nachricht mithilfe eines Ausdrucks:

Issue 标题：{{ $json.issue.title }}
Issue 内容：{{ $json.issue.body }}
作者：{{ $json.issue.user.login }}

Schritt 4: KI-Ausgabe parsen

Fügen Sie einen Code-Node hinzu, um JSON zu parsen (da die KI möglicherweise JSON mit Markdown-Codeblöcken ausgibt):

const text = $input.first().json.output;

// 去掉可能的 ```json 和 ``` 包裹，提取纯 JSON
const cleaned = text.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
const parsed = JSON.parse(cleaned);

return [{ json: parsed }];

Schritt 5: Switch-Routing

Fügen Sie einen Switch-Node hinzu:

Value 1：{{ $json.category }}
路由规则：
  "bug"     → Output 1
  "feature" → Output 2
  "question"→ Output 3
  "docs"    → Output 4
  (默认)    → Output 5

Schritt 6: Labels hinzufügen + Kommentare posten

Fügen Sie für jeden Zweig einen GitHub-Node hinzu (zwei Operationen).

GitHub-Node (Label hinzufügen):

Resource：Issue
Operation：Add Labels
Repository Owner：{{ $('Webhook').item.json.repository.owner.login }}
Repository Name：{{ $('Webhook').item.json.repository.name }}
Issue Number：{{ $('Webhook').item.json.issue.number }}
Labels：bug（根据分支不同填不同标签）

GitHub-Node (Kommentar posten, nur Question-Zweig):

Resource：Issue
Operation：Create Comment
Body：{{ $('AI Agent').item.json.suggested_reply }}

Schritt 7: Slack-Benachrichtigung

Channel：#bugs（根据分支选择不同频道）
Message：
*新 Issue* 已分类为 `{{ $json.category }}`（优先级 {{ $json.priority }}）

*标题*：{{ $('Webhook').item.json.issue.title }}
*作者*：{{ $('Webhook').item.json.issue.user.login }}
*链接*：{{ $('Webhook').item.json.issue.html_url }}

*分类理由*：{{ $json.reason }}

Szenario 2: KI-Dokumentenverarbeitungs-Pipeline (Rechnungs-/Vertragsextraktion)

Verwenden Sie KI, um Rechnungsinformationen aus E-Mail-Anhängen automatisch zu extrahieren und sie strukturiert in Google Sheets zu speichern.

Geschäftsszenario

Das wertvollste Einstiegsszenario ist der KI-Dokumentenverarbeitungs-Workflow. Das Muster ist: Dokumenteingang per Webhook oder E-Mail-Anhängen auslösen, den Dokumentinhalt an einen KI-Node übergeben, mit JSON-formatigen Anweisungen strukturierte Daten extrahieren und die Ergebnisse dann in Google Sheets, Airtable oder eine Datenbank schreiben. Dieser einzelne Workflow kann einem kleinen Betriebsteam täglich 2-4 Stunden manuelle Dateneingabe ersparen.

Ziel: Mithilfe von KI Schlüsselfelder aus einer an eine E-Mail angehängten Rechnungs-PDF extrahieren, sie in Google Sheets schreiben und eine Bestätigung senden.

Workflow-Design

Email Trigger（监听新邮件，有附件）
  ↓
IF 节点（过滤：只处理包含发票/invoice 的邮件）
  ↓
HTTP Request（下载邮件附件）
  ↓
AI Agent（提取发票信息，返回结构化 JSON）
  ↓
Google Sheets（追加新行）
  ↓
Email（发送处理确认邮件给发件人）

Wichtige Knotenkonfiguration

E-Mail-Trigger（IMAP）

Protocol：IMAP
Host：imap.gmail.com（或你的邮件服务器）
User/Password：邮箱账号和专用密码
Mailbox：INBOX
Download Attachments：开启

Prompt zum Extrahieren von Rechnungsinformationen

Verwende den AI Agent Node oder direkt den Anthropic Chat Model Node (kosteneffizienter):

System: 你是一个发票数据提取专家。从以下发票文本中提取信息，
        返回严格的 JSON 格式，不要任何额外文字：
{
  "invoice_number": "发票号",
  "invoice_date": "发票日期（YYYY-MM-DD）",
  "vendor_name": "供应商名称",
  "vendor_tax_id": "供应商税号",
  "buyer_name": "购买方名称",
  "items": [
    {
      "description": "商品描述",
      "quantity": 数量,
      "unit_price": 单价,
      "amount": 金额
    }
  ],
  "subtotal": 小计,
  "tax_rate": 税率,
  "tax_amount": 税额,
  "total_amount": 总金额,
  "currency": "货币（CNY/USD/EUR）",
  "due_date": "付款截止日（YYYY-MM-DD，没有则为 null）"
}

User: {{ $json.attachmentText }}

Google Sheets Node

Konfiguration:

Resource：Sheet Within Document
Operation：Append Row

Felder zuordnen (Ausdrücke verwenden, um auf die KI-Ausgabe zu verweisen):

发票号：{{ $json.invoice_number }}
日期：{{ $json.invoice_date }}
供应商：{{ $json.vendor_name }}
金额：{{ $json.total_amount }}
货币：{{ $json.currency }}
处理时间：{{ $now.toISOString() }}

Szenario 3: Multi-Channel-Kundenservice-Routing (mit Human-in-the-Loop)

Kundenservice-Tickets aus mehreren Kanälen zusammenführen, KI verwenden, um sie zu klassifizieren, Tickets mit niedriger Priorität automatisch bearbeiten und bei Tickets mit hoher Priorität auf manuelle Genehmigung warten.

Geschäftsszenario

Kundenservice-Tickets strömen aus mehreren Kanälen herein (E-Mail, Slack, Formulare), was eine erste KI-Analyse und priorisierte Weiterleitung erfordert. Komplexe Tickets erfordern eine manuelle Genehmigung vor der Antwort.

Workflow-Design

Merge（合并来自三个渠道的触发）
├── Email Trigger（邮件渠道）
├── Slack Trigger（Slack 消息）
└── Webhook（表单提交）
  ↓
Code 节点（统一数据格式）
  ↓
AI Agent（分析：分类、情感、优先级、建议回复）
  ↓
Switch 节点
  ├── 高优先级（P0/P1）→ 立即通知人工 + Wait 等待审批
  │                        ↓ （等人工回复 Webhook）
  │                     发送审批后的回复
  │
  └── 低优先级（P2/P3）→ 自动发送 AI 生成的回复
                          ↓
                       记录到 Airtable

Human-in-the-Loop-Kernkonfiguration

Wait-Node (auf manuelle Genehmigung warten)

Dies ist der zentrale Node zur Implementierung von Human-in-the-Loop in n8n:

Wait for：Webhook
Webhook URL：自动生成一个唯一的审批 URL

Genehmigungsanfrage senden (an Slack)

Verwende vor dem Wait-Node den Slack-Node, um eine Genehmigungsnachricht zu senden:

Channel: #customer-service-review
Message:
*高优先级工单需要审批*

*客户*：{{ $json.customer_email }}
*渠道*：{{ $json.source }}
*问题*：{{ $json.message }}

*AI 分析*：
- 分类：{{ $json.category }}
- 情感：{{ $json.sentiment }}
- 建议回复：{{ $json.suggested_reply }}

*操作链接*：
批准回复： {{ $json.approve_url }}?action=approve
修改后批准： https://your-n8n.com/form/modify-reply
拒绝（将升级处理）： {{ $json.approve_url }}?action=reject

Wait-Node empfängt Callback

Wenn eine Person auf den Link „Genehmigen“ klickt, wird eine GET-Anfrage an die Webhook-URL des Wait-Node gesendet, und der Workflow wird automatisch weiter ausgeführt.

Szenario 4: Geplante Wettbewerberüberwachung und wöchentliche Berichtserstellung

Erfasse automatisch jeden Montag Updates von Wettbewerbern, analysiere sie mit KI und generiere einen strukturierten Wochenbericht, wobei zwischen dringenden Warnungen und Routineberichten unterschieden wird.

Geschäftsszenario

Das Produktteam muss jeden Montagmorgen einen Bericht über Wettbewerberaktivitäten erhalten, der Blog-Updates, Produkteinführungen und Social-Media-Aktivitäten der Wettbewerber abdeckt.

Workflow-Design

Schedule Trigger（每周一 8:00）
  ↓
并行分支（4 个竞品，同时抓取）
├── HTTP Request → competitor1.com/blog/rss
├── HTTP Request → competitor2.com/blog/rss
├── HTTP Request → SerpAPI 搜索 "competitor3 release"
└── HTTP Request → GitHub API 查询 competitor4 最新 Release
  ↓
Merge（合并四路结果）
  ↓
Code（过滤：只保留过去 7 天的内容）
  ↓
AI Agent（
  分析所有条目，
  生成结构化的竞品周报，
  突出重大变化和值得关注的趋势
）
  ↓
IF 节点（有没有值得关注的重大变化？）
├── 有重大变化 → 发送 Slack 紧急提醒 + 发邮件周报
└── 无重大变化 → 只发邮件周报（减少噪音）
  ↓
Google Docs（创建本周报告文档）
  ↓
Notion（记录到知识库数据库）

Prompt für KI-generierte Wochenberichte

你是一个产品竞争情报分析师。

分析以下来自竞品的本周动态，生成一份结构化的竞品周报：

{{ $json.allItems }}

周报格式要求：
## 竞品动态周报 - {{ $now.format('YYYY年MM月DD日') }}

### 重大变化（需要立即关注）
[只列出明显的产品发布、定价调整、重大功能更新]

### 各竞品动态

#### Competitor A
- [本周更新摘要]

#### Competitor B
- [本周更新摘要]

### 值得关注的趋势
[跨竞品的共同趋势或信号]

### 建议行动
[基于本周动态的 1-3 条具体建议]

---
数据来源：RSS Feed + Google 搜索 + GitHub Releases
数据截止：{{ $now.format('YYYY-MM-DD HH:mm') }}

Fehlerbehandlung und Zuverlässigkeit

Produktions-Workflows müssen Fehler gut behandeln, um stille Fehler zu vermeiden – der Workflow schlägt fehl, aber du weißt es nicht.

Fehlerbehandlung auf Node-Ebene

Klicke auf einen Node, wähle den Tab Einstellungen und konfiguriere die folgenden Optionen:

Konfigurationseintrag	Beschreibung
Daten immer ausgeben	Daten an nachgelagerte Nodes weitergeben, auch wenn der Node fehlschlägt (geeignet für unkritische Schritte)
Einmal ausführen	Nur einmal ausführen, unabhängig davon, wie viele Datenelemente von vorgelagerten Nodes kommen
Bei Fehler wiederholen	Nach einem Fehler automatisch wiederholen; du kannst Maximale Versuche: 3, Wartezeit zwischen Versuchen: 2000ms festlegen
Bei Fehler fortfahren	Wenn der Node fehlschlägt, wird der Workflow nicht unterbrochen, aber der Fehler wird in der Ausgabe markiert.

Fehlerbehandlung auf Workflow-Ebene

Wähle in den Workflow-Einstellungen Error Workflow aus und gib einen Workflow zur Fehlerbehandlung an:

Error Trigger 节点
  ↓
Slack 节点（发送告警）：
  频道：#alerts
  消息：
  *工作流执行失败*
  工作流：{{ $json.workflow.name }}
  执行 ID：{{ $json.execution.id }}
  错误：{{ $json.execution.error.message }}
  发生时间：{{ $now.format('YYYY-MM-DD HH:mm:ss') }}

  查看执行详情： {{ $json.execution.url }}

Alarm-Workflows einrichten

Es wird empfohlen, einen dedizierten Workflow „System Monitoring“ zu erstellen:

Schedule Trigger（每 5 分钟）
  ↓
n8n API（获取最近失败的执行）
  ↓
IF 节点（有失败的执行吗？）
  ├── 是 → Slack 告警 + 记录到数据库
  └── 否 → 结束

OpenTelemetry-Integration (v2.16+)

n8n gibt jetzt OpenTelemetry-Trace-Daten für Workflow-Ausführungen aus.

Jede Ausführung wird zu einem Trace in deinem vorhandenen OpenTelemetry-Backend, ohne dass Sidecars, benutzerdefinierte Exporter oder Timing-Tricks erforderlich sind.

In .env konfigurieren:

N8N_METRICS=true
N8N_METRICS_PREFIX=n8n_
OTEL_EXPORTER_OTLP_ENDPOINT=http://your-otel-collector:4318

Versionskontrolle und Teamzusammenarbeit

Erziele Zusammenarbeit auf Teamebene durch Git-Integration, Projektisolierung und Variablenverwaltung.

Git-Integration (Business / Enterprise)

Für Produktionsbereitstellungen hilft die Git-Versionskontrolle, Workflow-Änderungen zu verwalten. Sie können alle Workflows in Git versionieren und sie über PRs prüfen, bevor Sie sie in die Produktion überführen – etwas, das in Zapier oder Make völlig unmöglich ist.

Konfigurationspfad: Wählen Sie in den Einstellungen Source Control aus:

Ein Git-Repository verbinden (GitHub / GitLab)
Bei jedem Speichern eines Workflows automatisch committen
Unterstützt die Synchronisierung zwischen verschiedenen Umgebungen (Entwicklung / Test / Produktion)

Projekte

Im Team-Plan und höher können Workflows in Projekten organisiert werden, mit Berechtigungsisolation zwischen Projekten, pro Projekt abgegrenzten Zugangsdaten und nach Projekt gefilterten Ausführungsprotokollen.

Variablenverwaltung

Umgebungsvariablen:

# 在 .env 文件中定义，在工作流里通过表达式引用
MY_API_BASE_URL=https://api.example.com

# 在节点中使用
{{ $env.MY_API_BASE_URL }}/endpoint

Variables-Knoten (Team-Plan und höher): Definieren Sie Variablen, indem Sie in der n8n-Oberfläche in den Einstellungen Variables auswählen; sie können ohne Neustart geändert werden und eignen sich zum Speichern häufig wechselnder Konfigurationswerte.

Preise und Planauswahl

Verstehen Sie die Kostenstrukturen von n8n Cloud und Self-Hosting und wählen Sie den Plan, der am besten zu Ihnen passt.

n8n Cloud-Pläne

Die n8n Cloud-Preise sind wie folgt:

Plan	Monatliche Gebühr (jährliche Abrechnung)	Ausführungen	Parallelität	Am besten geeignet für
Starter	€20/Monat	2,500/Monat	5	Persönliche Projekte, leichtes Testen
Pro	€50/Monat	10,000/Monat	20	Tägliche Automatisierung für kleine und mittlere Teams
Business	€667/Monat	40,000/Monat	Individuell	Enterprise, enthält SSO, Git, Multi-Umgebung
Enterprise	Individuell	Unbegrenzt	Unbegrenzt	Compliance-Anforderungen für große Unternehmen

Alle Pläne enthalten unbegrenzte Workflows und unbegrenzte Benutzer und werden nur nach Ausführungsvolumen abgerechnet. Update April 2026: n8n hat das Limit für aktive Workflows für alle Pläne entfernt. Jetzt hat jeder Plan unbegrenzte aktive Workflows, abgerechnet nur nach Ausführungsvolumen.

Selbstgehostete Community Edition (kostenlos)

Die n8n Community Edition ist völlig kostenlos und umfasst: unbegrenzte Workflow-Ausführungen (keine Obergrenze), 500+ Integrationsknoten, vollständige AI Agent-Workflows, MCP-Tool-Integration, Vector-Store-Knoten.

Sie zahlen nur für Serverkosten:

Konfiguration	Provider	Monatliche Gebühr	Am besten geeignet für
2 Kerne 4 GB	Hetzner CX22	€4.5/Monat	Persönlich / kleines Team
4 Kerne 8 GB	Hetzner CX32	€7.4/Monat	Mittlere Last
8 Kerne 16 GB	DigitalOcean	€40/Monat	Produktion mit hoher Parallelität

Wann Self-Hosting gewählt werden sollte

Self-Hosting erreicht den Break-even bei etwa 20,000 Ausführungen/Monat. Unterhalb dieses Volumens ist n8n Cloud kosteneffektiver (spart Betriebszeit). Oberhalb dieses Volumens beginnen sich die Einsparungen durch Self-Hosting deutlich zu vervielfachen.

Fälle, in denen Self-Hosting geeignet ist:

Ausführungsvolumen überschreitet das Limit des Pro-Plans (10,000/Monat)
Daten dürfen Ihre eigene Infrastruktur nicht verlassen (Finanzen, Gesundheitswesen, Behörden)
Verbindung zu On-Premises-Datenbanken oder privaten APIs erforderlich
Volle Kontrolle über den Update-Rhythmus gewünscht

Fälle, in denen n8n Cloud geeignet ist:

Das Team verfügt nicht über DevOps-Kenntnisse
Ausführungsvolumen zwischen 2,500-10,000/Monat
Erfordert schnellsten Start (registrieren und loslegen)

Vergleich mit Zapier / Make

Vergleichen Sie die drei Plattformen anhand von Dimensionen wie Anzahl der Integrationen, Preismodell, Code-Funktionen und Eignung für technische Teams.

n8n hat dasselbe Ausführungsvolumen wie Zapier und Make, ist aber bei komplexen Workflows kostengünstiger.

Zapier hat mehr Integrationen (6,000+ vs. 500+ bei n8n), berechnet aber pro Schritt, was es für mehrstufige Workflows deutlich teurer macht.

Make ist die günstigste Cloud-Option für einfache Workflows, aber die Kosten steigen in komplexen Szenarien schnell (jedes Modul = 1 Operation).

Dimension	Zapier	Make	n8n
Anzahl der Integrationen	6,000+	1,500+	500+ (+Community)
Preismodell	Pro Aufgabe (Abrechnung pro Schritt)	Pro Operation (Abrechnung pro Node)	Pro Ausführung (gesamter Workflow)
Code-Unterstützung	Eingeschränktes JavaScript	Keine	Vollständiges JS + Python
Self-Hosting	Nicht unterstützt	Nicht unterstützt	Vollständig unterstützt
KI-Agent	Eingeschränkt	Eingeschränkt	Nativ und vollständig
Git-Versionskontrolle	Nicht unterstützt	Nicht unterstützt	Unterstützt (Business+)
Lernkurve	Niedrig	Niedrig	Mittel
Eignung für technische Teams	Niedrig	Mittel	Hoch

Zusammenfassung: Wenn Sie einen technischen Hintergrund haben oder Ihre Workflow-Komplexität 3-5 Schritte überschreitet, ist n8n fast immer die bessere Wahl. Wenn Sie völlig nicht-technisch sind und nur zwei gängige SaaS-Apps verbinden müssen, ist Zapier weniger umständlich.

Ressourcen

Empfohlene Lernpfade und verwandte Ressourcen, die Ihnen helfen, in n8n vom Anfänger zum Experten zu werden.

Empfohlener Lernpfad

本地安装 n8n，跑通第一个 Hello World 工作流
    ↓
完成「HN 早报」案例，熟悉 Schedule + HTTP + Slack
    ↓
配置 3-5 个你日常工作的凭证（GitHub/Slack/Google）
    ↓
完成「文档处理流水线」场景，学会 AI Agent 节点
    ↓
用 Docker Compose + PostgreSQL 搭建自托管实例
    ↓
配置错误处理工作流，建立监控告警
    ↓
配置 MCP Server Trigger，让 Claude Desktop 调用你的工作流
    ↓
（团队）启用 Git 集成，建立开发/生产双环境

Offizielle Ressourcen

Ressource	Link	Beschreibung
Offizielle Website	n8n.io	Produktinformationen und Registrierungseinstieg
Dokumentation	docs.n8n.io	Vollständige Produktdokumentation
Workflow-Vorlagen	n8n.io/workflows	1,000+ Community-Vorlagen, Import mit einem Klick
GitHub	github.com/n8n-io/n8n	Fair-Code-Lizenz, Quellcode verfügbar
Community-Forum	community.n8n.io	Technische Fragen und Antworten sowie Diskussionen
Blog	blog.n8n.io	Funktionsupdates und Anwendungsfälle
Versionshinweise	docs.n8n.io/release-notes	Inhalte der Versionsupdates

Gängige Workflow-Vorlagen

Suchen Sie im Vorlagen-Marketplace nach den folgenden Schlüsselwörtern, um entsprechende Vorlagen schnell zu finden:

Szenario	Vorlagen-Suchbegriff
Slack-Benachrichtigungsbot	"slack notification"
GitHub-Automatisierung	"github automation"
KI-E-Mail-Verarbeitung	"email AI classification"
Airtable-Synchronisierung	"airtable sync"
Datenbank-ETL	"database sync"
KI-Agent	"AI agent tools"

Weitere Erweiterungen

Agent-Tools

Intelligente Agents mit Python implementieren

n8n Erste-Schritte-Tutorial

Unterschiede zwischen Dify und n8n

Für wen ist es gedacht?

Kernkonzepte

Workflow

Knoten

Ausführung

Verbindung

Zugangsdaten

Ausdruck

Installation und Start

Methode 1: Schneller lokaler Test (Am schnellsten, 5 Minuten)

Methode 2: Docker-Einzelcontainer (Empfohlen für Einzelpersonen und kleine Teams)

Methode 3: Docker Compose + PostgreSQL (Empfohlen für Produktionsumgebungen)

Methode 4: Reverse Proxy konfigurieren (Nginx + HTTPS)

Methode 5: Kubernetes (Hochverfügbarkeit, Enterprise-tauglich)

Systemanforderungen

Tour durch die Oberfläche: n8n zum ersten Mal öffnen

Linke Navigationsleiste

Workflow-Canvas

Node-Panel

Obere Symbolleiste

Erstellen Sie Ihren ersten Workflow

Schritt 1: Workflow erstellen

Schritt 2: Schedule-Trigger hinzufügen

Schritt 3: HN-Daten abrufen

Schritt 4: Auf die ersten 5 Elemente begrenzen

Beispiel

Schritt 5: Details für jeden Artikel parallel abrufen

Schritt 6: Nachricht formatieren

Beispiel

Schritt 7: An Slack senden

Schritt 8: Testlauf

Schritt 9: Workflow aktivieren

Detaillierte Erklärung gängiger Knoten

Trigger-Knoten

Knoten zur Datenverarbeitung

HTTP Request (der zentrale Knoten)

Code (JavaScript / Python)

Beispiel

Beispiel

Set (Variablen setzen)

IF (bedingte Verzweigung)

Switch (Mehrfachverzweigung)

Loop Over Items (Schleife)

Merge (kombinieren)

Wait (Warten/Human-in-the-Loop)

Auf Webhook antworten (Antwort an Webhook)

Datenbankknoten

Verwaltung von Anmeldedaten: Externe Dienste sicher verbinden

Anmeldedaten hinzufügen

Häufige Konfigurationen für Anmeldedaten

Slack（OAuth）

GitHub（Personal Access Token）

OpenAI / Anthropic（API Key）

Allgemeiner HTTP-Header (beliebige API)

AI-Agent-Knoten: Workflows zum Denken bringen

Komponenten des AI-Agent-Knotens

AI-Agent konfigurieren

Agent-Typ auswählen

MCP-Integration: Anbindung an das KI-Ökosystem

n8n als MCP-Client (Aufrufen externer Tools)

n8n als MCP-Server (Workflows bereitstellen)

Beispiel

MCP-Server auf Instanzebene

Praktisches Szenario 1: Automatische Klassifizierung und Benachrichtigung bei GitHub-Issues

Geschäftsszenario

Workflow-Design

Wichtige Knotenkonfiguration

Schritt 1: GitHub-Webhook konfigurieren

Schritt 2: Neue Ereignisse filtern

Schritt 3: KI-Klassifizierungs-Node

Schritt 4: KI-Ausgabe parsen

Schritt 5: Switch-Routing

Schritt 6: Labels hinzufügen + Kommentare posten

Schritt 7: Slack-Benachrichtigung

Szenario 2: KI-Dokumentenverarbeitungs-Pipeline (Rechnungs-/Vertragsextraktion)

Geschäftsszenario