Tabby : installer une autocomplétion de code locale auto-hébergée

#Pourquoi Tabby plutôt que Cline

Tabby et Cline ne sont pas concurrents : ils sont complémentaires. Cline (et Aider) excelle dans le chat conversationnel et le mode agent multi-fichiers, mais aucun des deux ne fait l'autocomplétion ligne par ligne pendant la frappe. Tabby, lui, ne fait que ça — et le fait très bien. Le combo gagnant en 2026 : Cline pour discuter et refactorer, Tabby pour la suggestion grisée qui apparaît au fil de la frappe.

Texte grisé inline

La suggestion s'affiche directement après le curseur, en grisé. Tab pour accepter, Échap pour ignorer. Exactement l'UX Copilot.

100 % auto-hébergé

Le serveur tourne chez vous (Docker). Aucun extrait de code n'est envoyé à un tiers — idéal pour les NDA et le code en secteur régulé.

Multi-utilisateurs

Contrairement à une extension purement locale, Tabby est un serveur : un seul GPU peut servir toute une équipe via le réseau.

Telemetry désactivable

Tabby remonte des stats anonymes par défaut ; une variable d'environnement coupe tout. Le code source que vous tapez n'est jamais transmis.

#Prérequis

Docker

Tabby se déploie en conteneur. Docker Desktop sur Windows/macOS, Docker Engine sur Linux.

GPU NVIDIA (recommandé)

Avec le NVIDIA Container Toolkit pour l'accès CUDA. Tabby tourne aussi en CPU, mais la latence inline devient inconfortable.

~6 Go de VRAM

Suffisant pour un modèle de complétion 1B–3B en quantisation. Plus de VRAM = modèle plus gros ou plus de devs en parallèle.

Un éditeur

VS Code ou un IDE JetBrains (IntelliJ, PyCharm, WebStorm, etc.). L'extension Tabby existe pour les deux.

#Quel modèle de complétion

L'autocomplétion inline a une contrainte que le chat n'a pas : la latence. La suggestion doit apparaître en quelques centaines de millisecondes, sinon vous tapez plus vite qu'elle. On privilégie donc des modèles Fill-In-the-Middle (FIM) compacts, en variante -base, pas les gros modèles instruct du chat.

#1. Lancer Tabby en Docker

On démarre le serveur Tabby avec accès GPU, un volume persistant pour les données, et un modèle de complétion choisi. Le port 8080 expose l'interface web et l'API.

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
   Vérifier le démarrage

   Au premier lancement, Tabby télécharge le modèle (quelques minutes). Suivez les logs avec docker logs -f tabby jusqu'au message indiquant que le serveur écoute sur le port 8080.
2. 02
   Ouvrir l'interface web

   Rendez-vous sur http://localhost:8080. Le premier accès vous invite à créer un compte administrateur (email + mot de passe). C'est local : ces identifiants restent dans votre volume ~/.tabby.
3. 03
   Tester la complétion

   L'onglet « Playground » de l'interface permet de vérifier que le modèle répond avant même de brancher un éditeur.

#2. Créer le token d'accès

Les éditeurs s'authentifient auprès du serveur Tabby avec un token. C'est ce qui permet, en équipe, de savoir qui se connecte et de révoquer un accès sans tout casser.

1. 01
   Aller dans les paramètres

   Dans l'interface web (http://localhost:8080), ouvrez la section comptes/sécurité. Le token de l'utilisateur courant y est affiché.
2. 02
   Copier le token

   Récupérez la chaîne de caractères (souvent préfixée auth_). C'est elle que les extensions VS Code et JetBrains demanderont.
3. 03
   Régénérer si besoin

   En cas de fuite ou de départ d'un collaborateur, régénérez le token depuis l'interface : l'ancien est immédiatement invalidé.

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

#3. Brancher VS Code

1. 01
   Installer l'extension

   Extensions (Ctrl+Shift+X) → chercher « Tabby » (éditeur TabbyML) → Install.
2. 02
   Renseigner l'endpoint

   Au premier lancement, l'extension demande l'URL du serveur. Saisissez http://localhost:8080 (ou l'IP du serveur partagé sur le réseau).
3. 03
   Coller le token

   Renseignez le token d'accès copié à l'étape précédente. L'icône Tabby dans la barre d'état doit passer au vert (connecté).
4. 04
   Coder

   Tapez du code : la suggestion grisée apparaît après le curseur. Tab pour l'accepter, continuez à taper pour l'ignorer.

#4. Brancher JetBrains

La même configuration fonctionne sur toute la gamme JetBrains : IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, etc. L'extension Tabby est un plugin unique compatible avec la plateforme.

1. 01
   Installer le plugin

   Settings → Plugins → Marketplace → chercher « Tabby » → Install, puis redémarrer l'IDE.
2. 02
   Configurer la connexion

   Settings → Tools → Tabby : renseignez l'endpoint (http://localhost:8080) et le token d'accès.
3. 03
   Vérifier

   L'indicateur Tabby dans la barre d'état confirme la connexion. Les suggestions inline s'affichent comme dans VS Code.

#5. Pointer Tabby sur votre Ollama

Si vous faites déjà tourner Ollama pour Cline ou Aider, inutile de charger un second moteur d'inférence : Tabby sait consommer un backend Ollama via son protocole compatible OpenAI. Vous mutualisez ainsi un seul serveur de modèles pour la complétion et le chat.

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

Côté Tabby, on déclare le backend HTTP au lieu d'un modèle local. La configuration se fait dans le fichier config.toml du volume de données (~/.tabby/config.toml), où l'on pointe le moteur de complétion vers l'API Ollama.

[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. Partager le GPU entre plusieurs devs

C'est l'avantage décisif de Tabby sur une extension purement locale : un seul serveur, un seul GPU, plusieurs développeurs. Vous installez Tabby sur une machine équipée d'un GPU (un poste dédié, un serveur d'équipe), et chaque dev pointe son éditeur vers cette adresse réseau.

Exposer sur le réseau

Le port 8080 doit être accessible depuis les postes des devs. En interne, l'IP locale du serveur suffit (http://192.168.x.x:8080).

Un token par dev

Créez un compte/token par développeur dans l'interface. Vous gardez la traçabilité et pouvez révoquer un accès individuellement.

Dimensionner le GPU

Un modèle de complétion compact (1.5B–3B) sert plusieurs devs en parallèle sans saturer. La complétion étant brève, les requêtes ne se chevauchent que rarement.

Reverse proxy + HTTPS

Pour un accès hors LAN, placez Tabby derrière un reverse proxy (Caddy, Nginx) avec TLS. N'exposez jamais le port 8080 nu sur Internet.

#Réglages perf et dépannage

Latence trop élevée

Descendez d'un cran de modèle (3B → 1.5B), vérifiez que --device cuda est bien actif (pas un fallback CPU), et limitez la longueur max des suggestions.

Pas de suggestion

Vérifiez l'icône d'état de l'extension (token/endpoint corrects) et que le conteneur tourne (docker ps). Le Playground web isole le problème côté serveur vs éditeur.

Suggestions hors-sujet

Quasi toujours un prompt_template FIM erroné ou une variante instruct au lieu de -base. Repassez sur un modèle base et le bon template FIM.

Indexation du dépôt (RAG)

Tabby peut indexer votre code pour des suggestions plus contextuelles. Activez-le dans l'interface si le GPU a de la marge ; désactivez-le si la latence souffre.

Mémoire GPU saturée

Si plusieurs modèles cohabitent (Tabby + Cline via Ollama), quantifiez le KV cache et surveillez la VRAM avec 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

#Questions fréquentes

#Conclusion

Vous avez désormais un serveur d'autocomplétion de code 100 % auto-hébergé : Tabby en Docker sur votre GPU, un modèle StarCoder ou Qwen-Coder en Fill-In-the-Middle, un token d'accès, et la suggestion grisée façon Copilot dans VS Code comme dans JetBrains — avec, en bonus, la possibilité de servir toute une équipe depuis un seul GPU. Associé à Cline pour le chat et l'agent, le tableau est complet et votre code ne quitte jamais votre infrastructure. Si vous voulez éviter les heures de réglages (templates FIM, configs Ollama, modèles par rôle), le guide payant « Copilote de code local » fournit un pack clé en main Ollama + Cline + Aider, prêt à compléter avec Tabby pour l'autocomplétion inline.