Serveur MCP Code Executor MCP

Que fait le serveur “MCP Code Executor” MCP ?

Le MCP Code Executor est un serveur MCP (Model Context Protocol) qui permet aux modèles de langage (LLM) d’exécuter du code Python au sein d’un environnement Python dédié, tel que Conda, virtualenv ou UV virtualenv. En reliant les assistants IA à de véritables environnements Python exécutables, il leur permet d’accomplir un large éventail de tâches de développement nécessitant exécution de code, gestion de bibliothèques et configuration dynamique d’environnement. Ce serveur prend en charge la génération de code incrémentale pour dépasser les limites de tokens, autorise l’installation à la volée de dépendances et facilite la configuration de l’environnement d’exécution. Les développeurs peuvent s’appuyer sur cet outil pour automatiser l’évaluation de code, expérimenter de nouveaux packages et gérer les calculs dans un environnement contrôlé et sécurisé.

Liste des prompts

Aucun modèle de prompt explicite n’est listé dans le dépôt ou la documentation.

Prêt à développer votre entreprise?

Commencez votre essai gratuit aujourd'hui et voyez les résultats en quelques jours.

Demander une démo Se connecter

Liste des ressources

Aucune ressource spécifique n’est décrite dans le dépôt ou la documentation.

Liste des outils

• execute_code
  • Exécute du code Python dans l’environnement configuré. Adapté à l’exécution de courts extraits de code et de scripts.
• install_dependencies
  • Installe les packages Python spécifiés dans l’environnement courant, permettant l’ajout dynamique de bibliothèques selon les besoins.
• check_installed_packages
  • Vérifie quels packages Python sont actuellement installés dans l’environnement.

Rejoignez notre newsletter

Recevez gratuitement les derniers conseils, tendances et offres.

Adresse e-mail

S'abonner

Cas d’utilisation de ce serveur MCP

• Évaluation automatisée de code
  • Les LLM peuvent exécuter et tester des extraits de code Python directement, ce qui est utile dans un contexte pédagogique, de relecture ou de débogage.
• Gestion dynamique des dépendances
  • Installe les packages nécessaires à la volée, permettant aux LLM d’adapter l’environnement d’exécution pour des tâches ou bibliothèques spécialisées.
• Isolement d’environnement
  • Exécute le code dans des environnements Conda ou virtualenv isolés, assurant la reproductibilité et évitant les conflits de dépendances.
• Génération de code incrémentale
  • Prend en charge l’exécution de code par incréments, ce qui permet de gérer de grands blocs de code pouvant dépasser les limites de tokens d’une seule réponse LLM.
• Data science et analyse
  • Permet aux agents IA de réaliser de l’analyse de données, d’exécuter des simulations ou de visualiser des résultats en utilisant les bibliothèques scientifiques Python courantes.

Comment le configurer

Windsurf

1. Assurez-vous que Node.js est installé.
2. Clonez le dépôt MCP Code Executor et construisez le projet.
3. Localisez votre fichier de configuration des serveurs MCP.
4. Ajoutez le serveur MCP Code Executor en utilisant l’extrait JSON suivant :

   {
     "mcpServers": {
       "mcp-code-executor": {
         "command": "node",
         "args": [
           "/path/to/mcp_code_executor/build/index.js"
         ],
         "env": {
           "CODE_STORAGE_DIR": "/path/to/code/storage",
           "ENV_TYPE": "conda",
           "CONDA_ENV_NAME": "your-conda-env"
         }
       }
     }
   }
   

5. Enregistrez le fichier et redémarrez Windsurf. Vérifiez que le serveur est accessible.

Sécurisation des clés API (exemple de variables d’environnement)

{
  "mcpServers": {
    "mcp-code-executor": {
      "env": {
        "CODE_STORAGE_DIR": "/path/to/code/storage",
        "ENV_TYPE": "conda",
        "CONDA_ENV_NAME": "your-conda-env",
        "MY_SECRET_API_KEY": "${MY_SECRET_API_KEY}"
      },
      "inputs": {
        "apiKey": "${MY_SECRET_API_KEY}"
      }
    }
  }
}

Claude

1. Assurez-vous que Node.js est installé.
2. Construisez MCP Code Executor selon les instructions du dépôt.
3. Ouvrez le fichier de configuration des serveurs MCP de Claude.
4. Insérez la configuration suivante :

   {
     "mcpServers": {
       "mcp-code-executor": {
         "command": "node",
         "args": [
           "/path/to/mcp_code_executor/build/index.js"
         ],
         "env": {
           "CODE_STORAGE_DIR": "/path/to/code/storage",
           "ENV_TYPE": "conda",
           "CONDA_ENV_NAME": "your-conda-env"
         }
       }
     }
   }
   

5. Enregistrez et redémarrez Claude. Vérifiez que le serveur est listé.

Cursor

1. Installez Node.js.
2. Clonez et construisez le dépôt MCP Code Executor.
3. Modifiez la configuration MCP de Cursor.
4. Ajoutez :

   {
     "mcpServers": {
       "mcp-code-executor": {
         "command": "node",
         "args": [
           "/path/to/mcp_code_executor/build/index.js"
         ],
         "env": {
           "CODE_STORAGE_DIR": "/path/to/code/storage",
           "ENV_TYPE": "conda",
           "CONDA_ENV_NAME": "your-conda-env"
         }
       }
     }
   }
   

5. Enregistrez et redémarrez Cursor. Testez en exécutant un code exemple.

Cline

1. Assurez-vous que Node.js est disponible.
2. Construisez MCP Code Executor selon les instructions du README.
3. Localisez le fichier de configuration MCP de Cline.
4. Ajoutez :

   {
     "mcpServers": {
       "mcp-code-executor": {
         "command": "node",
         "args": [
           "/path/to/mcp_code_executor/build/index.js"
         ],
         "env": {
           "CODE_STORAGE_DIR": "/path/to/code/storage",
           "ENV_TYPE": "conda",
           "CONDA_ENV_NAME": "your-conda-env"
         }
       }
     }
   }
   

5. Enregistrez et redémarrez Cline. Vérifiez que le serveur MCP est actif.

Remarque : Vous pouvez également utiliser Docker. Le Dockerfile fourni est testé pour le type d’environnement venv-uv :

{
  "mcpServers": {
    "mcp-code-executor": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "mcp-code-executor"
      ]
    }
  }
}

Comment utiliser ce MCP dans vos flux

Utilisation de MCP dans FlowHunt

Pour intégrer des serveurs MCP à votre workflow FlowHunt, commencez par ajouter le composant MCP à votre flux et reliez-le à votre agent IA :

Cliquez sur le composant MCP pour ouvrir le panneau de configuration. Dans la section configuration système MCP, insérez les détails de votre serveur MCP au format JSON suivant :

{
  "mcp-code-executor": {
    "transport": "streamable_http",
    "url": "https://yourmcpserver.example/pathtothemcp/url"
  }
}

Une fois configuré, l’agent IA pourra utiliser ce MCP comme un outil avec accès à toutes ses fonctions et capacités. Pensez à remplacer “mcp-code-executor” par le nom réel de votre serveur MCP et l’URL par celle de votre serveur MCP.

Vue d’ensemble

Notre avis

Ce serveur MCP offre des fonctionnalités essentielles et robustes pour l’exécution de code avec intégration LLM, ainsi que des instructions d’installation claires et des outils adaptés. Cependant, il manque de modèles de prompt, de ressources explicites, et d’informations sur les racines ou le support du sampling. Pour un MCP focalisé sur l’exécution de code, il est très solide, obtenant une excellente note pour son utilité pratique et sa facilité d’intégration, mais il perd quelques points sur l’absence de fonctions MCP avancées et l’exhaustivité de la documentation.

Score MCP