What is YepCode MCP Server?
An MCP (Model Context Protocol) server that enables AI platforms to interact with YepCode's infrastructure. Run LLM-generated scripts and turn your YepCode processes into powerful tools that AI assistants can use directly. YepCode is the perfect environment to build a dynamic MCP tools server: expose each process as a tool (with OAuth, API tokens, or your credentials), define each tool's parameters with JSON Schema for full flexibility, and implement tools in Python or Node.js—all in one server that mixes multiple languages.
Why YepCode MCP Server?
- Seamless AI Integration: Convert YepCode processes into AI-ready tools with zero configuration
- Real-time Process Control: Enable direct interaction between AI systems and your workflows
- Enterprise-Grade Security: Execute code in YepCode's isolated, production-ready environments
- Universal Compatibility: Integrate with any AI platform supporting the Model Context Protocol
YepCode: The Perfect Environment for a Dynamic MCP Tools Server
YepCode is built to be the ideal platform for running a dynamic MCP tools server:
-
One process, one tool: Each YepCode process can be exposed as an MCP tool. Tag your processes (e.g.
mcp-tool,core,automation) and they become tools that AI assistants can invoke. You can secure access with OAuth, API tokens, or your existing YepCode credentials—each tool runs in your workspace with the same security model. -
Full control over tool parameters: Every tool can define its own parameter schema as JSON Schema. You get complete flexibility to describe inputs (types, descriptions, required fields, enums, defaults, etc.), so the AI receives rich metadata and can call your tools correctly.
-
Polyglot tool implementations: Implement tools in Python or Node.js (or both). The same MCP server can expose tools backed by different runtimes—think of it as one MCP server that mixes implementations across several languages.
For complete documentation, see the YepCode MCP Server docs.
Installation
This package lets you run the YepCode MCP server locally or in your own infrastructure (NPX, Docker, or custom deployment). Integrate it with AI platforms like Cursor or Claude Desktop.
Tip: From your YepCode account you also have access to a hosted MCP server that doesn't require local installation. The connection URL is always:
https://cloud.yepcode.io/mcp
Prerequisites
Get your YepCode API credentials:
- Sign up to YepCode Cloud
- Visit
Settings>API credentialsto create a new API token.
Using NPX
Make sure you have Node.js installed (version 18 or higher), and use a configuration similar to the following:
{
"mcpServers": {
"yepcode-mcp-server": {
"command": "npx",
"args": ["-y", "@yepcode/mcp-server"],
"env": {
"YEPCODE_API_TOKEN": "your_api_token_here"
}
}
}
}
Using Docker
- Build the container image:
docker build -t yepcode/mcp-server .
- Use a configuration similar to the following:
{
"mcpServers": {
"yepcode-mcp-server": {
"command": "docker",
"args": [
"run",
"-d",
"-e",
"YEPCODE_API_TOKEN=your_api_token_here",
"yepcode/mcp-server"
]
}
}
}
Debugging
Debugging MCP servers can be tricky since they communicate over stdio. To make this easier, we recommend using the MCP Inspector, which you can run with the following command:
npm run inspector
This will start a server where you can access debugging tools directly in your browser.
YepCode MCP Tools Reference
The MCP server provides several tools to interact with YepCode's infrastructure:
Code Execution
run_code
Executes code in 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
}
MCP Options
YepCode MCP server supports the following options:
runCodeCleanup: Skip the run_code cleanup. By default, run_code processes source code is removed after execution. If you want to keep it for audit purposes, you can use this option.skipCodingRules: Skip including coding rules in the run_code tool definition. By default, JavaScript and Python coding rules from YepCode documentation are included in the tool schema to guide AI-generated code. If you want to skip this for faster tool initialization or smaller tool definitions, you can use this option.
Options can be passed as a comma-separated list in the YEPCODE_MCP_OPTIONS environment variable.
Tool Selection
You can control which tools are enabled by setting the YEPCODE_MCP_TOOLS environment variable with a comma-separated list of tool categories and process tags:
Built-in tool categories:
run_code: Enables the code execution toolyc_api: Enables all basic API management tools (processes, schedules, variables, storage, executions, modules)yc_api_full: Enables all API management tools including version-related tools (extendsyc_apiwith additional process and module version management tools)- any specific API tool name (e.g.,
execute_process_sync,get_execution,...)
Process tags:
- Any tag used in your YepCode processes (e.g.,
mcp-tool,core,automation, etc.) - When you specify a process tag, all processes with that tag will be exposed as individual MCP tools
- Process tools will be named using the process slug (or prefixed with
yc_and the process ID if the name is longer than 60 characters)
If not specified, all built-in tools are enabled by default, but no process tools will be exposed.
// 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"
}
}
}
}
Example scenarios:
YEPCODE_MCP_TOOLS=run_code,yc_api- Enables built-in code execution and basic API management toolsYEPCODE_MCP_TOOLS=run_code,yc_api_full- Enables built-in code execution and all API management tools (including version management)YEPCODE_MCP_TOOLS=core,automation- Only exposes processes tagged with "core" or "automation" as toolsYEPCODE_MCP_TOOLS=run_code,yc_api,core- Enables built-in tools plus all processes tagged with "core"
Environment Management
set_env_var
Sets an environment variable in the 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
Removes an environment variable from the YepCode workspace.
// Input
{
key: string; // Name of the variable to remove
}
Storage Management
YepCode provides a built-in storage system that allows you to upload, list, download, and delete files. These files can be accessed from your code executions using the yepcode.storage helper methods.
list_files
Lists all files in your YepCode storage.
// 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
Uploads a file to YepCode storage.
// 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
Downloads a file from YepCode storage.
// 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
Deletes a file from YepCode storage.
// Input
{
filename: string; // File path to delete
}
// Response
{
success: boolean; // Deletion success status
filename: string; // Deleted file path
}
Process Execution
The MCP server can expose your YepCode Processes as individual MCP tools, making them directly accessible to AI assistants. This feature is enabled by specifying process tags in the YEPCODE_MCP_TOOLS environment variable.
How it works:
- Tag your YepCode processes with any tag (e.g.,
core,api,automation,mcp-tool, etc.) - Add those tags to the
YEPCODE_MCP_TOOLSenvironment variable - All processes with the specified tags will be exposed as individual MCP tools
There will be a tool for each exposed process named using the process slug (or prefixed with yc_ and the process ID if the tool name is longer than 60 characters).
For more information about process tags, see our process tags documentation.
<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 Management Tools
The API management tool categories (yc_api and yc_api_full) provide comprehensive API access to manage all aspects of your YepCode workspace:
Basic API tools (yc_api):
The yc_api tag enables standard API management tools for core operations across your workspace.
Extended API tools (yc_api_full):
The yc_api_full tag includes everything from yc_api plus additional tools for managing process and module versions.
Processes Management:
get_processes- List processes with optional filteringcreate_process- Create new processes with source codeget_process- Get process detailsupdate_process- Update an existing processdelete_process- Delete a processget_process_versions- Get process versions (requiresyc_api_full)execute_process_async- Execute a process asynchronouslyexecute_process_sync- Execute a process synchronouslyschedule_process- Schedule a process to run automatically
Schedules Management:
get_schedules- List scheduled processesget_schedule- Get schedule detailspause_schedule- Pause a scheduled processresume_schedule- Resume a paused scheduledelete_schedule- Delete a scheduleupdate_schedule- Update a scheduled process
Variables Management:
get_variables- List team variablescreate_variable- Create a new variableupdate_variable- Update an existing variabledelete_variable- Delete a variable
Storage Management:
get_storage_objects- List storage objectsupload_storage_object- Upload a file to storagedownload_storage_object- Download a file from storagedelete_storage_object- Delete a file from storage
Executions Management:
get_executions- List executions with optional filteringget_execution- Get execution details from APIkill_execution- Kill a running executionrerun_execution- Rerun a previous executionget_execution_logs- Get execution logs
Modules Management:
get_modules- List script library modulescreate_module- Create a new moduleget_module- Get module detailsdelete_module- Delete a moduleget_module_versions- Get module versions (requiresyc_api_full)get_module_version- Get a specific module version (requiresyc_api_full)delete_module_version- Delete a module version (requiresyc_api_full)get_module_aliases- Get module version aliases (requiresyc_api_full)
License
This project is licensed under the MIT License - see the LICENSE file for details.
