发现优秀的 MCP 服务器

Unleash Mcp

一个与 Unleash Feature Toggle 系统集成的模型上下文协议 (MCP) 服务器实现。

n8n-mcp-server

用于 n8n 工作流自动化的模型-控制器-提供者 (MCP) 服务器实现

MCP Tradovate Server

Tradovate平台的MCP服务器

Token Info MCP

MCP 服务器用于检查 Betha 的 OAuth 令牌

MCP Server

这是一个用于 MCP 服务器的仓库。

iMessage Query MCP Server

镜子 (jìng zi)

多语言本地化翻译工具

一个简单的 MCP (机器翻译平台) 服务器，可以实现单个文件或目录的翻译功能，仅支持 JSON 数据 (JSON、JS、TS 格式)。它能根据文件名自动提取翻译的目标语言，从而实现自动化处理。

solon-ai-mcp-embedded-examples

Solon AI MCP 嵌入式示例

Deno MCP Template Repo

一个使用 Deno 编写和发布 MCP 服务器的模板仓库。

Cursor Self-Meta.

一个基于 stdio 的 Perl MCP 服务器实现，它允许以光标逐字访问其自身的内部状态。

GitHub Agentic Chat MCP Server

使用 Go 语言实现的 GitHub Agentic Chat 的 MCP 服务器

Mcp-server-v2ex

Okay, here's a simplified explanation of how to build a basic Minecraft Protocol (MCP) server using TypeScript, focusing on the core concepts and a minimal example. Keep in mind that a full MCP server is a complex undertaking, and this is just a starting point. **Conceptual Overview** 1. **Minecraft Protocol (MCP):** Minecraft clients and servers communicate using a specific binary protocol. You need to understand the structure of packets (data messages) defined by this protocol. The protocol changes with each Minecraft version. [Wiki.vg](https://wiki.vg/Protocol) is *the* resource for protocol information. 2. **TCP Socket Server:** Your server will listen for incoming TCP connections from Minecraft clients. 3. **Packet Handling:** When a client connects, your server needs to: * Receive data from the socket. * Parse the data into MCP packets. * Process the packets (e.g., handle handshake, login, player movement). * Construct appropriate response packets. * Send the response packets back to the client. 4. **TypeScript:** TypeScript adds static typing to JavaScript, making your code more maintainable and easier to reason about. **Simplified Example (Conceptual - Requires Libraries)** This example outlines the basic structure. You'll need to install libraries for socket handling, data serialization/deserialization (for MCP packets), and potentially logging. ```typescript import * as net from 'net'; // You'll need to install a library for handling Minecraft packets. // Example: npm install prismarine-packet // import { createSerializer, createDeserializer } from 'prismarine-packet'; const serverPort = 25565; // Default Minecraft port // Basic server information (for the server list ping) const serverDescription = "My Simple TS Server"; const maxPlayers = 10; const onlinePlayers = 0; const protocolVersion = 763; // Example: Minecraft 1.17.1 protocol version const minecraftVersion = "1.17.1"; // Create the TCP server const server = net.createServer((socket) => { console.log('Client connected:', socket.remoteAddress, socket.remotePort); // **Packet Handling (Simplified)** socket.on('data', (data) => { // In a real server, you'd: // 1. Deserialize the data into a Minecraft packet. // 2. Determine the packet type (e.g., Handshake, Login Start). // 3. Process the packet based on its type. // 4. Construct a response packet. // 5. Serialize the response packet. // 6. Send the serialized data back to the client. // **Extremely Simplified Example: Responding to a Handshake (Very Incomplete)** // This is just to illustrate the concept. It's not a complete handshake implementation. const packetId = data[0]; // Assuming the first byte is the packet ID if (packetId === 0x00) { // Handshake packet ID (This is version-dependent!) console.log("Received Handshake"); // **In reality, you'd parse the handshake data to get the protocol version, server address, and port.** // **Create a Status Response (Server List Ping)** const statusResponse = { version: { name: minecraftVersion, protocol: protocolVersion }, players: { max: maxPlayers, online: onlinePlayers, sample: [] // Player list (optional) }, description: { text: serverDescription } }; // **Serialize the status response to JSON** const statusResponseJson = JSON.stringify(statusResponse); // **Create the Status Response packet (0x00)** // **This is where you'd use a proper packet serialization library.** // **The following is a placeholder and WILL NOT WORK without proper serialization.** const responsePacket = Buffer.from([ 0x00, // Packet ID (Status Response) statusResponseJson.length, // Length of the JSON string (This needs to be properly encoded) ...Buffer.from(statusResponseJson, 'utf8') // The JSON string itself ]); // Send the response socket.write(responsePacket); // Request socket.once('data', (requestData) => { if (requestData[0] === 0x00) { console.log("Received Request"); const pongResponse = Buffer.from([ 0x01, // Pong packet ID 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // Payload (timestamp) ]); socket.write(pongResponse); socket.end(); } }); } else { console.log("Received unknown packet ID:", packetId); } }); socket.on('close', () => { console.log('Client disconnected:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Socket error:', err); }); }); // Start the server server.listen(serverPort, () => { console.log(`Server listening on port ${serverPort}`); }); ``` **Important Considerations and Next Steps** * **Minecraft Protocol Library:** You *absolutely* need a library to handle the Minecraft protocol. `prismarine-packet` is a popular choice, but there are others. This library will handle the complex serialization and deserialization of packets. Install it with `npm install prismarine-packet`. You'll need to adapt the example code to use the library's functions. * **Protocol Version:** The Minecraft protocol changes with each version. Make sure you're using the correct protocol version for the Minecraft client you're testing with. [Wiki.vg](https://wiki.vg/Protocol_version_IDs) lists protocol version IDs. * **Error Handling:** The example has minimal error handling. You need to add robust error handling to catch exceptions and prevent your server from crashing. * **Asynchronous Operations:** Use `async/await` or Promises to handle asynchronous operations (like socket reads and writes) properly. * **State Management:** You'll need to manage the state of each connected client (e.g., their username, position, inventory). * **Security:** Implement security measures to prevent exploits and attacks. * **World Generation:** If you want a playable world, you'll need to implement world generation. * **Multiplayer:** Handling multiple players concurrently adds significant complexity. **How to Run** 1. **Install Node.js:** Make sure you have Node.js installed. 2. **Create a Project:** Create a directory for your project and run `npm init -y` to create a `package.json` file. 3. **Install Dependencies:** `npm install net prismarine-packet` (or your chosen packet library). You might need other dependencies as you develop. 4. **Save the Code:** Save the TypeScript code as a `.ts` file (e.g., `server.ts`). 5. **Compile:** Compile the TypeScript code to JavaScript: `tsc server.ts` (you might need to configure `tsconfig.json` first). 6. **Run:** Run the server: `node server.js` **In summary, this is a very basic outline. Building a real Minecraft server is a significant project. Start small, focus on understanding the protocol, and use libraries to help you.**

MCP Local Router

一个 MCP（模型上下文协议）本地路由器，用作 MCP 服务器的聚合代理。

marker-mcp

A

WordPress MCP Server

用于向 WordPress 站点发布内容的机器通信协议 (MCP) 服务器

MCP Server Nekzus

镜子 (jìng zi)

Coder Toolbox MCP Server

镜子 (jìng zi)

MCP Multi-Server Demo with SSE Transport

Okay, here's a translation of the English text "Example of using MCP servers, both over sdio + sse. Also using langchain-mcp" into Chinese, along with some context and possible variations depending on the specific meaning you want to convey: **Translation:** **Option 1 (More Literal):** * **使用MCP服务器的示例，包括通过SDIO + SSE的方式。同时使用langchain-mcp。** * (Shǐyòng MCP fúwùqì de shìlì, bāokuò tōngguò SDIO + SSE de fāngshì. Tóngshí shǐyòng langchain-mcp.) This is a fairly direct translation. It's understandable but might sound a bit technical to someone not familiar with the terms. **Option 2 (Slightly More Natural, Emphasizing Usage):** * **关于使用MCP服务器的例子，包括通过SDIO和SSE两种方式。此外，还使用了langchain-mcp。** * (Guānyú shǐyòng MCP fúwùqì de lìzi, bāokuò tōngguò SDIO hé SSE liǎng zhǒng fāngshì. Cǐwài, hái shǐyòng le langchain-mcp.) This version uses "关于...的例子" (guānyú...de lìzi) which means "an example about..." and "两种方式" (liǎng zhǒng fāngshì) which means "two ways/methods". It flows a little better. **Option 3 (If you want to emphasize the "and" in "SDIO + SSE"):** * **使用MCP服务器的示例，包括通过SDIO *以及* SSE的方式。同时使用langchain-mcp。** * (Shǐyòng MCP fúwùqì de shìlì, bāokuò tōngguò SDIO *yǐjí* SSE de fāngshì. Tóngshí shǐyòng langchain-mcp.) Using "以及" (yǐjí) instead of just "+" emphasizes that both SDIO and SSE are being used. **Explanation of Terms and Considerations:** * **MCP Server (MCP服务器):** This is generally understood as is. If you're in a very specific context, you might need to elaborate on what "MCP" stands for. * **SDIO (SDIO):** This is a standard abbreviation and is usually kept as is in Chinese technical documentation. * **SSE (SSE):** Similar to SDIO, this is usually kept as is. Again, if the audience is unfamiliar, you might need to explain what it stands for (Streaming SIMD Extensions). * **langchain-mcp (langchain-mcp):** This is likely a specific library or tool. Keep it as is. **Which option is best?** The best option depends on your audience and the context. If you're writing for a technical audience familiar with the terms, Option 1 is fine. If you want a slightly more natural flow, Option 2 is better. If you want to emphasize the "and" between SDIO and SSE, use Option 3. **In summary, I recommend Option 2 as a good balance of accuracy and readability:** * **关于使用MCP服务器的例子，包括通过SDIO和SSE两种方式。此外，还使用了langchain-mcp。** Remember to consider your audience and the specific context when choosing the best translation. If you can provide more context about what you're trying to communicate, I can refine the translation further.

Project Hub MCP Server

镜子 (jìng zi)

Model Context Protocol (MCP) Server

镜子 (jìng zi)

MCP Servers Collection

用于增强 Claude 在 Cursor IDE 中能力的模型上下文协议 (MCP) 服务器集合

ICICI Direct MCP Server

学习 (xuéxí)