NOTE: I've stopped working on this repo in favor of:

It's a much more thought out approach to code mode

Code Mode MCP Server

A local implementation of the "Code Mode" workflow for MCP servers. Instead of struggling with multiple tool calls, LLMs write TypeScript/JavaScript code that calls a simple HTTP proxy to access your MCP servers.

Note: It does not attempt to handle the MCP -> typescript API transpilation layer. Would be cool but I really wanted to test the workflow.

https://blog.cloudflare.com/code-mode/

What is this?

This implements the core insight that LLMs are much better at writing code than at tool calling. Instead of exposing many tools directly to the LLM (which it struggles with), this server gives the LLM just one tool: execute_code. The LLM writes code that makes HTTP requests to access your other MCP servers.

How it works

LLM gets one tool: execute_code - executes TypeScript/JavaScript
LLM writes code: Uses fetch() to call http://localhost:3001/mcp/* endpoints
HTTP proxy forwards: Transparently proxies requests to your actual MCP servers
Results flow back: Through the code execution to the LLM

This gives you all the benefits of complex tool orchestration, but leverages what LLMs are actually good at: writing code.

Installation

Prerequisites

Bun (latest version)
Deno (for code execution sandbox)
An MCP-compatible client (Claude Desktop, Cursor, VS Code with Copilot, etc.)

Setup

Clone the repository

git clone https://github.com/jx-codes/codemode-mcp.git
cd codemode-mcp

Install dependencies

bun install

Configure the server (optional)

Create a codemode-config.json file to customize settings:

{
   "proxyPort": 3001,
   "configDirectories": [
      "~/.config/mcp/servers",
      "./mcp-servers",
      "./"
   ]
}

Set up your MCP servers

Create a .mcp.json file with your MCP server configurations in any of the directories you specified above:

{
   "mcpServers": {
      "fs": {
         "command": "npx",
         "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
         "env": {}
      }
   }
}

Example Workflows

Single MCP Server Call

Instead of direct tool calling, the LLM writes:

// List available servers
const servers = await fetch("http://localhost:3001/mcp/servers").then((r) =>
  r.json()
);
console.log("Available servers:", servers);

// Call a tool on the filesystem server
const result = await fetch("http://localhost:3001/mcp/call", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    server: "fs",
    tool: "read_file",
    args: { path: "/tmp/example.txt" },
  }),
}).then((r) => r.json());

console.log("File contents:", result);

Chaining Multiple Operations

The real power shows when chaining operations:

// Get list of files
const files = await fetch("http://localhost:3001/mcp/call", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    server: "fs",
    tool: "list_directory",
    args: { path: "/tmp" },
  }),
}).then((r) => r.json());

// Process each file
for (const file of files.content[0].text.split("\n")) {
  if (file.endsWith(".txt")) {
    const content = await fetch("http://localhost:3001/mcp/call", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        server: "fs",
        tool: "read_file",
        args: { path: `/tmp/${file}` },
      }),
    }).then((r) => r.json());

    console.log(`${file}: ${content.content[0].text.length} characters`);
  }
}

Tools

`execute_code`

Executes TypeScript/JavaScript code with network access to the MCP proxy.

Parameters:

code (string): Code to execute
typescript (boolean): TypeScript mode (default: true)

Proxy Endpoints:

GET /mcp/servers - List available MCP servers
GET /mcp/{server}/tools - List tools for server
POST /mcp/call - Call tool (body: {server, tool, args})

`check_deno_version`

Check Deno installation status.

`list_servers_with_tools`

Get a comprehensive overview of all available MCP servers and their tools. Returns structured JSON data optimized for LLM consumption, containing complete tool schemas and server status information.

JSON Output Structure:

{
  "summary": {
    "totalServers": 2,
    "successfulServers": 2,
    "totalTools": 4
  },
  "servers": [
    {
      "server": "filesystem",
      "status": "success",
      "toolCount": 3,
      "tools": [
        {
          "name": "read_file",
          "description": "Read contents of a file",
          "inputSchema": {
            "type": "object",
            "properties": {
              "path": {
                "type": "string",
                "description": "File path to read"
              }
            },
            "required": ["path"]
          }
        }
      ]
    },
    {
      "server": "database",
      "status": "success",
      "toolCount": 1,
      "tools": [
        {
          "name": "query",
          "description": "Execute a SQL query",
          "inputSchema": {
            "type": "object",
            "properties": {
              "query": {
                "type": "string",
                "description": "SQL query to execute"
              }
            },
            "required": ["query"]
          }
        }
      ]
    }
  ]
}

This provides complete tool discovery information including parameter schemas, types, and requirements for programmatic access.

Configuration

Create codemode-config.json:

{
  "proxyPort": 3001,
  "configDirectories": ["~/.config/mcp/servers", "./mcp-servers", "./"]
}

Add your MCP servers to .mcp.json files in those directories:

{
  "mcpServers": {
    "fs": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      "env": {}
    }
  }
}

Why (Might) Work Better

Traditional MCP: LLM → Tool Call → MCP Server → Result → LLM → Tool Call → ...

LLMs struggle with tool syntax
Each call goes through the neural network
Hard to chain operations
Limited by training on synthetic tool examples

Code Mode: LLM → Write Code → Code calls proxy → Proxy forwards to MCP → Results

LLMs excel at writing code (millions of real examples in training)
Code can chain operations naturally
Results flow through code logic, not neural network
Natural composition and data processing

Security

Code runs in Deno sandbox with network access only
No filesystem, environment, or system access
30-second execution timeout
MCP servers accessed through controlled proxy
Temporary files auto-cleanup

Troubleshooting

"Deno not installed": Install Deno and restart "Permission denied": Code trying to access restricted resources "Module not found": Use https:// URLs for imports "Execution timeout": Optimize code or break into smaller operations

TODO (Maybe)

Provide a simpler API layer for the MCP proxy something like mcp.tool('name', args);
- Could easily be done by injecting our own typescript file into the Deno scope before running user code
More config options
Filter out the tools somehow
Test it out more in my workflows and see the results

Deno code remixed from: https://github.com/Timtech4u/deno-mcp-server