Loop

Répéter des actions pour chaque élément d'une liste

À quoi sert ce node ?

Le node Loop traite les tableaux en répétant une séquence de nodes pour chaque élément. Il est essentiel pour les opérations en lot : parcourir plusieurs URL, traiter des lignes de feuille de calcul ou gérer des listes de réponses API.

Usages courants :

• Traiter une liste d’URL
• Parcourir les lignes d’une feuille de calcul
• Gérer les tableaux de réponses API
• Traiter des éléments en lot

Configuration rapide

Configuration

Champs obligatoires

Champs optionnels

Variables de boucle

Dans une boucle, vous pouvez utiliser ces variables :

Variable	Description	Exemple
{{Loop_0.currentItem}}	Élément courant	"https://example.com"
{{Loop_0.index}}	Index courant (à partir de 0)	0, 1, 2…
{{Loop_0.totalItems}}	Nombre total d’éléments	10

Accéder aux propriétés des éléments

Si les éléments sont des objets :

// Tableau d'éléments
[
  {"url": "https://a.com", "name": "Site A"},
  {"url": "https://b.com", "name": "Site B"}
]

Accès aux propriétés :

{{Loop_0.currentItem.url}}   → "https://a.com"
{{Loop_0.currentItem.name}}  → "Site A"

Sortie

À la fin, la boucle fournit :

{
  "results": [
    // Tableau des résultats de chaque itération
  ],
  "totalItems": 10,
  "processedItems": 10,
  "errors": []
}

Accès aux résultats : {{Loop_0.results}}

Exemples

Scraper plusieurs URL

Entrée : Liste d’URL depuis Google Sheets

graph LR
    A[Google Sheets] --> B[Loop]
    B --> C[Web Scraper]
    C --> D[LLM Analysis]
    D --> E[Save Results]

Configuration :

• Items : {{GoogleSheets_0.data}}
• Max iterations : 50
• Delay : 2000 ms

Dans la boucle :

• URL du Web Scraper : {{Loop_0.currentItem.url}}

Traiter les résultats d’une API

Entrée : Réponse API avec un tableau d’enregistrements

graph LR
    A[HTTP Request] --> B[Loop]
    B --> C[Transform Data]
    C --> D[BigQuery Write]

Configuration :

• Items : {{HTTP_0.body.results}}

Envoyer des e-mails à plusieurs destinataires

Entrée : Liste de contacts

graph LR
    A[Contacts] --> B[Loop]
    B --> C[LLM Personalize]
    C --> D[Email Sender]
    D --> E[Log Sent]

Dans la boucle :

• Destinataire : {{Loop_0.currentItem.email}}
• Variable nom : {{Loop_0.currentItem.name}}

Boucles imbriquées

Pour traiter des données multidimensionnelles :

graph LR
    A[Categories] --> B[Outer Loop]
    B --> C[Products per Category]
    C --> D[Inner Loop]
    D --> E[Process Product]

Configuration :

• Boucle externe : {{categories}}
• Boucle interne : {{OuterLoop_0.currentItem.products}}

Bonnes pratiques

Toujours définir un nombre max d’itérations

Pour éviter les boucles infinies ou incontrôlées :

Max iterations : 100

Même si vous attendez moins d’éléments, fixez une limite.

Ajouter des délais pour les appels externes

Lors d’appels API ou de scraping :

Delay : 2000 ms (2 secondes)

Cela limite le rate limiting et la surcharge des serveurs.

Gérer les erreurs dans la boucle

Prévoyez une gestion des erreurs à chaque itération :

graph LR
    A[Loop Item] --> B{Try Operation}
    B -->|Success| C[Save Result]
    B -->|Error| D[Log Error]
    C --> E[Next Item]
    D --> E

Utilisez des nodes Conditional pour détecter les échecs.

Traiter les gros jeux de données par lots

Pour des milliers d’éléments :

1. Découper en lots de 50 à 100
2. Traiter chaque lot dans une boucle
3. Ajouter des délais entre les lots
4. Suivre la progression dans un log

Donner des noms explicites aux nodes

Dans les boucles, nommez clairement les nodes :

❌ WebScraper_0
✅ ScrapeCurrentURL

❌ LLM_0
✅ AnalyzeContent

Modèles courants

Collecter et agréger

Parcourir les éléments en boucle
  → Traiter chacun
  → Ajouter au tableau des résultats

Après la boucle :
  → Agréger les résultats
  → Générer un résumé

Filtrer pendant le traitement

Parcourir les éléments en boucle
  → Vérifier une condition
  → Si ça correspond, traiter
  → Sinon, ignorer

Suivi de progression

Parcourir les éléments en boucle
  → Traiter
  → Logger la progression : "Traité {{Loop_0.index + 1}} sur {{Loop_0.totalItems}}"

Problèmes fréquents

La boucle prend trop de temps

• Réduire le nombre max d’itérations
• Réduire les délais
• Traiter par lots plus petits
• Vérifier qu’il n’y a pas de condition de boucle infinie

Rate limiting par l’API

• Augmenter le délai entre les itérations
• Réduire la taille des lots
• Mettre en place un backoff exponentiel
• Vérifier les limites de l’API

Certains éléments échouent

• Ajouter un node Conditional pour gérer les erreurs
• Logger les éléments en échec pour analyse
• Utiliser une logique de retry pour les erreurs temporaires

Le tableau des résultats est vide

• Vérifier que les nodes dans la boucle produisent une sortie
• Vérifier que les résultats sont bien collectés
• Vérifier que le tableau d’entrée contient des éléments

Nodes associés