Complétion de code TabbyML

Auto-hébergez TabbyML comme alternative privée à GitHub Copilot sur Clore.ai

TabbyML est un serveur d'auto-hébergement pour complétion de code IA — un remplacement prêt à l'emploi pour GitHub Copilot qui garde votre code intégralement sur votre propre infrastructure. Sous licence Apache 2.0, il fonctionne sur des GPU Clore.ai et se connecte à VS Code, JetBrains et Vim/Neovim via des extensions officielles. Les modèles vont de StarCoder2-1B (tient sur 4 Go de VRAM) à StarCoder2-15B et DeepSeek-Coder pour une qualité maximale.

Tous les exemples s'exécutent sur des serveurs GPU loués via le CLORE.AI Marketplace.

Principales caractéristiques

• Alternative auto-hébergée à Copilot — votre code ne quitte jamais votre serveur

• Licence Apache 2.0 — gratuit pour un usage commercial, sans restrictions

• Extensions IDE — VS Code, JetBrains (IntelliJ, PyCharm, WebStorm), Vim/Neovim

• Plusieurs modèles — StarCoder2 (1B/3B/7B/15B), DeepSeek-Coder, CodeLlama

• Contexte du dépôt — récupération de code pilotée par RAG pour des complétions conscientes du projet

• Déploiement Docker — commande unique pour lancer avec prise en charge GPU

• Tableau d'administration — analyses d'utilisation, gestion des modèles, gestion des utilisateurs

• Interface de chat — posez des questions de codage au-delà de l'autocomplétion

Exigences

Composant	Minimum	Recommandé
GPU	RTX 3060 12 Go	RTX 3080 10 Go+
VRAM	4 Go	10 Go
RAM	8 Go	16 Go
Disque	20 Go	50 Go
CUDA	11.8	12.1+

Tarifs Clore.ai : RTX 3080 ≈ 0,3–1 $/jour · RTX 3060 ≈ 0,15–0,3 $/jour

TabbyML est léger — même une RTX 3060 exécute StarCoder2-7B avec une inférence rapide.

Démarrage rapide

1. Déployer avec Docker

# StarCoder2-7B sur GPU (équilibre recommandé qualité/vitesse)
docker run -d \
  --name tabby \
  --gpus all \
  -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby \
  serve \
  --model StarCoder2-7B \
  --device cuda

# Vérifier que c'est en cours d'exécution
curl http://localhost:8080/v1/health

2. Choisir un modèle

Modèle	VRAM	Vitesse	Qualité	Idéal pour
StarCoder2-1B	~3 Go	Le plus rapide	Basique	RTX 3060, brouillons rapides
StarCoder2-3B	~5 Go	Rapide	Bon	Développement général
StarCoder2-7B	~8 Go	Moyen	Élevé	Par défaut recommandé
StarCoder2-15B	~16 Go	Plus lent	Meilleur	Bases de code complexes
DeepSeek-Coder-6.7B	~8 Go	Moyen	Élevé	Python, JS, TypeScript
CodeLlama-7B	~8 Go	Moyen	Bon	Usage général

Changez de modèle en modifiant le --model indicateur :

# Modèle plus léger pour moins de VRAM
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve --model StarCoder2-3B --device cuda

# Plus grand modèle pour la meilleure qualité
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve --model StarCoder2-15B --device cuda

3. Installer les extensions IDE

VS Code :

1. Ouvrir Extensions (Ctrl+Shift+X)

2. Rechercher "Tabby" et installer l'extension officielle

3. Ouvrir Paramètres → rechercher "Tabby"

4. Définir le point de terminaison du serveur : http://<votre-clore-ip>:8080

JetBrains (IntelliJ, PyCharm, WebStorm) :

1. Paramètres → Plugins → Marketplace

2. Rechercher "Tabby" et installer

3. Paramètres → Outils → Tabby → Point de terminaison du serveur : http://<votre-clore-ip>:8080

Vim/Neovim :

" Avec vim-plug
Plug 'TabbyML/vim-tabby'

" Configuration dans init.vim / .vimrc
let g:tabby_server_url = 'http://<votre-clore-ip>:8080'

4. Accéder au tableau d'administration

Ouvrir http://<votre-clore-ip>:8080 dans un navigateur. Le tableau fournit :

• Statistiques d'utilisation des complétions

• État du modèle et métriques de performance

• Gestion des utilisateurs et des jetons API

• Configuration de l'indexation du dépôt

Exemples d'utilisation

Ajouter le contexte du dépôt (RAG)

Indexez votre dépôt pour des complétions conscientes du projet :

# Via l'API d'administration
curl -X POST http://localhost:8080/v1beta/repositories \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-project",
    "git_url": "file:///workspace/my-project"
  }'

# Tabby indexe le repo et l'utilise pour des complétions prenant en compte le contexte

Utiliser l'API Chat

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "Write a Python function to parse CSV files with error handling"}
    ]
  }'

Exécuter avec authentification

# Générez un jeton d'auth via le tableau d'administration, puis :
docker run -d --gpus all -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  tabbyml/tabby serve \
  --model StarCoder2-7B \
  --device cuda

# Définir le jeton dans les paramètres de l'extension IDE
# ou utiliser l'en-tête Authorization :
curl -H "Authorization: Bearer <token>" http://localhost:8080/v1/health

Exécuter sans Docker (installation directe)

# Installer via Homebrew (Linux)
curl -fsSL https://raw.githubusercontent.com/TabbyML/tabby/main/install.sh | bash

# Ou cargo install
cargo install tabby

# Exécuter directement
tabby serve --model StarCoder2-7B --device cuda --port 8080

Comparaison des coûts

Solution	Coût mensuel	Confidentialité	Latence
GitHub Copilot	19 $/utilisateur	❌ Cloud	~200 ms
TabbyML sur RTX 3060	~5–9 $/mois	✅ Auto-hébergement	~50 ms
TabbyML sur RTX 3080	~9–30 $/mois	✅ Auto-hébergement	~30 ms
TabbyML sur RTX 4090	~15–60 $/mois	✅ Auto-hébergement	~15 ms

Pour une petite équipe (3–5 développeurs), une seule RTX 3080 sur Clore.ai remplace plusieurs abonnements Copilot pour une fraction du coût.

Conseils

• StarCoder2-7B est le point idéal — meilleur ratio qualité/VRAM pour la plupart des équipes

• Activer le contexte du dépôt — l'indexation RAG améliore considérablement la pertinence des complétions pour les grandes bases de code

• Exposez le port 8080 de manière sécurisée — utilisez un tunnel SSH ou un reverse proxy avec TLS pour les déploiements en production

• Surveillez l'utilisation de la VRAM — nvidia-smi pour vous assurer que le modèle tient avec une marge pour le regroupement d'inférences

• Utilisez l'API de complétion pour l'intégration CI/CD — automatiser les suggestions de revue de code

• Tabby prend en charge plusieurs utilisateurs — le tableau d'administration vous permet de créer des jetons API par développeur

• La latence compte — choisissez un serveur Clore.ai géographiquement proche de votre équipe pour des complétions les plus rapides

Dépannage

Problème	Solution
Le conteneur Docker se termine immédiatement	Vérifier les logs : docker logs tabby. Probablement VRAM insuffisante pour le modèle
L'extension IDE ne se connecte pas	Vérifiez l'URL du point de terminaison, contrôlez le pare-feu/le transfert de port sur Clore.ai
Complétions lentes	Utilisez un modèle plus petit, ou assurez-vous que le GPU n'est pas partagé avec d'autres tâches
CUDA out of memory	Passez à un modèle plus petit (StarCoder2-3B ou 1B)
Indexation du dépôt bloquée	Vérifiez l'espace disque et assurez-vous que le repo git est accessible
Jeton d'auth rejeté	Régénérez le jeton dans le tableau d'administration, mettez à jour l'extension IDE
Forte latence depuis l'IDE distant	Utilisez un tunnel SSH : ssh -L 8080:localhost:8080 root@<clore-ip>

Ressources

• TabbyML GitHub

• Documentation TabbyML

• Extension VS Code

• CLORE.AI Marketplace