Servidor MCP de YepCode

¿Qué es YepCode MCP Server?

Un servidor MCP ( Protocolo de Contexto de Modelo ) que permite que las plataformas de IA interactúen con la infraestructura de YepCode . Ejecute scripts generados por LLM y convierta sus procesos de YepCode en potentes herramientas que los asistentes de IA pueden usar directamente.

¿Por qué YepCode MCP Server?

Integración perfecta con IA : Convierta los procesos de YepCode en herramientas preparadas para IA sin necesidad de configuración.
Control de procesos en tiempo real : habilite la interacción directa entre los sistemas de IA y sus flujos de trabajo
Seguridad de nivel empresarial : ejecute código en los entornos aislados y listos para producción de YepCode
Compatibilidad universal : se integra con cualquier plataforma de IA compatible con el Protocolo de contexto de modelo

Guía de integración

El servidor MCP de YepCode se puede integrar con plataformas de IA como Cursor o Claude Desktop utilizando un enfoque remoto (ofrecemos una versión alojada del servidor MCP) o un enfoque local (se requiere la instalación de NPX o Docker).

Enfoque remoto mediante el servidor SSE

Regístrate en YepCode Cloud
Obtén la URL de tu servidor MCP desde tu espacio de trabajo en: Settings > API credentials .
Agregue la siguiente configuración a la configuración de su plataforma de IA:

{
  "mcpServers": {
    "yepcode-mcp-server": {
      "url": "https://cloud.yepcode.io/mcp/sk-c2E....RD/sse"
    }
  }
}

Enfoque local

Variables de entorno requeridas

YEPCODE_API_TOKEN : Tu token de la API de YepCode. Cómo obtenerlo:
1. Regístrate en YepCode Cloud
2. Obtén tu token de API desde tu espacio de trabajo en: Settings > API credentials

Uso de NPX

Agregue la siguiente configuración a la configuración de su plataforma de IA:

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

Usando Docker

Construya la imagen del contenedor:

docker build -t yepcode/mcp-server .

Agregue la siguiente configuración a la configuración de su plataforma de IA:

{
  "mcpServers": {
    "yepcode-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-d",
        "-e",
        "YEPCODE_API_TOKEN=your_api_token_here",
        "yepcode/mcp-server"
      ]
    }
  }
}

Depuración

Depurar servidores MCP puede ser complicado, ya que se comunican a través de stdio. Para facilitarlo, recomendamos usar el Inspector MCP , que se puede ejecutar con el siguiente comando:

npm run inspector

Esto iniciará un servidor donde podrá acceder a herramientas de depuración directamente en su navegador.

Referencia de herramientas MCP de YepCode

El servidor MCP proporciona varias herramientas para interactuar con la infraestructura de YepCode:

Ejecución de código

código de ejecución

Ejecuta código en el entorno seguro 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
}

Opciones de MCP

El servidor YepCode MCP admite las siguientes opciones:

Desactivar la herramienta run_code: En algunos casos, puede que quieras run_code . Por ejemplo, si quieres usar el servidor MCP como proveedor únicamente para las herramientas existentes en tu cuenta de YepCode.
Omitir la limpieza de run_code: De forma predeterminada, el código fuente de los procesos de run_code se elimina tras la ejecución. Si desea conservarlo para fines de auditoría, puede usar esta opción.

Las opciones se pueden pasar como una lista separada por comas en la variable de entorno YEPCODE_MCP_OPTIONS o como un parámetro de consulta en la URL del servidor MCP.

// SSE server configuration
{
  "mcpServers": {
    "yepcode-mcp-server": {
      "url": "https://cloud.yepcode.io/mcp/sk-c2E....RD/sse?mcpOptions=disableRunCodeTool,skipRunCodeCleanup"
    }
  }
}

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

Gestión del medio ambiente

establecer_variable_de_entorno

Establece una variable de entorno en el espacio de trabajo de YepCode.

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

eliminar_variable_de_entorno

Elimina una variable de entorno del espacio de trabajo de YepCode.

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

Ejecución del proceso

El servidor MCP puede exponer sus procesos de YepCode como herramientas MCP individuales, haciéndolos directamente accesibles para los asistentes de IA. Esta función se activa simplemente añadiendo la etiqueta mcp-tool a su proceso (consulte nuestra documentación para obtener más información sobre las etiquetas de proceso ).

Habrá una herramienta para cada proceso expuesto: run_ycp_<process_slug> (o run_ycp_<process_id> si el nombre de la herramienta tiene más de 60 caracteres).

run_ycp_<slug_de_proceso>

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

obtener_ejecución

Recupera el resultado de la ejecución de un proceso.

// Input
{
  executionId: string;                   // ID of the execution to retrieve
}

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

Licencia

Este proyecto está licenciado bajo la licencia MIT: consulte el archivo de LICENCIA para obtener más detalles.

YepCode MCP Server

Integrations