Docs

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 Motor Al lanzar

Ver como Markdown
En esta página
  1. Un motor, dos maneras de despertarlo
  2. Como funciones de AWS
  3. Por qué una cola, y solo una
  4. Qué crea la plantilla
  5. Arranques en frío, límites y conexiones
  6. Cuánto cuesta en AWS
  7. Como un proceso largo
  8. Las piezas que puedes cambiar
  9. Qué forma elegir
  10. Qué cambió frente al sistema del que sale
  11. Sigue

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.

Un motor, dos maneras de despertarlo

Diagrama por dibujarEl 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».
Figura. El mismo motor en las dos formas. En AWS hay una cola donde está el búfer en memoria; nada más cambia.
Funciones de AWSUn proceso
Lo arrancaLa plantillasypnia serve
El búfer de la ingesta (1) (2)Una cola: la ingesta envía, el worker escribe el segmentoMemoria: se escribe cada 2 s
La vía rápida correCuando la cola entrega, y cada minutoCuando cae un segmento, y cada 30 s
La consolidación correEn la marca del minuto, cuando pasaron 5 minutosEn el ciclo del worker, cuando pasaron 5 minutos
Escala conMás copias de una función, por sí solaMás procesos con --role, por tu cuenta
Costo sin tráficoCasi nadaEl servidor
Disposición del bucket y tablasLas mismasLas 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
#[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.

Diagrama por dibujarEl 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».
Figura. 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.
Función (rol)La despiertaHaceMemoria, 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 Bucket256 MB, 10 s, máximo 40 copias
worker (3)La cola de entrada (2): hasta 10 segundos de mensajesEscribe los segmentos, agrega las filas del registro y corre la vía rápida sobre ellos de inmediato1.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íncronaUna 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ásLa API, el servidor MCP en /mcp, la Consola en /console512 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
/// 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

RecursoNotas
Un bucket privadoSin 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 fallidosLos mensajes se guardan 4 días; 5 entregas antes de pasar a la cola de fallidos
Tres funciones, arm64, con sus rolesingest 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ónUna 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ónCada minuto. Las tareas diaria y semanal las inicia la pasada cuando les toca, así hay una programación que vigilar, no tres
Grupos de logsSe conservan 30 días
Dos alarmasMensajes en la cola de fallidos; el worker fallando
Postgres, opcionalUna 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.

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.

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 mesPequeñoMediano
Eventos4 millones (130.000 al día)40 millones
Sesiones30.000 (1.000 al día)300.000
Lotes enviados a la ingesta (30 por sesión)0,9 millones9 millones
Fragmentos de grabación (15 % de las sesiones grabadas × 22 fragmentos)0,1 millones1 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íneaAritmética (pequeño)PequeñoMediano
La dirección1,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és0,000,00
Solicitudes de ingest1,0 M × 0,200,202,00
Tiempo de ingest1,0 M × 0,05 s × 0,25 GB = 12.500 GB-s0,171,67
Cola0,9 M de envíos + unos 0,6 M de recepciones y borrados = 1,5 M × 0,400,604,00
worker, despertado por la colaMá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,786,98
worker, marca del minuto43.200 × 1 s × 1 GB (2 s en el mediano)0,581,15
worker, consolidación8.640 corridas × 5 s × 1 GB (30 s en el mediano)0,583,46
Escrituras de objetos260.000 segmentos + 60.000 archivos por sesión + 100.000 fragmentos = 0,42 M × 52,1010,50
Lecturas de objetosLa consolidación relee la hora abierta: máximo 3,1 M × 0,401,242,00
Almacenamiento de objetos1,2 GB por millón de eventos; 90 días de eventos, 30 de grabaciones: unos 8 GB × 0,0230,181,84
LogsÉxitos muestreados al 1 %: cerca de 1 GB0,502,00
Motor, sin Postgres≈ USD 8≈ USD 36
PostgresLa 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≈ 1425 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 procesoHaceCada
Servidor HTTPIngesta, OTLP, API, servidor MCP, ConsolaCada solicitud
Escritor del búferCierra los segmentos abiertos, los escribe y deja en cola sus filas del registro2 s, o 4 MiB
Ciclo del workerEngine::pass: vía rápida, alertas, disponibilidad, y la consolidación cuando tocaprocessing.interval_seconds, 30 s; de inmediato cuando cae un segmento
Tareas del agenteUna por trabajo, máximo 4 a la vezCuando la vía rápida deja una en cola
Refresco de la cachéLlaves, orígenes, límites, slow_down60 s
Tarea diariaParquet, retención, particiones02: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
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 tiene los tamaños.

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

Terminal
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.

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 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.

Diagrama por dibujarEl 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».
Figura. Los cuatro bordes del motor. Todo lo que está por fuera de un puerto se puede reemplazar sin tocar lo de adentro.

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
/// (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.

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.

Tus opciones

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.

Tus opciones

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.

Tus opciones

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.

Tus opciones

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áficoFunciones de AWS
Quieres todo en una máquina, o no estás en AWSUn proceso
Quieres probar el motor en un portátilUn proceso, con Docker Compose
Esperas tráfico en ráfagasFunciones de AWS: aparecen más copias por sí solas
Necesitas que tus datos nunca salgan de tu red, incluido el modeloUn 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 appFunciones, o un procesoBrief §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ónTres funciones por rol; el worker tiene una cola y una programaciónUna 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 bucketUna cola en AWS, memoria en lo demásFrescura, y objetos nombrados por proyecto
Solo x86_64, por un binario nativoarm64, o cualquier destino para el que compile RustYa no queda dependencia nativa
Cinco variables de entorno en la app para enviar datos del servidorUna llave de ingesta y una URLSu app llegó una vez a 3.924 de los 4.096 bytes que admite el entorno de una función

Sigue

Secciones

Empieza aquíQué es Sypnia, cómo funciona, qué es código abierto y qué es la nube de pago, y las dos maneras de recibir tu primer problema en palabras claras.ConceptosLas diez ideas de las que está hecho Sypnia, cada una definida con precisión, desde un proyecto y sus llaves hasta los problemas, las trazas y las alertas.SDKCómo envía tu app los datos a Sypnia. Un SDK para el navegador, uno para Node, uno para Next.js, y la entrada de OpenTelemetry para cualquier otro backend.El agenteCómo analiza Sypnia un problema, qué escribe, qué le envía a un modelo y qué nunca hace.MCP y skillsConecta tu agente de código a Sypnia para que pregunte qué está fallando en producción, lea lo que necesita para arreglarlo y configure Sypnia por ti.Referencia de la APILa API HTTP de Sypnia: una sola API para el motor de código abierto y para Sypnia Cloud, con cada endpoint, parámetro, respuesta y error.Referencia de la CLIEl comando sypnia: cómo instalarlo, qué variables lee, qué significan sus códigos de salida y dónde está documentado cada comando.Alojamiento propioQué corres cuando alojas tú mismo el motor de Sypnia, qué necesitas, cuánto cuesta y qué no tienes frente a Sypnia Cloud.Cómo está construido el motorTodo el motor de Sypnia en una página, desde un clic en tu app hasta la frase que lee tu agente de código, con las reglas de diseño y el código que las sostiene.Sypnia CloudCómo funciona el servicio pago, desde las organizaciones y los roles hasta los planes, los límites, la facturación, dónde viven tus datos, la GitHub App y el soporte.Privacidad y seguridadQué recoge Sypnia de tu app y de sus usuarios, qué no recoge nunca, cómo funciona el enmascarado, cómo eliminar datos y cómo se protege el servicio.LicenciasQué licencia cubre cada parte de Sypnia, qué puedes hacer con ella, cómo se puede usar el nombre, y los términos de una contribución.GuíasRecetas paso a paso para las formas comunes de usar Sypnia, desde apps hechas con constructores de IA y Next.js en Vercel hasta Supabase, source maps en CI, correos de alerta desde tu propio motor, y venir desde Sentry.ReferenciaLas páginas donde se consulta, desde el esquema de eventos y el glosario hasta lo planeado, el registro de cambios y las preguntas frecuentes.
↑↓ para moverte↵ para abrirEsc para cerrar