# 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](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md#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](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) - Uso de CLI
* [LocalAI](/guides/guides_v2-es/modelos-de-lenguaje/localai-openai-compatible.md) - Más backends
* [RAG + LangChain](/guides/guides_v2-es/entrenamiento/finetune-llm.md) - RAG avanzado


---

# Agent Instructions: Querying This Documentation

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

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/open-webui.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.