Tabby mit Docker installieren: Selbstgehosteter KI-Coding-Assistent als Copilot-Ersatz

GitHub Copilot schickt deinen Code in die Cloud – bei einem Team mit Datenschutzanforderungen oder unter DSGVO-Auflagen ist das oft keine Option. Tabby (TabbyML) ist die Open-Source-Antwort darauf: ein vollständig selbst gehosteter KI-Coding-Assistent, der als Docker-Container auf deiner eigenen Infrastruktur läuft und mit VSCode, JetBrains-IDEs sowie Vim Inline-Vorschläge liefert. Alle Daten – Code, Modelle, Konfiguration – bleiben On-Premises. Das Projekt ist mit über 33.600 Stars auf GitHub aktiv gepflegt (v0.32.0, Januar 2026, primär in Rust geschrieben), Apache-2.0-lizenziert und damit auch kommerziell nutzbar. Diese Anleitung führt dich Schritt für Schritt durch das Setup mit Docker Compose auf einem generischen Linux-Host.

Voraussetzungen

1. Docker Engine 24.0+ mit Docker Compose Plugin v2 – falls noch nicht installiert, folge der Anleitung Docker und Docker Compose auf Linux installieren.
2. Linux-Host (x86_64, Ubuntu 22.04/24.04 oder Debian 12 empfohlen), VM oder NAS mit Docker-Unterstützung.
3. Mindestens 20 GB freier Festplattenspeicher – Modelle belegen 1 bis 10+ GB im persistenten Volume.
4. Für GPU-Betrieb: NVIDIA-GPU mit 6+ GB VRAM und NVIDIA Container Toolkit (nvidia-ctk) installiert und konfiguriert.
5. Internetzugang für den ersten Modell-Download (Air-Gap-Setup ist möglich, aber nicht Gegenstand dieser Anleitung).
6. curl auf dem Host für Healthcheck-Verifikation.
7. Optional: Reverse Proxy (Nginx, Traefik oder Caddy) für HTTPS-Zugriff von außen – siehe Traefik als Docker-Reverse-Proxy.

Schritt 1: Projektordner anlegen

Lege einen eigenen Ordner für das Tabby-Projekt an. Alle Konfigurationsdateien landen hier; Docker-Volumes werden separat verwaltet.

mkdir -p /opt/tabby
cd /opt/tabby

Verifizieren: ls /opt/tabby gibt ein leeres Verzeichnis zurück. Du kannst auch pwd ausführen – erwartet wird /opt/tabby.

Schritt 2: .env-Datei erstellen

Die .env-Datei enthält Umgebungsvariablen, die Compose automatisch einliest. Für den Grundbetrieb genügt ein einziger Eintrag: die Deaktivierung der anonymen Telemetrie.

# /opt/tabby/.env
TABBY_DISABLE_USAGE_COLLECTION=1

Tabby sendet standardmäßig anonyme Nutzungsstatistiken nach Hause. Das Flag deaktiviert diese Funktion vollständig – sinnvoll in DSGVO-sensiblen Umgebungen und für Datenschutz-Audits dokumentierbar.

Verifizieren:

cat /opt/tabby/.env

Ausgabe: TABBY_DISABLE_USAGE_COLLECTION=1

Schritt 3: compose.yaml erstellen

Erstelle die Datei /opt/tabby/compose.yaml. Die Datei enthält zwei Varianten – GPU und CPU. Aktiviere je nach deiner Hardware den passenden Block.

Variante A: Mit NVIDIA-GPU (empfohlen für Produktivbetrieb)

services:
  tabby:
    image: registry.tabbyml.com/tabbyml/tabby
    container_name: tabby
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - tabby-data:/data
    env_file:
      - .env
    command: >
      serve
      --model StarCoder-1B
      --chat-model Qwen2-1.5B-Instruct
      --device cuda
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/v1/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 120s

volumes:
  tabby-data:
    driver: local

Variante B: CPU-only (für Tests oder Umgebungen ohne GPU – langsamer, aber funktional)

services:
  tabby:
    image: registry.tabbyml.com/tabbyml/tabby
    container_name: tabby
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - tabby-data:/data
    env_file:
      - .env
    command: >
      serve
      --model StarCoder-1B
      --device cpu
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/v1/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 120s

volumes:
  tabby-data:
    driver: local

Hinweise zur Konfiguration: Das --model-Flag ist Pflicht; StarCoder-1B ist ein guter Einstieg (kleiner Download, schnelle Inferenz). Das optionale --chat-model-Flag aktiviert den Chat-Assistenten zusätzlich zur Code-Vervollständigung. Der deploy-Block wird nur bei aktivem NVIDIA Container Toolkit ausgewertet – ohne GPU-Toolkit wird er stillschweigend ignoriert. Für SELinux-Hosts (RHEL, CentOS, Fedora) ergänze das Volume-Mapping um das :Z-Flag: tabby-data:/data:Z in compose.yaml.

Verifizieren:

cat /opt/tabby/compose.yaml

Die Datei muss syntaktisch korrekt sein. Eine schnelle Prüfung geht mit:

docker compose -f /opt/tabby/compose.yaml config

Erwartet wird die aufgelöste Compose-Konfiguration ohne Fehlermeldung.

Schritt 4: Container starten

Wechsle in den Projektordner und starte Tabby im Hintergrund:

cd /opt/tabby
docker compose up -d

Docker pulled jetzt das Image (~1,6 GB) und startet den Container. Beim ersten Start lädt Tabby automatisch das konfigurierte Modell herunter – rechne mit 5 bis 20 Minuten je nach Verbindungsgeschwindigkeit und Modellgröße. Der Healthcheck schlägt in dieser Zeit fehl; das ist normal.

Fortschritt des Modell-Downloads verfolgen:

docker compose logs -f tabby

Warte, bis du eine Zeile wie http://0.0.0.0:8080 in den Logs siehst – dann ist der Server bereit.

Verifizieren:

docker compose ps

Erwartete Ausgabe (nach vollständigem Start):

NAME    IMAGE                                  COMMAND   SERVICE   STATUS              PORTS
tabby   registry.tabbyml.com/tabbyml/tabby    ...       tabby     Up (healthy)        0.0.0.0:8080->8080/tcp

Zusätzlich per curl den Health-Endpunkt prüfen:

curl -s http://localhost:8080/v1/health

Erwartete Antwort: JSON-Objekt mit "device" und "model"-Feldern, z. B. {"device":"cuda","model":"StarCoder-1B"}.

Schritt 5: Web-UI öffnen und Admin-Account anlegen

Öffne im Browser die Adresse http://<server-ip>:8080. Beim ersten Aufruf fordert Tabby dich auf, einen Admin-Account mit E-Mail und Passwort zu erstellen. Dieser erste Account erhält automatisch Administratorrechte.

Nach der Registrierung siehst du das Tabby-Dashboard mit:

1. Models: aktiv geladene Completion- und Chat-Modelle
2. Settings > API Tokens: hier generierst du den Token für IDE-Plugins
3. Settings > Auth: Benutzerverwaltung, LDAP-Anbindung, GitHub/GitLab OAuth
4. Settings > Network: Subscription-Verwaltung für Team-Features

Lege unter Settings > API Tokens sofort einen Token für die IDE-Verbindung an. Notiere den Wert – er wird nur einmalig vollständig angezeigt.

Verifizieren: Das Dashboard ist erreichbar, der Admin-Account wurde angelegt, und unter Models zeigt Tabby das geladene Completion-Modell als aktiv an.

Schritt 6: IDE-Plugin verbinden (VSCode als Beispiel)

Tabby bietet offizielle Plugins für VSCode, alle JetBrains-IDEs sowie Vim/Neovim. Die Verbindung läuft immer über dieselbe Server-URL und den zuvor generierten Auth-Token.

VSCode:

1. Öffne den Marketplace und suche nach TabbyML.vscode-tabby – oder installiere direkt über die Extension-ID.
2. Öffne die Command Palette (Strg+Umschalt+P) und führe Tabby: Connect to Server… aus.
3. Trage die Server-URL ein: http://<server-ip>:8080
4. Füge den API-Token aus Schritt 5 ein.
5. Öffne eine Code-Datei – nach kurzer Verzögerung erscheinen graue Inline-Vorschläge.

JetBrains-IDEs (IntelliJ, PyCharm, GoLand usw.): Plugin Tabby im JetBrains Marketplace installieren, dann unter Settings > Tools > Tabby Server-URL und Token eintragen.

Verifizieren: In VSCode zeigt die Statusleiste unten „Tabby: Connected" an. Tippe in einer Funktion einige Zeichen – nach 1 bis 3 Sekunden erscheint ein grauer Inline-Vorschlag, den du mit Tab übernimmst.

Schritt 7: Updates und Backup

Tabby wird aktiv gepflegt; Updates bringen neue Modelle, Bugfixes und Performance-Verbesserungen. Das Update-Verfahren ist der Docker-Standard:

cd /opt/tabby
docker compose pull
docker compose up -d

Alle Daten im Volume tabby-data (Modelle, Datenbank, config.toml) bleiben erhalten. Beim ersten Start nach einem Update wird ggf. die interne Datenbank migriert – die Logs zeigen dabei entsprechende Meldungen.

Backup: Das gesamte persistente Volume lässt sich mit einem einzigen Befehl sichern:

docker run --rm \
  -v tabby-data:/data:ro \
  -v /backup:/backup \
  busybox \
  tar czf /backup/tabby-data-$(date +%Y%m%d).tar.gz /data

Für eine durchgängige Backup-Strategie empfiehlt sich die Anleitung 3-2-1-Backup-Strategie umsetzen.

Verifizieren:

docker compose ps

Nach dem Update: Spalte STATUS zeigt wieder Up (healthy). Version im Log prüfen:

docker compose logs tabby | grep -i version

Troubleshooting / Typische Fehler

1. Healthcheck schlägt beim ersten Start fehl – kein Fehler: Tabby lädt das Modell beim ersten Start herunter (5 bis 20 Minuten). Fortschritt verfolgen: docker compose logs -f tabby. Warten, bis „http://0.0.0.0:8080" in den Logs erscheint.
2. „nvidia driver not found" oder GPU wird nicht erkannt – das NVIDIA Container Toolkit fehlt oder wurde nach der Docker-Installation nicht konfiguriert. Lösung: nvidia-ctk runtime configure --runtime=docker && systemctl restart docker, dann docker compose up -d erneut.
3. Port 8080 bereits belegt – Jenkins, andere Web-Apps oder lokale Dienste nutzen diesen Port häufig. Prüfen: ss -tlnp | grep 8080. Abhilfe: in compose.yaml den Host-Port ändern, z. B. "8090:8080".
4. Permission denied beim Volume-Schreibzugriff (SELinux) – auf RHEL/CentOS/Fedora muss das Volume-Mapping das :Z-Flag tragen: tabby-data:/data:Z in compose.yaml.
5. Modell-Download schlägt still fehl (Air-Gapped-Umgebung) – ohne Internetzugang startet Tabby, aber es werden keine Vorschläge geliefert. Modelle müssen vorab in /data/models/ im Volume platziert werden (offizielle Air-Gap-Doku beachten).
6. IDE-Plugin verbindet sich nicht – nach Aktivierung der Authentifizierung in der Web-UI muss ein gültiger Token unter Settings > API Tokens generiert und im Plugin-Feld eingetragen sein. Ohne Token schlägt die Verbindung mit HTTP 401 fehl.
7. Deploy-Block wird ignoriert (kein GPU-Betrieb trotz Konfiguration) – der deploy.resources.reservations-Block setzt das NVIDIA Container Toolkit voraus. Mit docker compose --compatibility up -d erzwingen oder nvidia-smi im Container prüfen: docker exec tabby nvidia-smi.
8. Zu wenig Speicherplatz – Modelle belegen 1 bis 10+ GB. Platzbedarf vorab prüfen: df -h /opt/tabby. Mindestens 20 GB frei einplanen.

Häufige Fragen

Welche Mindest-Hardware brauche ich?

Für GPU-Betrieb: NVIDIA-Karte mit mindestens 6 GB VRAM (z. B. RTX 3060) für das StarCoder-1B-Modell. Für CPU-only: mindestens 8 GB RAM, allerdings sind die Antwortzeiten deutlich länger. Das Tabby-Projekt empfiehlt ab Version v0.30.0 für reine CPU-Umgebungen die Linux-Binary statt des Docker-Images, da das Image primär auf GPU-Betrieb optimiert ist.

Wie verbinde ich VSCode mit meinem Tabby-Server?

Extension TabbyML.vscode-tabby aus dem Marketplace installieren, dann in der Command Palette (Strg+Umschalt+P) den Befehl Tabby: Connect to Server… ausführen, die Server-URL http://<server-ip>:8080 eintragen und den API-Token aus der Web-UI unter Settings > API Tokens einfügen.

Kann ich externe Modelle wie Ollama oder OpenAI verwenden?

Ja. In der Datei /data/config.toml (im Container, persistent im Volume) können HTTP-Remote-Backends konfiguriert werden – Ollama als lokaler Proxy, OpenAI API, Mistral oder andere OpenAI-kompatible Dienste. In diesem Fall wird kein lokaler Modell-Download benötigt. API-Keys gehören in config.toml, nicht in Umgebungsvariablen. Eine Kombination ist möglich: lokales Completion-Modell + Remote-Chat-Modell.

Wie aktualisiere ich Tabby auf eine neue Version?

docker compose pull && docker compose up -d – die Daten im Volume bleiben vollständig erhalten. Da kein spezifischer stabiler Tag in der offiziellen Doku empfohlen wird, zieht der Standard-Tag immer das aktuelle Release. Wer lieber pinnt: nach dem ersten Pull den aktuellen Image-Digest mit docker inspect registry.tabbyml.com/tabbyml/tabby | grep -i digest notieren und in compose.yaml eintragen.

Ist Tabby DSGVO-konform nutzbar?

Ja, im selbst gehosteten Betrieb verlassen keinerlei Code-Daten deinen Server. Die anonyme Telemetrie deaktivierst du mit TABBY_DISABLE_USAGE_COLLECTION=1 in der .env-Datei. Das macht die Deaktivierung auditierbar und dokumentierbar – relevant für Datenschutz-Management-Systeme und DSGVO-Nachweise gegenüber Kunden oder Behörden.

Wie richte ich Team-Authentifizierung ein?

Tabby bringt eine eigene Benutzerverwaltung mit. Unter Settings > Auth in der Web-UI lassen sich lokale Nutzer anlegen, ein LDAP-Server anbinden oder OAuth über GitHub und GitLab konfigurieren – kein externer Identity-Provider nötig. Für größere Teams mit bestehendem Active Directory bietet sich die LDAP-Integration an.

Kann Tabby meinen Projektcode als Kontext verwenden?

Ja. Tabby unterstützt Repository-Kontext (RAG-ähnlich): Lokale Git-Repositories werden indiziert und liefern projektspezifischen Kontext für Code-Vorschläge. Die Konfiguration erfolgt über config.toml im persistenten Volume. Das macht die Vorschläge erheblich relevanter als bei einem generischen Modell ohne Codebasis-Wissen.

Fazit

Tabby ist einer der ausgereiftesten selbst gehosteten KI-Coding-Assistenten und ein ernstzunehmender Copilot-Ersatz für Teams mit Datenschutzanforderungen. Das Docker-Setup ist in 25 Minuten betriebsbereit, das persistente Volume sichert alle Modelle und Einstellungen, und die IDE-Plugins für VSCode sowie JetBrains sind in Minuten verbunden. Der einzige ehrliche Trade-off: Für produktiven GPU-Betrieb braucht es Hardware mit ausreichend VRAM – auf reinen CPU-Systemen empfiehlt das Projekt selbst ab v0.30.0 die Linux-Binary statt Docker. Wer bereits einen GPU-Server oder eine leistungsfähige VM betreibt, bekommt mit Tabby eine vollständig on-premises betriebene Lösung, die keine Nutzerdaten nach außen überträgt und DSGVO-konform dokumentiert werden kann.

Wer neben Code-Completion auch ein vollständiges lokales Sprachmodell für Chat und Dokumentenanalyse aufsetzen möchte, findet in der Anleitung Ollama und Open WebUI mit Docker den passenden nächsten Schritt. Für die Absicherung des Docker-Stacks im Produktivbetrieb empfiehlt sich außerdem Docker Compose absichern: Secrets, Healthchecks und Non-Root.

Weiterführende Anleitungen und Quellen

1. Docker und Docker Compose auf Linux installieren – die Self-Hosting-Grundlage
2. Ollama und Open WebUI mit Docker: eigenes lokales KI-Sprachmodell ohne Cloud
3. Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only
4. Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten
5. 3-2-1-Backup-Strategie umsetzen: Anleitung mit Restic, USB-Disk und S3-Cloud

Quellen: Tabby Offizielle Dokumentation: Docker Installation | Tabby Offizielle Dokumentation: Docker Compose | GitHub: TabbyML/tabby | Docker Hub: tabbyml/tabby | Tabby Modell-Konfiguration (config.toml)