🛒 La solution d'application approfondie d'assistant de programmation d'IA open source de Continue pour les développeurs couvre des fonctionnalités de base telles que la commutation backend multi-LLM, les mots d'invite personnalisés, le raisonnement du modèle local, la compréhension du contexte de la base de code, la personnalisation des commandes Slash, la configuration des règles, etc., pour créer un environnement de programmation d'IA flexible et contrôlable.

Continuer la solution approfondie de l'assistant de programmation IA open source

Présentation de la solution

Ce programme est destiné aux équipes de R&D de logiciels et aux développeurs individuels pour trier systématiquement la configuration des liens complets et les méthodes d'application approfondies de Continue assistant de programmation d'IA open source. Continue est actuellement l'un des plug-ins de programmation d'IA open source avec les plus grandes étoiles GitHub. Son principal avantage est qu'il n'est pas limité à un seul modèle ni lié à un fabricant spécifique - les développeurs peuvent librement passer à n'importe quel LLM tel que OpenAI API, Claude, Ollama et d'autres modèles locaux. backend et bénéficiez d'une expérience cohérente assistée par l'IA sur les plates-formes VS Code et JetBrains.

Contrairement aux solutions fermées telles que GitHub Copilot ou Cursor, Continue rend entièrement les droits de configuration et la souveraineté des données aux développeurs - les modèles de mots d'invite, la sélection de modèles et les politiques contextuelles sont tous gérés sous la forme de fichiers locaux, qui peuvent être intégrés dans le contrôle de version, le partage en équipe et même le déploiement privé.

Utilisateurs cibles : développeurs de R&D de logiciels de première ligne, chefs d'équipe technique, ingénieurs DevOps et équipes de R&D d'entreprise préoccupés par la confidentialité des données ou ayant besoin de se connecter à des modèles privés.

Prérequis :

• Avoir une expérience de base en utilisant VS Code ou JetBrains IDE
• Possibilité d'installer des extensions VS Code ou des plugins JetBrains (aucun droit d'administrateur requis)
• Si vous avez besoin d'accéder au cloud LLM (comme OpenAI, Claude), vous avez besoin de la clé API de la plateforme correspondante
• Pour exécuter des modèles locaux (comme via Ollama), un matériel avec au moins 8 Go de VRAM ou 16 Go de RAM est requis

Liste des chaînes d'outils

Remarque sur les coûts : Continuer lui-même est entièrement gratuit. Si vous utilisez uniquement des modèles locaux (Ollama/LM Studio), il n'y a aucun coût sauf le matériel ; si vous vous connectez à l'API cloud, le coût dépend du modèle et de l'utilisation sélectionnés. Comparé à GitHub Copilot (19 $/mois·personne) ou Cursor Pro (20 $/mois·personne), Continue peut réduire considérablement les coûts marginaux lorsque la taille de l'équipe est plus grande.

Préparation

Liste de contrôle environnementale

-[ ] VS Code 1.80+ ou JetBrains 2023.2+ IDE

• [ ] Node.js 18+ (requis pour certaines configurations avancées)
• [ ] Git installé et configuré (pour la synchronisation de la configuration)
• [ ] Pour le modèle natif : pilote GPU NVIDIA ou Apple Silicon Mac (M1+)

Compte et identifiants

• [ ] Pour le modèle cloud : OpenAI / Anthropic / autre clé API
• [ ] Pour le modèle local : Ollama installe et extrait le modèle cible

Préparation des connaissances

• [ ] Comprendre les trois modes d'interaction de Continue : complétion de code (complétion automatique), conversation (Chat) et édition en ligne (édition en ligne)
• [ ] Comprendre la syntaxe de base de YAML/JSON (pour la modification du fichier de configuration)

Guide étape par étape

Étape 1 : Installation du plug-in et vérification de base

⏱ Durée estimée : 10-15 minutes 🎯 Objectif : terminer l'installation du plug-in Continuer et vérifier le processus d'interaction de base ⚠️ Prérequis : VS Code ou JetBrains IDE installé

Instructions d'utilisation

Continue propose deux méthodes d'installation : l'extension VS Code et le plug-in JetBrains. Après l'installation, vous bénéficierez de capacités de programmation conversationnelle de base.

Opérations spécifiques

1. Installation du code VS : recherchez « Continuer » sur le marché des extensions ou visitez continue.dev pour obtenir le lien d'installation, puis cliquez pour installer.
2. Installation de JetBrains : ouvrez Paramètres → Plugins → Marketplace, recherchez « Continuer » pour installer.
3. Configuration initiale : Après l'installation, Continuer ajoutera une icône à la barre latérale de l'IDE. Cliquez pour ouvrir pour démarrer la conversation.
4. Vérification de base : saisissez « Expliquer le fichier actuel » dans la boîte de dialogue pour confirmer que Continuer peut lire correctement le contenu du fichier dans l'éditeur actuel et donner une réponse.

🔑Vue Expert : Après l'installation, Continue est livré par défaut avec un modèle de proxy gratuit (accessible via le proxy continue.dev), et les développeurs peuvent immédiatement découvrir la fonction de conversation complète sans aucune clé API. Cela abaisse le seuil de démarrage : il est recommandé d'utiliser le proxy par défaut pour vérifier la disponibilité du plug-in avant de saisir la configuration du modèle personnalisé.

Critères d'acceptation

• [ ] L'icône Continuer de la barre latérale est visible et le panneau de conversation peut être ouvert
• [ ] Le bouton flottant "Modifier" ou "Demander" apparaît après la sélection du code
• [ ] Les conversations peuvent être envoyées normalement et les réponses reçues

Étape 2 : Configuration et commutation de plusieurs backends LLM

⏱ Durée estimée : 30 à 60 minutes 🎯 Objectif : Configurer au moins 2 backends LLM (cloud + local) et vérifier le changement de modèle ⚠️ Prérequis : Vérification de l'installation du plug-in réussie

Instructions d'utilisation

Le concept de conception de base de Continue est « indépendant du modèle ». Grâce au fichier de configuration « config.json », les développeurs peuvent enregistrer plusieurs backends LLM en même temps et basculer de manière flexible selon les scénarios.

Opérations spécifiques

1. Ouvrez le fichier de configuration : Cliquez sur l'icône d'engrenage en bas du panneau Continuer → ouvrez ~/.continue/config.json.
2. Ajouter le backend OpenAI :

   {
    "modèles": [
      {
        "titre": "GPT-4o",
        "provider": "openai",
        "modèle": "gpt-4o",
        "apiKey": "sk-..."
      },
      {
        "titre": "Claude 3.5 Sonnet",
        "provider": "anthropique",
        "model": "claude-3-5-sonnet-20241022",
        "apiKey": "sk-ant-..."
      }
    ]
   }

3. Ajoutez le backend local Ollama (si nécessaire) :

   {
    "title": "Lama local 3",
    "fournisseur": "ollama",
    "modèle": "llama3"
   }

4. Changement de modèle : changez le modèle actuellement utilisé dans le menu déroulant en haut du panneau de dialogue Continuer, saisissez la même question pour comparer la qualité de réponse des différents modèles.
5. Concurrence multimodèle : configurez "completionOptions": {} pour définir des paramètres tels que la température et les maxTokens séparément pour chaque modèle.

🔑 Vue expert : la configuration du modèle de Continue adopte une architecture à deux niveaux « fournisseur + modèle », et le même fournisseur peut enregistrer plusieurs versions de modèle. Il est recommandé d'attribuer les modèles par type de tâche : modèles légers (tels que les modèles GPT-4o mini ou locaux 7B) pour la réalisation quotidienne du codage, et modèles phares (GPT-4o, Claude Sonnet) pour la reconstruction et l'analyse complexes. Cette stratégie de « modèle hiérarchique » est plus économique qu'une solution de modèle unique et peut être incluse dans le contrôle de version via « config.json ».

Critères d'acceptation

• [ ] Configurer au moins un modèle cloud et un modèle local
• [ ] peut basculer entre les modèles et obtenir des réponses normalement
• [ ] Il existe des différences évidentes dans la qualité de réponse des différents modèles (confirmez que le changement prend effet)

Étape 3 : Personnalisez les mots d'invite et la commande Slash

⏱ Durée estimée : 1-2 heures 🎯 Objectif : Écrivez un fichier Word d'invite personnalisé et enregistrez la commande Slash ⚠️ Condition préalable : La configuration du modèle est terminée

Instructions d'utilisation

Continue prend en charge la personnalisation des commandes Slash via les extensions de fichier « .prompt ». Il s'agit de sa capacité de différenciation la plus significative par rapport aux assistants de programmation d'IA à source fermée : les équipes peuvent accumuler des invites de flux de travail exclusives pour la révision du code, la révision de l'architecture, la génération de tests unitaires, etc.

Opérations spécifiques

1. Créer un répertoire d'invites personnalisées : créez le dossier .continue/prompts/ dans le répertoire racine du projet.

2. Commande de révision du code : Créez le fichier .continue/prompts/code-review.prompt :

   Vous êtes un expert senior en révision de code. Veuillez examiner les modifications de code sélectionnées en fonction des dimensions suivantes :
   
   1. **Sécurité** : existe-t-il des risques tels que l'injection SQL, XSS, le contournement des autorisations, etc.
   2. **Performances** : existe-t-il des boucles optimisables et des allocations de mémoire inutiles ?
   3. **Maintenabilité** : le nom est-il clair et s'il y a du code en double ?
   4. **Conditions limites** : Y a-t-il une valeur nulle non gérée ou une entrée anormale ?
   
   Veuillez indiquer le niveau de gravité (Critique/Majeur/Mineur) et joindre des suggestions de réparation.

3. Écrire la commande de génération de tests unitaires : Créez le fichier .continue/prompts/gen-test.prompt :

   Vous êtes un expert en tests. Veuillez générer des tests unitaires pytest pour les fonctions/classes sélectionnées :
   
   - Utiliser le framework pytest
   - Couvre les chemins normaux, les conditions aux limites et les chemins anormaux
   - Utiliser des simulations pour isoler les dépendances externes
   - La dénomination des tests suit le modèle gave_when_then

4. Enregistrez la commande Slash dans config.json :

   {
    "slashCommands": [
      {
        "name": "avis",
        "description": "révision du code",
        "promptPath": ".continue/prompts/code-review.prompt"
      },
      {
        "nom": "test",
        "description": "Générer des tests unitaires",
        "promptPath": ".continue/prompts/gen-test.prompt"
      }
    ]
   }

5. Vérification : saisissez « /review » ou « /test » dans le panneau de dialogue Continuer pour confirmer que la commande personnalisée prend effet.

🔑 Avis d'expert : La commande Slash est la fonction la plus précieuse pour la collaboration en équipe dans la solution Continue. Comparé aux règles du curseur ou aux participants au chat de GitHub Copilot, le fichier « .prompt » de Continue est essentiellement un modèle de texte brut et prend naturellement en charge la gestion des versions de Git. L'équipe peut créer un entrepôt d'invites indépendant et le distribuer à divers projets via un sous-module git ou des liens symboliques pour parvenir à « écrire une fois et réutiliser globalement ». Il est recommandé que l'équipe ne conserve que 3 à 5 commandes Slash de base au début pour éviter des coûts de sélection excessifs.

Critères d'acceptation

• [ ] Créez au moins 2 commandes Slash et enregistrez-les dans config.json
• La commande [ ] /review peut réviser le code en fonction des dimensions spécifiées
• La commande [ ] /test peut générer un code de test conforme au style du projet

Étape 4 : Configuration du contexte des règles et de la base de code

⏱ Durée estimée : 1-2 heures 🎯 Objectif : Configurer la référence @context et les règles de règles pour améliorer la compréhension de l'IA de la structure du projet ⚠️ Prérequis : configuration de la commande Slash terminée

Instructions d'utilisation

Le mécanisme de « contexte » de Continue détermine la quantité d'informations sur le projet que l'IA peut « voir ». Des sources de contexte correctement configurées peuvent améliorer considérablement la qualité de la complétion du code et du dialogue, en particulier dans les grands projets.

Opérations spécifiques

1. Configurez la référence @file : Entrez @file dans la boîte de dialogue et sélectionnez le fichier actuel, confirmez que Continuer peut lire le contenu du fichier.
2. Configurez la référence @folder : saisissez @folder pour sélectionner le répertoire du projet afin que l'IA puisse lire la structure des répertoires et la liste des fichiers.
3. Configuration @codebase : configurez l'index de base de code dans config.json :

   {
    "contextProviders": [
      {
        "nom": "base de code",
        "paramètres": {
          "useRag": vrai,
          "maxRésultats": 20
        }
      },
      {
        "nom": "fichier",
        "paramètres": {}
      },
      {
        "name": "dossier",
        "paramètres": {}
      }
    ]
   }

4. Règles personnalisées : créez le champ "rules" dans ~/.continue/config.json ou utilisez le fichier .continuerules au niveau du projet :

   {
    "règles": [
      "Toujours utiliser le mode strict TypeScript",
      "Suivez le style de code existant dans le projet",
      "Utilisez les hooks React pour la gestion de l'état",
      "Écrire des commentaires JSDoc pour toutes les fonctions exportées"
    ]
   }

5. Configurez l'index @docs : ajoutez des documents de projet ou des documents de bibliothèque tierce à l'index afin que l'IA puisse récupérer le contenu du document :

   {
    "contextProviders": [
      {
        "name": "docs",
        "paramètres": {
          "documents": [
            {
              "title": "Documentation de l'API du projet",
              "url": "https://votre-projet-docs-url"
            }
          ]
        }
      }
    ]
   }

🔑 Vue expert : la configuration du contexte est un tournant clé pour l'utilisation avancée de Continue. Dans la configuration par défaut, Continuer ne lit que le fichier actuellement ouvert et les réponses manquent souvent de vision au niveau du projet. Après avoir activé le mode RAG (Retrieval Enhanced Generation) de « codebase », Continue construira automatiquement un index vectoriel pour le projet et récupérera les extraits de code pertinents pendant la conversation. Pour les grands projets avec plus de 100 000 lignes, il est recommandé de définir « maxResults » sur 15-20 et de le combiner avec « @folder » pour limiter manuellement la plage de recherche afin d'éviter le bruit d'index.

Critères d'acceptation

• [ ] Les références @codebase peuvent récupérer correctement les extraits de code pertinents dans le projet
• [ ] Règles Les règles prennent effet dans la conversation (par exemple, l'exigence "Utiliser le mode strict TypeScript" est respectée) -[ ] Les réponses à la conversation reflètent la compréhension contextuelle au niveau de l'élément

Étape 5 : Intégration de l'inférence de modèle local

⏱ Durée estimée : 2 à 4 heures (y compris le téléchargement du modèle) 🎯 Objectif : Exécutez des modèles open source locaux via Ollama ou LM Studio pour obtenir une assistance complète à la programmation de l'IA hors ligne ⚠️ Prérequis : GPU local ou matériel Apple Silicon

Instructions d'utilisation

Le modèle sur site est l’un des principaux avantages de Continue par rapport aux solutions uniquement cloud. Grâce à Ollama ou LM Studio, les développeurs peuvent exécuter localement des modèles open source tels que Llama 3, CodeLlama, Mistral et DeepSeek Coder pour obtenir une expérience de programmation d'IA complètement hors ligne, sans latence et sans fuite de données.

Opérations spécifiques

Itinéraire A : Utiliser Ollama

1. Installez Ollama : Visitez ollama.com pour télécharger et installer la version correspondant à la plateforme.

2. Extrayez des modèles spécifiques à la programmation :

   # Recommandations pour l'achèvement du code
   ollama pull codellama:7b-instruct
   
   # Recommandations générales de conversation de programmation
   ollama tire deepseek-coder: 6.7b-instruct
   
   #Options légères
   ollama tire qwen2.5-coder:7b-instruct

3. Ajoutez la configuration du modèle Ollama dans Continue config.json :

   {
    "modèles": [
      {
        "title": "Codeur DeepSeek local",
        "fournisseur": "ollama",
        "model": "codeur de recherche profonde : 6.7b-instruct"
      }
    ]
   }

Voie B : Utilisation de LM Studio

1. Téléchargez et installez LM Studio.
2. Recherchez et téléchargez le modèle cible (tel que « Qwen2.5-Coder-7B-Instruct-GGUF ») dans LM Studio.
3. Démarrez le serveur d'inférence local (Local Inference Server) et enregistrez le numéro de port.
4. Configurez le backend de LM Studio dans Continuer :

   {
    "modèles": [
      {
        "titre": "LM Studio Local",
        "provider": "openai",
        "model": "qwen2.5-coder-7b-instruct",
        "apiBase": "http://localhost:1234/v1",
        "apiKey": "pas nécessaire"
      }
    ]
   }

🔑 Point de vue expert : Le modèle local et le modèle cloud ne sont pas substituables, mais complémentaires. La stratégie de superposition recommandée est la suivante : utilisez le modèle 7B local (vitesse de réponse < 1 seconde) pour l'achèvement quotidien du code et les conversations simples, et utilisez le modèle phare du cloud pour les révisions d'architecture complexes ou les refactorisations en profondeur. Continuer prend en charge le changement de modèle au cours de la même session sans redémarrer l'EDI. En termes de matériel, Apple Silicon Mac (M2+ 16 Go) peut exécuter le modèle 7B en douceur, et NVidia RTX 3060+ peut exécuter le modèle 13B-34B. Si le matériel est limité, Qwen2.5-Coder ou la version quantifiée 1.5B-7B de la série DeepSeek Coder est préférable.

Critères d'acceptation

• [ ] Le modèle local peut démarrer normalement et accepter les demandes
• [ ] Continuer peut se connecter avec succès au backend du modèle local
• [ ] Vous pouvez toujours utiliser Continuer pour mener des conversations de code dans un environnement hors ligne (déconnecté du réseau)

Étape 6 : Synchronisation de la configuration de l'équipe et déploiement privé

⏱ Durée estimée : 2-4 heures 🎯 Objectif : Établir un processus de gestion continue de la configuration au niveau de l'équipe pour assurer la cohérence de la configuration multi-membres ⚠️ Prérequis : Configuration personnelle complétée et vérifiée

Instructions d'utilisation

Lorsque plusieurs personnes d’une équipe utilisent Continue, la gestion fragmentée des fichiers de configuration peut rapidement devenir un goulot d’étranglement. Cette étape lie la configuration de Continue à l'entrepôt du projet pour implémenter la configuration en tant que code.

Opérations spécifiques

1. Configuration au niveau du projet : créez un répertoire .continue/ dans le répertoire racine du projet et placez le config.json spécifique au projet :

   {
    "modèles": [...],
    "slashCommands": [...],
    "règles": [...],
    "contextProviders" : [...]
   }

   Continuer fusionnera automatiquement les configurations au niveau de l'utilisateur (~/.continue/config.json) et au niveau du projet (.continue/config.json), la configuration au niveau du projet ayant une priorité plus élevée.

2. Configurer dans le contrôle de version : Soumettez le répertoire .continue/ à Git :

   git add .continue/
   git commit -m "corvée : ajouter Continuer la configuration de l'équipe"

3. Désensibilisation des informations sensibles : utilisez des variables d'environnement au lieu de la clé API :

   {
    "modèles": [
      {
        "titre": "GPT-4o",
        "provider": "openai",
        "modèle": "gpt-4o",
        "apiKey": "${OPENAI_API_KEY}"
      }
    ]
   }

   Excluez les fichiers .env dans .gitignore pour distribuer les variables d'environnement via CI/CD ou la documentation de l'équipe.

4. Agent de déploiement privé (scénario d'entreprise) : si vous avez besoin d'un routage de modèle unifié et d'un audit d'utilisation, vous pouvez déployer Continue Hub (version communautaire) en tant que couche d'agent de modèle pour gérer uniformément les clés API et les journaux de demandes.

🔑 Avis d'expert : Le système de configuration à deux niveaux « niveau utilisateur + niveau projet » de Continue est l'essence même de sa conception de collaboration en équipe. La stratégie hiérarchique recommandée est la suivante : la configuration au niveau de l'utilisateur stocke les clés API personnelles et les préférences de modèle personnalisées, et la configuration au niveau du projet stocke les commandes Slash, les règles et les politiques contextuelles unifiées de l'équipe. Cette séparation garantit que même si les individus peuvent changer librement de modèle, les principaux éléments de flux de travail de l'équipe restent cohérents. Par rapport à GitHub Copilot, qui ne prend en charge que le mode de configuration au niveau personnel, la gestion de la configuration d'équipe de Continue est plus adaptée aux équipes de R&D de moyenne et grande taille qui nécessitent des normes de codage unifiées.

Critères d'acceptation

-[ ] Au niveau du projet .continue/config.json a été inclus dans la gestion Git

• [ ] Un autre membre de l'équipe peut utiliser la configuration directement après avoir extrait le projet (après avoir complété la clé API personnelle)
• [ ] Les références aux variables d'environnement $ sont correctement remplacées au moment de l'exécution

Résultats attendus

Critères d'acceptation

• [ ] Les développeurs peuvent basculer librement entre plus de 3 modèles -[ ] Au moins 3 commandes Slash personnalisées peuvent être partagées au sein de l'équipe
• [ ] Les modèles locaux peuvent compléter la complétion du code et dialoguer dans un environnement hors ligne
• [ ] La configuration de l'équipe est distribuée via Git et les nouveaux membres peuvent terminer la configuration de l'environnement en 15 minutes

Questions fréquemment posées et dépannage

Q : Quelle est la principale différence entre Continuer et GitHub Copilot/Cursor ? R : Continuer est un plug-in open source plutôt qu'un IDE autonome. Il ne verrouille aucun fournisseur de modèles et permet une configuration gratuite pour appeler n'importe quel backend LLM (y compris les modèles open source exécutés localement). GitHub Copilot est lié à Azure OpenAI. Bien que Cursor puisse utiliser une variété de modèles, il n’est pas open source. Les valeurs fondamentales de Continue sont la souveraineté de la configuration et la confidentialité des données.

Q : Les performances du modèle local peuvent-elles être comparées à celles de GPT-4o ? R : Les performances actuelles des modèles open source locaux aux niveaux 7B-14B sont proches du niveau GPT-4 en termes de complétion de code et de questions et réponses simples (le score HumanEval est d'environ 60 à 75 % contre GPT-4 d'environ 85 %), mais il existe encore une lacune dans le raisonnement d'architecture complexe, la reconstruction multi-fichiers et l'analyse approfondie des bogues. La stratégie recommandée consiste à ce que le modèle local gère le codage quotidien et que le modèle cloud gère les tâches complexes.

Q : Quelle infrastructure est requise pour le déploiement de la privatisation d'équipe Continuer ? R : Le plan de base nécessite uniquement un fichier de configuration de distribution du référentiel Git (coût de serveur nul). Si vous avez besoin d'une gestion centralisée du routage et de l'utilisation des modèles, vous pouvez déployer l'édition communautaire Continue Hub (nécessite un serveur Linux ou un cluster Kubernetes), configurer uniformément les politiques de rotation des clés API et demander des journaux d'audit.

Q : Comment résoudre le problème de la vitesse d'inférence lente du modèle local ? R : Le matériel détermine la limite de vitesse inférieure. Les Mac Apple Silicon utilisent le backend MLX (Ollama automatiquement activé) pour une efficacité d'inférence optimale ; Les GPU NVidia recommandent les modèles quantifiés CUDA + (Q4_K_M). Si le matériel est limité, donnez la priorité à un modèle quantitatif avec <= 7B de paramètres et activez le mode « réponse en streaming » de Continue (activé par défaut). Vous pouvez commencer à lire les réponses après le premier délai de jeton.

Q : Le code sensible du projet sera-t-il téléchargé sur le cloud ? R : Lorsque vous utilisez le modèle local (Ollama/LM Studio), tout le traitement du code est entièrement effectué localement et aucune donnée n'est envoyée. Lors de l'utilisation de l'API cloud, le code est envoyé au fournisseur de modèles correspondant via HTTPS. Continuer lui-même ne stocke ni ne révise le contenu du code. Pour les scénarios de conformité d'entreprise, il est recommandé de configurer le modèle local comme backend par défaut et d'utiliser l'API cloud uniquement pour les modules non sensibles.

Avancement et expansion

Synchronisation multi-IDE

La configuration au niveau utilisateur de Continue est stockée dans le répertoire ~/.continue/. VS Code et JetBrains partagent le même répertoire de configuration. Après avoir installé le plug-in Continue dans JetBrains, les configurations existantes seront automatiquement lues pour permettre une commutation transparente entre les IDE.

Fournisseur de contexte personnalisé

Continue prend en charge l'écriture de fournisseurs de contexte personnalisés via TypeScript pour injecter des sources de données externes telles que des documents API internes, la base de connaissances Confluence, des documents de package NPM internes, etc. dans le contexte de conversation IA. Pour des directives de développement détaillées, consultez le chapitre « Fournisseur de contexte personnalisé » de la documentation officielle Continue.

Intégration CI/CD

Grâce à l'outil Continue CLI, vous pouvez appeler Continue dans le pipeline CI pour effectuer une révision automatisée du code ou une génération de documentation de code, étendant ainsi les capacités assistées par l'IA de l'IDE aux workflows DevOps.

Modèle de stratégie de routage

Les équipes d'entreprise peuvent configurer des stratégies de routage de modèles via Continue Hub : acheminez automatiquement vers différents modèles par chemin de base de code, suffixe de fichier ou mot-clé. Par exemple : les fichiers src/**/*.ts appellent automatiquement GPT-4o, les fichiers docs/** appellent Claude et les fichiers de test appellent des modèles locaux.

Période et résultat

Remarque : Le cycle ci-dessus est basé sur la valeur de référence de la première mise en œuvre par une équipe R&D de 3 à 5 personnes. Les développeurs individuels peuvent compresser leurs cycles de 40 à 50 %.

Avantages et inconvénients de la solution

Avantages

• Liberté de modèle : non lié à un fabricant de modèle, vous pouvez changer ou utiliser plusieurs modèles en parallèle à tout moment
• Souveraineté des données : la solution de modèle local permet une externalisation zéro code et répond aux exigences de conformité des données de l'entreprise
• Coût contrôlable : Modèle open source et gratuit + local, plus la taille de l'équipe est grande, plus les économies sont importantes par rapport aux solutions commerciales
• Configuration as code : les commandes et règles Slash sont gérées sous forme de fichiers, prenant naturellement en charge le contrôle de version Git et la distribution en équipe
• Cohérence multiplateforme : VS Code et JetBrains partagent la même configuration, les développeurs peuvent basculer de manière transparente entre différents IDE

Limites

• Limite supérieure de l'effet du modèle local : le modèle open source actuel est toujours à la traîne par rapport aux modèles phares tels que GPT-4o/Claude dans les tâches d'inférence complexes
• Complexité de configuration : par rapport aux solutions commerciales « prêtes à l'emploi », Continue nécessite que les développeurs investissent du temps de configuration initial.
• Seuil matériel : certaines conditions matérielles (GPU ou Apple Silicon) sont requises pour que les modèles locaux fonctionnent correctement.
• Piloté par la communauté : certaines itérations de fonctions dépendent des contributions de la communauté et le temps de sortie des fonctions est incontrôlable.
• Manque de marché unifié : Il existe plusieurs plug-ins portant le même nom/similarité sur le marché des extensions VS Code, qui doivent être installés à partir de la source officielle (continue.dev) pour éviter toute confusion.

Résumé de l'outil

Applicable au détournement de foule

Scénario optimal

• Des équipes R&D ayant des exigences élevées en matière de sélection de modèles et de confidentialité des données (finance, médecine, gouvernement et autres secteurs strictement réglementés)
• Équipes de développement moyennes et grandes qui souhaitent unifier les normes de codage d'équipe et les invites de flux de travail
• Les développeurs qui doivent programmer dans des environnements réseau hors ligne ou restreints
• Développeurs individuels ou équipes de start-up avec un budget limité qui souhaitent obtenir une assistance en programmation IA à faible coût
• Passionnés de technologie qui souhaitent comprendre en profondeur le mécanisme d'interaction sous-jacent à la programmation de l'IA

Ne convient pas à la scène

• Les équipes qui cherchent à sortir des sentiers battus et ne veulent pas passer du temps à configurer des modèles (il est recommandé de choisir Cursor ou GitHub Copilot)
• La pile technologique IDE des membres de l'équipe est très incohérente (les éditeurs tels qu'Eclipse et Vim ne sont pas pris en charge)
• Scénarios dans lesquels le besoin d'assistance à la programmation de l'IA n'est qu'une « complétion de code simple occasionnelle » et aucun flux de travail personnalisé n'est requis
• Les équipes dont les conditions matérielles ne peuvent pas répondre aux exigences d'exécution du modèle local et ne souhaitent pas utiliser le cloud.