mcpcodeserver

mcpcodeserver

Một máy chủ proxy Model Context Protocol (MCP) chuyển đổi các lệnh gọi công cụ thành việc tạo mã TypeScript. Thay vì thực hiện nhiều lệnh gọi công cụ qua lại, các LLM có thể viết mã TypeScript gọi nhiều công cụ một cách tự nhiên, giảm chi phí token và tận dụng khả năng tạo mã vượt trội của LLM.

❌ Khi không có mcpcodeserver

LLM thực hiện nhiều lệnh gọi công cụ tuần tự, tiêu tốn token và gặp khó khăn với các quy trình phức tạp:

• ❌ Nhiều vòng khứ hồi giữa LLM và công cụ
• ❌ Các chuỗi gọi công cụ phức tạp dễ gây lỗi
• ❌ Dữ liệu không thể dễ dàng truyền giữa các công cụ
• ❌ Xử lý lỗi và luồng điều khiển hạn chế

✅ Khi có mcpcodeserver

LLM viết mã TypeScript gọi nhiều công cụ một cách tự nhiên:

• ✅ Viết mã để gọi nhiều công cụ theo trình tự
• ✅ Sử dụng biến, vòng lặp và điều kiện một cách tự nhiên
• ✅ Xử lý lỗi tốt hơn với try/catch
• ✅ Giảm sử dụng token bằng cách kết hợp các thao tác
• ✅ Tận dụng khả năng tạo mã mạnh mẽ của LLM

Bắt đầu nhanh

1. Cài đặt mcpcodeserver trong máy khách MCP của bạn (xem phần cài đặt bên dưới)
2. Tạo tệp cấu hình mcp.json với các máy chủ MCP con của bạn
3. Bắt đầu sử dụng - LLM của bạn giờ đây có thể tạo và thực thi mã TypeScript gọi các công cụ của bạn

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

Tổng quan

mcpcodeserver là một máy chủ MCP độc đáo:

• Hoạt động như một máy khách MCP để kết nối với một hoặc nhiều máy chủ MCP con
• Khám phá tất cả các công cụ từ máy chủ con
• Cung cấp ba công cụ mạnh mẽ cho máy khách LLM cha:
  1. list_servers - Liệt kê tất cả các máy chủ con khả dụng được kết nối với máy chủ MCP này
  2. get_tool_definitions - Trả về định nghĩa kiểu TypeScript cho các công cụ đã khám phá (tùy chọn lọc theo máy chủ)
  3. generate_and_execute_code - Tạo và thực thi mã TypeScript gọi các công cụ đó trong một hộp cát

Kiến trúc này cho phép LLM điều phối các quy trình đa công cụ phức tạp bằng cách viết mã thay vì thực hiện các lệnh gọi công cụ tuần tự, điều này thường hiệu quả và tự nhiên hơn đối với các mô hình ngôn ngữ hiện đại.

Công trình liên quan & Nghiên cứu

Cách tiếp cận này được truyền cảm hứng từ nghiên cứu gần đây cho thấy LLM hoạt động tốt hơn khi tạo mã thực thi thay vì gọi công cụ trực tiếp:

• CodeAct: Your LLM Agent Acts Better when Generating Code (Apple, ICML 2024) - Chứng minh rằng các tác nhân LLM đạt tỷ lệ thành công cao hơn tới 20% khi sử dụng mã Python thực thi như một không gian hành động thống nhất thay vì các định dạng gọi công cụ được xác định trước.

• Cloudflare Code Mode - Một triển khai tương tự chuyển đổi các công cụ MCP thành API TypeScript, cho thấy "LLM viết mã để gọi MCP tốt hơn là gọi MCP trực tiếp."

Hiểu biết chính từ nghiên cứu này là LLM được đào tạo rộng rãi về mã thực tế nhưng ít tiếp xúc với các định dạng gọi công cụ tổng hợp, khiến việc tạo mã trở thành một cách tiếp cận tự nhiên và hiệu quả hơn cho các quy trình tác nhân phức tạp.

Tại sao nên sử dụng?

Vấn đề gọi công cụ truyền thống

• Nhiều vòng khứ hồi giữa LLM và công cụ tiêu tốn token
• LLM thường gặp khó khăn với các chuỗi gọi công cụ phức tạp
• Mỗi lệnh gọi công cụ yêu cầu hiểu và định dạng lược đồ JSON
• Dữ liệu không thể dễ dàng truyền giữa các công cụ mà không thông qua LLM

Giải pháp tạo mã

• Viết mã TypeScript để gọi nhiều công cụ theo trình tự
• Sử dụng biến, vòng lặp và điều kiện một cách tự nhiên
• Xử lý lỗi tốt hơn với try/catch
• Giảm sử dụng token bằng cách kết hợp các thao tác
• Tận dụng khả năng tạo mã mạnh mẽ của LLM

Khám phá công cụ động

mcpcodeserver tự động giám sát các máy chủ MCP con để phát hiện thay đổi công cụ và thông báo cho máy khách cha khi công cụ được thêm, xóa hoặc sửa đổi:

• Tự động làm mới: Kiểm tra thay đổi công cụ mỗi 30 giây
• Thông báo thời gian thực: Gửi notifications/tools/list_changed đến máy khách cha
• Cập nhật động: Định nghĩa và tóm tắt công cụ tự động cập nhật
• Không cần làm mới thủ công: LLM cha nhận thông báo để làm mới kiến thức công cụ của chúng

Điều này đảm bảo LLM cha luôn có định nghĩa công cụ mới nhất mà không cần can thiệp thủ công.

Lọc máy chủ

Để giảm sử dụng cửa sổ ngữ cảnh và cải thiện tập trung, mcpcodeserver hỗ trợ lọc định nghĩa công cụ theo các máy chủ cụ thể:

• Liệt kê máy chủ khả dụng: Sử dụng list_servers để xem tất cả máy chủ con được kết nối
• Định nghĩa công cụ đã lọc: Sử dụng get_tool_definitions với tham số server_names để chỉ lấy công cụ từ các máy chủ cụ thể
• Giảm độ dài: Nhận định nghĩa TypeScript tập trung mà không làm quá tải cửa sổ ngữ cảnh của LLM
• Không gian tên phương thức: Tất cả các hàm được tạo đều có tiền tố tên máy chủ (ví dụ: pizzashop_create_pizza, filesystem_read_file)

Ví dụ sử dụng:

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

Tính năng MCP nâng cao

mcpcodeserver hỗ trợ chuyển tiếp các tính năng giao thức MCP nâng cao khi cả máy khách cha và máy chủ con đều hỗ trợ:

• Elicitation: Máy chủ con có thể yêu cầu đầu vào của người dùng trong quá trình thực thi công cụ, được chuyển tiếp đến máy khách cha
• Roots: Liệt kê và tổng hợp các gốc từ tất cả máy chủ con, cung cấp cái nhìn thống nhất về tài nguyên khả dụng
• Sampling: Cho phép các yêu cầu lấy mẫu LLM được chuyển tiếp đến máy chủ con để có khả năng AI nâng cao

Các tính năng này được tự động quảng bá đến máy khách cha và hoạt động liền mạch khi được các máy chủ MCP con cơ bản hỗ trợ.

Bắt đầu nhanh

Dùng thử ngay với npx (không cần cài đặt):

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

# Or when published to npm
npx mcpcodeserver --help

🛠️ Cài đặt

Yêu cầu

• Node.js >= v18.0.0
• Cursor, Claude Code, VSCode, Windsurf hoặc một máy khách MCP khác

Cài đặt qua Smithery

Để cài đặt mcpcodeserver cho bất kỳ máy khách nào một cách tự động qua Smithery:

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

Cài đặt trong Cursor

Đi tới: Settings -> Cursor Settings -> MCP -> Add new global MCP server

Dán cấu hình sau vào tệp ~/.cursor/mcp.json Cursor của bạn là cách được khuyến nghị. Bạn cũng có thể cài đặt trong một dự án cụ thể bằng cách tạo .cursor/mcp.json trong thư mục dự án của bạn.

Cài đặt một lần nhấp cho Cursor

Kết nối máy chủ cục bộ Cursor

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

Kết nối máy chủ từ xa Cursor (nếu bạn thiết lập truyền tải HTTP)

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

Cài đặt trong Claude Code

Chạy lệnh này. Xem tài liệu Claude Code MCP để biết thêm thông tin.

Kết nối máy chủ cục bộ Claude Code

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

Kết nối máy chủ từ xa Claude Code

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

Cài đặt trong VSCode

Cài đặt một lần nhấp cho VSCode

Cấu hình thủ công VSCode

Thêm vào cài đặt MCP VSCode của bạn:

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

Cài đặt trong Windsurf

Cài đặt một lần nhấp cho Windsurf

Cài đặt trong Trợ lý lập trình AI

Đối với Continue, Cline, và RooCode, thêm vào cấu hình của bạn:

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

Cài đặt trong Amp

Chạy lệnh này trong terminal của bạn. Xem tài liệu Amp MCP để biết thêm thông tin.

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

Cài đặt trong Trình soạn thảo văn bản

Đối với Aider, Codium, Zed, Nova, và Sublime Text, thêm vào cấu hình của bạn:

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

Cài đặt trong Neovim

Thêm vào cấu hình MCP Neovim của bạn:

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

Cài đặt trong Emacs

Thêm vào cấu hình MCP Emacs của bạn:

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

Cài đặt trong IDE JetBrains

Đối với IntelliJ IDEA, WebStorm, PyCharm, và Android Studio, thêm vào cài đặt MCP của bạn:

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

Cài đặt trong Công cụ AI

Đối với Codeium, Tabnine, GitHub Copilot, và Amazon CodeWhisperer, thêm vào cài đặt MCP của bạn:

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

Cài đặt trong IDE đám mây

Đối với Replit, CodeSandbox, StackBlitz, GitPod, GitHub Codespaces, GitLab Web IDE, và Bitbucket Cloud, thêm vào cài đặt MCP của bạn:

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

Cài đặt trong Công cụ khác

Đối với Xcode, Fleet, Sourcegraph, và JetBrains Gateway, thêm vào cấu hình MCP của bạn:

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

Cài đặt trong Phát triển từ xa

Đối với môi trường phát triển từ xa, bạn cũng có thể sử dụng truyền tải HTTP:

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

Tệp cấu hình

Tạo tệp cấu hình mcp.json để định nghĩa máy chủ MCP con của bạn:

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

Cài đặt cho Phát triển

# 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

Lưu ý: Dự án này sử dụng Bun để có hiệu suất tốt hơn, nhưng npm/node cũng hoạt động tốt.

🚨 Khắc phục sự cố

Lỗi Không tìm thấy Mô-đun

Nếu bạn gặp ERR_MODULE_NOT_FOUND, hãy thử sử dụng bunx thay vì npx:

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

Vấn đề phân giải ESM

Đối với các lỗi như Error: Cannot find module, hãy thử cờ --experimental-vm-modules:

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

Vấn đề TLS/Chứng chỉ

Sử dụng cờ --experimental-fetch để bỏ qua các vấn đề liên quan đến TLS:

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

Lỗi máy khách MCP chung

1. Thử thêm @latest vào tên gói
2. Sử dụng bunx như một giải pháp thay thế cho npx
3. Cân nhắc sử dụng deno như một giải pháp thay thế khác
4. Đảm bảo bạn đang sử dụng Node.js v18 trở lên để hỗ trợ fetch gốc

Vấn đề cấu hình

• Đảm bảo tệp mcp.json của bạn là JSON hợp lệ
• Kiểm tra xem tất cả các lệnh máy chủ con có sẵn trong PATH của bạn không
• Xác minh rằng máy chủ con có thể khởi động độc lập
• Kiểm tra quyền truy cập tệp cho đường dẫn tệp cấu hình

Kiểm tra với MCP Inspector

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

💻 Phát triển

Đối số CLI

mcpcodeserver chấp nhận các cờ CLI sau:

• --config <path> – Đường dẫn đến tệp cấu hình MCP (mặc định: ./mcp.json)
• --transport <stdio|http> – Truyền tải sử dụng (stdio theo mặc định). Lưu ý rằng truyền tải HTTP tự động cung cấp cả điểm cuối HTTP và SSE
• --port <number> – Cổng lắng nghe khi sử dụng truyền tải http (mặc định 3000)
• --help – Hiển thị thông báo trợ giúp

Ví dụ với truyền tải HTTP và cổng 8080:

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

Ví dụ với truyền tải stdio:

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

Biến môi trường

Bạn có thể sử dụng biến môi trường để cấu hình:

• MCP_CONFIG_PATH – Đường dẫn đến tệp cấu hình MCP (thay thế cho --config)
• MCP_TRANSPORT – Loại truyền tải (thay thế cho --transport)
• MCP_PORT – Số cổng cho truyền tải HTTP (thay thế cho --port)

Ví dụ với biến môi trường:

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

Ví dụ cấu hình MCP sử dụng biến môi trường:

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

Lưu ý: Cờ CLI được ưu tiên hơn biến môi trường khi cả hai được cung cấp.

Cấu hình phát triển cục bộ

Đối với phát triển cục bộ, bạn có thể chạy trực tiếp mã nguồn TypeScript:

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

Chế độ chạy

Chế độ Stdio (Mặc định)

Máy chủ chạy ở chế độ stdio theo mặc định, hoàn hảo cho việc tích hợp với máy khách MCP như Claude Desktop:

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

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

Chế độ HTTP

Để gỡ lỗi, kiểm tra hoặc tích hợp với máy khách MCP dựa trên web, bạn có thể chạy máy chủ ở chế độ 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

Khi chạy ở chế độ HTTP, máy chủ sẽ khả dụng tại:

• URL Máy chủ: http://localhost:3000/mcp (hoặc host:port tùy chỉnh của bạn)
• MCP Inspector: Sử dụng npx @modelcontextprotocol/inspector http://localhost:3000/mcp để gỡ lỗi và kiểm tra

Tích hợp MCP Inspector

MCP Inspector là một công cụ mạnh mẽ để gỡ lỗi và kiểm tra máy chủ MCP. Khi chạy ở chế độ HTTP, bạn có thể sử dụng nó để:

• Kiểm tra các công cụ khả dụng và lược đồ của chúng
• Kiểm tra các lệnh gọi công cụ tương tác
• Gỡ lỗi truy cập tài nguyên và lời nhắc
• Giám sát thông báo thời gian thực

# 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 sẽ mở trong trình duyệt của bạn và cung cấp giao diện đầy đủ để khám phá và kiểm tra máy chủ MCP của bạn.

Lưu ý: Lệnh npm run inspector sử dụng mcp-test.json bao gồm 8 máy chủ MCP (tổng cộng 67 công cụ) từ các ví dụ chính thức, bao gồm cả máy chủ dựa trên TypeScript (npx) và Python (uvx).

Cấu hình

Tạo một tệp mcp.json để xác định các máy chủ MCP con nào cần kết nối. Tệp này tuân theo định dạng cấu hình máy khách MCP tiêu chuẩn:

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

Tùy chọn Cấu hình

Mỗi mục máy chủ hỗ trợ:

Đối với truyền tải stdio:

• command (bắt buộc) - Lệnh để thực thi (ví dụ: "node", "python", "npx")
• args (tùy chọn) - Mảng các đối số truyền cho lệnh
• env (tùy chọn) - Biến môi trường cho tiến trình con

Đối với truyền tải HTTP/SSE:

• url (bắt buộc) - URL điểm cuối HTTP
• transport - Đặt thành "sse" cho Server-Sent Events

Cách sử dụng

Khởi động Máy chủ

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

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

# Show help
mcpcodeserver --help

Sử dụng như một Máy chủ MCP

Cấu hình mcpcodeserver trong máy khách MCP của bạn (như Claude Desktop, Claude Code, Cline, v.v.):

Với npx (khuyến nghị - không cần cài đặt):

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

Từ GitHub (hoạt động ngay lập tức):

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

Với các trình quản lý gói khác:

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

Xem examples/ để biết thêm ví dụ cấu hình và thiết lập cụ thể cho từng máy khách MCP.

Công cụ 1: get_tool_definitions

Công cụ này trả về các định nghĩa kiểu TypeScript cho tất cả các công cụ được phát hiện từ các máy chủ con.

Đầu vào:

• include_examples (boolean tùy chọn) - Có bao gồm các ví dụ sử dụng hay không

Ví dụ:

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

Đầu ra: Trả về mã TypeScript với các giao diện và khai báo hàm:

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

Công cụ 2: generate_and_execute_code

Công cụ này thực thi mã TypeScript trong một hộp cát với quyền truy cập vào tất cả các hàm công cụ được phát hiện.

Đầu vào:

• code (chuỗi bắt buộc) - Mã TypeScript/JavaScript để thực thi
• timeout (số tùy chọn) - Thời gian thực thi tối đa tính bằng mili giây (mặc định: 30000, tối đa: 300000)

Ví dụ:

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

Đầu ra:

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

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

Môi trường Hộp cát

Hộp cát thực thi TypeScript cung cấp:

Có sẵn:

• Tất cả các hàm công cụ được phát hiện (dưới dạng hàm bất đồng bộ)
• Các phương thức console: console.log(), console.error(), console.warn(), console.info()
• Các biến toàn cục JavaScript cơ bản: Math, JSON, Date, Array, Object, String, Number, Boolean
• Hỗ trợ Promise và async/await
• Xử lý lỗi với try/catch
• Bộ định thời: setTimeout, setInterval, clearTimeout, clearInterval

Không có sẵn:

• Mô-đun Node.js (fs, http, child_process, v.v.)
• Truy cập hệ thống tệp (ngoại trừ thông qua các công cụ MCP)
• Truy cập mạng (ngoại trừ thông qua các công cụ MCP)
• Thông tin tiến trình

Lưu ý Bảo mật: Đây không phải là hộp cát an toàn tuyệt đối. Ngữ cảnh VM cung cấp sự cô lập nhưng không phải là bất khả xâm phạm. Chỉ thực thi mã đáng tin cậy.

Xử lý Lỗi

Các lỗi trong hộp cát được bắt và trả về kèm theo dấu vết ngăn xếp:

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

Kiểm thử với Claude Code

Bạn muốn dùng thử mcpcodeserver với Claude Code? Sử dụng thiết lập một lệnh duy nhất:

./setup-claude-code-test.sh

Lệnh này sẽ xây dựng dự án, cài đặt các phụ thuộc kiểm thử và hiển thị chính xác những gì bạn cần thêm vào cấu hình Claude Code. Xem TESTING_WITH_CLAUDE.md để biết hướng dẫn chi tiết.

Phát triển

# 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

Cấu trúc Dự án

Xem AGENTS.md để biết cấu trúc dự án chi tiết và tài liệu về các thành phần.

Trường hợp Sử dụng

Thao tác Đa tệp

Thay vì thực hiện nhiều lệnh gọi công cụ thông qua LLM, hãy viết mã:

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

Chuyển đổi Dữ liệu

Xử lý dữ liệu giữa các lệnh gọi công cụ mà không cần sự can thiệp của 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;

Logic Điều kiện

Đưa ra quyết định dựa trên kết quả công cụ:

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

Phục hồi Lỗi

Xử lý lỗi một cách nhẹ nhàng mà không hủy bỏ toàn bộ quy trình làm việc:

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;

Tích hợp Máy chủ MCP Thượng nguồn

mcpcodeserver có thể tích hợp với các máy chủ MCP thượng nguồn chính thức từ kho lưu trữ máy chủ Model Context Protocol. Điều này cho phép bạn sử dụng các máy chủ MCP thực tế, sẵn sàng cho sản xuất cùng với các công cụ tùy chỉnh của mình.

Các Máy chủ Thượng nguồn được Hỗ trợ

• filesystem: Thao tác hệ thống tệp (đọc, ghi, liệt kê thư mục)
• memory: Lưu trữ khóa-giá trị trong bộ nhớ
• sqlite: Thao tác cơ sở dữ liệu SQLite
• github: Tích hợp GitHub API
• brave-search: Khả năng tìm kiếm web
• fetch: Khả năng yêu cầu HTTP

Ví dụ Cấu hình

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

Kiểm thử Tích hợp Thượng nguồn

Dự án bao gồm các bài kiểm thử toàn diện cho tích hợp máy chủ thượng nguồn:

# 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

Quy trình làm việc Liên máy chủ

Với các máy chủ thượng nguồn, bạn có thể tạo ra các quy trình làm việc liên máy chủ mạnh mẽ:

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

Hạn chế

• Thời gian chờ thực thi: Tối đa 5 phút (có thể cấu hình, mặc định 30 giây)
• Bộ nhớ: Bị giới hạn bởi ngữ cảnh VM Node.js
• Không có trạng thái liên tục giữa các lần thực thi
• Không thể require/import các mô-đun bên ngoài
• Không phải hộp cát bảo mật - không chạy mã không đáng tin cậy

Đóng góp

Hoan nghênh đóng góp! Dự án này được xây dựng bằng:

• TypeScript 5.7+
• Node.js 18+
• MCP TypeScript SDK 1.20+
• Zod để xác thực

Xem CONTRIBUTING.md để biết hướng dẫn đóng góp chi tiết.

Hỗ trợ

Nếu bạn thấy dự án này hữu ích, hãy cân nhắc mua cho tôi một ly cà phê!

Giấy phép

MIT

Tài nguyên

• Đặc tả Model Context Protocol
• MCP TypeScript SDK
• Danh sách Máy chủ MCP