Continue.dev pour le codage IA

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

Continue.dev est un assistant de codage IA open-source pour VS Code et JetBrains avec plus de 25K étoiles sur GitHub. Le module 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é via Clore.ai, vous obtenez :

• Modèles de codage de premier ordre (34B+ 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 — payez uniquement pendant que vous codez (~0,20–0,50 $/h vs. 19 $/mois pour Copilot)

• API compatible OpenAI — Continue.dev se connecte de façon transparente à Ollama, vLLM ou TabbyML

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

Tous les exemples de serveurs GPU utilisent des serveurs loués via CLORE.AI Marketplace.

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.

Aperçu

Propriété	Détails
Projet	continuedev/continue
Licence	Apache 2.0
Étoiles GitHub	25K+
Prise en charge 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, APIs compatibles 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)
Principales caractéristiques	Autocomplétion, chat, mode édition, contexte du 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 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 de premier plan	Rivalise avec GPT-4 sur le code
qwen2.5-coder:7b	~6 Go	Code multilingue	Fort sur 40+ langages
qwen2.5-coder:32b	≈22 Go	À la pointe de la technologie	Meilleur modèle open pour le codage en 2024
starcoder2:15b	≈12 Go	Spécialiste de la complétion de code	Support FIM (fill-in-the-middle)

Exigences

Exigences serveur Clore.ai

Niveau	GPU	VRAM	RAM	Disque	Prix	Modèles
Économique	RTX 3060	12 Go	16 Go	40 Go	~0,10 $/h	CodeLlama 7B, DeepSeek 6.7B, Qwen2.5-Coder 7B
Recommandé	RTX 3090	24 Go	32 Go	80 Go	~0,20 $/h	CodeLlama 34B, DeepSeek 33B, Qwen2.5-Coder 32B
Performances	RTX 4090	24 Go	32 Go	80 Go	~0,35 $/h	Les mêmes modèles que ci-dessus, inférence plus rapide
Puissance	A100 40GB	40 Go	64 Go	120 Go	~0,60 $/h	Multiples modèles 34B simultanément
Maximum	A100 80GB	80 Go	80 Go	200 Go	~1,10 $/h	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 vers votre serveur Clore.ai

• Aucun 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.

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

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

# 3. Vérifier qu'Ollama est en cours d'exécution
curl http://localhost:11434/

# 4. Télécharger votre modèle de codage (choisissez en fonction de 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écharger 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érifier que les modèles sont disponibles
docker exec ollama ollama list

# 7. Tester 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 à l'extérieur (afin que votre IDE local puisse se connecter) :

# Redémarrer 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

# Tester depuis votre MACHINE LOCALE :
curl http://<clore-server-ip>:11434/api/tags

Exposer le port 11434 publiquement n'ajoute pas d'authentification par défaut. Pour une utilisation en production, configurez plutôt un tunnel SSH (voir Conseils et bonnes pratiques).

Option B — Backend vLLM (haut débit / compatible OpenAI)

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

# Démarrer 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="votre-token-huggingface" \
  --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="votre-token-huggingface" \
  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 texte fantôme. Voir le guide TabbyML pour les détails de configuration complets.

# 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. 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. File → Settings → 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 : Configurer Continue.dev pour utiliser Clore.ai

Éditer ~/.continue/config.json sur votre machine locale:

{
  "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 en 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 :

{
  "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) :

{
  "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 :

# 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

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

Tunnel persistant avec autossh

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

# Exécuter 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 Go), vous pouvez exécuter un grand modèle de chat et un petit modèle d'autocomplétion simultanément :

# Sur le serveur Clore.ai :

# Télécharger 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 l'échange de modèles
# Les trois tiennent dans 24 Go de VRAM avec un cache intelligent

# Surveiller 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 repo)

Continue.dev peut indexer votre base de code pour des suggestions conscientes du contexte. Téléchargez un modèle d'embeddings :

# Sur le serveur Clore.ai — ajouter 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.
# Lancer un ré-index manuel : Ctrl+Shift+P → "Continue: Index Codebase"

Accélération GPU

Surveiller les performances d'inférence

# Sur votre serveur Clore.ai — surveiller 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

Performance attendue 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 atteint 50–100 t/s — suffisamment rapide pour sembler instantané dans l'IDE.

Optimiser Ollama pour de meilleures performances

# Sur le serveur Clore.ai — optimiser 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

Configurer 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 :

{
  "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 texte fantôme"
    }
  ]
}

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 une RTX 3090 Clore.ai (~48 $/mois au total), le coût par utilisateur bat Copilot tout en fournissant un modèle privé et 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 :

# Enregistrez ceux-ci 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 !"

Utiliser les commandes personnalisées Continue.dev

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

{
  "customCommands": [
    {
      "name": "review",
      "prompt": "Passe en revue ce code pour détecter bugs, problèmes de sécurité et problèmes de performance. Sois précis et actionnable.",
      "description": "Revue de code"
    },
    {
      "name": "test",
      "prompt": "Écris des tests unitaires complets pour ce code. Inclue les cas limites. Utilise le même langage/cadre que le code.",
      "description": "Générer des tests"
    },
    {
      "name": "docstring",
      "prompt": "Ajoute des docstrings/commentaires clairs et complets à ce code en suivant les bonnes pratiques du langage.",
      "description": "Ajouter de la documentation"
    },
    {
      "name": "optimize",
      "prompt": "Optimise ce code pour les performances. Explique ce que tu as 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 tab non défini	Ajoutez tabAutocompleteModel dans config.json ; activez dans les paramètres Continue
Réponses très lentes (>30s 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 <model-name> sur le serveur Clore.ai
Latence élevée entre les tokens	Lag 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 déconnecte fréquemment	Connexion instable	Utilisez autossh pour reconnexion persistante ; ajoutez ServerAliveInterval 30
Fenêtre de contexte dépassée	Fichiers/conversations longs	Réduire 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

# 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érifier Ollama
docker logs ollama --tail 30 -f
docker exec ollama ollama list
docker exec ollama ollama ps                  # montrer 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 vLLM
docker logs vllm --tail 50 -f

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

Validation de la configuration Continue.dev

# 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 — docs officielles pour toutes les intégrations IDE et options de config

• GitHub Continue.dev — code source, problèmes, compatibilité des modèles

• Référence de configuration Continue.dev — complet config.json schéma

• Ollama sur Clore.ai — guide d'installation détaillé d'Ollama (backend recommandé)

• vLLM sur Clore.ai — backend alternatif haute performance pour les équipes

• TabbyML sur Clore.ai — backend d'autocomplétion spécialisé avec optimisation FIM

• Guide de comparaison GPU — choisissez le GPU adapté à votre charge de travail de codage

• Compatibilité des modèles — quels modèles tiennent dans quelles tailles de VRAM

• Qwen2.5-Coder — actuellement le meilleur modèle de codage open source

• DeepSeek-Coder-V2 — excellente alternative avec un long contexte

• CLORE.AI Marketplace — louer des serveurs GPU