---
title: Parallel
---

import { Callout } from 'fumadocs-ui/components/callout'
import { Tab, Tabs } from 'fumadocs-ui/components/tabs'
import { Image } from '@/components/ui/image'

Le bloc Parallèle est un conteneur qui exécute plusieurs instances simultanément pour un traitement plus rapide des flux de travail. Traitez les éléments en parallèle plutôt que séquentiellement.

<Callout type="info">
  Les blocs parallèles sont des nœuds conteneurs qui exécutent leur contenu plusieurs fois simultanément, contrairement aux boucles qui s'exécutent séquentiellement.
</Callout>

## Options de configuration

### Type de parallélisation

Choisissez entre deux types d'exécution parallèle :

<Tabs items={['Basée sur un nombre', 'Basée sur une collection']}>
  <Tab>
    **Parallèle basé sur un nombre** - Exécute un nombre fixe d'instances parallèles :
    
    <div className="flex justify-center">
      <Image
        src="/static/blocks/parallel-1.png"
        alt="Exécution parallèle basée sur un nombre"
        width={500}
        height={400}
        className="my-6"
      />
    </div>
    
    Utilisez cette option lorsque vous devez exécuter la même opération plusieurs fois simultanément.
    

    ```
    Example: Run 5 parallel instances
    - Instance 1 ┐
    - Instance 2 ├─ All execute simultaneously
    - Instance 3 │
    - Instance 4 │
    - Instance 5 ┘
    ```

  </Tab>
  <Tab>
    **Parallèle basé sur une collection** - Distribue une collection à travers des instances parallèles :
    
    <div className="flex justify-center">
      <Image
        src="/static/blocks/parallel-2.png"
        alt="Exécution parallèle basée sur une collection"
        width={500}
        height={400}
        className="my-6"
      />
    </div>
    
    Chaque instance traite un élément de la collection simultanément.
    

    ```
    Example: Process ["task1", "task2", "task3"] in parallel
    - Instance 1: Process "task1" ┐
    - Instance 2: Process "task2" ├─ All execute simultaneously
    - Instance 3: Process "task3" ┘
    ```

  </Tab>
</Tabs>

## Comment utiliser les blocs parallèles

### Création d'un bloc parallèle

1. Faites glisser un bloc Parallèle depuis la barre d'outils sur votre canevas
2. Configurez le type de parallélisation et les paramètres
3. Faites glisser un seul bloc à l'intérieur du conteneur parallèle
4. Connectez le bloc selon vos besoins

### Accès aux résultats

Une fois qu'un bloc parallèle est terminé, vous pouvez accéder aux résultats agrégés :

- **`<parallel.results>`** : Tableau des résultats de toutes les instances parallèles

## Exemples de cas d'utilisation

**Traitement par lots d'API** - Traiter plusieurs appels API simultanément

```
Parallel (Collection) → API (Call Endpoint) → Function (Aggregate)
```

**Traitement multi-modèles d'IA** - Obtenir des réponses de plusieurs modèles d'IA simultanément

```
Parallel (["gpt-4o", "claude-3.7-sonnet", "gemini-2.5-pro"]) → Agent → Evaluator (Select Best)
```

## Fonctionnalités avancées

### Agrégation des résultats

Les résultats de toutes les instances parallèles sont automatiquement collectés :

### Cas d'utilisation courants

### Isolation des instances

Chaque instance parallèle s'exécute indépendamment :
- Portées de variables séparées
- Pas d'état partagé entre les instances
- Les échecs dans une instance n'affectent pas les autres

### Limitations

<Callout type="info">
  Les blocs conteneurs (Boucles et Parallèles) prennent en charge l'imbrication. Vous pouvez placer des parallèles dans des parallèles, des boucles dans des parallèles, et toute combinaison de blocs conteneurs pour construire des flux de travail multidimensionnels complexes.
</Callout>

<Callout type="info">
  Bien que l'exécution parallèle soit plus rapide, soyez attentif à :
  - Limites de taux des API lors de requêtes simultanées
  - Utilisation de la mémoire avec de grands ensembles de données
  - Maximum de 20 instances simultanées pour éviter l'épuisement des ressources
</Callout>

## Parallèle vs Boucle

Comprendre quand utiliser chacun :

| Fonctionnalité | Parallèle | Boucle |
|---------|----------|------|
| Exécution | Simultanée | Séquentielle |
| Vitesse | Plus rapide pour les opérations indépendantes | Plus lente mais ordonnée |
| Ordre | Pas d'ordre garanti | Maintient l'ordre |
| Cas d'utilisation | Opérations indépendantes | Opérations dépendantes |
| Utilisation des ressources | Plus élevée | Plus faible |

## Entrées et sorties

<Tabs items={['Configuration', 'Variables', 'Résultats']}>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>Type de parallèle</strong> : Choisissez entre 'count' ou 'collection'
      </li>
      <li>
        <strong>Count</strong> : Nombre d'instances à exécuter (basé sur le comptage)
      </li>
      <li>
        <strong>Collection</strong> : Tableau ou objet à distribuer (basé sur la collection)
      </li>
    </ul>
  </Tab>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>parallel.currentItem</strong> : Élément pour cette instance
      </li>
      <li>
        <strong>parallel.index</strong> : Numéro d'instance (base 0)
      </li>
      <li>
        <strong>parallel.items</strong> : Collection complète (basé sur la collection)
      </li>
    </ul>
  </Tab>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>parallel.results</strong> : Tableau de tous les résultats d'instance
      </li>
      <li>
        <strong>Accès</strong> : Disponible dans les blocs après le parallèle
      </li>
    </ul>
  </Tab>
</Tabs>

## Bonnes pratiques

- **Opérations indépendantes uniquement** : Assurez-vous que les opérations ne dépendent pas les unes des autres
- **Gérer les limites de taux** : Ajoutez des délais ou une limitation pour les workflows intensifs en API
- **Gestion des erreurs** : Chaque instance doit gérer ses propres erreurs avec élégance

## Entrées et sorties

<Tabs items={['Configuration', 'Variables', 'Résultats']}>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>Type parallèle</strong> : choisissez entre « count » ou « collection »
      </li>
      <li>
        <strong>Count</strong> : nombre d'instances à exécuter (basé sur le comptage)
      </li>
      <li>
        <strong>Collection</strong> : tableau ou objet à distribuer (basé sur la collection)
      </li>
    </ul>
  </Tab>
  <Tab>
    Disponible **à l'intérieur** du parallèle uniquement :
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>{"<parallel.index>"}</strong> : numéro d'instance (base 0)
      </li>
      <li>
        <strong>{"<parallel.currentItem>"}</strong> : élément pour cette instance (collection uniquement)
      </li>
      <li>
        <strong>{"<parallel.items>"}</strong> : collection complète (collection uniquement)
      </li>
    </ul>
  </Tab>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>{"<blockname.results>"}</strong> : tableau de tous les résultats d'instance (accessible via le nom du bloc)
      </li>
      <li>
        <strong>Accès</strong> : disponible dans les blocs après la fin du parallèle
      </li>
    </ul>
  </Tab>
</Tabs>

## Bonnes pratiques

- **Opérations indépendantes uniquement** : assurez-vous que les opérations ne dépendent pas les unes des autres
- **Gérer les limites de débit** : ajoutez des délais ou une limitation pour les workflows intensifs en API
- **Gestion des erreurs** : chaque instance doit gérer ses propres erreurs de manière appropriée
