# Formas de despliegue

> Cómo el mismo binario de Sypnia corre como tres funciones de AWS o como un proceso largo, qué crea la plantilla de AWS, cuánto cuesta cada forma con la aritmética a la vista, y las piezas que puedes cambiar, vistas desde el código.

Aplica a: el motor de Sypnia (código abierto, en tu propia infraestructura). Estado: al lanzar.  
Fuente: https://docs.sypnia.com/es/architecture/deployment-shapes/

El motor es un solo programa, `sypnia`. Se puede arrancar de dos maneras, y en las dos hace el mismo trabajo:

- **como funciones en AWS**, que despiertan con solicitudes, una cola y una programación;
- **como un proceso largo**, en Docker o en cualquier servidor.

Esta página muestra qué cambia entre las dos, qué es igual, cuánto cuesta cada una y dónde están los bordes del motor: las cuatro piezas que puedes reemplazar.

> **Nota: Sobre el código y los números**
>
> El Rust de aquí es un extracto de diseño; el repositorio se abre al lanzar. Los costos son estimaciones hechas con precios publicados y con volúmenes medidos en el sistema del que sale este motor. Cada línea muestra su aritmética para que la rehagas con tus números y los precios de hoy.

## Un motor, dos maneras de despertarlo

**Figura (diagrama aún sin dibujar)**: El mismo motor en las dos formas. En AWS hay una cola donde está el búfer en memoria; nada más cambia.

Mostrará: El mismo diagrama de tres columnas que la figura 1 de la página en inglés (architecture/deployment-shapes), con las mismas cajas, flechas, llamadas (1) a (3) y el mismo elemento encendido (la caja central del motor). Rótulos traducidos: columna central «Motor (el mismo código)» con las fichas «Ingesta», «Vía rápida», «Consolidación», «El agente · Alertas», «API · Servidor MCP · Consola». Columna izquierda «En AWS: tres funciones»: «función: ingest» con el disparador «HTTPS, por la dirección»; «función: worker» con los disparadores «cola (ventana de 10 s)», «programación: cada minuto», «ella misma, para tareas del agente»; «función: api» con «HTTPS, por la dirección»; símbolo de cola «cola de entrada». Columna derecha «En un servidor: un proceso»: caja «sypnia serve» con las fichas «servidor HTTP», «búfer, se escribe cada 2 s», «ciclo del worker, cada 30 s», «refresco de caché, cada 60 s». Abajo: «Bucket» y «Postgres» con la línea «la misma disposición del bucket y las mismas tablas en las dos formas: puedes pasar de una a otra».

|                                 | Funciones de AWS                                          | Un proceso                                       |
| ------------------------------- | --------------------------------------------------------- | ------------------------------------------------ |
| Lo arranca                      | La plantilla                                              | `sypnia serve`                                   |
| El búfer de la ingesta (1) (2)  | Una cola: la ingesta envía, el worker escribe el segmento | Memoria: se escribe cada 2 s                     |
| La vía rápida corre             | Cuando la cola entrega, y cada minuto                     | Cuando cae un segmento, y cada 30 s              |
| La consolidación corre          | En la marca del minuto, cuando pasaron 5 minutos          | En el ciclo del worker, cuando pasaron 5 minutos |
| Escala con                      | Más copias de una función, por sí sola                    | Más procesos con `--role`, por tu cuenta         |
| Costo sin tráfico               | Casi nada                                                 | El servidor                                      |
| Disposición del bucket y tablas | Las mismas                                                | Las mismas                                       |

Las dos arrancan en el mismo `main`. Fíjate en que hay un solo `Engine::connect` y en que todo lo que sigue solo decide qué despierta al motor.

`crates/sypnia/src/main.rs`

```rust
#[tokio::main]
async fn main() -> ExitCode {
    let config = match Config::from_env_and_file() {
        Ok(config) => Arc::new(config),
        Err(error) => return fail(3, &error), // un ajuste obligatorio que falta dice su nombre
    };
    // Bucket, Postgres, el proveedor de IA (o ninguno), las salidas de alertas. Se arma una vez y lo comparte todo.
    let engine = match Engine::connect(config.clone()).await {
        Ok(engine) => Arc::new(engine),
        Err(error) => return fail(4, &error),
    };

    // Dentro de AWS Lambda el entorno pone esta variable y no hay línea de comandos.
    if std::env::var_os("AWS_LAMBDA_RUNTIME_API").is_some() {
        return exit(lambda::run(engine, config.role).await);
    }

    match Cli::parse().command {
        Command::Serve(args) => exit(serve::run(engine, args).await),       // el proceso largo
        Command::Aggregate(args) => exit(aggregate::run(engine, args).await), // una pasada y termina
        Command::Migrate(args) => exit(migrate::run(engine, args).await),
        Command::Doctor => exit(doctor::run(engine).await),
        other => exit(admin::run(engine, other).await), // project, key, token, sourcemaps, problems
    }
}
```

## Como funciones de AWS

La plantilla corre una función por rol, los mismos tres roles que acepta `sypnia serve --role`.

**Figura (diagrama aún sin dibujar)**: Lo que crea la plantilla: una dirección, tres funciones, una cola con su cola de mensajes fallidos, una programación y un bucket. Postgres lo traes tú o dejas que la plantilla lo cree.

Mostrará: El mismo diagrama de arquitectura que la figura 2 de la página en inglés (architecture/deployment-shapes), con los mismos recursos, flechas, candados, llamadas (1) a (6) y el mismo elemento encendido (la función worker). Rótulos traducidos: marco «Tu cuenta de AWS · una región»; afuera a la izquierda «Tu app (SDK)» y «Tú · tu agente de código»; nodo «Dirección · https\://sypnia.example.com» que reparte («/v1/ingest/\*, /v1/otlp/\*» a ingest, «todo lo demás» a api); cajas «ingest» («256 MB · 10 s · arm64»), «cola de entrada», «cola de mensajes fallidos», «worker» («1.024 MB · 15 min · arm64»), un reloj «programación: cada minuto» con la nota «también inicia la tarea diaria a las 02:30 UTC y la semanal el lunes a las 07:00 UTC», flecha curva «tareas del agente (asíncronas)», «Bucket» («privado · toda llave empieza con un id de proyecto»), «Postgres» («tuyo, o creado por la plantilla»), «api» («512 MB · 30 s · arm64», «API · Servidor MCP · Consola»). Flechas: «eventos, fragmentos de grabación, OTLP»; «lotes validados»; «fragmentos, capturas, lotes grandes»; «hasta 10 s de mensajes»; «tras 5 entregas fallidas»; «segmentos, archivos por sesión, Parquet»; «problemas, números, registro»; «lecturas»; «enlaces firmados». Cajas punteadas externas: «Proveedor de IA (tuyo)» con «el agente, si está configurado» y «Tu webhook» con «alertas». Candados: «solo escribir», «leer + firmar», «leer y escribir».

| Función (rol)    | La despierta                                          | Hace                                                                                                                                                                                                                                                                        | Memoria, límite de tiempo         |
| ---------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------- |
| **`ingest`** (1) | La dirección (6), para `/v1/ingest/*` y `/v1/otlp/*`  | Las siete puertas, y luego envía el lote validado a la cola. Escribe fragmentos de grabación, capturas y lotes de más de 192 KiB directo al Bucket                                                                                                                          | 256 MB, 10 s, máximo 40 copias    |
| **`worker`** (3) | La cola de entrada (2): hasta 10 segundos de mensajes | Escribe los segmentos, agrega las filas del registro y corre la vía rápida sobre ellos de inmediato                                                                                                                                                                         | 1.024 MB, 15 min, máximo 2 copias |
|                  | La programación, cada minuto (5)                      | Una pasada: lo que le quedó a la vía rápida y las fallas retenidas, alertas que ya debían salir, chequeos de disponibilidad, reintentos de webhooks, y la consolidación cuando pasaron 5 minutos                                                                            |                                   |
|                  | Ella misma, de forma asíncrona                        | Una tarea del agente: traducir la pila, analizar, liberar la alerta. Y las dos tareas largas que la pasada inicia cuando les toca: la diaria a las 02:30 UTC (Parquet, retención, particiones de los meses siguientes) y las sugerencias semanales el lunes a las 07:00 UTC |                                   |
| **`api`** (4)    | La dirección (6), para todo lo demás                  | La API, el servidor MCP en `/mcp`, la Consola en `/console`                                                                                                                                                                                                                 | 512 MB, 30 s, máximo 20 copias    |

El worker distingue quién lo despertó por la forma del evento. Fíjate en que el caso de la cola y el búfer de un proceso terminan en las mismas dos llamadas: escribir segmentos y revisarlos.

`crates/sypnia/src/lambda.rs`

```rust
/// Todo lo que puede despertar a la función worker.
#[derive(Deserialize)]
#[serde(untagged)]
enum WorkerEvent {
    Queue(SqsEvent),       // { "Records": [...] }: lotes de la función de ingesta
    Job { job: Job },      // { "job": "pass" }: una programación, o el worker llamándose a sí mismo
}

#[derive(Deserialize)]
#[serde(rename_all = "snake_case")]
enum Job {
    Pass,
    Daily,
    Suggestions,
    Agent { problem: ProblemId },
}

async fn worker_event(engine: &Engine, event: WorkerEvent) -> Result<(), EngineError> {
    match event {
        WorkerEvent::Queue(batch) => {
            // Los mismos dos pasos con los que termina el búfer en memoria.
            let segments = intake::write_segments(engine, batch.into_lines()?).await?;
            fast_path::scan(engine, &segments).await?;
        }
        WorkerEvent::Job { job: Job::Pass } => { engine.pass().await?; }
        WorkerEvent::Job { job: Job::Daily } => daily::run(engine).await?,
        WorkerEvent::Job { job: Job::Suggestions } => suggestions::run(engine).await?,
        WorkerEvent::Job { job: Job::Agent { problem } } => agent::run_job(engine, &problem).await?,
    }
    Ok(()) // un error hace que la cola entregue de nuevo; todo paso se puede repetir sin daño
}

pub async fn run(engine: Arc<Engine>, role: Role) -> Result<(), lambda_runtime::Error> {
    match role {
        Role::Ingest => lambda_http::run(ingest::router(engine)).await, // el mismo router de axum que `serve`
        Role::Api => lambda_http::run(api::router(engine)).await,
        Role::Worker | Role::All => {
            lambda_runtime::run(service_fn(move |event: LambdaEvent<WorkerEvent>| {
                let engine = engine.clone();
                async move { worker_event(&engine, event.payload).await }
            }))
            .await
        }
    }
}
```

### Por qué una cola, y solo una

La cola (2) existe por una razón: una función no tiene memoria entre solicitudes, así que no puede agrupar lotes en segmentos. La cola es esa memoria. También despierta al worker en el momento en que hay algo que revisar; por eso la forma de AWS crea un problema más rápido de lo que sugiere su programación de cada minuto.

Hay una cola y no cuatro. Las tareas del agente, la liberación de alertas y los reintentos de webhooks son filas en Postgres con una hora; la marca del minuto recoge lo que una llamada directa haya dejado pasar. La alternativa, una cola por tipo de trabajo, serían tres cosas más que crear, vigilar y pagar, para mover unas pocas filas por minuto.

Un mensaje que falla cinco entregas va a la cola de mensajes fallidos y dispara una alarma. Nada en el motor la lee por su cuenta: un lote que no se puede escribir cinco veces es un error que hay que mirar, y `sypnia aggregate` puede repetirlo.

### Qué crea la plantilla

| Recurso                                           | Notas                                                                                                                                                                                                          |
| ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Un bucket privado                                 | Sin acceso público. Una regla de ciclo de vida, para subidas sin terminar. La retención es la tarea diaria del motor                                                                                           |
| La cola de entrada y su cola de mensajes fallidos | Los mensajes se guardan 4 días; 5 entregas antes de pasar a la cola de fallidos                                                                                                                                |
| Tres funciones, arm64, con sus roles              | `ingest` puede enviar a la cola y escribir objetos; `api` puede leer objetos y firmar enlaces; `worker` puede leer y escribir el bucket y llamarse a sí misma                                                  |
| Una dirección                                     | Una distribución de entrega de contenido delante de las dos funciones HTTP, así el motor tiene una sola URL base. No guarda nada en caché salvo el archivo del SDK. CORS lo responde el motor, no la dirección |
| Una programación                                  | Cada minuto. Las tareas diaria y semanal las inicia la pasada cuando les toca, así hay una programación que vigilar, no tres                                                                                   |
| Grupos de logs                                    | Se conservan 30 días                                                                                                                                                                                           |
| Dos alarmas                                       | Mensajes en la cola de fallidos; el worker fallando                                                                                                                                                            |
| Postgres, opcional                                | Una instancia pequeña, o ninguna si pasas `SYPNIA_DATABASE_URL`                                                                                                                                                |

No crea un balanceador, un clúster de contenedores, una caché, un flujo ni un servicio de búsqueda. La guía paso a paso es [Desplegar en AWS](https://docs.sypnia.com/es/self-hosting/deploy-aws).

### Arranques en frío, límites y conexiones

- **Arranques en frío.** El binario es código nativo, sin un entorno que arrancar ni nada que descargar. Presupuesto: 300 ms para que una función fría responda su primera solicitud, casi todo abriendo la conexión a Postgres. Para comparar, medido en el sistema del que sale esto: 0,4 s para que arrancara su agregador, y luego una descarga de 50 MB de una extensión en cada arranque en frío, que este diseño no tiene.
- **La respuesta de 6 MB.** Una función no puede responder más de 6 MB. Las mismas reglas de allá: una grabación se entrega como enlaces firmados a sus fragmentos, nunca a través de la función; el detalle de una sesión tiene un presupuesto de 4 MB con un orden fijo de qué dejar fuera.
- **Conexiones a Postgres.** Cada copia de una función tiene las suyas. `ingest` tiene máximo una y la usa solo para llenar su caché; `api` máximo dos; un `worker`, una por proyecto que esté consolidando más una. Pon un agrupador de conexiones delante de Postgres cuando corran muchas copias: el sistema del que sale esto agotó su agrupador una vez, con cada copia de una función que atendía solicitudes abriendo su propio grupo.
- **La caché de la ingesta.** Una función `ingest` fría le pregunta a Postgres por una llave la primera vez que la ve, y luego la guarda 60 segundos. Una tibia nunca pregunta.

> **Nota: Sypnia Cloud**
>
> **\[Nube]** Sypnia Cloud corre esta forma en `us-east-1`, con la misma plantilla. Alrededor está la parte privada que el motor no tiene: cuentas y organizaciones, facturación, la app, el correo, la GitHub App y el modelo administrado.

## Cuánto cuesta en AWS

Dos proyectos de ejemplo. **Pequeño** es el tamaño medido en el sistema del que sale este motor. **Mediano** es diez veces eso.

| Por mes                                                                 | Pequeño                     | Mediano     |
| ----------------------------------------------------------------------- | --------------------------- | ----------- |
| Eventos                                                                 | 4 millones (130.000 al día) | 40 millones |
| Sesiones                                                                | 30.000 (1.000 al día)       | 300.000     |
| Lotes enviados a la ingesta (30 por sesión)                             | 0,9 millones                | 9 millones  |
| Fragmentos de grabación (15 % de las sesiones grabadas × 22 fragmentos) | 0,1 millones                | 1 millón    |

Precios usados, por demanda, publicados para `us-east-1` cuando se escribió esto: funciones en arm64, USD 0,0000133 por GB-segundo y USD 0,20 por millón de solicitudes; cola, USD 0,40 por millón de solicitudes; almacenamiento de objetos, USD 0,023 por GB-mes, USD 5 por millón de escrituras, USD 0,40 por millón de lecturas; logs, USD 0,50 por GB. Revísalos antes de confiar en un total.

| Línea                            | Aritmética (pequeño)                                                                                                                  | Pequeño      | Mediano           |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ------------ | ----------------- |
| La dirección                     | 1,0 M de solicitudes. Dentro de la cuota gratuita del proveedor, 10 millones de solicitudes al mes; cerca de USD 1 por millón después | 0,00         | 0,00              |
| Solicitudes de `ingest`          | 1,0 M × 0,20                                                                                                                          | 0,20         | 2,00              |
| Tiempo de `ingest`               | 1,0 M × 0,05 s × 0,25 GB = 12.500 GB-s                                                                                                | 0,17         | 1,67              |
| Cola                             | 0,9 M de envíos + unos 0,6 M de recepciones y borrados = 1,5 M × 0,40                                                                 | 0,60         | 4,00              |
| `worker`, despertado por la cola | Máximo una vez cada 10 s: 260.000 × 0,5 s × 1 GB = 130.000 GB-s (2 s cada una en el mediano)                                          | 1,78         | 6,98              |
| `worker`, marca del minuto       | 43.200 × 1 s × 1 GB (2 s en el mediano)                                                                                               | 0,58         | 1,15              |
| `worker`, consolidación          | 8.640 corridas × 5 s × 1 GB (30 s en el mediano)                                                                                      | 0,58         | 3,46              |
| Escrituras de objetos            | 260.000 segmentos + 60.000 archivos por sesión + 100.000 fragmentos = 0,42 M × 5                                                      | 2,10         | 10,50             |
| Lecturas de objetos              | La consolidación relee la hora abierta: máximo 3,1 M × 0,40                                                                           | 1,24         | 2,00              |
| Almacenamiento de objetos        | 1,2 GB por millón de eventos; 90 días de eventos, 30 de grabaciones: unos 8 GB × 0,023                                                | 0,18         | 1,84              |
| Logs                             | Éxitos muestreados al 1 %: cerca de 1 GB                                                                                              | 0,50         | 2,00              |
| **Motor, sin Postgres**          |                                                                                                                                       | **≈ USD 8**  | **≈ USD 36**      |
| Postgres                         | La instancia administrada más pequeña, con 1 GB de memoria y 20 GB de disco; 2 a 4 GB de memoria en el mediano                        | ≈ 14         | 25 a 50           |
| **Total**                        |                                                                                                                                       | **≈ USD 22** | **≈ USD 60 a 85** |

Tres cosas que leer de la tabla:

1. **La base de datos es la línea más grande** en tamaños pequeños. También es la que quizá ya tienes: sirve cualquier Postgres 15 o posterior.
2. **Escribir objetos cuesta más que todo lo guardado.** Medido allá: de USD 3,81 de almacenamiento de objetos en 12 días, USD 2,73 fueron escrituras. Por eso los lotes se agrupan en segmentos y los fragmentos de grabación son de 200 KB y no más pequeños.
3. **Recibir es casi gratis.** Aceptar un millón de lotes cuesta menos de 40 centavos.

La cuota gratuita de AWS para funciones, 400.000 GB-segundos y un millón de solicitudes al mes, cubre casi todas las líneas de funciones del proyecto pequeño. El total pequeño coincide con lo que cuesta el primer despliegue de este diseño, USD 15 a 25 al mes.

Fuera de la tabla: el modelo. Un análisis son unos miles de tokens de entrada y máximo dos mil de salida, máximo 100 al día por proyecto, al precio de tu proveedor. Y los datos que salen de AWS cuando ves grabaciones, que es el tamaño de la grabación.

## Como un proceso largo

`sypnia serve` es el motor completo en un proceso: el servidor HTTP para la ingesta, la API, el servidor MCP y la Consola, y el worker.

| Tarea dentro del proceso | Hace                                                                                | Cada                                                                     |
| ------------------------ | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| Servidor HTTP            | Ingesta, OTLP, API, servidor MCP, Consola                                           | Cada solicitud                                                           |
| Escritor del búfer       | Cierra los segmentos abiertos, los escribe y deja en cola sus filas del registro    | 2 s, o 4 MiB                                                             |
| Ciclo del worker         | `Engine::pass`: vía rápida, alertas, disponibilidad, y la consolidación cuando toca | `processing.interval_seconds`, 30 s; de inmediato cuando cae un segmento |
| Tareas del agente        | Una por trabajo, máximo 4 a la vez                                                  | Cuando la vía rápida deja una en cola                                    |
| Refresco de la caché     | Llaves, orígenes, límites, `slow_down`                                              | 60 s                                                                     |
| Tarea diaria             | Parquet, retención, particiones                                                     | 02:30 UTC                                                                |

Fíjate en el extracto en que el ciclo del worker espera lo que ocurra primero, el temporizador o un segmento que cae, y en que al apagarse deja terminar el paso en curso.

`crates/sypnia/src/serve.rs`

```rust
pub async fn run(engine: Arc<Engine>, args: ServeArgs) -> Result<(), ServeError> {
    let stop = CancellationToken::new();
    let mut tasks = JoinSet::new();

    if args.role.serves_http() {
        let app = Router::new()
            .merge(ingest::router(engine.clone()))  // /v1/ingest/*, /v1/otlp/*
            .merge(api::router(engine.clone()));    // /v1/*, /mcp, /console, /healthz
        let listener = TcpListener::bind(engine.config.listen).await?;
        let stopping = stop.clone();
        tasks.spawn(async move {
            axum::serve(listener, app)
                .with_graceful_shutdown(async move { stopping.cancelled().await })
                .await
                .map_err(ServeError::from)
        });
    }

    if args.role.works() {
        let (engine, stopping) = (engine.clone(), stop.clone());
        tasks.spawn(async move {
            let every = engine.config.processing.interval;
            loop {
                if let Err(error) = engine.pass().await {
                    tracing::error!(%error, "pass failed; the next one repeats it");
                }
                tokio::select! {
                    _ = tokio::time::sleep(every) => {}
                    _ = engine.segment_landed.notified() => {} // que una falla no espere 30 s
                    _ = stopping.cancelled() => return Ok(()),
                }
            }
        });
    }

    shutdown_signal().await; // SIGTERM o Ctrl-C
    stop.cancel();           // las solicitudes tienen 20 s; los segmentos abiertos se escriben; la pasada termina su paso
    while let Some(done) = tasks.join_next().await {
        done??;
    }
    Ok(())
}
```

**Tamaño.** El proceso del motor necesita memoria para dos proyectos en consolidación (2 × 256 MB), el búfer de la ingesta (32 MiB) y la caché de source maps (200 MB): con 1 GB va cómodo, con 2 GB sobra espacio. Un núcleo de CPU alcanza para el proyecto pequeño de arriba; el trabajo es esperar al Bucket y a Postgres, no calcular. Con Postgres y el bucket en la misma máquina, calcula más: [Escalado y costo](https://docs.sypnia.com/es/self-hosting/scaling-and-cost) tiene los tamaños.

**Escalar.** Corre varios procesos contra el mismo Bucket y el mismo Postgres, cada uno con un rol:

```bash
sypnia serve --role ingest --listen 0.0.0.0:8081   # los que necesites, detrás de tu balanceador
sypnia serve --role api    --listen 0.0.0.0:8082
sypnia serve --role worker                         # dos workers no chocan: el registro decide quién hace qué
```

Con la ingesta y el worker separados, un segmento que cae no puede despertar al worker directamente. El worker lo encuentra en el registro en su siguiente pasada, máximo 30 segundos después, que es el caso para el que se calcula el presupuesto de 2 minutos en [Flujo de datos](https://docs.sypnia.com/es/architecture/data-flow).

**Costo.** El precio del servidor, más Postgres y un bucket si no están en la misma máquina. El archivo de Docker Compose de [Desplegar con Docker](https://docs.sypnia.com/es/self-hosting/deploy-docker) arranca juntos el motor, Postgres y un almacenamiento compatible con S3, para probarlo en una máquina.

## Las piezas que puedes cambiar

El motor toca el mundo exterior en cuatro lugares. Cada uno es un trait en el código y una elección en la documentación. El despliegue por defecto usa la opción más pequeña de cada uno.

**Figura (diagrama aún sin dibujar)**: Los cuatro bordes del motor. Todo lo que está por fuera de un puerto se puede reemplazar sin tocar lo de adentro.

Mostrará: El mismo diagrama de puertos y adaptadores que la figura 3 de la página en inglés (architecture/deployment-shapes), con el hexágono central, los cuatro puertos (los nombres de los traits no se traducen: «ObjectStore», «Database», «AiProvider», «AlertSink»), los mismos adaptadores, marcas, llamadas (1) a (4) y el mismo elemento encendido (el hexágono). Rótulos traducidos: hexágono «Motor» con el texto «solo conoce cuatro traits»; adaptadores de ObjectStore: «Amazon S3», «Cloudflare R2», «MinIO», punteado «una carpeta (pruebas)»; de Database: «Postgres en RDS», «Supabase», «Neon», «tu propio Postgres», punteado «Postgres dentro del proceso (pruebas)»; de AiProvider: «ninguno (por defecto)», «OpenRouter», «API de OpenAI», «API de Anthropic», «Google Gemini», «cualquier endpoint compatible con OpenAI», punteado «una respuesta grabada (pruebas)»; de AlertSink: «el registro en Postgres (siempre)», «tu webhook», y fuera del borde punteado «lo construyes tú, sobre el webhook»: «correo con Amazon SES» y «cualquier SMTP»; caja solo de la nube «correo y alertas dentro de la app (Sypnia Cloud)». Leyenda: punto relleno «despliegue por defecto», símbolo de nube «Sypnia Cloud», caja punteada «solo en pruebas».

Los dos traits que no aparecen en otras páginas. Fíjate en que cada método del almacén recibe una llave armada por `Keys`, nunca un texto, y en que una salida recibe una alerta terminada y no puede cambiarla.

`crates/sypnia-core/src/ports.rs`

```rust
/// (1) Dónde viven los objetos. Implementado sobre el crate `object_store` para almacenes compatibles con S3,
/// y sobre una carpeta para pruebas y para `sypnia serve` en un portátil.
#[async_trait]
pub trait ObjectStore: Send + Sync {
    async fn put(&self, key: &ObjectKey, body: Bytes, options: PutOptions) -> Result<(), StoreError>;
    /// El objeto como líneas, descomprimidas a medida que se leen. Un segmento nunca está dos veces en memoria.
    async fn read_lines(&self, key: &ObjectKey) -> Result<LineStream, StoreError>;
    async fn get(&self, key: &ObjectKey) -> Result<Bytes, StoreError>;
    /// Llaves bajo un prefijo, en orden. `after` continúa un listado sin releerlo.
    async fn list(&self, prefix: &KeyPrefix, after: Option<&ObjectKey>) -> Result<Vec<ObjectMeta>, StoreError>;
    async fn delete_prefix(&self, prefix: &KeyPrefix) -> Result<u64, StoreError>;
    /// Un enlace que un navegador puede usar directamente: para reproducir un fragmento o subir un source map.
    async fn sign(&self, key: &ObjectKey, method: SignedMethod, ttl: Duration) -> Result<Url, StoreError>;
}

/// (4) A dónde va una alerta liberada. El motor trae dos: el registro y el webhook.
#[async_trait]
pub trait AlertSink: Send + Sync {
    fn name(&self) -> &str;
    /// Se llama una vez por alerta liberada. Un error se reintenta con esperas crecientes y queda anotado como entrega.
    async fn deliver(&self, alert: &ReleasedAlert) -> Result<Delivery, SinkError>;
}
```

`Database` (2) es la misma idea con más métodos: uno por sentencia que corre el motor, agrupados por tabla, implementados una vez con `sqlx` para Postgres. Es un trait para que las pruebas puedan contar consultas y hacerlas fallar, no porque se planee otra base de datos. `AiProvider` (3) está en [El proceso del agente](https://docs.sypnia.com/es/architecture/agent-pipeline).

**Una pieza que eliges tú: Almacenamiento de objetos.** Guarda los eventos crudos, los fragmentos de grabación, las capturas de página y los source maps.

- **Despliegue por defecto:** El bucket que crea la plantilla, o el que nombres en SYPNIA_STORAGE_BUCKET.
- **Sypnia Cloud usa:** Amazon S3.

**Una pieza que eliges tú: Base de datos.** Guarda los agregados, el índice de sesiones, los problemas y la configuración.

- **Despliegue por defecto:** Una URL de Postgres que tú das, o la instancia que crea la plantilla.
- **Sypnia Cloud usa:** Postgres.

**Una pieza que eliges tú: Entrega de alertas.** Lleva una alerta del motor a una persona.

- **Despliegue por defecto:** Ninguna. Las alertas se registran, se muestran en la Consola y se envían a un webhook si pones uno.
- **Sypnia Cloud usa:** Correo con Amazon SES y alertas dentro de la app.

**Una pieza que eliges tú: Proveedor de IA.** Corre el modelo detrás del análisis del agente y del prompt listo.

- **Despliegue por defecto:** Apagado hasta que pongas una llave.
- **Sypnia Cloud usa:** OpenRouter.

No hay salida de WhatsApp ni de Slack, ni en el motor ni en Sypnia Cloud. Un `AlertSink` para cualquiera de los dos son unas pocas decenas de líneas de tu lado del webhook, y el motor no necesita saberlo.

## Qué forma elegir

| Si tú                                                                          | Elige                                                              |
| ------------------------------------------------------------------------------ | ------------------------------------------------------------------ |
| Ya tienes cosas en AWS y quieres pagar por uso, no por un servidor sin tráfico | Funciones de AWS                                                   |
| Quieres todo en una máquina, o no estás en AWS                                 | Un proceso                                                         |
| Quieres probar el motor en un portátil                                         | Un proceso, con Docker Compose                                     |
| Esperas tráfico en ráfagas                                                     | Funciones de AWS: aparecen más copias por sí solas                 |
| Necesitas que tus datos nunca salgan de tu red, incluido el modelo             | Un proceso, con un endpoint compatible con OpenAI dentro de tu red |

Puedes cambiar de opinión. La disposición del Bucket y las tablas son las mismas, así que mudarse es apuntar la otra forma al mismo Bucket y al mismo Postgres.

## Qué cambió frente al sistema del que sale

| Allá                                                                                             | Aquí                                                                | Por qué                                                                              |
| ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
| Solo funciones, desplegadas con la app                                                           | Funciones, o un proceso                                             | Brief §10.9: el mismo binario en las dos formas                                      |
| Una función de ingesta, una de cada hora, una diaria y una semanal, cada una con su programación | Tres funciones por rol; el worker tiene una cola y una programación | Una función por rol coincide con `--role`, y un binario tiene una sola configuración |
| Un flujo de entrega administrado entre la ingesta y el bucket                                    | Una cola en AWS, memoria en lo demás                                | Frescura, y objetos nombrados por proyecto                                           |
| Solo x86_64, por un binario nativo                                                               | arm64, o cualquier destino para el que compile Rust                 | Ya no queda dependencia nativa                                                       |
| Cinco variables de entorno en la app para enviar datos del servidor                              | Una llave de ingesta y una URL                                      | Su app llegó una vez a 3.924 de los 4.096 bytes que admite el entorno de una función |

## Sigue
