Merge pull request #8 from yepcode/feature/YEP-3000

YEP-3000 Improve MCP tools filter (mcp-server)

Author: agtraveso

README.md

@@ -150,36 +150,58 @@ Executes code in YepCode's secure environment.
 
 YepCode MCP server supports the following options:
 
-- Disable the run_code tool: In some cases, you may want to disable the `run_code` tool. For example, if you want to use the MCP server as a provider only for the existing tools in your YepCode account.
-- 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.
+- `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.
 
-Options can be passed as a comma-separated list in the `YEPCODE_MCP_OPTIONS` environment variable or as a query parameter in the MCP server URL.
+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 tool
+- `executions`: Enables execution management tools
+- `env_vars`: Enables environment variable management tools
+- `storage`: Enables storage management tools
+
+**Process tags:**
+- Any tag used in your YepCode processes (e.g., `mcp-tool`, `core`, `api`, `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 `run_ycp_<process_slug>` (or `run_ycp_<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.
 
 ```typescript
-// SSE server configuration
+// SSE server configuration with options
 {
   "mcpServers": {
     "yepcode-mcp-server": {
-      "url": "https://cloud.yepcode.io/mcp/sk-c2E....RD/sse?mcpOptions=disableRunCodeTool,runCodeCleanup"
+      "url": "https://cloud.yepcode.io/mcp/sk-c2E....RD/sse?mcpOptions=runCodeCleanup&tools=run_code,storage,env_vars,core,api"
     }
   }
 }
 
-// NPX configuration
+// 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": "disableRunCodeTool,runCodeCleanup"
+        "YEPCODE_MCP_OPTIONS": "runCodeCleanup",
+        "YEPCODE_MCP_TOOLS": "run_code,storage,env_vars,core,api"
       }
     }
   }
 }
 ```
 
+**Example scenarios:**
+- `YEPCODE_MCP_TOOLS=run_code,storage` - Only enables built-in code execution and storage tools
+- `YEPCODE_MCP_TOOLS=core,automation` - Only exposes processes tagged with "core" or "automation" as tools
+- `YEPCODE_MCP_TOOLS=run_code,storage,core` - Enables built-in tools plus all processes tagged with "core"
+
 ### Environment Management
 
 #### set_env_var
@@ -288,10 +310,17 @@ Deletes a file from YepCode storage.
 
 ### 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 just adding the `mcp-tool` tag to your process (see our docs to learn more about [process tags](https://yepcode.io/docs/processes/tags)).
+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:**
+1. Tag your YepCode processes with any tag (e.g., `core`, `api`, `automation`, `mcp-tool`, etc.)
+2. Add those tags to the `YEPCODE_MCP_TOOLS` environment variable
+3. All processes with the specified tags will be exposed as individual MCP tools
 
 There will be a tool for each exposed process: `run_ycp_<process_slug>` (or `run_ycp_<process_id>` if tool name is longer than 60 characters).
 
+For more information about process tags, see our [process tags documentation](https://yepcode.io/docs/processes/tags).
+
 #### run_ycp_<process_slug>
 
 ```typescript

package-lock.json

@@ -50,7 +50,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.17.0",
-    "@yepcode/run": "^1.8.0",
+    "@yepcode/run": "^1.9.0",
     "dotenv": "^16.4.7",
     "zod": "^3.24.2"
   },

package.json

@@ -8,16 +8,19 @@ import { getVersion } from "./utils.js";
 const logger = new Logger("StdioServer", { logsToStderr: true });
 
 const main = async (): Promise<void> => {
-  let disableRunCodeTool = false;
+  let tools: string[] | undefined;
   let runCodeCleanup = false;
   if (process.env.YEPCODE_MCP_OPTIONS) {
     const mcpOptions = process.env.YEPCODE_MCP_OPTIONS.split(",");
-    disableRunCodeTool = mcpOptions.includes("disableRunCodeTool");
     runCodeCleanup = mcpOptions.includes("runCodeCleanup");
   }
+  if (process.env.YEPCODE_MCP_TOOLS) {
+    tools = process.env.YEPCODE_MCP_TOOLS.split(",").map((tool) => tool.trim());
+  }
+
   const server = new YepCodeMcpServer(
     {},
-    { logsToStderr: true, disableRunCodeTool, runCodeCleanup }
+    { logsToStderr: true, tools, runCodeCleanup }
   );
   try {
     const transport = new StdioServerTransport();

src/index.ts

@@ -50,6 +50,18 @@ import {
 
 const RUN_PROCESS_TOOL_NAME_PREFIX = "run_ycp_";
 const RUN_PROCESS_TOOL_TAG = "mcp-tool";
+const RUN_CODE_TOOL_TAG = "run_code";
+const EXECUTIONS_TOOL_TAG = "executions";
+const ENV_VARS_TOOL_TAG = "env_vars";
+const STORAGE_TOOL_TAG = "storage";
+
+const DEFAULT_TOOL_TAGS = [
+  RUN_CODE_TOOL_TAG,
+  EXECUTIONS_TOOL_TAG,
+  ENV_VARS_TOOL_TAG,
+  STORAGE_TOOL_TAG,
+  RUN_PROCESS_TOOL_TAG,
+];
 
 dotenv.config();
 
@@ -58,17 +70,17 @@ class YepCodeMcpServer extends Server {
   private yepCodeEnv: YepCodeEnv;
   private yepCodeApi: YepCodeApi;
   private logger: Logger;
-  private disableRunCodeTool: boolean;
+  private tools: string[];
   private runCodeCleanup: boolean;
   constructor(
     config: YepCodeApiConfig,
     {
       logsToStderr = false,
-      disableRunCodeTool = false,
+      tools = DEFAULT_TOOL_TAGS,
       runCodeCleanup = false,
     }: {
       logsToStderr?: boolean;
-      disableRunCodeTool?: boolean;
+      tools?: string[];
       runCodeCleanup?: boolean;
     } = {}
   ) {
@@ -86,7 +98,7 @@ class YepCodeMcpServer extends Server {
       }
     );
 
-    this.disableRunCodeTool = disableRunCodeTool;
+    this.tools = tools;
     this.runCodeCleanup = runCodeCleanup;
     this.setupHandlers();
     this.setupErrorHandling();
@@ -216,48 +228,54 @@ class YepCodeMcpServer extends Server {
   private setupToolHandlers(): void {
     this.setRequestHandler(ListToolsRequestSchema, async () => {
       this.logger.info(`Handling ListTools request`);
-      const tools = [
-        ...envVarsToolDefinitions,
-        ...storageToolDefinitions,
-        ...getExecutionToolDefinitions,
-      ];
-
-      if (!this.disableRunCodeTool) {
+      const tools = [];
+      if (this.tools.includes(EXECUTIONS_TOOL_TAG)) {
+        tools.push(...getExecutionToolDefinitions);
+      }
+      if (this.tools.includes(STORAGE_TOOL_TAG)) {
+        tools.push(...storageToolDefinitions);
+      }
+      if (this.tools.includes(ENV_VARS_TOOL_TAG)) {
+        tools.push(...envVarsToolDefinitions);
+      }
+      if (this.tools.includes(RUN_CODE_TOOL_TAG)) {
         const envVars = await this.yepCodeEnv.getEnvVars();
         tools.push(...(await runCodeToolDefinitions(envVars)));
       }
 
       let page = 0;
       let limit = 100;
       while (true) {
-        const processes = await this.yepCodeApi.getProcesses({ page, limit });
+        const processes = await this.yepCodeApi.getProcesses({
+          page,
+          limit,
+          tags: this.tools,
+        });
         this.logger.info(`Found ${processes?.data?.length} processes`);
         if (!processes.data) {
           break;
         }
         tools.push(
-          ...processes.data
-            .filter((process) => process.tags?.includes(RUN_PROCESS_TOOL_TAG))
-            .map((process) => {
-              const inputSchema = zodToJsonSchema(RunProcessSchema) as any;
-              if (!isEmpty(process.parametersSchema)) {
-                inputSchema.properties.parameters = process.parametersSchema;
-              } else {
-                delete inputSchema.properties.parameters;
-              }
-              let toolName = `${RUN_PROCESS_TOOL_NAME_PREFIX}${process.slug}`;
-              if (toolName.length > 60) {
-                toolName = `${RUN_PROCESS_TOOL_NAME_PREFIX}${process.id}`;
-              }
-              return {
-                name: toolName,
-                title: process.name,
-                description: `${process.name}${
-                  process.description ? ` - ${process.description}` : ""
-                }`,
-                inputSchema,
-              };
-            })
+          ...processes.data.map((process) => {
+            const inputSchema = zodToJsonSchema(RunProcessSchema) as any;
+            if (!isEmpty(process.parametersSchema)) {
+              inputSchema.properties.parameters = process.parametersSchema;
+            } else {
+              delete inputSchema.properties.parameters;
+            }
+            let toolName = `${RUN_PROCESS_TOOL_NAME_PREFIX}${process.slug}`;
+            if (toolName.length > 60) {
+              toolName = `${RUN_PROCESS_TOOL_NAME_PREFIX}${process.id}`;
+            }
+            return {
+              name: toolName,
+              title: process.name,
+              description: `${process.name}${
+                process.description ? ` - ${process.description}` : ""
+              }`,
+              inputSchema,
+            };
+          })
         );
         if (!processes.hasNextPage) {
           break;
@@ -312,7 +330,7 @@ class YepCodeMcpServer extends Server {
 
       switch (request.params.name) {
         case runCodeToolNames.runCode:
-          if (this.disableRunCodeTool) {
+          if (!this.tools.includes(RUN_CODE_TOOL_TAG)) {
             this.logger.error("Run code tool is disabled");
             throw new McpError(
               ErrorCode.MethodNotFound,