> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/outils-de-codage-ia/tabby.md).

# Complétion de code TabbyML

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.

{% hint style="success" %}
Tous les exemples s'exécutent sur des serveurs GPU loués via le [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## 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

```bash
# 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 :

```bash
# 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 :**

```vim
" 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 :

```bash
# 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

```bash
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

```bash
# 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)

```bash
# 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](https://github.com/TabbyML/tabby)
* [Documentation TabbyML](https://tabby.tabbyml.com)
* [Extension VS Code](https://marketplace.visualstudio.com/items?itemName=TabbyML.vscode-tabby)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/outils-de-codage-ia/tabby.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
