YepCode MCP Server

oficial

Execute qualquer código gerado por LLM no ambiente sandbox seguro e escalável do YepCode e crie suas próprias ferramentas MCP usando JavaScript ou Python, com suporte completo para pacotes NPM e PyPI

GitHub
43

Documentação

YepCode MCP Server Preview

NPM version NPM Downloads GitHub Workflow Status

Trust Score smithery badge

O que é o YepCode MCP Server?

Um servidor MCP (Model Context Protocol) que permite que plataformas de IA interajam com a infraestrutura do YepCode. Execute scripts gerados por LLMs e transforme seus processos do YepCode em ferramentas poderosas que assistentes de IA podem usar diretamente. O YepCode é o ambiente perfeito para construir um servidor dinâmico de ferramentas MCP: exponha cada processo como uma ferramenta (com OAuth, tokens de API ou suas credenciais), defina os parâmetros de cada ferramenta com JSON Schema para total flexibilidade e implemente ferramentas em Python ou Node.js — tudo em um único servidor que combina múltiplas linguagens.

Por que o YepCode MCP Server?

  • Integração perfeita com IA: Converta processos do YepCode em ferramentas prontas para IA com configuração zero
  • Controle de processos em tempo real: Permita interação direta entre sistemas de IA e seus fluxos de trabalho
  • Segurança de nível empresarial: Execute código nos ambientes isolados e prontos para produção do YepCode
  • Compatibilidade universal: Integre-se com qualquer plataforma de IA que suporte o Model Context Protocol

YepCode: O Ambiente Perfeito para um Servidor Dinâmico de Ferramentas MCP

O YepCode foi construído para ser a plataforma ideal para executar um servidor dinâmico de ferramentas MCP:

  • Um processo, uma ferramenta: Cada processo do YepCode pode ser exposto como uma ferramenta MCP. Marque seus processos (ex.: mcp-tool, core, automation) e eles se tornam ferramentas que assistentes de IA podem invocar. Você pode proteger o acesso com OAuth, tokens de API ou suas credenciais existentes do YepCode — cada ferramenta executa em seu espaço de trabalho com o mesmo modelo de segurança.

  • Controle total sobre os parâmetros da ferramenta: Cada ferramenta pode definir seu próprio esquema de parâmetros como JSON Schema. Você tem total flexibilidade para descrever entradas (tipos, descrições, campos obrigatórios, enumerações, padrões, etc.), para que a IA receba metadados ricos e possa chamar suas ferramentas corretamente.

  • Implementações de ferramentas poliglotas: Implemente ferramentas em Python ou Node.js (ou ambos). O mesmo servidor MCP pode expor ferramentas suportadas por diferentes runtimes — pense nisso como um servidor MCP que mistura implementações em várias linguagens.

Para documentação completa, veja a documentação do YepCode MCP Server.

Instalação

Este pacote permite que você execute o servidor MCP do YepCode localmente ou em sua própria infraestrutura (NPX, Docker ou implantação personalizada). Integre-o com plataformas de IA como Cursor ou Claude Desktop.

Dica: A partir da sua conta YepCode, você também tem acesso a um servidor MCP hospedado que não requer instalação local. A URL de conexão é sempre: https://cloud.yepcode.io/mcp

Pré-requisitos

Obtenha suas credenciais da API do YepCode:

  1. Cadastre-se no YepCode Cloud
  2. Visite Settings > API credentials para criar um novo token de API.

Usando NPX

Certifique-se de ter o Node.js instalado (versão 18 ou superior) e use uma configuração semelhante à seguinte:

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

Usando Docker

  1. Construa a imagem do contêiner:
docker build -t yepcode/mcp-server .
  1. Use uma configuração semelhante à seguinte:
{
  "mcpServers": {
    "yepcode-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-d",
        "-e",
        "YEPCODE_API_TOKEN=your_api_token_here",
        "yepcode/mcp-server"
      ]
    }
  }
}

Depuração

Depurar servidores MCP pode ser complicado, pois eles se comunicam via stdio. Para facilitar, recomendamos usar o MCP Inspector, que você pode executar com o seguinte comando:

npm run inspector

Isso iniciará um servidor onde você pode acessar ferramentas de depuração diretamente no seu navegador.

Referência de Ferramentas MCP do YepCode

O servidor MCP fornece várias ferramentas para interagir com a infraestrutura do YepCode:

Execução de Código

run_code

Executa código no ambiente seguro do 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
}
Opções MCP

O servidor MCP do YepCode suporta as seguintes opções:

  • runCodeCleanup: Pular a limpeza do run_code. Por padrão, o código fonte dos processos run_code é removido após a execução. Se você quiser mantê-lo para fins de auditoria, pode usar esta opção.
  • skipCodingRules: Pular a inclusão de regras de codificação na definição da ferramenta run_code. Por padrão, as regras de codificação JavaScript e Python da documentação do YepCode são incluídas no esquema da ferramenta para orientar o código gerado por IA. Se você quiser pular isso para uma inicialização mais rápida da ferramenta ou definições menores, pode usar esta opção.

As opções podem ser passadas como uma lista separada por vírgulas na variável de ambiente YEPCODE_MCP_OPTIONS.

Seleção de Ferramentas

Você pode controlar quais ferramentas estão habilitadas definindo a variável de ambiente YEPCODE_MCP_TOOLS com uma lista separada por vírgulas de categorias de ferramentas e tags de processo:

Categorias de ferramentas integradas:

  • run_code: Habilita a ferramenta de execução de código
  • yc_api: Habilita todas as ferramentas básicas de gerenciamento de API (processos, agendamentos, variáveis, armazenamento, execuções, módulos)
  • yc_api_full: Habilita todas as ferramentas de gerenciamento de API, incluindo ferramentas relacionadas a versões (estende yc_api com ferramentas adicionais de gerenciamento de versões de processos e módulos)
  • qualquer nome de ferramenta de API específico (ex.: execute_process_sync, get_execution, ...)

Tags de processo:

  • Qualquer tag usada em seus processos do YepCode (ex.: mcp-tool, core, automation, etc.)
  • Quando você especifica uma tag de processo, todos os processos com essa tag serão expostos como ferramentas MCP individuais
  • As ferramentas de processo serão nomeadas usando o slug do processo (ou prefixadas com yc_ e o ID do processo se o nome tiver mais de 60 caracteres)

Se não for especificado, todas as ferramentas integradas são habilitadas por padrão, mas nenhuma ferramenta de processo será exposta.

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

Cenários de exemplo:

  • YEPCODE_MCP_TOOLS=run_code,yc_api - Habilita a execução de código integrada e ferramentas básicas de gerenciamento de API
  • YEPCODE_MCP_TOOLS=run_code,yc_api_full - Habilita a execução de código integrada e todas as ferramentas de gerenciamento de API (incluindo gerenciamento de versões)
  • YEPCODE_MCP_TOOLS=core,automation - Expõe apenas processos marcados com "core" ou "automation" como ferramentas
  • YEPCODE_MCP_TOOLS=run_code,yc_api,core - Habilita ferramentas integradas mais todos os processos marcados com "core"

Gerenciamento de Ambiente

set_env_var

Define uma variável de ambiente no espaço de trabalho do YepCode.

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

remove_env_var

Remove uma variável de ambiente do espaço de trabalho do YepCode.

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

Gerenciamento de Armazenamento

O YepCode fornece um sistema de armazenamento integrado que permite fazer upload, listar, baixar e excluir arquivos. Esses arquivos podem ser acessados de suas execuções de código usando os métodos auxiliares yepcode.storage.

list_files

Lista todos os arquivos no seu armazenamento do 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

Faz upload de um arquivo para o armazenamento do 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

Baixa um arquivo do armazenamento do 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

Exclui um arquivo do armazenamento do YepCode.

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

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

Execução de Processos

O servidor MCP pode expor seus Processos do YepCode como ferramentas MCP individuais, tornando-os diretamente acessíveis a assistentes de IA. Este recurso é habilitado especificando tags de processo na variável de ambiente YEPCODE_MCP_TOOLS.

Como funciona:

  1. Marque seus processos do YepCode com qualquer tag (ex.: core, api, automation, mcp-tool, etc.)
  2. Adicione essas tags à variável de ambiente YEPCODE_MCP_TOOLS
  3. Todos os processos com as tags especificadas serão expostos como ferramentas MCP individuais

Haverá uma ferramenta para cada processo exposto, nomeada usando o slug do processo (ou prefixada com yc_ e o ID do processo se o nome da ferramenta tiver mais de 60 caracteres).

Para mais informações sobre tags de processo, veja nossa documentação de tags de processo.

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

Ferramentas de Gerenciamento de API

As categorias de ferramentas de gerenciamento de API (yc_api e yc_api_full) fornecem acesso abrangente à API para gerenciar todos os aspectos do seu espaço de trabalho YepCode:

Ferramentas básicas de API (yc_api): A tag yc_api habilita ferramentas padrão de gerenciamento de API para operações principais em seu espaço de trabalho.

Ferramentas de API estendidas (yc_api_full): A tag yc_api_full inclui tudo de yc_api mais ferramentas adicionais para gerenciar versões de processos e módulos.

Gerenciamento de Processos:

  • get_processes - Listar processos com filtragem opcional
  • create_process - Criar novos processos com código fonte
  • get_process - Obter detalhes do processo
  • update_process - Atualizar um processo existente
  • delete_process - Excluir um processo
  • get_process_versions - Obter versões do processo (requer yc_api_full)
  • execute_process_async - Executar um processo de forma assíncrona
  • execute_process_sync - Executar um processo de forma síncrona
  • schedule_process - Agendar um processo para execução automática

Gerenciamento de Agendamentos:

  • get_schedules - Listar processos agendados
  • get_schedule - Obter detalhes do agendamento
  • pause_schedule - Pausar um processo agendado
  • resume_schedule - Retomar um agendamento pausado
  • delete_schedule - Excluir um agendamento
  • update_schedule - Atualizar um processo agendado

Gerenciamento de Variáveis:

  • get_variables - Listar variáveis da equipe
  • create_variable - Criar uma nova variável
  • update_variable - Atualizar uma variável existente
  • delete_variable - Excluir uma variável

Gerenciamento de Armazenamento:

  • get_storage_objects - Listar objetos de armazenamento
  • upload_storage_object - Fazer upload de um arquivo para o armazenamento
  • download_storage_object - Baixar um arquivo do armazenamento
  • delete_storage_object - Excluir um arquivo do armazenamento

Gerenciamento de Execuções:

  • get_executions - Listar execuções com filtragem opcional
  • get_execution - Obter detalhes da execução via API
  • kill_execution - Encerrar uma execução em andamento
  • rerun_execution - Reexecutar uma execução anterior
  • get_execution_logs - Obter logs de execução

Gerenciamento de Módulos:

  • get_modules - Listar módulos da biblioteca de scripts
  • create_module - Criar um novo módulo
  • get_module - Obter detalhes do módulo
  • delete_module - Excluir um módulo
  • get_module_versions - Obter versões do módulo (requer yc_api_full)
  • get_module_version - Obter uma versão específica do módulo (requer yc_api_full)
  • delete_module_version - Excluir uma versão do módulo (requer yc_api_full)
  • get_module_aliases - Obter aliases de versão do módulo (requer yc_api_full)

Licença

Este projeto está licenciado sob a Licença MIT - veja o arquivo LICENSE para detalhes.