Tutoriel de prise en main de n8n

n8n (prononcé « n-eight-n », abréviation de « nodemation ») est actuellement la plateforme d'automatisation de workflows open source la plus prisée par les équipes techniques.

Les principaux atouts de n8n sont : un canevas visuel + la prise en charge native du code + l'auto-hébergement complet — il permet aux non-développeurs de construire par glisser-déposer, permet aux développeurs d'écrire du JavaScript ou du Python dans n'importe quel nœud, et peut s'exécuter sur vos propres serveurs avec les données qui restent locales.

n8n est une plateforme d'automatisation de workflows qui vous permet d'intégrer l'IA dans votre travail et vos processus de manière sûre et contrôlable.

n8n combine une expérience de construction visuelle avec des capacités de codage — vous pouvez écrire du JavaScript ou du Python n'importe où dans le workflow et visualiser instantanément les résultats à côté des entrées et sorties de chaque étape.

Différences entre Dify et n8n

Contrairement à Dify, le cœur de n8n est l'automatisation généraliste et l'intégration système, où l'IA est un composant puissant, tandis que le cœur de Dify est le développement d'applications d'IA, où l'automatisation est une capacité auxiliaire.

En bref :

Si vous devez connecter plusieurs systèmes SaaS et faire circuler des données entre eux : n8n est le meilleur choix
Si vous devez créer une application centrée sur la conversation IA (bot de service client, questions-réponses RAG) : Dify est le meilleur choix

À qui s'adresse-t-il ?

L'interface visuelle de n8n permet aux non-développeurs de concevoir et tester rapidement des workflows. À mesure que la complexité augmente, les développeurs peuvent l'étendre avec des nœuds Function, des scripts externes ou des intégrations personnalisées.

Cela permet aux équipes d'ajouter progressivement de la structure, de la validation et du contrôle.

Les groupes d'utilisateurs les plus typiques :

Groupe d'utilisateurs	Scénarios typiques
Équipes opérationnelles	Automatisation des mises à jour CRM, génération de rapports, envoi d’e-mails
Développeurs	Intégration API, pipelines de données, automatisation des outils internes
Ingénieurs de données	Pipelines ETL, nettoyage des données, synchronisation planifiée
Équipes informatiques	Alertes de surveillance, réponse aux incidents, gestion des utilisateurs
Startups tech	Construire rapidement la couche d’automatisation backend pour un MVP

Concepts fondamentaux

Avant de commencer à apprendre, commençons par comprendre ces concepts clés.

Workflow

Un workflow est un graphe orienté d'une série de nœuds, définissant la logique « lorsque X se produit, exécuter Y, puis exécuter Z ».

Un workflow a deux états : lorsqu'il est Actif, il répond aux déclencheurs et s'exécute automatiquement ; lorsqu'il est Inactif, il ne peut être exécuté que manuellement pour les tests.

Nœud

Le bloc de construction de base d'un workflow ; chaque nœud effectue une opération spécifique :

Type de nœud	Couleur	Description
Nœud déclencheur	Orange	Le point de départ d'un workflow, définissant quand il se déclenche
Nœud standard	Bleu	Traiter des données, appeler des API, exécuter la logique
Nœuds liés à l'IA	Violet	Appels LLM, stockage vectoriel, Agent

Exécution

Une exécution complète d'un workflow est appelée une exécution.

Le modèle de facturation des exécutions de n8n est : une exécution = le workflow s'exécute une fois, quel que soit le nombre d'étapes qu'il contient ou la quantité de données qu'il traite.

Connexion

Les flèches entre les nœuds définissent le flux de données et l'ordre d'exécution. Un nœud peut avoir plusieurs sorties pour implémenter une logique de branchement.

Identifiant

Un conteneur sécurisé pour stocker des informations sensibles telles que des clés API, des jetons OAuth, des mots de passe de base de données, etc.

Les identifiants sont chiffrés pour le stockage et peuvent être partagés entre plusieurs workflows sans être exposés en clair dans le JSON du workflow.

Expression

La syntaxe de valeur dynamique de n8n, entourée d'accolades doubles :{{ $json.fieldName }}。

Permet aux paramètres d'un nœud de référencer les sorties des nœuds en amont au lieu de valeurs fixes.

Installation et démarrage

Cinq méthodes d'installation, du démarrage rapide local au déploiement haute disponibilité de niveau entreprise.

Méthode 1 : Essai local rapide (le plus rapide, 5 minutes)

Utilisez npx ou une installation globale, aucune configuration supplémentaire requise.

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

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

Ouvrez votre navigateur et rendez-vous sur http://localhost:5678, terminez l'inscription du compte et vous êtes prêt à l'utiliser.

Si vous oubliez votre mot de passe e-mail, utilisez la commandenpx n8n user-management:resetpour réinitialiser.

Méthode 2 : Conteneur Docker unique (recommandé pour les particuliers et les petites équipes)

Démarrez avec une seule commande, les données sont persistées dans un répertoire local.

# 创建数据持久化目录
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

Visitez http://localhost:5678 pour terminer la configuration.

Méthode 3 : Docker Compose + PostgreSQL (recommandé pour les environnements de production)

Convient aux environnements de production, les données sont stockées dans PostgreSQL, ce qui permet un accès concurrent plus stable.

Créez 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:

Créez un fichier .env :

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

Générez une clé de chiffrement sécurisée :

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

Démarrer le service :

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

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

Méthode 4 : Configurer un proxy inverse (Nginx + HTTPS)

] Pour un déploiement en production, il est recommandé de configurer Nginx pour faciliter la liaison de domaine et HTTPS.

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 "";
    }
}

] Demander un certificat SSL (Let's Encrypt) :

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

Méthode 5 : Kubernetes (haute disponibilité, niveau entreprise)

] Pour les équipes nécessitant une haute disponibilité, utilisez le Helm Chart officiel.

# 添加 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

] L'architecture haute disponibilité nécessite de configurer le "Queue Mode", en utilisant Redis comme file d'attente de messages, ce qui permet à plusieurs nœuds Worker de traiter les tâches en parallèle.

Configuration système requise

] Recommandations matérielles pour différents scénarios d'utilisation :

] Scénario	CPU	] Mémoire	] Disque
] Développement/Test	] 1 cœur	1 GB	10 GB
] Production en petite équipe	] 2 cœurs	4 GB	20 GB
] Charge moyenne	] 4 cœurs	8 GB	50 GB

Recommandation de base de données : n8n utilise SQLite par défaut, mais PostgreSQL est fortement recommandé pour les environnements de production. PostgreSQL offre de meilleures performances, prend en charge l'accès concurrent et est plus facile à sauvegarder.

Visite de l'interface : Première ouverture de n8n

Apprenez les principales zones de l'interface de n8n et démarrez rapidement.

Barre de navigation de gauche

Icône/Zone	Fonction
Liste des workflows	Afficher, rechercher et créer des workflows
Historique d'exécution	Afficher les enregistrements d'exécution de tous les workflows
Identifiants	Gérer les informations sensibles telles que les clés API et OAuth
Variables	Variables globales (fonctionnalité Équipe/Entreprise)
Paramètres	Configuration de l'instance, gestion des utilisateurs

Nous pouvons configurer un fournisseur d'API, tel que DeepSeek. Cliquez sur le menu Nouveau chat, cliquez sur le modèle dans le coin supérieur gauche, puis sélectionnez DeepSeek dans la liste déroulante :

Configurez ensuite la clé API :

Après une configuration réussie, cliquez sur le modèle dans le coin supérieur gauche et sélectionnez le modèle DeepSeek dans la liste déroulante :

Vous pouvez maintenant commencer à discuter :

Canevas de workflow

Raccourcis d'opérations du canevas :

Opération	Raccourci/Méthode
Ajouter un nœud	Cliquez sur le bouton + pour ajouter entre deux nœuds
Rechercher un nœud	Ctrl+K pour rechercher et ajouter rapidement
Déplacer le canevas	Glisser dans une zone vide
Zoomer sur le canevas	Molette de la souris
Sélectionner tous les nœuds	Ctrl+A
Supprimer le nœud	Appuyez sur Delete pour supprimer le nœud sélectionné

Panneau du nœud

Cliquez sur n'importe quel nœud pour ouvrir le panneau de configuration, qui comporte trois onglets :

Onglet	Fonction
Parameters	Configuration principale du nœud
Paramètres	Contrôle de l'exécution (réessai, délai d'attente, gestion des erreurs)
Notes	Ajouter un texte de description au nœud

Barre d’outils supérieure

Bouton	Fonction
Exécuter le workflow	Déclencher manuellement une exécution
Save	Enregistrer les modifications en cours
Bouton bascule d’activation	Activer/désactiver le workflow

Créez votre premier workflow

Commencez avec un exemple complet : récupérez automatiquement les articles les plus populaires de Hacker News à 8 h chaque jour, mettez-les en forme et envoyez-les dans un canal Slack.

Étape 1 : Créer un workflow

À gauche, sélectionnez Workflows, cliquez sur New Workflow et renommez-le en « HN Morning Report ».

Étape 2 : Ajouter un Schedule Trigger

Cliquez sur le bouton +, recherchez « Schedule » et sélectionnez Schedule Trigger.

Notes de configuration :

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

Étape 3 : Récupérer les données HN

À droite du Schedule Trigger, cliquez sur +, recherchez « HTTP Request » et ajoutez un nœud.

Configuration :

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

Cela renvoie un tableau d'ID pour les articles les plus populaires du moment (jusqu'à 500).

Étape 4 : Limiter aux 5 premiers éléments

Ajoutez un nœud Code, écrivez du JavaScript :

Exemple

// Prendre les 5 premiers ID d'articles, les renvoyer sous forme d'objets JSON individuels
const topIds = $input.first().json.slice(0, 5);
return topIds.map(id => ({ json: { id } }));

Étape 5 : Récupérer les détails de chaque article en parallèle

Ajoutez un nœud HTTP Request.

n8n exécute automatiquement en parallèle pour chaque élément provenant du nœud en amont, pas besoin d'écrire des boucles manuellement.

Configuration :

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

Étape 6 : Formater le message

Ajoutez un nœud Code :

Exemple

Étape 7 : Envoyer à Slack

Ajoutez un nœud Slack (complétez d'abord la configuration des identifiants Slack, voir le chapitre Gestion des identifiants).

Configuration :

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

Étape 8 : Exécution du test

Cliquez sur le bouton Exécuter le workflow en haut, et observez les nombres apparaissant à côté de chaque nœud (indiquant le nombre d'éléments de données traités).

Cliquez sur n'importe quel nœud pour afficher ses données d'entrée et de sortie.

Étape 9 : Activer le workflow

Une fois le test réussi, basculez l'interrupteur Active dans le coin supérieur droit. Le workflow passe à l'état actif et s'exécutera automatiquement à 8 h chaque jour ouvré.

Explication détaillée des nœuds courants

Maîtrisez les types de nœuds les plus courants, couvrant trois grandes catégories : déclencheurs, traitement des données et bases de données.

Nœuds déclencheurs

Les déclencheurs sont le point de départ d'un workflow, définissant quand l'exécution doit commencer.

Nœud	Type de déclencheur	Scénarios typiques
Déclencheur planifié	Planifié (expression cron)	Rapports quotidiens, synchronisation planifiée
Webhook	Déclencheur de requête HTTP	Recevoir des événements Stripe/GitHub
Déclencheur de chat	Messages de conversation IA	Piloter les workflows d'agents IA
Déclencheur d'e-mail (IMAP)	Nouvel e-mail reçu	Traiter les demandes par e-mail
Déclencheur Slack	Événements Slack	Répondre aux commandes Slash

Nœuds de traitement des données

Requête HTTP (le nœud central)

Peut appeler presque n'importe quelle API REST :

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

Prend en charge la pagination automatique, ce qui vous permet de récupérer toutes les données sans écrire de logique de boucle.

Code（JavaScript / Python）

Exemple JavaScript :

Exemple

// Traiter tous les éléments provenant de l'amont
for (const item of $input.all()) {
// Ajouter un horodatage de traitement à chaque élément de données
item.json.processedAt = new Date().toISOString();
}
return $input.all();

Exemple Python :

Exemple

# Python prend également cela en charge, utilisez _input pour accéder aux données en amont
for item in _input.all():
item.json["processed"] = True
return _input.all()

Set (définir des variables)

Définir, modifier et supprimer visuellement des champs sans écrire de code.

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

IF (branche conditionnelle)

Acheminez les données vers différentes branches en fonction de conditions :

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

Switch (multi-branche)

Similaire à IF, mais prend en charge plusieurs conditions (comme switch-case), acheminant les données vers différents chemins de traitement.

Loop Over Items (boucle)

Traiter chaque élément d'un tableau un par un, adapté aux scénarios nécessitant un contrôle de débit plutôt qu'un traitement parallèle.

Merge (combiner)

Combiner les données de plusieurs branches, en prenant en charge des stratégies telles que Append, Keep Key Matches, Combine By Position.

Wait (attente/Intervention humaine)

Suspendre l'exécution du flux de travail et attendre que les conditions suivantes soient remplies avant de continuer :

Continuer automatiquement après un certain temps
Continuer après réception d'un rappel Webhook (cœur du Human-in-the-Loop)
Continuer après la soumission d'un formulaire spécifique

Répondre au Webhook (réponse au Webhook)

Dans un workflow qui reçoit un Webhook, retourner de manière synchrone une réponse au demandeur.

Nœuds de base de données

Nœud	Opérations prises en charge
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	Via le nœud REST ou PostgreSQL

Gestion des identifiants : Connexion sécurisée aux services externes

Les identifiants sont le mécanisme unifié dans n8n pour gérer toutes les informations d'authentification ; tous les identifiants sont chiffrés et stockés dans la base de données à l'aide de N8N_ENCRYPTION_KEY.

Les équipes peuvent partager des identifiants sans voir le contenu secret réel.

Ajouter un identifiant

Il existe deux façons d'ajouter des identifiants :

Sélectionnez Identifiants dans la navigation de gauche, puis cliquez sur Ajouter un identifiant.
Dans la configuration du nœud, cliquez sur la liste déroulante des identifiants et sélectionnez Créer un nouvel identifiant.

Configurations courantes des identifiants

Slack（OAuth）

Accédez àapi.slack.com/appsCréer une application
Activez les portées du jeton de bot (chat:write, channels:read)
Installez l'application dans l'espace de travail et copiez le jeton de bot (commençant par xoxb-).
Dans n8n, sélectionnez Slack et collez le jeton de bot.

GitHub（Jeton d'accès personnel）

Dans GitHub, sélectionnez Paramètres, allez dans Paramètres développeur, sélectionnez Jetons d'accès personnels, et cliquez sur Générer un nouveau jeton.
Sélectionnez les autorisations requises (repo, issues, etc.)
Copiez le jeton et ajoutez un identifiant GitHub dans n8n.

OpenAI / Anthropic（Clé API）

Obtenez la clé API depuis la console de chaque fournisseur.
Dans n8n, sélectionnez Identifiants, recherchez "OpenAI" ou "Anthropic", et collez la clé.

En-tête HTTP générique (toute API)

Pour les services sans nœud dédié dans n8n, utilisez le nœud HTTP Request avec des identifiants Header Auth :

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

Nœud AI Agent : faire réfléchir les workflows

Le nœud AI Agent natif de n8n vous permet de créer des workflows intelligents et autonomes qui utilisent de grands modèles de langage pour prendre des décisions, traiter le langage naturel et effectuer un raisonnement en plusieurs étapes.

Composants du nœud AI Agent

Le nœud AI Agent est un « nœud cluster » composé de trois types de sous-nœuds :

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 服务器）

Configurer l'AI Agent

Étape 1 : Ajouter le nœud AI Agent.

Recherchez AI Agent sur le canevas de workflow et sélectionnez Tools Agent (le type d'agent le plus polyvalent).

Étape 2 : Ajouter un Chat Model.

Cliquez sur l'emplacement Chat Model en bas du nœud AI Agent et ajoutez l'Anthropic Chat Model.

Configuration :

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

Étape 3 : Configurer le System Prompt.

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

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

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

Étape 4 : Ajouter des outils.

Cliquez sur Ajouter un outil pour ajouter les nœuds d’outil requis.

Chaque outil nécessite de configurer un nom d’outil (l’Agent utilise ce nom pour décider quand l’appeler) et une description d’outil (indique à l’Agent ce que cet outil peut faire).

Sélection du type d’Agent

Type d’Agent	Scénarios adaptés
Agent d’outils (recommandé)	Usage général, prend en charge l’appel de fonctions, meilleur choix pour les LLM modernes
Agent ReAct	Raisonnement + Action, adapté aux tâches nécessitant un raisonnement en plusieurs étapes
Agent de planification et d’exécution	Formulez d’abord un plan complet, puis exécutez étape par étape
Agent conversationnel	Conversationnel, avec mémoire intégrée, adapté aux chatbots
SQL Agent	Spécialisé dans le traitement des requêtes de base de données
OpenAI Functions Agent	Appel de fonctions exclusif à OpenAI

Intégration MCP : connexion à l’écosystème de l’IA

n8n a une double identité dans l’écosystème MCP (Model Context Protocol) : il peut à la fois consommer des services MCP (en tant que client MCP) et exposer des workflows en tant que services MCP (en tant que serveur MCP).

n8n en tant que client MCP (appel d’outils externes)

Utilisez le nœud MCP Client Tool pour vous connecter à n’importe quel serveur MCP.

Le nœud MCP Client Tool prend en charge les méthodes d’authentification Bearer, Header générique, Header multiple et OAuth2.

Exemple de configuration : connexion à un serveur MCP GitHub

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

Connectez le nœud MCP Client Tool à l’emplacement Tools de l’AI Agent, et l’Agent peut directement appeler les outils MCP de GitHub (lister les Issues, créer des PR, consulter le code, etc.).

n8n en tant que serveur MCP (exposition de workflows)

Utilisez le nœud MCP Server Trigger pour faire de n8n un serveur MCP, exposant les outils et workflows n8n aux clients MCP.

Il fonctionne en exposant une URL, avec laquelle les clients MCP peuvent interagir pour accéder aux outils n8n.

Étapes de configuration :

Créez un nouveau workflow et ajoutez le nœud MCP Server Trigger
Le nœud génère automatiquement une URL de test et une URL de production (format : https://your-n8n.com/mcp/xxxxxxxx)
À côté du MCP Server Trigger, connectez les nœuds d’outils que vous souhaitez exposer.

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

Publiez le workflow (cliquez sur Publier)

Utilisation dans Claude Desktop :

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

Exemple

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

Serveur MCP au niveau de l'instance

En avril 2026, n8n a lancé des serveurs MCP au niveau de l'instance.

Il permet aux clients IA (Claude Desktop, Cursor, etc.) de créer, valider, tester et publier directement des workflows entiers en langage naturel — c'est un outil de développement, pas un outil d'exécution.

Comment l'activer (auto-hébergé) :

N8N_MCP_ACCESS_ENABLED=true

Après l'activation, votre Claude Desktop ou un autre client MCP peut directement demander à n8n : « Crée un workflow qui envoie la liste des PR GitHub sur Slack chaque matin », et n8n construira automatiquement ce workflow.

Scénario pratique 1 : Classification et notification automatiques des Issues GitHub

Utilisez un agent IA pour classer automatiquement les Issues GitHub et les acheminer vers différents assignés et canaux selon leur type.

Scénario métier

Les projets open source reçoivent un grand nombre d'Issues chaque jour et doivent les classer automatiquement (Bug / Demande de fonctionnalité / Question / Docs) et notifier les personnes responsables.

Conception du Workflow

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 节点（发送通知到对应频道）

Configuration des nœuds clés

Étape 1 : Configurer le Webhook GitHub

Dans le dépôt GitHub, sélectionnez Settings, allez dans Webhooks, puis cliquez sur Add Webhook :

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

Ajoutez un nœud Webhook dans n8n :

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

Étape 2 : Filtrer les nouveaux événements

Ajoutez un nœud IF :

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

Seuls les événements avec action === "opened" sont traités par la suite ; les événements labeled, closed et autres sont écartés directement.

Étape 3 : Nœud de classification IA

Ajoutez un nœud AI Agent et configurez le 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：优化建议、文档改善

Configurez le User message à l'aide d'une expression :

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

Étape 4 : Analyser la sortie de l'IA

Ajoutez un nœud Code pour analyser le JSON (car l'IA peut produire du JSON avec des blocs de code Markdown) :

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 }];

Étape 5 : Routage avec Switch

Ajouter un nœud Switch :

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

Étape 6 : Ajouter des étiquettes + publier des commentaires

Ajouter un nœud GitHub pour chaque branche (deux opérations).

Nœud GitHub (ajouter une étiquette) :

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（根据分支不同填不同标签）

Nœud GitHub (publier un commentaire, branche de question uniquement) :

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

Étape 7 : Notification Slack

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 }}

Scénario 2 : Pipeline de traitement de documents par IA (extraction de factures/contrats)

Utiliser l'IA pour extraire automatiquement les informations de facture à partir des pièces jointes d'e-mail et les stocker de manière structurée dans Google Sheets.

Scénario métier

Le scénario d'entrée de gamme à la plus forte valeur est le workflow de traitement de documents par IA. Le modèle est le suivant : déclencher la réception de documents via Webhook ou des pièces jointes d'e-mail, transmettre le contenu du document à un nœud IA, utiliser des instructions au format JSON pour extraire des données structurées, puis écrire les résultats dans Google Sheets, Airtable ou une base de données. Ce seul workflow peut faire économiser à une petite équipe d'opérations 2-4 heures de saisie manuelle de données chaque jour.

Objectif : Extraire les champs clés d'une facture PDF jointe à un e-mail à l'aide de l'IA, les écrire dans Google Sheets et envoyer une confirmation.

Conception du Workflow

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

Configuration des nœuds clés

Email Trigger（IMAP）

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

Prompt pour extraire les informations de facture

Utilisez le nœud AI Agent, ou utilisez directement le nœud Anthropic Chat Model (plus rentable) :

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 }}

Nœud Google Sheets

Configuration :

Resource：Sheet Within Document
Operation：Append Row

Mapper les champs (utilisez des expressions pour référencer la sortie de l'IA) :

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

Scénario 3 : Routage du service client multicanal (avec Human-in-the-Loop)

Fusionnez les tickets du service client provenant de plusieurs canaux, utilisez l'IA pour les classer, traitez automatiquement ceux de faible priorité et attendez l'approbation manuelle pour ceux de haute priorité.

Scénario métier

Les tickets du service client affluent depuis plusieurs canaux (e-mail, Slack, formulaires), nécessitant une analyse initiale par IA et un routage basé sur la priorité. Les tickets complexes nécessitent une approbation manuelle avant réponse.

Conception du Workflow

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

Configuration centrale de Human-in-the-Loop

Nœud Wait (attendre une approbation manuelle)

Ceci est le nœud central pour implémenter Human-in-the-Loop dans n8n :

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

Envoyer une demande d'approbation (vers Slack)

Avant le nœud Wait, utilisez le nœud Slack pour envoyer un message d'approbation :

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

Le nœud Wait reçoit le callback

Lorsqu'un humain clique sur le lien « Approuver », une requête GET est envoyée à l'URL Webhook du nœud Wait, et le workflow poursuit automatiquement son exécution.

Scénario 4 : Surveillance planifiée des concurrents et génération de rapports hebdomadaires

Capturer automatiquement les mises à jour des concurrents chaque lundi, utiliser l'IA pour les analyser et générer un rapport hebdomadaire structuré, en distinguant les alertes urgentes des rapports de routine.

Scénario métier

L'équipe produit doit recevoir un rapport d'activité des concurrents chaque lundi matin, couvrant les mises à jour des blogs des concurrents, les lancements de produits et l'activité sur les réseaux sociaux.

Conception du Workflow

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（记录到知识库数据库）

Invite pour les rapports hebdomadaires générés par IA

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

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

{{ $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') }}

Gestion des erreurs et fiabilité

Les workflows de production doivent bien gérer les échecs pour éviter les échecs silencieux — le workflow produit une erreur, mais vous ne le savez pas.

Gestion des erreurs au niveau du nœud

Cliquez sur un nœud, sélectionnez l'onglet Paramètres, puis configurez les options suivantes :

Élément de configuration	Description
Toujours produire des données	Transmettre les données en aval même si le nœud échoue (adapté aux étapes non critiques)
Exécuter une fois	Exécuter une seule fois, quel que soit le nombre d'éléments de données provenant en amont
Réessayer en cas d'échec	Réessayer automatiquement après un échec ; vous pouvez définir Max Tries: 3, Wait Between Tries: 2000ms
Continuer en cas d'échec	Si le nœud échoue, le workflow n'est pas interrompu, mais l'erreur est marquée dans la sortie

Gestion des erreurs au niveau du workflow

Dans les paramètres du workflow, sélectionnez Error Workflow et spécifiez un workflow de gestion des erreurs :

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 }}

Configuration des workflows d'alerte

Il est recommandé de créer un workflow dédié 'System Monitoring' :

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

Intégration OpenTelemetry (v2.16+)

n8n émet désormais des données de trace OpenTelemetry pour les exécutions de workflow.

Chaque exécution devient une trace dans votre backend OpenTelemetry existant, sans avoir besoin de sidecars, d’exportateurs personnalisés ni d’astuces de minutage.

Configurer dans .env :

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

Gestion de versions et collaboration d’équipe

Obtenez une collaboration à l’échelle de l’équipe grâce à l’intégration Git, à l’isolation des projets et à la gestion des variables.

Intégration Git (Business / Enterprise)

Pour les déploiements en production, la gestion de versions Git aide à gérer les modifications de workflows. Vous pouvez versionner tous les workflows dans Git et les examiner via des PR avant de les promouvoir en production—ce qui est totalement impossible dans Zapier ou Make.

Chemin de configuration : sélectionnez Contrôle de code source dans Paramètres :

Connecter un dépôt Git (GitHub / GitLab)
Effectuer automatiquement un commit chaque fois qu’un workflow est enregistré
Prend en charge la synchronisation entre différents environnements (développement / test / production)

Projets

Dans le forfait Team et les forfaits supérieurs, les workflows peuvent être organisés en projets, avec une isolation des permissions entre les projets, des identifiants propres à chaque projet et des journaux d’exécution filtrés par projet.

Gestion des variables

Variables d'environnement :

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

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

Nœud Variables (offre Team et supérieure) : définissez des variables en sélectionnant Variables dans Paramètres de l'interface n8n ; elles peuvent être modifiées sans redémarrage et conviennent pour stocker des valeurs de configuration fréquemment modifiées.

Tarification et sélection de l'offre

Comprenez les structures de coûts de n8n Cloud et de l'auto-hébergement, et choisissez l'offre qui vous convient le mieux.

Offres n8n Cloud

La tarification de n8n Cloud est la suivante :

Forfait	Frais mensuels (facturés annuellement)	Exécutions	Concurrence	Idéal pour
Starter	€20/mois	2,500/mois	5	Projets personnels, tests légers
Pro	€50/mois	10,000/mois	20	Automatisation quotidienne pour petites et moyennes équipes
Business	€667/mois	40,000/mois	Personnalisé	Entreprise, comprend SSO, Git, multi-environnements
Entreprise	Personnalisé	Illimité	Illimité	Besoins de conformité pour les grandes entreprises

Tous les forfaits incluent des workflows illimités et des utilisateurs illimités, et sont facturés uniquement en fonction du volume d'exécutions. Mise à jour avril 2026 : n8n a supprimé la limite de workflows actifs pour tous les forfaits. Désormais, chaque forfait dispose de workflows actifs illimités, facturés uniquement en fonction du volume d'exécutions.

Community Edition auto-hébergée (gratuite)

n8n Community Edition est entièrement gratuite et comprend : exécutions de workflows illimitées (sans plafond), plus de 500 nœuds d'intégration, workflows AI Agent complets, intégration des outils MCP, nœuds de vector store.

Vous ne payez que les coûts de serveur :

Configuration	Provider	Frais mensuels	Idéal pour
2 cores 4 GB	Hetzner CX22	€4.5/month	Personnel / petite équipe
4 cores 8 GB	Hetzner CX32	7.4 €/mois	Charge moyenne
8 cœurs 16 GB	DigitalOcean	40 €/mois	Production à forte concurrence

Quand choisir l'auto-hébergement

L'auto-hébergement devient rentable à partir d'environ 20,000 exécutions/mois. En dessous de ce volume, n8n Cloud est plus rentable (en vous économisant du temps d'exploitation). Au-dessus de ce volume, les économies réalisées grâce à l'auto-hébergement commencent à s'accumuler de manière significative.

Cas où l'auto-hébergement est approprié :

Le volume d'exécutions dépasse la limite du plan Pro (10,000/mois)
Les données ne peuvent pas quitter votre propre infrastructure (finance, santé, gouvernement)
Besoin de se connecter à des bases de données sur site ou à des API privées
Vouloir un contrôle total sur la fréquence des mises à jour

Cas où n8n Cloud est adapté :

L’équipe ne dispose pas de compétences DevOps
Volume d'exécutions entre 2,500-10,000/month
Nécessite le démarrage le plus rapide (s'inscrire et démarrer)

Comparaison avec Zapier / Make

Comparez les trois plateformes selon des dimensions telles que le nombre d'intégrations, le modèle de tarification, les capacités de code et l'adéquation aux équipes techniques.

n8n a le même volume d'exécutions que Zapier et Make, mais un coût inférieur pour les workflows complexes.

Zapier propose plus d'intégrations (6,000+ vs 500+ pour n8n), mais facture par étape, ce qui le rend beaucoup plus cher pour les workflows à plusieurs étapes.

Make est l'option cloud la moins chère pour les workflows simples, mais les coûts grimpent rapidement dans les scénarios complexes (chaque module = 1 opération).

Dimension	Zapier	Make	n8n
Nombre d'intégrations	6,000+	1,500+	500+ (+communauté)
Modèle de tarification	Par tâche (facturé par étape)	Par opération (facturé par nœud)	Par exécution (workflow entier)
Prise en charge du code	JavaScript limité	Aucune	JS + Python complets
Auto-hébergement	Non pris en charge	Non pris en charge	Entièrement pris en charge
Agent IA	Limité	Limité	Natif et complet
Gestion de versions Git	Non pris en charge	Non pris en charge	Pris en charge (Business+)
Courbe d'apprentissage	Faible	Faible	Moyenne
Pertinence pour les équipes techniques	Faible	Moyenne	Élevée

Résumé : Si vous avez un profil technique, ou si la complexité de votre workflow dépasse 3-5 étapes, n8n est presque toujours le meilleur choix. Si vous n'êtes pas du tout technique et que vous avez seulement besoin de connecter deux applications SaaS courantes, Zapier est moins contraignant.

Ressources

Parcours d'apprentissage recommandés et ressources associées pour vous aider à passer de débutant à expert sur n8n.

Parcours d'apprentissage recommandé

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

Ressources officielles

Ressource	Lien	Description
Site officiel	n8n.io	Informations produit et accès à l'inscription
Documentation	docs.n8n.io	Documentation produit complète
Modèles de workflow	n8n.io/workflows	1,000+ modèles communautaires, import en un clic
GitHub	github.com/n8n-io/n8n	Licence fair-code, code source disponible
Forum communautaire	community.n8n.io	Questions-réponses techniques et discussions
Blog	blog.n8n.io	Mises à jour des fonctionnalités et cas d’utilisation
Notes de version	docs.n8n.io/release-notes	Contenu des mises à jour de version

Modèles de workflow courants

Recherchez les mots-clés suivants dans la marketplace de modèles pour trouver rapidement les modèles correspondants :

Scénario	Mot-clé de recherche de modèle
Bot de notification Slack	"slack notification"
Automatisation GitHub	"github automation"
Traitement des e-mails par IA	"email AI classification"
Synchronisation Airtable	"synchronisation airtable"
ETL de base de données	"synchronisation de base de données"
Agent IA	"outils d'agents IA"

Autres extensions

Outils pour agents

Implémenter des agents intelligents en Python

Tutoriel de prise en main de n8n

Différences entre Dify et n8n

À qui s'adresse-t-il ?

Concepts fondamentaux

Workflow

Nœud

Exécution

Connexion

Identifiant

Expression

Installation et démarrage

Méthode 1 : Essai local rapide (le plus rapide, 5 minutes)

Méthode 2 : Conteneur Docker unique (recommandé pour les particuliers et les petites équipes)

Méthode 3 : Docker Compose + PostgreSQL (recommandé pour les environnements de production)

Méthode 4 : Configurer un proxy inverse (Nginx + HTTPS)

Méthode 5 : Kubernetes (haute disponibilité, niveau entreprise)

Configuration système requise

Visite de l'interface : Première ouverture de n8n

Barre de navigation de gauche

Canevas de workflow

Panneau du nœud

Barre d’outils supérieure

Créez votre premier workflow

Étape 1 : Créer un workflow

Étape 2 : Ajouter un Schedule Trigger

Étape 3 : Récupérer les données HN

Étape 4 : Limiter aux 5 premiers éléments

Exemple

Étape 5 : Récupérer les détails de chaque article en parallèle

Étape 6 : Formater le message

Exemple

Étape 7 : Envoyer à Slack

Étape 8 : Exécution du test

Étape 9 : Activer le workflow

Explication détaillée des nœuds courants

Nœuds déclencheurs

Nœuds de traitement des données

Requête HTTP (le nœud central)

Code（JavaScript / Python）

Exemple

Exemple

Set (définir des variables)

IF (branche conditionnelle)

Switch (multi-branche)

Loop Over Items (boucle)

Merge (combiner)

Wait (attente/Intervention humaine)

Répondre au Webhook (réponse au Webhook)

Nœuds de base de données

Gestion des identifiants : Connexion sécurisée aux services externes

Ajouter un identifiant

Configurations courantes des identifiants

Slack（OAuth）

GitHub（Jeton d'accès personnel）

OpenAI / Anthropic（Clé API）

En-tête HTTP générique (toute API)

Nœud AI Agent : faire réfléchir les workflows

Composants du nœud AI Agent

Configurer l'AI Agent

Sélection du type d’Agent

Intégration MCP : connexion à l’écosystème de l’IA

n8n en tant que client MCP (appel d’outils externes)

n8n en tant que serveur MCP (exposition de workflows)

Exemple

Serveur MCP au niveau de l'instance

Scénario pratique 1 : Classification et notification automatiques des Issues GitHub

Scénario métier

Conception du Workflow

Configuration des nœuds clés

Étape 1 : Configurer le Webhook GitHub

Étape 2 : Filtrer les nouveaux événements

Étape 3 : Nœud de classification IA

Étape 4 : Analyser la sortie de l'IA

Étape 5 : Routage avec Switch

Étape 6 : Ajouter des étiquettes + publier des commentaires

Étape 7 : Notification Slack

Scénario 2 : Pipeline de traitement de documents par IA (extraction de factures/contrats)

Scénario métier