Intégration MCP

Qu'est-ce que MCP (Model Context Protocol) ?

Model Context Protocol (MCP) est un système d'intégration qui étend les capacités de Verdent en le connectant à des outils, des sources de données et des services externes.

Concept clé : MCP permet à Verdent d'interagir avec des systèmes au-delà de son ensemble d'outils intégrés, en permettant une intégration fluide avec :

• Des APIs externes et des services web
• Des systèmes de bases de données
• Des plateformes cloud (AWS, Azure, GCP)
• Des outils de gestion de projet
• Des pipelines CI/CD
• Des outils internes personnalisés

Architecture : Les serveurs MCP agissent comme des passerelles entre Verdent et les systèmes externes. Chaque serveur MCP expose des capacités spécifiques que Verdent peut invoquer pendant les sessions de codage, à l'instar des outils intégrés comme file_read ou bash.

Stockage de la configuration : Les configurations des serveurs MCP sont stockées dans ~/.verdent/mcp.json et gérées via le menu Paramètres.

Avantages de l'intégration MCP

Capacités étendues

Accès aux systèmes externes : Connectez Verdent à des outils et services non disponibles via les fonctionnalités intégrées. Interrogez des bases de données, interagissez avec des services cloud ou intégrez des APIs propres à votre projet sans quitter votre flux de travail de codage.

Développement d'outils personnalisés : Créez des serveurs MCP adaptés aux besoins spécifiques de votre projet. Développez des intégrations spécialisées pour des outils internes, des APIs propriétaires ou des systèmes propres à un domaine.

Interopérabilité

Exploitation de l'écosystème : Profitez de l'écosystème MCP en pleine croissance. Les serveurs MCP développés par la communauté fournissent des intégrations prêtes à l'emploi pour des outils et services populaires.

Protocole standardisé : MCP fournit une interface cohérente pour l'intégration d'outils, garantissant que les nouvelles capacités s'intègrent parfaitement au système d'outils existant de Verdent.

Automatisation des flux de travail

Intégration transparente : Les serveurs MCP font partie de l'ensemble d'outils de Verdent. L'agent utilise automatiquement les outils MCP lorsque cela est pertinent, ou vous pouvez les invoquer explicitement pour des tâches spécifiques.

Opérations sensibles au contexte : Les intégrations MCP comprennent le contexte de votre base de code, permettant des interactions intelligentes avec les systèmes externes en fonction de l'état de développement actuel.

Configuration des serveurs MCP

Processus de configuration

Accéder aux paramètres MCP :

1. Ouvrez le menu Paramètres dans Verdent
2. Accédez à la section Serveurs MCP
3. Consultez ou modifiez la configuration de ~/.verdent/mcp.json

Fichier de configuration : Les serveurs MCP sont configurés via le fichier ~/.verdent/mcp.json, qui définit les connexions au serveur, l'authentification et les paramètres d'intégration. Consultez la section Configuration MCP ci-dessous pour le schéma complet.

Gestion de la configuration

Ajout de serveurs : Configurez de nouveaux serveurs MCP en ajoutant des entrées dans mcp.json avec les détails de connexion et les identifiants d'authentification.

Serveurs multiples : Verdent prend en charge plusieurs serveurs MCP simultanés, permettant l'intégration avec plusieurs systèmes externes en même temps.

Test des connexions : Validez les configurations des serveurs MCP pour vous assurer que les connexions réussissent avant de les utiliser dans vos flux de travail de développement.

État du serveur

Surveillez l'état de connexion dans le panneau de paramètres MCP :

Actualisation des outils : Cliquez sur le bouton d'actualisation pour redétecter les outils disponibles d'un serveur après des modifications de configuration ou des problèmes de connexion.

Configuration MCP

Configuration de base

Emplacement : .mcp.json à la racine du projet ou ~/.verdent/mcp.json (global)

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/myapp_dev"
      ]
    }
  }
}

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/myapp_dev"
      ]
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Clés de configuration :

• mcpServers - Clé de premier niveau requise pour la configuration MCP
• command - Exécutable à lancer (généralement npx pour les paquets Node.js)
• args - Arguments transmis à la commande (nom du paquet, chaînes de connexion, etc.)
• env - Variables d'environnement pour l'authentification/la configuration

Plugins et extensions MCP

Plugins disponibles

Les plugins MCP fournissent des intégrations prêtes à l'emploi pour les outils et services courants. Parcourez le registre communautaire sur mcp.so/servers ou le dépôt officiel des serveurs MCP pour connaître la disponibilité actuelle.

Catégories de plugins courantes :

• Intégrations de bases de données : outils de requête PostgreSQL, MySQL, MongoDB
• Services cloud : interactions API AWS, Azure, GCP
• Outils de développement : intégrations GitHub, GitLab, Jira, Linear
• Plateformes CI/CD : Jenkins, GitHub Actions, CircleCI
• Services de surveillance : Datadog, New Relic, Sentry
• Communication : notifications Slack, Discord, Microsoft Teams

Installation de plugins

Méthodes d'installation : Les plugins sont installés et configurés via l'interface Paramètres de MCP, nécessitant généralement :

• Un identifiant ou une source de plugin
• Des paramètres de configuration
• Des identifiants d'authentification (le cas échéant)

Gestion des dépendances : Les plugins MCP peuvent avoir des dépendances sur des services ou des bibliothèques externes. Les processus d'installation gèrent automatiquement la résolution des dépendances lorsque cela est possible.

Développement de serveurs MCP personnalisés

Création de serveurs personnalisés

Les utilisateurs avancés peuvent créer des serveurs MCP personnalisés pour intégrer des outils propriétaires ou des systèmes propres à un domaine.

Approche de développement : Les serveurs MCP personnalisés implémentent la spécification du protocole MCP, exposant des capacités d'outils que Verdent peut invoquer. Consultez la spécification Model Context Protocol pour les détails d'implémentation et les SDK.

Cas d'usage pour les serveurs personnalisés :

• Intégration API interne : connexion à des APIs et services propres à l'entreprise
• Passerelles vers les systèmes existants : permettre à Verdent d'interagir avec une infrastructure existante
• Sources de données spécialisées : accès à des bases de données ou entrepôts de données propriétaires
• Automatisation des flux de travail : déclenchement de pipelines de build, déploiement ou test personnalisés

Modèles d'intégration

Configuration au niveau de l'espace de travail : Les serveurs MCP peuvent être configurés au niveau de l'espace de travail pour des intégrations propres à un projet, permettant aux équipes de partager les configurations MCP via le contrôle de version.

Interopérabilité des outils : Les outils fournis par MCP s'intègrent parfaitement aux outils intégrés de Verdent (file_read, bash, spawn_subagent), permettant des flux de travail complexes combinant plusieurs types d'outils.

Fonctionnalités MCP spécifiques au bureau

Configuration par projet

MCP multi-arbres de travail

Les serveurs MCP fonctionnent sur plusieurs arbres de travail :

• Serveurs partagés : la configuration MCP de l'espace de travail de base est partagée par tous les arbres de travail
• Opérations isolées : chaque arbre de travail conserve un état de session MCP distinct
• Accès parallèle : plusieurs arbres de travail peuvent utiliser les mêmes serveurs MCP simultanément

Changement de projet

Lors du changement de projet :

• Les serveurs MCP du projet actuel sont chargés
• Les serveurs MCP globaux restent disponibles
• Les connexions MCP du projet précédent sont maintenues en arrière-plan

Exemples de flux de travail MCP

Intégration de requêtes de base de données

Scénario : interroger la base de données de production pour déboguer des problèmes de données.

Approche MCP :

User: "Check the orders table for customer ID 12345"
Verdent: [Uses MCP database server to execute safe read-only query]
        Results: 3 orders found for customer 12345
        [Displays formatted results]

Le serveur de base de données MCP gère l'authentification, la validation des requêtes et le formatage des résultats.

Interaction avec les services cloud

Scénario : vérifier les journaux des fonctions AWS Lambda pour détecter des erreurs.

Approche MCP :

User: "Show me recent errors from the payment-processor Lambda function"
Verdent: [Invokes MCP AWS integration]
        [Retrieves CloudWatch logs for specified function]
        [Filters for ERROR level entries]
        [Presents formatted error summaries]

Le serveur AWS MCP gère l'authentification, les appels API et l'analyse des journaux.

Surveillance des pipelines CI/CD

Scénario : vérifier l'état du build avant de déployer des modifications.

Approche MCP :

User: "Is the master branch build passing?"
Verdent: [Queries MCP CI/CD integration]
        Build #245: ✓ Passed (2 minutes ago)
        All tests passed, ready for deployment

Le serveur CI/CD MCP suit l'état du pipeline et fournit des retours en temps réel.

Considérations de sécurité

Authentification et autorisation

Gestion des identifiants : Les serveurs MCP gèrent l'authentification auprès des services externes. Les identifiants sont stockés en toute sécurité dans la configuration MCP et ne sont jamais exposés dans l'historique des conversations ou dans le code.

Limitation des permissions : Configurez les serveurs MCP avec les permissions minimales nécessaires. Utilisez un accès en lecture seule lorsque cela est possible et restreignez les opérations destructrices.

Opérations sûres

Revue des commandes : Les opérations impliquant les outils MCP apparaissent dans l'historique des conversations, offrant visibilité et contrôle.

Journalisation d'audit : Les opérations des serveurs MCP apparaissent dans l'historique des conversations de Verdent, créant une piste d'audit des interactions avec les systèmes externes.

Résolution des problèmes d'intégration MCP

Problèmes courants

Échecs de connexion :

• Vérifiez la connectivité réseau vers le serveur MCP
• Vérifiez les identifiants d'authentification dans mcp.json
• Assurez-vous que le serveur MCP est en cours d'exécution et accessible
• Validez la syntaxe du fichier de configuration

Erreurs de permission :

• Confirmez que les clés ou identifiants API disposent des permissions requises
• Vérifiez les quotas de service ou les limites de taux
• Vérifiez que les règles de pare-feu autorisent le trafic MCP

Problèmes d'invocation d'outils :

• Assurez-vous que le serveur MCP expose correctement les outils attendus
• Vérifiez que les formats de paramètres des outils correspondent aux attentes du serveur
• Consultez les journaux du serveur MCP pour les détails des erreurs

Obtenir de l'aide

Canaux d'assistance :

• Assistance Verdent : support@verdent.ai
• Documentation du protocole MCP
• Communauté Discord Verdent

Informations de diagnostic : Lorsque vous signalez des problèmes MCP, fournissez :

• Le type et la version du serveur MCP
• Les détails de configuration (sans les identifiants)
• Les messages d'erreur de l'historique des conversations
• Les journaux du serveur MCP (si accessibles)

FAQ