Complétion de code TabbyML

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

TabbyML est un serveur d’achèvement de code IA auto-hébergé — un remplacement direct de GitHub Copilot qui garde tout votre code 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 la place de marché CLORE.AI.

Caractéristiques clés

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

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

• Extensions d’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 alimentée par RAG pour des complétions tenant compte du projet

• Déploiement Docker — une seule commande pour lancer avec prise en charge du GPU

• Tableau de bord d’administration — analyses d’utilisation, gestion des modèles, gestion des utilisateurs

• Interface de chat — poser des questions de programmation au-delà de l’autocomplétion

Exigences

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

Tarification Clore.ai : RTX 3080 ≈ $0.05–0.19/h · RTX 3060 ≈ $0.03–0.07/h

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é entre qualité et 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érifiez que cela fonctionne
curl http://localhost:8080/v1/health

2. Choisir un modèle

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

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

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

# Modèle le plus grand 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 d’IDE

VS Code :

1. Ouvrez Extensions (Ctrl+Shift+X)

2. Recherchez « Tabby » et installez l’extension officielle

3. Ouvrez Paramètres → recherchez « Tabby »

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

JetBrains (IntelliJ, PyCharm, WebStorm) :

1. Paramètres → Plugins → Marketplace

2. Recherchez « Tabby » et installez

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

Vim/Neovim :

" Utilisation de vim-plug
Plug 'TabbyML/vim-tabby'

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

4. Accéder au tableau de bord d’administration

Ouvrez http://<your-clore-ip>:8080 dans un navigateur. Le tableau de bord 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 tenant compte 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 dépôt et l’utilise pour des complétions contextuelles

Utilisez l’API de 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’authentification via le tableau de bord 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éfinissez le jeton dans les paramètres de votre extension d’IDE
# ou utilisez 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ébergé	~50 ms
TabbyML sur RTX 3080	~9–30 $/mois	✅ Auto-hébergé	~30 ms
TabbyML sur RTX 4090	~15–60 $/mois	✅ Auto-hébergé	~15 ms

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

Conseils

• StarCoder2-7B est le meilleur compromis — le meilleur rapport qualité/VRAM pour la plupart des équipes

• Activez 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 proxy inverse avec TLS pour les déploiements de production

• Surveillez l’utilisation de la VRAM — nvidia-smi pour vous assurer que le modèle tient avec une marge suffisante pour le batching d’inférence

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

• Tabby prend en charge plusieurs utilisateurs — le tableau de bord 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 les complétions les plus rapides

Dépannage

Problème	Solution
Le conteneur Docker se ferme immédiatement	Vérifiez les journaux : docker logs tabby. VRAM probablement insuffisante pour le modèle
L’extension d’IDE ne se connecte pas	Vérifiez l’URL du point de terminaison, contrôlez le pare-feu/la redirection 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
Mémoire CUDA insuffisante	Passez à un modèle plus petit (StarCoder2-3B ou 1B)
L’indexation du dépôt est bloquée	Vérifiez l’espace disque et assurez-vous que le dépôt git est accessible
Jeton d’authentification refusé	Régénérez le jeton dans le tableau de bord d’administration, mettez à jour l’extension d’IDE
Latence élevée depuis un IDE distant	Utilisez un tunnel SSH : ssh -L 8080:localhost:8080 root@<clore-ip>

Ressources

• TabbyML sur GitHub

• Documentation TabbyML

• Extension VS Code

• la place de marché CLORE.AI