# Open WebUI

Hermosa interfaz tipo ChatGPT para ejecutar LLMs en GPUs de CLORE.AI.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## ¿Por qué Open WebUI?

* **Interfaz tipo ChatGPT** - Interfaz familiar y pulida
* **Multi-modelo** - Cambia entre modelos fácilmente
* **RAG incorporado** - Sube documentos para contexto
* **Gestión de usuarios** - Soporte multiusuario
* **Historial** - Persistencia de conversaciones
* **Integración con Ollama** - Funciona desde el primer momento

## Despliegue rápido en CLORE.AI

**Imagen Docker:**

```
ghcr.io/open-webui/open-webui:cuda
```

**Puertos:**

```
22/tcp
8080/http
```

**Comando:**

```bash
# Iniciar Ollama en segundo plano
ollama serve &
sleep 5
ollama pull llama3.2

# Iniciar Open WebUI (se conecta a Ollama automáticamente)
# Nota: La imagen de Docker se encarga de esto
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis Pedidos**:

1. Ir a **Mis Pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Usa `https://TU_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos abajo.

### Verificar que funciona

```bash
# Comprobar salud
curl https://your-http-pub.clorecloud.net/health

# Obtener versión
curl https://your-http-pub.clorecloud.net/api/version
```

Respuesta:

```json
{"version": "0.7.2"}
```

{% hint style="warning" %}
Si obtienes HTTP 502, espera 1-2 minutos: el servicio aún se está iniciando.
{% endhint %}

## Instalación

### Con Ollama (Recomendado)

```bash
# Inicia Ollama primero
docker run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

# Descargar un modelo
docker exec -it ollama ollama pull llama3.2

# Iniciar Open WebUI
docker run -d -p 8080:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main
```

### Todo en Uno (Ollama incluido)

```bash
docker run -d -p 8080:8080 \
  --gpus all \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:ollama
```

## Primeros pasos

1. Abrir `http://tu-servidor:8080`
2. Crea una cuenta de administrador (el primer usuario se convierte en administrador)
3. Ve a Configuración → Modelos → Descargar un modelo
4. ¡Comienza a chatear!

## Características

### Interfaz de chat

* Renderizado Markdown
* Resaltado de código
* Generación de imágenes (con modelos compatibles)
* Entrada/salida de voz
* Adjuntos de archivos

### Gestión de modelos

* Descargar modelos directamente desde la IU
* Crear modelos personalizados
* Establecer modelo predeterminado
* Ajustes específicos por modelo

### RAG (Chat con documentos)

1. Haz clic en "+" en el chat
2. Sube PDF, TXT u otros documentos
3. Haz preguntas sobre el contenido

### Gestión de usuarios

* Usuarios múltiples
* Acceso basado en roles
* Gestión de claves API
* Seguimiento de uso

## Configuración

### Variables de entorno

```bash
docker run -d \
  -e OLLAMA_BASE_URL=http://ollama:11434 \
  -e WEBUI_AUTH=True \
  -e WEBUI_NAME="Mi Chat IA" \
  -e DEFAULT_MODELS="llama3.2" \
  ghcr.io/open-webui/open-webui:main
```

### Ajustes clave

| Variable                | Descripción             | Valor por defecto        |
| ----------------------- | ----------------------- | ------------------------ |
| `OLLAMA_BASE_URL`       | URL de la API de Ollama | `http://localhost:11434` |
| `WEBUI_AUTH`            | Habilitar autenticación | `True`                   |
| `WEBUI_NAME`            | Nombre de la instancia  | `Abrir WebUI`            |
| `DEFAULT_MODELS`        | Modelo predeterminado   | -                        |
| `ENABLE_RAG_WEB_SEARCH` | Búsqueda web en RAG     | `False`                  |

### Conectar a Ollama remoto

```bash
docker run -d -p 8080:8080 \
  -e OLLAMA_BASE_URL=http://remote-server:11434 \
  ghcr.io/open-webui/open-webui:main
```

## Docker Compose

```yaml
versión: '3.8'

services:
  ollama:
    image: ollama/ollama
    container_name: ollama
    volumes:
      - ollama:/root/.ollama
    ports:
      - "11434:11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    volumes:
      - open-webui:/app/backend/data
    ports:
      - "8080:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    depends_on:
      - ollama

volumes:
  ollama:
  open-webui:
```

```bash
docker-compose up -d
```

## Referencia de la API

Open WebUI proporciona varios endpoints de API:

| Endpoint           | Método | Descripción                                  |
| ------------------ | ------ | -------------------------------------------- |
| `/health`          | GET    | Comprobación de salud                        |
| `/api/version`     | GET    | Obtener la versión de Open WebUI             |
| `/api/config`      | GET    | Obtener configuración                        |
| `/ollama/api/tags` | GET    | Listar modelos de Ollama (a través de proxy) |
| `/ollama/api/chat` | POST   | Chatear con Ollama (a través de proxy)       |

### Comprobar estado

```bash
curl https://your-http-pub.clorecloud.net/health
```

Respuesta: `true`

### Obtener versión

```bash
curl https://your-http-pub.clorecloud.net/api/version
```

Respuesta:

```json
{"version": "0.7.2"}
```

### Listar modelos (a través del proxy de Ollama)

```bash
curl https://your-http-pub.clorecloud.net/ollama/api/tags
```

{% hint style="info" %}
La mayoría de las operaciones de la API requieren autenticación. Usa la interfaz web para crear una cuenta y administrar claves API.
{% endhint %}

## Consejos

### Respuestas más rápidas

1. Usa modelos cuantizados (Q4\_K\_M)
2. Habilita el streaming en ajustes
3. Reduce la longitud del contexto si es necesario

### Mejor calidad

1. Usa modelos más grandes (13B+)
2. Usa cuantización Q8
3. Ajusta la temperatura en la configuración del modelo

### Ahorrar recursos

1. Establecer `OLLAMA_KEEP_ALIVE=5m`
2. Descargar modelos no usados
3. Usa modelos más pequeños para pruebas

## Requisitos de GPU

Lo mismo que [Ollama](https://docs.clore.ai/guides/guides_v2-es/ollama#gpu-requirements).

Open WebUI en sí utiliza recursos mínimos (\~500MB de RAM).

## Solución de problemas

### No se puede conectar a Ollama

```bash
# Comprueba que Ollama se está ejecutando
curl http://localhost:11434/api/tags

# Si usas Docker, usa la red del host o la URL correcta
docker run --network=host ghcr.io/open-webui/open-webui:main
```

### Los modelos no aparecen

1. Comprueba la conexión con Ollama en Configuración
2. Actualizar la lista de modelos
3. Descargar modelos vía CLI: `ollama pull modelname`

### Rendimiento lento

1. Comprueba que se está usando la GPU: `nvidia-smi`
2. Prueba modelos más pequeños/cuántizados
3. Reduce usuarios concurrentes

## Estimación de costos

| Configuración     | GPU      | Por hora |
| ----------------- | -------- | -------- |
| Básico (7B)       | RTX 3060 | \~$0.03  |
| Estándar (13B)    | RTX 3090 | \~$0.06  |
| Avanzado (34B)    | RTX 4090 | \~$0.10  |
| Empresarial (70B) | A100     | \~$0.17  |

## Próximos pasos

* [Ollama](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ollama) - Uso de CLI
* [LocalAI](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/localai-openai-compatible) - Más backends
* [RAG + LangChain](https://docs.clore.ai/guides/guides_v2-es/entrenamiento/finetune-llm) - RAG avanzado