Guide de sélection des nodes

Ce guide répond à une question simple : "J'ai besoin de faire X → quel node j'utilise ?"

Plutôt qu'un catalogue technique, ce guide est orienté problème. Il part du besoin et arrive au node.

Matrice de décision rapide

Par catégorie de besoin

J'ai besoin de router ou décider (logique)

→ Node Condition pour les branchements

Le point de départ de la plupart des flows. Évalue une expression et dirige le flow vers une branche ou l'autre. Beaucoup de cas d'usage peuvent être résolus avec de la logique conditionnelle seule, sans IA.

Exemples d'expressions :

• {{ trigger.metadata.category }} == "vip" — Routage par catégorie client.
• {{ trigger.message }} contient "urgent" — Détection de mot-clé.
• {{ http_request.response.status }} == 200 — Vérification d'un appel API.

Bonne pratique : Définissez toujours une branche else. Un flow sans else est un flow qui plante silencieusement sur les cas imprévus.

→ Node Loop pour les itérations

Prend un tableau en entrée et exécute les nodes enfants pour chaque élément.

Cas typiques :

• Traiter N documents un par un.
• Analyser chaque ligne d'un tableau CSV.
• Envoyer une notification à chaque destinataire d'une liste.

J'ai besoin d'intelligence (IA)

→ Node Agent

Envoie un prompt à un LLM et retourne la réponse. Utile quand le traitement nécessite de la compréhension du langage naturel (classification sémantique, génération de texte, extraction intelligente).

Paramètres clés :

Quand utiliser une temperature basse (0-0.3) : extraction de données, classification, réponses factuelles.

Quand utiliser une temperature haute (0.7-1) : rédaction créative, brainstorming, reformulation.

Piège courant : Un prompt trop vague produit des réponses imprévisibles. Soyez spécifique sur le format de sortie attendu.

Attention : Si vous utilisez un Agent dans une boucle, chaque itération = un appel LLM = un coût. Évaluez si un node Code ou une Condition ne suffirait pas.

J'ai besoin de communiquer avec l'extérieur

→ Node HTTP Request pour appeler des APIs

Configure un appel HTTP complet : méthode, URL, headers, body, authentification.

Cas typiques :

• Créer un ticket dans Jira, ServiceNow.
• Récupérer des données depuis un CRM (Salesforce, HubSpot).
• Envoyer une notification Slack/Teams.
• Appeler un microservice interne.

Configuration :

Piège courant : Ne pas gérer le cas où l'API retourne une erreur (500, timeout). Ajoutez une Condition après le HTTP Request pour vérifier le statut.

J'ai besoin de transformer des données

→ Node Code pour les transformations complexes

Exécute du code Python. Utile quand les expressions {{ }} ne suffisent pas.

Cas typiques :

• Parser un JSON complexe.
• Calculer des statistiques sur un ensemble de données.
• Formater un email HTML.
• Appliquer une logique métier spécifique que l'IA ne peut pas faire de manière fiable.

Quand préférer Code vs Agent : Si le traitement est déterministe (calcul, formatage, filtre), utilisez Code. Si le traitement nécessite de la compréhension (classification, résumé, extraction sémantique), utilisez Agent.

→ Node Set Variable pour les variables simples

Définit ou met à jour une variable sans écrire de code.

Cas typiques :

• Stocker un score calculé : score = {{ agent.output.score }}.
• Accumuler des résultats dans une boucle.
• Préparer un contexte pour un node en aval.

J'ai besoin d'intervention humaine

→ Node Human Input (HITL)

Met le flow en pause et affiche un formulaire à un opérateur humain. Le flow reprend quand l'opérateur répond.

Cas typiques :

• Valider une réponse générée par l'IA avant envoi au client.
• Demander une information manquante qu'un humain seul peut fournir.
• Escalader un cas complexe que l'IA ne sait pas traiter.

Points d'attention :

• Qui reçoit la notification de validation ? Prévoir le workflow humain en amont.
• Quel est le délai acceptable ? L'utilisateur final attend pendant ce temps.
• Que se passe-t-il si personne ne valide ? (timeout, fallback)

J'ai besoin de traiter des documents

→ Node Parse Document

Extrait le texte d'un fichier (PDF, Word, etc.) pour le rendre exploitable par un Agent.

Workflow typique : Parse Document → Agent (extraction/analyse) → résultat structuré.

Limites :

• Le résultat est du texte brut. La mise en page, les tableaux et les images sont perdus ou approximatifs.
• Les documents scannés (images de texte) nécessitent un OCR en amont (hors nAIxus).

Arbre de décision

Mon besoin principal :

├── Router / décider automatiquement
│   ├── Par règles (mot-clé, catégorie, seuil) → Condition
│   └── Par compréhension sémantique → Agent + Condition
│
├── Comprendre / Générer du texte
│   └── → Agent
│
├── Traiter une liste d'éléments
│   └── → Loop + [node de traitement]
│
├── Appeler un système externe
│   └── → HTTP Request
│
├── Transformer des données (calcul, formatage)
│   ├── Simple → Set Variable
│   └── Complexe → Code
│
├── Demander l'avis d'un humain
│   └── → Human Input
│
└── Extraire du texte d'un fichier
    └── → Parse Document

Combinaisons fréquentes