> 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/agente/async.md).

# Async

Neuron admite la ejecución asíncrona y el procesamiento paralelo de agentes, lo que te permite manejar múltiples operaciones simultáneamente de manera eficiente. El enfoque de Neuron para la ejecución asíncrona ofrece varias ventajas:

**Agnóstico al framework**: Puedes hacer que los agentes y RAG sean compatibles con async para los entornos async más comunes con un simple adaptador; no se requieren cambios en tu implementación.

**Compatibilidad con proveedores**: Nuestra solución funciona independientemente del proveedor que uses. Puedes tener flujos de trabajo o sistemas multiagente que usen diferentes proveedores y modelos ejecutándose sin problemas en un bucle async.

**Escalabilidad**: Las aplicaciones que manejan grandes volúmenes de datos (clasificación de productos, moderación de contenido, etiquetado de datos) se benefician significativamente de las capacidades de procesamiento concurrente.

### Concurrencia vs Async

La concurrencia es el concepto de alto nivel de gestionar tareas, lo que puede implicar varios hilos/núcleos (paralelismo), mientras que async usa bucles de eventos/callbacks para permitir que las tareas se ejecuten fuera de orden, perfecto para trabajo intensivo en E/S sin esperar.

La concurrencia consiste en gestionar muchas cosas en paralelo, mientras que la asincronía es cómo un solo hilo puede gestionar muchas operaciones de E/S de manera eficiente.

Los agentes de IA suelen considerarse software intensivo en E/S porque la solicitud HTTP para ejecutar la inferencia en el modelo normalmente tarda segundos en completarse. En un entorno PHP estándar, durante ese tiempo tu aplicación simplemente espera. En esta sección de la documentación te ofrecemos un par de soluciones para ejecutar varios agentes de forma eficiente.

## Concurrencia

No necesitas ninguna característica particular de Neuron para ejecutar varios agentes en paralelo. Solo necesitas que tu aplicación PHP pueda crear múltiples procesos para gestionar la ejecución de varios agentes al mismo tiempo. Puedes hacer esto con bibliotecas de PHP como [spatie/fork](https://github.com/spatie/fork), o soluciones específicas del framework como [concurrencia en Laravel](https://laravel.com/docs/master/concurrency), o [procesos de Symfony](https://symfony.com/doc/current/components/process.html).

Async es otra historia.

## Async

Las versiones anteriores de Neuron estaban fuertemente acopladas al cliente Guzzle para realizar solicitudes HTTP para la inferencia de modelos en la API de los proveedores. Guzzle es una gran herramienta, pero no es compatible con bucles de eventos verdaderamente async como los que proporcionan frameworks como [Amp](https://github.com/amphp/amp) y [ReactPHP](https://github.com/reactphp/reactphp).

Para ejecutar agentes en este tipo de entornos async es necesario integrarse con sus implementaciones específicas. Por eso Neuron incluye un sencillo `HttpClientInterface` que se puede implementar para permitir que los proveedores de IA realicen solicitudes HTTP sin problemas en un bucle async.

Por defecto, el framework usa la implementación de Guzzle, pero puedes inyectar clientes HTTP personalizados según tus necesidades. Ya proporcionamos implementaciones para el framework async más común.

### AmpHttpClient

Si quieres usar Amp para ejecutar múltiples solicitudes de agentes async, necesitas instalar `amphp/http-client` .

```bash
composer require amphp/http-client
```

Ahora puedes inyectar el `AmpHttpClient` adaptador integrado en el proveedor:

```php
namespace App\Neuron;

use NeuronAI\Agent\Agent;
use NeuronAI\HttpClient\AmpHttpClient;
use NeuronAI\Providers\Anthropic\Anthropic;

class MyAgent extends Agent
{
    protected function provider(): AIProviderInterface
    {
        // Es lo mismo para cualquier proveedor (Anthropic, OpenAI, Ollama, Gemini, etc.)
        return new Anthropic(
            key: 'ANTHROPIC_API_KEY',
            model: 'ANTHROPIC_MODEL',
            httpClient: new AmpHttpClient(),
        );
    }
}
```

Ahora puedes ejecutar múltiples solicitudes de agentes usando el patrón async/await de Amp para ejecutar múltiples agentes de forma asíncrona:

```php
use Amp\Future;

use function Amp\async;

$handler1 = MyAgent::make()->chat(new UserMessage('Hi!'));
$handler2 = MyAgent::make()->chat(new UserMessage('Hi!'));
$handler3 = MyAgent::make()->chat(new UserMessage('Hi!'));

// Ejecutar tres solicitudes en paralelo
[$response1, $response2, $response3] = Future\await([
    async(fn() => $handler1->getMessage()), 
    async(fn() => $handler2->getMessage()),
    async(fn() => $handler3->getMessage()),
]);

// Imprimir el contenido
echo $response1->getContent();
echo $response2->getContent();
echo $response3->getContent();
```

### RAG asíncrono

La abstracción del cliente HTTP también es aceptada por todos los demás componentes del framework, como los proveedores de embeddings y los almacenes vectoriales. Puedes proporcionar un cliente async a todos estos componentes y también ejecutar de forma asíncrona la canalización de carga de datos.

```php
class MyChatBot extends RAG
{
    protected function provider(): AIProviderInterface
    {
        return new Anthropic(
            key: 'ANTHROPIC_API_KEY',
            model: 'ANTHROPIC_MODEL',
            httpClient: new AmpHttpClient(),
        );
    }
    
    protected function embeddings(): EmbeddingsProviderInterface
    {
        return new VoyageEmbeddingsProvider(
            key: 'OPENAI_API_KEY',
            model: 'OPENAI_MODEL'
            httpClient: new AmpHttpClient(),
        );
    }
    
    protected function vectorStore(): VectorStoreInterface
    {
        return new PineconeVectorStore(
            key: 'PINECONE_API_KEY',
            indexUrl: 'PINECONE_INDEX_URL',
            httpClient: new AmpHttpClient(),
        );
    }
}
```

### Salvaguardas

La capacidad de ejecutar agentes asíncronamente abre la posibilidad de ejecutar una salvaguarda de entrada al mismo tiempo que la solicitud principal. Normalmente puedes crear un agente especializado para ejecutar comprobaciones de seguridad sobre la entrada del usuario y usar la respuesta estructurada para obtener el resultado.

Puedes ejecutar ambas solicitudes en paralelo y comprobar el resultado de la salvaguarda antes de devolver la respuesta al usuario. Ejecutar ambas solicitudes en paralelo te permite aplicar seguridad sin afectar la experiencia del usuario.

```php
use Amp\Future;
use function Amp\async;

$input = new UserMessage('Hi!');

// Ejecutar tres solicitudes en paralelo
[$response, $guardrail] = Future\await([
    async(fn() => MyAgent::make()->chat($input)->getMessage()), 
    async(fn() => GuardrailAgent::make()->structured($input, Guardrail::class)),
]);

if (! $guardrail->valid) {
    throw \Exception('Violation of content policy.');
}

// Imprimir el contenido
echo $response->getContent();
```