mcpcodeserver

ทางการ

แทนที่จะเรียกใช้เครื่องมือ MCP โดยตรง mcpcodeserver จะแปลงการเรียกใช้เครื่องมือ MCP เป็นโปรแกรม TypeScript ช่วยให้ LLM สามารถจัดลำดับการทำงานได้อย่างชาญฉลาดและมีความหน่วงต่ำลง

GitHub
13

คุณทำอะไรได้บ้างด้วย Mcpcodeserver MCP?

  • List connected child servers — ใช้ list_servers เพื่อดูว่าเซิร์ฟเวอร์ย่อยใดบ้างที่พร้อมใช้งานและทำงานอยู่
  • Get TypeScript definitions for tools — เรียก get_tool_definitions เพื่อดึงลายเซ็นฟังก์ชันแบบมีชนิดข้อมูลสำหรับเครื่องมือของเซิร์ฟเวอร์ทั้งหมดหรือเฉพาะเซิร์ฟเวอร์
  • Execute multi-tool workflows as code — เขียน TypeScript ที่เชื่อมโยงการเรียกใช้เครื่องมือหลายครั้ง การวนซ้ำ และเงื่อนไขผ่าน generate_and_execute_code
  • Filter tool definitions by server — ส่ง server_names ไปยัง get_tool_definitions เพื่อลดการใช้บริบทและมุ่งเน้นไปที่เครื่องมือที่เกี่ยวข้อง
  • Handle errors in tool sequences — ใช้ try/catch ภายในโค้ดที่สร้างขึ้นเพื่อกู้คืนจากความล้มเหลวของเครื่องมือแต่ละรายการโดยไม่ต้องยกเลิกเวิร์กโฟลว์ทั้งหมด

เอกสาร

mcpcodeserver

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

เซิร์ฟเวอร์พร็อกซี Model Context Protocol (MCP) ที่แปลการเรียกใช้เครื่องมือเป็นการสร้างโค้ด TypeScript แทนที่จะเรียกใช้เครื่องมือหลายครั้งไปมา LLM สามารถเขียนโค้ด TypeScript ที่เรียกใช้เครื่องมือหลายตัวได้อย่างเป็นธรรมชาติ ลดค่าใช้จ่ายด้านโทเค็นและใช้ประโยชน์จากความสามารถในการสร้างโค้ดที่เหนือกว่าของ LLM

❌ หากไม่มี mcpcodeserver

LLM จะเรียกใช้เครื่องมือตามลำดับหลายครั้ง สิ้นเปลืองโทเค็นและประสบปัญหากับเวิร์กโฟลว์ที่ซับซ้อน:

  • ❌ การเดินทางไป-กลับหลายรอบระหว่าง LLM และเครื่องมือ
  • ❌ ลำดับการเรียกใช้เครื่องมือที่ซับซ้อนมีแนวโน้มเกิดข้อผิดพลาด
  • ❌ ไม่สามารถส่งผ่านข้อมูลระหว่างเครื่องมือได้ง่าย
  • ❌ การจัดการข้อผิดพลาดและการควบคุมโฟลว์มีจำกัด

✅ เมื่อใช้ mcpcodeserver

LLM เขียนโค้ด TypeScript ที่เรียกใช้เครื่องมือหลายตัวได้อย่างเป็นธรรมชาติ:

  • ✅ เขียนโค้ดเพื่อเรียกใช้เครื่องมือหลายตัวตามลำดับ
  • ✅ ใช้ตัวแปร ลูป และเงื่อนไขได้อย่างเป็นธรรมชาติ
  • ✅ จัดการข้อผิดพลาดได้ดีขึ้นด้วย try/catch
  • ✅ ลดการใช้โทเค็นด้วยการรวมการดำเนินการ
  • ✅ ใช้ประโยชน์จากความสามารถในการสร้างโค้ดที่แข็งแกร่งของ LLM

เริ่มต้นอย่างรวดเร็ว

  1. ติดตั้ง mcpcodeserver ในไคลเอนต์ MCP ของคุณ (ดูส่วนการติดตั้งด้านล่าง)
  2. สร้างไฟล์การกำหนดค่า mcp.json พร้อมกับเซิร์ฟเวอร์ MCP ลูกของคุณ
  3. เริ่มใช้งาน - LLM ของคุณสามารถสร้างและรันโค้ด TypeScript ที่เรียกใช้เครื่องมือของคุณได้แล้ว
// 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"));

ภาพรวม

mcpcodeserver เป็นเซิร์ฟเวอร์ MCP ที่ไม่เหมือนใครซึ่ง:

  • ทำหน้าที่เป็นไคลเอนต์ MCP เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ MCP ลูกหนึ่งตัวหรือมากกว่า
  • ค้นพบเครื่องมือทั้งหมดจากเซิร์ฟเวอร์ลูก
  • เปิดเผยเครื่องมือที่ทรงพลังสามตัวแก่ไคลเอนต์ LLM แม่:
    1. list_servers - แสดงรายการเซิร์ฟเวอร์ย่อยทั้งหมดที่เชื่อมต่อกับเซิร์ฟเวอร์ MCP นี้
    2. get_tool_definitions - ส่งคืนนิยามประเภท TypeScript สำหรับเครื่องมือที่ค้นพบ (สามารถกรองตามเซิร์ฟเวอร์ได้)
    3. generate_and_execute_code - สร้างและรันโค้ด TypeScript ที่เรียกใช้เครื่องมือเหล่านั้นในแซนด์บ็อกซ์

สถาปัตยกรรมนี้ช่วยให้ LLM สามารถจัดการเวิร์กโฟลว์หลายเครื่องมือที่ซับซ้อนได้โดยการเขียนโค้ดแทนการเรียกใช้เครื่องมือตามลำดับ ซึ่งมักจะมีประสิทธิภาพและเป็นธรรมชาติมากกว่าสำหรับโมเดลภาษาสมัยใหม่

งานวิจัยและผลงานที่เกี่ยวข้อง

แนวทางนี้ได้รับแรงบันดาลใจจากงานวิจัยล่าสุดที่แสดงให้เห็นว่า LLM ทำงานได้ดีขึ้นเมื่อสร้างโค้ดที่ปฏิบัติการได้แทนที่จะเรียกใช้เครื่องมือโดยตรง:

  • CodeAct: Your LLM Agent Acts Better when Generating Code (Apple, ICML 2024) - แสดงให้เห็นว่าเอเจนต์ LLM มีอัตราความสำเร็จสูงขึ้นถึง 20% เมื่อใช้โค้ด Python ที่ปฏิบัติการได้เป็นพื้นที่การกระทำที่เป็นหนึ่งเดียวแทนที่จะใช้รูปแบบการเรียกใช้เครื่องมือที่กำหนดไว้ล่วงหน้า

  • Cloudflare Code Mode - การนำไปใช้ที่คล้ายกันซึ่งแปลงเครื่องมือ MCP เป็น TypeScript API แสดงให้เห็นว่า "LLM เขียนโค้ดเพื่อเรียกใช้ MCP ได้ดีกว่าการเรียกใช้ MCP โดยตรง"

ข้อมูลเชิงลึกที่สำคัญจากงานวิจัยนี้คือ LLM ได้รับการฝึกฝนอย่างกว้างขวางเกี่ยวกับโค้ดในโลกแห่งความเป็นจริง แต่มีประสบการณ์จำกัดกับรูปแบบการเรียกใช้เครื่องมือสังเคราะห์ ทำให้การสร้างโค้ดเป็นแนวทางที่เป็นธรรมชาติและมีประสิทธิภาพมากขึ้นสำหรับเวิร์กโฟลว์เอเจนต์ที่ซับซ้อน

ทำไมต้องใช้สิ่งนี้?

ปัญหาการเรียกใช้เครื่องมือแบบดั้งเดิม

  • การเดินทางไป-กลับหลายรอบระหว่าง LLM และเครื่องมือทำให้สิ้นเปลืองโทเค็น
  • LLM มักประสบปัญหากับลำดับการเรียกใช้เครื่องมือที่ซับซ้อน
  • การเรียกใช้เครื่องมือแต่ละครั้งต้องอาศัยความเข้าใจและการจัดรูปแบบ JSON schema
  • ไม่สามารถส่งผ่านข้อมูลระหว่างเครื่องมือได้ง่ายโดยไม่ผ่าน LLM

โซลูชันการสร้างโค้ด

  • เขียนโค้ด TypeScript เพื่อเรียกใช้เครื่องมือหลายตัวตามลำดับ
  • ใช้ตัวแปร ลูป และเงื่อนไขได้อย่างเป็นธรรมชาติ
  • จัดการข้อผิดพลาดได้ดีขึ้นด้วย try/catch
  • ลดการใช้โทเค็นด้วยการรวมการดำเนินการ
  • ใช้ประโยชน์จากความสามารถในการสร้างโค้ดที่แข็งแกร่งของ LLM

การค้นพบเครื่องมือแบบไดนามิก

mcpcodeserver จะตรวจสอบเซิร์ฟเวอร์ MCP ลูกโดยอัตโนมัติเพื่อดูการเปลี่ยนแปลงของเครื่องมือ และแจ้งเตือนไคลเอนต์แม่เมื่อมีการเพิ่ม ลบ หรือแก้ไขเครื่องมือ:

  • รีเฟรชอัตโนมัติ: ตรวจสอบการเปลี่ยนแปลงของเครื่องมือทุก 30 วินาที
  • การแจ้งเตือนแบบเรียลไทม์: ส่ง notifications/tools/list_changed ไปยังไคลเอนต์แม่
  • อัปเดตแบบไดนามิก: นิยามเครื่องมือและสรุปจะอัปเดตโดยอัตโนมัติ
  • ไม่ต้องรีเฟรชด้วยตนเอง: LLM แม่ได้รับการแจ้งเตือนให้รีเฟรชความรู้เกี่ยวกับเครื่องมือ

สิ่งนี้ทำให้แน่ใจว่า LLM แม่มีนิยามเครื่องมือที่เป็นปัจจุบันที่สุดเสมอโดยไม่ต้องดำเนินการด้วยตนเอง

การกรองเซิร์ฟเวอร์

เพื่อลดการใช้หน้าต่างบริบทและปรับปรุงโฟกัส mcpcodeserver รองรับการกรองนิยามเครื่องมือตามเซิร์ฟเวอร์ที่ระบุ:

  • แสดงรายการเซิร์ฟเวอร์ที่พร้อมใช้งาน: ใช้ list_servers เพื่อดูเซิร์ฟเวอร์ย่อยทั้งหมดที่เชื่อมต่ออยู่
  • นิยามเครื่องมือที่กรองแล้ว: ใช้ get_tool_definitions พร้อมพารามิเตอร์ server_names เพื่อรับเครื่องมือจากเซิร์ฟเวอร์ที่ระบุเท่านั้น
  • ลดความละเอียด: รับนิยาม TypeScript ที่โฟกัสโดยไม่ทำให้หน้าต่างบริบทของ LLM ล้น
  • การตั้งชื่อเมธอดตามเนมสเปซ: ฟังก์ชันที่สร้างขึ้นทั้งหมดจะมีคำนำหน้าด้วยชื่อเซิร์ฟเวอร์ (เช่น pizzashop_create_pizza, filesystem_read_file)

ตัวอย่างการใช้งาน:

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

คุณสมบัติ MCP ขั้นสูง

mcpcodeserver รองรับการส่งผ่านคุณสมบัติโปรโตคอล MCP ขั้นสูงเมื่อทั้งไคลเอนต์แม่และเซิร์ฟเวอร์ลูกรองรับ:

  • Elicitation: เซิร์ฟเวอร์ลูกสามารถขอข้อมูลจากผู้ใช้ระหว่างการดำเนินการเครื่องมือ ซึ่งจะถูกส่งผ่านไปยังไคลเอนต์แม่
  • Roots: แสดงรายการและรวบรวม roots จากเซิร์ฟเวอร์ลูกทั้งหมด ให้มุมมองที่เป็นหนึ่งเดียวของทรัพยากรที่พร้อมใช้งาน
  • Sampling: เปิดใช้งานการส่งคำขอ sampling ของ LLM ไปยังเซิร์ฟเวอร์ลูกเพื่อความสามารถ AI ขั้นสูง

คุณสมบัติเหล่านี้จะถูกโฆษณาไปยังไคลเอนต์แม่โดยอัตโนมัติและทำงานได้อย่างราบรื่นเมื่อเซิร์ฟเวอร์ MCP ลูกที่เกี่ยวข้องรองรับ

เริ่มต้นอย่างรวดเร็ว

ทดลองใช้ทันทีด้วย npx (ไม่ต้องติดตั้ง):

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

# Or when published to npm
npx mcpcodeserver --help

🛠️ การติดตั้ง

ข้อกำหนด

  • Node.js >= v18.0.0
  • Cursor, Claude Code, VSCode, Windsurf หรือไคลเอนต์ MCP อื่นๆ

การติดตั้งผ่าน Smithery

เพื่อติดตั้ง mcpcodeserver สำหรับไคลเอนต์ใดๆ โดยอัตโนมัติผ่าน Smithery:

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

ติดตั้งใน Cursor

ไปที่: Settings -> Cursor Settings -> MCP -> Add new global MCP server

การวางการกำหนดค่าต่อไปนี้ลงในไฟล์ ~/.cursor/mcp.json ของ Cursor เป็นแนวทางที่แนะนำ คุณยังสามารถติดตั้งในโปรเจกต์เฉพาะได้โดยการสร้าง .cursor/mcp.json ในโฟลเดอร์โปรเจกต์ของคุณ

การติดตั้ง Cursor แบบคลิกเดียว

Install MCP Server

การเชื่อมต่อเซิร์ฟเวอร์ภายในของ Cursor

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

การเชื่อมต่อเซิร์ฟเวอร์ระยะไกลของ Cursor (หากคุณตั้งค่าการขนส่ง HTTP)

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

ติดตั้งใน Claude Code

รันคำสั่งนี้ ดูข้อมูลเพิ่มเติมได้ที่ เอกสาร Claude Code MCP

การเชื่อมต่อเซิร์ฟเวอร์ภายในของ Claude Code

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

การเชื่อมต่อเซิร์ฟเวอร์ระยะไกลของ Claude Code

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

ติดตั้งใน VSCode

การติดตั้ง VSCode แบบคลิกเดียว

Install in VS Code (npx)

การกำหนดค่า VSCode ด้วยตนเอง

เพิ่มในการตั้งค่า MCP ของ VSCode:

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

ติดตั้งใน Windsurf

การติดตั้ง Windsurf แบบคลิกเดียว

Install in Windsurf

ติดตั้งใน AI Coding Assistants

สำหรับ Continue, Cline, และ RooCode เพิ่มในการกำหนดค่าของคุณ:

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

ติดตั้งใน Amp

รันคำสั่งนี้ในเทอร์มินัลของคุณ ดูข้อมูลเพิ่มเติมได้ที่ เอกสาร Amp MCP

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

ติดตั้งใน Text Editors

สำหรับ Aider, Codium, Zed, Nova, และ Sublime Text เพิ่มในการกำหนดค่าของคุณ:

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

ติดตั้งใน Neovim

เพิ่มในการกำหนดค่า Neovim MCP:

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

ติดตั้งใน Emacs

เพิ่มในการกำหนดค่า Emacs MCP:

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

ติดตั้งใน JetBrains IDEs

สำหรับ IntelliJ IDEA, WebStorm, PyCharm, และ Android Studio เพิ่มในการตั้งค่า MCP ของคุณ:

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

ติดตั้งใน AI Tools

สำหรับ Codeium, Tabnine, GitHub Copilot, และ Amazon CodeWhisperer เพิ่มในการตั้งค่า MCP ของคุณ:

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

ติดตั้งใน Cloud IDEs

สำหรับ Replit, CodeSandbox, StackBlitz, GitPod, GitHub Codespaces, GitLab Web IDE, และ Bitbucket Cloud เพิ่มในการตั้งค่า MCP ของคุณ:

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

ติดตั้งในเครื่องมืออื่นๆ

สำหรับ Xcode, Fleet, Sourcegraph, และ JetBrains Gateway เพิ่มในการกำหนดค่า MCP ของคุณ:

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

ติดตั้งใน Remote Development

สำหรับสภาพแวดล้อมการพัฒนาระยะไกล คุณยังสามารถใช้การขนส่ง HTTP:

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

ไฟล์การกำหนดค่า

สร้างไฟล์การกำหนดค่า mcp.json เพื่อกำหนดเซิร์ฟเวอร์ MCP ลูกของคุณ:

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

การติดตั้งสำหรับการพัฒนา

# 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

หมายเหตุ: โปรเจกต์นี้ใช้ Bun เพื่อประสิทธิภาพที่ดีขึ้น แต่ npm/node ก็ทำงานได้ดีเช่นกัน

🚨 การแก้ไขปัญหา

ข้อผิดพลาด Module Not Found

หากคุณพบ ERR_MODULE_NOT_FOUND ให้ลองใช้ bunx แทน npx:

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

ปัญหา ESM Resolution

สำหรับข้อผิดพลาดเช่น Error: Cannot find module ให้ลองใช้แฟล็ก --experimental-vm-modules:

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

ปัญหา TLS/Certificate

ใช้แฟล็ก --experimental-fetch เพื่อข้ามปัญหาที่เกี่ยวข้องกับ TLS:

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

ข้อผิดพลาดทั่วไปของไคลเอนต์ MCP

  1. ลองเพิ่ม @latest ต่อท้ายชื่อแพ็คเกจ
  2. ใช้ bunx เป็นทางเลือกแทน npx
  3. พิจารณาใช้ deno เป็นอีกทางเลือกหนึ่ง
  4. ตรวจสอบให้แน่ใจว่าคุณใช้ Node.js v18 หรือสูงกว่าเพื่อรองรับ fetch ดั้งเดิม

ปัญหาการกำหนดค่า

  • ตรวจสอบให้แน่ใจว่าไฟล์ mcp.json ของคุณเป็น JSON ที่ถูกต้อง
  • ตรวจสอบว่าคำสั่งเซิร์ฟเวอร์ลูกทั้งหมดพร้อมใช้งานใน PATH ของคุณ
  • ตรวจสอบว่าเซิร์ฟเวอร์ลูกสามารถเริ่มต้นได้อย่างอิสระ
  • ตรวจสอบสิทธิ์ของไฟล์สำหรับพาธไฟล์การกำหนดค่า

การทดสอบด้วย MCP Inspector

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

💻 การพัฒนา

อาร์กิวเมนต์ CLI

mcpcodeserver ยอมรับแฟล็ก CLI ต่อไปนี้:

  • --config <path> – พาธไปยังไฟล์การกำหนดค่า MCP (ค่าเริ่มต้น: ./mcp.json)
  • --transport <stdio|http> – การขนส่งที่จะใช้ (stdio โดยค่าเริ่มต้น) โปรดทราบว่าการขนส่ง HTTP จะให้ทั้งจุดสิ้นสุด HTTP และ SSE โดยอัตโนมัติ
  • --port <number> – พอร์ตที่จะรับฟังเมื่อใช้การขนส่ง http (ค่าเริ่มต้น 3000)
  • --help – แสดงข้อความช่วยเหลือ

ตัวอย่างด้วยการขนส่ง HTTP และพอร์ต 8080:

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

ตัวอย่างด้วยการขนส่ง stdio:

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

ตัวแปรสภาพแวดล้อม

คุณสามารถใช้ตัวแปรสภาพแวดล้อมสำหรับการกำหนดค่า:

  • MCP_CONFIG_PATH – พาธไปยังไฟล์การกำหนดค่า MCP (ทางเลือกแทน --config)
  • MCP_TRANSPORT – ประเภทการขนส่ง (ทางเลือกแทน --transport)
  • MCP_PORT – หมายเลขพอร์ตสำหรับการขนส่ง HTTP (ทางเลือกแทน --port)

ตัวอย่างด้วยตัวแปรสภาพแวดล้อม:

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

ตัวอย่างการกำหนดค่า MCP โดยใช้ตัวแปรสภาพแวดล้อม:

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

หมายเหตุ: แฟล็ก CLI มีความสำคัญกว่าตัวแปรสภาพแวดล้อมเมื่อมีการระบุทั้งสองอย่าง

การกำหนดค่าการพัฒนาในเครื่อง

สำหรับการพัฒนาในเครื่อง คุณสามารถรันซอร์ส TypeScript ได้โดยตรง:

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

โหมดการทำงาน

โหมด Stdio (ค่าเริ่มต้น)

เซิร์ฟเวอร์ทำงานในโหมด stdio ตามค่าเริ่มต้น ซึ่งเหมาะสำหรับการรวมเข้ากับไคลเอนต์ MCP เช่น Claude Desktop:

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

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

โหมด HTTP

สำหรับการดีบัก ทดสอบ หรือรวมเข้ากับไคลเอนต์ MCP บนเว็บ คุณสามารถรันเซิร์ฟเวอร์ในโหมด 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

เมื่อทำงานในโหมด HTTP เซิร์ฟเวอร์จะพร้อมใช้งานที่:

  • URL เซิร์ฟเวอร์: http://localhost:3000/mcp (หรือโฮสต์:พอร์ตที่คุณกำหนดเอง)
  • MCP Inspector: ใช้ npx @modelcontextprotocol/inspector http://localhost:3000/mcp เพื่อดีบักและทดสอบ

การรวม MCP Inspector

MCP Inspector เป็นเครื่องมือที่ทรงพลังสำหรับการดีบักและทดสอบเซิร์ฟเวอร์ MCP เมื่อทำงานในโหมด HTTP คุณสามารถใช้เพื่อ:

  • ตรวจสอบเครื่องมือที่มีอยู่และ schema ของมัน
  • ทดสอบการเรียกใช้เครื่องมือแบบโต้ตอบ
  • ดีบักการเข้าถึงทรัพยากรและพรอมต์
  • ตรวจสอบการแจ้งเตือนแบบเรียลไทม์
# 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

Inspector จะเปิดในเบราว์เซอร์ของคุณและให้อินเทอร์เฟซเต็มรูปแบบสำหรับการสำรวจและทดสอบเซิร์ฟเวอร์ MCP ของคุณ

หมายเหตุ: คำสั่ง npm run inspector ใช้ mcp-test.json ซึ่งรวมเซิร์ฟเวอร์ MCP 8 ตัว (เครื่องมือทั้งหมด 67 รายการ) จาก ตัวอย่างอย่างเป็นทางการ รวมถึงเซิร์ฟเวอร์ที่ใช้ TypeScript (npx) และ Python (uvx)

การกำหนดค่า

สร้างไฟล์ mcp.json ที่กำหนดว่าจะเชื่อมต่อกับเซิร์ฟเวอร์ MCP ลูกใดบ้าง ซึ่งเป็นไปตามรูปแบบการกำหนดค่าไคลเอนต์ MCP มาตรฐาน:

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

ตัวเลือกการกำหนดค่า

แต่ละรายการเซิร์ฟเวอร์รองรับ:

สำหรับการขนส่งแบบ stdio:

  • command (จำเป็น) - คำสั่งที่จะดำเนินการ (เช่น "node", "python", "npx")
  • args (ไม่บังคับ) - อาร์เรย์ของอาร์กิวเมนต์ที่จะส่งให้คำสั่ง
  • env (ไม่บังคับ) - ตัวแปรสภาพแวดล้อมสำหรับกระบวนการลูก

สำหรับการขนส่งแบบ HTTP/SSE:

  • url (จำเป็น) - URL ปลายทาง HTTP
  • transport - ตั้งค่าเป็น "sse" สำหรับ Server-Sent Events

การใช้งาน

การเริ่มต้นเซิร์ฟเวอร์

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

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

# Show help
mcpcodeserver --help

การใช้เป็นเซิร์ฟเวอร์ MCP

กำหนดค่า mcpcodeserver ในไคลเอนต์ MCP ของคุณ (เช่น Claude Desktop, Claude Code, Cline ฯลฯ):

ด้วย npx (แนะนำ - ไม่ต้องติดตั้ง):

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

จาก GitHub (ใช้งานได้ทันที):

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

ด้วยตัวจัดการแพ็คเกจอื่นๆ:

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

ดู examples/ สำหรับตัวอย่างการกำหนดค่าเพิ่มเติมและการตั้งค่าเฉพาะของไคลเอนต์ MCP

เครื่องมือ 1: get_tool_definitions

เครื่องมือนี้ส่งคืนคำจำกัดความประเภท TypeScript สำหรับเครื่องมือทั้งหมดที่ค้นพบจากเซิร์ฟเวอร์ลูก

อินพุต:

  • include_examples (บูลีน ไม่บังคับ) - ว่าจะรวมตัวอย่างการใช้งานหรือไม่

ตัวอย่าง:

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

เอาต์พุต: ส่งคืนโค้ด TypeScript พร้อมอินเทอร์เฟซและการประกาศฟังก์ชัน:

/**
 * 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

เครื่องมือ 2: generate_and_execute_code

เครื่องมือนี้ดำเนินการโค้ด TypeScript ในแซนด์บ็อกซ์ที่เข้าถึงฟังก์ชันเครื่องมือทั้งหมดที่ค้นพบได้

อินพุต:

  • code (สตริง จำเป็น) - โค้ด TypeScript/JavaScript ที่จะดำเนินการ
  • timeout (ตัวเลข ไม่บังคับ) - เวลาดำเนินการสูงสุดในหน่วยมิลลิวินาที (ค่าเริ่มต้น: 30000, สูงสุด: 300000)

ตัวอย่าง:

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

เอาต์พุต:

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

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

สภาพแวดล้อมแซนด์บ็อกซ์

แซนด์บ็อกซ์การดำเนินการ TypeScript มีให้:

ที่มีอยู่:

  • ฟังก์ชันเครื่องมือทั้งหมดที่ค้นพบ (เป็นฟังก์ชัน async)
  • เมธอดคอนโซล: console.log(), console.error(), console.warn(), console.info()
  • โกลบอล JavaScript พื้นฐาน: Math, JSON, Date, Array, Object, String, Number, Boolean
  • การรองรับ Promise และ async/await
  • การจัดการข้อผิดพลาดด้วย try/catch
  • ตัวจับเวลา: setTimeout, setInterval, clearTimeout, clearInterval

ไม่มี:

  • โมดูล Node.js (fs, http, child_process ฯลฯ)
  • การเข้าถึงระบบไฟล์ (ยกเว้นผ่านเครื่องมือ MCP)
  • การเข้าถึงเครือข่าย (ยกเว้นผ่านเครื่องมือ MCP)
  • ข้อมูลกระบวนการ

หมายเหตุด้านความปลอดภัย: นี่ไม่ใช่แซนด์บ็อกซ์ที่ปลอดภัยอย่างสมบูรณ์ บริบท VM ให้การแยกส่วนแต่ไม่สามารถป้องกันได้ทั้งหมด ควรดำเนินการเฉพาะโค้ดที่เชื่อถือได้เท่านั้น

การจัดการข้อผิดพลาด

ข้อผิดพลาดในแซนด์บ็อกซ์จะถูกจับและส่งคืนพร้อมกับ stack traces:

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

การทดสอบกับ Claude Code

ต้องการลอง mcpcodeserver กับ Claude Code หรือไม่? ใช้การตั้งค่าด้วยคำสั่งเดียว:

./setup-claude-code-test.sh

สิ่งนี้จะสร้างโปรเจกต์ ติดตั้งการพึ่งพาสำหรับการทดสอบ และแสดงให้คุณเห็นอย่างชัดเจนว่าต้องเพิ่มอะไรลงในการกำหนดค่า Claude Code ของคุณ ดู TESTING_WITH_CLAUDE.md สำหรับคำแนะนำโดยละเอียด

การพัฒนา

# 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

โครงสร้างโปรเจกต์

ดู AGENTS.md สำหรับโครงสร้างโปรเจกต์โดยละเอียดและเอกสารประกอบคอมโพเนนต์

กรณีการใช้งาน

การดำเนินการหลายไฟล์

แทนที่จะเรียกใช้เครื่องมือหลายครั้งผ่าน LLM ให้เขียนโค้ด:

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

การแปลงข้อมูล

ประมวลผลข้อมูลระหว่างการเรียกใช้เครื่องมือโดยไม่ต้องให้ 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;

ตรรกะแบบมีเงื่อนไข

ตัดสินใจตามผลลัพธ์ของเครื่องมือ:

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

การกู้คืนข้อผิดพลาด

จัดการข้อผิดพลาดอย่างสง่างามโดยไม่ยกเลิกเวิร์กโฟลว์ทั้งหมด:

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;

การรวมเซิร์ฟเวอร์ MCP ต้นทาง

mcpcodeserver สามารถรวมกับเซิร์ฟเวอร์ MCP ต้นทางอย่างเป็นทางการจาก ที่เก็บเซิร์ฟเวอร์ Model Context Protocol ซึ่งช่วยให้คุณใช้เซิร์ฟเวอร์ MCP จริงที่พร้อมใช้งานจริงร่วมกับเครื่องมือที่กำหนดเองของคุณได้

เซิร์ฟเวอร์ต้นทางที่รองรับ

  • filesystem: การดำเนินการระบบไฟล์ (อ่าน เขียน แสดงรายการไดเรกทอรี)
  • memory: ที่เก็บคีย์-ค่าในหน่วยความจำ
  • sqlite: การดำเนินการฐานข้อมูล SQLite
  • github: การรวม GitHub API
  • brave-search: ความสามารถในการค้นหาเว็บ
  • fetch: ความสามารถในการร้องขอ HTTP

ตัวอย่างการกำหนดค่า

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

การทดสอบการรวมต้นทาง

โปรเจกต์นี้รวมการทดสอบที่ครอบคลุมสำหรับการรวมเซิร์ฟเวอร์ต้นทาง:

# 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

เวิร์กโฟลว์ข้ามเซิร์ฟเวอร์

ด้วยเซิร์ฟเวอร์ต้นทาง คุณสามารถสร้างเวิร์กโฟลว์ข้ามเซิร์ฟเวอร์ที่ทรงพลัง:

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

ข้อจำกัด

  • หมดเวลาการดำเนินการ: สูงสุด 5 นาที (กำหนดค่าได้ ค่าเริ่มต้น 30 วินาที)
  • หน่วยความจำ: จำกัดโดยบริบท VM ของ Node.js
  • ไม่มีสถานะคงอยู่ระหว่างการดำเนินการ
  • ไม่สามารถ require/import โมดูลภายนอกได้
  • ไม่ใช่แซนด์บ็อกซ์ด้านความปลอดภัย - อย่าเรียกใช้โค้ดที่ไม่น่าเชื่อถือ

การมีส่วนร่วม

ยินดีต้อนรับการมีส่วนร่วม! โปรเจกต์นี้สร้างด้วย:

  • TypeScript 5.7+
  • Node.js 18+
  • MCP TypeScript SDK 1.20+
  • Zod สำหรับการตรวจสอบความถูกต้อง

ดู CONTRIBUTING.md สำหรับแนวทางการมีส่วนร่วมโดยละเอียด

การสนับสนุน

หากคุณพบว่าโปรเจกต์นี้มีประโยชน์ ลองเลี้ยงกาแฟฉันสักแก้ว!

Buy Me A Coffee

ใบอนุญาต

MIT

แหล่งข้อมูล