Nœuds d'action

Nœuds non-LLM programmatiques pour des opérations de flux de travail déterministes. Les nœuds d'action complètent les LLM agents en gérant la transformation de données, les API intégrations, le flux de contrôle et la logique d'automatisation.

Aperçu

Les nœuds d'action sont visuellement distincts des LLM nœuds d'agent — ils utilisent des couleurs et des icônes uniques pour faciliter la lecture des flux de travail. Chaque type de nœud gère une catégorie d'opération spécifique, des HTTP requêtes aux requêtes de base de données en passant par le branchement conditionnel.

Tous les nœuds d'action partagent un ensemble de propriétés standard pour la gestion des erreurs, le traçage, le contrôle d'exécution et le mappage d'E/S. Ils prennent en charge l'{{variable}} interpolation dans les champs de chaîne et reçoivent automatiquement les sorties des nœuds prédécesseurs.

Nœuds disponibles

---

Propriétés standard

Chaque nœud d'action hérite de ces propriétés partagées :

Identité

Gestion des erreurs

Traçage

Contrôle d'exécution

Mappage Entrée/Sortie

Référence des Nœuds

Nœud Déclencheur 🎯

Point d'entrée du workflow. Chaque workflow commence par un nœud déclencheur. Consultez le Guide des Déclencheurs dédié pour plus de détails.

HTTP Node 🌐

Effectue HTTP des requêtes vers des APIs externes avec une gestion complète de l'authentification, des en-têtes, du corps et de la réponse.

Configuration :

Exemple :

{
  "type": "http",
  "name": "Fetch User Data",
  "method": "GET",
  "url": "https://api.example.com/users/{{userId}}",
  "auth": {
    "type": "bearer",
    "bearer": { "token": "{{API_TOKEN}}" }
  },
  "headers": { "Accept": "application/json" },
  "body": { "type": "none" },
  "response": { "type": "json", "jsonPath": "$.data" },
  "errorHandling": { "mode": "retry", "retryCount": 3, "retryDelay": 1000 },
  "mapping": { "outputKey": "userData" }
}

Nœud Set 📝

Définit et manipule les variables d'état du workflow. Prend en charge les valeurs littérales, les expressions et les secrets.

Configuration :

Types de variables : string, number, boolean, json, expression

Les variables marquées isSecret: true sont masquées dans les journaux et l'interface utilisateur.

Nœud de transformation ⚙️

Transforme les données à l'aide d'expressions ou d'opérations intégrées.

Types de transformations :

Opérations intégrées : pick, omit, rename, flatten, sort, unique

Cibles de conversion de type : string, number, boolean, array, object

Nœud Switch 🔀

Branchement conditionnel avec plusieurs ports de sortie. Chaque condition correspond à un port de sortie distinct sur le nœud.

Configuration :

Opérateurs de condition : eq, neq, gt, lt, gte, lte, contains, startsWith, endsWith, matches, in, empty, exists

Exemple :

{
  "type": "switch",
  "evaluationMode": "first_match",
  "conditions": [
    { "id": "ok", "name": "Success", "field": "status", "operator": "eq", "value": "success", "outputPort": "success" },
    { "id": "err", "name": "Error", "field": "status", "operator": "eq", "value": "error", "outputPort": "error" }
  ],
  "defaultBranch": "unknown"
}

Nœud de boucle 🔄

Itère sur des tableaux, se répète un nombre fixe de fois, ou boucle tant qu'une condition est remplie.

Types de boucles :

Exécution parallèle : Activer parallel.enabled avec les options batchSize et delayBetween pour une itération concurrente.

Agrégation des résultats : Lorsque results.collect est vrai, les résultats de l'itération sont collectés dans un tableau sous results.aggregationKey.

Nœud de fusion 🔗

Combine plusieurs branches parallèles en un seul flux. Possède plusieurs ports d'entrée.

Modes de fusion :

Combiner les stratégies : array, object, first, last

Délai d'attente optionnel avec continue ou error comportement.

Nœud d'attente ⏱️

Met en pause l'exécution du workflow.

Types d'attente :

Code Node 💻

Exécute du code personnalisé JavaScript dans un environnement d'exécution isolé boa_engine. L'état du graphe est injecté en tant qu'objet global input.

Configuration :

Paramètres par défaut du bac à sable :

Nœud de base de données 🗄️

Effectue des opérations de base de données avec un pool de connexions et des requêtes paramétrées.

Bases de données prises en charge :

Les chaînes de connexion sont traitées comme des secrets et masquées dans les journaux.

Nœud Email 📧

Envoyez des e-mails via SMTP ou surveillez les e-mails entrants via IMAP.

Mode d'envoi (SMTP) :

• Prise en charge TLS/SSL
• Authentification
• Destinataires À/CC/BCC
• Corps HTML ou texte brut
• Interpolation {{variable}} dans l'objet et le corps
• Pièces jointes à partir de l'état

Mode de surveillance (IMAP) :

• Sélection de dossier (par défaut : INBOX)
• Filtres : expéditeur, objet, plage de dates, non lus uniquement
• Marquer comme lu après traitement

Nœud de Notification 🔔

Envoie des notifications aux plateformes de messagerie.

Canaux : Slack, Discord, Microsoft Teams, webhook personnalisé

Formats de message : texte brut, markdown, blocs spécifiques à la plateforme (Block Kit, Embeds, Adaptive Cards)

Nœud RSS 📡

Surveille les flux RSS/Atom pour les nouvelles entrées.

• Intervalle d'interrogation configurable
• Filtres par mot-clé, auteur, catégorie et date
• Suivi des éléments vus pour éviter les doublons
• Contenu complet ou résumé uniquement (optionnel)

Nœud de Fichier 📁

Opérations de fichier sur le stockage local ou cloud.

Opérations : lire, écrire, supprimer, lister

Fournisseurs cloud : Amazon S3, Google Cloud Storage, Azure Blob Storage

Formats de fichier : JSON, CSV, XML, texte, binaire (avec options d'analyse CSV pour le délimiteur, les en-têtes, les guillemets)

---

Interpolation de Variables

Tous les champs de chaîne dans les nœuds d'action supportent la syntaxe {{variable}} pour les valeurs dynamiques :

https://api.example.com/users/{{userId}}
Bearer {{API_TOKEN}}
Hello {{user.name}}, your order {{orderId}} is ready.

Les variables sont résolues à partir de l'état du workflow au moment de l'exécution. La notation par points (user.name) accède aux valeurs imbriquées.

Nœuds Multi-Ports

Deux types de nœuds ont des nombres de ports dynamiques :

• Switch — un port de sortie par condition, plus un port par défaut optionnel
• Merge — plusieurs ports d'entrée, un par branche entrante

Ces ports sont représentés visuellement sur le nœud et se connectent à différents nœuds en aval/amont.

---

Génération de Code

Les nœuds d'action compilent en code Rust de production aux côtés des LLM agents. Les dépendances sont auto-détectées et ajoutées au Cargo.toml généré.

Tout le code généré utilise adk-graph FunctionNode closures avec GraphError::NodeExecutionFailed pour la gestion des erreurs.

Exemple de code généré (HTTP node) :

let http_node = FunctionNode::new("fetch_data", |ctx| async move {
    let client = reqwest::Client::new();
    let resp = client.get("https://api.example.com/data")
        .bearer_auth(&ctx.get("API_TOKEN").unwrap_or_default())
        .send().await
        .map_err(|e| GraphError::NodeExecutionFailed {
            node: "fetch_data".into(),
            message: e.to_string(),
        })?;
    let body: serde_json::Value = resp.json().await?;
    Ok(NodeOutput::new().with_update("apiData", body))
});

Exemple de code généré (Code node) :

let code_node = FunctionNode::new("process", |ctx| async move {
    let mut js_ctx = boa_engine::Context::default();
    // Graph state injected as global `input` object
    // User code executed in thread-isolated sandbox
    Ok(NodeOutput::new().with_update("result", output))
});

---

Précédent : ← Studio | Suivant : Triggers →