Unleash AI Power: YepCode MCP Server - Bridging LLMs and Real-World Workflows

Empower your AI applications with seamless access to external data and tools using the YepCode MCP Server, a robust implementation of the Model Context Protocol (MCP). Transform your YepCode processes into AI-ready tools, enabling intelligent automation and real-time interaction between AI systems and your workflows.

Why Choose YepCode MCP Server?

• Effortless AI Integration: Instantly convert your YepCode processes into powerful tools accessible to AI agents, requiring minimal configuration.
• Real-Time Workflow Control: Enable direct, dynamic interaction between AI systems and your YepCode workflows, unlocking new possibilities for intelligent automation.
• Enterprise-Grade Security: Leverage YepCode's secure, isolated execution environments to run code with confidence.
• Universal Compatibility: Integrate seamlessly with any AI platform that supports the Model Context Protocol, ensuring flexibility and future-proof compatibility.

Integration Made Easy

Integrate the YepCode MCP server with leading AI platforms like Cursor and Claude Desktop using either a remote or local approach.

Remote Integration (Hosted MCP Server)

1. Sign up: Create an account on YepCode Cloud.
2. Retrieve MCP Server URL: Navigate to Settings > API credentials within your workspace to obtain your unique MCP Server URL.
3. Configure AI Platform: Add the following configuration to your AI platform's settings, replacing the URL with your own:

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

Local Integration (NPX or Docker)

Prerequisites: Environment Variables

• YEPCODE_API_TOKEN: Your YepCode API token. Obtain this from Settings > API credentials in your YepCode Cloud workspace.

Option 1: Using NPX

Add the following configuration to your AI platform settings, replacing "your_api_token_here" with your actual API token:

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

Option 2: Using Docker

1. Build the Docker Image:

docker build -t yepcode/mcp-server .

2. Configure AI Platform: Add the following configuration to your AI platform settings, replacing "your_api_token_here" with your actual API token:

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

Streamlined Debugging with MCP Inspector

Debugging MCP servers can be challenging due to their communication over stdio. Simplify the process with the MCP Inspector:

npm run inspector

This command launches a server providing browser-based debugging tools for efficient troubleshooting.

YepCode MCP Tools: A Comprehensive Reference

The MCP server offers a suite of tools for interacting with YepCode's infrastructure:

Code Execution: run_code

Execute code snippets within YepCode's secure environment.

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

Environment Management: set_env_var and remove_env_var

Manage environment variables within your YepCode workspace.

set_env_var

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

remove_env_var

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

Process Execution: run_ycp_<process_slug> and get_execution

Expose your YepCode Processes as individual MCP tools by adding the mcp-tool tag (refer to the process tags documentation for details).

run_ycp_<process_slug>

Execute a specific YepCode process.

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

get_execution

Retrieve the result of a process execution.

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