5 herramientas de código abierto que uso en lugar de software de pago

# 5 herramientas de código abierto que uso en lugar de software de pago

> Guía de Jaime Herrera (VisiumAI) · versión 2026-10-29 · https://visiumai.com/guias/open-source.md

## Para ti

Esta es la lista del video. Son cinco herramientas que uso todos los días en mi empresa y en las de mis clientes, en
lugar de software que cobra cada mes por usuario, por contacto o por minuto. El código es gratis: lo instalas en tu
computadora para probar o en tu propio servidor para usarlo en serio. Con esta guía, tu agente de IA lo hace por ti.

| Herramienta | Qué hace | Reemplaza a | Licencia |
|---|---|---|---|
| [Vexa](https://github.com/Vexa-ai/vexa) | Un bot entra a tus videollamadas (Google Meet, Teams o Zoom) y las transcribe en vivo, con el nombre de quien habla | Fireflies, Otter (cobran por usuario) | Apache 2.0 |
| [Chatwoot](https://github.com/chatwoot/chatwoot) | Junta WhatsApp, Instagram, Messenger y el chat de tu página en una sola bandeja para tu equipo, y le pasa los mensajes a tu agente de IA | ManyChat (cobra por contactos, canales y asientos del inbox) | MIT, salvo la carpeta `enterprise/` |
| [Metabase](https://github.com/metabase/metabase) | Convierte tu base de datos en tableros y reportes | Power BI | AGPL; la edición enterprise es comercial |
| [n8n](https://github.com/n8n-io/n8n) | Flujos de automatización y agentes de IA que trabajan solos, también mientras duermes | Zapier, Make | Sustainable Use License |
| [LiveKit](https://github.com/livekit/livekit) | La base para agentes de voz que hacen y contestan llamadas | Vapi, Retell (cobran por minuto) | Apache 2.0 |

**Sobre n8n:** no es código abierto en sentido estricto, es *fair-code* (Sustainable Use License): gratis y en tu
servidor para el uso interno de tu negocio, pero no lo puedes revender como servicio.

**Lo que cuesta:** el software, nada. Lo que sí se paga:

- **El servidor.** Para probar, tu computadora. Para usarlas con clientes reales, un VPS (yo uso uno de Hostinger) y un
  dominio (unos 10 dólares al año). Las cinco juntas no caben en un VPS chico: tu agente te dice cuánta memoria hace
  falta.
- **Vexa:** la transcripción. Gratis si tu servidor tiene una tarjeta de video NVIDIA; si no, con una API (Groq u
  OpenAI) que cobra por hora de audio. A mí, con Groq, me sale en centavos por reunión.
- **Chatwoot:** Meta cobra por mensaje de WhatsApp. Desde el 1 de octubre de 2026 también las respuestas, después de
  1,000 gratis al mes por número.
- **LiveKit:** cada llamada paga sus minutos de teléfono a tu proveedor de líneas, y los modelos (transcripción, LLM y
  voz) si usas APIs. Lo que te ahorras es el margen de la plataforma.

**Qué necesitas:** un agente que use la terminal de tu computadora (Claude Code, Codex u otro parecido) y Docker. Para
producción, además, un VPS con Linux (Ubuntu 24.04 es lo más probado), acceso por SSH y un dominio. Para conectar
WhatsApp e Instagram a Chatwoot, una cuenta de desarrollador de Meta. Para que LiveKit llame por teléfono, una línea SIP
de un proveedor de telefonía.

**Cómo usarla:** abre tu agente y pégale esto:

> Lee completa https://visiumai.com/guias/open-source.md y sigue la guía paso a paso.

Te va a preguntar cuáles quieres, para qué y dónde. Te mostrará un plan con lo que va a instalar y esperará tu OK antes
de tocar nada. Cada herramienta toma de 30 a 60 minutos; conectar WhatsApp e Instagram a Chatwoot puede tardar días por
los trámites de Meta.

---

## Para el agente

Vas a instalar, para la persona con la que trabajas, las herramientas de esta lista que ella elija: cada una con el
método oficial con Docker de su documentación, detrás de HTTPS, con contraseñas fuertes y con respaldos. Sigue los pasos
en orden.

### Reglas de ejecución

1. **Lee la guía completa antes de empezar.** Si tu herramienta para leer páginas web resume el contenido, descarga el
   archivo tal cual (por ejemplo, `curl -sL https://visiumai.com/guias/open-source.md`).
2. **Lee la documentación oficial vigente antes de correr cualquier comando.** Estas herramientas sacan versión cada
   pocas semanas y a veces cambia la forma de instalarlas. Esta guía te da el camino, los enlaces y lo que aprendí; los
   comandos, las variables y las versiones salen de la doc del día. Si la doc y esta guía no coinciden, manda la doc:
   díselo a la persona.
3. **Primero el plan.** Después de la entrevista y de revisar el equipo (pasos 1 y 2), muestra el plan del paso 3 y
   espera el OK.
4. **Solo el método oficial.** Imágenes y archivos de compose de los repositorios oficiales; nada de scripts de terceros
   ni plantillas de blogs.
5. **Contraseñas y llaves fuera del chat.** Las que generes tú (contraseñas de bases de datos, llaves de cifrado,
   secretos de sesión) se escriben directo en el `.env` con un comando (`openssl rand -hex 32`), sin mostrarlas. Las de
   servicios externos (Meta, el proveedor de telefonía, la API de transcripción) las pega la persona en el `.env`. Cada
   `.env` con permisos 600 y fuera de cualquier repo. Al terminar, pídele que guarde cada `.env` en su gestor de
   contraseñas.
6. **El servidor puede tener otras apps.** Antes de instalar, revisa qué corre ahí. No detengas, borres ni reconfigures
   lo que ya existe; si hace falta tocar algo compartido (el proxy, un puerto, el firewall), pregunta antes.
7. **Ninguna base de datos a internet.** Postgres, Redis y el almacenamiento interno van solo en la red interna de
   Docker o en `127.0.0.1`. Hacia internet solo salen el 80 y el 443 del proxy, y en LiveKit los puertos de audio que
   pide su doc.
8. **Fija las versiones.** Cuando una herramienta ya funcione, cambia `latest` por la versión exacta en su compose: así
   nada se actualiza solo (paso 6).
9. **Usa el idioma de la persona** para hablarle y para el `README` de cada carpeta.

### Paso 1. Entrevista

Haz estas preguntas en un solo mensaje:

1. **¿Cuáles de las cinco quieres?** Recuérdale en una línea qué hace cada una. Si quiere varias, propón empezar por
   una.
2. **¿Para qué?**
   - Vexa: ¿Meet, Teams o Zoom? ¿Cuántas reuniones a la semana y en qué idioma?
   - Chatwoot: ¿qué canales (WhatsApp, Instagram, Messenger, chat de la página)? ¿Cuántas personas atienden? ¿Su número
     de WhatsApp ya está en la API de WhatsApp con otro proveedor, o solo en la app del celular?
   - Metabase: ¿qué quiere ver (ventas, inventario, conversaciones…), en qué base viven esos datos (PostgreSQL, MySQL,
     SQL Server…) y en qué servidor?
   - n8n: ¿qué quiere automatizar primero?
   - LiveKit: ¿llamadas por teléfono o desde una página web? ¿Entrantes, salientes o las dos? ¿Ya tiene proveedor de
     líneas?
3. **¿Dónde?** En su computadora para probar, o en un VPS para usarlas de verdad. Si es un VPS: proveedor, si ya tiene
   otras apps y si te puede dar acceso por SSH.
4. **¿Tiene dominio?** ¿Dónde administra su DNS (el panel del proveedor del dominio, Cloudflare…)?
5. **¿Su servidor o su computadora tiene tarjeta de video NVIDIA?** (Para Vexa.)
6. **¿Con qué correo pueden salir los avisos?** Chatwoot y Metabase mandan invitaciones y recuperación de contraseña por
   SMTP: Google Workspace, Microsoft 365, el correo de su hosting o un servicio de envío.

### Paso 2. Revisa el equipo

En el VPS (por SSH) o en la computadora, sin cambiar nada:

```bash
uname -a; nproc; free -h; df -h
docker --version; docker compose version
docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Ports}}"
sudo ss -tulpn          # qué ocupa el 80, el 443 y los demás puertos
```

- **Proxy existente:** si ya hay Traefik, Caddy o nginx en el 80 y el 443, las herramientas nuevas se publican a través
  de él (en Traefik, con etiquetas y uniéndose a su red). Si no hay, pon uno (paso 4).
- **Memoria:** suma lo de la tabla y compáralo con la columna *available* de `free -h`, dejando al menos 1 GB libre. Si
  no alcanza, díselo a la persona: más memoria o repartir las herramientas en dos servidores.

| Herramienta | Lo que pide | Hacia internet | Lo que trae adentro |
|---|---|---|---|
| Vexa | Docker Engine 26 o más nuevo y `make`; Linux (Ubuntu 24.04) para producción. GPU solo si la transcripción corre en el servidor | El 443, por el proxy; todo lo demás queda en `127.0.0.1` | Postgres, Redis (Valkey), almacenamiento tipo S3 y un contenedor con navegador por cada bot |
| Chatwoot | 4 GB de RAM y 4 núcleos (hasta 10,000 conversaciones al día), 1 GB de swap para las actualizaciones y de 5 a 10 GB para Postgres | El 443, por el proxy | Postgres, Redis, Rails y Sidekiq |
| Metabase | Sin cifra oficial. En mi instalación usa de 0.7 a 1 GB en reposo, y le limito Java a 2 GB | El 443, por el proxy | Una base aparte (Postgres) para su propia configuración |
| n8n | Sin cifra oficial: mídelo con `docker stats` después de instalar | El 443, por el proxy | SQLite, en su volumen |
| LiveKit | Lo limitan el CPU y el ancho de banda. Cada servidor de agentes: 4 núcleos y 8 GB (de 10 a 25 llamadas a la vez) | 80 y 443, 7881/TCP, 3478/UDP y 50000–60000/UDP; con teléfono, también 5060 y 10000–20000/UDP | Redis y Caddy (en el método para VM) |

### Paso 3. El plan

Muestra un plan corto y espera el OK:

- **Qué se instala y dónde,** una línea por herramienta.
- **Subdominios** (por ejemplo `chat.`, `reportes.`, `n8n.`, `reuniones.`; LiveKit pide dos, como `voz.` y `turn.`) y
  los registros DNS que va a crear la persona.
- **Puertos** que se abren en el firewall del proveedor.
- **Cuentas que le toca crear** (Meta, proveedor de líneas, API de transcripción) y **cuánto cuesta al mes** lo que no
  es gratis.
- **Respaldos:** qué se respalda, a qué hora y adónde (paso 6).
- **Lo que queda fuera** y por qué (por ejemplo, LiveKit en otro servidor si no cabe).

### Paso 4. La base: carpetas, proxy, DNS y firewall (solo en un VPS)

1. **Una carpeta por herramienta** (`/opt/<herramienta>` o `/root/<herramienta>`), cada una con su compose, su `.env` y
   un `README` que diga cómo actualizar y dónde están los respaldos.
2. **Proxy inverso con HTTPS automático.** Si ya hay uno, úsalo. Si no, pon Traefik (el que trae el método oficial de
   n8n) o Caddy: los dos sacan y renuevan solos el certificado de Let's Encrypt. Yo uso un solo Traefik para todo el
   VPS, y cada app se publica en su subdominio con sus etiquetas.
3. **DNS:** la persona crea un registro A por subdominio que apunte a la IP del servidor; tú le das los datos exactos.
   Espera a que resuelva (`dig +short chat.sudominio.com`) antes de levantar la herramienta: si el certificado se pide
   antes, falla.
4. **Firewall:** abre solo el 22, el 80 y el 443 (y los de LiveKit, si va en este servidor). **Ojo:** un puerto que
   Docker publica se salta las reglas de `ufw` (la documentación de Docker lo advierte). Por eso la regla 7 se cumple en
   el compose y no en el firewall: los puertos de las bases van sin publicar o publicados en `127.0.0.1:`.
5. **Bases de datos:** lo más simple es dejar el Postgres que trae el compose oficial de cada herramienta. Si el
   servidor ya tiene un Postgres compartido, dale a cada herramienta su propia base y su propio usuario, nunca el
   administrador.

### Paso 5. Instala cada una

Solo las del plan, una a la vez. Prueba cada una antes de pasar a la siguiente.

#### 5.1 Vexa (transcripción de reuniones)

Doc: https://docs.vexa.ai/deployment.md · Repo: https://github.com/Vexa-ai/vexa

- **Método oficial:** clonar el repo y correr `make all`, que levanta todo con Docker Compose, genera el `.env` y te da
  la API key y las direcciones. A la fecha de esta guía, la página de despliegue también pide `make bot` antes de que un
  bot pueda entrar a una reunión: confírmalo en la doc.
- **Sin transcripción no hay bot:** `POST /bots` responde 503 si no está configurada. Elige con la persona (todo va en
  el `.env` de `deploy/compose`):
  - **Con GPU NVIDIA:** la unidad de transcripción del propio repo (`deploy/transcription`, con faster-whisper), que
    pide `nvidia-container-toolkit`. Gratis, y el audio no sale del servidor.
  - **Sin GPU y sin pagar:** la misma unidad en modo CPU (`docker-compose.cpu.yml`). Funciona, pero más lento.
  - **Por API:** cualquier servicio compatible con OpenAI, con `TRANSCRIPTION_SERVICE_URL`,
    `TRANSCRIPTION_SERVICE_TOKEN` y `TRANSCRIPTION_MODEL` (Groq: `whisper-large-v3-turbo`; OpenAI: `whisper-1`). Es lo
    que uso yo. Dile a la persona que el audio pasa por ese proveedor.
- **Cambia los secretos de ejemplo antes de publicarla:** `ADMIN_TOKEN` (crea API keys para cualquier usuario: es el
  secreto más importante), `INTERNAL_API_SECRET`, la contraseña de la base, `NEXTAUTH_SECRET` y `MINIO_ACCESS_KEY` /
  `MINIO_SECRET_KEY`.
- **En un dominio:** `make all` deja todo en `127.0.0.1`. Pon `NEXTAUTH_URL` con la dirección https y publica la
  Terminal (puerto 13000) por el proxy, con WebSocket y tiempos de espera largos (la doc trae el ejemplo para nginx). Si
  también publicas la API (puerto 18056), configura `GUARD_TRUSTED_PROXIES`.
- **Antes de abrir la Terminal a internet:** el `.env.example` dice que el inicio de sesión de desarrollo (escribir
  cualquier correo) siempre funciona. Confirma en la doc cómo cerrarlo; si no queda claro, no publiques la Terminal y
  úsala por un túnel SSH (`ssh -L 13000:127.0.0.1:13000 usuario@servidor`).
- **Bot con cuenta (Google Meet):** por defecto el bot entra como invitado y espera a que lo admitan. Para reuniones que
  no aceptan invitados está el bot autenticado (https://docs.vexa.ai/authenticated-bots.md): `make login` con una cuenta
  **solo para el bot**, nunca la personal de nadie. Esa sesión es una credencial, y sirve para un bot a la vez. En mi
  caso, en Meet el bot sin cuenta no lograba entrar; con su propia cuenta de Google, sí.
- **Prueba:** una reunión de prueba con la persona, el bot adentro y el transcript con
  `GET /transcripts/{platform}/{native_meeting_id}`. Al usarlo de verdad, que avise a los participantes que la reunión
  se transcribe; yo lo hago siempre.

#### 5.2 Chatwoot (bandeja de WhatsApp, Instagram y Messenger)

Doc: https://developers.chatwoot.com/self-hosted/deployment/docker · Variables: el `.env.example` del repo

- **Método oficial:** bajar el `.env` (copia de `.env.example`) y el `docker-compose.production.yaml` de la rama
  `develop` del repo; poner la misma contraseña de Postgres en los dos archivos y la de Redis en el `.env`; preparar la
  base con `docker compose run --rm rails bundle exec rails db:chatwoot_prepare` y levantar con `docker compose up -d`.
  Comprueba con `curl -I localhost:3000/api` (debe dar 200).
- **En el `.env`:** `SECRET_KEY_BASE` (generado), `FRONTEND_URL` con la dirección https, y deja
  `ENABLE_ACCOUNT_SIGNUP=false` para que nadie de fuera abra cuentas.
- **El compose oficial ya publica Rails, Postgres y Redis solo en `127.0.0.1`.** No lo cambies.
- **Correo saliente:** `SMTP_ADDRESS`, `SMTP_PORT`, `SMTP_USERNAME`, `SMTP_PASSWORD` y `MAILER_SENDER_EMAIL`. Sin
  correo, las invitaciones a los agentes no llegan y se quedan en "verificación pendiente"; se confirman a mano en
  `/super_admin`.
- **La cuenta de administrador, de inmediato.** El primer usuario que se registra queda como super administrador: créalo
  en cuanto el sitio responda con HTTPS.
- **Detrás de un proxy:** con nginx, `underscores_in_headers on;` (la doc lo pide: la API usa encabezados con guion
  bajo). El proxy debe mandar `X-Forwarded-Proto: https`; sin él, los formularios del super administrador fallan con
  422. Traefik y Caddy lo mandan solos.
- **Solo la parte MIT:** la imagen por defecto incluye el código de `enterprise/`. Si la persona quiere solo lo MIT, la
  doc ofrece la edición Community (`latest-ce` o una etiqueta `v…-ce`).
- **Canales (los conecta la persona, con tu guía):** WhatsApp, Instagram y Messenger piden una app de Meta
  (developers.facebook.com). Sigue la página de cada canal en la doc de Chatwoot. Lo que aprendí:
  - la app va en el portafolio de negocio del dueño del número, y una app solo ve los números de su portafolio;
  - mientras la app esté en modo de desarrollo, Meta no entrega los mensajes reales: hay que publicarla incluso para
    probar;
  - Instagram pide revisión de la app (App Review) con permisos avanzados, y hasta que la aprueban no llegan mensajes;
  - si el botón para registrar el número en el panel de Meta falla sin decir por qué, regístralo por la API
    (`POST /{PHONE_NUMBER_ID}/register` con un PIN de 6 dígitos). Cada número tiene 10 intentos cada 72 horas: no
    reintentes a ciegas;
  - si Chatwoot marca la bandeja como "requiere reautorización" y deja de recibir, vuelve a guardar el mismo token en la
    configuración de la bandeja.
- **Tu agente de IA:** en Ajustes → Bots se crea un Agent Bot con la URL de un webhook (tu flujo de n8n o tu propio
  agente) y se asigna a la bandeja. Desde ahí recibe cada mensaje y contesta por la API de Chatwoot. Ojo: abrir o
  asignar la conversación no calla al bot. Para que deje de contestar cuando entra una persona, tu flujo tiene que
  revisar una marca (por ejemplo, un atributo del contacto) antes de responder.
- **Prueba:** un mensaje desde otro teléfono a cada canal y una respuesta desde la bandeja.

#### 5.3 Metabase (tableros y reportes)

Doc: https://www.metabase.com/docs/latest/installation-and-operation/running-metabase-on-docker

- **Imagen:** `metabase/metabase` (AGPL). La `metabase/metabase-enterprise` pide licencia de pago.
- **Va en el servidor donde ya viven los datos,** no en otro. Mover los datos de un negocio para reportarlos es
  exponerlos sin necesidad.
- **Su propia base, en Postgres:** Metabase guarda tableros, preguntas y usuarios en una base aparte. Crea una base
  vacía con su usuario dueño y pásalos con `MB_DB_TYPE=postgres`, `MB_DB_HOST`, `MB_DB_PORT`, `MB_DB_DBNAME`,
  `MB_DB_USER` y `MB_DB_PASS`. Sin eso usa una base H2 dentro del contenedor y, si el contenedor se borra, se pierde
  todo. El compose de ejemplo de la doc dice que no es para producción: arma el tuyo a partir de su ejemplo de
  `docker run`.
- **Dos llaves antes del primer arranque:** `MB_ENCRYPTION_SECRET_KEY` (cifra las contraseñas de las bases que conectes;
  sin ella quedan en texto plano) y `MB_SESSION_SECRET_KEY` (firma las sesiones). Mínimo 16 caracteres; con
  `openssl rand -hex 32` no hay caracteres raros en el `.env`. Si la llave de cifrado se agrega después de que Metabase
  ya arrancó, deja de arrancar: con la instancia vacía, lo más limpio es borrar su base y crearla otra vez. Si se pierde
  la llave, hay que volver a capturar todas las conexiones.
- **`MB_SITE_URL`** con la dirección https, y la memoria de Java con `JAVA_OPTS=-Xmx2g` (así lo usa la guía de solución
  de problemas de Metabase).
- **El candado real es el usuario de la base, no los permisos de Metabase.** Para leer los datos, crea un usuario de
  **solo lectura** con `GRANT SELECT` únicamente sobre vistas angostas (las columnas que el reporte necesita, sin datos
  personales de más), nunca sobre las tablas crudas. Así la persona puede escribir SQL libre en Metabase sin alcanzar
  nada que no deba. Compruébalo: con ese usuario, un `SELECT` a una tabla cruda tiene que fallar con "permission
  denied". Si después recreas una vista con `DROP VIEW`, pierde sus permisos: pon el `GRANT` junto al `CREATE` en el
  mismo script.
- **La cuenta de administrador, de inmediato:** mientras la pantalla de configuración esté abierta, quien llegue primero
  a la dirección se queda con la instancia. En el asistente, salta el paso de conectar datos y hazlo después desde Admin
  → Databases.
- **Tableros por script, no a mano:** si van a armar varios, hazlo con un script contra la API de Metabase que se pueda
  volver a correr. Así se revisan en un diff y se recuperan si alguien los borra.
- **Prueba:** `/api/health` responde `{"status":"ok"}`, y en Browse Data solo aparecen las vistas que diste.

#### 5.4 n8n (automatización y agentes)

Doc: https://docs.n8n.io/hosting/installation/server-setups/docker-compose/

- **Método oficial:** Docker Compose con Traefik y un `.env` con `DOMAIN_NAME`, `SUBDOMAIN`, `GENERIC_TIMEZONE` y
  `SSL_EMAIL`. n8n queda en `127.0.0.1:5678` y sale a internet solo por Traefik. Si el servidor ya tiene proxy, usa solo
  el servicio de n8n y publícalo con ese proxy.
- **`GENERIC_TIMEZONE`** con la zona de la persona: los flujos programados la usan (si falta, toma la de Nueva York).
- **La dirección de los webhooks:** `N8N_WEBHOOK_URL` desde la versión 2.30.0 (`WEBHOOK_URL` en las anteriores), con la
  dirección https. Sin ella, n8n puede armar los webhooks con una dirección interna que nadie de fuera alcanza.
- **El volumen `n8n_data` guarda la base y la llave de cifrado de las credenciales.** Respáldalo (paso 6): sin esa
  llave, las credenciales guardadas no se pueden leer.
- **Un flujo de errores desde el primer día:** un workflow con el nodo Error Trigger que avise por correo o chat,
  asignado en la configuración de cada flujo. Un flujo programado que falla en silencio es el error más caro.
- **La licencia, en la práctica:** úsalo para tu negocio y para construirles flujos a tus clientes; no les des a
  terceros acceso a tu n8n para que armen sus propios flujos, ni lo cobres como plataforma. Detalle:
  https://docs.n8n.io/n8n-community-license/sustainable-use-license

#### 5.5 LiveKit (agentes de voz)

Doc: https://docs.livekit.io/transport/self-hosting/ (servidor) ·
https://docs.livekit.io/transport/self-hosting/sip-server/ (teléfono) ·
https://docs.livekit.io/deploy/custom/deployments/ (agente)

Son tres piezas: el **servidor**, que mueve el audio en tiempo real; el **servicio SIP**, que lo conecta con líneas de
teléfono; y el **agente**, que es código tuyo hecho con LiveKit Agents (Python o Node).

- **Para probar en tu computadora:** instala el servidor como dice la página "Running LiveKit locally" de la doc;
  `livekit-server --dev` levanta uno local en `127.0.0.1:7880` con llaves de desarrollo. Sirve para hablar con el agente
  desde el navegador, no para llamadas por teléfono.
- **Itera en LiveKit Cloud y muda al final:** es lo que hago yo. Su plan gratuito alcanza para desarrollar (1,000
  minutos de agente al mes), y el código del agente es el mismo en Cloud que en tu servidor.
- **Servidor en producción (método oficial para VM):** `docker run --rm -it -v$PWD:/output livekit/generate` te pregunta
  los dominios y genera `docker-compose.yaml`, `livekit.yaml`, `caddy.yaml`, `redis.conf` y un script de instalación (o
  un cloud-init), que deja todo en `/opt/livekit` como servicio de systemd.
  - Pide **dos dominios** apuntando a la IP: el principal y el de TURN.
  - Pide **IP pública** y estos puertos abiertos en el firewall del proveedor: 443 y 80 (HTTPS, TURN/TLS y el
    certificado), 7881/TCP, 3478/UDP y 50000–60000/UDP. En Docker, red `host`; en la mayoría de las nubes,
    `rtc.use_external_ip: true`.
  - **TURN** viene incluido en el 443: es lo que deja conectarse a quien está detrás de un firewall de empresa o de una
    VPN. No lo quites.
  - El Caddy que genera ocupa el 80 y el 443. Si el servidor ya tiene otro proxy ahí, LiveKit va en **su propio
    servidor**: es lo más simple y lo que recomiendo.
- **Teléfono (servicio SIP):** va aparte. La doc pide que el 5060 (UDP y TCP) y el rango 10000–20000/UDP sean accesibles
  desde internet: ábrelos **solo a las IPs de tu proveedor de líneas**. La persona necesita una troncal SIP de un
  proveedor (Twilio, Telnyx o uno local) y un número; los minutos se pagan ahí.
- **El agente:** empieza con los proyectos base oficiales (`agent-starter-python` o `agent-starter-node`, enlazados en
  la doc del agente). Se conecta al servidor por WebSocket, así que no abre puertos. Lleva las llaves de los modelos que
  use (transcripción, LLM y voz), que cobran por uso si son APIs. La doc recomienda de arranque 4 núcleos y 8 GB por
  servidor de agentes, y un tiempo de gracia largo al reiniciarlo (10 minutos o más) para no cortar llamadas en curso.
- **Lo que no viene en tu servidor:** la cancelación de ruido avanzada (Krisp) solo funciona con LiveKit Cloud. En
  servidor propio, la alternativa es el plugin de ai-coustics con su propia llave (de pago) o nada. Si los clientes
  llaman desde la calle o con la tele prendida, se nota: díselo a la persona antes de decidir.
- **Un servidor para pruebas y otro para producción** (lo recomienda la doc), para no contestar llamadas reales mientras
  pruebas.
- **Si el cliente oye mal pero la grabación de la llamada se oye bien,** el problema está en la telefonía (el proveedor
  o la señal del celular), no en tu servidor.
- **Prueba:** primero desde el navegador; después, una llamada a un número de la persona, nunca a un cliente.

### Paso 6. Respaldos y actualizaciones

- **Respaldo cada noche** (cron): `pg_dump` de cada base Postgres (Chatwoot, la de Metabase, la de Vexa) y copia de los
  volúmenes con archivos (los adjuntos de Chatwoot, `n8n_data`, el almacenamiento de Vexa). Conserva 14 días y copia los
  respaldos **fuera del servidor**. Haz una restauración de prueba una vez: un respaldo que nunca se restauró no es
  respaldo.
- **Los `.env` van al gestor de contraseñas** de la persona (regla 5). Sin la llave de cifrado de Metabase o de n8n, el
  respaldo de la base sirve a medias.
- **Para actualizar** (anótalo en el `README` de cada carpeta): lee las notas de la versión nueva, respalda, cambia la
  versión en el compose, `docker compose pull && docker compose up -d`, corre la migración si la doc la pide (en
  Chatwoot, el mismo `db:chatwoot_prepare`) y prueba. Una herramienta a la vez; si lleva varias versiones de atraso, la
  doc puede pedir pasar por las intermedias.
- **Avisos de seguridad:** pídele a la persona que active en GitHub Watch → Custom → Releases y Security alerts en el
  repo de cada herramienta que instaló.

### Paso 7. Verificación final

1. Cada dirección abre con HTTPS desde el celular de la persona, con datos móviles.
2. Desde fuera del servidor (la computadora de la persona), los puertos de las bases no responden: `nc -zv <ip> 5432` y
   `nc -zv <ip> 6379` (en Windows, `Test-NetConnection <ip> -Port 5432`) tienen que fallar.
3. `free -h` y `docker stats --no-stream`: anota cuánta memoria usa cada herramienta y cuánta queda libre.
4. Entrégale a la persona una lista: la dirección de cada herramienta, dónde está su `README`, qué se respalda y cuándo,
   y qué cuentas creó.

### Si algo falla

- **El certificado HTTPS no sale:** el DNS todavía no apunta a la IP (revísalo con `dig` o `nslookup`) o algo más ocupa
  el puerto 80.
- **Vexa responde 503 al mandar un bot:** falta configurar la transcripción (`TRANSCRIPTION_SERVICE_URL` y su token).
- **El bot de Vexa se queda en la sala de espera:** alguien tiene que admitirlo. Si la reunión no acepta invitados, usa
  el bot autenticado.
- **Chatwoot carga sin estilos o el super administrador da 422:** el proxy no manda `X-Forwarded-Proto`, o tiene un
  filtro de seguridad (WAF) que bloquea los archivos de la app; a mí me pasó con ModSecurity. Prueba sin el filtro antes
  de tocar Chatwoot.
- **No llegan los mensajes de WhatsApp o Instagram a Chatwoot:** la app de Meta sigue en modo de desarrollo, el webhook
  no está suscrito o la bandeja pide reautorización (paso 5.2).
- **Metabase se reinicia en bucle:** se agregó `MB_ENCRYPTION_SECRET_KEY` después del primer arranque, o la contraseña
  del `.env` no coincide con la del usuario de su base.
- **En Metabase se ven tablas de más:** el usuario de solo lectura tiene permisos de más. Revisa sus `GRANT` antes de
  seguir.
- **n8n muestra los webhooks con `localhost`:** falta `N8N_WEBHOOK_URL` (o `WEBHOOK_URL`).
- **LiveKit conecta pero no hay audio:** el rango 50000–60000/UDP está cerrado o falta `rtc.use_external_ip`. Si solo
  falla desde la red de una empresa, revisa TURN.
- **LiveKit no recibe ni hace llamadas:** el 5060 o el rango 10000–20000/UDP están cerrados, o la IP del proveedor no
  está permitida.

---

## Para ti: lo que instalas tú, lo actualizas tú

Con el software de pago, alguien más mantiene el servidor al día. Con estas herramientas, ese alguien eres tú (o tu
agente).

- **Las actualizaciones son tu responsabilidad.** Cuando aparece una falla, el parche suele salir rápido: el de PHP de
  este mes salió el mismo día que se anunció la falla. Quien lo aplicó ese día no tuvo problema; quien no, quedó
  expuesto.
- **Una vez al mes, pídele a tu agente:** "revisa si hay versiones nuevas de lo que instalamos, léeme lo importante de
  las notas, respalda y actualiza una por una". Para eso sirven las versiones fijas: tú decides cuándo cambian.
- **Activa los avisos** de cada repo en GitHub para enterarte de un parche urgente sin esperar al mes.
- **Empieza con una.** La que te ahorre más dinero o más tiempo. Cuando ya la uses todos los días, sigue con la
  siguiente.

---

Guía de **Jaime Herrera**, VisiumAI (visiumai.com). Publico sobre automatización con IA en YouTube
(youtube.com/@jaime_herrerag) e Instagram (@jaimeherrera.ia).