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

Cloud-Assistenten wie GitHub Copilot übertragen Quellcode an externe Server; bei Datenschutzvorgaben oder Kundencode ist das oft nicht zulässig. Tabby von TabbyML ist ein selbst gehosteter KI-Coding-Assistent, der als Docker-Container auf Ihrer eigenen Infrastruktur läuft und in VS Code, JetBrains-IDEs sowie Vim/Neovim Vorschläge liefert. Code, Modelle und Konfiguration bleiben auf Ihrem Server. Tabby steht unter Apache-2.0-Lizenz; aktuelle Version ist 0.32.0 vom Januar 2026. Diese Anleitung richtet Tabby mit Docker Compose auf einem Linux-Server ein.

Voraussetzungen

1. Docker Engine 24.0+ mit Docker Compose Plugin v2, siehe 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.
6. Für den Zugriff von anderen Rechnern: Reverse Proxy mit HTTPS, z. B. Traefik als Docker-Reverse-Proxy.

Schritt 1: Projektordner anlegen

Legen Sie einen Ordner für die Konfigurationsdateien an. Die Daten liegen später im Docker-Volume tabby-data.

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

Verifizieren: pwd gibt /opt/tabby aus.

Schritt 2: .env-Datei erstellen

Die .env enthält einen Eintrag, der die anonyme Nutzungsstatistik abschaltet:

# /opt/tabby/.env
TABBY_DISABLE_USAGE_COLLECTION=1

Ohne diesen Eintrag sendet Tabby anonyme Nutzungsdaten an den Hersteller. Die Einstellung ist in der Datei dokumentiert und damit für Datenschutz-Nachweise belegbar.

Verifizieren:

cat /opt/tabby/.env

Ausgabe: TABBY_DISABLE_USAGE_COLLECTION=1

Schritt 3: compose.yaml erstellen

Erstellen Sie /opt/tabby/compose.yaml in einer der beiden Varianten.

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

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

volumes:
  tabby-data:
    driver: local

--model legt das Modell für die Code-Vervollständigung fest; StarCoder-1B ist klein und schnell. --chat-model aktiviert zusätzlich den Chat. Die CPU-Variante startet über entrypoint die CPU-Programmdatei im Image; --device cpu allein genügt dafür nicht. Der deploy-Block setzt das NVIDIA Container Toolkit voraus, ohne es bricht der Start mit einer Fehlermeldung zum Gerätetreiber ab. Port 8080 ist nur lokal erreichbar; andere Rechner greifen über den Reverse Proxy zu. Auf SELinux-Hosts (RHEL, Fedora) ergänzen Sie am Volume :Z. Der Healthcheck nutzt curl, das im Image enthalten ist.

Verifizieren:

cat /opt/tabby/compose.yaml

Syntax prüfen:

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

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

Schritt 4: Container starten

Starten Sie Tabby im Projektordner:

cd /opt/tabby
docker compose up -d

Docker lädt das Image und startet den Container. Beim ersten Start lädt Tabby das Modell herunter, je nach Verbindung 5 bis 20 Minuten. Bis dahin meldet der Healthcheck starting oder unhealthy.

Fortschritt verfolgen:

docker compose logs -f tabby

Der Server ist bereit, sobald das Log meldet, dass Tabby auf 0.0.0.0:8080 lauscht (innerhalb des Containers).

Verifizieren:

docker compose ps

Erwartete Ausgabe (nach vollständigem Start):

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

Health-Endpunkt prüfen:

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

Erwartet wird ein JSON-Objekt mit Angaben zu Modell und Gerät.

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

Öffnen Sie http://localhost:8080 auf dem Server (per SSH-Tunnel ssh -L 8080:127.0.0.1:8080 user@server) oder die HTTPS-Adresse Ihres Reverse Proxys. Beim ersten Aufruf legen Sie ein Konto mit E-Mail und Passwort an; das erste Konto erhält die Rolle Owner. Legen Sie das Konto sofort an, bevor andere die Seite erreichen.

Die Startseite zeigt danach Endpoint und Token für die IDE-Anbindung. Weitere Teammitglieder laden Sie unter Settings > Members ein.

Verifizieren: Nach der Anmeldung zeigt die Startseite Endpoint und Token Ihres Kontos.

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

Tabby bietet Erweiterungen für VS Code, JetBrains-IDEs und Vim/Neovim. Alle nutzen Endpoint und Token von der Startseite.

VS Code:

1. Installieren Sie die Erweiterung TabbyML.vscode-tabby aus dem Marketplace.
2. Tragen Sie in den Einstellungen der Erweiterung den Endpoint ein, z. B. https://tabby.example.de.
3. Auf den Hinweis zum fehlenden Token klicken Sie Set Credentials und fügen den Token ein.

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

Verifizieren: Die Statusleiste der IDE zeigt das Tabby-Symbol als verbunden. Tippen Sie in einer Funktion einige Zeichen: Nach wenigen Sekunden erscheint ein grauer Vorschlag, den Sie mit Tab übernehmen.

Schritt 7: Updates und Backup

Sichern Sie vor einem Update das Volume (siehe unten). Tragen Sie dann in der compose.yaml die neue Version aus den Release Notes auf GitHub ein und führen Sie aus:

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

Die Daten im Volume tabby-data bleiben erhalten; eine nötige Datenbankmigration läuft beim Start automatisch.

Backup: Stoppen Sie Tabby mit docker compose stop, sichern Sie das Volume und starten Sie wieder mit docker compose start:

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

Für eine vollständige Backup-Strategie siehe 3-2-1-Backup-Strategie umsetzen.

Verifizieren:

docker compose ps

STATUS zeigt wieder Up (healthy), die Spalte IMAGE den neuen Tag.

Troubleshooting / Typische Fehler

1. Healthcheck schlägt beim ersten Start fehl: Tabby lädt noch das Modell. Mit docker compose logs -f tabby verfolgen und warten.
2. „could not select device driver nvidia“ oder GPU nicht erkannt: Das NVIDIA Container Toolkit fehlt oder ist nicht eingerichtet. Lösung: sudo nvidia-ctk runtime configure --runtime=docker && sudo systemctl restart docker, dann docker compose up -d.
3. Port 8080 belegt: Prüfen mit ss -tlnp | grep 8080, dann den Host-Port ändern, z. B. "127.0.0.1:8090:8080".
4. Permission denied am Volume (SELinux): tabby-data:/data:Z eintragen.
5. Kein Modell-Download ohne Internet: Modelle vorab in /data/models/ im Volume ablegen, siehe Tabby-Doku zum Offline-Betrieb.
6. IDE verbindet sich nicht: Endpoint muss vom Arbeitsplatz erreichbar sein (Reverse Proxy, nicht localhost des Servers); Token von der Startseite neu kopieren. Ohne gültigen Token antwortet der Server mit HTTP 401.
7. Kein GPU-Betrieb trotz Konfiguration: Mit docker exec tabby nvidia-smi prüfen, ob der Container die Karte sieht; sonst Toolkit wie oben einrichten.
8. Zu wenig Speicherplatz: df -h /var/lib/docker prüfen, dort liegt das Volume.

Häufige Fragen

Welche Mindest-Hardware brauche ich?

Für GPU-Betrieb eine NVIDIA-Karte mit mindestens 6 GB VRAM für StarCoder-1B. Ohne GPU mindestens 8 GB RAM bei deutlich längeren Antwortzeiten; für CPU-Systeme bietet das Projekt zusätzlich eine Linux-Programmdatei an.

Wie verbinde ich VSCode mit meinem Tabby-Server?

Erweiterung TabbyML.vscode-tabby installieren, Endpoint eintragen und den Token von der Tabby-Startseite über Set Credentials hinterlegen (Schritt 6).

Kann ich externe Modelle wie Ollama oder OpenAI verwenden?

Ja. In /data/config.toml im Volume tragen Sie HTTP-Backends ein, etwa Ollama oder OpenAI-kompatible Dienste; ein lokaler Modell-Download entfällt dann. Kombinationen sind möglich, z. B. lokale Vervollständigung und externes Chat-Modell. Bei externen Diensten verlässt Code den Server.

Wie aktualisiere ich Tabby auf eine neue Version?

Neue Version in der compose.yaml eintragen, dann docker compose pull && docker compose up -d (Schritt 7). Die Daten im Volume bleiben erhalten. Ohne Tag würde Docker latest laden, das bei Tabby auch Vorabversionen enthalten kann.

Ist Tabby DSGVO-konform nutzbar?

Mit lokalen Modellen verlässt kein Code Ihren Server. Die Nutzungsstatistik schalten Sie mit TABBY_DISABLE_USAGE_COLLECTION=1 ab; die Einstellung ist in der .env dokumentiert. Die rechtliche Bewertung Ihres Einsatzes ersetzt das nicht.

Wie richte ich Team-Authentifizierung ein?

Tabby hat eine eigene Benutzerverwaltung. Unter Settings > Members laden Sie Nutzer ein. Anmeldung über LDAP oder OAuth (GitHub, GitLab) ist je nach Lizenzstufe möglich; prüfen Sie den Umfang in der Tabby-Dokumentation.

Kann Tabby meinen Projektcode als Kontext verwenden?

Ja. Tabby indiziert Git-Repositories und nutzt sie als Kontext für Vorschläge. Repositories binden Sie in der Weboberfläche unter Settings ein.

Fazit

Tabby bietet Code-Vervollständigung und Chat, ohne dass Quellcode den eigenen Server verlässt. Voraussetzung für flüssige Arbeit ist eine GPU mit ausreichend VRAM. Mit festem Image-Tag, lokal gebundenem Port hinter einem HTTPS-Proxy und regelmäßiger Sicherung des Volumes ist der Betrieb im Team gut beherrschbar. Seit dem Release 0.32.0 im Januar 2026 ist keine neue stabile Version erschienen; prüfen Sie vor dem Einsatz den Projektstand auf GitHub.

Für ein lokales Sprachmodell für Chat und Dokumente siehe Ollama und Open WebUI mit Docker . Zur Absicherung des Stacks: 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)