YepCode MCP Server

officiel

Exécutez tout code généré par LLM dans l'environnement sandbox sécurisé et évolutif de YepCode et créez vos propres outils MCP en utilisant JavaScript ou Python, avec un support complet des packages NPM et PyPI.

GitHub
43

Documentation

YepCode MCP Server Preview

NPM version NPM Downloads GitHub Workflow Status

Trust Score smithery badge

Qu'est-ce que le serveur MCP YepCode ?

Un serveur MCP (Model Context Protocol) qui permet aux plateformes d'IA d'interagir avec l'infrastructure de YepCode. Exécutez des scripts générés par LLM et transformez vos processus YepCode en outils puissants que les assistants IA peuvent utiliser directement. YepCode est l'environnement idéal pour construire un serveur d'outils MCP dynamique : exposez chaque processus comme un outil (avec OAuth, jetons API ou vos identifiants), définissez les paramètres de chaque outil avec un schéma JSON pour une flexibilité totale, et implémentez les outils en Python ou Node.js — le tout dans un seul serveur qui mélange plusieurs langages.

Pourquoi le serveur MCP YepCode ?

  • Intégration IA transparente : Convertissez les processus YepCode en outils prêts pour l'IA sans aucune configuration
  • Contrôle des processus en temps réel : Permettez une interaction directe entre les systèmes d'IA et vos flux de travail
  • Sécurité de niveau entreprise : Exécutez le code dans les environnements isolés et prêts pour la production de YepCode
  • Compatibilité universelle : Intégrez-vous à toute plateforme d'IA prenant en charge le Model Context Protocol

YepCode : L'environnement parfait pour un serveur d'outils MCP dynamique

YepCode est conçu pour être la plateforme idéale pour exécuter un serveur d'outils MCP dynamique :

  • Un processus, un outil : Chaque processus YepCode peut être exposé comme un outil MCP. Étiquetez vos processus (par ex. mcp-tool, core, automation) et ils deviennent des outils que les assistants IA peuvent invoquer. Vous pouvez sécuriser l'accès avec OAuth, des jetons API ou vos identifiants YepCode existants — chaque outil s'exécute dans votre espace de travail avec le même modèle de sécurité.

  • Contrôle total des paramètres des outils : Chaque outil peut définir son propre schéma de paramètres en JSON Schema. Vous avez une flexibilité totale pour décrire les entrées (types, descriptions, champs obligatoires, énumérations, valeurs par défaut, etc.), afin que l'IA reçoive des métadonnées riches et puisse appeler vos outils correctement.

  • Implémentations d'outils polyglottes : Implémentez les outils en Python ou Node.js (ou les deux). Le même serveur MCP peut exposer des outils reposant sur différents environnements d'exécution — pensez-y comme un seul serveur MCP qui mélange les implémentations dans plusieurs langages.

Pour une documentation complète, consultez la documentation du serveur MCP YepCode.

Installation

Ce package vous permet d'exécuter le serveur MCP YepCode localement ou dans votre propre infrastructure (NPX, Docker ou déploiement personnalisé). Intégrez-le à des plateformes d'IA comme Cursor ou Claude Desktop.

Astuce : Depuis votre compte YepCode, vous avez également accès à un serveur MCP hébergé qui ne nécessite pas d'installation locale. L'URL de connexion est toujours : https://cloud.yepcode.io/mcp

Prérequis

Obtenez vos identifiants API YepCode :

  1. Inscrivez-vous sur YepCode Cloud
  2. Visitez Settings > API credentials pour créer un nouveau jeton API.

Utilisation avec NPX

Assurez-vous d'avoir Node.js installé (version 18 ou supérieure) et utilisez une configuration similaire à la suivante :

{
  "mcpServers": {
    "yepcode-mcp-server": {
      "command": "npx",
      "args": ["-y", "@yepcode/mcp-server"],
      "env": {
        "YEPCODE_API_TOKEN": "your_api_token_here"
      }
    }
  }
}

Utilisation avec Docker

  1. Construisez l'image du conteneur :
docker build -t yepcode/mcp-server .
  1. Utilisez une configuration similaire à la suivante :
{
  "mcpServers": {
    "yepcode-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-d",
        "-e",
        "YEPCODE_API_TOKEN=your_api_token_here",
        "yepcode/mcp-server"
      ]
    }
  }
}

Débogage

Le débogage des serveurs MCP peut être délicat car ils communiquent via stdio. Pour faciliter cela, nous vous recommandons d'utiliser le MCP Inspector, que vous pouvez exécuter avec la commande suivante :

npm run inspector

Cela démarrera un serveur où vous pourrez accéder aux outils de débogage directement dans votre navigateur.

Référence des outils MCP YepCode

Le serveur MCP fournit plusieurs outils pour interagir avec l'infrastructure de YepCode :

Exécution de code

run_code

Exécute du code dans l'environnement sécurisé de YepCode.

// Input
{
  code: string;                          // The code to execute
  options?: {
    language?: string;                   // Programming language (default: 'javascript')
    comment?: string;                    // Execution context
    settings?: Record<string, unknown>;  // Runtime settings
  }
}

// Response
{
  returnValue?: unknown;                 // Execution result
  logs?: string[];                       // Console output
  error?: string;                        // Error message if execution failed
}
Options MCP

Le serveur MCP YepCode prend en charge les options suivantes :

  • runCodeCleanup : Ignorer le nettoyage de run_code. Par défaut, le code source des processus run_code est supprimé après l'exécution. Si vous souhaitez le conserver à des fins d'audit, vous pouvez utiliser cette option.
  • skipCodingRules : Ignorer l'inclusion des règles de codage dans la définition de l'outil run_code. Par défaut, les règles de codage JavaScript et Python de la documentation YepCode sont incluses dans le schéma de l'outil pour guider le code généré par l'IA. Si vous souhaitez ignorer cela pour une initialisation plus rapide de l'outil ou des définitions d'outils plus petites, vous pouvez utiliser cette option.

Les options peuvent être passées sous forme de liste séparée par des virgules dans la variable d'environnement YEPCODE_MCP_OPTIONS.

Sélection des outils

Vous pouvez contrôler quels outils sont activés en définissant la variable d'environnement YEPCODE_MCP_TOOLS avec une liste séparée par des virgules de catégories d'outils et d'étiquettes de processus :

Catégories d'outils intégrées :

  • run_code : Active l'outil d'exécution de code
  • yc_api : Active tous les outils de gestion API de base (processus, planifications, variables, stockage, exécutions, modules)
  • yc_api_full : Active tous les outils de gestion API, y compris les outils liés aux versions (étend yc_api avec des outils supplémentaires de gestion des versions de processus et de modules)
  • tout nom d'outil API spécifique (par ex., execute_process_sync, get_execution,...)

Étiquettes de processus :

  • Toute étiquette utilisée dans vos processus YepCode (par ex., mcp-tool, core, automation, etc.)
  • Lorsque vous spécifiez une étiquette de processus, tous les processus avec cette étiquette seront exposés comme des outils MCP individuels
  • Les outils de processus seront nommés en utilisant le slug du processus (ou préfixés par yc_ et l'ID du processus si le nom dépasse 60 caractères)

Si non spécifié, tous les outils intégrés sont activés par défaut, mais aucun outil de processus ne sera exposé.

// NPX configuration with options
{
  "mcpServers": {
    "yepcode-mcp-server": {
      "command": "npx",
      "args": ["-y", "@yepcode/mcp-server"],
      "env": {
        "YEPCODE_API_TOKEN": "your_api_token_here",
        "YEPCODE_MCP_OPTIONS": "runCodeCleanup,skipCodingRules",
        "YEPCODE_MCP_TOOLS": "run_code,yc_api,mcp-tool,core"
      }
    }
  }
}

Exemples de scénarios :

  • YEPCODE_MCP_TOOLS=run_code,yc_api - Active l'exécution de code intégrée et les outils de gestion API de base
  • YEPCODE_MCP_TOOLS=run_code,yc_api_full - Active l'exécution de code intégrée et tous les outils de gestion API (y compris la gestion des versions)
  • YEPCODE_MCP_TOOLS=core,automation - Expose uniquement les processus étiquetés "core" ou "automation" comme outils
  • YEPCODE_MCP_TOOLS=run_code,yc_api,core - Active les outils intégrés plus tous les processus étiquetés "core"

Gestion de l'environnement

set_env_var

Définit une variable d'environnement dans l'espace de travail YepCode.

// Input
{
  key: string;                           // Variable name
  value: string;                         // Variable value
  isSensitive?: boolean;                 // Whether to mask the value in logs (default: true)
}

remove_env_var

Supprime une variable d'environnement de l'espace de travail YepCode.

// Input
{
  key: string;                           // Name of the variable to remove
}

Gestion du stockage

YepCode fournit un système de stockage intégré qui vous permet de télécharger, lister, télécharger et supprimer des fichiers. Ces fichiers sont accessibles depuis vos exécutions de code en utilisant les méthodes d'assistance yepcode.storage.

list_files

Liste tous les fichiers dans votre stockage YepCode.

// Input
{
  prefix?: string;                       // Optional prefix to filter files
}

// Response
{
  files: Array<{
    filename: string;                    // File name or path
    size: number;                        // File size in bytes
    lastModified: string;                // Last modification date
  }>;
}

upload_file

Télécharge un fichier vers le stockage YepCode.

// Input
{
  filename: string;                      // File path (e.g., 'file.txt' or 'folder/file.txt')
  content: string | {                   // File content
    data: string;                        // Base64 encoded content for binary files
    encoding: "base64";
  };
}

// Response
{
  success: boolean;                      // Upload success status
  filename: string;                      // Uploaded file path
}

download_file

Télécharge un fichier depuis le stockage YepCode.

// Input
{
  filename: string;                      // File path to download
}

// Response
{
  filename: string;                      // File path
  content: string;                       // File content (base64 for binary files)
  encoding?: string;                     // Encoding type if binary
}

delete_file

Supprime un fichier du stockage YepCode.

// Input
{
  filename: string;                      // File path to delete
}

// Response
{
  success: boolean;                      // Deletion success status
  filename: string;                      // Deleted file path
}

Exécution de processus

Le serveur MCP peut exposer vos processus YepCode comme des outils MCP individuels, les rendant directement accessibles aux assistants IA. Cette fonctionnalité est activée en spécifiant des étiquettes de processus dans la variable d'environnement YEPCODE_MCP_TOOLS.

Comment cela fonctionne :

  1. Étiquetez vos processus YepCode avec n'importe quelle étiquette (par ex., core, api, automation, mcp-tool, etc.)
  2. Ajoutez ces étiquettes à la variable d'environnement YEPCODE_MCP_TOOLS
  3. Tous les processus avec les étiquettes spécifiées seront exposés comme des outils MCP individuels

Il y aura un outil pour chaque processus exposé nommé en utilisant le slug du processus (ou préfixé par yc_ et l'ID du processus si le nom de l'outil dépasse 60 caractères).

Pour plus d'informations sur les étiquettes de processus, consultez notre documentation sur les étiquettes de processus.

<process_slug>

// Input
{
  parameters?: any;                      // This should match the input parameters specified in the process
  options?: {
    tag?: string;                        // Process version to execute
    comment?: string;                    // Execution context
  };
  synchronousExecution?: boolean;        // Whether to wait for completion (default: true)
}

// Response (synchronous execution)
{
  executionId: string;                   // Unique execution identifier
  logs: string[];                        // Process execution logs
  returnValue?: unknown;                 // Process output
  error?: string;                        // Error message if execution failed
}

// Response (asynchronous execution)
{
  executionId: string;                   // Unique execution identifier
}

Outils de gestion API

Les catégories d'outils de gestion API (yc_api et yc_api_full) fournissent un accès API complet pour gérer tous les aspects de votre espace de travail YepCode :

Outils API de base (yc_api) : L'étiquette yc_api active les outils de gestion API standard pour les opérations de base dans votre espace de travail.

Outils API étendus (yc_api_full) : L'étiquette yc_api_full inclut tout ce qui vient de yc_api plus des outils supplémentaires pour gérer les versions de processus et de modules.

Gestion des processus :

  • get_processes - Lister les processus avec filtrage optionnel
  • create_process - Créer de nouveaux processus avec le code source
  • get_process - Obtenir les détails d'un processus
  • update_process - Mettre à jour un processus existant
  • delete_process - Supprimer un processus
  • get_process_versions - Obtenir les versions d'un processus (nécessite yc_api_full)
  • execute_process_async - Exécuter un processus de manière asynchrone
  • execute_process_sync - Exécuter un processus de manière synchrone
  • schedule_process - Planifier un processus pour qu'il s'exécute automatiquement

Gestion des planifications :

  • get_schedules - Lister les processus planifiés
  • get_schedule - Obtenir les détails d'une planification
  • pause_schedule - Mettre en pause un processus planifié
  • resume_schedule - Reprendre une planification en pause
  • delete_schedule - Supprimer une planification
  • update_schedule - Mettre à jour un processus planifié

Gestion des variables :

  • get_variables - Lister les variables d'équipe
  • create_variable - Créer une nouvelle variable
  • update_variable - Mettre à jour une variable existante
  • delete_variable - Supprimer une variable

Gestion du stockage :

  • get_storage_objects - Lister les objets de stockage
  • upload_storage_object - Télécharger un fichier vers le stockage
  • download_storage_object - Télécharger un fichier depuis le stockage
  • delete_storage_object - Supprimer un fichier du stockage

Gestion des exécutions :

  • get_executions - Lister les exécutions avec filtrage optionnel
  • get_execution - Obtenir les détails d'une exécution depuis l'API
  • kill_execution - Tuer une exécution en cours
  • rerun_execution - Relancer une exécution précédente
  • get_execution_logs - Obtenir les journaux d'exécution

Gestion des modules :

  • get_modules - Lister les modules de la bibliothèque de scripts
  • create_module - Créer un nouveau module
  • get_module - Obtenir les détails d'un module
  • delete_module - Supprimer un module
  • get_module_versions - Obtenir les versions d'un module (nécessite yc_api_full)
  • get_module_version - Obtenir une version spécifique d'un module (nécessite yc_api_full)
  • delete_module_version - Supprimer une version de module (nécessite yc_api_full)
  • get_module_aliases - Obtenir les alias de version de module (nécessite yc_api_full)

Licence

Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.