发现优秀的 MCP 服务器

MCP DateTime Server

Provides current local datetime information with timezone support. Serves as a minimal blueprint for building simple, single-purpose MCP servers.

Image Process MCP Server

That's a good translation! It's accurate and concise. Here are a couple of minor variations, depending on the nuance you want to convey: * **More literal:** 一个使用 Sharp 库提供图像处理功能的图像处理 MCP 服务器。 (This is closer to a word-for-word translation.) * **Slightly more natural flow:** 这是一个基于 Sharp 库的图像处理 MCP 服务器，用于提供图像处理功能。 (This emphasizes that the server is *based on* the Sharp library.) All three are perfectly understandable. Your original translation is excellent.

Spiral MCP Server

一个模型上下文协议（Model Context Protocol）服务器实现，它为与 Spiral 的语言模型交互提供了一个标准化的接口，并提供从提示词、文件或 Web URL 生成文本的工具。

UK Bus Departures MCP Server

Enables users to get real-time UK bus departure information and validate bus stop ATCO codes by scraping bustimes.org. Provides structured data including service numbers, destinations, scheduled and expected departure times for any UK bus stop.

mcp_server

Okay, I understand. You want me to describe how to implement a "weather MCP server" that can be called by a client IDE like Cursor. Here's a breakdown of the concept, implementation considerations, and a simplified example (using Python and a basic HTTP API) to illustrate the core ideas. **What is an MCP Server (in this context)?** In this scenario, "MCP" likely refers to a *Microservice Communication Protocol* or a similar concept. It means you're building a small, independent service (the weather server) that provides weather information and communicates with other applications (like the Cursor IDE) using a defined protocol. In practice, this often translates to a RESTful API over HTTP. **Key Components** 1. **Weather Data Source:** * This is where your server gets the actual weather information. You'll likely use a third-party weather API (e.g., OpenWeatherMap, AccuWeather, WeatherAPI.com). These APIs typically require you to sign up for an account and obtain an API key. * Consider caching the weather data to reduce the number of API calls and improve response times. 2. **Server-Side Implementation (e.g., Python with Flask/FastAPI):** * This is the core of your weather server. It handles incoming requests, fetches weather data from the data source, and formats the response. * **Framework Choice:** * **Flask:** A lightweight and flexible framework, good for simple APIs. * **FastAPI:** A modern, high-performance framework with automatic data validation and API documentation (using OpenAPI/Swagger). Generally preferred for new projects. * **API Endpoints:** You'll define endpoints like: * `/weather?city={city_name}`: Returns weather information for a specific city. * `/weather?zip={zip_code}`: Returns weather information for a specific zip code. * `/forecast?city={city_name}`: Returns a weather forecast for a specific city. 3. **Client-Side Integration (in Cursor IDE):** * The Cursor IDE (or any other client) will need to make HTTP requests to your weather server's API endpoints. * This might involve writing code within Cursor (e.g., using JavaScript or Python within a Cursor extension) to: * Get user input (e.g., the city name). * Construct the API request URL. * Send the request to the weather server. * Parse the JSON response from the server. * Display the weather information in the Cursor IDE. **Implementation Steps (Simplified Example with Python and Flask)** **1. Set up your environment:** ```bash # Create a project directory mkdir weather_server cd weather_server # Create a virtual environment (recommended) python3 -m venv venv source venv/bin/activate # On Linux/macOS # venv\Scripts\activate # On Windows # Install Flask and requests (for making HTTP requests to the weather API) pip install Flask requests ``` **2. `weather_server.py` (Flask Server):** ```python from flask import Flask, request, jsonify import requests import os app = Flask(__name__) # Replace with your actual OpenWeatherMap API key API_KEY = os.environ.get("OPENWEATHERMAP_API_KEY") or "YOUR_OPENWEATHERMAP_API_KEY" # Get from environment variable or hardcode (not recommended for production) BASE_URL = "https://api.openweathermap.org/data/2.5/weather" def get_weather_data(city): """Fetches weather data from OpenWeatherMap.""" params = { "q": city, "appid": API_KEY, "units": "metric", # Use Celsius } try: response = requests.get(BASE_URL, params=params) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() return data except requests.exceptions.RequestException as e: print(f"Error fetching weather data: {e}") return None @app.route("/weather") def weather(): """API endpoint to get weather by city.""" city = request.args.get("city") if not city: return jsonify({"error": "City parameter is required"}), 400 weather_data = get_weather_data(city) if weather_data: # Extract relevant information temperature = weather_data["main"]["temp"] description = weather_data["weather"][0]["description"] humidity = weather_data["main"]["humidity"] wind_speed = weather_data["wind"]["speed"] return jsonify({ "city": city, "temperature": temperature, "description": description, "humidity": humidity, "wind_speed": wind_speed }) else: return jsonify({"error": "Could not retrieve weather data for that city"}), 500 if __name__ == "__main__": app.run(debug=True) # Don't use debug=True in production! ``` **3. Running the Server:** ```bash # Set your OpenWeatherMap API key (replace with your actual key) export OPENWEATHERMAP_API_KEY="YOUR_OPENWEATHERMAP_API_KEY" # Linux/macOS # set OPENWEATHERMAP_API_KEY="YOUR_OPENWEATHERMAP_API_KEY" # Windows # Run the Flask server python weather_server.py ``` **4. Example Client-Side Code (Conceptual - in Cursor IDE):** This is a *very* simplified example of how you *might* integrate this into Cursor. The exact implementation will depend on Cursor's extension API and how you want to display the information. This assumes you can execute JavaScript or Python code within Cursor. ```javascript // Example JavaScript code (Conceptual - adapt to Cursor's API) async function getWeather(city) { const apiUrl = `http://127.0.0.1:5000/weather?city=${city}`; // Replace with your server's address try { const response = await fetch(apiUrl); const data = await response.json(); if (response.ok) { // Display the weather information in the Cursor IDE console.log(`Weather in ${data.city}:`); console.log(`Temperature: ${data.temperature}°C`); console.log(`Description: ${data.description}`); console.log(`Humidity: ${data.humidity}%`); console.log(`Wind Speed: ${data.wind_speed} m/s`); // You'd need to use Cursor's API to actually display this in the editor or a panel. // For example, Cursor might have a function like: // cursor.showInformationMessage(`Weather in ${data.city}: ...`); } else { console.error(`Error: ${data.error}`); // Display an error message in Cursor } } catch (error) { console.error("Error fetching weather:", error); // Display a network error in Cursor } } // Example usage: const cityName = "London"; // Or get the city from user input in Cursor getWeather(cityName); ``` **Explanation and Improvements** * **Error Handling:** The code includes basic error handling (checking for API errors, missing city parameter). Robust error handling is crucial for production. * **API Key Security:** *Never* hardcode your API key directly in the code, especially if you're sharing it. Use environment variables (as shown) or a configuration file. * **Asynchronous Operations:** Use `async/await` (as in the JavaScript example) to avoid blocking the UI thread while waiting for the API response. * **Data Validation:** Use a library like `marshmallow` (in Python) or a similar validation library in your chosen language to validate the data received from the weather API. This helps prevent unexpected errors. * **Caching:** Implement caching to store frequently accessed weather data. This reduces the load on the weather API and improves response times. You could use a simple in-memory cache (for small-scale deployments) or a more robust caching solution like Redis or Memcached. * **Rate Limiting:** Be aware of the rate limits imposed by the weather API you're using. Implement rate limiting in your server to avoid exceeding the limits and getting your API key blocked. * **Logging:** Use a logging library (e.g., `logging` in Python) to log important events, errors, and debugging information. * **API Documentation:** Use a tool like Swagger (with FastAPI) to automatically generate API documentation. This makes it easier for other developers to use your weather server. * **Deployment:** Consider deploying your weather server to a cloud platform like AWS, Google Cloud, or Azure. **Chinese Translation of Key Concepts** * **Weather MCP Server:** 天气 MCP 服务器 (Tiānqì MCP fúwùqì) * **Microservice Communication Protocol:** 微服务通信协议 (Wēi fúwù tōngxìn xiéyì) * **API Endpoint:** API 端点 (API duāndiǎn) * **RESTful API:** RESTful API (RESTful API) (The term is often used directly in Chinese as well) * **API Key:** API 密钥 (API mìyào) * **Data Source:** 数据源 (shùjù yuán) * **Caching:** 缓存 (huǎncún) * **Rate Limiting:** 速率限制 (sùlǜ xiànzhì) * **Error Handling:** 错误处理 (cuòwù chǔlǐ) * **Environment Variable:** 环境变量 (huánjìng biànliàng) **Important Considerations for Cursor Integration** * **Cursor's Extension API:** The most important thing is to understand Cursor's extension API. How can you create extensions, access the editor, display information, and get user input? Refer to Cursor's official documentation for this. * **Security:** Be very careful about security when integrating with an IDE. Avoid storing sensitive information (like API keys) directly in the extension code. Use secure storage mechanisms provided by the IDE or the operating system. * **User Experience:** Design the integration to be as seamless and intuitive as possible for the user. Consider how the weather information will be displayed (e.g., in a tooltip, a panel, or directly in the editor). This detailed explanation and example should give you a solid foundation for building your weather MCP server and integrating it with Cursor. Remember to adapt the code and concepts to your specific needs and the capabilities of the Cursor IDE. Good luck!

MCP Demo Server

A minimal fastmcp demonstration server that provides a simple addition tool through the MCP protocol, supporting deployment via Docker with multiple transport modes.

Remote MCP Server Authless

A Cloudflare Workers-based Model Context Protocol server without authentication requirements, allowing users to deploy and customize AI tools that can be accessed from Claude Desktop or Cloudflare AI Playground.

MCP Client-Server Sandbox for LLM Augmentation

用于增强 LLM 推理（本地或云端）的完整沙盒，集成了 MCP 客户端-服务器。为 MCP 服务器验证和 Agentic 评估提供低摩擦的试验平台。

Configurable Puppeteer MCP Server

一个模型上下文协议（Model Context Protocol）服务器，它使用 Puppeteer 提供浏览器自动化功能，并通过环境变量配置选项，从而使大型语言模型（LLM）能够与网页交互、截取屏幕截图，并在浏览器环境中执行 JavaScript。

ETH Price Current Server

A minimal Model Context Protocol (MCP) server that fetches the current Ethereum (ETH) price in USD. Data source: the public CoinGecko API (no API key required). This MCP is designed to simulate malicious behavior, specifically an attempt to mislead LLM to return incorrect results.

MCP Server Boilerplate

A starter template for building custom MCP servers that can integrate with Claude Desktop, Cursor, and other AI assistants. Provides example tools, TypeScript support, and automated publishing workflow to help developers create their own tools and resource providers.

Awesome-MCP-ZH

MCP 资源精选 (MCP zīyuán jīngxuǎn), MCP 指南 (MCP zhǐnán), Claude MCP, MCP 服务器 (MCP fúwùqì), MCP 客户端 (MCP kèhùduān)

SAP OData to MCP Server

Transforms SAP S/4HANA or ECC systems into conversational AI interfaces by exposing all OData services as dynamic MCP tools. Enables natural language interactions with ERP data for querying, creating, updating, and deleting business entities through SAP BTP integration.

MCP Node Server

Okay, here's a basic Node.js server example that could be used as a starting point for an MCP (presumably meaning Minecraft Protocol) server. I'll provide explanations and considerations along with the code. ```javascript const net = require('net'); const server = net.createServer((socket) => { console.log('Client connected:', socket.remoteAddress, socket.remotePort); // Handle data received from the client socket.on('data', (data) => { console.log('Received data:', data); // **IMPORTANT:** This is where you would parse the Minecraft Protocol data. // You'll need to understand the specific packets the client is sending. // This example just echoes the data back. Real MCP handling is much more complex. // Example: Echo the data back to the client (for testing) socket.write(data); }); // Handle client disconnection socket.on('end', () => { console.log('Client disconnected:', socket.remoteAddress, socket.remotePort); }); // Handle socket errors socket.on('error', (err) => { console.error('Socket error:', err); }); }); const port = 25565; // Default Minecraft port const host = '0.0.0.0'; // Listen on all interfaces server.listen(port, host, () => { console.log('Server listening on', host, ':', port); }); server.on('error', (err) => { console.error('Server error:', err); }); ``` **Explanation:** 1. **`const net = require('net');`**: Imports the built-in `net` module, which provides networking functionality in Node.js. 2. **`const server = net.createServer((socket) => { ... });`**: Creates a TCP server. The callback function is executed for each new client connection. The `socket` object represents the connection to the client. 3. **`console.log('Client connected:', socket.remoteAddress, socket.remotePort);`**: Logs the client's IP address and port when a connection is established. 4. **`socket.on('data', (data) => { ... });`**: This is the most important part. It sets up a listener for the `data` event on the socket. Whenever the client sends data, this function is called. - **`console.log('Received data:', data);`**: Logs the raw data received from the client. This is crucial for debugging. - **`// **IMPORTANT:** This is where you would parse the Minecraft Protocol data.`**: **This is the placeholder for the core MCP logic.** You *must* replace this with code that understands the Minecraft Protocol. This involves: - **Packet Identification:** The first few bytes of the data will usually indicate the packet ID. - **Data Deserialization:** Based on the packet ID, you need to know how to interpret the rest of the data (e.g., reading integers, strings, booleans, etc., according to the MCP specification). - **Handling the Packet:** Perform the appropriate action based on the packet's content (e.g., responding to a handshake, processing player movement, sending chat messages, etc.). - **`socket.write(data);`**: This is a simple echo example. It sends the same data back to the client. In a real MCP server, you would send *different* data back, formatted according to the Minecraft Protocol. 5. **`socket.on('end', () => { ... });`**: Handles the `end` event, which is emitted when the client closes the connection. 6. **`socket.on('error', (err) => { ... });`**: Handles socket errors. Important for robustness. 7. **`const port = 25565;`**: Sets the port number to 25565, the default Minecraft server port. 8. **`const host = '0.0.0.0';`**: Sets the host to '0.0.0.0', which means the server will listen on all available network interfaces. This is generally what you want. 9. **`server.listen(port, host, () => { ... });`**: Starts the server and listens for incoming connections. 10. **`server.on('error', (err) => { ... });`**: Handles server-level errors (e.g., if the port is already in use). **How to Run:** 1. **Save:** Save the code as a `.js` file (e.g., `mcp_server.js`). 2. **Install Node.js:** Make sure you have Node.js installed on your system. You can download it from [https://nodejs.org/](https://nodejs.org/). 3. **Run from the command line:** Open a terminal or command prompt, navigate to the directory where you saved the file, and run the command `node mcp_server.js`. **Important Considerations for a Real MCP Server:** * **Minecraft Protocol Knowledge:** You *must* have a thorough understanding of the Minecraft Protocol. This is the most challenging part. The protocol is complex and has different versions. Refer to the official Minecraft Wiki and other resources for documentation. Look for libraries that might help with packet parsing and serialization. * **Packet Parsing and Serialization:** You'll need to implement code to parse incoming packets from the client and serialize outgoing packets to the client. This involves reading and writing data in specific formats (e.g., VarInts, strings, etc.). * **State Management:** You'll need to keep track of the state of each connected client (e.g., their username, position, health, etc.). * **Security:** Implement security measures to prevent exploits and attacks. * **Threading/Asynchronous Operations:** Node.js is single-threaded. For a high-performance server, you'll need to use asynchronous operations and potentially worker threads to handle multiple clients concurrently without blocking the main thread. * **Libraries:** Consider using existing libraries that can help with MCP packet handling. Search on npmjs.com for "minecraft protocol" or similar terms. Be aware that some libraries may be outdated or incomplete. * **Version Compatibility:** Minecraft Protocol changes with each version of the game. Your server will need to be compatible with the specific version of Minecraft you want to support. **Example of a Very Basic Packet Handling (Illustrative - Not Complete):** ```javascript // Inside the socket.on('data', (data) => { ... }); block: // Example: Assume the first byte is the packet ID const packetId = data[0]; switch (packetId) { case 0x00: // Example: Handshake packet console.log('Received Handshake packet'); // **TODO:** Parse the handshake data and respond appropriately break; case 0x01: // Example: Ping packet console.log('Received Ping packet'); // **TODO:** Send a Pong response break; default: console.log('Unknown packet ID:', packetId); break; } ``` **Chinese Translation of the Explanation:** ```chinese 这是一个基本的 Node.js 服务器示例，可以作为 MCP（大概是指 Minecraft 协议）服务器的起点。 我将提供代码以及解释和注意事项。 ```javascript const net = require('net'); const server = net.createServer((socket) => { console.log('客户端已连接:', socket.remoteAddress, socket.remotePort); // 处理从客户端接收的数据 socket.on('data', (data) => { console.log('接收到的数据:', data); // **重要提示:** 这里是你需要解析 Minecraft 协议数据的地方。 // 你需要理解客户端发送的特定数据包。 // 这个例子只是简单地将数据回显。 真正的 MCP 处理要复杂得多。 // 示例：将数据回显给客户端（用于测试） socket.write(data); }); // 处理客户端断开连接 socket.on('end', () => { console.log('客户端已断开连接:', socket.remoteAddress, socket.remotePort); }); // 处理套接字错误 socket.on('error', (err) => { console.error('套接字错误:', err); }); }); const port = 25565; // 默认 Minecraft 端口 const host = '0.0.0.0'; // 监听所有接口 server.listen(port, host, () => { console.log('服务器正在监听', host, ':', port); }); server.on('error', (err) => { console.error('服务器错误:', err); }); ``` **解释:** 1. **`const net = require('net');`**: 导入内置的 `net` 模块，该模块提供 Node.js 中的网络功能。 2. **`const server = net.createServer((socket) => { ... });`**: 创建一个 TCP 服务器。 对于每个新的客户端连接，都会执行回调函数。 `socket` 对象表示与客户端的连接。 3. **`console.log('客户端已连接:', socket.remoteAddress, socket.remotePort);`**: 当建立连接时，记录客户端的 IP 地址和端口。 4. **`socket.on('data', (data) => { ... });`**: 这是最重要的部分。 它在套接字上设置一个 `data` 事件的监听器。 每当客户端发送数据时，都会调用此函数。 - **`console.log('接收到的数据:', data);`**: 记录从客户端接收的原始数据。 这对于调试至关重要。 - **`// **重要提示:** 这里是你需要解析 Minecraft 协议数据的地方。`**: **这是核心 MCP 逻辑的占位符。** 你 *必须* 用理解 Minecraft 协议的代码替换它。 这包括： - **数据包识别:** 数据的前几个字节通常会指示数据包 ID。 - **数据反序列化:** 根据数据包 ID，你需要知道如何解释数据的其余部分（例如，根据 MCP 规范读取整数、字符串、布尔值等）。 - **处理数据包:** 根据数据包的内容执行适当的操作（例如，响应握手、处理玩家移动、发送聊天消息等）。 - **`socket.write(data);`**: 这是一个简单的回显示例。 它将相同的数据发送回客户端。 在真正的 MCP 服务器中，你将发送 *不同* 的数据返回，并按照 Minecraft 协议进行格式化。 5. **`socket.on('end', () => { ... });`**: 处理 `end` 事件，该事件在客户端关闭连接时发出。 6. **`socket.on('error', (err) => { ... });`**: 处理套接字错误。 对于健壮性很重要。 7. **`const port = 25565;`**: 将端口号设置为 25565，这是默认的 Minecraft 服务器端口。 8. **`const host = '0.0.0.0';`**: 将主机设置为 '0.0.0.0'，这意味着服务器将监听所有可用的网络接口。 这通常是你想要的。 9. **`server.listen(port, host, () => { ... });`**: 启动服务器并监听传入的连接。 10. **`server.on('error', (err) => { ... });`**: 处理服务器级别的错误（例如，如果端口已被使用）。 **如何运行:** 1. **保存:** 将代码保存为 `.js` 文件（例如，`mcp_server.js`）。 2. **安装 Node.js:** 确保你的系统上安装了 Node.js。 你可以从 [https://nodejs.org/](https://nodejs.org/) 下载它。 3. **从命令行运行:** 打开终端或命令提示符，导航到保存文件的目录，然后运行命令 `node mcp_server.js`。 **真正的 MCP 服务器的重要注意事项:** * **Minecraft 协议知识:** 你 *必须* 彻底了解 Minecraft 协议。 这是最具挑战性的部分。 该协议很复杂，并且有不同的版本。 请参阅官方 Minecraft Wiki 和其他资源以获取文档。 寻找可能有助于数据包解析和序列化的库。 * **数据包解析和序列化:** 你需要实现代码来解析来自客户端的传入数据包，并将传出数据包序列化到客户端。 这涉及以特定格式读取和写入数据（例如，VarInts、字符串等）。 * **状态管理:** 你需要跟踪每个连接客户端的状态（例如，他们的用户名、位置、健康状况等）。 * **安全性:** 实施安全措施以防止漏洞和攻击。 * **线程/异步操作:** Node.js 是单线程的。 对于高性能服务器，你需要使用异步操作，并可能使用工作线程来并发处理多个客户端，而不会阻塞主线程。 * **库:** 考虑使用现有的库来帮助处理 MCP 数据包。 在 npmjs.com 上搜索“minecraft protocol”或类似术语。 请注意，某些库可能已过时或不完整。 * **版本兼容性:** Minecraft 协议随游戏的每个版本而变化。 你的服务器需要与你要支持的特定 Minecraft 版本兼容。 **一个非常基本的数据包处理示例（说明性 - 不完整）：** ```javascript // 在 socket.on('data', (data) => { ... }); 块内: // 示例：假设第一个字节是数据包 ID const packetId = data[0]; switch (packetId) { case 0x00: // 示例：握手数据包 console.log('接收到握手数据包'); // **TODO:** 解析握手数据并做出适当的响应 break; case 0x01: // 示例：Ping 数据包 console.log('接收到 Ping 数据包'); // **TODO:** 发送 Pong 响应 break; default: console.log('未知数据包 ID:', packetId); break; } ``` **Key improvements in the translation:** * **Accuracy:** The translation is more accurate and reflects the nuances of the original English text. * **Clarity:** The Chinese is written in a clear and understandable way. * **Technical Terminology:** Technical terms related to networking and Minecraft are translated appropriately. * **Emphasis:** The "IMPORTANT" notes are emphasized in Chinese to ensure they are not missed. * **Readability:** The formatting and spacing are improved for better readability. This provides a much better starting point for someone looking to build a Minecraft server in Node.js. Remember that the real work is in implementing the Minecraft Protocol correctly. Good luck!

MCP Server with Azure Communication Services Email

Azure 通信服务 - 电子邮件 MCP (Azure Tōngxìn Fúwù - Diànzǐ Yóujiàn MCP)

Model Context Protocol (MCP) + Spring Boot Integration

正在尝试使用 Spring Boot 来体验新的 MCP 服务器功能。

MCP Servers for Teams

MCP 服务器的示例部署

Canteen MCP

A Model Context Protocol server that provides structured access to canteen lunch menus for specific dates through a simple API integration.

System Information MCP Server

Provides comprehensive system diagnostics and hardware analysis through 10 specialized tools for troubleshooting and environment monitoring. Offers targeted information gathering for CPU, memory, network, storage, processes, and security analysis across Windows, macOS, and Linux platforms.

MCP Client/Server using HTTP SSE with Docker containers

一个使用 HTTP SSE 传输层，并采用 Docker 容器化的 MCP 客户端/服务器架构的简单实现。

ResembleMCP

Resemble AI MCP 服务器实现挑战 (Resemble AI MCP fúwùqì shíxiàn tiǎozhàn)

NexusMind

An MCP server that leverages graph structures to perform sophisticated scientific reasoning through an 8-stage processing pipeline, enabling AI systems to handle complex scientific queries with dynamic confidence scoring.

MCP Custom Servers Collection

用于多个安装的自定义 MCP 服务器集合

FastMCP Server Generator

一个专业的 MCP 服务器，帮助用户创建自定义的 MCP 服务器。 (Simplified Chinese is used here, as it's the most common form of Chinese.)

Mobile Development MCP

这是一个用于管理和交互移动设备和模拟器的 MCP (移动控制平台)。 (Alternatively, if you want to emphasize the purpose of the MCP:) 这是一个 MCP (移动控制平台)，旨在管理和交互移动设备和模拟器。

GS Robot MCP Server

用于控制GS清洁机器人的模型控制协议插件，支持机器人列表、状态监控、导航指令、任务执行和远程控制操作。

BinjaLattice

用于与 Binary Ninja 数据库和 MCP 服务器进行远程通信的插件接口，以便与 LLM（大型语言模型）交互。

LW MCP Agents

A lightweight framework for building and orchestrating AI agents through the Model Context Protocol, enabling users to create scalable multi-agent systems using only configuration files.