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

# Codage IA Continue.dev

Alimentez Continue.dev avec les GPU Clore.ai — exécutez CodeLlama 34B, DeepSeek Coder et Qwen2.5-Coder localement sur des locations de GPU bon marché pour une assistance privée au codage IA.

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

* **Modèles de codage haut de gamme** (plus de 34 milliards de paramètres) qui ne tiendront pas sur votre ordinateur portable
* **Confidentialité totale** — le code reste sur une infrastructure que vous contrôlez
* **Coûts flexibles** — ne payez que pendant que vous codez (\~0,20–0,50 $/h contre 19 $/mois pour Copilot)
* **API compatible avec OpenAI** — Continue.dev se connecte à Ollama, vLLM ou TabbyML de manière transparente

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

{% hint style="success" %}
Tous les exemples de serveur GPU utilisent des serveurs loués via le [la place de marché CLORE.AI](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+                                                                                               |
| **Prise en charge des IDE**  | VS Code, JetBrains (IntelliJ, PyCharm, WebStorm, GoLand, etc.)                                     |
| **Fichier de configuration** | `~/.continue/config.json`                                                                          |
| **Options de backend**       | Ollama, vLLM, TabbyML, LM Studio, llama.cpp, API compatibles avec OpenAI                           |
| **Difficulté**               | Facile (installation de l'extension) / Moyen (backend auto-hébergé)                                |
| **GPU requis ?**             | Sur le serveur Clore.ai (oui) ; sur votre ordinateur portable (non)                                |
| **Caractéristiques clés**    | Autocomplétion, chat, mode édition, contexte de base de code (RAG), commandes slash personnalisées |

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

| Modèle                | VRAM    | Atout                                | Remarques                                              |
| --------------------- | ------- | ------------------------------------ | ------------------------------------------------------ |
| `codellama:7b`        | \~6 Go  | Autocomplétion rapide                | Bon point de départ                                    |
| `codellama:13b`       | \~10 Go | Équilibré                            | Meilleur rapport qualité/vitesse pour l'autocomplétion |
| `codellama:34b`       | \~22 Go | Meilleure qualité CodeLlama          | Nécessite une RTX 3090 / A100                          |
| `deepseek-coder:6.7b` | \~5 Go  | Spécialiste Python/JS                | Excellent pour le développement web                    |
| `deepseek-coder:33b`  | \~22 Go | Open source haut de gamme            | Concurrence GPT-4 sur le code                          |
| `qwen2.5-coder:7b`    | \~6 Go  | Code multilingue                     | Performant sur plus de 40 langues                      |
| `qwen2.5-coder:32b`   | \~22 Go | À la pointe de la technologie        | Meilleur modèle de codage open source de 2024          |
| `starcoder2:15b`      | \~12 Go | Spécialiste de la complétion de code | Prise en charge du FIM (remplissage au milieu)         |

## Exigences

### Exigences du serveur Clore.ai

| Niveau           | GPU        | VRAM  | RAM   | Disque | Prix                                      | Modèles                                            |
| ---------------- | ---------- | ----- | ----- | ------ | ----------------------------------------- | -------------------------------------------------- |
| **Petit budget** | RTX 3060   | 12 Go | 16 Go | 40 Go  | $0.03–0.07/hr                             | CodeLlama 7B, DeepSeek 6.7B, Qwen2.5-Coder 7B      |
| **Recommandé**   | RTX 3090   | 24 Go | 32 Go | 80 Go  | 0,07–0,21 $/h                             | CodeLlama 34B, DeepSeek 33B, Qwen2.5-Coder 32B     |
| **Performances** | RTX 4090   | 24 Go | 32 Go | 80 Go  | 0,14–0,42 $/h                             | Mêmes modèles que ci-dessus, inférence plus rapide |
| **Puissance**    | A100 40 Go | 40 Go | 64 Go | 120 Go | [bare metal](https://clore.ai/bare-metal) | Plusieurs modèles 34B simultanément                |
| **Maximum**      | A100 80 Go | 80 Go | 80 Go | 200 Go | [bare metal](https://clore.ai/bare-metal) | Modèles 70B (CodeLlama 70B)                        |

### Exigences locales (votre machine)

* VS Code ou n'importe quel IDE JetBrains
* Extension Continue.dev installée
* Connexion Internet stable à votre serveur Clore.ai
* **Aucun GPU local requis** — 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 avec OpenAI.

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

# 2. Démarrez Ollama avec prise en charge du 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 s'exécute
curl http://localhost:11434/

# 4. Téléchargez votre modèle de codage (choisissez selon votre VRAM)
# Pour 12 Go de VRAM (RTX 3060) :
docker exec ollama ollama pull codellama:13b

# Pour 24 Go 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. Téléchargez un modèle d'autocomplétion rapide (séparé du modèle de chat)
docker exec ollama ollama pull starcoder2:3b   # Très rapide, excellent 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 publique du port 11434 ne comporte aucune 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 avec OpenAI)

vLLM offre une inférence plus rapide et une prise en charge multi-utilisateur. Idéal si plusieurs développeurs partagent un seul serveur Clore.ai.

```bash
# Démarrez vLLM avec une API compatible avec 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 plusieurs 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

# Tester 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 de l'autocomplétion FIM)

TabbyML fournit une autocomplétion fill-in-the-middle (FIM) supérieure — les suggestions de texte fantôme en ligne. Voir la [documentation TabbyML](https://tabby.tabbyml.com/) pour tous les détails de configuration.

```bash
# Configuration rapide de 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érifier
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. Recherchez **"Continue"** — installez l'extension officielle de 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. Recherchez **"Continue"** et installez
3. Redémarrez l'IDE ; le panneau Continue apparaît dans la barre latérale droite

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

Modifier `~/.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 (autocomplétion)",
    "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 en Markdown" },
    { "name": "cmd", "description": "Générer une commande de terminal" },
    { "name": "commit", "description": "Générer un message de commit git" }
  ]
}
```

Pour **le backend vLLM** à la place 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 uniquement) :

```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 les ports publiquement, utilisez un tunnel SSH depuis votre machine locale :

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

# Gardez le tunnel actif (ajoutez ceci à ~/.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

# Connectez-vous avec :
ssh -N clore-coding

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

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

# Ajoutez à systemd pour un 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

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

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

# Téléchargez les modèles
docker exec ollama ollama pull qwen2.5-coder:32b      # Chat (22 Go)
docker exec ollama ollama pull starcoder2:3b           # Autocomplétion (2 Go)
docker exec ollama ollama pull nomic-embed-text        # Embeddings (0,5 Go)

# Ollama gère automatiquement le changement de modèle
# Les trois tiennent dans 24 Go de VRAM grâce à une mise en cache intelligente

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

### Indexation de la base de code (RAG pour votre dépôt)

Continue.dev peut indexer votre base de code pour fournir des suggestions contextuelles. Téléchargez un modèle d'embedding :

```bash
# Sur le serveur Clore.ai — ajoutez le modèle d'embedding à 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éclenchez la réindexation manuelle : Ctrl+Shift+P → "Continue : indexer la base de code"
```

## Accélération GPU

### Surveiller les performances d'inférence

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

# Vérifiez les jetons par seconde (journaux Ollama)
docker logs ollama --tail 20 -f

# Statistiques détaillées du GPU
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 | Jetons/s (approx.) |
| -------------- | ------------------------ | -------- | ------------------ |
| RTX 3060 12 Go | CodeLlama 7B             | 8K       | \~40–60 t/s        |
| RTX 3060 12 Go | DeepSeek-Coder 6.7B      | 8K       | \~45–65 t/s        |
| RTX 3090 24 Go | Qwen2.5-Coder 32B (Q4)   | 16K      | \~15–25 t/s        |
| RTX 3090 24 Go | DeepSeek-Coder 33B (Q4)  | 16K      | \~15–22 t/s        |
| RTX 4090 24 Go | Qwen2.5-Coder 32B (Q4)   | 16K      | \~25–40 t/s        |
| A100 40 Go     | Qwen2.5-Coder 32B (FP16) | 32K      | \~35–50 t/s        |
| A100 80 Go     | CodeLlama 70B (Q4)       | 32K      | \~20–30 t/s        |

Pour l'autocomplétion (fill-in-the-middle), **starcoder2:3b** ou **codellama:7b** atteint 50–100 t/s — suffisamment rapide pour donner une impression d'instantanéité dans l'IDE.

### Optimiser Ollama pour de meilleures performances

```bash
# Sur le serveur Clore.ai — optimisez les réglages 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 : conserver 2 modèles en mémoire GPU
# OLLAMA_FLASH_ATTENTION=1 : activer 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'interface 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 relecture 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": "Autocomplétion — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "Suggestions de texte fantôme en ligne"
    }
  ]
}
```

### Comparaison des coûts

| Solution                | Coût mensuel (utilisation 8 h/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 80 Go sur Clore.ai | \~264 $/mois                        | ✅ Votre serveur   | CodeLlama 70B      |

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

### Arrêter quand on ne code pas

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

```bash
# Enregistrez ceci 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 stopper la facturation !"
```

### Utiliser 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": "Passez ce code en revue pour détecter les bugs, les problèmes de sécurité et les problèmes de performance. Soyez précis et concret.",
      "description": "Revue de code"
    },
    {
      "name": "test",
      "prompt": "Écrivez des tests unitaires complets pour ce code. Incluez les cas limites. Utilisez le même langage/framework que le code.",
      "description": "Générer des tests"
    },
    {
      "name": "docstring",
      "prompt": "Ajoutez à ce code des docstrings/commentaires clairs et complets en suivant les meilleures pratiques du langage.",
      "description": "Ajouter de la documentation"
    },
    {
      "name": "optimize",
      "prompt": "Optimisez ce code pour les performances. Expliquez ce que vous avez changé et pourquoi.",
      "description": "Optimiser le code"
    }
  ]
}
```

## Dépannage

| Problème                                           | Cause probable                                                | Solution                                                                                                             |
| -------------------------------------------------- | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| Continue.dev affiche "Connexion refusée"           | Ollama injoignable                                            | Vérifiez que le tunnel SSH est actif ; vérifiez que `curl http://localhost:11434/` fonctionne                        |
| La saisie semi-automatique ne se déclenche pas     | Le modèle de saisie semi-automatique par Tab n'est pas défini | Ajoutez `tabAutocompleteModel` dans config.json ; activez-le dans les paramètres de Continue                         |
| Réponses très lentes (>30 s pour le premier jeton) | Chargement du modèle depuis le disque                         | La première requête charge le modèle dans la VRAM — les requêtes suivantes sont rapides                              |
| Erreur "Modèle introuvable"                        | Le modèle n'a pas été téléchargé                              | Exécutez `docker exec ollama ollama pull <model-name>` sur le serveur Clore.ai                                       |
| Latence élevée entre les jetons                    | Latence réseau ou modèle trop volumineux                      | Utilisez le tunnel SSH ; passez à un modèle plus petit ; vérifiez l'utilisation du GPU du serveur                    |
| Le contexte de la base de code ne fonctionne pas   | Le modèle d'embeddings est manquant                           | Téléchargez `nomic-embed-text` via Ollama ; vérifiez `embeddingsProvider` dans config.json                           |
| Le tunnel SSH se déconnecte fréquemment            | Connexion instable                                            | Utilisez `autossh` pour une reconnexion persistante ; ajoutez `ServerAliveInterval 30`                               |
| La fenêtre de contexte est 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 |
| OOM de vLLM 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 — testez la connectivité
curl http://localhost:11434/api/tags          # si vous utilisez le 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                  # affiche 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 journaux 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
# Validez la syntaxe de config.json sur votre machine locale
python3 -c "
import json, sys
try:
    config = json.load(open(sys.argv[1]))
    print('✅ La 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
```

## Pour aller plus loin

* [Documentation Continue.dev](https://docs.continue.dev/) — documentation officielle pour toutes les intégrations IDE et les options de configuration
* [GitHub Continue.dev](https://github.com/continuedev/continue) — code source, problèmes, compatibilité des modèles
* [Référence de configuration Continue.dev](https://docs.continue.dev/reference) — schéma `config.json` — guide détaillé de configuration d'Ollama (backend recommandé)
* [Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — backend alternatif haute performance pour les équipes
* [vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — backend de saisie semi-automatique spécialisé avec optimisation FIM
* [TabbyML](https://tabby.tabbyml.com/) — choisissez le bon GPU pour votre charge de travail de codage
* [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) — quels modèles tiennent dans quelles tailles de VRAM
* [Compatibilité des modèles](/guides/guides_v2-fr/premiers-pas/model-compatibility.md) Qwen2.5-Coder
* [— actuellement le meilleur modèle de codage ouvert](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) — excellente alternative avec un long contexte
* [DeepSeek-Coder-V2](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct) — louez des serveurs GPU
* [la place de marché CLORE.AI](https://clore.ai/marketplace) — louez 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-ia-et-agents/continue-dev.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.