Continue.dev avec Claude Code : assistant IA dans VSCode — config 2026

Introduction

Chaque développeur qui a testé GitHub Copilot pendant quelques semaines s’est heurté tôt ou tard à la même limite : le modèle est imposé, la politique de données est opaque, et la facture mensuelle est incompressible même lorsque le quota est à moitié entamé. Continue.dev part d’un principe radicalement différent. C’est une extension open-source pour VSCode (et JetBrains) qui joue le rôle d’interface universelle entre votre éditeur et n’importe quel LLM — qu’il soit hébergé chez Anthropic, Google, Mistral, ou tournant localement via Ollama sur votre propre machine. Continue ne fournit aucun modèle. Il connecte. C’est la philosophie bring your own LLM appliquée directement dans l’éditeur de code.

Pour une équipe de développeurs au Sénégal, en Côte d’Ivoire ou au Mali, cette flexibilité n’est pas un détail esthétique : c’est la différence entre un outil accessible et un abonnement dollar qu’il faut justifier chaque mois face à un client en FCFA. Avec Continue.dev, vous pouvez démarrer en utilisant Claude Sonnet via l’API Anthropic pour les sessions de chat et de refactoring avancées, puis basculer vers un modèle Ollama local pour l’autocomplétion inline qui tourne gratuitement 24h/24 — sans une seule requête qui quitte votre réseau local.

Ce tutoriel couvre l’installation complète, la configuration de config.yaml avec Claude Sonnet, la mise en place d’Ollama comme backend d’autocomplétion gratuite, les custom slash commands, l’indexing du codebase par embeddings, et les trois modes d’interaction (Chat, Edit, Autocomplete). Durée estimée : 20 à 30 minutes pour une configuration fonctionnelle complète.

Prérequis

Avant de démarrer, assurez-vous de disposer des éléments suivants. VSCode version 1.87 ou plus récente est requis — la fonctionnalité d’indexing en arrière-plan a été stabilisée dans cette branche. Si vous êtes encore sur une version antérieure, la mise à jour s’impose.

Pour le backend LLM, deux options coexistent et peuvent être utilisées simultanément. La première est une clé API Anthropic : vous en créez une sur console.anthropic.com et vous l’utilisez pour les sessions de chat et d’édition assistée où la qualité du raisonnement prime. La seconde est Ollama installé en local — disponible sur Linux, macOS et Windows depuis ollama.com — qui sert de moteur d’autocomplétion inline gratuit. Les deux peuvent cohabiter dans le même fichier config.yaml.

Côté matériel, l’autocomplétion Ollama avec un modèle léger comme qwen2.5-coder:1.5b tourne sur une machine avec 8 Go de RAM. Pour codeqwen:7b, prévoyez 16 Go et idéalement un GPU. Pour l’API Anthropic, n’importe quelle connexion internet suffit — même une 4G stable.

Enfin, comptez environ vingt minutes pour tout configurer de zéro, davantage si vous souhaitez indexer un gros codebase et configurer des slash commands personnalisés.

Étape 1 — Continue.dev vs Cursor vs GitHub Copilot

Avant d’investir du temps dans une configuration, il vaut la peine de comprendre où Continue.dev se positionne dans l’écosystème des assistants IA pour développeurs, et pourquoi ce choix fait sens dans un contexte PME francophone.

GitHub Copilot est le produit historique qui a démocratisé l’autocomplétion IA. Il est profondément intégré dans VSCode, fonctionne dès l’installation, et propose depuis 2025 un mode agent autonome. Sa limite structurelle reste la même : vous n’avez aucun contrôle sur le modèle sous-jacent — Microsoft choisit pour vous — et vous ne pouvez pas utiliser votre propre clé API ni pointer vers un LLM local. Le prix est fixe à 10 USD par mois et par développeur. Pour une équipe de cinq personnes à Abidjan facturant en FCFA, c’est une charge prévisible mais non négociable.

Cursor est un fork complet de VSCode avec l’IA intégrée au niveau de l’éditeur lui-même. Son avantage principal est l’accès au contexte global du codebase avant de répondre, ce qui produit des suggestions très pertinentes sur de grandes bases de code. Cursor permet d’utiliser ses propres clés API pour contourner les crédits mensuels. En revanche, Cursor reste un éditeur propriétaire : vous migrez tout votre environnement de travail vers un fork dont vous ne contrôlez pas la feuille de route.

Continue.dev occupe une position distincte : c’est une extension, pas un éditeur. Vous gardez votre VSCode habituel avec toutes vos extensions existantes, tous vos paramètres, tous vos thèmes. Continue s’y greffe sans rien remplacer. Il est 100 % open-source (licence Apache 2.0, code source sur github.com/continuedev/continue), supporte une liste de providers sans équivalent (Anthropic, OpenAI, Gemini, Mistral, Ollama, LM Studio, AWS Bedrock, Azure, Groq, et tout endpoint compatible OpenAI), et peut fonctionner entièrement offline avec Ollama. Pour une équipe avec des contraintes budgétaires ou des exigences de confidentialité des données, c’est l’option la plus souple du marché en 2026.

Étape 2 — Installer l’extension VSCode

L’installation est délibérément simple. Continue.dev est disponible sur le marketplace officiel VSCode et s’installe comme n’importe quelle extension.

Ouvrez VSCode, accédez au panneau Extensions avec le raccourci Ctrl+Shift+X (ou Cmd+Shift+X sur Mac), tapez Continue dans la barre de recherche, et installez l’extension publiée par Continue (identifiant Continue.continue). Vous pouvez également l’installer depuis la ligne de commande :

# Installation via CLI VSCode
code --install-extension Continue.continue

Après installation, une icône Continue apparaît dans la barre latérale gauche de VSCode. Au premier lancement, l’extension vous propose un assistant de configuration rapide : vous pouvez choisir entre plusieurs providers et entrer votre clé API directement dans l’interface. Cependant, pour un contrôle précis de la configuration — notamment pour définir des modèles différents selon les rôles (chat vs autocomplétion), des slash commands personnalisés et un provider d’embeddings — il est préférable d’éditer directement le fichier config.yaml.

Ce fichier de configuration principal se trouve dans votre répertoire personnel : ~/.continue/config.yaml sous Linux et macOS, C:\Users\VotreNom\.continue\config.yaml sous Windows. L’extension crée ce fichier automatiquement avec un exemple commenté lors du premier démarrage. Pour l’ouvrir depuis Continue, cliquez sur l’icône d’engrenage en bas du panneau Continue, puis sur Open config.yaml.

Étape 3 — Configurer config.yaml avec Claude Sonnet via l’API Anthropic

Le fichier config.yaml est le cœur de Continue.dev. Chaque comportement de l’extension — quel modèle répond dans le chat, quel modèle propose les complétions, comment le codebase est indexé, quels slash commands sont disponibles — est défini ici. La structure suit le schéma officiel disponible sur docs.continue.dev/reference.

Voici une configuration minimale fonctionnelle pour démarrer avec Claude Sonnet comme modèle principal de chat. Commencez par ouvrir ~/.continue/config.yaml et remplacez le contenu par :

name: Ma config PME
version: 1
schema: v1

models:
  - name: Claude Sonnet 4
    provider: anthropic
    model: claude-sonnet-4-5
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}
    roles:
      - chat
      - edit

  - name: Claude Haiku (rapide)
    provider: anthropic
    model: claude-haiku-4-5
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}
    roles:
      - summarize

La notation ${{ secrets.ANTHROPIC_API_KEY }} indique à Continue de lire la valeur depuis un fichier .env placé dans le même répertoire ~/.continue/. Créez ce fichier ~/.continue/.env et ajoutez-y une seule ligne : ANTHROPIC_API_KEY=sk-ant-votre-cle-ici. Cette séparation entre la configuration et les secrets est importante : elle vous permet de versionner votre config.yaml dans un dépôt Git sans exposer vos clés.

Le champ roles indique à Continue dans quel contexte utiliser ce modèle. chat correspond aux conversations dans le panneau latéral, edit au mode d’édition inline (sélectionnez du code, appuyez sur Ctrl+I, décrivez la modification souhaitée). Après avoir sauvegardé le fichier, Continue recharge la configuration automatiquement. Ouvrez le panneau Continue, envoyez un message de test, et vérifiez que la réponse provient bien de Claude.

Étape 4 — Backend Ollama local pour l’autocomplétion gratuite

L’autocomplétion inline est la fonctionnalité la plus utilisée au quotidien : pendant que vous tapez, Continue suggère la suite du code que vous validez avec la touche Tab. Cette fonctionnalité génère un très grand nombre de requêtes — plusieurs dizaines par minute en session active — ce qui la rend coûteuse si elle est reliée à une API payante. La stratégie recommandée est donc de la connecter à Ollama en local, où les requêtes sont gratuites et instantanées.

Vérifiez d’abord qu’Ollama est en cours d’exécution. Ouvrez un terminal et tapez curl http://localhost:11434 : si vous recevez Ollama is running, tout va bien. Ensuite, téléchargez un modèle adapté à l’autocomplétion. Pour une machine avec 8 Go de RAM, le modèle Qwen2.5 Coder 1.5B est un bon point de départ :

# Télécharger le modèle d'autocomplétion léger
ollama pull qwen2.5-coder:1.5b

# Si vous avez 16 Go de RAM et souhaitez plus de qualité
ollama pull qwen2.5-coder:7b

Le téléchargement prend quelques minutes selon votre connexion. Une fois terminé, ajoutez le modèle à votre config.yaml en lui assignant le rôle autocomplete :

models:
  # ... vos modèles Claude existants ...

  - name: Qwen Coder local (autocomplete)
    provider: ollama
    model: qwen2.5-coder:1.5b
    apiBase: http://localhost:11434
    roles:
      - autocomplete

Après sauvegarde du fichier, revenez dans un fichier de code dans VSCode et commencez à taper : vous devriez voir apparaître des suggestions grises en italique après une courte latence. La touche Tab les accepte, Échap les rejette. Si les suggestions n’apparaissent pas, vérifiez que le serveur Ollama tourne bien (ollama serve dans un terminal), puis ouvrez la sortie de Continue dans VSCode via Affichage → Sortie → Continue pour inspecter les éventuels messages d’erreur.

Étape 5 — Custom slash commands

Les slash commands sont des raccourcis textuels que vous tapez dans le panneau Chat de Continue pour déclencher des actions prédéfinies. Continue fournit plusieurs commandes intégrées (/edit, /comment, /test) mais vous pouvez définir les vôtres pour automatiser les tâches répétitives spécifiques à votre projet ou à votre équipe.

Supposons que votre équipe écrit fréquemment des fonctions Python et a besoin que chaque fonction soit accompagnée d’une docstring au format Google. Vous créez une commande /docstring qui envoie automatiquement le bon prompt à Claude. Dans votre config.yaml, ajoutez une section customCommands :

customCommands:
  - name: docstring
    description: "Génère une docstring Google-style pour la fonction sélectionnée"
    prompt: |
      Génère une docstring au format Google Python pour cette fonction.
      Inclus les sections Args, Returns et Raises si pertinent.
      Réponds uniquement avec la docstring, sans répéter le code.
      {{{ input }}}

  - name: review
    description: "Code review sécurité et performance"
    prompt: |
      Effectue une revue de code en te concentrant sur :
      1. Les failles de sécurité potentielles
      2. Les problèmes de performance évidents
      3. La lisibilité et les conventions PEP 8 / PSR-12
      Sois concis, liste les problèmes par ordre de priorité.
      {{{ input }}}

Le marqueur {{{ input }}} sera remplacé soit par le texte sélectionné dans l’éditeur, soit par ce que vous tapez après le nom de la commande. Une fois le fichier sauvegardé, tapez /doc dans le chat Continue et l’autocomplétion proposera votre commande. Sélectionnez d’abord un bloc de code dans l’éditeur, puis invoquez /docstring : Continue envoie le code sélectionné à Claude avec le prompt défini et retourne la docstring générée directement dans le chat.

Étape 6 — Codebase indexing avec embeddings

L’une des fonctionnalités les plus puissantes de Continue est sa capacité à indexer votre codebase entier par embeddings et à utiliser cet index pour retrouver automatiquement les fichiers les plus pertinents à inclure dans le contexte de chaque requête. Cela permet de poser des questions comme « Comment est gérée l’authentification dans ce projet ? » sans avoir à sélectionner manuellement les bons fichiers.

Par défaut, Continue utilise un modèle d’embeddings intégré à l’extension (all-MiniLM-L6-v2 via Transformers.js, embeddings de taille 384). Ce modèle tourne en local sans requête externe et convient à la plupart des projets de taille moyenne. Pour activer l’indexing, ouvrez votre workspace VSCode et tapez Ctrl+Shift+P puis cherchez Continue: Index Codebase. L’indexing se lance en arrière-plan et peut prendre quelques minutes selon la taille du projet.

Pour de meilleures performances sur du code, vous pouvez configurer un modèle d’embeddings dédié. Ollama propose le modèle nomic-embed-text qui est rapide et gratuit :

# Télécharger le modèle d'embeddings
ollama pull nomic-embed-text

# Dans config.yaml, ajouter le provider d'embeddings
models:
  # ... vos modèles existants ...

  - name: Nomic Embeddings local
    provider: ollama
    model: nomic-embed-text
    apiBase: http://localhost:11434
    roles:
      - embed

Une fois l’index construit, utilisez le raccourci Ctrl+Enter dans le chat (au lieu de Enter seul) pour que Continue interroge automatiquement l’index et inclue les fichiers pertinents dans le contexte. Vous pouvez également mentionner explicitement @codebase dans votre message pour forcer l’utilisation de l’index. L’index est mis à jour automatiquement à chaque modification de fichier dans votre workspace.

Étape 7 — Modes Chat, Edit et Autocomplete

Continue expose trois modes d’interaction distincts, chacun adapté à un type de tâche. Les comprendre permet d’utiliser l’outil de manière beaucoup plus efficace au quotidien.

Le mode Chat est accessible via le panneau latéral Continue (icône dans la barre d’activité). C’est une conversation classique avec le LLM, enrichie par la possibilité d’ajouter du contexte précis via des mentions. Tapez @ suivi du nom d’un fichier pour l’inclure directement, @codebase pour interroger l’index d’embeddings, @docs pour interroger une documentation externe que vous aurez indexée, ou encore @terminal pour inclure le contenu du terminal actif. Le raccourci Ctrl+L (ou Cmd+L sur Mac) ouvre immédiatement le chat et y colle la sélection courante.

Le mode Edit est conçu pour la modification de code en place. Sélectionnez un bloc de code dans l’éditeur, appuyez sur Ctrl+I, décrivez la transformation souhaitée en langage naturel, et Continue génère les modifications et les affiche dans une vue diff directement dans l’éditeur. Vous acceptez chaque modification bloc par bloc avec Ctrl+Shift+Enter ou vous les rejetez. C’est le mode le plus adapté au refactoring ciblé, à la correction de bugs ou à l’ajout de gestion d’erreurs.

Le mode Autocomplete fonctionne en arrière-plan en permanence, sans interaction explicite. Continue observe ce que vous tapez et prédit la suite du code — une ligne, un bloc entier, une signature de fonction complète. La qualité et la vitesse dépendent du modèle configuré sous le rôle autocomplete. Avec Ollama en local, la latence est typiquement entre 300 ms et 1 seconde selon le modèle et votre matériel. Si vous trouvez les suggestions trop intrusives, vous pouvez désactiver temporairement l’autocomplétion via Ctrl+Shift+P → Continue: Toggle Autocomplete.

Erreurs fréquentes

Adaptation au contexte ouest-africain

Utiliser Continue.dev dans le contexte d’une PME ou d’une équipe de freelances en Afrique de l’Ouest nécessite quelques ajustements stratégiques par rapport au cas d’usage européen ou nord-américain classique. Trois dimensions méritent une attention particulière : le contrôle du budget API, l’autonomie offline et la performance sur des réseaux variables.

LiteLLM proxy pour budget équipe partagé

Lorsqu’une équipe de cinq développeurs utilise tous Claude Sonnet via leur propre clé Anthropic, le suivi de la consommation devient rapidement opaque. La solution consiste à déployer un proxy LiteLLM sur un VPS partagé (un VPS à 5 USD/mois chez DigitalOcean ou Hetzner suffit) et à faire pointer tous les config.yaml de l’équipe vers ce proxy. LiteLLM expose une API compatible OpenAI tout en routant vers Anthropic en backend, et fournit un tableau de bord de consommation par clé utilisateur. Dans chaque config.yaml d’équipe :

models:
  - name: Claude via LiteLLM Equipe
    provider: openai  # LiteLLM expose une API compatible OpenAI
    model: claude-sonnet-4-5
    apiBase: http://votre-vps-litellm:4000
    apiKey: sk-litellm-cle-equipe
    roles:
      - chat
      - edit

Cette architecture permet au responsable technique de définir un budget mensuel global, de voir qui consomme quoi, et de couper l’accès individuellement sans toucher aux clés Anthropic. C’est une solution bien adaptée aux équipes distribuées entre Dakar, Abidjan et Bamako où la facturation centralisée est difficile.

Ollama CodeQwen pour l’autocomplétion sans aucune API

Pour les développeurs qui travaillent régulièrement dans des environnements à connectivité limitée — bureaux avec coupures fréquentes, déplacements, zones rurales — configurer Ollama en autocomplétion locale est essentiel. Les modèles de la famille Qwen2.5 Coder sont particulièrement bien adaptés car ils ont été entraînés spécifiquement sur du code source et produisent des complétions cohérentes même sur le modèle 1.5B qui tient en RAM sur une machine standard. Une fois le modèle téléchargé (ollama pull qwen2.5-coder:1.5b), l’autocomplétion fonctionne sans aucune connexion internet, ce qui est un avantage considérable lors de coupures 4G ou de connexions internet haut débit indisponibles.

RAG codebase locale pour travail offline

La fonctionnalité d’indexing par embeddings prend une dimension critique dans un contexte offline. Si vous configurez le provider d’embeddings sur Ollama (nomic-embed-text ou mxbai-embed-large), l’index de votre codebase est construit localement, sans aucune requête externe. Ainsi, même en coupure totale de réseau, le raccourci Ctrl+Enter interroge l’index local et retourne les fichiers pertinents — Continue peut ensuite les passer au modèle Ollama local pour un flux de travail entièrement offline. Pour un projet de 50 000 lignes de code, l’index occupe environ 200 Mo sur disque et se reconstruit en moins de deux minutes sur un SSD récent.

Tutoriels frères

Ce tutoriel s’inscrit dans le cluster LLM Self-Hosted. Les articles suivants couvrent des sujets complémentaires et sont conçus pour être lus dans la continuité de celui-ci :

• OpenWebUI : interface ChatGPT-like pour vos LLM locaux — installation sur VPS — déployez une interface web complète pour partager vos modèles Ollama avec toute l’équipe
• LiteLLM proxy : gérez le budget LLM de votre équipe avec un seul endpoint — le tutoriel complet du proxy évoqué dans la section adaptation ouest-africaine ci-dessus

Pour aller plus loin

• Retour au pilier : LLM en self-hosted pour PME francophone : OpenWebUI, LiteLLM, vLLM (2026)
• Documentation officielle Continue.dev : docs.continue.dev
• Code source et issues : github.com/continuedev/continue
• Configuration du provider Anthropic : docs.continue.dev/customize/model-providers/top-level/anthropic
• Documentation autocomplétion : docs.continue.dev/customize/deep-dives/autocomplete
• Codebase context provider : docs.continue.dev/customize/context/codebase

FAQ

Q : Continue.dev est-il vraiment gratuit, ou y a-t-il un abonnement caché ?
R : L’extension elle-même est gratuite et open-source (Apache 2.0). Continue ne facture rien. Les coûts potentiels viennent uniquement des LLM que vous choisissez d’utiliser : si vous configurez Claude via l’API Anthropic, Anthropic vous facture à l’usage. Si vous configurez uniquement Ollama en local, le coût est zéro. Il n’y a pas d’abonnement Continue ni de version Pro.

Q : Mes données de code sont-elles envoyées à Continue ou à des tiers ?
R : Continue n’a aucun backend central qui reçoit votre code. Les requêtes vont directement depuis votre VSCode vers le provider LLM que vous avez configuré (Anthropic, Ollama local, etc.). Si vous utilisez Ollama, rien ne quitte votre machine. Si vous utilisez l’API Anthropic, vos prompts sont soumis à la politique de confidentialité d’Anthropic. Continue lui-même ne stocke rien en dehors de votre machine.

Q : Peut-on utiliser Continue.dev avec JetBrains (IntelliJ, PyCharm, etc.) ?
R : Oui. Continue.dev est disponible pour JetBrains via le JetBrains Marketplace. Le fichier config.yaml est partagé entre les deux extensions : une configuration faite dans VSCode fonctionne immédiatement dans IntelliJ sans modification.

Q : Quelle est la différence entre taper Enter et Ctrl+Enter dans le chat ?
R : Enter envoie votre message en utilisant uniquement le contexte que vous avez explicitement fourni (fichiers mentionnés avec @, sélection copiée). Ctrl+Enter déclenche en plus une recherche dans l’index d’embeddings de votre codebase et ajoute automatiquement les extraits de code les plus pertinents au contexte. Utilisez Ctrl+Enter pour les questions architecturales sur votre projet, Enter pour les questions générales.

Q : L’autocomplétion Ollama fonctionne-t-elle sur tous les langages de programmation ?
R : Les modèles Qwen2.5 Coder et DeepSeek Coder supportent les principaux langages : Python, JavaScript, TypeScript, PHP, Java, C/C++, Go, Rust, SQL, HTML/CSS et plusieurs autres. La qualité varie selon le langage — Python et JavaScript sont les mieux couverts car ils sont surreprésentés dans les données d’entraînement. Pour du code très spécialisé ou des langages rares, les suggestions peuvent être moins pertinentes.

Q : Comment migrer une équipe de GitHub Copilot vers Continue.dev sans perturber les habitudes ?
R : La transition la plus douce consiste à déployer Continue en parallèle de Copilot pendant une semaine, sans désactiver Copilot. Chaque développeur teste Continue pour les tâches de chat et de refactoring, tout en gardant Copilot pour l’autocomplétion. Une fois la configuration Ollama validée et la qualité des suggestions jugée satisfaisante, on désactive l’autocomplétion Copilot dans les paramètres VSCode et on active celle de Continue. Copilot peut ensuite être résilié au prochain cycle de facturation. L’avantage est que les raccourcis clavier de Continue (Ctrl+L pour le chat, Ctrl+I pour l’édition inline) sont différents de ceux de Copilot, ce qui évite les conflits.

Q : Est-il possible de configurer des instructions système persistantes (system prompt) pour tout le chat ?
R : Oui. Dans config.yaml, chaque modèle accepte un champ systemMessage qui définit des instructions persistantes envoyées avec chaque requête. Vous pouvez y préciser le contexte de votre projet, la stack technique, les conventions de code adoptées par l’équipe, ou le niveau de détail attendu dans les réponses. Cela évite de répéter le contexte à chaque conversation.