Continue.dev 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 peu coûteuses pour une assistance IA privée au codage.

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.

Tous les exemples de serveurs GPU utilisent des serveurs loués via le 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+
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.

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

# 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

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).

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.

# 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 pour les détails complets de configuration.

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

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

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

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

# 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

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

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

# 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

# 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

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

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

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

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

# 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

# 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 — documentation officielle pour toutes les intégrations IDE et options de configuration

• Continue.dev GitHub — code source, issues, 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 — backend d'autocomplétion spécialisé avec optimisation FIM

• Guide de comparaison des GPU — choisissez le bon GPU pour 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 open pour le codage

• DeepSeek-Coder-V2 — alternative solide avec long contexte

• CLORE.AI Marketplace — louer des serveurs GPU