> For the complete documentation index, see [llms.txt](https://docs.neuron-ai.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.neuron-ai.dev/neuron-v3-es/flujo-de-trabajo/multi-step-workflow.md).

# Flujo de trabajo de múltiples pasos

Aprende cómo manejar flujos de ejecución complejos orquestando la ejecución de múltiples nodos

Se crean múltiples pasos definiendo eventos personalizados que pueden ser emitidos por nodos y activar otros nodos. Definamos un flujo de trabajo simple de 3 pasos.

### Eventos personalizados

Definimos dos eventos personalizados, `FirstEvent` y `SecondEvent`. Estas clases pueden tener cualquier nombre y propiedades, pero deben implementar `Event`:

{% tabs %}
{% tab title="Unix" %}

```bash
vendor/bin/neuron make:event App\\Neuron\\FirstEvent
```

{% endtab %}

{% tab title="Windows" %}

```powershell
.\vendor\bin\neuron make:event App\Neuron\FirstEvent
```

{% endtab %}
{% endtabs %}

```php
namespace App\Neuron;

class FirstEvent implements Event 
{
    public function __construct(protected string $firstMsg){}
}

class SecondEvent implements Event 
{
    public function __construct(protected string $secondMsg){}
}
```

### Definiendo el flujo de trabajo

Ahora definimos el flujo de trabajo en sí. Lo hacemos definiendo los tipos de entrada y salida en cada nodo. Aquí está la implementación mínima de los nodos para este demo.

<figure><img src="https://content.gitbook.com/content/GHx4l2LknIex7vFIUg1R/blobs/4TRyH3V7QYbS4NVDzJyI/workflow-multi-steps.png" alt=""><figcaption></figcaption></figure>

#### InitialNode

{% tabs %}
{% tab title="Unix" %}

```bash
vendor/bin/neuron make:node App\\Neuron\\InitialNode
```

{% endtab %}

{% tab title="Windows" %}

```powershell
.\vendor\bin\neuron make:node App\Neuron\InitialNode
```

{% endtab %}
{% endtabs %}

```php
namespace App\Neuron;

use NeuronAI\Workflow\Node;
use NeuronAI\Workflow\StartEvent;
use NeuronAI\Workflow\WorkflowResources;
use App\Neuron\FirstEvent;

class InitialNode extends Node
{
    /**
     * Obtiene el "StartEvent" y devuelve "FirstEvent"
     */
    public function __invoke(
        StartEvent $event, 
        WorkflowState $state,
        WorkflowResources $resources
    ): FirstEvent {
        echo "\n- Procesando StartEvent";
        
        return new FirstEvent("InitialNode completado");
    }
}
```

#### NodeOne

{% tabs %}
{% tab title="Unix" %}

```bash
vendor/bin/neuron make:node App\\Neuron\\NodeOne
```

{% endtab %}

{% tab title="Windows" %}

```powershell
.\vendor\bin\neuron make:node App\Neuron\NodeOne
```

{% endtab %}
{% endtabs %}

```php
class NodeOne extends Node
{
    /**
     * Toma "FirstEvent" como entrada y devuelve "SecondEvent"
     */
    public function __invoke(
        FirstEvent $event, 
        WorkflowState $state,
        WorkflowResources $resources
    ): SecondEvent {
        echo "\n- ".$event->firstMsg;
        
        return new SecondEvent("NodeOne completado");
    }
}
```

#### NodeTwo

{% tabs %}
{% tab title="Unix" %}

```bash
vendor/bin/neuron make:node App\\Neuron\\NodeTwo
```

{% endtab %}

{% tab title="Windows" %}

```powershell
.\vendor\bin\neuron make:node App\Neuron\NodeTwo
```

{% endtab %}
{% endtabs %}

```php
class NodeTwo extends Node
{
    /**
     * Toma "SecondEvent" como entrada y devuelve "StopEvent"
     */
    public function __invoke(
        SecondEvent $event, 
        WorkflowState $state,
        WorkflowResources $resources
    ): StopEvent {
        echo "\n- ".$event->secondMsg;
        
        echo "\n- NodeTwo completado";
        
        return new StopEvent();
    }
}
```

Defina el flujo de trabajo adjuntando los nodos:

```php
use NeuronAI\Workflow\Workflow;

$workflow = Workflow::make()
    ->setWorkflowId('wk_id')
    ->addNodes([
        new InitialNode(),
        new NodeOne(),
        new NodeTwo(),
    ]);

/*
 * Ejecute el flujo de trabajo
 */
$workflow->run();
```

La salida completa será:

```
- Procesando StartEvent
- InitialNode completado
- NodeOne completado
- NodeTwo completado
```

Por supuesto, un flujo de trabajo todavía no tiene mucho sentido si simplemente lo ejecutas de principio a fin. Hagamos algo de ramificación y bucles.

### Monitoreo y depuración

Muchas de las aplicaciones que construyas con Neuron contendrán múltiples pasos con múltiples invocaciones de llamadas a LLM. A medida que estas aplicaciones se vuelven cada vez más complejas, resulta crucial poder inspeccionar exactamente qué está ocurriendo dentro de tu sistema agéntico. La mejor manera de hacerlo es con [Inspector](https://inspector.dev/).

{% embed url="<https://docs.inspector.dev/guides/neuron-ai>" %}
