> For the complete documentation index, see [llms.txt](https://docs.dapta.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.dapta.ai/dapta-docs-es/dcal/developers/self-hosting.md).

# Alojarlo tú mismo

Ejecuta tu propia copia de dCal: los requisitos, SQLite para desarrollo y PostgreSQL para producción, los comandos de inicio rápido, las opciones de inicio de sesión, correo y calendario, las páginas

dCal corre en cualquier lugar donde corran Node o Docker: una sola máquina virtual, Docker Compose, Kubernetes o la plataforma que elijas. Esta página es un mapa. Las instrucciones de referencia están en el repositorio, en inglés, y cambian con el código:

| Archivo del repositorio                                                                                            | Qué cubre                                                                                                                                                                                                    |
| ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [`README.md`](https://github.com/Dapta-Tech/dapta-calendars-slate/blob/main/README.md)                             | El inicio rápido local, sin base de datos ni cuentas que configurar.                                                                                                                                         |
| [`SELF-HOSTING.md`](https://github.com/Dapta-Tech/dapta-calendars-slate/blob/main/SELF-HOSTING.md)                 | La guía de producción: imágenes, base de datos, la referencia completa de entorno, proxy inverso y TLS, inicio de sesión, correo, backend de calendario, actualizaciones, reversión y solución de problemas. |
| [`.env.example`](https://github.com/Dapta-Tech/dapta-calendars-slate/blob/main/.env.example)                       | Cada ajuste con notas en línea y su valor por defecto.                                                                                                                                                       |
| [`docker-compose.prod.yml`](https://github.com/Dapta-Tech/dapta-calendars-slate/blob/main/docker-compose.prod.yml) | Una pila de referencia con forma de producción que levantas con un comando.                                                                                                                                  |

***

## Requisitos

* **Node 20.9 o superior y pnpm 10 o superior**, solo si compilas desde el código fuente. O **Docker con Docker Compose** para construir y ejecutar las dos imágenes.
* **PostgreSQL 14 o superior** para producción, con la extensión `btree_gist`. La primera migración crea la extensión; si el rol de tu base de datos no puede, pide a un superusuario que ejecute `CREATE EXTENSION IF NOT EXISTS btree_gist;` una vez.
* **Un proxy inverso que termine TLS**, como nginx, Caddy, Traefik o un balanceador de carga en la nube, delante de dos dominios: uno para la app web (puerto `3000`) y otro para la API (puerto `4000`).

***

## SQLite o PostgreSQL

`DATABASE_URL` elige la base de datos:

|                                   | SQLite                                                       | PostgreSQL                                                                                                                                                   |
| --------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `DATABASE_URL`                    | `file:./.data/dev.db`, el valor por defecto si no la defines | `postgres://<usuario>:<contraseña>@<servidor>:5432/<base>`                                                                                                   |
| Para qué sirve                    | Probar dCal y desarrollar en local, sin configurar nada      | Cualquier instalación real                                                                                                                                   |
| Protección contra dobles reservas | Solo una comprobación dentro de la app                       | La misma comprobación, más una restricción de la base de datos que hace imposible que dos reservas (aceptadas o pendientes) de un mismo anfitrión se solapen |

> **⚠️ Nota:** Nunca uses SQLite en producción. No tiene la restricción de la base de datos que es la garantía firme de dCal contra las dobles reservas.

Las migraciones son archivos SQL numerados. Ejecútalas antes de que arranque la API, nunca dentro del proceso de la API que queda corriendo, para que varias copias de la API nunca migren a la vez:

```bash
DATABASE_URL=postgres://<usuario>:<contraseña>@<servidor>:5432/<base> pnpm db:migrate
```

Los cambios de esquema solo añaden cosas (tablas nuevas, columnas nuevas que admiten vacío), así que puedes migrar una base de datos en uso durante un despliegue gradual.

***

## Inicio rápido

### Ejecútalo en tu computadora

```bash
git clone https://github.com/Dapta-Tech/dapta-calendars-slate.git calendars && cd calendars
pnpm install
pnpm dev
```

`pnpm dev` compila los paquetes, crea y llena una base SQLite en `.data/dev.db` y arranca las dos apps:

* **Web**: <http://localhost:3000>, con una página de reservas de demostración en `/acme/alex-rivera/intro-call`.
* **API**: <http://localhost:4000/health>.

El correo está en `log-only`, así que las confirmaciones se imprimen en el registro de la API. `pnpm db:reset` restaura los datos de demostración. Para usar PostgreSQL en Docker, el mismo motor que producción, ejecuta `pnpm dev:pg`; si el puerto `5432` ya está ocupado en tu computadora, define `PG_PORT`, por ejemplo `PG_PORT=5433 pnpm dev:pg`.

### Levanta las imágenes de producción

`docker-compose.prod.yml` construye las mismas dos imágenes que usa una instalación de producción, ejecuta las migraciones una vez en un servicio `migrate` de un solo uso y luego arranca la API y la app web contra un PostgreSQL local:

```bash
POSTGRES_USER=calendars POSTGRES_DB=calendars \
POSTGRES_PASSWORD=<una-contraseña-segura> \
DATABASE_URL=postgres://calendars:<una-contraseña-segura>@db:5432/calendars \
docker compose -f docker-compose.prod.yml up --build
```

Luego abre `http://localhost:3000` (web) y `http://localhost:4000/health` (API). Esta pila es una prueba de humo: corre con `NODE_ENV=development` y el inicio de sesión abierto de desarrollo. Para una instalación real, define `NODE_ENV=production` junto con un proveedor de inicio de sesión real (mira más abajo).

### Construye las dos imágenes

Los dos Dockerfiles usan la raíz del repositorio como contexto de construcción:

```bash
docker build -f apps/api/Dockerfile -t calendars-api:local .
docker build -f apps/web/Dockerfile \
  --build-arg NEXT_PUBLIC_API_URL=https://calendars-api.example.com \
  -t calendars-web:local .
```

> **⚠️ Nota:** Cada valor `NEXT_PUBLIC_*` queda fijado en la imagen web al construirla, no se lee al arrancar el contenedor. Si mueves la API o cambias alguno de esos valores, vuelve a construir la imagen web.

***

## Inicio de sesión

Las páginas públicas de reservas siempre están abiertas. El inicio de sesión solo protege el panel, y `AUTH_PROVIDER` decide cómo funciona. Pon el mismo valor en la API y en la app web.

| `AUTH_PROVIDER`       | Qué hace                                                                                                                                                                                                                                       | Cuándo usarlo                                 |
| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- |
| `local` (por defecto) | Un inicio de sesión abierto de desarrollo: quien escribe un correo entra como esa persona. La API se niega a arrancar con él si `NODE_ENV=production`.                                                                                         | Solo para probar dCal y desarrollar en local. |
| `workos`              | A pesar del nombre, una verificación genérica de tokens: la API acepta cualquier JWT HS256 firmado con tu `JWT_SECRET` que traiga las claims `sub`, `account_id`, `email` y `name`. `JWT_ISSUER` y `JWT_AUDIENCE` se verifican si los defines. | Cualquier instalación real.                   |

Lo que debes saber antes de elegir `workos`:

* `account_id` identifica el workspace. La primera persona que entra a un workspace es su propietaria; quienes llegan después son miembros, salvo que una invitación les haya dado otro rol.
* La app web necesita `WEB_SESSION_SECRET` para firmar su cookie de sesión. Sin él, se niega a crear una sesión.
* En producción (`NODE_ENV=production`) las cookies de inicio de sesión son cookies `__Host-` marcadas como `Secure`, así que la gente debe entrar a la app web por `https` (o en `localhost`). Un proxy que termina TLS delante de ella sirve.
* El inicio de sesión de la app web envía a las personas a un servicio de identidad en `IAM_BASE_URL`, que le devuelve una dirección de inicio de sesión y regresa a la persona ya identificada a `/api/auth/callback` con su token. Lee las rutas de `apps/web/app/api/auth/` en el repositorio antes de conectar tu propio servicio de identidad: son el contrato que tiene que cumplir.

`SELF-HOSTING.md` también explica cómo generar un token de prueba para trabajar en local.

***

## Correo

No se envía ningún correo hasta que eliges un proveedor con `EMAIL_PROVIDER`. Mientras tanto, los correos de las reservas se escriben en el registro de la API, así que una instalación nueva funciona de punta a punta igual.

| `EMAIL_PROVIDER`         | Qué pasa                                                                                                                                                                                       |
| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `log-only` (por defecto) | Los correos se imprimen en el registro de la API.                                                                                                                                              |
| `noop`                   | Los correos se descartan en silencio. Útil en pruebas.                                                                                                                                         |
| `smtp`                   | Se envían por cualquier servidor SMTP: define `SMTP_HOST`, y `SMTP_PORT`, `SMTP_SECURE`, `SMTP_USER` y `SMTP_PASS` según lo que pida tu servidor.                                              |
| `http`                   | Cada correo se envía a un servicio de correo HTTP en `EMAIL_HTTP_ENDPOINT`, con un cuerpo JSON genérico y un token Bearer opcional (`generic`) o con peticiones firmadas (`transactional-v1`). |

Define `MAIL_FROM_EMAIL` y `MAIL_FROM_NAME` antes de enviar nada real, y `MAIL_SUPPORT_EMAIL` para mostrar una dirección de soporte en el pie de los correos (con el perfil `transactional-v1`, el pie de soporte propio del servicio de correo reemplaza esa línea). Un proveedor al que le faltan sus ajustes vuelve a `log-only` en lugar de detener la API.

***

## Opciones de calendario para tu copia

El código público habla con los calendarios a través de un contrato que no depende de ningún proveedor. `CALENDAR_PROVIDER` decide si habla con calendarios o no:

| Opción                                                                          | Qué obtienes                                                                                                                                                                                                                                                                     |
| ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CALENDAR_PROVIDER=disabled` (por defecto)                                      | Ningún calendario externo. Los horarios libres solo descuentan las reservas de dCal, no se escribe nada en un calendario y no se crean enlaces de reunión en línea. Suficiente si no necesitas sincronizar calendarios.                                                          |
| `CALENDAR_PROVIDER=external` con `CALENDAR_API_BASE_URL` y `CALENDAR_API_TOKEN` | dCal llama a tu propio servicio de calendario con un contrato REST pequeño y documentado: lectura de horas ocupadas, crear, mover y borrar eventos, listar calendarios, comprobar una conexión e iniciar la conexión. `SELF-HOSTING.md` lista cada ruta y lo que debe responder. |
| `CALENDAR_PROVIDER=external` con `CALENDAR_BACKEND_MODULE`                      | La ruta absoluta a tu propio módulo de JavaScript, que aporta la URL base, los tokens y la forma de las peticiones. Para un backend que genera sus propios tokens de corta duración o que necesita otra forma de petición.                                                       |

Tres reglas importan cuando escribes un backend:

* **Las respuestas de horas ocupadas tienen que estar completas.** dCal lee las horas ocupadas en ventanas de hasta 14 días (`CALENDAR_BUSY_WINDOW_DAYS`). Si una ventana falla, dCal no muestra horarios en lugar de mostrar horarios que podrían estar ocupados. Si una ventana vuelve con solo parte de las horas ocupadas, las que faltan parecen libres, así que recorre todas las páginas de tu fuente antes de responder.
* **Un enlace de reunión por reserva.** dCal pide el enlace de reunión solo en el evento del organizador. Si no puedes crearlo, devuelve el evento sin él: la reserva sigue en pie y la confirmación sale sin enlace para unirse. dCal lo pide en las reuniones en línea y en las reservas sin ubicación, nunca en las demás.
* **Las invitaciones siguen `sendInvitations`.** Las llamadas para crear, mover y borrar eventos pueden llevar `sendInvitations`, en el cuerpo (al borrar, como `?sendInvitations=`). `false` significa que dCal le envía al invitado su propia invitación para ese cambio: escribe el evento sin la invitación, la actualización ni la cancelación propias de tu calendario, o el invitado recibe dos. `true` las pide, y sin el campo decide tu backend. dCal envía `true` cuando su correo no puede reemplazar al tuyo, por ejemplo con `EMAIL_PROVIDER` en `log-only` o `noop`. Si el correo de un invitado nunca sale, dCal pide la invitación después en el evento del organizador: una actualización sin el invitado (`false`) y otra con la lista completa (`true`), así que reemplaza la lista de invitados por la que recibes. Una respuesta `404` o `410` al borrar cuenta como hecha.

El servicio alojado app.dcal.ai conecta Google Calendar y Outlook con su propio backend privado, que no forma parte del repositorio público.

***

## HubSpot y webhooks

* Define `CRM_PROVIDER=hubspot` para ofrecer la integración con [HubSpot](https://docs.dapta.ai/dapta-docs-es/dcal/integrations/hubspot.md) en **Ajustes** > **Integraciones**.
* Define `INTEGRATION_ENCRYPTION_KEY` con 32 bytes aleatorios en base64 (`openssl rand -base64 32`). dCal la necesita para guardar un token de HubSpot y para crear un webhook, porque se niega a guardar cualquiera de esos secretos sin cifrar. Con HubSpot activado y sin clave, la pestaña **Integraciones** dice *Todavía no se pueden guardar credenciales aquí*, y añadir un webhook se rechaza.

> **⚠️ Nota:** Respalda esta clave como respaldas la base de datos. Si la pierdes o la cambias, cada workspace tiene que volver a pegar su token de HubSpot, cada webhook necesita un secreto de firma nuevo, y las entregas de webhooks fallan hasta que se corrija.

***

## Páginas de reservas en un host propio

En app.dcal.ai, las páginas de reservas están en `https://book.dcal.ai`, separadas del panel, para que las etiquetas que un anfitrión agrega a un evento nunca compartan dirección con una sesión iniciada. Tu copia puede hacer lo mismo: el panel en un host, como `app.<tu-dominio>`, y las páginas de reservas (personales, de equipo, enlaces de un solo uso y la página donde el invitado gestiona su reserva) en otro, como `book.<tu-dominio>`.

| Variable                 | Dónde se define               | Qué hace                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------------------ | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `PUBLIC_BOOKING_URL`     | Web y API, con el mismo valor | El host de reservas, como origen. Sirve todas las páginas de reservas, envía las páginas del panel a `PUBLIC_APP_URL` y responde `404` a las rutas `/api` propias de la app, salvo `/api/availability`. Todos los enlaces que escribe dCal lo usan: los enlaces de gestión de los correos, los enlaces de reserva del MCP, y los fragmentos para copiar, abrir e insertar del panel. Sin definir, o vacía, las páginas de reservas se quedan en `PUBLIC_APP_URL`. |
| `BOOKING_HOST_REDIRECTS` | Web                           | `off` (por defecto), `temporary` (307) o `permanent` (308). Con `temporary` o `permanent`, cualquier otro host responde al `GET` de una página de reservas con una redirección a la misma ruta y los mismos parámetros en el host de reservas.                                                                                                                                                                                                                    |

Haz el cambio por pasos; cada uno se deshace quitando su ajuste:

1. Apunta el nuevo host a la app web. Define `PUBLIC_BOOKING_URL` **primero en la app web** y, cuando todas las instancias web lo tengan, **en la API**. `PUBLIC_APP_URL` también debe estar definida en la app web. Los dos hosts sirven entonces páginas de reservas, y los enlaces nuevos usan el nuevo.
2. Cuando todos los tipos de página y tu tráfico real respondan en el nuevo host, define `BOOKING_HOST_REDIRECTS=temporary`; tras un mes estable, `permanent`.

Para revertir, ve al revés: quita `PUBLIC_BOOKING_URL` primero de la API y después de la app web. Cuando el ajuste nombra otro host, la app web deja de leer el nombre anterior de su cookie de sesión, así que una sesión que no pasó al nombre `__Host-` inicia sesión una vez más. Si ya corrieron etiquetas en el host de reservas, `SELF-HOSTING.md` recomienda quitar el ajuste solo de la API y dejarlo en la app web, salvo que el propio host de reservas tenga que desaparecer.

Lo que sigue funcionando durante el cambio:

* Un `POST` se atiende donde llega, como una pestaña que quedó abierta.
* `/api/availability` y `embed.js` responden en los dos hosts.
* El marco de una página insertada nunca se redirige, así que un sitio que solo permite el host anterior como origen de marcos sigue reservando. Los fragmentos de inserción nuevos usan el host de reservas.
* Una página que revisa `event.origin` en los mensajes de la inserción debe aceptar el origen del host de reservas para los fragmentos nuevos.

***

## Seguimiento y píxeles

Los propietarios y administradores pueden agregar etiquetas de seguimiento a cada tipo de evento. Un **píxel de Meta** y un proyecto de **PostHog** (nube de EE. UU. o de la UE) no necesitan nada de tu parte: solo cargan el código del propio proveedor. Una dirección de PostHog alojada por ti se rechaza.

**Google Tag Manager**, **Google Analytics 4** y **HubSpot** son distintos: la cuenta del propio anfitrión puede hacer que ejecuten cualquier código. Con las páginas de reservas en un host propio (`PUBLIC_BOOKING_URL` definida en la app web y en la API), todos los workspaces pueden usarlos, y solo arrancan en ese host. Sin él, correrían en la misma dirección que el panel y su sesión, así que solo cargan para los workspaces que nombres:

| Variable                  | Por defecto                      | Qué hace                                                                                                                                                                                                                                                                             |
| ------------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `EVENT_TRACKING_ACCOUNTS` | sin definir, que significa nadie | API. Los workspaces que pueden cargar Google Tag Manager, Google Analytics 4 y HubSpot en sus páginas de reservas: códigos cortos de cuenta o enlaces personalizados, separados por comas, o `*` para todos los workspaces. No hace falta cuando `PUBLIC_BOOKING_URL` está definida. |

Nombra solo workspaces de confianza, y usa `*` solo cuando todos los workspaces de la instalación sean tuyos. Quitar un workspace de la lista quita al instante su Google Tag Manager, Google Analytics 4 y HubSpot de sus páginas; sus otras etiquetas se quedan. Donde ninguno de los tres está permitido, el editor del evento dice que esta instalación todavía no los ofrece en las páginas de reservas.

***

## Eventos repetidos y consulta de asistentes

Para admitir [eventos repetidos](https://docs.dapta.ai/dapta-docs-es/dcal/developers/mcp-tools.md#eventos-que-se-repiten) en tu instalación, el adaptador de calendario debe escribir una sola serie, mover o cancelar fechas individuales y actualizar la regla de la serie. Una conexión que no puede hacerlo responde `RECURRENCE_UNSUPPORTED`; dCal nunca escribe solo la primera fecha sin avisar.

Para el backend REST genérico, define `CALENDAR_BACKEND_FEATURES=recurrence,attendee-free-busy` solo cuando implementes ambos contratos. `recurrence` habilita series y cambios de fechas individuales. `attendee-free-busy` permite consultar los calendarios que el anfitrión tiene permiso de ver. Puedes declarar cada capacidad por separado. Un calendario que el proveedor no deja ver debe quedar desconocido, nunca como una lista vacía de ocupaciones que significaría libre. Los contratos están en [`SELF-HOSTING.md`](https://github.com/Dapta-Tech/dapta-calendars-slate/blob/main/SELF-HOSTING.md#repeating-events-and-other-peoples-busy-times).

Las series, los enlaces de video y la consulta de asistentes dependen de las capacidades del calendario conectado del anfitrión. dCal las revisa antes de crear una serie o pedir un enlace de video. Si una conexión no admite consultar asistentes, sus calendarios quedan desconocidos. Tu adaptador determina qué capacidades ofrece tu instalación.

Al crear una serie, dCal bloquea fechas hasta 180 días después del momento actual o de su primer inicio, el que sea posterior. Con `OUTBOX_WORKER_ENABLED=true`, la API revisa cada hora si hace falta agregar fechas a ese horizonte; la primera revisión es cerca de un minuto después de arrancar. No lo hace en pruebas ni con el worker apagado. Mantén ese proceso activo. No hay variables de entorno separadas para ampliar series.

Sin calendario conectado, un bloque repetido debe terminar dentro de ese horizonte inicial de 180 días. Las fechas posteriores las protege el calendario conectado, no las fechas que dCal todavía no ha creado. Pedir video también requiere un calendario capaz de crear el enlace; si no lo admite, responde `VIDEO_UNSUPPORTED`.

***

## Detrás de un proxy

* `RATE_LIMIT_TRUSTED_PROXY_HOPS` es cuántos proxies hay delante de la API (por defecto `1`). Configúralo bien o el límite de uso contará a todos los visitantes como un solo cliente.
* Define `INTERNAL_API_SECRET` con el mismo valor (de al menos 32 caracteres) en la API y en la app web, y define `API_URL` en la app web con la dirección privada de la API. Así las páginas de reservas le pasan a la API la dirección de cada visitante, y cada visitante tiene su propio límite en lugar de compartir el del servidor web.
* Si guardar una página de reservas falla con un mensaje de tamaño demasiado grande, sube el límite de tamaño de petición de tu proxy. La foto y la portada del anfitrión se guardan con la página; el límite por defecto de nginx, 1 MB, se queda corto, así que súbelo a al menos 4 MB tanto para la web como para la API.

***

## Asistentes de IA, analítica y buscadores

* **El servidor MCP viene encendido** en `/mcp` de tu propia API (en app.dcal.ai está en `https://mcp.dcal.ai/mcp`): las herramientas de las páginas de reservas públicas responden a cualquiera; las demás responden a claves de API y, cuando enciendes el inicio de sesión, también a inicios de sesión. Define `MCP_PUBLIC_URL` en la API y en la app web con la dirección exacta que la gente debe pegar, y `API_PUBLIC_URL` en la app web, para que **Conecta tu agente** las muestre, el menú de la izquierda tenga un elemento **Docs de la API** que abre el `/docs` de tu API, y se pueda descargar el skill para agentes desde **Claves API**. Para apagarlo, define `MCP_ENABLED=false`.
* **El inicio de sesión para apps de IA (OAuth) viene apagado.** Permite que la gente conecte Claude, ChatGPT y otras apps iniciando sesión en lugar de pegar una clave, de una de dos formas:
  * **Con un servidor de autorización que ya tienes**, como funciona app.dcal.ai: define `OAUTH_ENABLED=true`, `MCP_PUBLIC_URL` y `OAUTH_AUTHORIZATION_SERVER`. Ese servidor debe admitir indicadores de recurso (RFC 8707), con `MCP_PUBLIC_URL` registrado como recurso para que sus tokens lo lleven como audiencia; firmar sus tokens con RS256 o ES256 y publicar sus claves; y dejar que las apps MCP se registren, con Client ID Metadata Documents o Dynamic Client Registration. Tu inicio de sesión web también debe guardar el ID de usuario de cada persona en ese servidor: `SELF-HOSTING.md` explica cómo. Solo pueden conectarse los propietarios y administradores que iniciaron sesión en la app web dentro de `OAUTH_LINK_MAX_AGE_DAYS`. Envía a la API `/.well-known/oauth-protected-resource` (y las rutas bajo ella) y `/.well-known/oauth-authorization-server` del host de `MCP_PUBLIC_URL`.
  * **Con el servidor de autorización incluido**: define `OAUTH_ENABLED=true` con `MCP_PUBLIC_URL`, `OAUTH_ISSUER` y `OAUTH_SIGNING_JWK`. Envía a la API `/oauth/` y `/.well-known/oauth-authorization-server` del host del emisor, y `/.well-known/oauth-protected-resource` del host de `MCP_PUBLIC_URL`. La gente aprueba cada app en una página de consentimiento, y solo los propietarios y administradores pueden hacerlo; **Claves API** lista las apps conectadas. Una conexión nueva al principio solo puede leer: la primera vez que alguien le pide a su agente agendar, mover o cancelar, su app le pide aprobarlo también, y **Conecta tu agente** lo avisa.
* **Conecta tu agente sigue tu configuración.** Con el servidor MCP encendido, el inicio de sesión para apps de IA encendido (de cualquiera de las dos formas) y `MCP_PUBLIC_URL` definida, muestra una pestaña por app, como en app.dcal.ai. Si no, dice **El conector no está disponible en esta instalación** y nombra los ajustes que hay que encender. Las claves de API funcionan en los dos casos, desde **API y webhooks** > **Claves API**.
* **El elemento Documentación del menú de la izquierda** aparece solo cuando defines `DOCS_URL` en la app web, y `DOCS_URL_ES` para quienes usan el panel en español. Apúntalo a tus propias páginas de ayuda, o déjalo sin definir.
* **La referencia de la API en `/docs`** enlaza a tus propias guías para desarrolladores solo cuando defines `DEVELOPER_DOCS_URL` en la API. Sin definir, su introducción no tiene enlace a las guías.
* **La analítica del producto está apagada** salvo que definas `PRODUCT_ANALYTICS_PROVIDER` y `PRODUCT_ANALYTICS_KEY`.
* **Los buscadores** pueden leer tus páginas de reservas y nunca tu panel. En una copia de pruebas o de vista previa, define `NOINDEX=1` en la app web para dejar todo el sitio fuera.
* **Varias copias de la API** pueden compartir una base de datos: la cola en segundo plano le da cada entrega a una sola copia a la vez, y se la pasa a otra si esa copia se detiene. Cada copia cuenta los límites de uso por separado.

Mira [Variables de entorno](https://docs.dapta.ai/dapta-docs-es/dcal/developers/environment-variables.md) para cada ajuste y su valor por defecto.

***

## Qué cambia frente a app.dcal.ai

| En app.dcal.ai                                                                                                                                                | En tu propia copia                                                                                                                                                                                                                      |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Entras con tu cuenta de Dapta.                                                                                                                                | Conectas tu propio servicio de identidad, o usas el inicio de sesión abierto de desarrollo para probar.                                                                                                                                 |
| Los workspaces vienen de tu cuenta de Dapta.                                                                                                                  | Los workspaces vienen del `account_id` de tus propios tokens.                                                                                                                                                                           |
| Google Calendar y Outlook se conectan desde **Calendarios**.                                                                                                  | No hay sincronización de calendarios hasta que conectes un backend de calendario.                                                                                                                                                       |
| Las páginas de reservas están en `https://book.dcal.ai`, separadas del panel.                                                                                 | Las páginas de reservas comparten la dirección de la app web hasta que defines `PUBLIC_BOOKING_URL`.                                                                                                                                    |
| Todos los workspaces pueden agregar Google Tag Manager, Google Analytics 4 y HubSpot a sus eventos.                                                           | Esos tres solo cargan para los workspaces de `EVENT_TRACKING_ACCOUNTS`, hasta que les des a las páginas de reservas un host propio. El píxel de Meta y PostHog funcionan en los dos casos.                                              |
| Los correos de las reservas se envían por ti.                                                                                                                 | No se envía nada hasta que configures SMTP o un servicio de correo HTTP.                                                                                                                                                                |
| Ocultar la marca de Dapta y el enlace personalizado vienen con una suscripción de Dapta AI.                                                                   | `PREMIUM_FEATURES=open`, el valor por defecto, los desbloquea para todos.                                                                                                                                                               |
| HubSpot está listo para conectar.                                                                                                                             | Primero define `CRM_PROVIDER` e `INTEGRATION_ENCRYPTION_KEY`.                                                                                                                                                                           |
| El servidor MCP de dCal para asistentes de IA está en `https://mcp.dcal.ai/mcp`. Te conectas iniciando sesión con tu cuenta de Dapta, o con una clave de API. | El servidor MCP responde por defecto en `/mcp` de tu API. El inicio de sesión para apps de IA sigue apagado hasta que defines `OAUTH_ENABLED`, con tu propio servidor de autorización (`OAUTH_AUTHORIZATION_SERVER`) o con el incluido. |
| Dapta se encarga de los respaldos, las actualizaciones y los arreglos de seguridad.                                                                           | Te encargas tú. Hasta una versión 1.0, solo la última versión de `main` recibe arreglos de seguridad.                                                                                                                                   |
| El soporte viene de Dapta.                                                                                                                                    | El soporte es el repositorio: issues y pull requests en GitHub.                                                                                                                                                                         |

Todo lo demás, las páginas de reservas, los eventos, la disponibilidad, los equipos, los correos, los recordatorios, el estudio de diseño, los webhooks, la API REST y la API compatible con Cal.com, es el mismo producto.

***

## Actualizar y revertir

* **Actualizar:** descarga o reconstruye las imágenes nuevas, ejecuta las migraciones pendientes y luego despliega la API y la app web. Como las migraciones solo añaden cosas, una copia antigua sigue funcionando mientras arranca la nueva.
* **Revertir:** despliega las etiquetas de imagen anteriores. No hace falta una migración hacia atrás.
* **Una excepción:** la migración que llevó el lugar de las reuniones a su propia columna también reescribió datos guardados. Revertir más allá de ella no recupera el texto anterior, así que toma una instantánea de la base de datos antes de actualizar si podrías necesitar volver a un punto exacto. `SELF-HOSTING.md` indica qué migración es.

***

## Problemas comunes al arrancar

| Lo que ves                                                                                                                                      | Qué hacer                                                                                                                                                                                                                                                                                                                                                          |
| ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| La API se detiene al arrancar con un error de entorno                                                                                           | Lee la lista que imprime. Cada ajuste se comprueba al arrancar y un valor incorrecto nombra la variable. Revisa `DATABASE_URL`, y `JWT_SECRET` si `AUTH_PROVIDER=workos`.                                                                                                                                                                                          |
| *Refusing to boot: AUTH\_PROVIDER=local*                                                                                                        | Definiste `NODE_ENV=production` con el inicio de sesión de desarrollo. Cambia a `workos` con su secreto.                                                                                                                                                                                                                                                           |
| Una migración falla en `CREATE EXTENSION btree_gist`                                                                                            | Pide a un superusuario de la base de datos que cree la extensión una vez y vuelve a ejecutar las migraciones.                                                                                                                                                                                                                                                      |
| La app web llama a una dirección de API equivocada                                                                                              | `NEXT_PUBLIC_API_URL` queda fijado al construir. Vuelve a construir la imagen web con el valor correcto.                                                                                                                                                                                                                                                           |
| Los correos de las reservas nunca llegan                                                                                                        | `EMAIL_PROVIDER` sigue en `log-only`. Configura `smtp` o `http`.                                                                                                                                                                                                                                                                                                   |
| La API se detiene al arrancar con `CALENDAR_PROVIDER=external`                                                                                  | No hay backend de calendario configurado. Define `CALENDAR_API_BASE_URL` y `CALENDAR_API_TOKEN`, o `CALENDAR_BACKEND_MODULE`, o vuelve a `disabled`.                                                                                                                                                                                                               |
| *Refusing to boot: OAUTH\_ENABLED=true but the authorization server is not configured*                                                          | Lee la lista que aparece debajo y define lo que nombra. Con tu propio servidor de autorización: `MCP_PUBLIC_URL` y `OAUTH_AUTHORIZATION_SERVER`, escrito exactamente como un origen simple. Con el incluido: `MCP_PUBLIC_URL`, `OAUTH_ISSUER` (un origen `https://`, sin ruta) y `OAUTH_SIGNING_JWK` (una clave privada EC P-256). O define `OAUTH_ENABLED=false`. |
| **Conecta tu agente** dice *El conector no está disponible en esta instalación*                                                                 | El servidor MCP todavía no acepta inicio de sesión. Define `MCP_ENABLED=true` (el valor por defecto) y `OAUTH_ENABLED=true` con un servidor de autorización en la API, y `MCP_PUBLIC_URL` en la app web, y reinicia.                                                                                                                                               |
| **Claves API** dice *El skill no está disponible en esta instalación*                                                                           | La app web no tiene una dirección pública de la API. Define `API_PUBLIC_URL`, o `MCP_PUBLIC_URL`, en la app web y reiníciala.                                                                                                                                                                                                                                      |
| El menú de la izquierda no tiene el elemento **Docs de la API**                                                                                 | La app web no tiene una dirección pública de la API. Define `API_PUBLIC_URL`, o `MCP_PUBLIC_URL`, en la app web y reiníciala.                                                                                                                                                                                                                                      |
| Las herramientas de una app que inició sesión responden `NOT_LINKED`, *This sign-in is not an owner or admin of any account on this server yet* | La persona debe ser propietaria o administradora activa y haber iniciado sesión en la app web dentro de `OAUTH_LINK_MAX_AGE_DAYS`, y tu inicio de sesión web debe guardar su ID de usuario del servidor de autorización. Cuando eso se cumple, la siguiente llamada funciona sin reconectar. Mira `SELF-HOSTING.md`.                                               |
| Nadie puede iniciar sesión en el panel en producción                                                                                            | Las cookies de inicio de sesión necesitan `https`. Sirve la app web por `https`, por ejemplo detrás de un proxy que termina TLS.                                                                                                                                                                                                                                   |

## Relacionado

* [Variables de entorno](https://docs.dapta.ai/dapta-docs-es/dcal/developers/environment-variables.md): cada ajuste, su valor por defecto y qué hace.
* [API REST](https://docs.dapta.ai/dapta-docs-es/dcal/developers/rest-api.md): los endpoints que expone tu instalación.
* [Seguridad y privacidad](https://docs.dapta.ai/dapta-docs-es/dcal/security-and-privacy.md): cómo se protegen los secretos y los enlaces, y cómo reportar una vulnerabilidad.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.dapta.ai/dapta-docs-es/dcal/developers/self-hosting.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
