Tabby: Lokale Code-Autovervollständigung installieren selbst gehostet

#Warum Tabby anstatt Cline

Tabby und Cline sind keine Konkurrenten: Sie ergänzen sich. Cline (und Aider) eignet sich hervorragend für dialogorientierte Chats und den Agentenmodus mit mehreren Dateien, aber keines der beiden Tools bietet eine zeilenweise Autovervollständigung während des Tippens. Tabby hingegen macht genau das – und macht es sehr gut. Die erfolgreiche Kombination im Jahr 2026: Cline zum Diskutieren und Refaktorieren, Tabby für den grau dargestellten Vorschlag, der während des Tippens erscheint.

Grauer Inline-Text

Der Vorschlag erscheint direkt nach dem Cursor in grauer Farbe. Drücken Sie Tab, um ihn zu akzeptieren, Escape, um ihn zu ignorieren. Genau wie die UX von Copilot.

100 % selbst gehostet

Der Server läuft bei Ihnen (Docker). Kein Codeausschnitt wird an Dritte gesendet – ideal für NDAs und Code in regulierten Branchen.

Multi-utilisateurs

Im Gegensatz zu einer rein lokalen Erweiterung ist Tabby ein Server: Eine einzige GPU kann ein ganzes Team über das Netzwerk bedienen.

Telemetrie deaktivierbar

Tabby sendet standardmäßig anonyme Statistiken; eine Umgebungsvariable deaktiviert dies vollständig. Der von Ihnen eingegebene Quellcode wird niemals übermittelt.

#Voraussetzungen

Docker

Tabby wird als Container bereitgestellt. Docker Desktop für Windows/macOS, Docker Engine für Linux.

NVIDIA-GPU (empfohlen)

Mit dem NVIDIA Container Toolkit für den Zugriff auf CUDA. Tabby läuft auch auf CPU, aber die Inline-Latenz wird unangenehm.

~6 GB VRAM

Ausreichend für ein quantisiertes Vervollständigungsmodell mit 1–3 Milliarden Parametern. Mehr VRAM bedeutet ein größeres Modell oder mehr Entwickler, die es gleichzeitig nutzen können.

Ein Editor

VS Code oder eine JetBrains-IDE (IntelliJ, PyCharm, WebStorm usw.). Die Tabby-Erweiterung ist für beide verfügbar.

#Welches Completion-Modell?

Die Inline-Autovervollständigung unterliegt einer Einschränkung, die es beim Chat nicht gibt: der Latenz. Der Vorschlag muss innerhalb weniger Hundert Millisekunden erscheinen, sonst tippen Sie schneller, als er angezeigt wird. Deshalb bevorzugt man kompakte Fill-In-the-Middle-Modelle (FIM) in der -base-Variante statt der großen Instruct-Modelle für den Chat.

#1. Tabby in Docker starten

Der Tabby-Server wird mit GPU-Zugriff, einem persistenten Volume für die Daten und einem ausgewählten Modell zur Vervollständigung gestartet. Über Port 8080 sind die Weboberfläche und die API erreichbar.

docker run -d \
  --name tabby \
  --gpus all \
  -p 8080:8080 \
  -v $HOME/.tabby:/data \
  registry.tabbyml.com/tabbyml/tabby \
  serve --model StarCoder2-3B --device cuda

1. 01
   Den Start überprüfen

   Beim ersten Start lädt Tabby das Modell herunter (das dauert einige Minuten). Verfolgen Sie die Logs mit docker logs -f tabby, bis die Meldung erscheint, dass der Server auf Port 8080 lauscht.
2. 02
   Webinterface öffnen

   Rufen Sie http://localhost:8080 auf. Beim ersten Zugriff werden Sie aufgefordert, ein Administratorkonto zu erstellen (E-Mail-Adresse + Passwort). Das erfolgt lokal: Diese Zugangsdaten bleiben in Ihrem Volume ~/.tabby.
3. 03
   Die Codevervollständigung testen

   Die Registerkarte „Playground“ der Benutzeroberfläche ermöglicht es, zu prüfen, ob das Modell antwortet, noch bevor ein Editor angebunden wird.

#2. Den Zugriffstoken erstellen

Die Editoren authentifizieren sich mit einem Token beim Tabby-Server. So lässt sich im Team feststellen, wer sich verbindet, und ein Zugang widerrufen, ohne den gesamten Betrieb zu beeinträchtigen.

1. 01
   In die Einstellungen gehen

   Öffnen Sie in der Weboberfläche (http://localhost:8080) den Bereich Konten/Sicherheit. Dort wird das Token des aktuellen Benutzers angezeigt.
2. 02
   Token kopieren

   Rufen Sie die Zeichenfolge ab (oft mit dem Präfix auth_). Die Erweiterungen für VS Code und JetBrains werden nach genau dieser Zeichenfolge fragen.
3. 03
   Neu generieren, wenn nötig

   Falls der Token offengelegt wird oder ein Mitarbeiter ausscheidet, generieren Sie den Token über die Benutzeroberfläche neu: Der alte Token wird sofort ungültig.

Endpoint : http://localhost:8080
Token    : auth_xxxxxxxxxxxxxxxxxxxxxxxx

#3. VS Code anbinden

1. 01
   Die Erweiterung installieren

   Extensions (Ctrl+Shift+X) → nach „Tabby“ suchen (Herausgeber: TabbyML) → Install.
2. 02
   Endpoint angeben

   Beim ersten Start fragt die Erweiterung nach der Server-URL. Geben Sie http://localhost:8080 (oder die IP-Adresse des gemeinsam genutzten Servers im Netzwerk) ein.
3. 03
   Den Token einfügen

   Geben Sie das im vorherigen Schritt kopierte Zugriffstoken ein. Das Tabby-Symbol in der Statusleiste sollte grün werden (verbunden).
4. 04
   Coder

   Geben Sie Code ein: Der ausgegraute Vorschlag erscheint hinter dem Cursor. Drücken Sie Tab, um ihn anzunehmen, oder tippen Sie weiter, um ihn zu ignorieren.

#4. JetBrains anbinden

Dieselbe Konfiguration funktioniert in der gesamten JetBrains-Produktpalette: IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider usw. Die Tabby-Erweiterung ist ein einziges Plugin, das mit der Plattform kompatibel ist.

1. 01
   Plugin installieren

   Settings → Plugins → Marketplace → nach „Tabby“ suchen → Install, anschließend die IDE neu starten.
2. 02
   Verbindung konfigurieren

   Settings → Tools → Tabby: Geben Sie den Endpunkt (http://localhost:8080) und das Zugriffstoken ein.
3. 03
   Prüfen

   Der Tabby-Indikator in der Statusleiste bestätigt die Verbindung. Die Inline-Vorschläge erscheinen wie in VS Code.

#5. Tabby auf Ihre Ollama-Instanz ausrichten

Wenn Sie Ollama bereits für Cline oder Aider betreiben, müssen Sie keine zweite Inferenz-Engine laden: Tabby kann über das OpenAI-kompatible Protokoll ein Ollama-Backend nutzen. So verwenden Sie einen einzigen Modellserver gemeinsam für Autovervollständigung und Chat.

# Tirez un modèle de complétion FIM dans Ollama
ollama pull qwen2.5-coder:1.5b-base
# ou
ollama pull starcoder2:3b

In Tabby wird das HTTP-Backend anstelle eines lokalen Modells angegeben. Die Konfiguration erfolgt in der Datei config.toml im Datenvolume (~/.tabby/config.toml), in der die Engine für die Codevervollständigung auf die Ollama-API ausgerichtet wird.

[model.completion.http]
kind = "ollama/completion"
model_name = "qwen2.5-coder:1.5b-base"
api_endpoint = "http://localhost:11434"
prompt_template = "<|fim_prefix|>{prefix}<|fim_suffix|>{suffix}<|fim_middle|>"

#6. GPU zwischen mehreren Entwicklern teilen

Das ist der entscheidende Vorteil von Tabby gegenüber einer rein lokalen Erweiterung: ein einziger Server, eine einzige GPU, mehrere Entwickler. Sie installieren Tabby auf einem Rechner mit GPU (einem dedizierten Arbeitsplatzrechner oder einem Team-Server), und jeder Entwickler richtet seinen Editor so ein, dass er sich mit dieser Netzwerkadresse verbindet.

Im Netzwerk zugänglich machen

Port 8080 muss von den Rechnern der Entwickler aus erreichbar sein. Intern genügt die lokale IP-Adresse des Servers (http://192.168.x.x:8080).

Ein Token pro Dev

Erstellen Sie in der Benutzeroberfläche für jeden Entwickler ein Konto/Token. So bleibt die Nachvollziehbarkeit erhalten, und Sie können einzelne Zugänge widerrufen.

Die GPU dimensionieren

Ein kompaktes Modell zur Codevervollständigung (1,5B–3B) bedient mehrere Entwickler parallel, ohne an seine Kapazitätsgrenze zu stoßen. Da die Vervollständigungen kurz sind, überschneiden sich die Anfragen nur selten.

Reverse Proxy + HTTPS

Für den Zugriff von außerhalb des LAN betreiben Sie Tabby hinter einem Reverse-Proxy (Caddy, Nginx) mit TLS. Machen Sie Port 8080 niemals ungeschützt über das Internet zugänglich.

#Leistungseinstellungen und Fehlerbehebung

Zu hohe Latenz

Wechseln Sie zu einem Modell eine Größenstufe darunter (3B → 1.5B), überprüfen Sie, ob --device cuda tatsächlich aktiv ist (kein CPU-Fallback), und begrenzen Sie die maximale Länge der Vorschläge.

Keine Vorschläge

Prüfen Sie das Statussymbol der Erweiterung (Token und Endpunkt korrekt) und ob der Container läuft (docker ps). Mit dem Web-Playground lässt sich eingrenzen, ob das Problem auf der Server- oder auf der Editorseite liegt.

Themenfremde Vorschläge

Fast immer liegt es an einem falschen FIM-prompt_template oder einer instruct-Variante statt -base. Wechseln Sie zurück zu einem Basismodell und zur passenden FIM-Vorlage.

Indexierung des Repositoriums (RAG)

Tabby kann Ihren Code indexieren, um stärker kontextbezogene Vorschläge zu liefern. Aktivieren Sie die Indexierung in der Oberfläche, wenn die GPU noch Reserven hat; deaktivieren Sie sie, wenn sich die Latenz verschlechtert.

GPU-Speicher vollständig belegt

Wenn mehrere Modelle parallel betrieben werden (Tabby + Cline über Ollama), quantisieren Sie den KV-Cache und überwachen Sie den VRAM mit nvidia-smi.

# Le conteneur tourne-t-il ?
docker ps | grep tabby
# Logs en direct
docker logs -f tabby
# Le GPU est-il bien vu ?
docker exec tabby nvidia-smi

#Häufig gestellte Fragen

#Fazit

Sie haben nun einen zu 100 % selbst gehosteten Server für die automatische Codevervollständigung: Tabby in Docker auf Ihrer GPU, ein StarCoder- oder Qwen-Coder-Modell mit Fill-In-the-Middle, ein Zugriffstoken und ausgegraute Vorschläge im Copilot-Stil sowohl in VS Code als auch in JetBrains – mit dem zusätzlichen Vorteil, dass Sie ein ganzes Team über eine einzige GPU versorgen können. Mit Cline für Chat und Agentenfunktionen ist die Lösung komplett, und Ihr Code verlässt nie Ihre Infrastruktur. Wenn Sie sich stundenlange Konfigurationsarbeit (FIM-Templates, Ollama-Konfigurationen, Modelle nach Rolle) sparen möchten, bietet der kostenpflichtige Leitfaden „Lokaler Code-Copilot“ ein schlüsselfertiges Paket aus Ollama + Cline + Aider, das sich für die Inline-Codevervollständigung um Tabby ergänzen lässt.