> 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/plateformes-et-agents-ia/continue-dev.md).

# Codage IA Continue.dev

Continue.dev est un assistant de codage IA open-source pour VS Code et JetBrains avec plus de 25K étoiles sur GitHub. Le **plugin s'exécute sur votre machine locale** (ou dans votre IDE), mais il se connecte à un serveur modèle backend pour l'inférence. En pointant Continue.dev vers un GPU puissant loué depuis Clore.ai, vous obtenez :

* **Modèles de codage de premier ordre** (34B+ paramètres) qui ne tiennent pas sur votre ordinateur portable
* **Confidentialité totale** — le code reste sur une infrastructure que vous contrôlez
* **Coûts flexibles** — payez uniquement pendant que vous codez (\~0,20–0,50 $/h vs. 19 $/mois pour Copilot)
* **API compatible OpenAI** — Continue.dev se connecte à Ollama, vLLM ou TabbyML sans effort

Ce guide se concentre sur la configuration du **backend GPU Clore.ai** (Ollama ou vLLM) auquel votre extension Continue.dev locale se connecte.

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

{% hint style="info" %}
**Architecture**: Votre IDE (avec l'extension Continue.dev) → Internet → serveur GPU Clore.ai (exécutant Ollama / vLLM / TabbyML) → inférence locale du modèle. Aucun code ne touche jamais une API tierce.
{% endhint %}

## Aperçu

| Propriété                | Détails                                                                                    |
| ------------------------ | ------------------------------------------------------------------------------------------ |
| **Projet**               | [continuedev/continue](https://github.com/continuedev/continue)                            |
| **Licence**              | Apache 2.0                                                                                 |
| **Étoiles GitHub**       | 25K+                                                                                       |
| **Support IDE**          | VS Code, JetBrains (IntelliJ, PyCharm, WebStorm, GoLand, etc.)                             |
| **Fichier de config**    | `~/.continue/config.json`                                                                  |
| **Options backend**      | Ollama, vLLM, TabbyML, LM Studio, llama.cpp, API compatibles OpenAI                        |
| **Difficulté**           | Facile (installation de l'extension) / Moyenne (backend auto-hébergé)                      |
| **GPU requis ?**         | Sur le serveur Clore.ai (oui) ; sur votre portable (non)                                   |
| **Fonctionnalités clés** | Autocomplétion, chat, mode édition, contexte du code (RAG), commandes slash personnalisées |

### Modèles recommandés pour le codage

| Modèle                | VRAM    | Points forts                         | Remarques                                              |
| --------------------- | ------- | ------------------------------------ | ------------------------------------------------------ |
| `codellama:7b`        | \~6 GB  | Autocomplétion rapide                | Bon point de départ                                    |
| `codellama:13b`       | \~10 GB | Équilibré                            | Meilleur rapport qualité/vitesse pour l'autocomplétion |
| `codellama:34b`       | \~22 GB | Meilleure qualité CodeLlama          | Nécessite RTX 3090 / A100                              |
| `deepseek-coder:6.7b` | \~5 GB  | Spécialiste Python/JS                | Excellent pour le développement web                    |
| `deepseek-coder:33b`  | \~22 GB | Open source de premier plan          | Rivalise avec GPT-4 sur le code                        |
| `qwen2.5-coder:7b`    | \~6 GB  | Code multilingue                     | Performant sur 40+ langages                            |
| `qwen2.5-coder:32b`   | \~22 GB | État de l'art                        | Meilleur modèle de codage open en 2024                 |
| `starcoder2:15b`      | \~12 GB | Spécialiste de la complétion de code | Prise en charge FIM (fill-in-the-middle)               |

## Exigences

### Exigences du serveur Clore.ai

| Niveau          | GPU       | VRAM  | RAM   | Disque | Prix       | Modèles                                           |
| --------------- | --------- | ----- | ----- | ------ | ---------- | ------------------------------------------------- |
| **Budget**      | RTX 3060  | 12 GB | 16 GB | 40 GB  | \~0,10 $/h | CodeLlama 7B, DeepSeek 6.7B, Qwen2.5-Coder 7B     |
| **Recommandé**  | RTX 3090  | 24 GB | 32 GB | 80 GB  | \~0,20 $/h | CodeLlama 34B, DeepSeek 33B, Qwen2.5-Coder 32B    |
| **Performance** | RTX 4090  | 24 GB | 32 GB | 80 GB  | \~0,35 $/h | Même modèles que ci-dessus, inférence plus rapide |
| **Puissance**   | A100 40GB | 40 GB | 64 GB | 120 GB | \~0,60 $/h | Plusieurs modèles 34B simultanément               |
| **Maximum**     | A100 80GB | 80 GB | 80 GB | 200 GB | \~1,10 $/h | Modèles 70B (CodeLlama 70B)                       |

### Exigences locales (votre machine)

* VS Code ou tout IDE JetBrains
* Extension Continue.dev installée
* Connexion Internet stable vers votre serveur Clore.ai
* **Pas de GPU local nécessaire** — toute l'inférence se fait sur Clore.ai

## Démarrage rapide

### Partie 1 : Configurer le backend Clore.ai

#### Option A — Backend Ollama (Recommandé pour la plupart des utilisateurs)

Ollama est le backend le plus simple pour Continue.dev — configuration simple, excellente gestion des modèles, API compatible OpenAI.

```bash
# 1. SSH sur votre serveur Clore.ai
ssh root@<clore-server-ip> -p <port>

# 2. Démarrez Ollama avec le support GPU
docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  --restart unless-stopped \
  ollama/ollama

# 3. Vérifiez qu'Ollama fonctionne
curl http://localhost:11434/

# 4. Récupérez votre modèle de codage (choisissez selon votre VRAM)
# Pour 12GB de VRAM (RTX 3060) :
docker exec ollama ollama pull codellama:13b

# Pour 24GB de VRAM (RTX 3090 / RTX 4090) :
docker exec ollama ollama pull qwen2.5-coder:32b
# ou :
docker exec ollama ollama pull deepseek-coder:33b

# 5. Récupérez un modèle d'autocomplétion rapide (séparé du modèle de chat)
docker exec ollama ollama pull starcoder2:3b   # Très rapide, idéal pour l'autocomplétion FIM

# 6. Vérifiez que les modèles sont disponibles
docker exec ollama ollama list

# 7. Testez l'inférence
docker exec ollama ollama run qwen2.5-coder:32b "Write a Python function to binary search a sorted list"
```

Pour exposer Ollama en externe (afin que votre IDE local puisse se connecter) :

```bash
# Redémarrez Ollama avec l'accès externe activé
docker stop ollama && docker rm ollama

docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \
  --restart unless-stopped \
  ollama/ollama

# Testez depuis votre machine LOCALE :
curl http://<clore-server-ip>:11434/api/tags
```

{% hint style="warning" %}
L'exposition du port 11434 publiquement n'a pas d'authentification par défaut. Pour un usage en production, configurez plutôt un tunnel SSH (voir [Conseils et bonnes pratiques](#tips--best-practices)).
{% endhint %}

#### Option B — Backend vLLM (Haut débit / Compatible OpenAI)

vLLM offre une inférence plus rapide et un support multi-utilisateurs. Idéal si plusieurs développeurs partagent un serveur Clore.ai.

```bash
# Démarrez vLLM avec une API compatible OpenAI
docker run -d \
  --name vllm \
  --gpus all \
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \
  -e HF_TOKEN="your-huggingface-token" \
  --restart unless-stopped \
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --dtype auto \
  --max-model-len 32768 \
  --tensor-parallel-size 1 \
  --gpu-memory-utilization 0.90 \
  --served-model-name qwen2.5-coder-32b

# Pour multi-GPU (par ex., deux RTX 3090) :
docker run -d \
  --name vllm \
  --gpus all \
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \
  -e HF_TOKEN="your-huggingface-token" \
  vllm/vllm-openai:latest \
  --model deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct \
  --tensor-parallel-size 2 \
  --dtype auto \
  --max-model-len 65536 \
  --served-model-name deepseek-coder-v2

# Testez l'API
curl http://localhost:8000/v1/models
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-coder-32b",
    "messages": [{"role": "user", "content": "Write a hello world in Rust"}],
    "max_tokens": 200
  }'
```

#### Option C — Backend TabbyML (Spécialiste FIM Autocomplete)

TabbyML fournit une autocomplétion fill-in-the-middle (FIM) supérieure — les suggestions inline en ghost-text. Voir la [documentation TabbyML](https://tabby.tabbyml.com/) pour les détails complets de configuration.

```bash
# Configuration rapide TabbyML pour l'autocomplétion Continue.dev
docker run -d \
  --name tabby \
  --gpus all \
  -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  --restart unless-stopped \
  tabbyml/tabby serve \
  --model StarCoder2-7B \
  --chat-model Mistral-7B \
  --device cuda

# Vérifiez
curl http://localhost:8080/v1/health
```

### Partie 2 : Installer l'extension Continue.dev

**VS Code :**

1. Ouvrez le panneau Extensions (`Ctrl+Shift+X` / `Cmd+Shift+X`)
2. Rechercher **"Continue"** — installez l'extension officielle par Continue (continuedev)
3. Cliquez sur l'icône Continue dans la barre latérale (ou `Ctrl+Shift+I`)

**JetBrains (IntelliJ, PyCharm, WebStorm, GoLand) :**

1. `Fichier → Paramètres → Plugins → Marketplace`
2. Rechercher **"Continue"** et installez
3. Redémarrez l'IDE ; le panneau Continue apparaît dans la barre latérale droite

### Partie 3 : Configurez Continue.dev pour utiliser Clore.ai

Éditez `~/.continue/config.json` sur votre **machine locale**:

```json
{
  "models": [
    {
      "title": "Clore.ai — Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 32768,
      "completionOptions": {
        "temperature": 0.1,
        "topP": 0.95,
        "maxTokens": 4096
      }
    },
    {
      "title": "Clore.ai — CodeLlama 13B (rapide)",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 16384
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B (autocomplete)",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "embeddingsProvider": {
    "provider": "ollama",
    "model": "nomic-embed-text",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "contextProviders": [
    { "name": "code" },
    { "name": "docs" },
    { "name": "diff" },
    { "name": "terminal" },
    { "name": "problems" },
    { "name": "folder" },
    { "name": "codebase" }
  ],
  "slashCommands": [
    { "name": "edit", "description": "Modifier le code sélectionné" },
    { "name": "comment", "description": "Ajouter des commentaires au code" },
    { "name": "share", "description": "Exporter la conversation au format markdown" },
    { "name": "cmd", "description": "Générer une commande terminal" },
    { "name": "commit", "description": "Générer un message de commit git" }
  ]
}
```

Pour **backend vLLM** au lieu d'Ollama :

```json
{
  "models": [
    {
      "title": "Clore.ai — DeepSeek Coder 33B (vLLM)",
      "provider": "openai",
      "model": "deepseek-coder-v2",
      "apiBase": "http://<clore-server-ip>:8000/v1",
      "apiKey": "not-required",
      "contextLength": 65536,
      "completionOptions": {
        "temperature": 0.0,
        "maxTokens": 8192
      }
    }
  ]
}
```

Pour **Backend TabbyML** (autocomplétion seulement) :

```json
{
  "tabAutocompleteModel": {
    "title": "Clore.ai — TabbyML StarCoder2",
    "provider": "openai",
    "model": "StarCoder2-7B",
    "apiBase": "http://<clore-server-ip>:8080/v1",
    "apiKey": "auth-token-if-set"
  }
}
```

## Configuration

### Configuration du tunnel SSH (accès distant sécurisé)

Au lieu d'exposer des ports publiquement, utilisez un tunnel SSH depuis votre machine locale :

```bash
# Ouvrir le tunnel SSH : port local 11434 → port 11434 du serveur Clore.ai
ssh -N -L 11434:localhost:11434 root@<clore-server-ip> -p <clore-ssh-port>

# Garder le tunnel actif (ajouter à ~/.ssh/config) :
Host clore-coding
  HostName <clore-server-ip>
  Port <clore-ssh-port>
  User root
  LocalForward 11434 localhost:11434
  LocalForward 8000 localhost:8000
  ServerAliveInterval 60
  ServerAliveCountMax 3

# Se connecter avec :
ssh -N clore-coding

# Ensuite dans config.json utilisez localhost :
# "apiBase": "http://localhost:11434"
```

### Tunnel persistant avec autossh

```bash
# Installez autossh sur votre machine locale (Linux/macOS)
sudo apt install autossh   # Ubuntu/Debian
brew install autossh       # macOS

# Exécutez un tunnel persistant qui se reconnecte automatiquement
autossh -M 0 -N \
  -o "ServerAliveInterval 30" \
  -o "ServerAliveCountMax 3" \
  -L 11434:localhost:11434 \
  root@<clore-server-ip> -p <clore-ssh-port>

# Ajouter à systemd pour démarrage automatique au boot (Linux)
cat > ~/.config/systemd/user/clore-tunnel.service << 'EOF'
[Unit]
Description=Tunnel SSH vers le serveur de codage Clore.ai
After=network.target

[Service]
ExecStart=autossh -M 0 -N \
  -o StrictHostKeyChecking=accept-new \
  -o ServerAliveInterval=30 \
  -o ServerAliveCountMax=3 \
  -L 11434:localhost:11434 \
  root@CLORE_IP -p CLORE_PORT
Restart=always
RestartSec=10

[Install]
WantedBy=default.target
EOF

systemctl --user enable clore-tunnel
systemctl --user start clore-tunnel
```

### Charger plusieurs modèles pour différentes tâches

Pour une RTX 3090 (24 GB), vous pouvez exécuter un grand modèle de chat et un petit modèle d'autocomplétion simultanément :

```bash
# Sur le serveur Clore.ai :

# Récupérez les modèles
docker exec ollama ollama pull qwen2.5-coder:32b      # Chat (22 GB)
docker exec ollama ollama pull starcoder2:3b           # Autocomplétion (2 GB)
docker exec ollama ollama pull nomic-embed-text        # Embeddings (0.5 GB)

# Ollama gère automatiquement le swapping des modèles
# Les trois entrent dans 24 GB de VRAM avec un caching intelligent

# Surveillez l'utilisation de la VRAM
nvidia-smi --query-gpu=memory.used,memory.free --format=csv -l 5
```

### Indexation du code (RAG pour votre repo)

Continue.dev peut indexer votre codebase pour des suggestions contextuelles. Récupérez un modèle d'embeddings :

```bash
# Sur le serveur Clore.ai — ajoutez le modèle d'embeddings à Ollama
docker exec ollama ollama pull nomic-embed-text

# Dans config.json (local), les embeddings sont déjà configurés ci-dessus.
# Continue.dev indexera automatiquement votre espace de travail ouvert.
# Déclencher une ré-indexation manuelle : Ctrl+Shift+P → "Continue: Index Codebase"
```

## Accélération GPU

### Surveiller les performances d'inférence

```bash
# Sur votre serveur Clore.ai — surveillez le GPU pendant les sessions de codage
watch -n 1 nvidia-smi

# Vérifier les tokens par seconde (logs Ollama)
docker logs ollama --tail 20 -f

# Statistiques GPU détaillées
nvidia-smi dmon -s u -d 2

# Répartition de la mémoire
nvidia-smi --query-gpu=name,memory.used,memory.free,utilization.gpu \
  --format=csv,noheader -l 5
```

### Performances attendues par GPU

| GPU           | Modèle                   | Contexte | Tokens/sec (approx.) |
| ------------- | ------------------------ | -------- | -------------------- |
| RTX 3060 12GB | CodeLlama 7B             | 8K       | \~40–60 t/s          |
| RTX 3060 12GB | DeepSeek-Coder 6.7B      | 8K       | \~45–65 t/s          |
| RTX 3090 24GB | Qwen2.5-Coder 32B (Q4)   | 16K      | \~15–25 t/s          |
| RTX 3090 24GB | DeepSeek-Coder 33B (Q4)  | 16K      | \~15–22 t/s          |
| RTX 4090 24GB | Qwen2.5-Coder 32B (Q4)   | 16K      | \~25–40 t/s          |
| A100 40GB     | Qwen2.5-Coder 32B (FP16) | 32K      | \~35–50 t/s          |
| A100 80GB     | CodeLlama 70B (Q4)       | 32K      | \~20–30 t/s          |

Pour l'autocomplétion (fill-in-the-middle), **starcoder2:3b** ou **codellama:7b** atteignent 50–100 t/s — assez rapide pour paraître instantané dans l'IDE.

### Ajuster Ollama pour de meilleures performances

```bash
# Sur le serveur Clore.ai — optimisez les paramètres d'Ollama
docker stop ollama && docker rm ollama

docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \
  -e OLLAMA_NUM_PARALLEL=2 \
  -e OLLAMA_MAX_LOADED_MODELS=2 \
  -e OLLAMA_FLASH_ATTENTION=1 \
  --restart unless-stopped \
  ollama/ollama

# OLLAMA_NUM_PARALLEL=2 : servir 2 requêtes simultanément
# OLLAMA_MAX_LOADED_MODELS=2 : garder 2 modèles en mémoire GPU
# OLLAMA_FLASH_ATTENTION=1 : activer la flash attention (plus rapide, moins de mémoire)
```

## Conseils et bonnes pratiques

### Utiliser différents modèles pour différentes tâches

Configurez Continue.dev avec des modèles spécialisés par type de tâche — l'UI vous permet de changer de modèle en cours de conversation :

```json
{
  "models": [
    {
      "title": "Chat — Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://localhost:11434",
      "contextLength": 32768,
      "description": "Idéal pour les questions complexes, la revue de code, les décisions d'architecture"
    },
    {
      "title": "Rapide — CodeLlama 7B",
      "provider": "ollama",
      "model": "codellama:7b",
      "apiBase": "http://localhost:11434",
      "contextLength": 8192,
      "description": "Réponses rapides, complétions simples, faible latence"
    },
    {
      "title": "Autocomplete — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "Suggestions inline en ghost-text"
    }
  ]
}
```

### Comparaison des coûts

| Solution               | Coût mensuel (utilisation 8h/jour) | Confidentialité   | Qualité du modèle  |
| ---------------------- | ---------------------------------- | ----------------- | ------------------ |
| GitHub Copilot         | 19 $/utilisateur/mois              | ❌ Cloud Microsoft | GPT-4o (fermé)     |
| Cursor Pro             | 20 $/utilisateur/mois              | ❌ Cloud Cursor    | Claude 3.5 (fermé) |
| RTX 3060 sur Clore.ai  | \~24 $/mois                        | ✅ Votre serveur   | CodeLlama 13B      |
| RTX 3090 sur Clore.ai  | \~48 $/mois                        | ✅ Votre serveur   | Qwen2.5-Coder 32B  |
| RTX 4090 sur Clore.ai  | \~84 $/mois                        | ✅ Votre serveur   | Qwen2.5-Coder 32B  |
| A100 80GB sur Clore.ai | \~264 $/mois                       | ✅ Votre serveur   | CodeLlama 70B      |

Pour une équipe de 3+ développeurs partageant un seul RTX 3090 Clore.ai (\~48 $/mois au total), le coût par utilisateur est inférieur à Copilot tout en offrant un modèle privé plus grand.

### Arrêter quand vous ne codez pas

Clore.ai facture à l'heure. Utilisez un script simple pour démarrer/arrêter le serveur :

```bash
# Enregistrez-les comme scripts locaux

# start-coding-server.sh
#!/bin/bash
echo "Ouverture du tunnel SSH vers Clore.ai..."
ssh -N -f -L 11434:localhost:11434 clore-coding
echo "Tunnel ouvert. Continue.dev est prêt."

# stop-coding-server.sh
#!/bin/bash
echo "Fermeture du tunnel SSH..."
pkill -f "ssh.*clore-coding"
echo "Tunnel fermé. N'oubliez pas d'arrêter votre commande Clore.ai pour arrêter la facturation !"
```

### Utilisez les commandes personnalisées de Continue.dev

Ajoutez des commandes slash personnalisées à `config.json` pour les flux de travail de codage courants :

```json
{
  "customCommands": [
    {
      "name": "review",
      "prompt": "Vérifiez ce code pour les bogues, les problèmes de sécurité et les problèmes de performance. Soyez précis et actionnable.",
      "description": "Revue de code"
    },
    {
      "name": "test",
      "prompt": "Écrivez des tests unitaires complets pour ce code. Incluez les cas limites. Utilisez le même langage/cadre que le code.",
      "description": "Générer des tests"
    },
    {
      "name": "docstring",
      "prompt": "Ajoutez des docstrings/commentaires clairs et complets à ce code en suivant les meilleures pratiques pour le langage.",
      "description": "Ajouter la documentation"
    },
    {
      "name": "optimize",
      "prompt": "Optimisez ce code pour la performance. Expliquez ce que vous avez changé et pourquoi.",
      "description": "Optimiser le code"
    }
  ]
}
```

## Dépannage

| Problème                                          | Cause probable                                   | Solution                                                                                                             |
| ------------------------------------------------- | ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
| Continue.dev affiche "Connection refused"         | Ollama inaccessible                              | Vérifiez que le tunnel SSH est actif ; vérifiez `curl http://localhost:11434/` fonctionne                            |
| Autocomplétion ne se déclenche pas                | Modèle d'autocomplétion de tabulation non défini | Ajoutez `tabAutocompleteModel` à config.json ; activez dans les paramètres de Continue                               |
| Réponses très lentes (>30s pour le premier token) | Chargement du modèle depuis le disque            | La première requête charge le modèle en VRAM — les requêtes suivantes sont rapides                                   |
| Erreur "Model not found"                          | Modèle non téléchargé                            | Exécutez `docker exec ollama ollama pull <nom-du-modèle>` sur le serveur Clore.ai                                    |
| Forte latence entre les tokens                    | Latence réseau ou modèle trop grand              | Utilisez un tunnel SSH ; passez à un modèle plus petit ; vérifiez l'utilisation GPU du serveur                       |
| Contexte de la base de code ne fonctionne pas     | Modèle d'embeddings manquant                     | Téléchargez `nomic-embed-text` via Ollama ; vérifiez `embeddingsProvider` dans config.json                           |
| Le tunnel SSH se coupe fréquemment                | Connexion instable                               | Utilisez `autossh` pour une reconnexion persistante ; ajoutez `ServerAliveInterval 30`                               |
| Fenêtre de contexte dépassée                      | Fichiers/conversations longs                     | Réduisez `contextLength` dans config.json ; utilisez un modèle avec un contexte plus long                            |
| Le plugin JetBrains ne se charge pas              | Incompatibilité de version de l'IDE              | Mettez à jour l'IDE JetBrains vers la dernière version ; vérifiez la matrice de compatibilité du plugin Continue.dev |
| vLLM OOM lors du chargement                       | Pas assez de VRAM                                | Ajoutez `--gpu-memory-utilization 0.85`; utilisez un modèle plus petit ou une version quantifiée                     |

### Commandes de débogage

```bash
# Sur votre machine LOCALE — tester la connectivité
curl http://localhost:11434/api/tags          # si vous utilisez un tunnel SSH
curl http://<clore-ip>:11434/api/tags        # si le port est ouvert directement

# Sur le serveur CLORE.AI — vérifiez Ollama
docker logs ollama --tail 30 -f
docker exec ollama ollama list
docker exec ollama ollama ps                  # afficher les modèles actuellement chargés

# Tester le temps de réponse du modèle
time curl http://localhost:11434/api/generate \
  -d '{"model": "codellama:7b", "prompt": "def hello():", "stream": false}'

# Vérifier la mémoire GPU
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

# Vérifier les logs de vLLM
docker logs vllm --tail 50 -f

# Redémarrer Ollama sans perdre les modèles
docker restart ollama
```

### Validation de la configuration Continue.dev

```bash
# Valider la syntaxe de config.json sur votre machine locale
python3 -c "
import json, sys
try:
    config = json.load(open(sys.argv[1]))
    print('✅ Le fichier de configuration est un JSON valide')
    print(f'Modèles : {[m[\"title\"] for m in config.get(\"models\", [])]}')
except Exception as e:
    print(f'❌ Erreur : {e}')
" ~/.continue/config.json
```

## Lectures complémentaires

* [Documentation Continue.dev](https://docs.continue.dev/) — documentation officielle pour toutes les intégrations IDE et options de configuration
* [Continue.dev GitHub](https://github.com/continuedev/continue) — code source, issues, compatibilité des modèles
* [Référence de configuration Continue.dev](https://docs.continue.dev/reference) — complet `config.json` schéma
* [Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — guide d'installation détaillé d'Ollama (backend recommandé)
* [vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — backend alternatif haute performance pour les équipes
* [TabbyML](https://tabby.tabbyml.com/) — backend d'autocomplétion spécialisé avec optimisation FIM
* [Guide de comparaison des GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — choisissez le bon GPU pour votre charge de travail de codage
* [Compatibilité des modèles](/guides/guides_v2-fr/prise-en-main/model-compatibility.md) — quels modèles tiennent dans quelles tailles de VRAM
* [Qwen2.5-Coder](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) — actuellement le meilleur modèle open pour le codage
* [DeepSeek-Coder-V2](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct) — alternative solide avec long contexte
* [CLORE.AI Marketplace](https://clore.ai/marketplace) — louer des serveurs GPU


---

# 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/plateformes-et-agents-ia/continue-dev.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.