Discover Awesome MCP Servers

mariadb-mcp-server

一个提供对 MariaDB 只读访问权限的 MCP 服务器。

TimezoneToolkit MCP Server

提供全面时间和时区工具的高级 MCP 服务器。

Gitee MCP Server

Gitee API 集成、仓库、议题和拉取请求管理等。

Memory Bank MCP Server 2.2.1

一个服务器，用于通过全局和分支特定的记忆库来管理 Claude AI 会话中的项目文档和上下文，从而实现具有结构化 JSON 文档存储的一致知识管理。

MCP Server

Okay, here's a translation of "MCP server implementation for handling run_python requests" into Chinese, along with some considerations for different contexts: **Option 1 (Most General):** * **Simplified Chinese:** 用于处理 `run_python` 请求的 MCP 服务器实现 * **Pinyin:** Yòng yú chǔlǐ `run_python` qǐngqiú de MCP fúwùqì shíxiàn * **Explanation:** This is a straightforward and common way to translate the phrase. It emphasizes the *purpose* of the MCP server implementation. **Option 2 (More Technical, Emphasizing the Mechanism):** * **Simplified Chinese:** MCP 服务器中处理 `run_python` 请求的实现 * **Pinyin:** MCP fúwùqì zhōng chǔlǐ `run_python` qǐngqiú de shíxiàn * **Explanation:** This version focuses on the *implementation within* the MCP server. It's suitable if you're discussing the specific code or architecture. **Option 3 (More Verbose, for Clarity):** * **Simplified Chinese:** MCP 服务器中，用于响应和处理 `run_python` 请求的具体实现方案 * **Pinyin:** MCP fúwùqì zhōng, yòng yú xiǎngyìng hé chǔlǐ `run_python` qǐngqiú de jùtǐ shíxiàn fāng'àn * **Explanation:** This is a more detailed translation, explicitly mentioning "responding to" the requests and using "implementation scheme/solution" for a more complete understanding. It's good if you need to be very clear. **Key Considerations and Nuances:** * **`run_python`:** It's generally best to keep the code-related terms like `run_python` in English, especially in technical documentation. This avoids potential ambiguity and ensures consistency with the codebase. If you *absolutely* need to translate it, you could use something like `运行Python代码` (yùnxíng Python dàimǎ), but it's generally not recommended. * **MCP:** If "MCP" is a well-known acronym within your specific context, leave it as is. If not, you might consider providing the full name the first time it's used, followed by the acronym in parentheses. For example: "主控制程序 (MCP) 服务器中..." (Zhǔ kòngzhì chéngxù (MCP) fúwùqì zhōng...). However, without knowing what MCP stands for, I can't provide the best translation for the full name. * **Context is Crucial:** The best translation depends heavily on the context in which you're using the phrase. Who is the audience? What are you trying to convey? Are you writing documentation, giving a presentation, or having a casual conversation? **Recommendation:** I would recommend **Option 1 (用于处理 `run_python` 请求的 MCP 服务器实现)** as a good starting point for most situations. It's concise, clear, and generally well-understood. However, consider the context and the other options to choose the most appropriate translation.

Figma to Vue MCP Server

根据 Hostinger 设计系统，从 Figma 设计稿生成 Vue 组件的 MCP 服务器

AWS Model Context Protocol (MCP) Server

一个轻量级服务，使 AI 助手能够通过模型上下文协议 (MCP) 执行 AWS CLI 命令，从而允许 AI 工具检索 AWS 文档并与 AWS 服务交互。

Documentation MCP Server

一个用于访问常用库的最新文档的 MCP 服务器 (Yī gè yòng yú fǎngwèn chángyòng kù de zuìxīn wéndàng de MCP fúwùqì)

Memory Cache Server

镜子 (jìng zi)

codemirror-mcp

Here are a few possible translations, depending on the nuance you want to convey: **Option 1 (Most straightforward and common):** * **Chinese:** CodeMirror 扩展，用于连接模型上下文提供程序 (MCP) * **Pinyin:** CodeMirror kuòzhǎn, yòng yú liánjiē móxíng shàngxiàwén tígōngzhě (MCP) * **Explanation:** This is a direct translation. "扩展" (kuòzhǎn) means "extension," "用于" (yòng yú) means "used for," "连接" (liánjiē) means "connect," "模型上下文提供程序" (móxíng shàngxiàwén tígōngzhě) means "Model Context Provider," and "(MCP)" is the abbreviation. This is suitable for technical documentation or general communication. **Option 2 (More emphasis on integration):** * **Chinese:** CodeMirror 扩展，用于集成模型上下文提供程序 (MCP) * **Pinyin:** CodeMirror kuòzhǎn, yòng yú jíchéng móxíng shàngxiàwén tígōngzhě (MCP) * **Explanation:** "集成" (jíchéng) means "integrate." This emphasizes that the extension is designed to make the MCP work seamlessly with CodeMirror. **Option 3 (More descriptive, if the purpose of the hook is important):** * **Chinese:** CodeMirror 扩展，用于将模型上下文提供程序 (MCP) 接入 * **Pinyin:** CodeMirror kuòzhǎn, yòng yú jiāng móxíng shàngxiàwén tígōngzhě (MCP) jiērù * **Explanation:** "接入" (jiērù) means "to connect to," "to access," or "to hook up to." This is a good choice if you want to emphasize the act of connecting the MCP to CodeMirror. The "将...接入" (jiāng...jiērù) structure is common for describing connecting something to something else. **Option 4 (More informal, like a developer might say):** * **Chinese:** CodeMirror 扩展，用来搞定模型上下文提供程序 (MCP) * **Pinyin:** CodeMirror kuòzhǎn, yòng lái gǎodìng móxíng shàngxiàwén tígōngzhě (MCP) * **Explanation:** "搞定" (gǎodìng) is a very informal term meaning "to handle," "to take care of," or "to get something done." It's suitable for casual conversation among developers but not for formal documentation. **Recommendation:** For most situations, **Option 1** is the best choice because it's clear, concise, and technically accurate. If you want to emphasize the integration aspect, use **Option 2**. If you want to emphasize the act of connecting, use **Option 3**. Avoid **Option 4** unless you're in a very informal setting.

mem0 MCP Server

一个 Model Context Protocol 服务器的 TypeScript 实现，它支持使用 Mem0 集成来创建、管理和对内存流进行语义搜索。

kagi-server MCP Server

镜子 (jìng zi)

Server

Okay, here's a basic outline and code snippets for a simple "Weather MCP" (presumably meaning "Minecraft Protocol") server in Python. I'll break it down into sections and explain the key concepts. Keep in mind that this is a *very* simplified example and doesn't implement the full Minecraft protocol. It's designed to illustrate the core idea of a server that responds to Minecraft client requests with weather data. **Important Considerations:** * **Minecraft Protocol Complexity:** The actual Minecraft protocol is complex and constantly evolving. This example *does not* implement it fully. It's a simplified demonstration. For real Minecraft server development, you'd need a robust library like `mcstatus` or a more complete server implementation. * **MCP (Minecraft Coder Pack):** MCP is primarily for *modding* the Minecraft client and server, not for creating entirely new servers. I'm assuming you're using "MCP" loosely to mean "something that interacts with Minecraft." * **Weather Data Source:** This example uses a placeholder for weather data. You'll need to integrate a real weather API (e.g., OpenWeatherMap, AccuWeather) to get actual weather information. * **Security:** This is a basic example and doesn't include any security measures. Real Minecraft servers need proper security to prevent exploits. **Conceptual Outline:** 1. **Socket Setup:** Create a TCP socket to listen for incoming connections from Minecraft clients (or a proxy/mod that simulates a client). 2. **Client Connection Handling:** When a client connects, accept the connection and create a new thread or process to handle it. 3. **Simplified Protocol:** Define a very simple protocol for the client to request weather data. For example, the client might send a specific string like "WEATHER_REQUEST". 4. **Weather Data Retrieval:** When a request is received, fetch weather data from your chosen source (API or placeholder). 5. **Response Formatting:** Format the weather data into a string or a simple data structure that the client can understand. 6. **Sending the Response:** Send the formatted weather data back to the client through the socket. 7. **Closing the Connection:** Close the connection with the client. **Python Code (Illustrative Example):** ```python import socket import threading import time # For simulating weather updates import random # For simulating weather updates # Configuration HOST = '127.0.0.1' # Listen on localhost PORT = 25566 # Choose a port (not the default Minecraft port) WEATHER_REQUEST_COMMAND = "WEATHER_REQUEST" SIMULATE_WEATHER = True # Set to False if using a real API # Placeholder for weather data (replace with API integration) weather_data = { "temperature": 25, "condition": "Clear", "humidity": 60 } def update_weather(): """Simulates weather updates (replace with API calls).""" global weather_data while SIMULATE_WEATHER: weather_data["temperature"] = random.randint(15, 35) conditions = ["Clear", "Rain", "Cloudy", "Thunderstorm"] weather_data["condition"] = random.choice(conditions) weather_data["humidity"] = random.randint(40, 80) print(f"Weather updated: {weather_data}") time.sleep(60) # Update every 60 seconds def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") try: while True: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break # Client disconnected message = data.decode('utf-8').strip() print(f"Received: {message}") if message == WEATHER_REQUEST_COMMAND: # Format the weather data into a string weather_string = f"Temperature: {weather_data['temperature']}°C, Condition: {weather_data['condition']}, Humidity: {weather_data['humidity']}%" conn.sendall(weather_string.encode('utf-8')) else: conn.sendall("Unknown command".encode('utf-8')) except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") def start_server(): """Starts the weather server.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Avoid address already in use error try: server_socket.bind((HOST, PORT)) server_socket.listen() print(f"Weather server listening on {HOST}:{PORT}") # Start the weather update thread if SIMULATE_WEATHER: weather_thread = threading.Thread(target=update_weather) weather_thread.daemon = True # Exit when the main thread exits weather_thread.start() while True: conn, addr = server_socket.accept() client_thread = threading.Thread(target=handle_client, args=(conn, addr)) client_thread.start() except Exception as e: print(f"Server error: {e}") finally: server_socket.close() if __name__ == "__main__": start_server() ``` **Explanation:** 1. **Imports:** Imports necessary modules: `socket` for network communication, `threading` for handling multiple clients concurrently, `time` for simulating weather updates, and `random` for generating random weather data. 2. **Configuration:** * `HOST`: The IP address to listen on (localhost in this case). * `PORT`: The port number to listen on. Choose a port that's not already in use. *Do not use the default Minecraft port (25565) unless you know what you're doing.* * `WEATHER_REQUEST_COMMAND`: The string that the client sends to request weather data. * `SIMULATE_WEATHER`: A flag to control whether to simulate weather updates or use a real API. 3. **`weather_data`:** A dictionary to store the current weather information. This is a placeholder; you'll replace this with data from a real weather API. 4. **`update_weather()`:** This function simulates weather updates. It randomly changes the temperature, condition, and humidity every 60 seconds. *Replace this with code that calls a weather API.* The `time.sleep(60)` call pauses the thread for 60 seconds. The `weather_thread.daemon = True` line ensures that the thread exits when the main program exits. 5. **`handle_client(conn, addr)`:** This function handles the communication with a single client. * It receives data from the client using `conn.recv(1024)`. * It decodes the data from bytes to a string using `data.decode('utf-8')`. * It checks if the received message is the `WEATHER_REQUEST_COMMAND`. * If it is, it formats the weather data into a string and sends it back to the client using `conn.sendall(weather_string.encode('utf-8'))`. The `encode('utf-8')` converts the string to bytes before sending. * If the message is not recognized, it sends an "Unknown command" message. * It closes the connection using `conn.close()`. 6. **`start_server()`:** This function sets up the server socket and listens for incoming connections. * It creates a TCP socket using `socket.socket(socket.AF_INET, socket.SOCK_STREAM)`. * It binds the socket to the specified host and port using `server_socket.bind((HOST, PORT))`. * It starts listening for connections using `server_socket.listen()`. * It enters a loop that accepts incoming connections using `server_socket.accept()`. * For each connection, it creates a new thread to handle the client using `threading.Thread(target=handle_client, args=(conn, addr))`. * It starts the thread using `client_thread.start()`. * The `server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)` line is important. It allows you to quickly restart the server after it crashes or is stopped without getting an "Address already in use" error. 7. **`if __name__ == "__main__":`:** This ensures that the `start_server()` function is only called when the script is run directly (not when it's imported as a module). **How to Run:** 1. Save the code as a Python file (e.g., `weather_server.py`). 2. Run the script from your terminal: `python weather_server.py` **Client-Side (Simplified Example - Requires Modification for Minecraft):** This is a *very* basic Python client to test the server. **This will NOT work directly with Minecraft.** You'll need to adapt it to send the request from within a Minecraft mod or through a proxy. ```python import socket HOST = '127.0.0.1' PORT = 25566 WEATHER_REQUEST_COMMAND = "WEATHER_REQUEST" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) s.sendall(WEATHER_REQUEST_COMMAND.encode('utf-8')) data = s.recv(1024) print('Received:', repr(data.decode('utf-8'))) ``` **Important Notes and Next Steps:** * **Minecraft Integration:** The biggest challenge is integrating this with Minecraft. You'll need to: * **Create a Minecraft Mod:** This is the most common approach. Your mod would need to: * Establish a connection to your Python server. * Send the `WEATHER_REQUEST_COMMAND`. * Receive the weather data. * Display the weather data in the game (e.g., in the chat, on a custom GUI). * **Use a Proxy:** You could create a proxy server that sits between the Minecraft client and the real Minecraft server. The proxy would intercept weather-related packets and replace them with data from your Python server. This is more complex. * **Weather API Integration:** Replace the placeholder weather data with calls to a real weather API. You'll need to: * Sign up for an API key from a weather service (e.g., OpenWeatherMap). * Install the `requests` library: `pip install requests` * Modify the `update_weather()` function to make API calls. * **Error Handling:** Add more robust error handling to the server and client code. * **Data Formatting:** Consider using a more structured data format like JSON for sending weather data between the server and client. This will make it easier to parse the data on the client side. * **Security:** Implement security measures to protect your server from unauthorized access. **Example of Weather API Integration (OpenWeatherMap):** ```python import requests # Replace with your OpenWeatherMap API key API_KEY = "YOUR_OPENWEATHERMAP_API_KEY" CITY = "London" # Or any city you want def get_weather_from_api(): """Gets weather data from OpenWeatherMap.""" url = f"http://api.openweathermap.org/data/2.5/weather?q={CITY}&appid={API_KEY}&units=metric" try: response = requests.get(url) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() weather_data = { "temperature": data["main"]["temp"], "condition": data["weather"][0]["description"], "humidity": data["main"]["humidity"] } return weather_data except requests.exceptions.RequestException as e: print(f"Error fetching weather data: {e}") return None # In your update_weather() function: def update_weather(): global weather_data while SIMULATE_WEATHER: new_weather = get_weather_from_api() if new_weather: weather_data = new_weather print(f"Weather updated from API: {weather_data}") else: print("Failed to update weather from API.") time.sleep(60) ``` Remember to replace `"YOUR_OPENWEATHERMAP_API_KEY"` with your actual API key. You'll also need to adjust the `CITY` variable to the city you want weather data for. This comprehensive explanation and code should give you a solid starting point for building your weather MCP server in Python. Good luck!

MCP Image Generation Server

镜子 (jìng zi)

mcp-cbs-cijfers-open-data

用于处理 CBS 统计开放数据的 MCP 服务器

WCGW

Okay, I understand. Please provide the code snippet and the paths you want me to translate into Chinese. I will then provide the translated text. For example, you could provide something like this: **Code Snippet:** ```python def handle_request(request): """ This function processes the incoming request. """ data = request.get_json() user_id = data.get("user_id") item_id = data.get("item_id") # Perform some action based on user_id and item_id result = process_data(user_id, item_id) return jsonify({"result": result}) ``` **Paths:** * `/api/v1/recommendations` * `/data/models/trained_model.pkl` * `/logs/application.log` Once you provide the code and paths, I will translate them into Chinese. I will focus on providing translations that are appropriate for a technical context, keeping in mind the likely use case with the "wcgw mcp server."

MCP Command History

一个强大的工具，通过 MCP（模型控制协议）接口来探索、搜索和管理你的 shell 命令历史记录。 这个项目让你能够轻松地访问、搜索和检索你之前执行过的 shell 命令。

Flights Mcp Server

谷歌航班的 MCP 服务器！ (Gǔgē hángbān de MCP fúwùqì!)

gatherings MCP Server

一个模型上下文协议服务器，帮助追踪社交活动的开销并计算报销金额，从而方便朋友之间结算账单。

mcp-server-web3

基于 Anthropic 的 MCP 的 Web3 函数插件服务器。

Prompt Decorators

一个标准化的框架，旨在通过可组合的装饰器来增强大型语言模型（LLM）处理和响应提示的方式。该框架包含一个官方的开放标准规范和一个带有 MCP 服务器集成的 Python 参考实现。

artifacts-mcp

文物 MMO 的 MCP 服务器

Knowledge Graph Memory Server

镜子 (jìng zi)

MCP Server Docker

Docker 的 MCP 服务器