Remplacer GitHub Copilot : Ollama + Continue.dev

laptop_mac macOS Sonoma Intermediate schedule 8 min read

by Alex Rivera • May 14, 2024

Step 1 Le Coût de l'Autocomplétion Cloud vs l'IA Locale

Chaque frappe que vous tapez dans VS Code avec GitHub Copilot actif est transmise vers l'infrastructure OpenAI hébergée sur Azure de Microsoft. Ce n'est pas une théorie du complot — c'est l'architecture produit documentée. Vos algorithmes propriétaires, votre logique métier interne, vos fonctionnalités non publiées et vos décisions architecturales quittent toutes votre machine. Pour les développeurs individuels travaillant sur des projets personnels, ce compromis est souvent acceptable. Pour les équipes développant des logiciels commercialement sensibles, c'est un risque matériel en matière de sécurité et de conformité.

Il y a aussi la dimension financière.

La Réalité des Tarifs GitHub Copilot

Pour une organisation d'ingénierie de taille moyenne de 50 développeurs sur le niveau Business, vous regardez $11 400 par an — payés indéfiniment, à un fournisseur externe, sans propriété du modèle sous-jacent ni garantie de stabilité des prix. Microsoft a déjà révisé les tarifs de Copilot à la hausse depuis le lancement, et il n'y a aucune raison structurelle de s'attendre à ce que cette tendance s'inverse.

Ce que Signifie Réellement « l'IA Locale »

Exécuter un modèle local via Ollama change complètement l'équation. Le coût de calcul correspond à votre matériel existant. Le modèle de confidentialité est absolu — aucune donnée ne quitte votre machine. La latence est souvent inférieure à celle de l'autocomplétion cloud, car vous éliminez le temps d'aller-retour réseau vers des serveurs d'inférence distants.

Cloud Copilot flow:
Keypress → VS Code → HTTPS → Azure OpenAI → Inference → Response → VS Code

Local Ollama flow:
Keypress → VS Code → localhost:11434 → Inference → Response → VS Code

Le chemin d'inférence en localhost supprime toute une catégorie de modes de défaillance : les pannes d'API, la limitation de débit, les interférences des proxys d'entreprise et la variance de latence géographique. Les développeurs derrière des pare-feux d'entreprise stricts qui ne pouvaient auparavant pas utiliser Copilot peuvent désormais exécuter un modèle de code pleinement capable sans toucher au périmètre réseau.

Les Coûts Cachés de la Dépendance au Cloud

Au-delà des frais de licence, l'autocomplétion cloud introduit un couplage opérationnel qu'il est facile de sous-estimer :

• Dépendance à un fournisseur : Le flux de travail de votre équipe devient dépendant d'un service tiers disposant d'un contrôle unilatéral sur la tarification, la disponibilité et les conditions d'utilisation.
• Surcharge de conformité : De nombreux secteurs réglementés (santé, finance, défense) exigent des accords formels de traitement des données et des audits de sécurité pour tout outil transmettant du code en externe. Le processus d'approbation de Copilot est loin d'être trivial dans ces environnements.
• Fuite de la fenêtre de contexte : Les modèles cloud reçoivent non seulement votre fichier actuel, mais aussi les tampons de contexte environnants — fichiers adjacents, onglets récemment ouverts et métadonnées du dépôt selon la configuration.
• Lacunes dans la piste d'audit : Lorsque les suggestions de code proviennent d'une boîte noire externe, l'attribution de la provenance de la propriété intellectuelle devient complexe en cas de litige ou de conflit de licence.

Où les modèles locaux sont compétitifs aujourd'hui

Les modèles quantifiés modernes tels que Code Llama 13B et StarCoder2 7B fonctionnant sur du matériel grand public atteignent une qualité de complétion véritablement compétitive avec Copilot pour les scénarios d'autocomplétion les plus courants : génération de code passe-partout, complétion de signatures de fonctions, création de squelettes de tests et implémentations d'algorithmes courants. L'écart se réduit encore davantage lorsque le modèle opère sur du code dans des langages et des schémas sur lesquels il a été spécifiquement entraîné.

Le calcul est simple : coût marginal nul, souveraineté totale des données et aucune dépendance externe face à une facture SaaS croissante et un accord implicite de partage de votre base de code avec un fournisseur d'inférence cloud. Pour les équipes soucieuses de la maîtrise à long terme de leur chaîne d'outils, l'approche locale n'est pas un compromis — c'est le choix architectural le plus défendable.

Step 2 Prérequis : VS Code et Ollama

Avant de plonger dans la configuration, vous devez disposer de deux composants fondamentaux installés et vérifiés. Ne pas valider correctement les prérequis est la principale raison pour laquelle les développeurs perdent des heures à déboguer ce qui devrait être une configuration locale d'IA simple. Faites-le bien, et tout le reste devient mécanique.

Visual Studio Code

Vous avez besoin de VS Code 1.80 ou ultérieur. L'extension Continue.dev dépend des API modernes de VS Code pour les complétions en ligne de type texte fantôme, et les versions plus anciennes échoueront silencieusement ou produiront un comportement dégradé.

Vérifiez votre version depuis la ligne de commande :

code --version

Résultat attendu (le vôtre peut être plus récent) :

1.89.1
e170252f762678dec6ca2cc69aba1864a9a1f8ad
x64

Si vous utilisez un fork tel que VSCodium, Continue.dev est entièrement compatible — assurez-vous simplement de télécharger l'extension depuis le registre Open VSX plutôt que depuis le Microsoft Marketplace, car VSCodium n'inclut pas l'hôte d'extensions propriétaire de Microsoft par défaut.

Ollama

Ollama est le moteur d'exécution de modèles locaux qui gère les téléchargements de modèles, la gestion de la quantification et expose une API REST compatible OpenAI sur localhost:11434. Cette couche de compatibilité est précisément la raison pour laquelle Continue.dev s'y intègre si proprement — aucune architecture de plugin personnalisée n'est requise.

Installation par plateforme :

Après l'installation, démarrez le daemon Ollama :

ollama serve

Sur macOS, Ollama s'exécute automatiquement en tant qu'application dans la barre de menus après l'installation. Sur Linux, vous pouvez le configurer en tant que service systemd :

sudo systemctl enable ollama
sudo systemctl start ollama

Vérifiez que l'API est active :

curl http://localhost:11434/api/tags

Une réponse réussie renvoie un objet JSON listant vos modèles installés localement. Une liste vide est normale à cette étape — le téléchargement des modèles intervient dans une étape ultérieure.

{
  "models": []
}

Considérations matérielles

C'est là que la plupart des tutoriels vous laissent sans réponse. Votre matériel détermine directement quels modèles sont viables et à quel niveau de quantification.

Ollama décharge automatiquement les couches vers votre GPU via Metal (Apple Silicon), CUDA (NVIDIA) ou ROCm (AMD). Aucune configuration manuelle n'est requise — Ollama détecte votre matériel et optimise le déchargement des couches de manière transparente.

Note importante pour les utilisateurs d'Apple Silicon : La mémoire unifiée est partagée entre le CPU et le GPU. Un MacBook Pro M3 avec 16 Go peut faire tourner confortablement un modèle 13B car il n'y a pas de plafond de VRAM discrète. C'est l'un des arguments les plus solides en faveur d'Apple Silicon dans les flux de travail d'IA locale.

Validation de votre environnement

Effectuez cette vérification rapide avant de continuer :

# Confirm VS Code version
code --version

# Confirm Ollama is running and responsive
curl -s http://localhost:11434/api/tags | python3 -m json.tool

# Confirm GPU acceleration (Ollama logs)
ollama run llama3.2:1b "say ok"

Observez la sortie du terminal Ollama pendant l'inférence du modèle. Vous devriez voir des compteurs de déchargement de couches faisant référence à votre GPU. Si tout s'exécute sur le CPU, revérifiez l'installation de vos pilotes avant de télécharger des modèles de code plus volumineux.

Une fois les deux prérequis confirmés, vous êtes prêt à installer Continue.dev et à tout connecter ensemble.

Step 3 Étape 1 : Installation de l'extension Continue.dev

Continue.dev est la pierre angulaire de toute cette configuration — un assistant de code IA open-source qui agit comme un remplacement direct de GitHub Copilot, mais avec une différence architecturale critique : il achemine vos requêtes là où vous le lui indiquez, y compris vers une instance Ollama exécutée localement. Pas de télémétrie. Pas de transit vers le cloud. Pas d'abonnement.

Installation depuis le marketplace VS Code

Le chemin d'installation le plus simple passe directement par le marketplace d'extensions VS Code, depuis l'éditeur :

1. Ouvrez VS Code
2. Appuyez sur Ctrl+Shift+X (Windows/Linux) ou Cmd+Shift+X (macOS) pour ouvrir le panneau Extensions
3. Recherchez "Continue"
4. Localisez l'extension publiée par Continue (l'icône est un logo distinctif avec un dégradé violet)
5. Cliquez sur Installer

Vous pouvez également l'installer depuis la ligne de commande via le CLI de VS Code :

code --install-extension Continue.continue

Ou si vous utilisez VS Codium (le fork sans télémétrie), l'extension est disponible sur le registre Open VSX :

codium --install-extension Continue.continue

Remarque : Continue.dev prend également en charge les IDE JetBrains (IntelliJ, PyCharm, GoLand, etc.) via un plugin séparé, mais ce guide se concentre exclusivement sur l'intégration VS Code.

Vérification de l'installation

Une fois installé, vous devriez constater deux changements immédiats dans votre environnement VS Code :

Cliquez sur l'icône Continue dans la barre d'activités pour ouvrir le panneau latéral. Au premier lancement, Continue affichera un flux d'intégration vous invitant à connecter un fournisseur. Vous pouvez ignorer ou fermer cette étape — nous configurerons Ollama manuellement à l'étape suivante en modifiant directement config.json, ce qui nous offre bien plus de contrôle que l'assistant graphique.

Comprendre l'architecture de l'extension

Avant d'aller plus loin, il est utile de comprendre ce que Continue installe réellement et comment il communique :

VS Code Extension (Continue.dev)
        │
        ▼
  config.json  ──────────────────────────────────────────────────┐
        │                                                          │
        ▼                                                          ▼
  Chat Provider (LLM)                               Autocomplete Provider (LLM)
  e.g., Ollama → llama3                             e.g., Ollama → starcoder2
        │                                                          │
        └────────────────────────┬─────────────────────────────────┘
                                 │
                                 ▼
                    http://localhost:11434  (Ollama REST API)

Continue sépare le chat et l'autocomplétion en deux fournisseurs configurables indépendamment. Il s'agit d'une distinction puissante — vous pouvez exécuter un modèle large et optimisé pour les instructions comme llama3 ou deepseek-coder pour les requêtes conversationnelles, tout en utilisant un modèle léger de type fill-in-the-middle comme starcoder2:3b pour des complétions en ligne à faible latence. Aucune autre alternative grand public à Copilot n'expose ce niveau de granularité des fournisseurs.

Localiser le fichier config.json

Le comportement complet de Continue est contrôlé par un unique fichier JSON. Sachez où il se trouve :

Vous pouvez l'ouvrir directement depuis VS Code en utilisant l'icône d'engrenage des paramètres du panneau Continue, ou y accéder manuellement depuis votre terminal :

# macOS / Linux
cat ~/.continue/config.json

# Windows (PowerShell)
Get-Content "$env:USERPROFILE\.continue\config.json"

Une fois l'extension installée et le fichier de configuration localisé, vous êtes prêt à pointer Continue vers votre instance Ollama locale.

Step 4 Étape 2 : Configurer config.json pour Ollama

Une fois Continue.dev installé, l'intégralité du comportement de l'extension est gouvernée par un seul fichier : config.json. C'est ici que vous connectez Continue à votre instance Ollama locale, définissez quels modèles gèrent le chat par rapport à l'autocomplétion, et ajustez les paramètres de performance. Bien configurer ce fichier fait toute la différence entre une configuration lente et peu fiable et une configuration qui rivalise avec GitHub Copilot en termes de réactivité.

Localiser config.json

Continue stocke sa configuration dans votre répertoire personnel :

Vous pouvez également l'ouvrir directement depuis VS Code en utilisant la barre latérale de Continue — cliquez sur l'icône d'engrenage en bas du panneau Continue, et cela ouvrira config.json dans l'éditeur.

La Configuration Minimale pour Ollama

Voici un fichier config.json de référence prêt pour la production, qui connecte Continue à une instance Ollama en cours d'exécution en local pour le chat et la complétion automatique par onglet :

{
  "models": [
    {
      "title": "CodeLlama 13B (Chat)",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B (Autocomplete)",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://localhost:11434"
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "maxPromptTokens": 1024,
    "prefixPercentage": 0.85
  },
  "allowAnonymousTelemetry": false
}

Pourquoi deux modèles séparés ? Les modèles de chat sont optimisés pour le suivi d'instructions et le dialogue multi-tours. Les modèles d'autocomplétion — en particulier ceux entraînés avec le Fill-in-the-Middle (FIM) — sont spécifiquement ajustés pour prédire du code à partir d'une fenêtre de contexte composée d'un préfixe et d'un suffixe. Confondre les deux dégrade les deux expériences.

Décryptage de Chaque Champ

Tableau models — Il définit les modèles disponibles dans le panneau de chat de Continue. Vous pouvez ajouter plusieurs entrées et basculer entre elles à l'exécution. Chaque objet requiert : - provider : défini sur "ollama" pour l'inférence locale - model : le tag exact tel qu'il apparaît dans ollama list - apiBase : le point de terminaison REST par défaut d'Ollama ; ne le modifiez que si vous avez remappé le port

tabAutocompleteModel — Une entrée dédiée à la complétion automatique en ligne. Ce modèle se déclenche à chaque pause de frappe, donc plus petit et plus rapide est préférable ici. Un modèle de 3B–7B paramètres avec support FIM est le point idéal.

tabAutocompleteOptions — Contrôle précis du moteur de complétion automatique :

allowAnonymousTelemetry — Définissez ceci à false. Vous exécutez une IA locale spécifiquement pour garder votre code hors des serveurs tiers ; il n'y a aucune raison d'envoyer des données de télémétrie au pipeline d'analyse de Continue.

Vérification de la connexion

Après avoir sauvegardé config.json, confirmez qu'Ollama est accessible depuis Continue en ouvrant la palette de commandes VS Code (Cmd+Shift+P / Ctrl+Shift+P) et en exécutant :

Continue: Open Debug Panel

Vous devriez voir un indicateur de statut vert et un ping de modèle réussi. Si vous rencontrez une erreur connection refused, vérifiez qu'Ollama est en cours d'exécution avec :

ollama serve
# or check its status
curl http://localhost:11434/api/tags

Une réponse JSON valide listant vos modèles téléchargés confirme que l'API est active et que Continue peut procéder à la fourniture de complétions.

Step 5 Étape 3 : Téléchargement de Code Llama ou StarCoder2

Avec Continue.dev installé et votre config.json configuré, la prochaine décision critique est quel modèle vous téléchargez réellement sur votre machine. Pour la complétion de code locale et le chat, deux modèles dominent la conversation : Code Llama (Meta) et StarCoder2 (BigCode/Hugging Face). Les deux fonctionnent excellemment via Ollama, mais ils ont des forces significativement différentes. Décomposons-les, puis passons en revue les commandes de téléchargement exactes.

Comparaison des modèles en un coup d'œil

Recommandation : Si vous disposez de 8 Go de VRAM ou de RAM à spare, commencez avec codellama:7b-code pour une expérience équilibrée. Si vous êtes purement concentré sur la qualité de la complétion automatique en ligne et le support multi-langage, starcoder2:7b le surpasse fréquemment sur les benchmarks de remplissage au milieu (FIM).

Téléchargement de Code Llama via Ollama

Ollama rend la gestion des modèles extrêmement simple. Ouvrez votre terminal et exécutez :

# Lightweight 7B instruct variant — best starting point
ollama pull codellama:7b-instruct

# 7B code-specialized variant — better raw completion, less chat
ollama pull codellama:7b-code

Si vous avez la marge matérielle nécessaire (13B est nettement plus précis)

ollama pull codellama:13b-instruct

La variante `instruct` comprend les instructions en langage naturel et est idéale pour le **panneau de chat** dans Continue.dev. La variante `code` est allégée et optimisée uniquement pour les tâches de complétion — considérez-la comme la variante « moteur d'autocomplétion ».

Après le téléchargement, vérifiez que le modèle est disponible :

```bash
ollama list

Vous devriez voir une sortie similaire à :

NAME                    ID              SIZE    MODIFIED
codellama:7b-instruct   8fdf8f752f6e    3.8 GB  2 minutes ago

Téléchargement de StarCoder2 via Ollama

StarCoder2 a été spécialement conçu pour les tâches de complétion au milieu (FIM, fill-in-the-middle) — exactement ce dont dépend l'autocomplétion des IDE. Il a été entraîné sur plus de 600 langages de programmation issus du jeu de données The Stack v2, ce qui le rend exceptionnellement polyvalent.

# 3B — fonctionne sur presque toutes les machines modernes, y compris sans GPU
ollama pull starcoder2:3b

# 7B — le meilleur compromis qualité/ressources
ollama pull starcoder2:7b

# 15B — nécessite ~10+ Go de VRAM, mais offre une qualité proche de Copilot
ollama pull starcoder2:15b

Testez le modèle immédiatement depuis votre terminal pour confirmer qu'il répond correctement :

ollama run starcoder2:7b "Write a Python function to flatten a nested list."

Si vous obtenez une sortie cohérente et syntaxiquement correcte, votre modèle est prêt à être utilisé par Continue.dev.

Remarque sur les contraintes matérielles

Ne vous laissez pas intimider par le nombre élevé de paramètres. Les modèles quantifiés (que Ollama télécharge par défaut — généralement avec une quantification Q4_K_M) sont considérablement plus petits que leur taille théorique. Un modèle 7B en quantification Q4 fonctionne confortablement sur :

• Les Mac Apple Silicon (M1/M2/M3) avec 16 Go de mémoire unifiée — accélération GPU quasi native via Metal
• Les GPU NVIDIA avec 6 à 8 Go de VRAM (RTX 3060, 4060, etc.)
• Les machines sans GPU avec 16+ Go de RAM — plus lent, mais tout à fait fonctionnel pour le chat ; la latence de l'autocomplétion sera perceptible

Si vous êtes limité par le CPU, préférez fortement starcoder2:3b ou codellama:7b-code — leur empreinte mémoire réduite se traduit directement par une génération de tokens plus rapide et une expérience d'autocomplétion plus réactive.

Une fois votre modèle choisi téléchargé et vérifié, Continue.dev le découvrira automatiquement via le point de terminaison de l'API Ollama (http://localhost:11434) que vous avez configuré à l'étape 2 — aucune liaison supplémentaire n'est requise.

Step 6 Bonnes pratiques pour l'autocomplétion et le chat locaux

Faire fonctionner la pile n'est que la moitié du travail. Tirer le maximum de productivité d'une configuration d'IA locale nécessite des choix de configuration délibérés, des habitudes de prompt disciplinées et une compréhension claire des domaines où les modèles locaux excellent par rapport à ceux où ils vous frustrent.

Stratégie de sélection des modèles

Tous les modèles ne se valent pas, et le bon outil dépend de la tâche à accomplir. Utilisez des modèles séparés pour l'autocomplétion et le chat plutôt que de forcer un seul modèle à faire les deux.

L'insight clé : l'autocomplétion est sensible à la latence, le chat est sensible à la qualité. Un modèle de 3B répondant en 150ms paraît magique pour les complétions. Ce même modèle donnant une réponse superficielle à une question architecturale complexe semble défaillant.

Réglage du comportement d'autocomplétion dans config.json

Les paramètres d'autocomplétion par défaut dans Continue.dev sont conservateurs. Poussez-les pour une meilleure expérience :

{
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://localhost:11434"
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "maxPromptTokens": 1024,
    "prefixPercentage": 0.85,
    "multilineCompletions": "always",
    "debounceDelay": 300
  }
}

Explication des options clés :

• debounceDelay: 300 — Attend 300ms après votre dernière frappe avant de déclencher une requête de complétion. Des valeurs plus basses semblent plus réactives mais sollicitent davantage votre GPU. Trouvez votre seuil optimal.
• prefixPercentage: 0.85 — Alloue 85% de la fenêtre de contexte au code avant le curseur. C'est idéal car le modèle a besoin d'un maximum de contexte de préfixe pour produire des complétions pertinentes.
• multilineCompletions: "always" — Force le modèle à tenter de compléter des blocs entiers, et pas seulement des lignes individuelles. Indispensable pour la génération de code standard.
• maxPromptTokens: 1024 — Maintient les requêtes légères. Des valeurs plus élevées améliorent marginalement la qualité mais augmentent considérablement la latence sur du matériel grand public.

Gestion du contexte pour le chat

L'interface de chat est l'endroit où la plupart des développeurs sous-utilisent Continue.dev. Utilisez les fournisseurs de contexte intégrés de manière intensive :

• @file — Référencez un fichier spécifique directement dans votre prompt
• @codebase — Déclenche une recherche par embeddings dans l'ensemble de votre dépôt (nécessite la configuration d'un modèle d'embeddings)
• @terminal — Colle votre sortie terminal la plus récente dans le contexte
• @problems — Injecte le contenu du panneau Problèmes de VS Code, parfait pour déboguer les erreurs du compilateur

Exemple de flux de travail pour le débogage :

@problems @file src/auth/middleware.ts

The JWT validation is throwing a 401 on every request even with a valid token.
Walk me through what could cause this and show me the fix.

Ce simple prompt fournit au modèle le message d'erreur, le fichier source pertinent et un énoncé clair du problème — améliorant considérablement la qualité des réponses.

Conseils d'optimisation matérielle

Utilisateurs GPU (NVIDIA/AMD) : Assurez-vous qu'Ollama utilise bien votre GPU et ne bascule pas vers le CPU :

# Verify GPU utilization while a model is loaded
ollama ps

# Check VRAM usage
nvidia-smi  # NVIDIA
rocm-smi    # AMD

Si ollama ps affiche 100% CPU, vous avez probablement un problème de débordement de VRAM. Passez à une quantification plus petite :

# Pull a smaller quantized variant
ollama pull codellama:13b-code-q4_K_M

Utilisateurs CPU uniquement : Gardez les modèles d'autocomplétion à 3 milliards de paramètres ou moins. Utilisez la quantification q4_0 pour l'empreinte mémoire la plus réduite et définissez numThreads dans l'environnement d'Ollama pour correspondre à votre nombre de cœurs physiques (sans hyperthreading) :

OLLAMA_NUM_PARALLEL=1 OLLAMA_MAX_LOADED_MODELS=1 ollama serve

Faire tourner deux modèles simultanément sur CPU provoquera des conflits de ressources. Gardez MAX_LOADED_MODELS=1 et acceptez le délai de chargement à froid lors du basculement entre les modèles d'autocomplétion et de chat.

Discipline des Prompts pour des Résultats Cohérents

Les modèles locaux sont plus petits et plus sensibles à la qualité des prompts que GPT-4. Ces habitudes vous feront gagner des heures de frustration :

1. Soyez explicite sur le langage et le framework. Ne supposez pas que le modèle sait que vous travaillez dans un projet Next.js 14 App Router. Précisez-le.
2. Collez l'erreur, pas seulement la description. Les traces de pile complètes avec les numéros de ligne surpassent largement les descriptions vagues.
3. Demandez un format de sortie spécifique. Terminez les prompts par "Montrez uniquement la fonction modifiée, sans explication" ou "Expliquez d'abord, puis montrez le code" selon vos besoins.
4. Utilisez /clear entre les tâches sans rapport. La contamination du contexte par une conversation précédente sur Python peut dégrader les réponses dans une nouvelle session TypeScript.

Quand Revenir au Cloud

Les modèles locaux ne remplacent pas universellement tous les cas d'usage. Soyez pragmatique :

La garantie de confidentialité est non négociable pour de nombreuses équipes — votre code ne quitte jamais la machine. Cela seul justifie la mise en place locale, même si les modèles cloud produisent parfois des réponses plus précises.

Continue Reading

Performance

Mistral 7B vs Llama 3 on Apple Silicon

Tools

Best GUI clients for Local LLMs

Advanced

Quantization 101: Speed up your Inference