Tabby — Lokaler KI-Code-Assistent als GitHub Copilot-Alternative

Das Problem mit Cloud-basierten Code-Assistenten:

Jedes Mal wenn du in VS Code tippst und GitHub Copilot aktiv ist, werden Code-Snippets an Microsoft gesendet — inklusive:

• Dateinamen und Pfade
• Umgebender Code (Kontext)
• Kommentare und Dokumentation
• Möglicherweise API-Keys und Secrets in Nachbar-Dateien

Tabby vs. GitHub Copilot — direkter Vergleich:

Feature	GitHub Copilot	Tabby (selbst gehostet)
Kosten	10-19 $/Monat	0 € (Open Source)
Datenschutz	Code geht an Microsoft	Code bleibt lokal
DSGVO	Problematisch	✅ Konform
Auto-Completion	✅ Sehr gut	✅ Gut (modellabhängig)
Chat-Funktion	✅	✅
Code-Erklärungen	✅	✅
Repository-Kontext	✅ (Workspace)	✅ (Indexierung)
VS Code	✅	✅
JetBrains	✅	✅
Vim/Neovim	✅	✅
Modell-Auswahl	GPT-4 (fix)	Frei wählbar
Offline-Modus	❌	✅

Wann ist Tabby die bessere Wahl?

• Du arbeitest mit vertraulichem Code (Firma, Kunden-Projekte)
• Du brauchst DSGVO-Konformität
• Du willst keine monatlichen Kosten
• Du hast einen Server oder starken PC mit GPU

GPU-Anforderungen nach Modellgröße:

CPU-Only Betrieb:

Tabby kann auch ohne GPU laufen, ist dann aber deutlich langsamer:

Latenz = Zeit bis der erste Completion-Vorschlag erscheint

Empfohlene Hardware-Konfigurationen:

Einsteiger (1 Entwickler):

• GPU: RTX 3060 12GB (gebraucht ~200 €)
• RAM: 16 GB
• Modell: StarCoder2-3B oder DeepSeek-Coder-6.7B

Team (5-10 Entwickler):

• GPU: RTX 4090 24GB
• RAM: 32 GB
• Modell: CodeLlama-13B

Enterprise (20+ Entwickler):

• GPU: 2× RTX 4090 oder A100 40GB
• RAM: 64 GB
• Modell: CodeLlama-34B

Docker ist der einfachste Weg, Tabby zu installieren. Falls du Docker noch nicht hast, siehe unsere Ollama-Anleitung (Schritt 6).

NVIDIA GPU (empfohlen):

docker run -d \
  --gpus all \
  -p 8080:8080 \
  -v $HOME/.tabby:/data \
  --name tabby \
  --restart always \
  tabbyml/tabby \
  serve \
  --model StarCoder2-3B \
  --chat-model Qwen2-1.5B-Instruct \
  --device cuda

Was macht dieser Befehl?

• --gpus all → Nutzt alle verfügbaren NVIDIA-GPUs
• -p 8080:8080 → Tabby erreichbar unter Port 8080
• -v $HOME/.tabby:/data → Modelle und Daten persistent speichern
• --model StarCoder2-3B → Code-Completion-Modell
• --chat-model Qwen2-1.5B-Instruct → Chat-Modell für Erklärungen
• --device cuda → NVIDIA GPU nutzen

CPU-Only (ohne GPU):

docker run -d \
  --entrypoint /opt/tabby/bin/tabby-cpu \
  -p 8080:8080 \
  -v $HOME/.tabby:/data \
  --name tabby \
  --restart always \
  tabbyml/tabby \
  serve \
  --model StarCoder2-3B \
  --chat-model Qwen2-1.5B-Instruct

Apple Silicon (macOS):

docker run -d \
  -p 8080:8080 \
  -v $HOME/.tabby:/data \
  --name tabby \
  --restart always \
  tabbyml/tabby \
  serve \
  --model StarCoder2-3B \
  --chat-model Qwen2-1.5B-Instruct \
  --device metal

Prüfe ob Tabby läuft:

# Logs anschauen:
docker logs -f tabby
# Beim ersten Start werden die Modelle heruntergeladen (~2-5 GB)
# Warte bis du siehst: "Listening on 0.0.0.0:8080"

Öffne http://localhost:8080 im Browser — du solltest die Tabby-Oberfläche sehen!

Falls du Docker nicht nutzen willst, kannst du Tabby auch direkt installieren:

Via pip (Python):

pip install tabby-server
# Starten mit GPU:
tabby serve --model StarCoder2-3B --chat-model Qwen2-1.5B-Instruct --device cuda
# Starten ohne GPU:
tabby serve --model StarCoder2-3B --chat-model Qwen2-1.5B-Instruct --device cpu

Via Homebrew (macOS):

brew install tabbyml/tabby/tabby
tabby serve --model StarCoder2-3B --chat-model Qwen2-1.5B-Instruct --device metal

Via vorcompiliertes Binary (Linux):

# Neueste Version von GitHub Releases herunterladen:
# https://github.com/TabbyML/tabby/releases
# Beispiel für Linux x86_64 mit CUDA:
wget https://github.com/TabbyML/tabby/releases/latest/download/tabby_x86_64-linux-cuda
chmod +x tabby_x86_64-linux-cuda
./tabby_x86_64-linux-cuda serve --model StarCoder2-3B --device cuda

Als systemd-Service einrichten (Linux):

sudo tee /etc/systemd/system/tabby.service << 'EOF'
[Unit]
Description=Tabby AI Code Assistant
After=network.target
[Service]
Type=simple
User=tabby
ExecStart=/usr/local/bin/tabby serve --model StarCoder2-3B --chat-model Qwen2-1.5B-Instruct --device cuda
Restart=always
RestartSec=10
Environment=HOME=/home/tabby
Environment=TABBY_ROOT=/home/tabby/.tabby
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now tabby
sudo systemctl status tabby

Die Qualität deiner Code-Vorschläge hängt stark vom gewählten Modell ab. Hier die besten Optionen:

Completion-Modelle (für Auto-Vervollständigung):

Chat-Modelle (für Code-Erklärungen und Q&A):

Modell wechseln:

# Docker-Container stoppen und entfernen:
docker stop tabby && docker rm tabby
# Mit neuem Modell starten:
docker run -d \
  --gpus all \
  -p 8080:8080 \
  -v $HOME/.tabby:/data \
  --name tabby \
  --restart always \
  tabbyml/tabby \
  serve \
  --model DeepSeek-Coder-6.7B \
  --chat-model Qwen2-1.5B-Instruct \
  --device cuda

Unsere Empfehlung:

• RTX 3060 12GB: StarCoder2-3B + Qwen2-1.5B-Instruct
• RTX 4070/4080: DeepSeek-Coder-6.7B + Qwen2-1.5B-Instruct
• RTX 4090: CodeLlama-13B + Mistral-7B-Instruct

Extension installieren:

1. Öffne VS Code 2. Gehe zu Extensions (Ctrl+Shift+X) 3. Suche nach "Tabby" 4. Installiere die Extension von TabbyML (verifizierter Herausgeber)

Extension konfigurieren:

1. Öffne die VS Code Einstellungen (Ctrl+,) 2. Suche nach "tabby" 3. Setze die Server-URL: http://localhost:8080

Oder direkt in der settings.json:

{
  "tabby.api.endpoint": "http://localhost:8080",
  "tabby.api.token": "",
  "tabby.usage.automaticInlineCompletion": true,
  "tabby.usage.indexing": true
}

API-Token erstellen (empfohlen):

1. Öffne http://localhost:8080 im Browser 2. Erstelle einen Admin-Account (beim ersten Besuch) 3. Gehe zu Settings → Tokens 4. Erstelle ein neues Token und kopiere es 5. Füge es in VS Code ein: "tabby.api.token": "dein-token-hier"

Tabby in VS Code nutzen:

• Auto-Completion: Tippe Code und warte kurz — Tabby schlägt den nächsten Block vor
• Vorschlag annehmen: Tab-Taste
• Vorschlag ablehnen: Escape oder weiterschreiben
• Chat öffnen: Ctrl+Shift+P → "Tabby: Open Chat"
• Code erklären: Code markieren → Rechtsklick → "Tabby: Explain Code"

Tastenkürzel anpassen:

// keybindings.json
[
  {
    "key": "ctrl+shift+t",
    "command": "tabby.chat.focus"
  },
  {
    "key": "alt+\\",
    "command": "tabby.inlineCompletion.trigger"
  }
]

Tabby unterstützt alle JetBrains-IDEs: IntelliJ IDEA, PyCharm, WebStorm, GoLand, PhpStorm, CLion und mehr.

Plugin installieren:

1. Öffne deine JetBrains IDE 2. Gehe zu File → Settings → Plugins (oder Ctrl+Alt+S) 3. Wechsle zum Tab "Marketplace" 4. Suche nach "Tabby" 5. Klicke auf "Install" und starte die IDE neu

Plugin konfigurieren:

1. Gehe zu File → Settings → Tools → Tabby 2. Setze die Server-URL: http://localhost:8080 3. Optional: API-Token eintragen 4. Klicke "Test Connection" — es sollte "Connected" erscheinen

Nutzung in JetBrains:

• Inline-Completion: Erscheint automatisch beim Tippen (grauer Text)
• Tab: Vorschlag übernehmen
• Escape: Vorschlag ablehnen
• Alt+\: Manuell Completion triggern
• Chat: Über den Tabby-Tab in der Seitenleiste

Vim/Neovim Integration:

# Für Neovim mit lazy.nvim:
# In deiner init.lua oder plugins.lua:

{
  'TabbyML/vim-tabby',
  lazy = false,
  dependencies = { 'neovim/nvim-lspconfig' },
  config = function()
    vim.g.tabby_server_url = 'http://localhost:8080'
  end,
}

# Für klassisches Vim:
# Installiere via vim-plug:
# Plug 'TabbyML/vim-tabby'

Das Killer-Feature von Tabby: Es kann deine gesamte Codebasis indexieren und nutzt den Kontext für bessere Vorschläge.

Repository über die Web-UI hinzufügen:

1. Öffne http://localhost:8080 2. Gehe zu Settings (Admin) → Repositories 3. Klicke "Add Repository" 4. Wähle die Quelle: - Git URL: z.B. https://github.com/dein-user/dein-repo.git - Lokaler Pfad: z.B. /home/user/projects/mein-projekt

Lokales Repository in Docker einbinden:

# Docker-Container mit eingebundenem Code-Verzeichnis:
docker run -d \
  --gpus all \
  -p 8080:8080 \
  -v $HOME/.tabby:/data \
  -v /home/user/projects:/projects:ro \
  --name tabby \
  --restart always \
  tabbyml/tabby \
  serve \
  --model StarCoder2-3B \
  --chat-model Qwen2-1.5B-Instruct \
  --device cuda

Das :ro am Ende bedeutet read-only — Tabby kann deinen Code nur lesen, nicht verändern.

Indexierungs-Status prüfen:

• Im Admin-Panel unter Repositories siehst du den Fortschritt
• Die Erstindexierung eines großen Repos kann einige Minuten dauern
• Danach werden Änderungen inkrementell indexiert

Was bringt die Indexierung?

Ohne Indexierung kennt Tabby nur die aktuell geöffnete Datei. Mit Indexierung versteht es:

• Deine Projekt-Struktur und Namenskonventionen
• Vorhandene Funktionen, Klassen und Interfaces
• Import-Pfade und Dependencies
• Coding-Patterns die du häufig verwendest

Feature-Vergleich der beliebtesten Code-Assistenten:

Wann welches Tool?

• Tabby: Wenn Datenschutz Priorität hat und du eine GPU hast
• GitHub Copilot: Wenn du die bestmögliche Completion-Qualität willst und Cloud okay ist
• Codeium: Kostenlose Cloud-Alternative zu Copilot
• Continue: Wenn du maximale Flexibilität bei der Modell-Wahl brauchst

Ehrliche Einschätzung:

GitHub Copilot (GPT-4) liefert aktuell die besten Completions. Aber Tabby mit DeepSeek-Coder-6.7B kommt auf ~80% der Qualität — und das komplett kostenlos und privat. Für die meisten Entwickler reicht das völlig aus.

Kosten über 2 Jahre:

Ab dem 3. Jahr ist Tabby deutlich günstiger, da die GPU-Kosten entfallen.