Skip to main content
Glama

Code Mode MCP Server

by jx-codes
GitHub
JavaScript
6
OverviewInspectNewEndpointsSchemaRelated ServersReviewsScore
Need Help?View Source CodeReport Issue

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

  1. LLM gets one tool: execute_code - executes TypeScript/JavaScript

  2. LLM writes code: Uses fetch() to call http://localhost:3001/mcp/* endpoints

  3. HTTP proxy forwards: Transparently proxies requests to your actual MCP servers

  4. 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

  1. Clone the repository

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

  1. Install dependencies

bun install

  1. Configure the server (optional)

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

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

  1. 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

This server cannot be installed

-
security - not tested
F
license - not found
-
quality - not tested

How are these scores calculated?

local-only server

The server can only run on the client's local machine because it depends on local resources.

Enables LLMs to interact with MCP servers by writing TypeScript/JavaScript code instead of direct tool calls. Provides a code execution sandbox that accesses MCP servers through HTTP proxy endpoints.

  1. What is this?
    1. How it works
      1. Installation
        1. Prerequisites
        2. Setup
      2. Example Workflows
        1. Single MCP Server Call
        2. Chaining Multiple Operations
      3. Tools
        1. execute_code
        2. check_deno_version
        3. list_servers_with_tools
      4. Configuration
        1. Why (Might) Work Better
          1. Security
            1. Troubleshooting
              1. TODO (Maybe)
                1. Deno code remixed from: https://github.com/Timtech4u/deno-mcp-server

                  New MCP Servers

                  MCP directory API

                  We provide all the information about MCP servers via our MCP API.

                  curl -X GET 'https://glama.ai/api/mcp/v1/servers/jx-codes/codemode-mcp'

                  If you have feedback or need assistance with the MCP directory API, please join our Discord server