MCP Servers

Discover Awesome MCP Servers

Extend your agent with 16,166 capabilities via MCP servers.

All16,166

Crypto Fear & Greed Index MCP Server

一个 MCP 服务器，提供实时和历史加密货币恐惧与贪婪指数数据。

P-GitHubTestRepo

从 MCP 服务器演示创建。

slack-mcp-server

MCP Stock Market

一个模型上下文协议工具，用于使用 Alpha Vantage API 获取任何股票代码的每日股市数据。

mcp-server-weaviate

一个服务器，使 Claude AI 能够与 Weaviate 向量数据库交互，并通过 Anthropic 的 MCP 协议支持搜索和存储操作。

Runbook MCP server

Unity AI MCP Server

一个 MCP 服务器，为 Unity 游戏开发提供 AI 驱动的工具和助手，并与 Cursor IDE 集成。 (Alternatively, a slightly more formal translation could be:) 一个 MCP 服务器，旨在为 Unity 游戏开发提供人工智能驱动的工具和辅助功能，并与 Cursor IDE 进行集成。

Advanced PocketBase MCP Server

镜子 (jìng zi)

MCP Servers - OpenAI and Flux Integration

镜子 (jìng zi)

Todo Assistant with AI and Google Calendar Integration

基于人工智能的待办事项助手，集成了 Google 日历，并使用 OpenAI 的 API 和模型上下文协议 (MCP) 来支持自然语言任务管理。

Coco AI

Coco AI 应用 - 搜索、连接、协作，你专属的 AI 搜索和助手，尽在一个空间。

mcp-server-imessage

用于在 macOS 上与 iMessage 交互的 MCP 服务器

FindRepo MCP Server

🌐 Starknet MCP Server

Starknet MCP 服务器。

MongoDB MCP Server

镜子 (jìng zi)

Typescript Mcp Server Usage

Okay, I will provide you with a basic example of how to create an MCP (Minecraft Protocol) server using TypeScript. Keep in mind that building a full-fledged Minecraft server from scratch is a complex undertaking. This example will focus on the core networking and handshake aspects. You'll need to install some dependencies first. **1. Project Setup and Dependencies:** First, create a new TypeScript project: ```bash mkdir mcp-server cd mcp-server npm init -y npm install typescript ts-node ws --save npm install @types/node @types/ws --save-dev ``` * `ws`: A popular WebSocket library for Node.js. Minecraft uses a custom protocol over TCP, but WebSocket provides a convenient way to handle the underlying socket communication for this example. In a real Minecraft server, you'd implement the protocol directly over TCP. * `typescript`: The TypeScript compiler. * `ts-node`: Allows you to execute TypeScript files directly. * `@types/node`, `@types/ws`: TypeScript type definitions for Node.js and WebSocket, respectively. Create a `tsconfig.json` file: ```json { "compilerOptions": { "target": "es2017", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "resolveJsonModule": true }, "include": ["src/**/*"], "exclude": ["node_modules"] } ``` **2. `src/index.ts` (Main Server Code):** ```typescript import * as WebSocket from 'ws'; const PORT = 25565; // Or any port you prefer const wss = new WebSocket.Server({ port: PORT }, () => { console.log(`Server started on port ${PORT}`); }); wss.on('connection', ws => { console.log('Client connected'); ws.on('message', message => { // In a real Minecraft server, you'd parse the Minecraft protocol packets here. // This is a simplified example, so we're just echoing the message. console.log(`Received: ${message}`); // Example: Echo the message back to the client ws.send(`Server received: ${message}`); }); ws.on('close', () => { console.log('Client disconnected'); }); ws.on('error', error => { console.error('WebSocket error:', error); }); }); wss.on('error', error => { console.error('Server error:', error); }); console.log('MCP Server is starting...'); ``` **Explanation:** * **Import `ws`:** Imports the WebSocket library. * **`PORT`:** Defines the port the server will listen on. Minecraft's default port is 25565. * **`WebSocket.Server`:** Creates a new WebSocket server instance. * **`wss.on('connection', ...)`:** This is the core of the server. It's called whenever a new client connects. * `ws`: Represents the WebSocket connection to the client. * `ws.on('message', ...)`: Handles incoming messages from the client. **This is where you would implement the Minecraft protocol parsing and handling.** In this example, it simply logs the message and echoes it back. * `ws.on('close', ...)`: Handles client disconnections. * `ws.on('error', ...)`: Handles errors on the WebSocket connection. * **`wss.on('error', ...)`:** Handles errors on the server itself. **3. Building and Running:** 1. **Compile:** Run `npm run tsc` (or just `tsc` if you have it globally installed) to compile the TypeScript code into JavaScript. This will create a `dist` directory with the compiled `index.js` file. You might need to add `"build": "tsc"` to your `package.json` scripts section. 2. **Run:** Execute the server using `node dist/index.js` or `ts-node src/index.ts`. **Important Considerations and Next Steps (for a *real* Minecraft server):** * **Minecraft Protocol:** The code above uses WebSockets for simplicity. A *real* Minecraft server communicates using a custom binary protocol over TCP. You'll need to: * **Understand the Protocol:** Study the Minecraft protocol documentation (see links below). It involves packets with specific IDs, data types, and structures. * **Implement Packet Parsing/Serialization:** Write code to read incoming TCP data, parse it into Minecraft packets, and serialize packets to send back to the client. Libraries exist that can help with this, but you'll still need to understand the protocol. * **Handshake:** The initial connection involves a handshake where the client and server exchange protocol versions. You need to implement this handshake correctly. * **Authentication:** Minecraft servers typically require authentication. You'll need to handle login requests and verify user credentials. * **Game Logic:** This example has *no* game logic. You'll need to implement the core game mechanics: world generation, player movement, entity management, block updates, etc. * **Threading/Asynchronous Operations:** Minecraft servers are highly concurrent. You'll need to use threading or asynchronous programming (e.g., `async/await` in TypeScript) to handle multiple clients efficiently. * **World Storage:** You'll need a way to store the game world data (blocks, entities, etc.). This could involve files, databases, or other storage mechanisms. **Example of a very basic handshake (to illustrate the concept):** ```typescript // Inside the 'connection' handler: ws.on('message', message => { const buffer = Buffer.from(message); // Convert to Buffer for binary data // Example: Very basic handshake (replace with actual protocol parsing) if (buffer[0] === 0x00) { // Assuming 0x00 is a handshake packet ID const protocolVersion = buffer.readInt32BE(1); // Read protocol version const serverAddressLength = buffer.readInt8(5); const serverAddress = buffer.toString('utf8', 6, 6 + serverAddressLength); const serverPort = buffer.readUInt32BE(6 + serverAddressLength); const nextState = buffer.readInt8(10 + serverAddressLength); console.log(`Handshake: Protocol ${protocolVersion}, Address ${serverAddress}:${serverPort}, Next State ${nextState}`); // Send a response (e.g., a status response) const response = JSON.stringify({ version: { name: "My TypeScript Server", protocol: protocolVersion }, players: { max: 10, online: 0, sample: [] }, description: { text: "A simple TypeScript Minecraft server" } }); const responseBuffer = Buffer.from(response); const length = responseBuffer.length; const lengthBuffer = Buffer.alloc(1); lengthBuffer.writeInt8(length); ws.send(Buffer.concat([lengthBuffer, responseBuffer])); } else { console.log(`Received other message: ${message}`); } }); ``` **Important Resources:** * **Minecraft Protocol Documentation:** This is essential. Search for "Minecraft Protocol" or "wiki.vg Minecraft Protocol". `wiki.vg` is a good starting point. * **Existing Minecraft Server Implementations:** Look at open-source Minecraft server projects (e.g., in Java or other languages) to see how they handle the protocol and game logic. This can be a great learning resource. However, be aware that the protocol changes over time, so make sure the implementation you're looking at is relatively up-to-date. **Chinese Translation of Key Terms:** * **Minecraft Protocol:** 我的世界协议 (Wǒ de shìjiè xiéyì) * **Server:** 服务器 (Fúwùqì) * **Client:** 客户端 (Kèhùduān) * **Packet:** 数据包 (Shùjù bāo) * **Handshake:** 握手 (Wòshǒu) * **Authentication:** 身份验证 (Shēnfèn yànzhèng) * **WebSocket:** WebSocket (Websocket, no direct translation is commonly used) * **TCP:** TCP (TCP, no direct translation is commonly used) * **Port:** 端口 (Duānkǒu) * **Connection:** 连接 (Liánjiē) * **Message:** 消息 (Xiāoxī) * **Error:** 错误 (Cuòwù) * **Protocol Version:** 协议版本 (Xiéyì bǎnběn) This is a very basic starting point. Building a real Minecraft server is a significant project. Good luck!

YouTube Transcript Server

镜子 (jìng zi)