Discover Awesome MCP Servers

Free Image Generation MCP Server

这个 MCP 服务器使用 Together AI Flux Schnell 模型提供免费的图像生成服务。 可以根据需要更改模型以使用其他 Together AI 模型。

MCP Hub

用于模型上下文协议 (MCP) 服务器的集中式管理器，具有动态服务器管理和监控功能。

Chrome MCP Server

MCP 服务器与 Chrome 交互

🚀 MCP Tester

它基本上是一个 MCP 服务器或客户端测试应用程序。

mcp-server-agenda

镜子 (jìng zi)

google-calendar-mcp-python

好的，这是对“A python-based MCP server for google calendar”的翻译： **基于 Python 的 Google 日历 MCP 服务器** Here are some alternative translations, depending on the specific nuance you want to convey: * **更字面翻译:** 一个基于 Python 的，用于 Google 日历的 MCP 服务器 * **更强调功能:** 用于 Google 日历的，基于 Python 的 MCP 服务器 * **更简洁:** Python Google 日历 MCP 服务器 The best translation depends on the context. However, the first translation is generally the most accurate and understandable.

Awesome MCP Servers - Concise List

Okay, to give you the best translation, I need a little more context. What kind of "mcp servers" are you referring to? "MCP" can stand for a few things. Here are some possibilities and their translations, along with a general translation if you just mean "servers for MCP": **Possible Meanings of "MCP" and Translations:** * **If "MCP" refers to Minecraft Protocol (MCP) servers (servers that use a specific protocol for Minecraft):** * Simplified Chinese: **MCP协议服务器列表** (MCP Xiéyì Fúwùqì Lièbiǎo) * This translates to "MCP Protocol Server List" * **If "MCP" refers to a specific game or software called "MCP" (please specify the full name if possible):** * In this case, I need the full name of the game or software to provide an accurate translation. For example, if it was "MCP Game X", it would be "MCP游戏X服务器列表" (MCP Yóuxì X Fúwùqì Lièbiǎo) * **If "MCP" refers to Master Control Program (from Tron):** * Simplified Chinese: **主控程序服务器列表** (Zhǔkòng Chéngxù Fúwùqì Lièbiǎo) * This translates to "Master Control Program Server List" * **If you simply mean "servers for something called MCP" and the meaning of MCP is not important:** * Simplified Chinese: **MCP服务器简明列表** (MCP Fúwùqì Jiǎnmíng Lièbiǎo) * This translates to "Concise List of MCP Servers" **Therefore, without more information, the safest translation is probably:** **MCP服务器简明列表** (MCP Fúwùqì Jiǎnmíng Lièbiǎo) - Concise List of MCP Servers To get a more accurate translation, please tell me what "MCP" stands for in your context.

Vectorize MCP Server

官方 Vectorize MCP 服务器

Ultra-MCP-Servers

我们制作并测试过的超级 MCP 服务器

mcp-sonic-pi: MCP server for Sonic Pi

Sonic Pi 的 MCP 服务器

GitHub Code Explorer using Model Context Protocol

好的，这是一个演示如何构建和运行 MCP 服务器的示例： **假设：** * 你已经安装了 Java Development Kit (JDK) 8 或更高版本。 * 你已经安装了 Maven。 * 你已经安装了 Git (可选，但推荐用于克隆项目)。 **步骤 1: 克隆 MCP 项目 (可选，如果已经有项目则跳过)** 如果你还没有 MCP 项目，你需要克隆一个。 这里假设你使用 MCP 9.40 (Minecraft 1.12.2)，但你可以根据你的需要选择不同的版本。 ```bash git clone https://github.com/MinecraftForge/MCP-Reborn.git cd MCP-Reborn git checkout 1.12.2 ``` **步骤 2: 设置 MCP 环境** 进入 MCP 项目目录后，你需要设置 MCP 环境。 这通常涉及运行一些 Gradle 任务。 ```bash gradlew setupDecompWorkspace ``` 这个命令会下载 Minecraft 客户端和服务器 jar 文件，并开始反编译过程。 这可能需要一段时间，具体取决于你的网络速度和计算机性能。 **步骤 3: 构建服务器** 构建服务器通常涉及运行 `recompile` 和 `reobfuscate` 任务。 ```bash gradlew recompileMc gradlew reobfuscateMc ``` `recompileMc` 编译修改后的 Minecraft 代码。 `reobfuscateMc` 将代码重新混淆，使其更接近原始 Minecraft 代码。 **步骤 4: 运行服务器** 构建完成后，你可以在 `mcp/build/minecraft_server.jar` 找到服务器 jar 文件。 你可以使用以下命令运行它： ```bash java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui ``` * `-Xmx1024M` 和 `-Xms1024M` 设置服务器的最大和最小内存分配。 根据你的需要调整这些值。 * `nogui` 参数禁用图形用户界面，使其在控制台中运行。 **步骤 5: 接受 EULA** 首次运行服务器时，它会生成一个 `eula.txt` 文件。 你需要打开这个文件，并将 `eula=false` 更改为 `eula=true`，以接受 Minecraft 的最终用户许可协议。 **步骤 6: 再次运行服务器** 保存 `eula.txt` 文件后，再次运行服务器： ```bash java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui ``` 现在，服务器应该启动并运行。 **总结:** 以下是整个过程的总结： 1. **克隆 MCP 项目 (可选):** `git clone ...` 2. **设置 MCP 环境:** `gradlew setupDecompWorkspace` 3. **编译服务器:** `gradlew recompileMc` 4. **重新混淆服务器:** `gradlew reobfuscateMc` 5. **运行服务器:** `java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui` 6. **接受 EULA:** 修改 `eula.txt` 文件。 7. **再次运行服务器:** `java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui` **重要提示:** * **Gradle 版本:** 确保你使用的 Gradle 版本与 MCP 项目兼容。 通常，MCP 项目会指定所需的 Gradle 版本。 * **内存分配:** 根据你的服务器需求调整 `-Xmx` 和 `-Xms` 参数。 * **错误处理:** 如果在构建或运行过程中遇到错误，请仔细阅读错误消息，并尝试解决问题。 常见的错误包括缺少依赖项、Gradle 版本不兼容和内存不足。 * **MCP 版本:** 不同的 Minecraft 版本需要不同的 MCP 版本。 确保你使用与你的 Minecraft 版本兼容的 MCP 版本。 * **修改代码:** 在修改 Minecraft 代码之前，请确保你了解 Minecraft 的许可协议。 **中文翻译:** 好的，这是一个演示如何构建和运行 MCP 服务器的示例： **假设：** * 你已经安装了 Java Development Kit (JDK) 8 或更高版本。 (你已经安装了 Java 开发工具包 (JDK) 8 或更高版本。) * 你已经安装了 Maven。 (你已经安装了 Maven。) * 你已经安装了 Git (可选，但推荐用于克隆项目)。 (你已经安装了 Git (可选，但推荐用于克隆项目)。) **步骤 1: 克隆 MCP 项目 (可选，如果已经有项目则跳过)** 如果你还没有 MCP 项目，你需要克隆一个。 这里假设你使用 MCP 9.40 (Minecraft 1.12.2)，但你可以根据你的需要选择不同的版本。 (如果你还没有 MCP 项目，你需要克隆一个。 这里假设你使用 MCP 9.40 (Minecraft 1.12.2)，但你可以根据你的需要选择不同的版本。) ```bash git clone https://github.com/MinecraftForge/MCP-Reborn.git cd MCP-Reborn git checkout 1.12.2 ``` **步骤 2: 设置 MCP 环境** 进入 MCP 项目目录后，你需要设置 MCP 环境。 这通常涉及运行一些 Gradle 任务。 (进入 MCP 项目目录后，你需要设置 MCP 环境。 这通常涉及运行一些 Gradle 任务。) ```bash gradlew setupDecompWorkspace ``` 这个命令会下载 Minecraft 客户端和服务器 jar 文件，并开始反编译过程。 这可能需要一段时间，具体取决于你的网络速度和计算机性能。 (这个命令会下载 Minecraft 客户端和服务器 jar 文件，并开始反编译过程。 这可能需要一段时间，具体取决于你的网络速度和计算机性能。) **步骤 3: 构建服务器** 构建服务器通常涉及运行 `recompile` 和 `reobfuscate` 任务。 (构建服务器通常涉及运行 `recompile` 和 `reobfuscate` 任务。) ```bash gradlew recompileMc gradlew reobfuscateMc ``` `recompileMc` 编译修改后的 Minecraft 代码。 `reobfuscateMc` 将代码重新混淆，使其更接近原始 Minecraft 代码。 (`recompileMc` 编译修改后的 Minecraft 代码。 `reobfuscateMc` 将代码重新混淆，使其更接近原始 Minecraft 代码。) **步骤 4: 运行服务器** 构建完成后，你可以在 `mcp/build/minecraft_server.jar` 找到服务器 jar 文件。 你可以使用以下命令运行它： (构建完成后，你可以在 `mcp/build/minecraft_server.jar` 找到服务器 jar 文件。 你可以使用以下命令运行它：) ```bash java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui ``` * `-Xmx1024M` 和 `-Xms1024M` 设置服务器的最大和最小内存分配。 根据你的需要调整这些值。 (`-Xmx1024M` 和 `-Xms1024M` 设置服务器的最大和最小内存分配。 根据你的需要调整这些值。) * `nogui` 参数禁用图形用户界面，使其在控制台中运行。 (`nogui` 参数禁用图形用户界面，使其在控制台中运行。) **步骤 5: 接受 EULA** 首次运行服务器时，它会生成一个 `eula.txt` 文件。 你需要打开这个文件，并将 `eula=false` 更改为 `eula=true`，以接受 Minecraft 的最终用户许可协议。 (首次运行服务器时，它会生成一个 `eula.txt` 文件。 你需要打开这个文件，并将 `eula=false` 更改为 `eula=true`，以接受 Minecraft 的最终用户许可协议。) **步骤 6: 再次运行服务器** 保存 `eula.txt` 文件后，再次运行服务器： (保存 `eula.txt` 文件后，再次运行服务器：) ```bash java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui ``` 现在，服务器应该启动并运行。 (现在，服务器应该启动并运行。) **总结:** 以下是整个过程的总结： (以下是整个过程的总结：) 1. **克隆 MCP 项目 (可选):** `git clone ...` (克隆 MCP 项目 (可选): `git clone ...`) 2. **设置 MCP 环境:** `gradlew setupDecompWorkspace` (设置 MCP 环境: `gradlew setupDecompWorkspace`) 3. **编译服务器:** `gradlew recompileMc` (编译服务器: `gradlew recompileMc`) 4. **重新混淆服务器:** `gradlew reobfuscateMc` (重新混淆服务器: `gradlew reobfuscateMc`) 5. **运行服务器:** `java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui` (运行服务器: `java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui`) 6. **接受 EULA:** 修改 `eula.txt` 文件。 (接受 EULA: 修改 `eula.txt` 文件。) 7. **再次运行服务器:** `java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui` (再次运行服务器: `java -Xmx1024M -Xms1024M -jar build/minecraft_server.jar nogui`) **重要提示:** * **Gradle 版本:** 确保你使用的 Gradle 版本与 MCP 项目兼容。 通常，MCP 项目会指定所需的 Gradle 版本。 (Gradle 版本: 确保你使用的 Gradle 版本与 MCP 项目兼容。 通常，MCP 项目会指定所需的 Gradle 版本。) * **内存分配:** 根据你的服务器需求调整 `-Xmx` 和 `-Xms` 参数。 (内存分配: 根据你的服务器需求调整 `-Xmx` 和 `-Xms` 参数。) * **错误处理:** 如果在构建或运行过程中遇到错误，请仔细阅读错误消息，并尝试解决问题。 常见的错误包括缺少依赖项、Gradle 版本不兼容和内存不足。 (错误处理: 如果在构建或运行过程中遇到错误，请仔细阅读错误消息，并尝试解决问题。 常见的错误包括缺少依赖项、Gradle 版本不兼容和内存不足。) * **MCP 版本:** 不同的 Minecraft 版本需要不同的 MCP 版本。 确保你使用与你的 Minecraft 版本兼容的 MCP 版本。 (MCP 版本: 不同的 Minecraft 版本需要不同的 MCP 版本。 确保你使用与你的 Minecraft 版本兼容的 MCP 版本。) * **修改代码:** 在修改 Minecraft 代码之前，请确保你了解 Minecraft 的许可协议。 (修改代码: 在修改 Minecraft 代码之前，请确保你了解 Minecraft 的许可协议。) 希望这个例子对你有帮助！

OpenAPI MCP Server

镜子 (jìng zi)

Fluent MCP

There isn't a single, pre-built Python package specifically designed to create Minecraft (MCP) servers with embedded Large Language Model (LLM) reasoning. You'll need to combine several existing packages and build the integration logic yourself. Here's a breakdown of the components you'll need and how you might approach it, along with potential package recommendations: **1. Minecraft Server Management:** * **Purpose:** This handles the core Minecraft server functionality: starting, stopping, managing players, executing commands, and receiving server events. * **Options:** * **`mcstatus`:** (Relatively simple) Primarily for querying server status (player count, MOTD, etc.). Less suitable for full server control. * **`minecraft-launcher-lib`:** (More complex, but powerful) Allows you to launch and manage Minecraft server instances programmatically. You can control the server process, read its output, and send commands. This is likely the best option for more advanced control. * **`pyminecraft`:** (Less actively maintained) Provides some server interaction capabilities, but might be outdated. * **Directly interacting with the server process:** You can use Python's `subprocess` module to launch the Minecraft server JAR file and communicate with it via standard input/output. This gives you the most control but requires more manual handling of server processes and command parsing. **2. Minecraft Protocol Handling:** * **Purpose:** This allows your Python code to understand and interact with the Minecraft network protocol. You'll need this to send commands to the server and receive information about the game world. * **Options:** * **`python-minecraft-protocol` (or `mcproto`):** A popular library for handling the Minecraft protocol. It allows you to connect to a Minecraft server as a client, send and receive packets, and interact with the game world. This is crucial for sending commands and receiving information from the server. * **`nbt`:** For reading and writing NBT (Named Binary Tag) data, which is used to store Minecraft world data, player data, and other information. You'll likely need this if you want to analyze or modify the game world. **3. LLM Integration:** * **Purpose:** This provides the interface to your chosen Large Language Model. * **Options:** * **`openai`:** For interacting with OpenAI's models (GPT-3, GPT-4, etc.). Requires an OpenAI API key. * **`transformers` (Hugging Face):** A very versatile library for working with a wide range of LLMs, including open-source models. You can use it to load pre-trained models or fine-tune your own. * **`cohere`:** For interacting with Cohere's LLMs. * **`llama-cpp-python`:** For running Llama 2 and other LLMs locally. This is useful if you want to avoid API costs and have more control over the model. * **LangChain:** A framework that simplifies the process of building applications with LLMs. It provides tools for chaining together different LLM calls, managing prompts, and integrating with external data sources. It can be very helpful for complex reasoning tasks. **4. Text Processing and Natural Language Understanding (NLU):** * **Purpose:** To parse player commands, extract relevant information, and format responses from the LLM. * **Options:** * **`spaCy`:** A powerful library for natural language processing. It can be used for tokenization, part-of-speech tagging, named entity recognition, and more. * **`NLTK` (Natural Language Toolkit):** Another popular NLP library with a wide range of features. * **Regular expressions (`re` module):** Useful for simple pattern matching and text extraction. **5. Asynchronous Programming (Optional but Recommended):** * **Purpose:** To handle multiple tasks concurrently (e.g., listening for server events, processing player commands, interacting with the LLM) without blocking the main thread. * **Options:** * **`asyncio`:** Python's built-in asynchronous programming library. * **`aiohttp`:** An asynchronous HTTP client/server library (useful if you're interacting with an LLM API over the network). **Conceptual Architecture:** 1. **Minecraft Server Management:** Use `minecraft-launcher-lib` (or `subprocess`) to start and manage the Minecraft server. 2. **Protocol Connection:** Use `python-minecraft-protocol` to connect to the server as a client. 3. **Command Handling:** * Listen for chat messages from players using `python-minecraft-protocol`. * Parse the chat messages using `spaCy` or regular expressions to identify commands and arguments. 4. **LLM Reasoning:** * Formulate a prompt for the LLM based on the player's command and any relevant game state information. * Send the prompt to the LLM using the `openai`, `transformers`, `cohere`, or `llama-cpp-python` library. * Receive the LLM's response. 5. **Action Execution:** * Parse the LLM's response to determine the appropriate action to take in the game world. * Use `python-minecraft-protocol` to send commands to the server to execute the action (e.g., `/give`, `/tp`, `/say`). * Send a response back to the player in the chat. **Example (Illustrative - Requires Significant Implementation):** ```python import asyncio import minecraft_launcher_lib from mcproto import MinecraftProtocol import openai import re # Configuration (replace with your actual values) SERVER_JAR = "server.jar" # Path to your Minecraft server JAR SERVER_PORT = 25565 OPENAI_API_KEY = "YOUR_OPENAI_API_KEY" async def main(): # 1. Start the Minecraft server # (Using minecraft-launcher-lib or subprocess) # ... (Implementation details omitted for brevity) # 2. Connect to the server using mcproto protocol = MinecraftProtocol("localhost", SERVER_PORT) await protocol.connect() await protocol.handshake() await protocol.login("LLMBot") # Bot's username # 3. Listen for chat messages async def handle_chat_message(packet): message = packet.data['content'] print(f"Received chat message: {message}") # Extract player name and command (very basic example) match = re.match(r"^<(\w+)> !(\w+)\s*(.*)$", message) if match: player_name = match.group(1) command = match.group(2) arguments = match.group(3) # 4. LLM Reasoning prompt = f"Player {player_name} issued command: {command} {arguments}. What should I do in Minecraft?" openai.api_key = OPENAI_API_KEY response = openai.Completion.create( engine="text-davinci-003", # Choose an appropriate model prompt=prompt, max_tokens=50, n=1, stop=None, temperature=0.7, ) llm_response = response.choices[0].text.strip() print(f"LLM Response: {llm_response}") # 5. Action Execution (very basic example) server_command = f"/say {llm_response}" await protocol.send_chat_message(server_command) # Assuming you have a send_chat_message function protocol.register_packet_listener("chat.message", handle_chat_message) # Keep the connection alive try: while True: await asyncio.sleep(1) except asyncio.CancelledError: pass finally: await protocol.disconnect() if __name__ == "__main__": asyncio.run(main()) ``` **Important Considerations:** * **Security:** Be extremely careful about executing commands based on LLM output. Implement robust validation and sanitization to prevent malicious commands from being executed. Consider using a whitelist of allowed commands. * **Rate Limiting:** LLM APIs often have rate limits. Implement appropriate rate limiting in your code to avoid exceeding these limits. * **Prompt Engineering:** The quality of the LLM's responses depends heavily on the prompts you provide. Experiment with different prompts to find what works best for your application. * **Error Handling:** Implement robust error handling to gracefully handle unexpected errors, such as network errors, API errors, and invalid LLM responses. * **Minecraft Server Configuration:** You may need to configure your Minecraft server to allow connections from your Python script. * **Performance:** LLM inference can be computationally expensive. Consider using techniques such as caching and batching to improve performance. Running the LLM locally (e.g., with `llama-cpp-python`) can reduce latency but requires significant computational resources. * **Ethical Considerations:** Be mindful of the potential ethical implications of using LLMs in a game environment. Consider how the LLM's behavior might affect players and ensure that it is used responsibly. This is a complex project, but by breaking it down into smaller components and using the appropriate libraries, you can create a powerful and engaging Minecraft server with embedded LLM reasoning. Good luck!

Claude-LMStudio-Bridge

一个桥接 MCP 服务器，允许 Claude 通过 LM Studio 与本地运行的 LLM 模型进行通信。 (Yī gè qiáo jiē MCP fúwùqì, yǔnxǔ Claude tōngguò LM Studio yǔ běndì yùnxíng de LLM móxíng jìnxíng tōngxìn.)

Test Repository

通过 MCP 服务器创建的测试仓库

Ebay MCP server

镜子 (jìng zi)

samcp

Okay, here's a translation of "Implementation of Solana Agent Kit MCP Server" into Chinese, along with some considerations for choosing the best translation: **Option 1 (More Literal):** * **Solana Agent Kit MCP 服务器的实现** * (Solana Agent Kit MCP fúwùqì de shíxiàn) * This is a direct translation. It's clear and understandable, especially if the audience is familiar with the English terms "Agent Kit" and "MCP." "服务器 (fúwùqì)" means "server," and "实现 (shíxiàn)" means "implementation." **Option 2 (Slightly More Natural, Assuming Context):** * **Solana Agent Kit MCP 服务器的开发** * (Solana Agent Kit MCP fúwùqì de kāifā) * This uses "开发 (kāifā)" which means "development." It implies the process of building the server, which might be more appropriate than just "implementation" if you're talking about the entire development effort. **Option 3 (If "Agent Kit" and "MCP" are well-known abbreviations):** * **Solana Agent Kit MCP 服务器实现** * (Solana Agent Kit MCP fúwùqì shíxiàn) * This is a shortened version of Option 1, omitting the "的 (de)". It's grammatically correct and common in technical writing where brevity is valued. **Option 4 (More Explanatory, if needed):** * **Solana 代理工具包 MCP 服务器的实现** * (Solana dàilǐ gōngjùbāo MCP fúwùqì de shíxiàn) * This replaces "Agent Kit" with "代理工具包 (dàilǐ gōngjùbāo)," which means "agent toolkit." This is helpful if the audience might not know what "Agent Kit" refers to. You would still likely leave "MCP" as is, assuming it's a specific acronym. **Which option is best depends on the context:** * **For a technical document or audience already familiar with the terms:** Option 1 or 3 are likely the best. * **For a broader audience or if you want to be more explicit:** Option 4 is a good choice. * **If you're talking about the entire process of building the server:** Option 2 might be more appropriate. **Therefore, my recommendation, assuming a technical audience familiar with the terms, is:** * **Solana Agent Kit MCP 服务器的实现** (Option 1) If you can provide more context about where this translation will be used, I can refine the translation further. For example: * Is this for a technical specification? * Is this for marketing material? * Is the audience primarily developers? * Is "Agent Kit" and "MCP" already established terminology in the Chinese-speaking community you're targeting?

Whimsical MCP Server

镜子 (jìng zi)

coderider-mcp

季候实验室 MCP 服务器 (Jìhòu shíyànshì MCP fúwùqì)

Linktree Demo

使用 GitHub MCP 服务器创建的演示仓库

MCPGod

对模型上下文协议 (MCP) 客户端、服务器和工具进行细粒度控制。上下文为王。

Kubernetes MCP Server

一个用于调试和管理 Kubernetes 的 MCP 服务器，使用自然语言。 (Yī gè yòng yú tiáoshì hé guǎnlǐ Kubernetes de MCP fúwùqì, shǐyòng zìrán yǔyán.)

mcp-claude

使用 Claude 与不同的 MCP 服务器

@servicestack/mcp

针对 ServiceStack API 的 MCP 服务器

Awesome Mcp Servers

测试 (cè shì)