Discover Awesome MCP Servers

MCP server in Python

Okay, here's a translation of "Creating a barebones MCP server around python (plus uv), encapsulated in a nix flake": **Simplified Chinese:** 使用 Nix Flake 创建一个基于 Python (加上 uv) 的极简 MCP 服务器。 **Traditional Chinese:** 使用 Nix Flake 創建一個基於 Python (加上 uv) 的極簡 MCP 伺服器。 **Explanation of Choices:** * **"Creating a barebones MCP server"**: This is translated as "创建一个极简 MCP 服务器" (chuàngjiàn yī gè jíjiǎn MCP fúwùqì). * "Creating" -> "创建" (chuàngjiàn) - to create, to build * "barebones" -> "极简" (jíjiǎn) - extremely simple, minimal, barebones * "MCP server" -> "MCP 服务器" (MCP fúwùqì) - MCP server (transliterated and then added "server") * **"around python (plus uv)"**: This is translated as "基于 Python (加上 uv) 的" (jīyú Python (jiāshàng uv) de). * "around" -> "基于" (jīyú) - based on, built around * "python" -> "Python" (Python) - Python (transliterated) * "(plus uv)" -> "(加上 uv)" ((jiāshàng uv)) - (plus uv) - "加上" means "plus" or "adding". "uv" is kept as is, assuming it's a technical term. * "的" (de) - a possessive particle, making the phrase an adjective describing the server. * **"encapsulated in a nix flake"**: This is translated as "使用 Nix Flake" (shǐyòng Nix Flake). * "encapsulated in" -> "使用" (shǐyòng) - using, employing. While "encapsulated" could be translated more literally, in this context, "using Nix Flake" conveys the intended meaning of the Nix Flake providing the encapsulation. * "a nix flake" -> "Nix Flake" (Nix Flake) - Nix Flake (transliterated). **Why this translation is appropriate:** * **Technical Accuracy:** It uses the correct Chinese terms for technical concepts like "server" and transliterates "Python," "MCP," and "Nix Flake" appropriately. * **Conciseness:** It's a relatively short and direct translation, which is often preferred in technical contexts. * **Readability:** The sentence structure is natural and easy to understand for a Chinese speaker familiar with programming concepts. This translation should be suitable for most contexts where you need to communicate this idea in Chinese.

aivengers-mcp MCP server

使用 AIvengers 智能工具的 MCP 服务器，具有动态工具搜索/调用功能。

Template for Bun MCP Server

Okay, here's a template structure and some example code for a Bun + Minecraft Protocol (MCP) server project, along with explanations to get you started. This focuses on the core structure and handling basic connections. You'll need to adapt it based on the specific features you want to implement. **Project Structure:** ``` bun-mcp-server/ ├── src/ │ ├── index.ts # Main entry point │ ├── server.ts # Server logic (listening, connection handling) │ ├── protocol.ts # MCP packet handling (encoding/decoding) │ ├── player.ts # Player object/class │ ├── config.ts # Configuration loading │ └── utils.ts # Utility functions ├── package.json ├── bun.lockb ├── .gitignore └── README.md ``` **1. `package.json`:** ```json { "name": "bun-mcp-server", "version": "0.0.1", "description": "A Minecraft Protocol server written in Bun", "main": "src/index.ts", "scripts": { "start": "bun run src/index.ts", "dev": "bun run --watch src/index.ts" }, "dependencies": { // Add any dependencies here, e.g., for logging, configuration, etc. }, "devDependencies": { "@types/node": "^20.0.0" // Important for Node.js compatibility }, "type": "module" } ``` **Explanation:** * `name`, `version`, `description`: Standard package metadata. * `main`: Specifies the entry point of your application. * `scripts`: Defines commands for running and developing your server. `bun run src/index.ts` starts the server. `bun run --watch src/index.ts` starts the server in watch mode, automatically restarting when files change. * `dependencies`: List any external libraries your project uses. You'll likely need libraries for more advanced features (e.g., logging, configuration parsing). * `devDependencies`: Development-time dependencies, like TypeScript type definitions. `@types/node` is crucial for compatibility with Node.js APIs that Bun supports. * `type": "module"`: This is *essential* for using ES modules (import/export syntax) in Bun. **2. `src/index.ts` (Main Entry Point):** ```typescript import { startServer } from './server'; import { loadConfig } from './config'; async function main() { try { const config = await loadConfig(); // Load configuration console.log("Configuration loaded:", config); startServer(config); // Start the server } catch (error) { console.error("Error starting server:", error); } } main(); ``` **Explanation:** * This is the starting point of your application. * It imports the `startServer` function from `server.ts` and `loadConfig` from `config.ts`. * It calls `loadConfig` to load the server configuration. * It calls `startServer` to start the server, passing the configuration. * It includes error handling to catch any errors that occur during startup. **3. `src/server.ts` (Server Logic):** ```typescript import { listen } from 'bun'; import { handleConnection } from './protocol'; import { ServerConfig } from './config'; export function startServer(config: ServerConfig) { console.log(`Starting server on ${config.host}:${config.port}`); Bun.serve({ fetch(req, server) { if (server.upgrade(req)) { // handle WebSocket request return undefined; } return new Response("Upgrade failed :(", { status: 500 }); }, websocket: { open(ws) { console.log("Client connected"); handleConnection(ws); // Handle the new connection }, message(ws, message) { // Handle WebSocket message console.log(`Received message: ${message}`); }, close(ws, code, message) { console.log(`Client disconnected with code ${code} and message ${message}`); }, error(ws, error) { console.error("WebSocket error:", error); }, }, port: config.port, hostname: config.host, }); console.log("Server started"); } ``` **Explanation:** * This file contains the core server logic. * `startServer` function takes a `config` object (defined in `config.ts`). * It uses `Bun.serve` to create an HTTP server that listens for incoming connections. * The `fetch` function handles HTTP requests and upgrades them to WebSockets. * The `websocket` object defines the WebSocket event handlers: * `open`: Called when a new WebSocket connection is established. It calls `handleConnection` to process the connection. * `message`: Called when a WebSocket message is received. This is where you'll handle incoming MCP packets. * `close`: Called when a WebSocket connection is closed. * `error`: Called when a WebSocket error occurs. * The server listens on the port and hostname specified in the configuration. **4. `src/protocol.ts` (MCP Packet Handling):** ```typescript import { WebSocket } from 'bun'; import { Player } from './player'; export function handleConnection(ws: WebSocket) { console.log("Handling new connection..."); const player = new Player(ws); // Create a new player object ws.addEventListener("message", (event) => { const message = event.data; if (typeof message === "string") { console.log(`Received text message: ${message}`); } else if (message instanceof ArrayBuffer) { // Handle binary data (MCP packets) const buffer = new Uint8Array(message); console.log(`Received binary message: ${buffer}`); // TODO: Decode the MCP packet and process it // Example: // const packetId = buffer[0]; // switch (packetId) { // case 0x00: // Handshake // handleHandshake(buffer, player); // break; // // ... other packet types // default: // console.warn(`Unknown packet ID: ${packetId}`); // } } else { console.log(`Received unknown message type: ${typeof message}`); } }); ws.addEventListener("close", () => { console.log("Connection closed"); // Clean up player data }); ws.addEventListener("error", (error) => { console.error("WebSocket error:", error); }); } // Example Handshake handler (replace with actual MCP logic) function handleHandshake(buffer: Uint8Array, player: Player) { // TODO: Implement handshake logic based on the MCP protocol console.log("Handling handshake packet"); // Example: Read protocol version, server address, and next state from the buffer // const protocolVersion = buffer.readInt32BE(1); // Example: Read from offset 1 // ... } ``` **Explanation:** * This file handles the Minecraft Protocol (MCP) logic. * `handleConnection` is called when a new WebSocket connection is established. * It creates a `Player` object to represent the connected player. * It sets up event listeners for the WebSocket: * `message`: This is the most important part. It receives incoming messages from the client. You'll need to: * Check if the message is a string or an `ArrayBuffer`. MCP packets are binary data (ArrayBuffer). * Decode the MCP packet. This involves reading the packet ID and any data associated with the packet. * Process the packet based on its ID. This might involve updating the player's state, sending data to other players, etc. * `close`: Called when the connection is closed. You'll need to clean up any player data. * `error`: Called when an error occurs. * The `handleHandshake` function is a placeholder. You'll need to implement the actual handshake logic based on the MCP protocol. The handshake is the first packet sent by the client and is used to establish the connection. **5. `src/player.ts` (Player Class):** ```typescript import { WebSocket } from 'bun'; export class Player { socket: WebSocket; username: string | null = null; // Add other player properties here (e.g., position, health, inventory) constructor(socket: WebSocket) { this.socket = socket; } send(data: Uint8Array) { if (this.socket.readyState === WebSocket.OPEN) { this.socket.send(data); } else { console.warn("Socket is not open, cannot send data"); } } // Add methods for updating player state, sending packets, etc. } ``` **Explanation:** * This file defines the `Player` class, which represents a connected player. * It stores the player's WebSocket connection, username, and other properties. * The `send` method sends data to the player's client. * You'll need to add methods for updating the player's state, sending packets, and handling other player-related logic. **6. `src/config.ts` (Configuration):** ```typescript import { readFile } from 'node:fs/promises'; // Use Node.js fs/promises for file reading export interface ServerConfig { host: string; port: number; motd: string; // Message of the Day maxPlayers: number; } const defaultConfig: ServerConfig = { host: '0.0.0.0', port: 25565, motd: 'A Bun Minecraft Server', maxPlayers: 20, }; export async function loadConfig(): Promise<ServerConfig> { try { // Attempt to load from config.json const configFile = await readFile('config.json', 'utf-8'); const parsedConfig = JSON.parse(configFile) as Partial<ServerConfig>; // Merge with defaults, overriding with values from config.json return { ...defaultConfig, ...parsedConfig }; } catch (error) { console.warn("Failed to load config.json, using default configuration:", error); return defaultConfig; } } ``` **Explanation:** * This file handles loading the server configuration. * The `ServerConfig` interface defines the structure of the configuration object. * `defaultConfig` provides default values for the configuration. * `loadConfig` attempts to load the configuration from a `config.json` file. If the file doesn't exist or is invalid, it uses the default configuration. * It uses `node:fs/promises` to read the file asynchronously. This is important for performance. **7. `config.json` (Example Configuration File):** ```json { "port": 25566, "motd": "My Awesome Bun Server!" } ``` **8. `src/utils.ts` (Utility Functions):** ```typescript // Example utility function (add more as needed) export function hexEncode(data: Uint8Array): string { return Array.from(data) .map(byte => byte.toString(16).padStart(2, '0')) .join(''); } ``` **9. `.gitignore`:** ``` node_modules bun.lockb ``` **Key Concepts and Next Steps:** 1. **Minecraft Protocol (MCP):** This is the most important part. You *must* understand the MCP to build a functional server. Refer to the official Minecraft Protocol documentation (search for "Minecraft Protocol" or "wiki.vg/Protocol"). Pay close attention to: * **Packet IDs:** Each packet has a unique ID that identifies its type. * **Data Types:** The MCP uses specific data types (e.g., VarInt, VarLong, strings, integers, booleans). You'll need to read and write these data types correctly. * **Packet Structure:** Each packet has a specific structure, with fields in a defined order. * **State Machine:** The protocol operates in different states (Handshaking, Status, Login, Play). You need to handle packets differently depending on the current state. 2. **Binary Data Handling:** MCP packets are binary data. You'll need to use `Uint8Array` and `DataView` to read and write data to the buffers. 3. **VarInt and VarLong:** These are variable-length integers used in the MCP. You'll need to implement functions to read and write them. 4. **Asynchronous Operations:** Bun is designed for asynchronous operations. Use `async/await` and Promises to handle network I/O efficiently. 5. **Error Handling:** Implement robust error handling to catch and log errors. 6. **Logging:** Use a logging library to log important events and errors. 7. **Configuration:** Use a configuration file to store server settings (e.g., port, MOTD, max players). 8. **Player Management:** Keep track of connected players and their state. 9. **World Management:** Implement world loading, saving, and generation. 10. **Game Logic:** Implement the game logic (e.g., player movement, block placement, entity spawning). **Example: Reading a VarInt (Important for MCP):** ```typescript function readVarInt(buffer: Uint8Array, offset: number): { value: number, bytesRead: number } { let result = 0; let shift = 0; let bytesRead = 0; while (true) { const byte = buffer[offset + bytesRead]; bytesRead++; if (byte === undefined) { throw new Error("Incomplete VarInt"); } result |= (byte & 0x7F) << shift; shift += 7; if (!(byte & 0x80)) { return { value: result, bytesRead: bytesRead }; } if (shift > 35) { throw new Error("VarInt is too big"); } } } ``` **Example: Writing a VarInt:** ```typescript function writeVarInt(value: number): Uint8Array { const buffer: number[] = []; while (true) { const byte = value & 0x7F; value >>>= 7; if (value !== 0) { buffer.push(byte | 0x80); } else { buffer.push(byte); break; } } return new Uint8Array(buffer); } ``` **How to Run:** 1. **Install Bun:** Follow the instructions on the official Bun website ([https://bun.sh/](https://bun.sh/)). 2. **Create the Project:** Create the directory structure and files as described above. 3. **Install Dependencies:** Run `bun install` in the project directory. 4. **Start the Server:** Run `bun run start` or `bun run dev` in the project directory. **Important Considerations for Bun:** * **Node.js Compatibility:** Bun aims to be compatible with Node.js APIs, but there may be differences. Test your code thoroughly. * **WebSockets:** Bun has excellent WebSocket support. * **Performance:** Bun is designed for performance. Take advantage of its features to optimize your server. This template provides a solid foundation for building a Bun + MCP server. Remember to consult the Minecraft Protocol documentation and adapt the code to your specific needs. Good luck! **Chinese Translation of Key Terms:** * **Minecraft Protocol (MCP):** Minecraft 协议 (Minecraft Xiéyì) * **Packet:** 数据包 (Shùjùbāo) * **Server:** 服务器 (Fúwùqì) * **Client:** 客户端 (Kèhùduān) * **WebSocket:** WebSocket (pronounced the same in Chinese) * **Handshake:** 握手 (Wòshǒu) * **VarInt:** 变长整数 (Biàncháng Zhěngshù) * **Configuration:** 配置 (Pèizhì) * **Player:** 玩家 (Wánjiā) * **World:** 世界 (Shìjiè) * **MOTD (Message of the Day):** 每日消息 (Měirì Xiāoxī) or 服务器标语 (Fúwùqì Biāoyǔ) * **ArrayBuffer:** 数组缓冲区 (Shùzǔ Huǎnchōngqū) * **Uint8Array:** 8位无符号整数数组 (8 Wèi Wúfúhào Zhěngshù Shùzǔ) This should give you a good start. Let me know if you have any more questions!

Minesweeper MCP Server 🚀

一个用于玩扫雷的 MCP 服务器

mcp_rs_testWhat is MCP RS Test?How to use MCP RS Test?Key features of MCP RS Test?Use cases of MCP RS Test?FAQ from MCP RS Test?

用 Rust 实现 MCP 服务器

Kafka MCP Server

镜子 (jìng zi)

MCP Server Neurolorap

镜子 (jìng zi)

mcp-server-notifier

轻量级 Node.js 服务器，用于发送 Webhook 通知。非常适合在多项目中使用 AI 代理（例如 Cursor）的开发者，可在任务完成时发出警报，以便高效切换。功能包括 Webhook 警报、多项目开发、AI 集成，以及为开发工具和自动化提供的简易设置。

Anti-Bullshit MCP Server

镜子 (jìng zi)

mcp-taskwarrior

Taskwarrior 的一个简单的 MCP 服务器

Jira communication server MCP Server

镜子 (jìng zi)

mcp-all

使用 Spring AI 构建 MCP 服务器和客户端

WordPress MCP Server

镜子 (jìng zi)

Central MCP Host

将 MCP 服务器集中化，使其在家庭实验室中运行，而不是在每台机器上单独运行。

Twilio Messaging MCP Server

镜子 (jìng zi)

WebSockets MCP Math Demo

使用持久对象进行状态跟踪的 MCP 客户端/服务器演示

mcp-jira-server

MCP Jira 服务器 (MCP Jira fúwùqì)

Workers MCP Server

镜子 (jìng zi)

MCP Server Logger

好的，这是将 "console.log for your stdio MCP server" 翻译成中文的几种方式，根据不同的语境，表达的侧重点会有所不同： **1. 最直接的翻译 (偏技术):** * **为你的标准输入/输出 MCP 服务器使用 console.log** * 这种翻译比较直白，适合技术文档或者代码注释。 **2. 更自然的翻译 (强调调试):** * **使用 console.log 来调试你的标准输入/输出 MCP 服务器** * 这种翻译暗示了 `console.log` 的用途是调试。 **3. 更加简洁的翻译 (口语化):** * **在你的标准输入/输出 MCP 服务器中使用 console.log 输出信息** * 这种翻译更加口语化，更容易理解。 **4. 如果 MCP 服务器是你的项目，可以这样翻译：** * **在我的标准输入/输出 MCP 服务器中使用 console.log** * 这种翻译更强调所有权。 **选择哪个翻译取决于你想要表达的具体含义和目标读者。** 总的来说，我推荐使用 **“为你的标准输入/输出 MCP 服务器使用 console.log”** 或者 **“使用 console.log 来调试你的标准输入/输出 MCP 服务器”**，因为它们比较准确地表达了原文的意思。

Admin Transactions MCP

通过 MCP 服务器暴露 ZoomRx AP API

Claude MCP Server Collection

Okay, here's a translation of "MCP Server implementation for Claude" into Chinese, along with some considerations for choosing the best translation: **Option 1 (Most Literal):** * **克劳德的 MCP 服务器实现 (Kèláodé de MCP fúwùqì shíxiàn)** * This is the most direct translation. * *克劳德 (Kèláodé)* is the transliteration of "Claude." * *的 (de)* is the possessive particle ("of"). * *MCP 服务器 (MCP fúwùqì)* is "MCP Server." * *实现 (shíxiàn)* is "implementation." **Option 2 (Slightly More Natural, Assuming "Claude" is a System/Project Name):** * **为克劳德实现的 MCP 服务器 (Wèi Kèláodé shíxiàn de MCP fúwùqì)** * This translates to "MCP Server implemented for Claude." * *为 (wèi)* means "for" or "in order to." This implies the server implementation is *specifically* designed for Claude. **Option 3 (If "Claude" is a Person's Name):** * **为克劳德开发的 MCP 服务器实现 (Wèi Kèláodé kāifā de MCP fúwùqì shíxiàn)** * This translates to "MCP Server implementation developed for Claude." * *开发 (kāifā)* means "developed." This is suitable if Claude is a person who is having the server implemented for them. **Option 4 (More Contextual, if "Claude" is a specific technology/product):** * **用于克劳德的 MCP 服务器实现 (Yòng yú Kèláodé de MCP fúwùqì shíxiàn)** * This translates to "MCP Server implementation for use with Claude." * *用于 (yòng yú)* means "for use with" or "intended for." This is a good choice if "Claude" is a technology or product that the MCP server will interact with. **Which option is best depends on the context:** * **If "Claude" is simply a name (of a project, system, or person), Option 1 or 2 is likely the best.** Option 2 is slightly more natural-sounding. * **If "Claude" is a person who *commissioned* the implementation, Option 3 is suitable.** * **If "Claude" is a technology or product that the MCP server will *integrate with*, Option 4 is the most appropriate.** **Recommendation:** Without more context, I would recommend **Option 2: 为克劳德实现的 MCP 服务器 (Wèi Kèláodé shíxiàn de MCP fúwùqì)**. It's a good balance of accuracy and naturalness. However, *please* consider the context of "Claude" to choose the most accurate translation.

Taskqueue

用于“驯服 Claude”的 MCP 服务器，带有结构化的任务队列。

MCP Atlassian

用于与 Atlassian 产品（Confluence 和 Jira）集成的模型上下文协议服务器，支持 Atlassian Cloud 和 Server/Data Center 部署。

LND MCP Server

一个使用自然语言查询闪电网络 (LND) 节点数据的模型上下文协议 (MCP)。 (Alternatively, depending on the specific context and intended audience, you could also translate it as:) 用于使用自然语言查询闪电网络 (LND) 节点数据的模型上下文协议 (MCP)。

Email sending MCP 💌

一个简单的 MCP (可能是指 Mod Configuration Panel 或其他缩写，请根据上下文确认) 服务器，它允许用户使用 Resend 的 API 发送电子邮件，并与 Cursor 和 Claude Desktop 等工具集成，实现无缝的邮件撰写和发送。 (Alternatively, if MCP refers to something else, please provide more context so I can provide a more accurate translation.)

Ummon

使用知识图谱解锁代码洞察：将代码与概念连接，轻松查询，增强 AI 辅助能力。

mcp-server-duckdb

镜子 (jìng zi)

Azure Revisor MCP Server

一个与 Cursor IDE 集成的服务器，为 Azure 仓库提供代码审查功能，从而实现 AI 驱动的拉取请求分析和反馈。