# Open WebUI en la oficina: cuentas, modelos, registros y copias

> Open WebUI 0.13 para una oficina pequeña, paso a paso sobre una instancia de prueba: cuentas, modelos por grupo, registros, copias de seguridad y RGPD.

- Publicado: 2026-10-27
- Revisado: 2026-11-15
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: Open WebUI, Ollama, Autoalojado, RGPD, Benchmarks
- URL canónica: https://vorluxai.com/blog/open-webui-office-accounts-models-logs-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

Al terminar esta guía tu oficina tendrá una página de chat privada: una cuenta por persona, solo los modelos que elijas para cada grupo, las conversaciones en una máquina tuya, una copia de seguridad que ya has restaurado una vez y una respuesta por escrito a «quién puede leer qué». Puedes empezar en el ordenador que ya ejecuta [Ollama](https://vorluxai.com/blog/instalar-ollama-primer-llm-local-es/).

Ejecutamos cada paso el 15 de noviembre de 2026 contra un contenedor desechable de Open WebUI 0.13.3, con cuentas inventadas y a través de su API. Los menús son los de la documentación oficial; las salidas y los errores, los que obtuvimos. El registro completo está en [openwebui-office-walkthrough-2026-11-15.json](https://vorluxai.com/data/measurements/openwebui-office-walkthrough-2026-11-15.json).

> **TL;DR**
> * Open WebUI 0.13.3 te da cuentas, grupos, acceso a modelos por grupo y un registro de auditoría. Un usuario nuevo **no ve ningún modelo** hasta que se lo concedes, y el registro de altas se cierra solo tras la primera cuenta.
> * En nuestro hardware, diez peticiones simultáneas a un modelo 7B recibieron cada una su respuesta completa en unos 15 segundos con vLLM. Con Ollama y una sola ranura, esas diez hicieron cola más de un minuto.
> * Veredicto: **No compres nada todavía.** Empieza con la máquina que tienes. Haz la copia con el contenedor parado y pon por escrito tu plazo de conservación: el programa no trae ninguno.

## Para quién es, y cuándo no hacerlo

Encaja en una oficina de 3 a 30 personas donde alguien esté dispuesto a cuidar un contenedor Docker.

No lo montes si nadie va a ocuparse de actualizaciones y copias, o si el administrador no debe poder leer las conversaciones ni técnicamente. La propia [página de privacidad](https://docs.openwebui.com/security/chat-data-privacy-and-encryption) de Open WebUI pide tratar a cada administrador como alguien capaz de leer todos los chats.

## Qué necesitas

* Una máquina que ya sirva un modelo con Ollama. Un portátil o un mini PC basta para empezar.
* Docker con Docker Compose.
* Alrededor de una hora, con una copia y una restauración incluidas.

Sobre la licencia: La [página de licencia](https://docs.openwebui.com/license) (leída el 15 de noviembre de 2026) describe la Open WebUI License: el texto BSD de 3 cláusulas más una cláusula que prohíbe quitar la marca Open WebUI, con una excepción para despliegues de hasta 50 usuarios. Usarlo sin modificar no cuesta nada.

## Paso 1: arranca una versión fijada

La [guía rápida](https://docs.openwebui.com/getting-started/quick-start/) usa la imagen `:main`, que se reconstruye de continuo. La misma página aclara que `:latest` es esa misma imagen y que etiquetas como `:v0.13.3` no cambian nunca. Fija la versión y decide tú cuándo actualizar. El 15 de noviembre de 2026 la última publicada era la [v0.13.3](https://github.com/open-webui/open-webui/releases/tag/v0.13.3), del 8 de noviembre.

```yaml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:v0.13.3
    ports:
      - "3000:8080"
    environment:
      - WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY}
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
      - ENABLE_OPENAI_API=false
      - AUDIT_LOG_LEVEL=METADATA
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - open-webui:/app/backend/data
    restart: unless-stopped

volumes:
  open-webui:
```

```bash
echo "WEBUI_SECRET_KEY=$(openssl rand -hex 32)" > .env && chmod 600 .env
docker compose up -d
curl -s http://localhost:3000/api/version
```

La nuestra respondió `{"version":"0.13.3","deployment_id":""}`. Nosotros lo arrancamos con las opciones equivalentes de `docker run` y una carpeta montada.

Tres detalles que importan:

* **Fija tú `WEBUI_SECRET_KEY`.** Sin ella, el contenedor escribe una clave aleatoria en un archivo que queda fuera del volumen de datos. Recreamos el contenedor sin la variable: todas las sesiones abiertas respondieron `401 Unauthorized` y hubo que volver a entrar.
* **La mayoría de los ajustes se leen del entorno una sola vez.** Tras el primer arranque viven en la base de datos; la [referencia de variables](https://docs.openwebui.com/reference/env-configuration) los llama ConfigVar. Recreamos el contenedor con `DEFAULT_USER_ROLE=user` y otra `OLLAMA_BASE_URL`: no cambió nada. Esos se cambian en los ajustes de administración.
* **Si Ollama está en otra máquina**, necesita `OLLAMA_HOST` en esa máquina para escuchar más allá de 127.0.0.1, como explica la [FAQ de Ollama](https://docs.ollama.com/faq). Ollama no tiene inicio de sesión propio, así que déjalo accesible solo desde el equipo de Open WebUI. Nuestra [lista de parches](https://vorluxai.com/blog/keep-your-local-ai-patched-ollama-security-checklist-es/) cubre esa exposición.

## Paso 2: primer administrador y política de altas

Abre `http://localhost:3000` y crea tu cuenta antes de compartir la dirección. La primera cuenta es la administradora, y la [página de roles](https://docs.openwebui.com/features/authentication-access/rbac/roles) avisa de que no se puede borrar nunca. Lo intentamos: `The requested action has been restricted as a security measure.`

Aquí las guías antiguas, la nuestra incluida, ya no valen. **Tras la primera cuenta, el registro se desactivó solo.** Sin haber puesto `ENABLE_SIGNUP=false`, la segunda persona que se registró recibió un HTTP 403 con este mensaje:

```text
You do not have permission to access this resource. Please contact your administrator for assistance.
```

Así que eliges entre dos políticas:

| Política | Cómo | Qué vimos |
|---|---|---|
| El administrador crea cada cuenta | **Admin Panel > Users**, añadir usuario con rol `user` | La cuenta funciona al momento; el registro sigue cerrado |
| Cada uno se registra y tú apruebas | Activa el registro en los ajustes de administración; rol por defecto `pending` | La cuenta nueva queda en `pending` y recibe ese mismo mensaje en cada petición hasta que la pasas a `user` |

Para diez personas, crea tú las cuentas y deja el registro cerrado. Para un segundo factor, la 0.12.0 añadió `ENABLE_MFA` ([notas de la versión](https://github.com/open-webui/open-webui/releases/tag/v0.12.0)); no lo hemos probado.

Cambiar un rol no cierra la sesión de nadie. Para eso, la página de roles remite a «Sign out all devices» en la ficha del usuario.

## Paso 3: grupos y qué modelos ve cada uno

Si no pusiste la variable, conecta antes Ollama en **Settings > Connections > Manage Ollama API Connections**, como muestra la [página de conexión con Ollama](https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-ollama).

Con Ollama conectado y sin tocar nada más, nuestro administrador veía los 14 modelos del servidor. Cada uno de los tres usuarios normales veía **cero**. Los modelos son privados hasta que concedes acceso: una lista vacía el primer día es lo normal, no una avería.

Crea los grupos en **Admin Panel > Users > Groups**. Los permisos se suman: cada persona recibe los permisos globales más lo que le dé cualquiera de sus grupos, y no existe el «denegar» ([página de permisos](https://docs.openwebui.com/features/authentication-access/rbac/permissions)). Después edita cada modelo y da acceso de lectura a un grupo ([página de grupos](https://docs.openwebui.com/features/authentication-access/rbac/groups)). Este es el reparto que probamos:

| Grupo | Miembros | Lectura sobre | Qué veían sus miembros |
|---|---|---|---|
| Personal (todos) | 3 | `llama3.1:8b` | Solo ese modelo |
| Finanzas | 1 | `qwen2.5vl:7b` | Los dos modelos |
| Administrador | 1 | (no hace falta) | Los 14 |

Quien pidió un modelo sin tener acceso recibió `Model not found`, tanto en el chat como en el proxy de Ollama que trae Open WebUI. La restricción se aplica en el servidor, no en el menú.

* **Fija el contexto en la ficha del modelo.** Pusimos `num_ctx` 4096 en sus parámetros avanzados y Ollama cargó el modelo con 4.096 tokens de contexto. Si lo dejas vacío, Ollama usa su valor por defecto, y el contexto cuesta memoria por cada ranura. Lo medimos en [cuánta memoria cuesta el contexto](https://vorluxai.com/blog/ollama-longitud-contexto-memoria-medida-es/).
* **`BYPASS_MODEL_ACCESS_CONTROL=true`** da todos los modelos a todo el mundo. Úsalo solo si la tabla de arriba te sobra.

Permisos por defecto de un usuario normal, tal como los encontramos: subir archivos, borrar y exportar chats, compartir enlaces y chats temporales, activados; crear modelos, bases de conocimiento y herramientas, y las claves de API, desactivados. Revísalos en **Groups > Default Permissions**.

## Paso 4: dónde se guardan los chats y los archivos

Todo vive en la carpeta montada en `/app/backend/data`. La nuestra contenía:

| Ruta | Qué guarda |
|---|---|
| `webui.db` | Base de datos SQLite: cuentas, chats, grupos, ajustes (53 tablas en la 0.13.3) |
| `webui.db-wal`, `webui.db-shm` | Escrituras recientes aún no volcadas en `webui.db` |
| `uploads/` | Archivos subidos, con nombre `<id>_<nombre original>` |
| `vector_db/` | Índice de búsqueda en documentos |
| `cache/` | Audio e imágenes generados |
| `audit.log` | El registro de auditoría, si lo activas |

Las contraseñas se guardan como hashes bcrypt. La aplicación no cifra los chats ni los archivos: para eso, la página de privacidad recomienda un disco cifrado.

Quién puede leer un chat, tal como lo probamos:

* Un compañero que abrió el chat de otra persona por su dirección recibió `We could not find what you're looking for :/`.
* El administrador pudo listar y abrir los chats de cualquier usuario, y descargar la base de datos entera.
* Con `ENABLE_ADMIN_CHAT_ACCESS=false` y `ENABLE_ADMIN_EXPORT=false`, el administrador recibió un HTTP 401 en las tres cosas. Estas dos sí son variables de entorno corrientes y se aplicaron al reiniciar.

La documentación es franca: esos interruptores fijan el comportamiento de la interfaz y no son una barrera de seguridad. Quien controla el servidor, el volumen o las copias puede leerlo todo.

## Paso 5: haz una copia y restáurala una vez

Open WebUI usa SQLite en modo de escritura anticipada (WAL). Los cambios recientes están en `webui.db-wal`, con dos consecuencias que vimos en directo.

**La «descarga de la base de datos» del administrador puede estar muy desfasada.** Envía `webui.db` tal como está en disco. Nuestra primera descarga, minutos después de crear cuatro cuentas y dos chats, contenía cero usuarios y cero chats. La referencia de variables tampoco la recomienda como copia.

**No abras la base de datos en marcha con otras herramientas.** Tras una descarga de administrador, abrimos `webui.db` con `sqlite3` desde un segundo proceso con el servidor funcionando. El servidor se quedó escribiendo en un archivo WAL ya borrado, y un chat guardado después (HTTP 200) había desaparecido tras reiniciar. Lo reprodujimos una vez más; cada acción por separado no hizo daño. Una ejecución por caso y causa sin establecer: es un aviso, no un diagnóstico.

La copia que funcionó es la sencilla, con el contenedor parado:

```bash
docker compose stop open-webui
docker run --rm -v open-webui:/data:ro -v "$PWD":/backup alpine \
  tar czf /backup/open-webui-$(date +%F).tgz -C /data .
docker compose start open-webui
```

Comprueba el nombre real del volumen con `docker volume ls`. Incluso tras una parada limpia, en nuestra carpeta seguía habiendo un `webui.db-wal` con contenido, así que copia la carpeta entera y nunca `webui.db` suelto.

Para restaurar, vaciamos la carpeta, extrajimos el archivo y arrancamos el contenedor con la misma `WEBUI_SECRET_KEY`:

```bash
docker compose down
docker run --rm -v open-webui:/data -v "$PWD":/backup:ro alpine \
  sh -c 'rm -rf /data/* && tar xzf /backup/open-webui-2026-11-15.tgz -C /data'
docker compose up -d
```

Volvieron las cuentas, los chats, los grupos y los ajustes, y las sesiones abiertas antes de la copia seguían valiendo. Guarda el `.env` junto a la copia.

## Paso 6: actualizaciones

La [página de actualización](https://docs.openwebui.com/getting-started/updating) avisa de que las migraciones de base de datos son de un solo sentido: volver a la imagen anterior no las deshace. Las notas de la 0.13.0 y de la 0.13.1 anuncian cambios de esquema. Por eso el orden es fijo:

1. Lee las notas de todas las versiones entre la tuya y la de destino.
2. Haz la copia del paso 5.
3. Cambia la etiqueta en el compose y ejecuta `docker compose pull && docker compose up -d`.
4. Comprueba `/api/version`, entra y abre un chat antiguo.

Si sale mal, restaura la copia con la etiqueta antigua. No hemos probado una actualización: este es el procedimiento documentado.

## Paso 7: HTTPS en la red de la oficina

Las contraseñas no deberían viajar en claro por la wifi, y los navegadores solo permiten el micrófono con HTTPS. Añádelo al mismo compose y quita la entrada `ports` de Open WebUI:

```yaml
  caddy:
    image: caddy:2-alpine
    ports:
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy-data:/data
    restart: unless-stopped
```

```text
chat.oficina.lan {
	tls internal
	reverse_proxy open-webui:8080
}
```

Declara `caddy-data` bajo `volumes:` y apunta `chat.oficina.lan` al servidor en el DNS de tu router. Con Caddy 2.11.4 delante de nuestra instancia, `/api/version` respondió por HTTPS y el WebSocket negoció con un 101 sin más configuración.

Con `tls internal`, Caddy hace de autoridad de certificación propia. Cada ordenador tiene que confiar en su certificado raíz (carpeta de datos de Caddy, `pki/authorities/local`) o el navegador mostrará un aviso ([documentación de Caddy](https://caddyserver.com/docs/automatic-https)).

Open WebUI escribió esto al arrancar: `WARNING: CORS_ALLOW_ORIGIN IS SET TO '*' - NOT RECOMMENDED FOR PRODUCTION DEPLOYMENTS.` La [referencia de HTTPS](https://docs.openwebui.com/reference/https/) pide poner tu dirección en `WEBUI_URL` y `CORS_ALLOW_ORIGIN`, y añadir `WEBUI_SESSION_COOKIE_SECURE=true`. Esos tres no los hemos probado.

## Paso 8: qué se registra y cómo leerlo

Hay dos registros.

**El del contenedor** (`docker compose logs open-webui`) tiene una línea por petición, en hora UTC, con la ruta y el resultado, pero sin el nombre del usuario:

```text
2026-11-15 19:32:30.787 | INFO | uvicorn.protocols.http.httptools_impl:send:482 - 172.17.0.1:46674 - "POST /api/v1/auths/signin HTTP/1.1" 200
```

**El de auditoría** viene apagado. `AUDIT_LOG_LEVEL=METADATA` escribe un objeto JSON por línea en `audit.log`, dentro de la carpeta de datos. Esta es la nuestra para el borrado de un usuario, abreviada:

```json
{"timestamp": 1794771082, "user": {"email": "admin@oficina.test", "role": "admin", "name": "Admin Prueba"},
 "audit_level": "METADATA", "verb": "DELETE", "request_uri": "http://127.0.0.1:38080/api/v1/users/332123ae-…",
 "source_ip": "172.17.0.1", "model_id": null, "request_object": "", "response_object": ""}
```

Lo que aprendimos al leerlo:

* `timestamp` son segundos Unix. `date -d @1794771082` lo convierte.
* Recoge quién hizo qué y desde dónde: altas, cambios de rol, ediciones de grupos y modelos, subidas, borrados. En este nivel no guarda el texto de ningún mensaje.
* Las líneas de inicio de sesión llevan `user` vacío: solo dan la hora y la dirección.
* **Las peticiones de chat están excluidas por defecto.** Con `AUDIT_EXCLUDED_PATHS=/chats,/folders`, cada una escribió una línea con el usuario y el `model_id`.
* Los niveles `REQUEST` y `REQUEST_RESPONSE` añaden los cuerpos, es decir, las preguntas y las respuestas ([página de endurecimiento](https://docs.openwebui.com/getting-started/advanced-topics/hardening#audit-logging)). Eso copia las conversaciones de tu equipo en un segundo archivo, así que ten un motivo que puedas explicarles.

## Paso 9: dar de baja a un usuario y sus datos

El borrado está en **Admin Panel > Users**. Borramos a una usuaria que tenía un chat, un archivo subido y dos grupos:

| Elemento | Tras el borrado |
|---|---|
| Inicio de sesión y sesiones abiertas | Rechazados: `Invalid authentication request.` |
| Chats | Borrados |
| Pertenencia a grupos | Eliminada |
| Archivo subido | **Sigue ahí**, en la base de datos y en `uploads/` |

El archivo siguió en su sitio hasta que el administrador lo borró por su identificador. Antes de dar de baja a alguien, lista sus archivos (o pídele que vacíe **Settings > Data Controls > Manage Files**). Las copias antiguas lo conservan todo. Si quiere antes una copia, puede exportar sus chats desde ese mismo menú.

## Protección de datos, dicho claro

Esto es información y no asesoramiento jurídico. Los artículos son los del [RGPD en EUR-Lex](https://eur-lex.europa.eu/eli/reg/2016/679/oj), todos en vigor.

* **El responsable eres tú.** La empresa decide para qué y cómo se tratan los chats (art. 4.7). Con una instalación propia y un modelo local no hay proveedor que actúe de encargado para las conversaciones.
* **Informa al equipo** (art. 13): qué se guarda, cuánto tiempo, y que el administrador puede leer los chats técnicamente.
* **Conservación** (art. 5.1.e): los datos no se guardan más tiempo del necesario. No encontramos ningún ajuste de conservación ni de borrado automático en la referencia de variables ni en la 0.13.3, así que elige un plazo, escríbelo y borra a mano con un calendario. Los chats temporales, que un administrador puede imponer por grupo, no se guardan.
* **Solicitudes de acceso y supresión** (arts. 15 y 17): hay un mes para responder (art. 12.3). Los pasos 4 y 9 son tus herramientas: exportar, borrar al usuario, borrar sus archivos y dejar caducar las copias antiguas.
* **Registro y seguridad** (arts. 30 y 32): añade el servicio de chat a tu registro de actividades. La excepción para menos de 250 empleados del art. 30.5 no cubre los tratamientos que no son ocasionales.
* **En España**, el artículo 87 de la [Ley Orgánica 3/2018](https://www.boe.es/eli/es/lo/2018/12/05/3/con) solo permite al empleador acceder a los contenidos de los dispositivos de trabajo para controlar el cumplimiento de las obligaciones y proteger la integridad de esos dispositivos, con criterios de uso que la plantilla conozca de antemano. Leer los chats de alguien debe figurar en esos criterios, con su motivo. El art. 88 del RGPD deja a cada país añadir normas laborales.

Sobre la privacidad desde el diseño en general, tienes nuestra nota sobre [el artículo 25 y la IA local](https://vorluxai.com/blog/rgpd-articulo-25-ia-local-privacidad-por-diseno-2026-es/).

## Qué medimos: a cuánta gente sirve una máquina

Open WebUI no ejecuta el modelo. Reenvía cada chat al servidor de modelos, que es quien marca la velocidad. Tres mediciones nuestras, todas en máquinas NVIDIA DGX Spark (GB10, 128 GB de memoria unificada):

| Servidor y fecha | Modelo | A la vez | Primera palabra, mediana (peor) | Respuesta completa, mediana (peor) |
|---|---|---|---|---|
| vLLM 0.19.0, 8-10-2026 | Qwen2.5-7B-Instruct BF16 | 10 | 0,19 s (4,79 s) | 15,2 s (19,8 s) |
| Ollama 0.30.10, 1 ranura, 2-11-2026 | qwen2.5:7b-instruct fp16 | 10 | 71,7 s (146,4 s) | 86,6 s (162,9 s) |
| Ollama 0.30.10, 1 ranura, 6-11-2026 | qwen2.5:7b-instruct Q4_K_M | 8 | 15,87 s (31,68 s) | 20,3 s (36,14 s) |
| Ollama 0.30.10, 8 ranuras, 6-11-2026 | el mismo | 8 | 0,26 s (0,47 s) | 7,37 s (7,54 s) |

Las dos primeras filas pedían 250 tokens a partir de un correo de oficina de 384 tokens, con tres repeticiones por nivel: [openwebui-concurrency-2026-10-08.json](https://vorluxai.com/data/measurements/openwebui-concurrency-2026-10-08.json) y [ollama-concurrency-prime-2026-11-02.json](https://vorluxai.com/data/measurements/ollama-concurrency-prime-2026-11-02.json). Las dos últimas pedían 200 tokens con 4.096 de contexto: [ollama-parallel-keep-alive-2026-11-06.json](https://vorluxai.com/data/measurements/ollama-parallel-keep-alive-2026-11-06.json). En esa prueba, las ocho ranuras subieron el modelo cargado de 4,75 GB a 6,53 GB.

La lectura: un modelo 7B sirve a diez personas que redactan correos si el servidor responde en paralelo. Con Ollama eso significa fijar `OLLAMA_NUM_PARALLEL`; con una ranura, las peticiones hacen cola. Comparamos los dos servidores en [Ollama o vLLM para una oficina pequeña](https://vorluxai.com/blog/ollama-o-vllm-oficina-pequena-medido-es/). Estas peticiones fueron directas al servidor de modelos, así que no incluyen la sobrecarga propia de Open WebUI, que no hemos medido.

## Cuando falla

| Qué ves | Causa | Arreglo |
|---|---|---|
| Un compañero no tiene modelos que elegir | Los modelos son privados por defecto | Da lectura a su grupo (paso 3) |
| `You do not have permission to access this resource...` al registrarse | El registro se cerró solo tras la primera cuenta | Crea la cuenta como administrador o activa el registro (paso 2) |
| El mismo mensaje después de registrarse | El rol es `pending` | Cámbialo a `user` |
| `WebUI could not connect to Ollama`, y en el registro `Cannot connect to host 127.0.0.1:11434 ... Connect call failed` | Dentro del contenedor, 127.0.0.1 es el propio contenedor | Usa `host.docker.internal` o la dirección del servidor. Los usuarios ven la lista vacía y `Model not found` |
| Todo el mundo fuera tras recrear el contenedor | No hay `WEBUI_SECRET_KEY` fija | Ponla una vez y consérvala (paso 1) |
| Cambias una variable y no pasa nada | El ajuste guardado manda sobre el entorno | Cámbialo en los ajustes de administración |
| Respuestas vacías o rotas detrás de un proxy | La [página de problemas de conexión](https://docs.openwebui.com/troubleshooting/connection-error) lo atribuye a WebSocket o CORS y cita el texto de registro `is not an accepted origin` | Pon tu dirección en `CORS_ALLOW_ORIGIN`. Este no lo reprodujimos |
| `Error loading SentenceTransformer...` al arrancar | `OFFLINE_MODE=true` en una instalación nueva: el modelo de embeddings no estaba en la caché | Arranca una vez sin esa variable si quieres búsqueda en documentos. El chat funcionó igual |

## Límites y lo que no probamos

* Todo fue por la API. No recorrimos la interfaz web, así que las rutas de menú son las de la documentación.
* Cuatro cuentas, no treinta. Sin PostgreSQL, LDAP, inicio de sesión único ni MFA.
* Subir un documento funcionó, pero no probamos la búsqueda dentro de documentos.
* Ninguna actualización desde una versión anterior, ni CORS restringido o cookies seguras detrás del proxy.
* Nuestras pruebas de velocidad enviaban textos cortos. Prueba con tus documentos reales y [calcula antes la memoria](https://vorluxai.com/blog/cuanta-vram-necesito-llm-local-es/). Un modelo mucho mayor, como el de nuestro [análisis de Llama 3.3 70B](https://vorluxai.com/blog/llama-3-3-70b-local-review-what-it-takes-to-run-es/), atenderá a menos gente a la vez.

## Preguntas frecuentes

**¿Puede el administrador leer mis chats?** Por defecto, sí. El interruptor del paso 4 los oculta en el producto, pero quien gestiona el servidor puede leer la base de datos.

**¿Podemos usar ChatGPT u otro modelo en la nube desde aquí?** Open WebUI puede conectarse a servicios compatibles con OpenAI. Nuestro compose lo desactiva con `ENABLE_OPENAI_API=false`, para que nada salga del edificio por descuido.

## Próximos pasos

* [Mide un modelo local en tu propia máquina](https://vorluxai.com/blog/benchmark-modelo-local-tu-ordenador-30-minutos-es/) para tener tu versión de la tabla de velocidad.
* [Mantén tu IA local al día](https://vorluxai.com/blog/keep-your-local-ai-patched-ollama-security-checklist-es/): actualizaciones y comprobaciones de exposición del servidor que hay detrás de Open WebUI.

¿Esto para tu empresa, dimensionado e instalado para tu equipo? [Reserva una llamada de 15 minutos](https://vorluxai.com/contact/) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
