sim/apps/docs/content/docs/es/blocks/parallel.mdx

---
title: Paralelo
---

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

El bloque Paralelo es un contenedor que ejecuta múltiples instancias concurrentemente para un procesamiento más rápido del flujo de trabajo. Procesa elementos simultáneamente en lugar de secuencialmente.

<Callout type="info">
  Los bloques paralelos son nodos contenedores que ejecutan su contenido múltiples veces simultáneamente, a diferencia de los bucles que ejecutan secuencialmente.
</Callout>

## Opciones de configuración

### Tipo de paralelismo

Elige entre dos tipos de ejecución paralela:

<Tabs items={['Count-based', 'Collection-based']}>
  <Tab>
    **Paralelismo basado en conteo** - Ejecuta un número fijo de instancias paralelas:
    
    <div className="flex justify-center">
      <Image
        src="/static/blocks/parallel-1.png"
        alt="Ejecución paralela basada en conteo"
        width={500}
        height={400}
        className="my-6"
      />
    </div>
    
    Úsalo cuando necesites ejecutar la misma operación múltiples veces concurrentemente.
    

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

  </Tab>
  <Tab>
    **Paralelismo basado en colección** - Distribuye una colección entre instancias paralelas:
    
    <div className="flex justify-center">
      <Image
        src="/static/blocks/parallel-2.png"
        alt="Ejecución paralela basada en colección"
        width={500}
        height={400}
        className="my-6"
      />
    </div>
    
    Cada instancia procesa un elemento de la colección simultáneamente.
    

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

  </Tab>
</Tabs>

## Cómo usar bloques paralelos

### Creación de un bloque paralelo

1. Arrastra un bloque Paralelo desde la barra de herramientas a tu lienzo
2. Configura el tipo de paralelismo y los parámetros
3. Arrastra un solo bloque dentro del contenedor paralelo
4. Conecta el bloque según sea necesario

### Acceso a los resultados

Después de que un bloque paralelo se completa, puedes acceder a los resultados agregados:

- **`<parallel.results>`**: Array de resultados de todas las instancias paralelas

## Ejemplos de casos de uso

**Procesamiento por lotes de API** - Procesa múltiples llamadas API simultáneamente

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

**Procesamiento de IA con múltiples modelos** - Obtén respuestas de varios modelos de IA concurrentemente

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

## Características avanzadas

### Agregación de resultados

Los resultados de todas las instancias paralelas se recopilan automáticamente:

### Procesamiento paralelo de datos

### Aislamiento de instancias

Cada instancia paralela se ejecuta de forma independiente:
- Ámbitos de variables separados
- Sin estado compartido entre instancias
- Los fallos en una instancia no afectan a las demás

### Limitaciones

<Callout type="warning">
  Los bloques contenedores (Bucles y Paralelos) no pueden anidarse unos dentro de otros. Esto significa:
  - No puedes colocar un bloque de Bucle dentro de un bloque Paralelo
  - No puedes colocar otro bloque Paralelo dentro de un bloque Paralelo
  - No puedes colocar ningún bloque contenedor dentro de otro bloque contenedor
</Callout>

<Callout type="info">
  Aunque la ejecución en paralelo es más rápida, ten en cuenta:
  - Límites de tasa de API al realizar solicitudes concurrentes
  - Uso de memoria con conjuntos de datos grandes
  - Máximo de 20 instancias concurrentes para evitar el agotamiento de recursos
</Callout>

## Paralelo vs Bucle

Entendiendo cuándo usar cada uno:

| Característica | Paralelo | Bucle |
|---------|----------|------|
| Ejecución | Concurrente | Secuencial |
| Velocidad | Más rápido para operaciones independientes | Más lento pero ordenado |
| Orden | Sin orden garantizado | Mantiene el orden |
| Caso de uso | Operaciones independientes | Operaciones dependientes |
| Uso de recursos | Mayor | Menor |

## Entradas y Salidas

<Tabs items={['Configuración', 'Variables', 'Resultados']}>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>Tipo de paralelo</strong>: Elige entre 'count' o 'collection'
      </li>
      <li>
        <strong>Count</strong>: Número de instancias a ejecutar (basado en conteo)
      </li>
      <li>
        <strong>Collection</strong>: Array u objeto a distribuir (basado en colección)
      </li>
    </ul>
  </Tab>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>parallel.currentItem</strong>: Elemento para esta instancia
      </li>
      <li>
        <strong>parallel.index</strong>: Número de instancia (base 0)
      </li>
      <li>
        <strong>parallel.items</strong>: Colección completa (basado en colección)
      </li>
    </ul>
  </Tab>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>parallel.results</strong>: Array de todos los resultados de instancias
      </li>
      <li>
        <strong>Access</strong>: Disponible en bloques después del paralelo
      </li>
    </ul>
  </Tab>
</Tabs>

## Mejores prácticas

- **Solo operaciones independientes**: Asegúrate de que las operaciones no dependan entre sí
- **Gestionar límites de tasa**: Añade retrasos o limitaciones para flujos de trabajo con uso intensivo de API
- **Manejo de errores**: Cada instancia debe manejar sus propios errores correctamente

## Entradas y salidas

<Tabs items={['Configuración', 'Variables', 'Resultados']}>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>Tipo paralelo</strong>: elige entre 'count' o 'collection'
      </li>
      <li>
        <strong>Count</strong>: número de instancias a ejecutar (basado en recuento)
      </li>
      <li>
        <strong>Collection</strong>: array u objeto a distribuir (basado en colección)
      </li>
    </ul>
  </Tab>
  <Tab>
    Disponible **dentro** del paralelo únicamente:
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>{"<parallel.index>"}</strong>: número de instancia (basado en 0)
      </li>
      <li>
        <strong>{"<parallel.currentItem>"}</strong>: elemento para esta instancia (solo basado en colección)
      </li>
      <li>
        <strong>{"<parallel.items>"}</strong>: colección completa (solo basado en colección)
      </li>
    </ul>
  </Tab>
  <Tab>
    <ul className="list-disc space-y-2 pl-6">
      <li>
        <strong>{"<blockname.results>"}</strong>: array de todos los resultados de instancia (accedido mediante el nombre del bloque)
      </li>
      <li>
        <strong>Acceso</strong>: disponible en bloques después de que se complete el paralelo
      </li>
    </ul>
  </Tab>
</Tabs>

## Buenas prácticas

- **Solo operaciones independientes**: asegúrate de que las operaciones no dependan unas de otras
- **Gestiona los límites de tasa**: añade retrasos o limitación para flujos de trabajo con uso intensivo de API
- **Gestión de errores**: cada instancia debe gestionar sus propios errores de forma elegante