YepCode MCP Server

offiziell

Führen Sie jeden von einem LLM generierten Code in der sicheren und skalierbaren Sandbox-Umgebung von YepCode aus und erstellen Sie Ihre eigenen MCP-Tools mit JavaScript oder Python, mit vollständiger Unterstützung für NPM- und PyPI-Pakete.

GitHub
43

Dokumentation

YepCode MCP Server Preview

NPM version NPM Downloads GitHub Workflow Status

Trust Score smithery badge

Was ist der YepCode MCP-Server?

Ein MCP-Server (Model Context Protocol), der KI-Plattformen die Interaktion mit der Infrastruktur von YepCode ermöglicht. Führen Sie LLM-generierte Skripte aus und verwandeln Sie Ihre YepCode-Prozesse in leistungsstarke Werkzeuge, die KI-Assistenten direkt nutzen können. YepCode ist die perfekte Umgebung, um einen dynamischen MCP-Tools-Server aufzubauen: Stellen Sie jeden Prozess als Tool bereit (mit OAuth, API-Tokens oder Ihren Anmeldedaten), definieren Sie die Parameter jedes Tools mit JSON Schema für maximale Flexibilität und implementieren Sie Tools in Python oder Node.js – alles in einem Server, der mehrere Sprachen vereint.

Warum den YepCode MCP-Server?

  • Nahtlose KI-Integration: Konvertieren Sie YepCode-Prozesse ohne Konfigurationsaufwand in KI-fähige Werkzeuge
  • Echtzeit-Prozesssteuerung: Ermöglichen Sie die direkte Interaktion zwischen KI-Systemen und Ihren Workflows
  • Unternehmenstaugliche Sicherheit: Führen Sie Code in den isolierten, produktionsreifen Umgebungen von YepCode aus
  • Universelle Kompatibilität: Integrieren Sie sich mit jeder KI-Plattform, die das Model Context Protocol unterstützt

YepCode: Die perfekte Umgebung für einen dynamischen MCP-Tools-Server

YepCode ist als ideale Plattform für den Betrieb eines dynamischen MCP-Tools-Servers konzipiert:

  • Ein Prozess, ein Tool: Jeder YepCode-Prozess kann als MCP-Tool bereitgestellt werden. Kennzeichnen Sie Ihre Prozesse (z. B. mcp-tool, core, automation) und sie werden zu Werkzeugen, die KI-Assistenten aufrufen können. Sie können den Zugriff mit OAuth, API-Tokens oder Ihren vorhandenen YepCode-Anmeldedaten absichern – jedes Tool läuft in Ihrem Workspace mit demselben Sicherheitsmodell.

  • Volle Kontrolle über Tool-Parameter: Jedes Tool kann sein eigenes Parameterschema als JSON Schema definieren. Sie erhalten vollständige Flexibilität, um Eingaben zu beschreiben (Typen, Beschreibungen, Pflichtfelder, Aufzählungen, Standardwerte usw.), sodass die KI umfangreiche Metadaten erhält und Ihre Tools korrekt aufrufen kann.

  • Polyglotte Tool-Implementierungen: Implementieren Sie Tools in Python oder Node.js (oder beidem). Derselbe MCP-Server kann Tools bereitstellen, die auf unterschiedlichen Laufzeitumgebungen basieren – stellen Sie sich das als einen MCP-Server vor, der Implementierungen in mehreren Sprachen mischt.

Die vollständige Dokumentation finden Sie in den YepCode MCP-Server-Dokumenten.

Installation

Dieses Paket ermöglicht es Ihnen, den YepCode MCP-Server lokal oder in Ihrer eigenen Infrastruktur (NPX, Docker oder benutzerdefinierte Bereitstellung) auszuführen. Integrieren Sie ihn mit KI-Plattformen wie Cursor oder Claude Desktop.

Tipp: Über Ihr YepCode-Konto haben Sie auch Zugriff auf einen gehosteten MCP-Server, der keine lokale Installation erfordert. Die Verbindungs-URL lautet immer: https://cloud.yepcode.io/mcp

Voraussetzungen

Besorgen Sie sich Ihre YepCode-API-Anmeldedaten:

  1. Registrieren Sie sich bei YepCode Cloud
  2. Besuchen Sie Settings > API credentials, um ein neues API-Token zu erstellen.

Verwendung von NPX

Stellen Sie sicher, dass Node.js installiert ist (Version 18 oder höher), und verwenden Sie eine Konfiguration ähnlich der folgenden:

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

Verwendung von Docker

  1. Erstellen Sie das Container-Image:
docker build -t yepcode/mcp-server .
  1. Verwenden Sie eine Konfiguration ähnlich der folgenden:
{
  "mcpServers": {
    "yepcode-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-d",
        "-e",
        "YEPCODE_API_TOKEN=your_api_token_here",
        "yepcode/mcp-server"
      ]
    }
  }
}

Fehlersuche

Die Fehlersuche bei MCP-Servern kann knifflig sein, da sie über stdio kommunizieren. Zur Vereinfachung empfehlen wir die Verwendung des MCP Inspector, den Sie mit folgendem Befehl ausführen können:

npm run inspector

Dadurch wird ein Server gestartet, über den Sie direkt in Ihrem Browser auf Debugging-Tools zugreifen können.

YepCode MCP-Tools-Referenz

Der MCP-Server stellt mehrere Tools für die Interaktion mit der YepCode-Infrastruktur bereit:

Code-Ausführung

run_code

Führt Code in der sicheren Umgebung von YepCode aus.

// 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
}
MCP-Optionen

Der YepCode MCP-Server unterstützt die folgenden Optionen:

  • runCodeCleanup: Überspringt die run_code-Bereinigung. Standardmäßig wird der Quellcode von run_code-Prozessen nach der Ausführung entfernt. Wenn Sie ihn zu Prüfzwecken aufbewahren möchten, können Sie diese Option verwenden.
  • skipCodingRules: Überspringt das Einfügen von Codierungsregeln in die run_code-Tool-Definition. Standardmäßig sind JavaScript- und Python-Codierungsregeln aus der YepCode-Dokumentation im Tool-Schema enthalten, um KI-generierten Code zu leiten. Wenn Sie dies für eine schnellere Tool-Initialisierung oder kleinere Tool-Definitionen überspringen möchten, können Sie diese Option verwenden.

Optionen können als kommagetrennte Liste in der Umgebungsvariable YEPCODE_MCP_OPTIONS übergeben werden.

Tool-Auswahl

Sie können steuern, welche Tools aktiviert sind, indem Sie die Umgebungsvariable YEPCODE_MCP_TOOLS mit einer kommagetrennten Liste von Tool-Kategorien und Prozess-Tags setzen:

Integrierte Tool-Kategorien:

  • run_code: Aktiviert das Code-Ausführungs-Tool
  • yc_api: Aktiviert alle grundlegenden API-Verwaltungstools (Prozesse, Zeitpläne, Variablen, Speicher, Ausführungen, Module)
  • yc_api_full: Aktiviert alle API-Verwaltungstools einschließlich versionierungsbezogener Tools (erweitert yc_api um zusätzliche Tools zur Verwaltung von Prozess- und Modulversionen)
  • jeder spezifische API-Tool-Name (z. B. execute_process_sync, get_execution, …)

Prozess-Tags:

  • Jedes in Ihren YepCode-Prozessen verwendete Tag (z. B. mcp-tool, core, automation usw.)
  • Wenn Sie ein Prozess-Tag angeben, werden alle Prozesse mit diesem Tag als individuelle MCP-Tools bereitgestellt
  • Prozess-Tools werden mit dem Prozess-Slug benannt (oder mit dem Präfix yc_ und der Prozess-ID, wenn der Name länger als 60 Zeichen ist)

Wenn nichts angegeben ist, sind standardmäßig alle integrierten Tools aktiviert, aber es werden keine Prozess-Tools bereitgestellt.

// 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"
      }
    }
  }
}

Beispielszenarien:

  • YEPCODE_MCP_TOOLS=run_code,yc_api - Aktiviert die integrierte Code-Ausführung und grundlegende API-Verwaltungstools
  • YEPCODE_MCP_TOOLS=run_code,yc_api_full - Aktiviert die integrierte Code-Ausführung und alle API-Verwaltungstools (einschließlich Versionsverwaltung)
  • YEPCODE_MCP_TOOLS=core,automation - Stellt nur Prozesse mit den Tags „core“ oder „automation“ als Tools bereit
  • YEPCODE_MCP_TOOLS=run_code,yc_api,core - Aktiviert integrierte Tools plus alle Prozesse mit dem Tag „core“

Umgebungsverwaltung

set_env_var

Setzt eine Umgebungsvariable im YepCode-Workspace.

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

remove_env_var

Entfernt eine Umgebungsvariable aus dem YepCode-Workspace.

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

Speicherverwaltung

YepCode bietet ein integriertes Speichersystem, mit dem Sie Dateien hochladen, auflisten, herunterladen und löschen können. Auf diese Dateien kann von Ihren Code-Ausführungen aus mit den Hilfsmethoden yepcode.storage zugegriffen werden.

list_files

Listet alle Dateien in Ihrem YepCode-Speicher auf.

// 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

Lädt eine Datei in den YepCode-Speicher hoch.

// 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

Lädt eine Datei aus dem YepCode-Speicher herunter.

// 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

Löscht eine Datei aus dem YepCode-Speicher.

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

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

Prozessausführung

Der MCP-Server kann Ihre YepCode-Prozesse als individuelle MCP-Tools bereitstellen und sie so direkt für KI-Assistenten zugänglich machen. Diese Funktion wird aktiviert, indem Sie Prozess-Tags in der Umgebungsvariable YEPCODE_MCP_TOOLS angeben.

So funktioniert es:

  1. Kennzeichnen Sie Ihre YepCode-Prozesse mit einem beliebigen Tag (z. B. core, api, automation, mcp-tool usw.)
  2. Fügen Sie diese Tags zur Umgebungsvariable YEPCODE_MCP_TOOLS hinzu
  3. Alle Prozesse mit den angegebenen Tags werden als individuelle MCP-Tools bereitgestellt

Für jeden bereitgestellten Prozess gibt es ein Tool, das mit dem Prozess-Slug benannt wird (oder mit dem Präfix yc_ und der Prozess-ID, wenn der Tool-Name länger als 60 Zeichen ist).

Weitere Informationen zu Prozess-Tags finden Sie in unserer Dokumentation zu Prozess-Tags.

<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
}

API-Verwaltungstools

Die API-Verwaltungs-Toolkategorien (yc_api und yc_api_full) bieten umfassenden API-Zugriff zur Verwaltung aller Aspekte Ihres YepCode-Workspace:

Grundlegende API-Tools (yc_api): Das Tag yc_api aktiviert Standard-API-Verwaltungstools für Kernoperationen in Ihrem Workspace.

Erweiterte API-Tools (yc_api_full): Das Tag yc_api_full umfasst alles von yc_api plus zusätzliche Tools zur Verwaltung von Prozess- und Modulversionen.

Prozessverwaltung:

  • get_processes - Prozesse mit optionaler Filterung auflisten
  • create_process - Neue Prozesse mit Quellcode erstellen
  • get_process - Prozessdetails abrufen
  • update_process - Einen vorhandenen Prozess aktualisieren
  • delete_process - Einen Prozess löschen
  • get_process_versions - Prozessversionen abrufen (erfordert yc_api_full)
  • execute_process_async - Einen Prozess asynchron ausführen
  • execute_process_sync - Einen Prozess synchron ausführen
  • schedule_process - Einen Prozess zur automatischen Ausführung planen

Zeitplanverwaltung:

  • get_schedules - Geplante Prozesse auflisten
  • get_schedule - Zeitplandetails abrufen
  • pause_schedule - Einen geplanten Prozess pausieren
  • resume_schedule - Einen pausierten Zeitplan fortsetzen
  • delete_schedule - Einen Zeitplan löschen
  • update_schedule - Einen geplanten Prozess aktualisieren

Variablenverwaltung:

  • get_variables - Team-Variablen auflisten
  • create_variable - Eine neue Variable erstellen
  • update_variable - Eine vorhandene Variable aktualisieren
  • delete_variable - Eine Variable löschen

Speicherverwaltung:

  • get_storage_objects - Speicherobjekte auflisten
  • upload_storage_object - Eine Datei in den Speicher hochladen
  • download_storage_object - Eine Datei aus dem Speicher herunterladen
  • delete_storage_object - Eine Datei aus dem Speicher löschen

Ausführungsverwaltung:

  • get_executions - Ausführungen mit optionaler Filterung auflisten
  • get_execution - Ausführungsdetails von der API abrufen
  • kill_execution - Eine laufende Ausführung beenden
  • rerun_execution - Eine vorherige Ausführung erneut ausführen
  • get_execution_logs - Ausführungsprotokolle abrufen

Modulverwaltung:

  • get_modules - Skriptbibliotheksmodule auflisten
  • create_module - Ein neues Modul erstellen
  • get_module - Moduldetails abrufen
  • delete_module - Ein Modul löschen
  • get_module_versions - Modulversionen abrufen (erfordert yc_api_full)
  • get_module_version - Eine bestimmte Modulversion abrufen (erfordert yc_api_full)
  • delete_module_version - Eine Modulversion löschen (erfordert yc_api_full)
  • get_module_aliases - Modulversions-Aliase abrufen (erfordert yc_api_full)

Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – siehe die LICENSE-Datei für Details.