Docs

Agrupación de problemas

Cómo las fallas se vuelven problemas, con el algoritmo exacto de la huella calculado a mano, la traducción de pilas con source maps, la regla que hace de una solicitud un solo problema entre navegador y servidor, los estados de un problema y qué dispara una alerta.

Aplica a Motor Al lanzar

Ver como Markdown
En esta página
  1. De una falla a un problema
  2. La huella
  3. El algoritmo
  4. Calculada a mano
  5. Una solicitud, un problema
  6. Traducción con source maps
  7. Los estados de un problema
  8. Qué escribe una transición
  9. Qué dispara una alerta
  10. Un problema, como lo devuelve la API
  11. Qué cambió frente al sistema del que sale
  12. Sigue

Un problema es un grupo de fallas con una sola causa. Esta página explica cómo decide el motor que dos fallas son la misma, cómo convierte una pila minificada en tus propios archivos y líneas, y cómo pasa un problema de un estado a otro. Es el diseño detrás de Problemas.

La agrupación la hace la vía rápida: el lector que revisa cada segmento nuevo en busca de fallas cada 30 segundos. Flujo de datos muestra dónde está.

De una falla a un problema

Diagrama por dibujarEl mismo diagrama de flujo de cinco etapas que la figura 1 de la página en inglés (architecture/problem-grouping), con las mismas llamadas (1) a (5) y el mismo elemento encendido (el nodo del problema nuevo). Rótulos traducidos: «Segmento» («una línea: server_error, fp 88a44b15205cb153»); «Vía rápida» con los pasos «¿es una falla?», «¿es parte de una solicitud ya conocida?», «huella»; flecha «cada 30 s»; rombo «¿huella conocida en este proyecto y entorno?» con salidas «no» → «Problema nuevo» y «sí» → «El mismo problema: sumar 1 ocurrencia»; «Postgres» con las fichas «problems», «problem_occurrences», «problem_hits», «alerts»; flechas a «El agente» («traducir la pila, luego la frase») y a «Alertas» («retenida hasta la frase o 100 s»); entrada lateral «Bucket: sourcemaps/4f2a91c/» con flecha punteada a «El agente»: «archivos y líneas originales».
Figura. El camino de una falla. La huella decide entre un problema nuevo y una ocurrencia más; los source maps se aplican después y nunca cambian la agrupación.

(1) Qué cuenta como falla. La vía rápida mira cuatro tipos de línea e ignora todas las demás.

LíneaEs una falla cuandoTipoLa huella viene de
error (navegador)SiempreerrorEl SDK: fp
server_errorSiempreerror, o failed_call cuando src es spanEl SDK: fp. El motor la calcula para OTLP
server_requestpartial es true y no existe el registro completo de la misma trazatimeoutEl SDK: fp
request (navegador)Sin respuesta, 400, o 500 o másfailed_callEl motor: ningún campo del SDK la trae

Un 401, 403, 404, 409 o 422 no es una falla. Tampoco un clic de rabia ni una página lenta. Eso lo cuenta la consolidación y nunca llega a este código.

(2), (3) y (4) son las tres secciones que siguen. (5) es la traducción con source maps.

La huella

Una huella son 16 caracteres hex. Las fallas con la misma huella, en el mismo proyecto y entorno, son el mismo problema.

Se calcula donde ocurre la falla, en el SDK, para que el SDK también pueda descartar una repetición del mismo error dentro de 5 segundos. El motor lleva el mismo algoritmo para los casos en que ningún SDK hizo el trabajo: excepciones de OTLP y llamadas fallidas del navegador. Los dos deben dar los mismos bytes para la misma entrada, así que el algoritmo queda escrito aquí con exactitud, y los mismos vectores de prueba corren en TypeScript y en Rust.

El algoritmo

Para un error, tres partes unidas con |:

Text
nombre | mensaje normalizado | función@archivo del primer marco de tu propio código
  1. name: el nombre del error. Error cuando no hay.

  2. El mensaje, normalizado, en este orden:

    PasoReemplazarPor
    1URLs<url>
    2Rutas de fragmentos compilados, como /_next/static/chunks/…<chunk>
    3UUIDs<uuid>
    4Textos entre comillas de hasta 200 caracteres"…"
    5Secuencias de 12 o más caracteres hex<hex>
    6Números#
    7Espacios seguidosun espacio
    8Todo lo que pase de los primeros 300 caracteresnada
  3. El marco superior: se leen las primeras 30 líneas de la pila, en la forma de V8 (at fn (file:line:col)) o la de Gecko (fn@file:line:col). Se toma el primer marco cuyo archivo no sea ruido. Ruido es node_modules, los fragmentos del propio framework, react-dom, scheduler, node:internal y <anonymous>. Si todos los marcos son ruido, se toma el primero. Luego se limpia el archivo: se quitan el origen, la consulta y el fragmento; se quita un hash de compilación de la forma - seguido de 8 o más caracteres hex; se corta todo lo anterior a la carpeta de compilación. La parte es función@archivo, o vacía cuando no hay pila.

Si el framework le dio al error un digest de 6 o más dígitos, la huella es el hash de digest: más el digest, porque ese id ya es estable.

Para una llamada fallida, la llamada, cómo falló y la solicitud en la que ocurrió:

Text
call | nombre del span | estado o código de error | MÉTODO | ruta

Para un tiempo agotado: timeout | MÉTODO | ruta.

El hash, hash64, es FNV-1a de 32 bits, corrido dos veces sobre el mismo texto con dos semillas distintas; los dos resultados se escriben con 8 caracteres hex cada uno y se unen.

Valor
Semilla de la primera mitad0x811c9dc5
Semilla de la segunda mitad0x050c5d1f
Primo0x01000193
Un pasoh = (h XOR unidad) × primo, conservando los 32 bits bajos
Una unidadUna unidad de código UTF-16 del texto

Fíjate en que la función no recibe proyecto ni hora: una huella depende solo de la falla.

crates/sypnia-fingerprint/src/lib.rs
const PRIME: u32 = 0x0100_0193;
const SEED_A: u32 = 0x811c_9dc5;
const SEED_B: u32 = 0x050c_5d1f;

/// FNV-1a de 32 bits sobre unidades de código UTF-16. Debe coincidir con los SDK bit por bit.
fn fnv1a_utf16(text: &str, seed: u32) -> u32 {
    text.encode_utf16()
        .fold(seed, |hash, unit| (hash ^ u32::from(unit)).wrapping_mul(PRIME))
}

/// 16 caracteres hex: dos hashes de 32 bits del mismo texto con semillas distintas.
pub fn hash64(text: &str) -> Fingerprint {
    Fingerprint::from_halves(fnv1a_utf16(text, SEED_A), fnv1a_utf16(text, SEED_B))
}

pub fn error_fingerprint(name: Option<&str>, message: &str, stack: Option<&str>, digest: Option<&str>) -> Fingerprint {
    if let Some(digest) = digest.filter(|d| d.len() >= 6 && d.bytes().all(|b| b.is_ascii_digit())) {
        return hash64(&format!("digest:{digest}"));
    }
    let frame = stack
        .and_then(top_frame) // primer marco de tu propio código, V8 o Gecko
        .map(|f| format!("{}@{}", f.function, normalize_frame_file(&f.file)))
        .unwrap_or_default();
    hash64(&format!(
        "{}|{}|{}",
        name.unwrap_or("Error"),
        normalize_message(message),
        frame,
    ))
}

pub fn call_fingerprint(span_name: &str, code: &str, method: &str, route: &str) -> Fingerprint {
    hash64(&format!("call|{span_name}|{code}|{}|{route}", method.to_ascii_uppercase()))
}

pub fn timeout_fingerprint(method: &str, route: &str) -> Fingerprint {
    hash64(&format!("timeout|{}|{route}", method.to_ascii_uppercase()))
}

Calculada a mano

La página de pago de la tienda lanza esto cuando el cobro es rechazado:

Text
ApiError: POST /api/checkout failed with 400 (amount_required)
    at o (https://shop.example/assets/checkout-3f9c.js:1:48211)
    at async HTMLButtonElement.<anonymous> (https://shop.example/assets/checkout-3f9c.js:1:49002)
Diagrama por dibujarEl mismo diagrama de cinco pasos que la figura 2 de la página en inglés (architecture/problem-grouping), con exactamente los mismos textos dentro de las cajas (no se traducen: son datos), las mismas llamadas (1) a (5) y el mismo elemento encendido (la caja final «1522805793228d19»). Rótulos traducidos de las reglas: fila 1 «nombre»; fila 2 «normalizar el mensaje: los números se vuelven #»; fila 3 «marco superior: primer marco de tu propio código», nota «sin origen, línea ni columna»; fila 4 «unir con |»; fila 5 «hash64: FNV-1a sobre unidades UTF-16, dos semillas», etiquetas «semilla 0x811c9dc5», «semilla 0x050c5d1f» y «la huella».
Figura. La huella del error de pago, paso a paso. Cambia el número de orden o el cliente y aquí no cambia nada; cambia la línea de código que lanza el error y sí.
PasoResultado
(1) NombreApiError
(2) Mensaje, normalizado. La regla 6 convierte 400 en #; nada más coincidePOST /api/checkout failed with # (amount_required)
(3) Marco superior. El primer marco, o, es tu propio código. Su archivo pierde el origen, la línea y la columna. -3f9c tiene cuatro caracteres, menos de los ocho que necesita un hash de compilación, así que se quedao@/assets/checkout-3f9c.js
(4) UnidoApiError|POST /api/checkout failed with # (amount_required)|o@/assets/checkout-3f9c.js
(5) hash64, primera mitad, semilla 0x811c9dc515228057
(5) hash64, segunda mitad, semilla 0x050c5d1f93228d19
Huella1522805793228d19

Los dos primeros pasos de la primera mitad, para comparar una implementación: el texto empieza con A (unidad 0x41) y p (0x70).

Text
h0 = 0x811c9dc5
h1 = (h0 XOR 0x41) × 0x01000193 mod 2^32 = 0x811c9d84 × 0x01000193 = 0xc40bf6cc
h2 = (h1 XOR 0x70) × 0x01000193 mod 2^32 = 0xc40bf6bc × 0x01000193 = 0x5ad569f4
…
h86 = 0x15228057

Y la falla que hay detrás en el servidor, la llamada que el servicio de pagos rechazó:

FallaTexto al que se le hace hashHuella
La llamada fallida del servidorcall|POST /v1/payments|400|POST|/api/checkout88a44b15205cb153
Si esa solicitud se hubiera quedado colgadatimeout|POST|/api/checkoutc405205e99c5aa6c

88a44b15205cb153 es el problema de la historia de ejemplo. Por qué es ese y no el del navegador es la sección que sigue.

Una solicitud, un problema

(2) en la primera figura. Cuando el cliente hace clic en Pagar, se reportan tres fallas de la misma solicitud:

  1. la llamada del servidor al servicio de pagos respondió 400 (server_error, de @sypnia/node);
  2. la llamada de la página a POST /api/checkout respondió 400 (request, de @sypnia/browser);
  3. la página lanzó ApiError (error, de @sypnia/browser).

Tres problemas por un clic serían ruido. La regla: la falla más profunda de una traza es el problema; lo que vio la persona es evidencia dentro de él.

Diagrama por dibujarEl mismo diagrama de traza en cascada que la figura 3 de la página en inglés (architecture/problem-grouping), con las mismas tres barras, llamadas (1) a (3) y el mismo elemento encendido (la barra 3). Rótulos traducidos: barra 1 «navegador · POST /api/checkout · 412 ms · respondió 400», etiqueta «request» y etiqueta «error: ApiError, 4 ms después, mismo lote»; barra 2 «shop-api · POST /api/checkout · 398 ms · 400», etiqueta «server_request»; barra 3 «POST /v1/payments · 340 ms · 400», etiqueta «span: llamada fallida», nota «falla más profunda = el problema»; línea vertical «un id de traza: 7c2e9a4b…». Panel «Lo que guarda el motor»: tarjeta «Problema 88a44b15205cb153 · createPayment answered 400 in POST /api/checkout» con «ocurrencias +1», «persona u_1042, sesión 8f3a6c1e…», «evidencia: la llamada fallida de la página y su ApiError»; tarjetas tachadas «no se abre: problema por la llamada del navegador» y «no se abre: problema por ApiError».
Figura. Un clic, tres fallas, un problema. La llamada fallida al fondo de la traza es el problema; las dos cosas que vio el navegador quedan adjuntas a él.

Cómo lo aplica la vía rápida:

FallaQué hace la vía rápida
Una falla del servidor, con id de traza (1)Es el problema. Entra una fila a trace_failures: «la traza 7c2e9a4b… es del problema prb_8f3k2m9x4q7w», por 48 horas. Si la misma traza tiene dos fallas del servidor, gana la del span más profundo.
Un request fallido del navegador, con id de traza (2)Se busca la traza en trace_failures. Está: es evidencia de ese problema. No suma ocurrencia; suma la persona y la sesión si el registro del servidor no las traía. No está, y el proyecto ha enviado datos del servidor: se retiene 15 segundos en held_failures y se busca otra vez. Sigue sin estar, o el proyecto solo tiene el SDK del navegador: es su propio problema.
Un error del navegador en el mismo lote y sesión que un request fallido, máximo 2 segundos después (3)Sigue a esa solicitud: evidencia si la solicitud es evidencia, y si no, parte del problema de la solicitud.
Un error del navegador sin una solicitud fallida antesSu propio problema. Son la mayoría de los errores del navegador: un TypeError en tu código no tiene una solicitud detrás.

La retención existe porque las dos mitades viajan por separado. El registro del servidor casi siempre llega primero, porque el servidor envía cuando termina la solicitud y el navegador espera hasta 10 segundos para enviar su lote. Los 15 segundos cubren el orden contrario. Son parte del presupuesto de 2 minutos calculado en Flujo de datos, y solo los gastan los proyectos que envían datos del servidor.

Un proyecto que solo tiene el SDK del navegador recibe como problema la llamada fallida de la página, tal como dice Problemas.

Traducción con source maps

Un navegador reporta la pila del código que ejecutó: minificado, en una línea, con nombres como o. Los source maps la devuelven a tus archivos.

(5) en la primera figura. La traducción ocurre después de que el problema existe y antes de que el agente lo lea. Nunca cambia la huella: la agrupación usa el marco minificado, así que un problema no se parte cuando los mapas llegan tarde o faltan.

Regla
CuándoCuando un problema nace o vuelve; otra vez cuando los mapas de su versión se suben después de la falla; y para la primera ocurrencia en cada versión nueva
Qué versiónEl ver de la ocurrencia. Sin ver no hay traducción
Encontrar el mapasourcemaps/<release>/index.json relaciona cada archivo compilado con su mapa. Los empaquetadores nombran los mapas sin relación con los fragmentos, así que adivinar <archivo>.map es solo el último recurso
MarcosLos primeros 30. Formas de V8 y de Gecko. Un marco sin mapa se queda como está
Resultadosample.stack_original, la pila con archivo:línea:columna y nombres de función originales, y where: el archivo, la línea y la función del primer marco de tu propio código
LímitesUna caché de 50 mapas o 200 MB; un mapa de más de 64 MB se salta; 60 segundos para el paso
Si fallaEl problema conserva su pila minificada. El paso nunca bloquea un problema ni una alerta

Para el error de pago, el resultado es:

Text
ApiError: POST /api/checkout failed with 400 (amount_required)
    at confirmPayment (src/checkout/checkout.tsx:142:11)
    at async onPayClick (src/checkout/PayButton.tsx:31:5)

De este paso se expone un número: problemas traducidos ÷ problemas que tenían versión y pila, en las últimas 24 horas, que muestra sypnia doctor. La razón es un incidente del sistema del que sale esto: durante seis días no se tradujo ningún error, porque una opción de compilación rompió el lector de mapas, y nadie lo notó. Una línea de log no es un número de salud.

Los estados de un problema

Un problema tiene un estado, open, resolved o ignored, y un problema abierto puede llevar marcas: nuevo, creciendo, volvió. Juntos son los estados de abajo.

Diagrama por dibujarLa misma máquina de estados que la figura 4 de la página en inglés (architecture/problem-grouping), con los mismos nodos, flechas, llamadas (1) a (4), la misma distinción entre flechas sólidas y punteadas y el mismo elemento encendido («Abierto · nuevo»). Rótulos traducidos de los estados: «Abierto · nuevo», «Abierto · creciendo», «Abierto», «Resuelto», «Ignorado», «Abierto · volvió». Flechas: inicio «primera falla con esta huella → alerta problem.new»; «24 h después de la primera falla»; «personas ≥ 2 × personas en la última alerta, y ≥ 5 → alerta problem.growing»; «24 h después»; «una persona o un token lo resuelve»; «ocurre de nuevo (en la versión del arreglo o una posterior, si se nombró) → alerta problem.regressed»; «se resuelve otra vez»; «una persona lo ignora (admin)»; ciclo en Ignorado «ocurre de nuevo: se cuenta, sin alerta, sigue ignorado»; punteadas «se reabre a mano». Nota en cada estado abierto: «las ocurrencias nuevas se cuentan». Leyenda: flecha sólida «lo hace el motor», flecha punteada «lo hace una persona».
Figura. Los estados de un problema. El motor solo hace tres movimientos por su cuenta: un problema nace, crece o vuelve. Todo lo demás lo hace una persona.

El motor decide una transición con una sola función pura. Recibe el problema como estaba antes de este segmento y como queda después, y responde qué pasó. Fíjate en que no puede escribir nada: quien la llama escribe la transición, la alerta y la fila del registro en una transacción, así que una transición nunca se puede anotar dos veces.

crates/sypnia-pipeline/src/problems/transition.rs
#[derive(Debug, PartialEq)]
pub enum Transition {
    Born,
    CameBack,
    Growing { from: u32, to: u32 },
    Quiet, // se cuenta, no hay nada que avisar
}

pub fn transition(
    before: Option<&ProblemState>,
    after: &ProblemState,
    seen: &Seen,          // lo que agregó este segmento: versiones, personas
    rules: &GrowingRule,  // factor 2, min_people 5, salvo que el proyecto los cambie
) -> Transition {
    let Some(before) = before else {
        return Transition::Born;
    };
    match before.status {
        Status::Ignored => Transition::Quiet,
        Status::Resolved => {
            // «Pestañas viejas»: si se nombró la versión del arreglo, solo reabre una falla en esa versión o en una posterior.
            let reopens = match &before.resolved_in_release {
                Some(fix) => seen.releases.iter().any(|r| r.is_same_or_later_than(fix)),
                None => true,
            };
            if reopens { Transition::CameBack } else { Transition::Quiet }
        }
        Status::Open => {
            let threshold = before
                .people_at_last_alert
                .saturating_mul(rules.factor)
                .max(rules.min_people);
            if after.people >= threshold && after.people > before.people_at_last_alert {
                Transition::Growing { from: before.people_at_last_alert, to: after.people }
            } else {
                Transition::Quiet
            }
        }
    }
}

Sigue el ejemplo de Problemas por ella. El problema nace con 1 persona, y people_at_last_alert queda en 1. Con 3 personas el umbral es max(1 × 2, 5) = 5: sin novedad. Con 5 personas: creciendo, y people_at_last_alert queda en 5. El siguiente umbral es 10, luego 20.

«Posterior», para una versión, significa que el motor la vio por primera vez al mismo tiempo que la versión del arreglo o después. El motor no compara los textos de las versiones: un commit corto de git no tiene orden.

Qué escribe una transición

Todo en la misma transacción que además marca el segmento como revisado:

TransiciónproblemsAlertaEl agente
NaceUna fila nueva, status = open, people_at_last_alert = peopleproblem.newTraducir la pila y luego analizar
Volvióstatus = open, regressed = true; resolved_at y resolved_by quedan como historiaproblem.regressedTraducir la pila y analizar de nuevo
Creciendogrowing_until = ahora + 24 h, people_at_last_alert = peopleproblem.growingAnalizar de nuevo, dentro del límite diario por problema
Sin novedadSolo contadores y last_seenNingunaNada

Qué dispara una alerta

Para los problemas, exactamente las tres transiciones de arriba, y solo cuando la regla del proyecto para ese tipo está encendida en el entorno del problema. Por defecto las tres están encendidas solo para production.

Cada fila de alerta tiene un dedupe_key con índice único, y eso hace que «un problema es una alerta» sea una propiedad de la base de datos y no un deseo:

Alertadedupe_keyPara que
problem.newproblem.new:<problem id>Un problema sea nuevo una vez en su vida
problem.regressedproblem.regressed:<problem id>:<resolved_at>Una vez por cada vez que se resolvió
problem.growingproblem.growing:<problem id>:<people at last alert>Una vez por cada escalón: 5, 10, 20

La alerta se inserta con released_at vacío y release_by puesto a 100 segundos después de que la falla llegó a la ingesta. Se libera cuando el agente escribe la frase, o al llegar release_by, lo que ocurra primero. Liberar significa: llenar released_at, escribir el título (la frase, o el título técnico) y entregarla a cada salida de alertas. El proceso del agente muestra esa entrega, y Formas de despliegue muestra las salidas.

Los demás tipos de alerta (disponibilidad, una página que se volvió lenta, una ruta de la API que falla, uso, el propio motor) los producen la pasada y la consolidación a partir de números, no este código. Sus reglas están en Alertas y el resumen diario.

Un problema, como lo devuelve la API

Después de tres personas y cinco fallas, GET /v1/problems/pay-button-does-nothing responde con la fila de problems, su análisis y sus enlaces:

GET /v1/problems/pay-button-does-nothing
{
  "id": "prb_8f3k2m9x4q7w",
  "slug": "pay-button-does-nothing",
  "fingerprint": "88a44b15205cb153",
  "kind": "failed_call",
  "origin": "server",
  "status": "open",
  "regressed": false,
  "title": "createPayment answered 400 in POST /api/checkout",
  "environment": "production",
  "route": "/checkout",
  "where": { "file": "src/checkout/checkout.tsx", "line": 142, "function": "confirmPayment" },
  "first_seen": "2026-03-12T09:12:04Z",
  "last_seen": "2026-03-12T10:31:47Z",
  "first_release": "4f2a91c",
  "last_release": "4f2a91c",
  "occurrences": 5,
  "people": 3,
  "sessions": 3,
  "resolved_at": null,
  "resolved_by": null,
  "resolved_in_release": null,
  "note": null,
  "analysis": {
    "status": "ready",
    "sentence": "3 people tried to pay today and could not. The Pay button does nothing since yesterday's change.",
    "confidence": "high",
    "runs": 3
  },
  "pull_request": null,
  "url": "https://sypnia.example.com/console/problems/pay-button-does-nothing",
  "created_at": "2026-03-12T09:13:02Z"
}

El análisis va recortado aquí; su forma completa está en la referencia de la API. occurrences es 5 y no 15: cada clic produjo tres fallas y una ocurrencia.

Qué cambió frente al sistema del que sale

AlláAquíPor qué
Grupos de errores por huella y entornoProblemas por proyecto, entorno y huellaVarios proyectos
Se agrupaba una vez por horaCada 30 segundos, en la vía rápidaLa promesa de 2 minutos
Las fallas del navegador y del servidor de una solicitud eran grupos separadosUn problema, por trazaBrief: una causa, una frase
Personas y sesiones por día, con arreglos limitados a 200Lo mismo por hora para la línea de tiempo, más problem_hits para un conteo exacto de toda la vida«3 personas» es la frase del producto; debe ser exacta
Un 4xx nunca era una falla del servidor; el navegador guardaba su códigoUna llamada fallida es sin respuesta, 400, o 500 o más, también en el navegadorPara que una app con solo el SDK del navegador tenga problemas
Traducción de pilas dentro de la tarea de cada hora, 200 grupos por horaDespués de cada problema nuevo o que vuelveUn problema nuevo necesita su archivo real dentro de los 2 minutos, para el agente
Reglas de fragmentos y digest de un solo framework dentro de la huellaLas mismas reglas, como una lista por plataformaCualquier framework, no uno
hash64 sobre unidades UTF-16, en JavaScriptLo mismo, bit por bit, en RustLos grupos existentes conservan sus huellas

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