# Integración de Open WebUI


[Open WebUI](https://github.com/open-webui/open-webui) es una interfaz web autohospedada y de código abierto que proporciona una experiencia similar a ChatGPT para modelos de IA locales. Puedes conectarla a Docker Model Runner para obtener una interfaz de chat pulida para tus modelos.

## Requisitos previos

- Docker Model Runner habilitado con acceso TCP
- Un modelo descargado (por ejemplo, `docker model pull ai/llama3.2`)

## Inicio rápido con Docker Compose

La forma más sencilla de ejecutar Open WebUI con Docker Model Runner es utilizando Docker Compose.

Crea un archivo `compose.yaml`:

```yaml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:12434
      - WEBUI_AUTH=false
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - open-webui:/app/backend/data

volumes:
  open-webui:
```

Inicia los servicios:

```console
$ docker compose up -d
```

Abre tu navegador en [http://localhost:3000](http://localhost:3000).

## Opciones de configuración

## Variables de entorno

| Variable              | Descripción                                   | Predeterminado |
| --------------------- | --------------------------------------------- | -------------- |
| `OLLAMA_BASE_URL`     | URL de Docker Model Runner                    | Requerido      |
| `WEBUI_AUTH`          | Habilitar autenticación                       | `true`         |
| `OPENAI_API_BASE_URL` | Usar la API compatible con OpenAI en su lugar | -              |
| `OPENAI_API_KEY`      | Clave de API (usa cualquier valor para DMR)   | -              |

### Usar la API compatible con OpenAI

Si prefieres utilizar la API compatible con OpenAI en lugar de la API de Ollama:

```yaml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OPENAI_API_BASE_URL=http://host.docker.internal:12434/engines/v1
      - OPENAI_API_KEY=not-needed
      - WEBUI_AUTH=false
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - open-webui:/app/backend/data

volumes:
  open-webui:
```

## Configuración de red

### Docker Desktop

En Docker Desktop, `host.docker.internal` se resuelve automáticamente a la máquina host. El ejemplo anterior funciona sin modificaciones.

### Docker Engine (Linux)

En Docker Engine, es posible que necesites configurar la red de forma diferente:

```yaml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    network_mode: host
    environment:
      - OLLAMA_BASE_URL=http://localhost:12434
      - WEBUI_AUTH=false
    volumes:
      - open-webui:/app/backend/data

volumes:
  open-webui:
```

O usa el gateway del host:

```yaml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://172.17.0.1:12434
      - WEBUI_AUTH=false
    volumes:
      - open-webui:/app/backend/data

volumes:
  open-webui:
```

## Usar Open WebUI

### Seleccionar un modelo

1. Abre [http://localhost:3000](http://localhost:3000).
2. Selecciona el menú desplegable de modelos en la esquina superior izquierda.
3. Elige uno de tus modelos descargados (aparecen con el prefijo `ai/`).

### Descargar modelos a través de la interfaz de usuario

Open WebUI puede descargar modelos directamente:

1. Selecciona el menú desplegable de modelos.
2. Introduce el nombre de un modelo: `ai/llama3.2`.
3. Selecciona el icono de descarga.

### Características del chat

Open WebUI proporciona:

- Conversaciones de múltiples turnos con contexto
- Edición y regeneración de mensajes
- Resaltado de sintaxis de código
- Renderizado de Markdown
- Historial de conversaciones y búsqueda
- Exportar conversaciones

## Ejemplo completo con múltiples modelos

Este ejemplo configura Open WebUI con Docker Model Runner y descarga previamente varios modelos:

```yaml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:12434
      - WEBUI_AUTH=false
      - DEFAULT_MODELS=ai/llama3.2
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - open-webui:/app/backend/data
    depends_on:
      model-setup:
        condition: service_completed_successfully

  model-setup:
    image: docker:cli
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: >
      sh -c "
        docker model pull ai/llama3.2 &&
        docker model pull ai/qwen2.5-coder &&
        docker model pull ai/smollm2
      "

volumes:
  open-webui:
```

## Habilitar la autenticación

Para configuraciones multiusuario o por seguridad, habilita la autenticación:

```yaml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:12434
      - WEBUI_AUTH=true
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - open-webui:/app/backend/data

volumes:
  open-webui:
```

En la primera visita, crearás una cuenta de administrador.

## Resolución de problemas

### Los modelos no aparecen en el menú desplegable

1. Verifica que Docker Model Runner sea accesible:

   ```console
   $ curl http://localhost:12434/api/tags
   ```

2. Comprueba que los modelos estén descargados:

   ```console
   $ docker model list
   ```

3. Verifica que `OLLAMA_BASE_URL` sea correcta y accesible desde el contenedor.

### Errores de "Conexión rechazada" (Connection refused)

1. Asegúrate de que el acceso TCP esté habilitado para Docker Model Runner.

2. En Docker Desktop, verifica que `host.docker.internal` se resuelva:

   ```console
   $ docker run --rm alpine ping -c 1 host.docker.internal
   ```

3. En Docker Engine, intenta usar `network_mode: host` o la IP explícita del host.

### Tiempos de respuesta lentos

1. Las primeras solicitudes cargan el modelo en memoria, lo cual lleva tiempo.

2. Las solicitudes posteriores son mucho más rápidas.

3. Si la lentitud es constante, considera:
   - Utilizar un modelo más pequeño
   - Reducir el tamaño del contexto
   - Comprobar que la aceleración por GPU esté funcionando

### Errores de CORS

Si ejecutas Open WebUI en un host diferente:

1. En Docker Desktop, ve a Settings > AI.
2. Añade la URL de Open WebUI a **CORS Allowed Origins**.

## Personalización

### Prompts del sistema personalizados

Open WebUI admite la configuración de prompts del sistema por modelo. Configúralos en la interfaz de usuario en Settings > Models.

### Parámetros del modelo

Ajusta los parámetros del modelo en la interfaz de chat:

1. Selecciona el icono de configuración junto al nombre del modelo.
2. Ajusta la temperatura, top-p, tokens máximos, etc.

Estos ajustes se pasan a Docker Model Runner.

## Ejecutar en un puerto diferente

Para ejecutar Open WebUI en un puerto diferente:

```yaml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "8080:8080" # Cambia el primer número de puerto
    # ... resto de la configuración
```

## Qué sigue

- [Referencia de la API](/ai/model-runner/openwebui-integration/api-reference/) - Obtén información sobre las API que utiliza Open WebUI
- [Opciones de configuración](/ai/model-runner/openwebui-integration/configuration/) - Ajusta el comportamiento del modelo
- [Integraciones de IDE](/ai/model-runner/openwebui-integration/ide-integrations/) - Conecta otras herramientas a DMR