Ollama und OpenWebUI auf NVIDIA DGX Spark mit Docker

Large Language Models (LLMs) wie Llama 2, Mistral oder die open‑source Variante von GPT‑OSS benötigen leistungsfähige GPUs und viel Arbeitsspeicher – vor allem, wenn man das Modell offline und interaktiv über eine Web‑UI bedienen will.

• Ollama ist ein plattformübergreifendes Tool, das es ermöglicht, Large Language Models lokal auf Rechnern mit GPU zu installieren, auszuführen und zu verwalten. Es vereinfacht den Prozess der Modellverwaltung, bietet eine einfache CLI (Command Line Interface) zur Interaktion und unterstützt eine Vielzahl von Modellen, darunter Llama 2, Mistral, Phi-3 und weitere. Mit Ollama können Entwickler und Forscher schnell experimentieren, Modelle testen und in ihre Anwendungen integrieren, ohne sich um die komplizierten Schritte der Modellinstallation kümmern zu müssen.
• OpenWebUI hingegen ist eine webbasierte Benutzeroberfläche, die es ermöglicht, mit lokal ausgeführten KI-Modellen wie Ollama interaktiv zu kommunizieren. Es bietet eine intuitive Oberfläche, die es Entwicklern und Benutzern erlaubt, Chats zu führen, verschiedene Modelle auszuwählen, Prompt-Engineerings durchzuführen und sogar die Modellperformance zu überwachen. OpenWebUI ist sehr nützlich sowohl für Entwickler als auch für Endanwender, die eine interaktive Plattform benötigen, um mit KI-Modelle zu interagieren.

Beide Tools sind miteinander kompatibel und ergänzen sich hervorragend: Ollama sorgt für die lokale Ausführung der Modelle, während OpenWebUI die Interaktion mit diesen Modellen über eine Benutzeroberfläche ermöglicht. In diesem Artikel zeigen wir, wie man beide Tools auf einer NVIDIA DGX Spark-Plattform mit Hilfe von Docker installiert und konfiguriert.

Der  NVIDIA DGX Spark kombiniert ein ARM‑CPU‑Cluster, 128 GB Unified‑RAM und eine NVIDIA Ada‑Generation GPU (6.144 Shader‑Units, 384 Tensor‑Cores) in einem kompakten Desktop‑Formfaktor. Damit liefert er mehr als 1 000 TOPS AI‑Rechenleistung und genug RAM, um LLMs mit 100 Mrd. Parametern auszuführen – und das zu einem Bruchteil der Kosten klassischer DGX‑Server.

Einrichten der Docker Container

Voraussetzungen

Bevor wir mit der Installation von Ollama und OpenWebUI beginnen, stellen wir sicher, dass alle notwendigen Voraussetzungen erfüllt sind. In diesem Fall arbeiten wir auf einer NVIDIA DGX Spark-Maschine, die mit DGX OS (Ubuntu) ausgestattet ist. Das Betriebssystem ist bereits vorinstalliert und sowohl Docker als auch die NVIDIA Container Runtime, sind ebenfalls schon fertig installiert.

Installation

Die Installation von Ollama und OpenWebUI erfolgt mithilfe einer Docker Compose-Konfigurationsdatei, die beide Dienste in einer isolierten Umgebung bereitstellt. Die unten bereitgestellte docker-compose.yml-Datei definiert zwei Dienste: ollama und open-webui, die jeweils in eigenen Containern ausgeführt werden.

services:
  ollama:
    image: ollama/ollama:0.13.5
    container_name: ollama
    read_only: true                         # erhöht Sicherheit, keine Schreibrechte im Image
    environment:
      - OLLAMA_NUM_PARALLEL=4                # Maximal vier parallele Anfragen
      - OLLAMA_MAX_LOADED_MODELS=2           # Maximal zwei Modelle gleichzeitig im GPU‑Memory
      - OLLAMA_KEEP_ALIVE=720m               # Modelle bleiben 12 h geladen (kann angepasst werden)
      - OLLAMA_KV_CACHE_TYPE=q8_0           # 8‑Bit KV‑Cache
      - OLLAMA_FLASH_ATTENTION=1
    ports:
      - "11434:11434"                        # Ollama‑API
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]           # bindet die NVIDIA‑GPU
    volumes:
      - ollama:/root/.ollama                # <-- Modell‑Daten (ggf. mehrere GB)
      - type: tmpfs                         # <-- Flüchtige Daten
        target: /tmp

  open-webui:
    image: ghcr.io/open-webui/open-webui:git-a727153
    container_name: open-webui
    read_only: true
    depends_on:
      - ollama
    ports:
      - "8080:8080"
    environment:
      - WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY:-8JXm2hF0T9tDvVpx82DguKr0}
      - WEBUI_SESSION_COOKIE_SECURE=False
      - DEFAULT_LOCALE=de
      - ENABLE_CHANNELS=True
      - ENABLE_COMMUNITY_SHARING=False
      - ENABLE_AUDIT_LOGS=True
      - ENABLE_DIRECT_CONNECTIONS=True
      - ENABLE_WEBSOCKET_SUPPORT=True
      - ENABLE_PERSISTENT_CONFIG=True
      - OFFLINE_MODE=True
      - CORS_ALLOW_ORIGIN=http://localhost:8080;http://spark:8080
      - ENABLE_OLLAMA_API=True
      - OLLAMA_BASE_URL=http://ollama:11434
      - RAG_EMBEDDING_ENGINE=ollama
      - RAG_EMBEDDING_MODEL=mxbai-embed-large
    volumes:
      - open-webui:/app/backend/data       # <-- UI‑Daten, DB, Uploads, Vector‑DB
      - type: tmpfs                        # <-- Flüchtige Daten
        target: /tmp

networks:
  default:
    driver: bridge

volumes:
  ollama:          # Volume für Modell-Dateien
  open-webui:      # Volume für UI Daten und Caches

Bemerkungen:

GPU-Zugriff über den deploy-Abschnitt

Der Zugriff auf die GPU wird durch den deploy-Abschnitt im ollama-Dienst konfiguriert. Dieser Abschnitt definiert Ressourcenzuweisungen, wobei die devices-Konfiguration spezifiziert, dass ein GPU-Device vom Treiber nvidia reserviert wird. Die Angabe count: 1 bedeutet, dass genau eine GPU-Instanz für den Dienst bereitgestellt wird, und capabilities: [gpu] stellt sicher, dass die GPU-Unterstützung aktiviert ist. Diese Konfiguration ermöglicht es Ollama, direkt auf die NVIDIA-GPU zuzugreifen, um die Berechnungen für die LLM-Modelle zu beschleunigen. Ohne diesen deploy-Abschnitt würde Ollama nicht auf die GPU zugreifen können.

tmpfs-Mount

Da sowohl der ollama– als auch der open-webui-Dienst mit read_only: true konfiguriert sind, dürfen diese Container keine Schreiboperationen auf ihre Dateisysteme durchführen. Um dennoch temporäre Dateien zu speichern, die für die Ausführung notwendig sind, wird ein tmpfs-Mount verwendet. Dieser Mount wird im volumes-Abschnitt definiert und zeigt auf das /tmp-Verzeichnis im Container. Das tmpfs-Dateisystem ist ein RAM-basiertes Dateisystem, das für temporäre Dateien geeignet ist und die Anforderungen der read-only-Konfiguration erfüllt, ohne dass persistente Speicherung erforderlich ist.

Docker Volumes

In der docker-compose.yml Datei sind zwei Volumes aufgeführt, die jeweils wichtige Daten beinhalten:

• ollama – Dieses vom „ollama“-Service verwendete Volume beinhaltet alle heruntergeladene LLMs
• open-webui – Dieses vom „open-webui“-Service verwendete Volume beinhaltet Chatverläufe, Nutzerdaten und mehr

Beide Arten von Daten haben einen gewissen Wert, insbesondere das open-webui Volume beinhaltet mit den Chatverläufen nicht wiederbringbare Daten. Diese Volumen sind entscheidend für die Datenpersistenz und ermöglichen eine dauerhafte Speicherung von Benutzerinhalten und Einstellungen. Die Verwendung von Volumen ist besonders wichtig in Produktionsumgebungen, andernfalls gehen bei jedem Neustart der Docker-Container alle Daten verloren.

Umgebungsvariablen

Die Umgebungsvariablen sind entscheidend für die Konfiguration der Dienste und beeinflussen deren Verhalten und Leistung. Im ollama-Dienst werden folgende Variablen verwendet:

• OLLAMA_NUM_PARALLEL=4: Steuert die Anzahl paralleler Anfragen, die gleichzeitig bearbeitet werden können. Mehr parallele Anfragen bedeutet natürlich eine höhere Latent pro Anfrage, aber auch grundsätzlich mehr Speicherverbrauch.
• OLLAMA_MAX_LOADED_MODELS=2: Begrenzt die maximale Anzahl geladener Modelle im Speicher. Sobald ein weiteres Modell geladen werden soll, wie zunächst ein aktives Modell aus dem Speicher entfernt.
• OLLAMA_KEEP_ALIVE=720m: Bestimmt, wie lange ein Modell im Speicher gehalten wird, bevor es entladen wird.
• OLLAMA_KV_CACHE_TYPE=q8_0: Legt den Datentyp für den KV-Cache fest, wobei q8_0 eine Quantisierung mit 8 Bit darstellt.
• OLLAMA_FLASH_ATTENTION=1: Aktiviert die Flash-Attention-Optimierung für bessere Leistung bei der Modellverarbeitung.

Im open-webui-Dienst sind zahlreiche Umgebungsvariablen definiert, die verschiedene Funktionen für den ersten Start steuern. Bei nachfolgenden Starts werden diese Daten aus der eingebetteten Datenbank geladen, und die meisten Umgebungsvariablen haben keinen weiteren Einfluss mehr.

• WEBUI_SECRET_KEY: Ein geheimer Schlüssel für Session-Schlüssel.
• WEBUI_SESSION_COOKIE_SECURE=False: Deaktiviert die sichere Cookie-Verwendung. Sichere Cookies können nur über https verwendet werden.
• DEFAULT_LOCALE=de: Setzt die Standardsprache auf Deutsch.
• ENABLE_WEBSOCKET_SUPPORT=True: Aktiviert WebSocket-Unterstützung für eine vereinfachte Kommunikation zwischen Browser und Open WebUI.
• ENABLE_PERSISTENT_CONFIG=True: Aktiviert dauerhafte Konfiguration in der eingebetteten Datenbank.
• CORS_ALLOW_ORIGIN: Erlaubt Zugriff von spezifischen Ursprünge, z. B. http://localhost:8080. Hier müssen mit Semikolon(!) getrennt alle Hostnamen eingetragen werden, über die auf Open WebUI zugegriffen wird.
• ENABLE_OLLAMA_API=True: Aktiviert die Ollama-API-Integration.
• OLLAMA_BASE_URL=http://ollama:11434: Gibt die Basis-URL des Ollama-Dienstes an, der sich in unserem Fall auf den „ollama“ Service bezieht.
• RAG_EMBEDDING_ENGINE=ollama: Verwendet Ollama als Embedding-Engine.
• RAG_EMBEDDING_MODEL=mxbai-embed-large: Gibt das verwendete Embedding-Modell an.

Starten der Container

Wenn die docker-compose.yml Datei nun erstellt worden ist, können die Container nun gestartet werden:

docker compose up -d
Creating network "ollama-openwebui_default"  ...
Creating volume "ollama-openwebui_ollama"   ...
Creating volume "ollama-openwebui_open-webui" ...
Creating ollama   ... done
Creating open-webui ... done

Damit sollten beide Container nun laufen. Sollte es wider Erwarten zu Problemen kommen, dann können wir mit docker compose logs -f die Logausgaben einsehen.

Zugriff auf Ollama

Ollama liefert ein CLI‑Tool, das im Container ausgeführt werden kann. Damit können wir zum Beispiel ein Modell von Ollama aus dem Internet laden, z.B. Llama2:7B. Da das CLI Tool ebenfalls im Docker Container verfügbar ist, verwenden wir docker exec, um den Befehl im Container auszuführen:

docker exec -ti -e OLLAMA_HOST=localhost:11434 ollama ollama pull llama2:7b
pulling manifest 
pulling 8934d96d3f08: 100% ▕████████████████████████████████████████████████████████████████████████▏ 3.8 GB                         
pulling 8c17c2ebb0ea: 100% ▕████████████████████████████████████████████████████████████████████████▏ 7.0 KB                         
pulling 7c23fb36d801: 100% ▕████████████████████████████████████████████████████████████████████████▏ 4.8 KB                         
pulling 2e0493f67d0c: 100% ▕████████████████████████████████████████████████████████████████████████▏   59 B                         
pulling fa304d675061: 100% ▕████████████████████████████████████████████████████████████████████████▏   91 B                         
pulling 42ba7f8a01dd: 100% ▕████████████████████████████████████████████████████████████████████████▏  557 B                         
verifying sha256 digest 
writing manifest 
success 

Ein wichtiger Trick dabei ist, dass wir den OLLAMA_HOST explizit als Umgebungsvariable setzen müssen, denn andernfalls findet das CLI den Ollama Daemon-Prozess nicht.

Danach können wir das Modell „starten“:

docker exec -ti -e OLLAMA_HOST=localhost:11434 ollama ollama run llama2:7b                                                      1.6m
>>> Wie heißt die Hauptstadt der Schweiz?

Die Hauptstadt der Schweiz ist Bern.

Zugriff über die Ollama API

Alternativ können wir natürlich mittels curl auch die Ollama API ansprechen. Da wir Ollama auf dem Port 11434 auf dem Docker Host exponiert haben, können wir das auch außerhalb des Containers ausführen.

Liste der Modelle

Um beispielsweise eine Liste aller verfügbaren Modelle abzurufen, kann folgender curl-Befehl verwendet werden:

curl http://localhost:11434/api/tags | jq .
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 10944    0 10944    0     0   377k      0 --:--:-- --:--:-- --:--:--  381k
{
  "models": [
    {
      "name": "llama2:7b",
      "model": "llama2:7b",
      "modified_at": "2026-01-09T18:29:27.528653219Z",
      "size": 3826793677,
      "digest": "78e26419b4469263f75331927a00a0284ef6544c1975b826b15abdaef17bb962",
      "details": {
        "parent_model": "",
        "format": "gguf",
        "family": "llama",
        "families": [
          "llama"
        ],
        "parameter_size": "7B",
        "quantization_level": "Q4_0"
      }
    },
    {
      "name": "devstral-2:123b",
      "model": "devstral-2:123b",
      "modified_at": "2025-12-25T18:29:53.798740856Z",
...

Prompt Request

Für die Ausführung eines Prompt-Requests kann ein POST-Aufruf verwendet werden. Das folgende Beispiel zeigt, wie ein einfacher Prompt an ein Modell gesendet wird:

$ curl http://localhost:11434/api/generate \                                                                                     41.8s
        -H "Content-Type: application/json" \
        -d '{
      "model": "llama2:7b",
      "prompt": "Erkläre den Unterschied zwischen Machine Learning und Deep Learning.",
      "stream": false
    }' | jq
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  7964    0  7826  100   138    611     10  0:00:13  0:00:12  0:00:01  1706
{
  "model": "llama2:7b",
  "created_at": "2026-01-10T08:37:35.0832492Z",
  "response": "\nMachine Learning (ML) and Deep Learning (DL) are both subfields of Artificial Intelligence (AI) that involve training algorithms to make predictions or take actions based on data. However, there are several key differences between the two:\n\n1...

Zugriff auf Open-WebUI

Nach dem Start der Container über Docker Compose ist Open WebUI über den Browser unter http://localhost:8080 erreichbar. Bei der ersten Anmeldung muss man ein neues Passwort für den Administrator vergeben, danach kann man auch weitere Benutzer hinzufügen.

Starten eines Chats

Um einen neuen Chat zu starten, klickt der Benutzer auf die Schaltfläche „New Chat“ im Hauptmenü oder in der linken Seitenleiste. Anschließend wird ein neuer Chat-Dialog geöffnet, in dem der Benutzer einen Prompt eingeben kann. Die Eingabemaske befindet sich am unteren Rand des Chat-Fensters, wo der Benutzer seinen Text eingeben und mit der Enter-Taste oder durch Klicken auf den Senden-Button absenden kann.

Modell-Auswahl und Einstellungen

Bevor ein Chat gestartet wird, kann der Benutzer im Chat-Fenster die verwendete Modellkonfiguration anpassen. In der rechten oberen Ecke des Chat-Fensters befindet sich ein Menü, in dem verschiedene Modelle ausgewählt werden können. Die Einstellungen für Temperatur, maximale Tokens und andere Parameter können angepasst werden, um das Verhalten des Modells zu steuern. Diese Einstellungen werden pro Chat gespeichert und können bei Bedarf geändert werden.

Fazit

Die Kombination von Ollama und Open WebUI mit NVIDIA DGX Spark als Hardware-Grundlage stellt eine leistungsstarke Plattform für lokale KI-Anwendungen dar. NVIDIA DGX Spark bietet die notwendige Rechenleistung und GPU-Ressourcen, um moderne LLMs effizient auszuführen, wobei die hohe Rechenleistung für komplexe Modellinferenz und parallele Verarbeitung von Anfragen sorgt. Die Integration von NVIDIA’s GPU-Technologie mit Docker-Containern ermöglicht eine einfache Bereitstellung via Docker, und ist damit als leichter Einstieg gut geeignet.

Neben der einfache Bereitstellung, bietet diese Lösung auch die Flexibilität, verschiedene Modelle und Anwendungsfälle zu unterstützen. Die Kombination aus Docker Compose, Ollama und Open WebUI ermöglicht es, komplexe KI-Anwendungen lokal zu betreiben, wodurch Datenschutz und Sicherheit gewährleistet sind. Diese Architektur eignet sich ideal für Entwicklungsumgebungen, Proof-of-Concepts und die lokale Bereitstellung von KI-Anwendungen in kleineren Unternehmen, wo eine kontrollierte und sichere Umgebung erforderlich ist.