LLMs im Heimlabor: Destillierte Modelle effizient betreiben

Servus, Home Lab-Enthusiasten und Admins!

Die Welt der KI dreht sich rasend schnell. Immer größere, immer mächtigere Modelle dominieren die Schlagzeilen. Doch wer von uns hat schon einen Serverpark mit Dutzenden A100-GPUs im Keller stehen? Die gute Nachricht: Das brauchst du oft gar nicht! Die Jungs von Golem haben es neulich wieder gut auf den Punkt gebracht: Das Zauberwort heißt "Distillation" – das Abspecken von KI-Modellen. Und genau das ist unser Thema heute. Es geht darum, wie wir diese kleineren, effizienteren Large Language Models (LLMs) in unserem eigenen Heimlabor zum Laufen bekommen, ohne uns finanziell zu ruinieren oder den Sicherungskasten in die Knie zu zwingen.

In meiner Erfahrung ist das ein Game Changer für alle, die mit LLMs experimentieren wollen, ohne auf Cloud-Dienste angewiesen zu sein. Wir sprechen hier von Modellen, die auf deiner eigenen Hardware laufen, deine Daten nicht verlassen und trotzdem erstaunliche Ergebnisse liefern können. Mein Ziel ist es, dir einen praxisnahen Guide an die Hand zu geben, damit du selbst Hand anlegen kannst. Wir nutzen dabei Tools, die du vielleicht schon kennst und schätzt: Docker für die Isolation und Ollama, das sich in den letzten Monaten als absoluter Champion für das lokale Betreiben von LLMs etabliert hat.

Warum destillierte LLMs im Heimlabor?

Die Idee hinter der Distillation, wie sie auch im Golem-Artikel beschrieben wird, ist genial: Nimm ein großes, leistungsstarkes Modell (den "Teacher") und bringe einem kleineren Modell (dem "Student") bei, dessen Verhalten nachzuahmen. Das Ergebnis ist ein Modell, das oft nur einen Bruchteil der Größe und Rechenleistung benötigt, aber immer noch sehr gute Ergebnisse liefert. Für unser Heimlabor bedeutet das:

Ressourcenschonung: Kleinere Modelle laufen mit weniger RAM und CPU-Kernen. Wenn du eine dedizierte GPU hast, ist das super, aber viele dieser Modelle laufen auch überraschend gut auf modernen CPUs.
Kostenersparnis: Keine monatlichen API-Gebühren für Cloud-LLMs. Alles läuft lokal.
Datenschutz: Deine Daten bleiben bei dir. Das ist besonders wichtig, wenn du sensible Informationen verarbeiten möchtest oder einfach Wert auf Privatsphäre legst.
Experimentierfreudigkeit: Du kannst Modelle beliebig wechseln, mit verschiedenen Parametern spielen und sogar eigene kleine Modelle trainieren (obwohl das ein Thema für einen anderen Guide wäre).
Unabhängigkeit: Keine Internetverbindung? Kein Problem. Dein lokales LLM läuft weiter.

Wichtig zu wissen ist, dass diese "destillierten" Modelle nicht immer die absolute Spitzenleistung ihrer riesigen Vorbilder erreichen. Aber für viele Anwendungsfälle – Texte zusammenfassen, Code generieren, Ideen brainstormen oder einfache Chats – sind sie mehr als ausreichend und bieten ein hervorragendes Preis-Leistungs-Verhältnis (oder besser gesagt: Performance-Ressourcen-Verhältnis) für unser Home Lab.

Voraussetzungen: Was du brauchst

Bevor wir loslegen, lass uns kurz checken, ob deine Hardware und Software bereit sind. In meiner Erfahrung ist eine solide Basis der Schlüssel zum Erfolg und erspart dir später viel Frust.

Hardware-Anforderungen

Proxmox VE Host (optional, aber empfohlen): Ich gehe davon aus, dass viele von euch Proxmox für ihre VMs und Container nutzen. Eine dedizierte VM für LLMs ist ideal, da du Ressourcen leicht zuweisen und Snapshots erstellen kannst.
CPU mit AVX2-Unterstützung: Das ist ein absolutes Muss für viele moderne LLM-Bibliotheken. Ohne AVX2 wird die Performance extrem leiden oder die Modelle laufen gar nicht erst. Die meisten CPUs der letzten 8-10 Jahre unterstützen das. Du kannst es später mit lscpu | grep avx2 prüfen.
RAM: Mindestens 16 GB, besser 32 GB oder mehr. Kleinere 7B-Modelle benötigen typischerweise 8-10 GB RAM (oder VRAM). Wenn du mehrere Modelle laden oder größere Modelle ausprobieren willst, ist mehr Speicher immer besser.
SSD: Eine schnelle NVMe- oder SATA-SSD ist Pflicht. Modelle können mehrere Gigabyte groß sein und werden beim Laden in den RAM geschoben. Eine langsame HDD würde hier zum Flaschenhals werden.
NVIDIA GPU (optional, aber sehr empfehlenswert): Wenn du eine NVIDIA-Grafikkarte (RTX 30-Serie oder neuer, mindestens 8 GB VRAM) hast, kannst du die Modelle deutlich schneller ausführen. Ollama unterstützt CUDA hervorragend. AMD-GPUs sind auch nutzbar, aber die Einrichtung ist oft komplexer und die Performance kann variieren. Für den Einstieg ist CPU-Betrieb aber völlig ausreichend.

Software-Anforderungen

Linux-Distribution: Eine aktuelle Debian- oder Ubuntu-basierte Distribution (z.B. Ubuntu Server LTS) ist meine Empfehlung. Ich nutze selbst oft Ubuntu Server in VMs.
Docker & Docker Compose: Das Herzstück unserer Containerisierung. Wir werden Ollama in einem Docker-Container betreiben.
Netzwerkkenntnisse: Grundlegendes Verständnis von IP-Adressen, Ports und Firewalls ist hilfreich.

Die Basis schaffen: Dein Linux-System vorbereiten

Egal ob du eine frische VM unter Proxmox aufsetzt oder einen dedizierten Linux-Host nutzt, die ersten Schritte sind ähnlich.

1. System aktualisieren

Das ist immer der erste Schritt nach einer Neuinstallation. So stellst du sicher, dass alle Pakete auf dem neuesten Stand sind und potenzielle Sicherheitslücken geschlossen werden.

sudo apt update
sudo apt upgrade -y
sudo apt autoremove -y

2. GPU-Treiber installieren (falls NVIDIA GPU vorhanden)

Wenn du eine NVIDIA-GPU hast, musst du die passenden Treiber installieren. Das kann manchmal etwas knifflig sein, aber es lohnt sich für die Performance. Wichtig: Installiere die Treiber *vor* Docker und dem NVIDIA Container Toolkit. Unter Ubuntu empfehle ich den Graphics Drivers PPA.

sudo add-apt-repository ppa:graphics-drivers/ppa -y
sudo apt update
sudo apt install nvidia-driver-535 -y # Oder die neueste stabile Version
sudo reboot

Nach dem Neustart solltest du mit nvidia-smi prüfen können, ob die Treiber korrekt geladen wurden.

3. Docker und Docker Compose installieren

Wir nutzen die offizielle Installationsanleitung von Docker, um die neueste Version zu erhalten. Das ist in meiner Erfahrung der zuverlässigste Weg.

# Docker Engine installieren
for pkg in docker.io docker-doc docker-compose docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin; do sudo apt remove $pkg; done

sudo apt update
sudo apt install ca-certificates curl gnupg -y
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

# Benutzer zur Docker-Gruppe hinzufügen (damit sudo nicht jedes Mal nötig ist)
sudo usermod -aG docker $USER
newgrp docker # Oder einfach neu anmelden

# NVIDIA Container Toolkit installieren (wenn GPU vorhanden)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://nvidia.github.io/libnvidia-container/ubuntu/$(. /etc/os-release; echo $VERSION_CODENAME) stable" | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt update
sudo apt install -y nvidia-container-toolkit
sudo systemctl restart docker

Mit docker run hello-world kannst du testen, ob Docker korrekt installiert ist.

Ollama: Dein Tor zu den kleinen Modellen

Ollama ist eine fantastische, quelloffene Plattform, die es extrem einfach macht, Large Language Models (LLMs) lokal zu installieren und auszuführen. Es bietet eine einfache API, die du später nutzen kannst, um deine Anwendungen anzubinden. Ich persönlich finde die Docker-Integration am praktischsten, da sie sauber isoliert und leicht zu verwalten ist.

1. Ollama mit Docker Compose starten

Erstelle einen Ordner für deine Ollama-Konfiguration, zum Beispiel ~/ollama, und darin eine docker-compose.yml Datei.

# ~/ollama/docker-compose.yml
version: '3.8'
services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434" # Standard-Port für Ollama API
    volumes:
      - ./ollama_data:/root/.ollama # Hier werden Modelle und Daten gespeichert
    environment:
      - OLLAMA_HOST=0.0.0.0 # Wichtig, damit Ollama von anderen Geräten erreichbar ist
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all # Oder eine spezifische Anzahl, z.B. 1
              capabilities: [gpu] # Wichtig für GPU-Nutzung

Ein paar Erklärungen zur Config:

image: ollama/ollama:latest: Zieht das neueste Ollama-Image.
ports: - "11434:11434": Mappt den Container-Port 11434 auf den Host-Port 11434. Das ist der Standard-API-Port von Ollama.
volumes: - ./ollama_data:/root/.ollama: Hier werden alle heruntergeladenen Modelle und Konfigurationen gespeichert. So bleiben sie auch erhalten, wenn du den Container neu erstellst. Ich persönlich lege diesen Ordner gerne auf eine separate Partition, wenn ich viel mit Modellen experimentiere.
environment: - OLLAMA_HOST=0.0.0.0: Das ist ein wichtiger Tipp! Standardmäßig bindet Ollama nur an localhost. Wenn du von anderen Geräten in deinem Netzwerk (z.B. Home Assistant, n8n) auf die Ollama-API zugreifen möchtest, musst du es an alle Schnittstellen binden.
deploy: resources: ...: Dieser Block ist nur nötig, wenn du eine NVIDIA GPU hast und diese nutzen möchtest. Er weist dem Docker-Container alle verfügbaren NVIDIA-GPUs zu. Wenn du keine GPU hast oder sie nicht nutzen möchtest, lass diesen Block einfach weg.

Speichere die Datei und starte den Container im Verzeichnis ~/ollama:

cd ~/ollama
docker compose up -d

Du kannst mit docker logs ollama prüfen, ob der Container erfolgreich gestartet ist. Wenn alles glattgeht, siehst du Meldungen wie "Listening on 0.0.0.0:11434".

Erste Schritte mit destillierten Modellen

Jetzt, wo Ollama läuft, können wir die ersten Modelle herunterladen und damit interagieren. Ollama macht das erstaunlich einfach. Du kannst entweder direkt im Container arbeiten oder den Ollama-Client auf deinem Host installieren (was ich persönlich bevorzuge, da es flexibler ist).

1. Ollama CLI auf dem Host installieren (optional, aber empfohlen)

Wenn du den Ollama-Client auf deinem Host installierst, kannst du direkt von deinem Terminal aus mit den Modellen interagieren, ohne in den Docker-Container springen zu müssen. Die Kommunikation läuft dann über den Port 11434.

curl -fsSL https://ollama.com/install.sh | sh

Nach der Installation kannst du prüfen, ob der Client funktioniert:

ollama --version

2. Modelle herunterladen und nutzen

Es gibt eine riesige Auswahl an Modellen auf der Ollama Library. Für den Anfang empfehle ich dir, mit kleineren, destillierten Modellen zu experimentieren, die gut auf CPUs laufen oder wenig VRAM benötigen.

Mistral: Ein sehr leistungsfähiges und effizientes Modell. Die 7B-Version ist ein guter Start.
Llama 3 (8B): Die neueste Generation von Meta, auch in kleineren, optimierten Varianten erhältlich.
Phi-3-mini: Ein extrem kleines, aber überraschend fähiges Modell von Microsoft, ideal für ressourcenbeschränkte Umgebungen.

Um ein Modell herunterzuladen und direkt damit zu chatten, nutze den ollama run Befehl:

ollama run mistral # Lädt Mistral und startet einen Chat
# Oder:
ollama run llama3 # Lädt Llama 3 und startet einen Chat
# Oder:
ollama run phi3-mini # Lädt Phi-3-mini und startet einen Chat

Wenn du das zum ersten Mal machst, wird Ollama das Modell herunterladen (was je nach Modellgröße und Internetgeschwindigkeit ein paar Minuten dauern kann). Danach startet ein interaktiver Chat, in dem du direkt Fragen stellen kannst. Probiere es aus: "Was ist der Sinn des Lebens?" oder "Erkläre mir Quantenverschränkung in einfachen Worten."

Um den Chat zu verlassen, gib /bye ein.

Du kannst auch die verfügbaren Modelle auflisten:

ollama list

Integration in dein Heimlabor: n8n, Home Assistant & Co.

Der eigentliche Spaß beginnt, wenn du deine lokalen LLMs in deine Automatisierungen integrierst. Hier sind ein paar Ideen, wie du die Ollama-API nutzen kannst:

n8n

Mit n8n kannst du leistungsstarke Workflows erstellen. Die Ollama-API ist eine einfache REST-API, die du über den HTTP-Request Node ansprechen kannst.

Endpunkt: http://<Deine-Ollama-IP>:11434/api/generate
Methode: POST

Body (JSON):

{
  "model": "mistral",
  "prompt": "Fasse den folgenden Text zusammen: {{ $json.text_to_summarize }}",
  "stream": false
}

Stell dir vor: Du parsest RSS-Feeds oder E-Mails, schickst den Inhalt an dein lokales LLM zur Zusammenfassung und lässt dir die Essenz per Telegram oder E-Mail schicken. Oder du lässt dir automatisch Antworten auf bestimmte Anfragen generieren. Die Möglichkeiten sind endlos!

Home Assistant

Auch Home Assistant kann von einem lokalen LLM profitieren. Du könntest zum Beispiel:

RESTful Command: Erstelle einen RESTful Command, der die Ollama-API aufruft, um Text zu generieren. Diesen kannst du dann in Automatisierungen nutzen.

# configuration.yaml
rest_command:
  ollama_generate:
    url: "http://<Deine-Ollama-IP>:11434/api/generate"
    method: post
    payload: '{"model": "mistral", "prompt": "{{ prompt }}", "stream": false}'
    content_type: "application/json"
    verify_ssl: false

Command Line Sensor: Für einfachere Abfragen, die nicht viel Kontext benötigen.
Custom Integration: Für fortgeschrittene Nutzer gibt es sicherlich Möglichkeiten, eine tiefergehende Integration zu entwickeln.

Stell dir vor, du fragst dein Home Assistant: "Was muss ich heute erledigen?" und ein LLM generiert basierend auf deinem Kalender und Wetter eine To-Do-Liste. Oder es hilft dir, komplexe Sprachbefehle zu interpretieren.

Netzwerk-Basics für den sicheren Betrieb

Ein lokales LLM ist großartig, aber wir wollen es auch sicher betreiben.

1. Feste IP-Adresse

Gib deinem Ollama-Host (oder der VM) eine feste IP-Adresse. Das erleichtert die Integration in andere Dienste und die Firewall-Konfiguration. Das machst du entweder über deinen Router (DHCP-Reservierung) oder direkt in der Netzwerkkonfiguration deines Linux-Systems.

2. Firewall-Regeln (UFW)

Öffne nur die Ports, die du wirklich brauchst. Für Ollama ist das in der Regel Port 11434. Wenn du UFW (Uncomplicated Firewall) nutzt, geht das sehr einfach.

sudo ufw allow 11434/tcp comment "Allow Ollama API"
sudo ufw enable # Falls noch nicht aktiv
sudo ufw status # Prüfen, ob die Regel aktiv ist

Mein Tipp: Wenn du nur von bestimmten Geräten in deinem Netzwerk auf Ollama zugreifen willst, kannst du die Regel noch spezifischer gestalten, z.B. sudo ufw allow from 192.168.1.100 to any port 11434.

3. Reverse Proxy (optional)

Wenn du Ollama über eine Subdomain (z.B. llm.deine-domain.de) oder mit SSL/TLS von extern zugänglich machen möchtest, solltest du einen Reverse Proxy wie Nginx oder Caddy davor schalten. Dies ist ein fortgeschrittener Schritt und sprengt den Rahmen dieses Guides, aber es ist wichtig, die Möglichkeit zu kennen.

Häufige Fehler und Lösungen

Wie bei jeder neuen Einrichtung gibt es Stolpersteine. Hier sind ein paar, über die ich selbst gestolpert bin oder die ich oft in der Community sehe:

1. "Ollama startet nicht oder kann keine Modelle laden."

Problem: Der Ollama-Container läuft nicht, oder beim Versuch, ein Modell zu laden, gibt es Fehler.
Mögliche Ursachen:
- Fehlende AVX2-Unterstützung: Deine CPU ist zu alt oder die VM ist falsch konfiguriert (z.B. QEMU/KVM CPU-Typ "host" nicht gesetzt).
- Nicht genug RAM: Das Modell ist zu groß für den verfügbaren Speicher.
- Docker-Probleme: Der Docker-Daemon läuft nicht oder der Container hat ein Problem.
Lösungen:
- AVX2 prüfen: Führe lscpu | grep avx2 auf deinem Host (oder in der VM) aus. Wenn nichts zurückkommt, ist deine CPU nicht kompatibel oder die VM-Konfiguration muss angepasst werden.
- RAM prüfen: Mit free -h kannst du den verfügbaren RAM sehen. Versuche, ein kleineres Modell zu laden oder erhöhe den RAM deiner VM.
- Docker-Logs: Prüfe die Logs deines Ollama-Containers mit docker logs ollama. Das gibt oft den entscheidenden Hinweis. Ist Docker überhaupt aktiv? sudo systemctl status docker.

2. "GPU wird nicht genutzt oder Performance ist schlecht."

Problem: Modelle laufen langsam, obwohl eine GPU vorhanden ist, oder nvidia-smi zeigt keine Auslastung durch Ollama.
Mögliche Ursachen:
- Falsche/fehlende NVIDIA-Treiber: Die Treiber sind nicht korrekt installiert oder nicht die richtige Version.
- Fehlendes nvidia-container-toolkit: Docker weiß nicht, wie es auf die GPU zugreifen soll.
- Docker Compose Config falsch: Der deploy: resources: Block fehlt oder ist fehlerhaft.
- GPU-Passthrough in Proxmox nicht korrekt: Wenn du eine GPU in eine VM durchschleifst, kann das eine eigene Fehlerquelle sein.
Lösungen:
- Treiber prüfen: nvidia-smi sollte funktionieren.
- Container Toolkit: Stelle sicher, dass nvidia-container-toolkit installiert und Docker neu gestartet wurde (sudo systemctl restart docker).
- Docker Info: docker info | grep -i runtime sollte nvidia als Runtime anzeigen.
- Docker Compose: Überprüfe den docker-compose.yml auf Tippfehler im deploy: resources: Block.
- Proxmox Passthrough: Prüfe die Proxmox-Doku für GPU-Passthrough. Das ist ein komplexes Thema, aber entscheidend für die Performance in VMs.

3. "Zugriff von anderen Geräten im Netzwerk nicht möglich."

Problem: Du kannst von deinem PC oder n8n nicht auf die Ollama-API zugreifen, obwohl der Container läuft.
Mögliche Ursachen:
- Firewall: Die Firewall auf deinem Linux-Host blockiert den Port 11434.
- Ollama an localhost gebunden: Der OLLAMA_HOST-Parameter in der Docker Compose ist nicht korrekt gesetzt.
- Falsche IP-Adresse: Du versuchst, eine falsche IP-Adresse anzusprechen.
Lösungen:
- Firewall prüfen: sudo ufw status sollte zeigen, dass Port 11434 erlaubt ist. Temporär kannst du UFW auch deaktivieren (sudo ufw disable) zum Testen, aber danach unbedingt wieder aktivieren!
- OLLAMA_HOST: Stelle sicher, dass in deiner docker-compose.yml der Eintrag - OLLAMA_HOST=0.0.0.0 unter environment: vorhanden ist. Danach docker compose down && docker compose up -d ausführen.
- Ping & IP: Prüfe, ob du den Ollama-Host von deinem Client aus pingen kannst und ob du die korrekte IP-Adresse verwendest.

Fazit und nächste Schritte

Glückwunsch! Du hast jetzt eine robuste Umgebung in deinem Heimlabor, um destillierte Large Language Models effizient zu betreiben. Du hast nicht nur die Kontrolle über deine Daten behalten, sondern auch eine flexible Plattform geschaffen, die du in unzählige Projekte integrieren kannst.

Die Welt der LLMs ist riesig und entwickelt sich ständig weiter. Dein nächster Schritt könnte sein, mit verschiedenen Modellen aus der Ollama Library zu experimentieren. Probiere verschiedene Größen und Architekturen aus, um herauszufinden, welche am besten zu deinen Anwendungsfällen passen. Vielleicht möchtest du auch tiefer in die Integration mit n8n oder Home Assistant eintauchen und komplexe Automatisierungen bauen.

Scheue dich nicht, deine Erfahrungen in der smoth.me Community zu teilen. Welche Modelle findest du besonders nützlich? Welche coolen Automatisierungen hast du gebaut? Wir lernen alle voneinander!