# Open WebUI

Schöne ChatGPT-ähnliche Oberfläche zum Ausführen von LLMs auf CLORE.AI-GPUs.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Warum Open WebUI?

* **ChatGPT-ähnliche Benutzeroberfläche** - Vertraute, ausgefeilte Oberfläche
* **Multi-Modell** - Einfaches Wechseln zwischen Modellen
* **RAG integriert** - Dokumente zum Kontext hochladen
* **Benutzerverwaltung** - Mehrbenutzerunterstützung
* **Verlauf** - Gesprächs-Persistenz
* **Ollama-Integration** - Funktioniert sofort

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

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

**Ports:**

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

**Befehl:**

```bash
# Ollama im Hintergrund starten
ollama serve &
sleep 5
ollama pull llama3.2

# Open WebUI starten (verbindet sich automatisch mit Ollama)
# Hinweis: Das Docker-Image kümmert sich darum
```

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zur **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B., `abc123.clorecloud.net`)

Verwenden Sie `https://IHRE_HTTP_PUB_URL` anstelle von `localhost` in den Beispielen unten.

### Überprüfen, ob es funktioniert

```bash
# Gesundheit prüfen
curl https://your-http-pub.clorecloud.net/health

# Version abrufen
curl https://your-http-pub.clorecloud.net/api/version
```

Antwort:

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

{% hint style="warning" %}
Wenn du HTTP 502 erhältst, warte 1–2 Minuten - der Dienst startet noch.
{% endhint %}

## Installation

### Mit Ollama (empfohlen)

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

# Ein Modell herunterladen
docker exec -it ollama ollama pull llama3.2

# Open WebUI starten
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
```

### All-in-One (mitgeliefertes Ollama)

```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
```

## Erste Einrichtung

1. Öffnen `http://your-server:8080`
2. Admin-Konto erstellen (der erste Benutzer wird Admin)
3. Gehe zu Einstellungen → Modelle → Ein Modell herunterladen
4. Beginne zu chatten!

## Funktionen

### Chat-Oberfläche

* Markdown-Darstellung
* Code-Hervorhebung
* Bildgenerierung (mit kompatiblen Modellen)
* Sprach-Ein-/Ausgabe
* Dateianhänge

### Modellverwaltung

* Modelle direkt aus der UI herunterladen
* Eigene Modelle erstellen
* Standardmodell festlegen
* Modellspezifische Einstellungen

### RAG (Dokumenten-Chat)

1. Klicke auf "+" im Chat
2. PDF-, TXT- oder andere Dokumente hochladen
3. Fragen zum Inhalt stellen

### Benutzerverwaltung

* Mehrere Benutzer
* Rollenbasierter Zugriff
* API-Schlüsselverwaltung
* Nutzungsverfolgung

## Konfiguration

### Umgebungsvariablen

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

### Wichtige Einstellungen

| Variable                | Beschreibung                 | Standard                 |
| ----------------------- | ---------------------------- | ------------------------ |
| `OLLAMA_BASE_URL`       | Ollama API-URL               | `http://localhost:11434` |
| `WEBUI_AUTH`            | Authentifizierung aktivieren | `True`                   |
| `WEBUI_NAME`            | Instanzname                  | `WebUI öffnen`           |
| `DEFAULT_MODELS`        | Standardmodell               | -                        |
| `ENABLE_RAG_WEB_SEARCH` | Websuche in RAG              | `False`                  |

### Mit Remote-Ollama verbinden

```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
version: '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
```

## API-Referenz

Open WebUI stellt mehrere API-Endpunkte bereit:

| Endpunkt           | Methode | Beschreibung                       |
| ------------------ | ------- | ---------------------------------- |
| `/health`          | GET     | Health-Check                       |
| `/api/version`     | GET     | Open WebUI-Version abrufen         |
| `/api/config`      | GET     | Konfiguration abrufen              |
| `/ollama/api/tags` | GET     | Ollama-Modelle auflisten (proxied) |
| `/ollama/api/chat` | POST    | Mit Ollama chatten (proxied)       |

### Gesundheitsprüfung

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

Antwort: `true`

### Version abrufen

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

Antwort:

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

### Modelle auflisten (über Ollama-Proxy)

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

{% hint style="info" %}
Die meisten API-Operationen erfordern Authentifizierung. Verwende die Weboberfläche, um ein Konto zu erstellen und API-Schlüssel zu verwalten.
{% endhint %}

## Tipps

### Schnellere Antworten

1. Verwende quantisierte Modelle (Q4\_K\_M)
2. Streaming in den Einstellungen aktivieren
3. Bei Bedarf Kontextlänge reduzieren

### Bessere Qualität

1. Verwende größere Modelle (13B+)
2. Verwende Q8-Quantisierung
3. Temperatur in den Modelleinstellungen anpassen

### Ressourcen sparen

1. Setze `OLLAMA_KEEP_ALIVE=5m`
2. Unbenutzte Modelle entladen
3. Für Tests kleinere Modelle verwenden

## GPU-Anforderungen

Das Gleiche wie [Ollama](https://docs.clore.ai/guides/guides_v2-de/ollama#gpu-requirements).

Open WebUI selbst benötigt minimale Ressourcen (\~500MB RAM).

## Fehlerbehebung

### Kann keine Verbindung zu Ollama herstellen

```bash
# Prüfe, ob Ollama läuft
curl http://localhost:11434/api/tags

# Wenn Docker verwendet wird, nutze Host-Netzwerk oder die korrekte URL
docker run --network=host ghcr.io/open-webui/open-webui:main
```

### Modelle werden nicht angezeigt

1. Verbindung zu Ollama in den Einstellungen prüfen
2. Modellliste aktualisieren
3. Modelle über CLI herunterladen: `ollama pull modelname`

### Langsame Leistung

1. Prüfe, ob die GPU verwendet wird: `nvidia-smi`
2. Versuche kleinere/quantisierte Modelle
3. Gleichzeitige Benutzer reduzieren

## Kostenabschätzung

| Einrichtung      | GPU      | Stündlich |
| ---------------- | -------- | --------- |
| Basic (7B)       | RTX 3060 | \~$0.03   |
| Standard (13B)   | RTX 3090 | \~$0.06   |
| Erweitert (34B)  | RTX 4090 | \~$0.10   |
| Enterprise (70B) | A100     | \~$0.17   |

## Nächste Schritte

* [Ollama](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) - CLI-Nutzung
* [LocalAI](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/localai-openai-compatible) - Mehr Backends
* [RAG + LangChain](https://docs.clore.ai/guides/guides_v2-de/training/finetune-llm) - Erweitertes RAG