What is Codemode and how does it work?

Codemode is a developer tool that enables Large Language Models (LLMs) to interact with Model Context Protocol (MCP) servers. It works by having the LLM write TypeScript/JavaScript code, which then calls a local HTTP proxy to access and orchestrate various MCP servers.

How does Codemode improve LLM interaction with external tools?

Instead of struggling with complex tool calling syntax, Codemode leverages LLMs' strength in writing code. It provides the LLM with a single `execute_code` tool, allowing it to write programmatic logic for advanced tool chaining, data processing, and natural composition of operations with MCP servers.

What are the security measures for code execution in Codemode?

Codemode runs LLM-generated code in a secure Deno sandbox. This environment has network-only access (specifically to the MCP proxy), no filesystem, environment, or system access, and includes a 30-second execution timeout, ensuring secure and controlled operations.

Can Codemode handle complex tool orchestration and chaining?

Absolutely. Codemode's core advantage is enabling complex tool orchestration and chaining. By writing code, LLMs can naturally compose multiple operations, process data between tool calls, and implement sophisticated logic that is challenging with traditional direct tool calling.

What are the prerequisites for setting up Codemode?

To get started with Codemode, you will need Bun (latest version) for dependency management, Deno for the secure code execution sandbox, and an MCP-compatible client such as Claude Desktop, Cursor, or VS Code with Copilot for interacting with the tool.

Key Features

01Executes LLM-generated TypeScript/JavaScript code in a Deno sandbox

02Provides a local HTTP proxy for unified MCP server access

03Enables complex tool orchestration and chaining via programmatic logic

04Offers comprehensive tool discovery with detailed schema information

05Ensures secure code execution with network-only access and timeouts

0632 GitHub stars

Use Cases

01Allowing LLMs to perform multi-step operations on MCP servers by writing sequential code

02Facilitating dynamic data processing and conditional logic based on MCP server outputs within an LLM workflow

03Providing a simplified, code-centric interface for LLMs to manage and interact with various MCP-compatible services

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

Key Features

01Executes LLM-generated TypeScript/JavaScript code in a Deno sandbox

02Provides a local HTTP proxy for unified MCP server access

03Enables complex tool orchestration and chaining via programmatic logic

04Offers comprehensive tool discovery with detailed schema information

05Ensures secure code execution with network-only access and timeouts

0632 GitHub stars

Use Cases

01Allowing LLMs to perform multi-step operations on MCP servers by writing sequential code

02Facilitating dynamic data processing and conditional logic based on MCP server outputs within an LLM workflow

03Providing a simplified, code-centric interface for LLMs to manage and interact with various MCP-compatible services

// 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);

// 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`); } }

{ "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"] } } ] } ] }