⏱️ Schnelleinstieg

Gesponsert vonTailscale

Verbinden Sie Self-Hosted AI mit jedem Gerät mit Tailscale

Wichtiger Hinweis zu Benutzerrollen und Datenschutz:

• Admin-Erstellung: Das erste auf Open WebUI erstellte Konto erhält Administratorrechte und steuert die Benutzerverwaltung und Systemeinstellungen.
• Benutzerregistrierungen: Nachfolgende Anmeldungen beginnen mit dem Status Ausstehend und erfordern die Genehmigung des Administrators für den Zugriff.
• Datenschutz und Datensicherheit: Alle Ihre Daten, einschließlich Anmeldedaten, werden lokal auf Ihrem Gerät gespeichert. Open WebUI gewährleistet strikte Vertraulichkeit und keine externen Anfragen für verbesserte Privatsphäre und Sicherheit.
  • Alle Modelle sind standardmäßig privat. Modelle müssen explizit über Gruppen geteilt oder öffentlich gemacht werden. Wenn ein Modell einer Gruppe zugewiesen wird, können nur Mitglieder dieser Gruppe es sehen. Wenn ein Modell öffentlich gemacht wird, kann es jeder auf der Instanz sehen.

Wählen Sie unten Ihre bevorzugte Installationsmethode

• Docker: Offiziell unterstützt und für die meisten Benutzer empfohlen
• Python: Geeignet für Umgebungen mit geringen Ressourcen oder für Benutzer, die eine manuelle Einrichtung wünschen
• Kubernetes: Ideal für Enterprise-Bereitstellungen, die Skalierbarkeit und Orchestrierung erfordern

Docker

Docker

Schnellstart mit Docker 🐳

Folgen Sie diesen Schritten, um Open WebUI mit Docker zu installieren.

Schritt 1: Ziehen Sie das Open WebUI-Image

Beginnen Sie damit, das neueste Open WebUI Docker-Image vom GitHub Container Registry herunterzuladen.

docker pull ghcr.io/open-webui/open-webui:main

Schritt 2: Führen Sie den Container aus

Führen Sie den Container mit den Standardeinstellungen aus. Dieser Befehl enthält eine Volume-Zuordnung, um eine persistente Datenspeicherung zu gewährleisten.

docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main

Wichtige Flags

• Volume-Zuordnung (-v open-webui:/app/backend/data): Gewährleistet die persistente Speicherung Ihrer Daten. Dies verhindert Datenverlust zwischen Container-Neustarts.
• Port-Zuordnung (-p 3000:8080): Macht die WebUI auf Port 3000 Ihres lokalen Rechners verfügbar.

GPU-Unterstützung verwenden

Für Nvidia GPU-Unterstützung fügen Sie --gpus all zum docker run-Befehl hinzu

docker run -d -p 3000:8080 --gpus all -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:cuda

Einzelbenutzermodus (Anmeldung deaktivieren)

Um die Anmeldeseite für eine Einzelbenutzer-Einrichtung zu umgehen, setzen Sie die Umgebungsvariable WEBUI_AUTH auf False

docker run -d -p 3000:8080 -e WEBUI_AUTH=False -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main

Warnung

Sie können nach dieser Änderung nicht mehr zwischen dem Einzelbenutzermodus und dem Mehrkontenmodus wechseln.

Erweiterte Konfiguration: Verbindung zu Ollama auf einem anderen Server herstellen

Um Open WebUI mit einem Ollama-Server auf einem anderen Host zu verbinden, fügen Sie die Umgebungsvariable OLLAMA_BASE_URL hinzu

docker run -d -p 3000:8080 -e OLLAMA_BASE_URL=https://example.com -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Greifen Sie auf die WebUI zu

Nachdem der Container läuft, greifen Sie auf Open WebUI unter

https://:3000

Für detaillierte Hilfe zu jedem Docker-Flag siehe Docker-Dokumentation.

Aktualisieren

Um Ihre lokale Docker-Installation auf die neueste Version zu aktualisieren, können Sie entweder Watchtower verwenden oder den Container manuell aktualisieren.

Option 1: Verwendung von Watchtower

Mit Watchtower können Sie den Aktualisierungsprozess automatisieren

docker run --rm --volume /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower --run-once open-webui

(Ersetzen Sie open-webui durch den Namen Ihres Containers, falls er anders ist.)

Option 2: Manuelle Aktualisierung

1. Stoppen und entfernen Sie den aktuellen Container

   docker rm -f open-webui

2. Ziehen Sie die neueste Version herunter

   docker pull ghcr.io/open-webui/open-webui:main

3. Starten Sie den Container erneut

   docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main

Beide Methoden sorgen dafür, dass Ihre Docker-Instanz aktualisiert und mit dem neuesten Build ausgeführt wird.

Docker Compose

Docker Compose-Einrichtung

Die Verwendung von Docker Compose vereinfacht die Verwaltung von Docker-Anwendungen mit mehreren Containern.

Wenn Sie Docker noch nicht installiert haben, lesen Sie unser Docker-Installations-Tutorial.

Docker Compose erfordert ein zusätzliches Paket, docker-compose-v2.

Warnung: Ältere Docker Compose-Tutorials beziehen sich möglicherweise auf Syntax von Version 1, die Befehle wie docker-compose build verwendet. Stellen Sie sicher, dass Sie die Syntax von Version 2 verwenden, die Befehle wie docker compose build verwendet (beachten Sie das Leerzeichen anstelle eines Bindestrichs).

Beispiel für docker-compose.yml

Hier ist eine Beispielkonfigurationsdatei für die Einrichtung von Open WebUI mit Docker Compose

services:
  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    volumes:
      - open-webui:/app/backend/data
volumes:
  open-webui:

Starten der Dienste

Um Ihre Dienste zu starten, führen Sie den folgenden Befehl aus

docker compose up -d

Hilfsskript

Ein nützliches Hilfsskript namens run-compose.sh ist im Code enthalten. Dieses Skript hilft bei der Auswahl der Docker Compose-Dateien, die in Ihre Bereitstellung einbezogen werden sollen, und vereinfacht den Einrichtungsprozess.

---

Hinweis: Für Nvidia GPU-Unterstützung ändern Sie das Image von ghcr.io/open-webui/open-webui:main zu ghcr.io/open-webui/open-webui:cuda und fügen Sie Folgendes zu Ihrer Service-Definition in der Datei docker-compose.yml hinzu

deploy:
  resources:
    reservations:
      devices:
        - driver: nvidia
          count: all
          capabilities: [gpu]

Diese Einrichtung stellt sicher, dass Ihre Anwendung GPU-Ressourcen nutzen kann, wenn sie verfügbar sind.

Podman

Verwendung von Podman

Podman ist eine daemonlose Container-Engine für die Entwicklung, Verwaltung und Ausführung von OCI-Containern.

Grundlegende Befehle

• Container ausführen

  podman run -d --name openwebui -p 3000:8080 -v open-webui:/app/backend/data ghcr.io/open-webui/open-webui:main

• Laufende Container auflisten

  podman ps

Netzwerk mit Podman

Wenn Netzwerkprobleme auftreten, verwenden Sie slirp4netns, um die Netzwerkeinstellungen des Pods anzupassen, damit der Container auf die Ports Ihres Computers zugreifen kann.

Stellen Sie sicher, dass Sie slirp4netns installiert haben, entfernen Sie den vorherigen Container, falls er existiert, mit podman rm und starten Sie einen neuen Container mit

  podman run -d --network=slirp4netns:allow_host_loopback=true --name openwebui -p 3000:8080 -v open-webui:/app/backend/data ghcr.io/open-webui/open-webui:main

Wenn Sie Ollama von Ihrem Computer aus verwenden (nicht innerhalb eines Containers ausgeführt),

Sobald Sie sich in Open WebUI befinden, navigieren Sie zu Einstellungen > Admin-Einstellungen > Verbindungen und erstellen Sie eine neue Ollama API-Verbindung zu http://10.0.2.2:[OLLAMA PORT]. Standardmäßig ist der Ollama-Port 11434.

Konsultieren Sie die Podman-Dokumentation für erweiterte Konfigurationen.

Podman Kube Play

Podman Kube Play-Einrichtung

Podman unterstützt Kubernetes-ähnliche Syntax für die Bereitstellung von Ressourcen wie Pods und Volumes, ohne den Overhead eines vollständigen Kubernetes-Clusters. Mehr über Kube Play.

Wenn Sie Podman noch nicht installiert haben, besuchen Sie die offizielle Website von Podman.

Beispiel für play.yaml

Hier ist ein Beispiel für eine Podman Kube Play-Datei zur Bereitstellung

apiVersion: v1
kind: Pod
metadata:
  name: open-webui
spec:
  containers:
    - name: container
      image: ghcr.io/open-webui/open-webui:main
      ports:
        - name: http
          containerPort: 8080
          hostPort: 3000
      volumeMounts:
        - mountPath: /app/backend/data
          name: data
  volumes:
    - name: data
      persistentVolumeClaim:
        claimName:  open-webui-pvc
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: open-webui-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi

Starten

Um Ihren Pod zu starten, führen Sie den folgenden Befehl aus

podman kube play ./play.yaml

GPU-Unterstützung verwenden

Für Nvidia GPU-Unterstützung müssen Sie das Container-Image durch ghcr.io/open-webui/open-webui:cuda ersetzen und die benötigte Geräte- (GPU) in den Pod-Ressourcenlimits wie folgt angeben

      [...]
      resources:
        limits:
          nvidia.com/gpu=all: 1
      [...]

Wichtig

Damit der open-webui-Container erfolgreich auf die GPU(s) zugreifen kann, müssen Sie die Container Device Interface (CDI) für die gewünschte GPU in Ihrer Podman-Maschine installiert haben. Sie können unter Podman GPU-Containerzugriff nachsehen.

Docker Swarm

Docker Swarm

Diese Installationsmethode erfordert Kenntnisse über Docker Swarms, da sie eine Stack-Datei verwendet, um 3 separate Container als Dienste in einem Docker Swarm bereitzustellen.

Sie enthält isolierte Container für ChromaDB, Ollama und OpenWebUI. Darüber hinaus gibt es vorausgefüllte Umgebungsvariablen, um die Einrichtung weiter zu veranschaulichen.

Wählen Sie den entsprechenden Befehl basierend auf Ihrem Hardware-Setup

• Vor dem Start:

  Verzeichnisse für Ihre Volumes müssen auf dem Host erstellt werden, oder Sie können einen benutzerdefinierten Speicherort oder ein Volume angeben.

  Das aktuelle Beispiel verwendet ein isoliertes Verzeichnis data, das sich im selben Verzeichnis wie die docker-stack.yaml befindet.

  • Zum Beispiel:

    mkdir -p data/open-webui data/chromadb data/ollama

• Mit GPU-Unterstützung:

  Docker-stack.yaml

  version: '3.9'
  
  services:
    openWebUI:
      image: ghcr.io/open-webui/open-webui:main
      depends_on:
          - chromadb
          - ollama
      volumes:
        - ./data/open-webui:/app/backend/data
      environment:
        DATA_DIR: /app/backend/data 
        OLLAMA_BASE_URLS: http://ollama:11434
        CHROMA_HTTP_PORT: 8000
        CHROMA_HTTP_HOST: chromadb
        CHROMA_TENANT: default_tenant
        VECTOR_DB: chroma
        WEBUI_NAME: Awesome ChatBot
        CORS_ALLOW_ORIGIN: "*" # This is the current Default, will need to change before going live
        RAG_EMBEDDING_ENGINE: ollama
        RAG_EMBEDDING_MODEL: nomic-embed-text-v1.5
        RAG_EMBEDDING_MODEL_TRUST_REMOTE_CODE: "True"
      ports:
        - target: 8080
          published: 8080
          mode: overlay
      deploy:
        replicas: 1
        restart_policy:
          condition: any
          delay: 5s
          max_attempts: 3
  
    chromadb:
      hostname: chromadb
      image: chromadb/chroma:0.5.15
      volumes:
        - ./data/chromadb:/chroma/chroma
      environment:
        - IS_PERSISTENT=TRUE
        - ALLOW_RESET=TRUE
        - PERSIST_DIRECTORY=/chroma/chroma
      ports: 
        - target: 8000
          published: 8000
          mode: overlay
      deploy:
        replicas: 1
        restart_policy:
          condition: any
          delay: 5s
          max_attempts: 3
      healthcheck: 
        test: ["CMD-SHELL", "curl localhost:8000/api/v1/heartbeat || exit 1"]
        interval: 10s
        retries: 2
        start_period: 5s
        timeout: 10s
  
    ollama:
      image: ollama/ollama:latest
      hostname: ollama
      ports:
        - target: 11434
          published: 11434
          mode: overlay
      deploy:
        resources:
          reservations:
            generic_resources:
              - discrete_resource_spec:
                  kind: "NVIDIA-GPU"
                  value: 0
        replicas: 1
        restart_policy:
          condition: any
          delay: 5s
          max_attempts: 3
      volumes:
        - ./data/ollama:/root/.ollama
  

  • Zusätzliche Anforderungen:

    1. Stellen Sie sicher, dass CUDA aktiviert ist. Befolgen Sie dazu die Anweisungen Ihres Betriebssystems und Ihrer GPU.
    2. Aktivieren Sie die Docker-GPU-Unterstützung. Siehe Nvidia Container Toolkit
    3. Folgen Sie der Anleitung hier zur Konfiguration von Docker Swarm für die Arbeit mit Ihrer GPU
    • Stellen Sie sicher, dass die GPU-Ressource in /etc/nvidia-container-runtime/config.toml aktiviert ist und aktivieren Sie die GPU-Ressourcenwerbung, indem Sie swarm-resource = "DOCKER_RESOURCE_GPU" einkommentieren. Der Docker-Daemon muss nach der Aktualisierung dieser Dateien auf jedem Knoten neu gestartet werden.

• Mit CPU-Unterstützung:

  Modifizieren Sie den Ollama-Dienst in docker-stack.yaml und entfernen Sie die Zeilen für generic_resources:

      ollama:
    image: ollama/ollama:latest
    hostname: ollama
    ports:
      - target: 11434
        published: 11434
        mode: overlay
    deploy:
      replicas: 1
      restart_policy:
        condition: any
        delay: 5s
        max_attempts: 3
    volumes:
      - ./data/ollama:/root/.ollama

• Docker Stack bereitstellen:

  docker stack deploy -c docker-stack.yaml -d super-awesome-ai

Python

uv

Installation mit uv

Der Laufzeitmanager uv sorgt für eine reibungslose Python-Umgebungsverwaltung für Anwendungen wie Open WebUI. Befolgen Sie diese Schritte, um loszulegen

1. Installieren Sie uv

Wählen Sie den entsprechenden Installationsbefehl für Ihr Betriebssystem

• macOS/Linux:

  curl -LsSf https://astral.sh/uv/install.sh | sh

• Windows:

  powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

2. Führen Sie Open WebUI aus

Sobald uv installiert ist, ist die Ausführung von Open WebUI ein Kinderspiel. Verwenden Sie den folgenden Befehl und stellen Sie sicher, dass Sie die Umgebungsvariable DATA_DIR festlegen, um Datenverlust zu vermeiden. Beispielpfade sind für jede Plattform angegeben

• macOS/Linux:

  DATA_DIR=~/.open-webui uvx --python 3.11 open-webui@latest serve

• Windows (PowerShell)

  $env:DATA_DIR="C:\open-webui\data"; uvx --python 3.11 open-webui@latest serve

Aktualisieren mit Python

Um Ihr lokal installiertes Open-WebUI-Paket auf die neueste Version mit pip zu aktualisieren, befolgen Sie diese einfachen Schritte

pip install -U open-webui

Das Flag -U (oder --upgrade) stellt sicher, dass pip das Paket auf die neueste verfügbare Version aktualisiert.

Das war's! Ihr Open-WebUI-Paket ist jetzt aktualisiert und einsatzbereit.

Conda

Installation mit Conda

1. Erstellen Sie eine Conda-Umgebung

   conda create -n open-webui python=3.11

2. Aktivieren Sie die Umgebung

   conda activate open-webui

3. Installieren Sie Open WebUI

   pip install open-webui

4. Starten Sie den Server

   open-webui serve

Aktualisieren mit Python

Um Ihr lokal installiertes Open-WebUI-Paket auf die neueste Version mit pip zu aktualisieren, befolgen Sie diese einfachen Schritte

pip install -U open-webui

Das Flag -U (oder --upgrade) stellt sicher, dass pip das Paket auf die neueste verfügbare Version aktualisiert.

Das war's! Ihr Open-WebUI-Paket ist jetzt aktualisiert und einsatzbereit.

Venv

Verwendung virtueller Umgebungen

Erstellen Sie isolierte Python-Umgebungen mit venv.

Schritte

1. Erstellen Sie eine virtuelle Umgebung

   python3 -m venv venv

2. Aktivieren Sie die virtuelle Umgebung

   • Unter Linux/macOS

     source venv/bin/activate

   • Unter Windows

     venv\Scripts\activate

3. Installieren Sie Open WebUI

   pip install open-webui

4. Starten Sie den Server

   open-webui serve

Aktualisieren mit Python

Um Ihr lokal installiertes Open-WebUI-Paket auf die neueste Version mit pip zu aktualisieren, befolgen Sie diese einfachen Schritte

pip install -U open-webui

Das Flag -U (oder --upgrade) stellt sicher, dass pip das Paket auf die neueste verfügbare Version aktualisiert.

Das war's! Ihr Open-WebUI-Paket ist jetzt aktualisiert und einsatzbereit.

Entwicklung

Entwicklungseinrichtung

Für Entwickler, die beitragen möchten, lesen Sie die Entwicklungsanleitung unter Erweiterte Themen.

Kubernetes

Helm

Helm-Einrichtung für Kubernetes

Helm hilft Ihnen bei der Verwaltung von Kubernetes-Anwendungen.

Voraussetzungen

• Kubernetes-Cluster ist eingerichtet.
• Helm ist installiert.

Schritte

1. Fügen Sie das Open WebUI Helm-Repository hinzu

   helm repo add open-webui https://open-webui.github.io/helm-charts
   helm repo update

2. Installieren Sie das Open WebUI Chart

   helm install openwebui open-webui/open-webui

3. Installation überprüfen

   kubectl get pods

Warnung

Wenn Sie Open WebUI mit mehreren Knoten/Pods/Workern in einer Clusterumgebung skalieren möchten, müssen Sie eine NoSQL-Schlüsselwertdatenbank einrichten. Es gibt einige Umgebungsvariablen, die für alle Service-Instanzen auf denselben Wert gesetzt werden müssen, andernfalls treten Konsistenzprobleme, fehlerhafte Sitzungen und andere Probleme auf!

Greifen Sie auf die WebUI zu

Richten Sie Portweiterleitung oder Lastenausgleich ein, um von außerhalb des Clusters auf Open WebUI zuzugreifen.

Kustomize

Kustomize-Einrichtung für Kubernetes

Kustomize ermöglicht die Anpassung von Kubernetes-YAML-Konfigurationen.

Voraussetzungen

• Kubernetes-Cluster ist eingerichtet.
• Kustomize ist installiert.

Schritte

1. Klonen Sie die Open WebUI-Manifeste

   git clone https://github.com/open-webui/k8s-manifests.git
   cd k8s-manifests

2. Wenden Sie die Manifeste an

   kubectl apply -k .

3. Installation überprüfen

   kubectl get pods

Warnung

Wenn Sie Open WebUI mit mehreren Knoten/Pods/Workern in einer Clusterumgebung skalieren möchten, müssen Sie eine NoSQL-Schlüsselwertdatenbank einrichten. Es gibt einige Umgebungsvariablen, die für alle Service-Instanzen auf denselben Wert gesetzt werden müssen, andernfalls treten Konsistenzprobleme, fehlerhafte Sitzungen und andere Probleme auf!

Greifen Sie auf die WebUI zu

Richten Sie Portweiterleitung oder Lastenausgleich ein, um von außerhalb des Clusters auf Open WebUI zuzugreifen.

Drittanbieter

Pinokio.computer

Pinokio.computer-Installation

Für die Installation über Pinokio.computer besuchen Sie bitte deren Website

https://pinokio.computer/

Die Unterstützung für diese Installationsmethode wird über deren Website bereitgestellt.

Zusätzliche Integrationen von Drittanbietern

(Fügen Sie Informationen zu Integrationen von Drittanbietern hinzu, sobald diese verfügbar sind.)

Nächste Schritte

Nach der Installation besuchen Sie

• https://:3000, um auf Open WebUI zuzugreifen.
• oder https://:8080/ bei Verwendung einer Python-Bereitstellung.

Sie sind nun bereit, Open WebUI zu nutzen!

Open WebUI mit Ollama verwenden

Wenn Sie Open WebUI mit Ollama verwenden, lesen Sie unbedingt unsere Anleitung zum Starten mit Ollama, um zu erfahren, wie Sie Ihre Ollama-Instanzen mit Open WebUI verwalten können.

Treten Sie der Community bei

Benötigen Sie Hilfe? Haben Sie Fragen? Treten Sie unserer Community bei

• Open WebUI Discord
• GitHub Issues

Bleiben Sie über die neuesten Funktionen, Tipps zur Fehlerbehebung und Ankündigungen auf dem Laufenden!