mcpcodeserver MCP Server

resmi

Alih-alih memanggil alat MCP secara langsung, server mcpcodeserver mengubah panggilan alat MCP menjadi program TypeScript, memungkinkan orkestrasi yang lebih cerdas dan latensi lebih rendah oleh LLM.

GitHub
13

Dokumentasi

mcpcodeserver

NPM Version MIT licensed Install MCP Server Install in VS Code (npx)

Server proxy Model Context Protocol (MCP) yang menerjemahkan panggilan alat menjadi pembuatan kode TypeScript. Alih-alih melakukan banyak panggilan alat bolak-balik, LLM dapat menulis kode TypeScript yang memanggil banyak alat secara alami, mengurangi overhead token dan memanfaatkan kemampuan pembuatan kode LLM yang unggul.

❌ Tanpa mcpcodeserver

LLM melakukan banyak panggilan alat berurutan, menghabiskan token dan kesulitan dengan alur kerja yang kompleks:

  • ❌ Banyak perjalanan bolak-balik antara LLM dan alat
  • ❌ Urutan panggilan alat yang kompleks rentan kesalahan
  • ❌ Data tidak dapat dengan mudah diteruskan antar alat
  • ❌ Penanganan kesalahan dan alur kontrol terbatas

✅ Dengan mcpcodeserver

LLM menulis kode TypeScript yang memanggil banyak alat secara alami:

  • ✅ Tulis kode untuk memanggil banyak alat secara berurutan
  • ✅ Gunakan variabel, perulangan, dan kondisional secara alami
  • ✅ Penanganan kesalahan yang lebih baik dengan try/catch
  • ✅ Kurangi penggunaan token dengan menggabungkan operasi
  • ✅ Manfaatkan kemampuan pembuatan kode LLM yang kuat

Mulai Cepat

  1. Instal mcpcodeserver di klien MCP Anda (lihat bagian instalasi di bawah)
  2. Buat file konfigurasi mcp.json dengan server MCP anak Anda
  3. Mulai gunakan - LLM Anda sekarang dapat membuat dan mengeksekusi kode TypeScript yang memanggil alat Anda
// Instead of multiple tool calls, write code like this:
const files = await filesystem.list_directory({ path: "/tmp" });
const results = await Promise.all(
  files.map(file => filesystem.read_file({ path: file.path }))
);
return results.filter(content => content.includes("important"));

Gambaran Umum

mcpcodeserver adalah server MCP unik yang:

  • Bertindak sebagai klien MCP untuk terhubung ke satu atau lebih server MCP anak
  • Menemukan semua alat dari server anak
  • Mengekspos tiga alat canggih ke klien LLM induk:
    1. list_servers - Mencantumkan semua sub-server yang tersedia yang terhubung ke server MCP ini
    2. get_tool_definitions - Mengembalikan definisi tipe TypeScript untuk alat yang ditemukan (opsional difilter berdasarkan server)
    3. generate_and_execute_code - Membuat dan mengeksekusi kode TypeScript yang memanggil alat tersebut dalam sandbox

Arsitektur ini memungkinkan LLM mengatur alur kerja multi-alat yang kompleks dengan menulis kode alih-alih melakukan panggilan alat berurutan, yang seringkali lebih efisien dan alami untuk model bahasa modern.

Karya Terkait & Penelitian

Pendekatan ini terinspirasi oleh penelitian terbaru yang menunjukkan bahwa LLM berkinerja lebih baik saat menghasilkan kode yang dapat dieksekusi daripada melakukan panggilan alat langsung:

  • CodeAct: Your LLM Agent Acts Better when Generating Code (Apple, ICML 2024) - Menunjukkan bahwa agen LLM mencapai tingkat keberhasilan hingga 20% lebih tinggi saat menggunakan kode Python yang dapat dieksekusi sebagai ruang aksi terpadu alih-alih format panggilan alat yang telah ditentukan sebelumnya.

  • Cloudflare Code Mode - Implementasi serupa yang mengonversi alat MCP menjadi API TypeScript, menunjukkan bahwa "LLM lebih baik dalam menulis kode untuk memanggil MCP, daripada memanggil MCP secara langsung."

Wawasan kunci dari penelitian ini adalah bahwa LLM memiliki pelatihan ekstensif pada kode dunia nyata tetapi paparan terbatas pada format panggilan alat sintetis, menjadikan pembuatan kode sebagai pendekatan yang lebih alami dan efektif untuk alur kerja agen yang kompleks.

Mengapa Menggunakan Ini?

Masalah Panggilan Alat Tradisional

  • Banyak perjalanan bolak-balik antara LLM dan alat menghabiskan token
  • LLM sering kesulitan dengan urutan panggilan alat yang kompleks
  • Setiap panggilan alat memerlukan pemahaman dan pemformatan skema JSON
  • Data tidak dapat dengan mudah diteruskan antar alat tanpa melalui LLM

Solusi Pembuatan Kode

  • Tulis kode TypeScript untuk memanggil banyak alat secara berurutan
  • Gunakan variabel, perulangan, dan kondisional secara alami
  • Penanganan kesalahan yang lebih baik dengan try/catch
  • Kurangi penggunaan token dengan menggabungkan operasi
  • Manfaatkan kemampuan pembuatan kode LLM yang kuat

Penemuan Alat Dinamis

mcpcodeserver secara otomatis memantau server MCP anak untuk perubahan alat dan memberi tahu klien induk saat alat ditambahkan, dihapus, atau dimodifikasi:

  • Penyegaran Otomatis: Memeriksa perubahan alat setiap 30 detik
  • Notifikasi Waktu Nyata: Mengirim notifications/tools/list_changed ke klien induk
  • Pembaruan Dinamis: Definisi alat dan ringkasan diperbarui secara otomatis
  • Tanpa Penyegaran Manual: LLM induk menerima notifikasi untuk menyegarkan pengetahuan alat mereka

Ini memastikan bahwa LLM induk selalu memiliki definisi alat terkini tanpa memerlukan intervensi manual.

Pemfilteran Server

Untuk mengurangi penggunaan jendela konteks dan meningkatkan fokus, mcpcodeserver mendukung pemfilteran definisi alat berdasarkan server tertentu:

  • Daftar Server yang Tersedia: Gunakan list_servers untuk melihat semua sub-server yang terhubung
  • Definisi Alat Terfilter: Gunakan get_tool_definitions dengan parameter server_names untuk mendapatkan alat hanya dari server tertentu
  • Verbosity Berkurang: Dapatkan definisi TypeScript yang terfokus tanpa membanjiri jendela konteks LLM
  • Penamaan Metode: Semua fungsi yang dihasilkan diawali dengan nama server (mis., pizzashop_create_pizza, filesystem_read_file)

Contoh penggunaan:

// List available servers
const servers = await list_servers({});
// Returns: ["pizzashop", "filesystem", "memory"]

// Get all tool definitions
const allTools = await get_tool_definitions({});

// Get only pizzashop tools
const pizzashopTools = await get_tool_definitions({
  server_names: ["pizzashop"]
});

Fitur MCP Lanjutan

mcpcodeserver mendukung penerusan fitur protokol MCP lanjutan ketika server induk dan anak mendukungnya:

  • Elicitation: Server anak dapat meminta masukan pengguna selama eksekusi alat, yang diteruskan ke klien induk
  • Roots: Mencantumkan dan menggabungkan roots dari semua server anak, menyediakan tampilan terpadu sumber daya yang tersedia
  • Sampling: Memungkinkan permintaan sampling LLM diteruskan ke server anak untuk kemampuan AI lanjutan

Fitur-fitur ini secara otomatis diiklankan ke klien induk dan bekerja dengan mulus ketika didukung oleh server MCP anak yang mendasarinya.

Mulai Cepat

Coba segera dengan npx (tanpa instalasi):

# From GitHub
npx github:zbowling/mcpcodeserver --help

# Or when published to npm
npx mcpcodeserver --help

🛠️ Instalasi

Persyaratan

  • Node.js >= v18.0.0
  • Cursor, Claude Code, VSCode, Windsurf atau klien MCP lainnya

Menginstal melalui Smithery

Untuk menginstal mcpcodeserver untuk klien apa pun secara otomatis melalui Smithery:

npx -y @smithery/cli@latest install mcpcodeserver --client <client-name> --key <smithery-key>

Instal di Cursor

Buka: Settings -> Cursor Settings -> MCP -> Add new global MCP server

Menempelkan konfigurasi berikut ke dalam file ~/.cursor/mcp.json Cursor Anda adalah pendekatan yang disarankan. Anda juga dapat menginstal di proyek tertentu dengan membuat .cursor/mcp.json di folder proyek Anda.

Instalasi Satu-Klik Cursor

Install MCP Server

Koneksi Server Lokal Cursor

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Koneksi Server Jarak Jauh Cursor (jika Anda mengatur transport HTTP)

{
  "mcpServers": {
    "mcpcodeserver": {
      "url": "http://localhost:3000/mcp"
    }
  }
}

Instal di Claude Code

Jalankan perintah ini. Lihat dokumen Claude Code MCP untuk info lebih lanjut.

Koneksi Server Lokal Claude Code

claude mcp add mcpcodeserver -- npx -y mcpcodeserver --config /path/to/your/mcp.json

Koneksi Server Jarak Jauh Claude Code

claude mcp add --transport http mcpcodeserver http://localhost:3000/mcp

Instal di VSCode

Instalasi Satu-Klik VSCode

Install in VS Code (npx)

Konfigurasi Manual VSCode

Tambahkan ke pengaturan MCP VSCode Anda:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Instal di Windsurf

Instalasi Satu-Klik Windsurf

Install in Windsurf

Instal di Asisten Pengkodean AI

Untuk Continue, Cline, dan RooCode, tambahkan ke konfigurasi Anda:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Instal di Amp

Jalankan perintah ini di terminal Anda. Lihat dokumen Amp MCP untuk info lebih lanjut.

amp mcp add mcpcodeserver -- npx -y mcpcodeserver --config /path/to/your/mcp.json

Instal di Editor Teks

Untuk Aider, Codium, Zed, Nova, dan Sublime Text, tambahkan ke konfigurasi Anda:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Instal di Neovim

Tambahkan ke konfigurasi MCP Neovim Anda:

{
  mcpServers = {
    mcpcodeserver = {
      command = "npx",
      args = {"-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"}
    }
  }
}

Instal di Emacs

Tambahkan ke konfigurasi MCP Emacs Anda:

(setq mcp-servers
      '((mcpcodeserver
         :command "npx"
         :args ("-y" "mcpcodeserver" "--config" "/path/to/your/mcp.json"))))

Instal di IDE JetBrains

Untuk IntelliJ IDEA, WebStorm, PyCharm, dan Android Studio, tambahkan ke pengaturan MCP Anda:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Instal di Alat AI

Untuk Codeium, Tabnine, GitHub Copilot, dan Amazon CodeWhisperer, tambahkan ke pengaturan MCP Anda:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Instal di IDE Cloud

Untuk Replit, CodeSandbox, StackBlitz, GitPod, GitHub Codespaces, GitLab Web IDE, dan Bitbucket Cloud, tambahkan ke pengaturan MCP Anda:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Instal di Alat Lainnya

Untuk Xcode, Fleet, Sourcegraph, dan JetBrains Gateway, tambahkan ke konfigurasi MCP Anda:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Instal di Pengembangan Jarak Jauh

Untuk lingkungan pengembangan jarak jauh, Anda juga dapat menggunakan transport HTTP:

{
  "mcpServers": {
    "mcpcodeserver": {
      "url": "http://your-server:3000/mcp"
    }
  }
}

File Konfigurasi

Buat file konfigurasi mcp.json untuk mendefinisikan server MCP anak Anda:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      "env": { "DEBUG": "false" }
    },
    "memory": {
      "command": "npx", 
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": { "BRAVE_API_KEY": "your-api-key" }
    }
  }
}

Instalasi untuk Pengembangan

# Install dependencies (using Bun for faster performance)
bun install

# Or with npm
npm install

# Build the project
bun run build

# Test the built server
bun dist/index.js --help

Catatan: Proyek ini menggunakan Bun untuk kinerja yang lebih baik, tetapi npm/node juga berfungsi dengan baik.

🚨 Pemecahan Masalah

Kesalahan Module Not Found

Jika Anda mengalami ERR_MODULE_NOT_FOUND, coba gunakan bunx alih-alih npx:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "bunx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Masalah Resolusi ESM

Untuk kesalahan seperti Error: Cannot find module, coba flag --experimental-vm-modules:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "--node-options=--experimental-vm-modules", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Masalah TLS/Sertifikat

Gunakan flag --experimental-fetch untuk melewati masalah terkait TLS:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "--node-options=--experimental-fetch", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Kesalahan Umum Klien MCP

  1. Coba tambahkan @latest ke nama paket
  2. Gunakan bunx sebagai alternatif untuk npx
  3. Pertimbangkan menggunakan deno sebagai alternatif lain
  4. Pastikan Anda menggunakan Node.js v18 atau lebih tinggi untuk dukungan fetch asli

Masalah Konfigurasi

  • Pastikan file mcp.json Anda adalah JSON yang valid
  • Periksa apakah semua perintah server anak tersedia di PATH Anda
  • Verifikasi bahwa server anak dapat dimulai secara independen
  • Periksa izin file untuk jalur file konfigurasi

Pengujian dengan MCP Inspector

npx -y @modelcontextprotocol/inspector npx mcpcodeserver --config /path/to/your/mcp.json

💻 Pengembangan

Argumen CLI

mcpcodeserver menerima flag CLI berikut:

  • --config <path> – Jalur ke file konfigurasi MCP (default: ./mcp.json)
  • --transport <stdio|http> – Transport yang digunakan (stdio secara default). Perhatikan bahwa transport HTTP secara otomatis menyediakan endpoint HTTP dan SSE
  • --port <number> – Port yang akan didengarkan saat menggunakan transport http (default 3000)
  • --help – Tampilkan pesan bantuan

Contoh dengan transport HTTP dan port 8080:

npx mcpcodeserver --config /path/to/mcp.json --transport http --port 8080

Contoh dengan transport stdio:

npx mcpcodeserver --config /path/to/mcp.json --transport stdio

Variabel Lingkungan

Anda dapat menggunakan variabel lingkungan untuk konfigurasi:

  • MCP_CONFIG_PATH – Jalur ke file konfigurasi MCP (alternatif untuk --config)
  • MCP_TRANSPORT – Tipe transport (alternatif untuk --transport)
  • MCP_PORT – Nomor port untuk transport HTTP (alternatif untuk --port)

Contoh dengan variabel lingkungan:

# .env
MCP_CONFIG_PATH=/path/to/your/mcp.json
MCP_TRANSPORT=stdio

Contoh konfigurasi MCP menggunakan variabel lingkungan:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver"],
      "env": {
        "MCP_CONFIG_PATH": "/path/to/your/mcp.json"
      }
    }
  }
}

Catatan: Flag CLI lebih diutamakan daripada variabel lingkungan ketika keduanya disediakan.

Konfigurasi Pengembangan Lokal

Untuk pengembangan lokal, Anda dapat menjalankan sumber TypeScript secara langsung:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcpcodeserver/src/index.ts", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Mode Berjalan

Mode Stdio (Default)

Server berjalan dalam mode stdio secara default, yang sempurna untuk integrasi dengan klien MCP seperti Claude Desktop:

# Run in stdio mode
npx mcpcodeserver --config mcp.json

# Or with custom config path
npx mcpcodeserver --config /path/to/your/mcp.json

Mode HTTP

Untuk debugging, pengujian, atau integrasi dengan klien MCP berbasis web, Anda dapat menjalankan server dalam mode HTTP:

# Run in HTTP mode on default port 3000
npx mcpcodeserver --http --config mcp.json

# Run on custom port and host
npx mcpcodeserver --http --port 8080 --host 0.0.0.0 --config mcp.json

Saat berjalan dalam mode HTTP, server akan tersedia di:

  • URL Server: http://localhost:3000/mcp (atau host:port kustom Anda)
  • MCP Inspector: Gunakan npx @modelcontextprotocol/inspector http://localhost:3000/mcp untuk debug dan pengujian

Integrasi MCP Inspector

MCP Inspector adalah alat yang kuat untuk debugging dan pengujian server MCP. Saat berjalan dalam mode HTTP, Anda dapat menggunakannya untuk:

  • Memeriksa alat yang tersedia dan skemanya
  • Menguji panggilan alat secara interaktif
  • Debug akses sumber daya dan prompt
  • Memantau notifikasi waktu nyata
# Start the server in HTTP mode
npx mcpcodeserver --http --config mcp.json

# In another terminal, start the MCP Inspector
npx @modelcontextprotocol/inspector http://localhost:3000/mcp

# Or use the shorthand script (includes all example servers)
npm run inspector

Inspektor akan terbuka di browser Anda dan menyediakan antarmuka lengkap untuk menjelajahi dan menguji server MCP Anda.

Catatan: Perintah npm run inspector menggunakan mcp-test.json yang mencakup 8 server MCP (total 67 alat) dari contoh resmi, termasuk server berbasis TypeScript (npx) dan Python (uvx).

Konfigurasi

Buat file mcp.json yang mendefinisikan server MCP anak mana yang akan dihubungkan. Ini mengikuti format konfigurasi klien MCP standar:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      "env": {
        "DEBUG": "false"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    },
    "weather": {
      "url": "http://localhost:3000/mcp",
      "transport": "sse"
    }
  }
}

Opsi Konfigurasi

Setiap entri server mendukung:

Untuk transport stdio:

  • command (wajib) - Perintah yang akan dieksekusi (mis., "node", "python", "npx")
  • args (opsional) - Array argumen untuk diteruskan ke perintah
  • env (opsional) - Variabel lingkungan untuk proses anak

Untuk transport HTTP/SSE:

  • url (wajib) - URL endpoint HTTP
  • transport - Atur ke "sse" untuk Server-Sent Events

Penggunaan

Memulai Server

# Use default config (./mcp.json)
mcpcodeserver

# Use custom config location
mcpcodeserver --config /path/to/custom-mcp.json

# Show help
mcpcodeserver --help

Menggunakan sebagai Server MCP

Konfigurasikan mcpcodeserver di klien MCP Anda (seperti Claude Desktop, Claude Code, Cline, dll.):

Dengan npx (disarankan - tidak perlu instalasi):

{
  "mcpServers": {
    "codeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/mcp.json"]
    }
  }
}

Dari GitHub (langsung berfungsi):

{
  "mcpServers": {
    "codeserver": {
      "command": "npx",
      "args": ["-y", "github:zbowling/mcpcodeserver", "--config", "/path/to/mcp.json"]
    }
  }
}

Dengan manajer paket lainnya:

// yarn
{ "command": "yarn", "args": ["dlx", "mcpcodeserver", "--config", "/path/to/mcp.json"] }

// pnpm
{ "command": "pnpm", "args": ["dlx", "mcpcodeserver", "--config", "/path/to/mcp.json"] }

// bun
{ "command": "bunx", "args": ["mcpcodeserver", "--config", "/path/to/mcp.json"] }

Lihat examples/ untuk lebih banyak contoh konfigurasi dan pengaturan khusus klien MCP.

Alat 1: get_tool_definitions

Alat ini mengembalikan definisi tipe TypeScript untuk semua alat yang ditemukan dari server anak.

Masukan:

  • include_examples (boolean opsional) - Apakah akan menyertakan contoh penggunaan

Contoh:

// Call the tool (in your MCP client)
get_tool_definitions({ include_examples: true })

Keluaran: Mengembalikan kode TypeScript dengan antarmuka dan deklarasi fungsi:

/**
 * Auto-generated TypeScript definitions for MCP tools
 */

interface ToolResult {
  content: Array<{
    type: string;
    text?: string;
    // ...
  }>;
  isError?: boolean;
}

/**
 * Read contents of a file
 * Server: filesystem
 * Tool: read_file
 */
interface ReadFileParams {
  path: string;
}

declare function filesystem_read_file(params: ReadFileParams): Promise<ToolResult>;

// ... more tool definitions

Alat 2: generate_and_execute_code

Alat ini mengeksekusi kode TypeScript dalam sandbox dengan akses ke semua fungsi alat yang ditemukan.

Masukan:

  • code (string wajib) - Kode TypeScript/JavaScript yang akan dieksekusi
  • timeout (angka opsional) - Waktu eksekusi maksimum dalam milidetik (default: 30000, maks: 300000)

Contoh:

// Call the tool with TypeScript code
generate_and_execute_code({
  code: `
    // Read multiple files and combine them
    const file1 = await filesystem_read_file({ path: "/tmp/file1.txt" });
    const file2 = await filesystem_read_file({ path: "/tmp/file2.txt" });

    const text1 = file1.content[0].text;
    const text2 = file2.content[0].text;

    console.log("File 1 length:", text1.length);
    console.log("File 2 length:", text2.length);

    return {
      combined: text1 + text2,
      totalLength: text1.length + text2.length
    };
  `
})

Keluaran:

=== Console Output ===
File 1 length: 42
File 2 length: 38

=== Result ===
{
  "combined": "...",
  "totalLength": 80
}

Lingkungan Sandbox

Sandbox eksekusi TypeScript menyediakan:

Tersedia:

  • Semua fungsi alat yang ditemukan (sebagai fungsi async)
  • Metode konsol: console.log(), console.error(), console.warn(), console.info()
  • Global JavaScript dasar: Math, JSON, Date, Array, Object, String, Number, Boolean
  • Dukungan Promise dan async/await
  • Penanganan kesalahan dengan try/catch
  • Timer: setTimeout, setInterval, clearTimeout, clearInterval

Tidak Tersedia:

  • Modul Node.js (fs, http, child_process, dll.)
  • Akses sistem file (kecuali melalui alat MCP)
  • Akses jaringan (kecuali melalui alat MCP)
  • Informasi proses

Catatan Keamanan: Ini bukan sandbox yang sepenuhnya aman. Konteks VM menyediakan isolasi tetapi tidak sepenuhnya kebal. Hanya eksekusi kode tepercaya.

Penanganan Kesalahan

Kesalahan di sandbox ditangkap dan dikembalikan dengan stack trace:

generate_and_execute_code({
  code: `
    try {
      const result = await filesystem_read_file({ path: "/nonexistent" });
      return result;
    } catch (error) {
      console.error("Failed to read file:", error.message);
      throw error; // Re-throw to surface to parent
    }
  `
})

Pengujian dengan Claude Code

Ingin mencoba mcpcodeserver dengan Claude Code? Gunakan pengaturan satu perintah:

./setup-claude-code-test.sh

Ini akan membangun proyek, menginstal dependensi pengujian, dan menunjukkan dengan tepat apa yang harus ditambahkan ke konfigurasi Claude Code Anda. Lihat TESTING_WITH_CLAUDE.md untuk instruksi terperinci.

Pengembangan

# Install dependencies
bun install

# Build the project
bun run build

# Watch mode for development
bun run dev

# Run the server
bun start

# Run tests
bun test                # All tests
bun run test:unit       # Unit tests only
bun run test:integration # Integration tests (requires Python)

# Code quality
bun run lint            # Check linting
bun run format          # Format code
bun run typecheck       # Type checking

Struktur Proyek

Lihat AGENTS.md untuk struktur proyek terperinci dan dokumentasi komponen.

Kasus Penggunaan

Operasi Multi-File

Alih-alih membuat banyak panggilan alat melalui LLM, tulis kode:

const files = ["/tmp/a.txt", "/tmp/b.txt", "/tmp/c.txt"];
const contents = await Promise.all(
  files.map(path => filesystem_read_file({ path }))
);
return contents.map(r => r.content[0].text);

Transformasi Data

Proses data antar panggilan alat tanpa intervensi LLM:

const data = await api_fetch({ url: "https://api.example.com/data" });
const json = JSON.parse(data.content[0].text);
const filtered = json.items.filter(item => item.active);
return filtered.length;

Logika Kondisional

Buat keputusan berdasarkan hasil alat:

const exists = await filesystem_read_file({ path: "/tmp/config.json" });
if (exists.isError) {
  console.log("Config doesn't exist, using defaults");
  return { source: "defaults" };
} else {
  return { source: "file", config: JSON.parse(exists.content[0].text) };
}

Pemulihan Kesalahan

Tangani kesalahan dengan baik tanpa membatalkan seluruh alur kerja:

const results = [];
for (const path of ["/tmp/a.txt", "/tmp/b.txt", "/tmp/c.txt"]) {
  try {
    const content = await filesystem_read_file({ path });
    results.push({ path, success: true, data: content });
  } catch (error) {
    results.push({ path, success: false, error: error.message });
  }
}
return results;

Integrasi Server MCP Hulu

mcpcodeserver dapat berintegrasi dengan server MCP hulu resmi dari repositori server Model Context Protocol. Ini memungkinkan Anda menggunakan server MCP nyata yang siap produksi bersama alat kustom Anda.

Server Hulu yang Didukung

  • filesystem: Operasi sistem file (baca, tulis, daftar direktori)
  • memory: Penyimpanan kunci-nilai dalam memori
  • sqlite: Operasi basis data SQLite
  • github: Integrasi API GitHub
  • brave-search: Kemampuan pencarian web
  • fetch: Kemampuan permintaan HTTP

Contoh Konfigurasi

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "/tmp/test.db"]
    }
  }
}

Pengujian Integrasi Hulu

Proyek ini mencakup pengujian komprehensif untuk integrasi server hulu:

# Run upstream servers integration tests
bun tests/integration/run-upstream-tests.ts

# Or manually test with upstream config
npx mcpcodeserver --config tests/integration/upstream-test-config.json

Alur Kerja Lintas Server

Dengan server hulu, Anda dapat membuat alur kerja lintas server yang kuat:

// Store database query results in memory and write to file
const queryResult = await sqlite_execute_sql({
  sql: "SELECT COUNT(*) as count FROM users"
});
const count = queryResult.content[0].text;

await memory_create({
  key: "user-count",
  value: count
});

await filesystem_write_file({
  path: "/tmp/user-count.txt",
  content: `Total users: ${count}`
});

Keterbatasan

  • Batas waktu eksekusi: Maksimum 5 menit (dapat dikonfigurasi, default 30 detik)
  • Memori: Dibatasi oleh konteks VM Node.js
  • Tidak ada status persisten antara eksekusi
  • Tidak dapat me-require/mengimpor modul eksternal
  • Bukan sandbox keamanan - jangan jalankan kode yang tidak tepercaya

Berkontribusi

Kontribusi diterima! Proyek ini dibangun dengan:

  • TypeScript 5.7+
  • Node.js 18+
  • MCP TypeScript SDK 1.20+
  • Zod untuk validasi

Lihat CONTRIBUTING.md untuk panduan kontribusi terperinci.

Dukungan

Jika Anda merasa proyek ini membantu, pertimbangkan untuk membelikan saya kopi!

Buy Me A Coffee

Lisensi

MIT

Sumber Daya