MCP 服务器

发现优秀的 MCP 服务器

通过 MCP 服务器扩展您的代理能力，拥有 14,326 个能力。

开发者工具3,065

MCP Simple Server

一个简单的服务器，实现了用于文档搜索的模型上下文协议。

Wonderland Editor MCP Plugin

适用于 Wonderland 编辑器的 MCP 服务器插件

MCP LLM Bridge

一个从 Ollama 到 fetch url mcp 服务器的简单桥梁

Prometheus Alertmanager MCP Server

一个与 Prometheus Alertmanager 集成的模型上下文协议 (MCP) 服务器 (Yī gè yǔ Prometheus Alertmanager jíchéng de móxíng shàngxiàwén xiéyì (MCP) fúwùqì)

Symbol MCP Server (REST API tools)

MCP 服务器符号。（REST API 工具）

OpsNow MCP Cost Server

Filesystem MCP Server

镜子 (jìng zi)

YouTube to LinkedIn MCP Server

镜子 (jìng zi)

Python Mcp Server Sample

uuid-mcp-server-example

这是一个简单的 MCP 服务器，用于生成 UUID (v4)。

rdb-mcp-server

Hello, MCP server.

一个基础的 MCP 服务器 (Yī gè jīchǔ de MCP fúwùqì)

spotify_mcp_server_claude

使用 MCP 框架构建的自定义 MCP 服务器

Excel Reader MCP Server

Simple MCP Search Server

A MCP server for Godot RAG

这个 MCP 服务器用于向 Godot RAG 模型提供 Godot 文档。

Cars MCP Server

Okay, here's a basic example of how you might set up a simple Minecraft Protocol (MCP) server using Spring AI. This is a high-level outline and requires you to fill in the details based on your specific needs and the MCP library you choose. This example focuses on the Spring AI integration for handling commands or interactions. **Important Considerations:** * **MCP Library:** There isn't a single "standard" MCP library for Java. You'll need to choose one. Popular options include: * **MinecraftForge:** A very common modding platform. If you're building a mod, this is likely your choice. * **SpongeAPI:** Another modding platform, known for its plugin API. * **Custom Implementation:** You *could* implement the MCP protocol yourself, but this is a significant undertaking. I strongly recommend using an existing library. * **Spring Boot:** This example assumes you're using Spring Boot for easy setup and dependency management. * **Spring AI:** This example uses Spring AI to process player input and generate responses. **Project Setup (Maven or Gradle):** Add the following dependencies to your `pom.xml` (Maven) or `build.gradle` (Gradle): **Maven (`pom.xml`):** ```xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-core</artifactId> <version>0.8.0</version>  </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai</artifactId> <version>0.8.0</version>  </dependency>   <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> ``` **Gradle (`build.gradle`):** ```gradle dependencies { implementation 'org.springframework.boot:spring-boot-starter-web' implementation 'org.springframework.ai:spring-ai-core:0.8.0' // Or the latest version implementation 'org.springframework.ai:spring-ai-openai:0.8.0' // Or the latest version // Your chosen MCP library dependency goes here. Example using a hypothetical MCP library: // implementation 'com.example:mcp-library:1.0.0' testImplementation 'org.springframework.boot:spring-boot-starter-test' } ``` **1. Spring Boot Application Class:** ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class McpServerApplication { public static void main(String[] args) { SpringApplication.run(McpServerApplication.class, args); } } ``` **2. MCP Server Component (Example):** ```java import org.springframework.ai.client.AiClient; import org.springframework.ai.prompt.PromptTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import java.util.HashMap; import java.util.Map; @Component public class McpServer { // Replace with your actual MCP server implementation private boolean isRunning = false; @Autowired private AiClient aiClient; @Value("${spring.ai.openai.api-key}") private String openAiApiKey; @Value("${mcp.server.port}") private int serverPort; @Value("${mcp.ai.prompt}") private String aiPrompt; @PostConstruct public void startServer() { System.out.println("Starting MCP Server on port: " + serverPort); System.out.println("Using OpenAI API Key: " + openAiApiKey); // Initialize your MCP server here (using your chosen library) // Example (replace with actual code): // this.mcpServer = new MyMcpserver(serverPort); // this.mcpServer.start(); isRunning = true; System.out.println("MCP Server started."); } @PreDestroy public void stopServer() { if (isRunning) { System.out.println("Stopping MCP Server"); // Stop your MCP server here (using your chosen library) // Example (replace with actual code): // this.mcpServer.stop(); isRunning = false; System.out.println("MCP Server stopped."); } } // Example method to handle player input and use Spring AI public String handlePlayerCommand(String playerName, String command) { System.out.println("Received command from " + playerName + ": " + command); // Use Spring AI to generate a response PromptTemplate promptTemplate = new PromptTemplate(aiPrompt); Map<String, Object> model = new HashMap<>(); model.put("playerName", playerName); model.put("command", command); String response = aiClient.generate(promptTemplate.create(model)).getGeneration().getText(); System.out.println("AI Response: " + response); return response; // Or send the response back to the player in-game } } ``` **3. Configuration (`application.properties` or `application.yml`):** ```properties spring.ai.openai.api-key=YOUR_OPENAI_API_KEY # Replace with your actual OpenAI API key mcp.server.port=25565 # Or your desired port mcp.ai.prompt=Player {playerName} issued command: {command}. Respond in a helpful and Minecraft-themed way. ``` **Explanation:** * **Dependencies:** The `spring-boot-starter-web` dependency is included for basic web functionality (though you might not need it directly for the MCP server itself, it's often useful for management endpoints). `spring-ai-core` and `spring-ai-openai` are the core Spring AI dependencies. You'll need to add the dependency for your chosen MCP library. * **`McpServerApplication`:** A standard Spring Boot application entry point. * **`McpServer` Component:** * `@Component`: Marks this class as a Spring-managed component. * `@Autowired AiClient`: Injects the Spring AI client. * `@Value`: Injects values from your `application.properties` or `application.yml` file. **Important:** Replace `YOUR_OPENAI_API_KEY` with your actual OpenAI API key. * `@PostConstruct`: The `startServer()` method is called after the Spring context is initialized. This is where you would start your MCP server. **You'll need to replace the placeholder comments with the actual code to initialize and start your chosen MCP library.** * `@PreDestroy`: The `stopServer()` method is called when the Spring context is shutting down. This is where you would stop your MCP server. **You'll need to replace the placeholder comments with the actual code to stop your chosen MCP library.** * `handlePlayerCommand()`: This is a *very* simplified example of how you might handle player input. It takes the player's name and command as input, uses Spring AI to generate a response, and then returns the response. **You'll need to adapt this to your specific MCP library and how it handles player input.** * **Spring AI Integration:** * `PromptTemplate`: Defines the prompt that will be sent to the AI model. The prompt includes placeholders for the player's name and command. * `aiClient.generate()`: Sends the prompt to the AI model and returns a response. * The response is then printed to the console and returned. * **`application.properties`:** Contains the configuration for your application, including the OpenAI API key, the server port, and the AI prompt. **Remember to replace `YOUR_OPENAI_API_KEY` with your actual key.** **How to Use It (Conceptual):** 1. **Choose an MCP Library:** Select the MCP library that best suits your needs (MinecraftForge, SpongeAPI, or a custom implementation). 2. **Implement MCP Server Logic:** Replace the placeholder comments in the `McpServer` class with the actual code to initialize, start, and stop your MCP server using your chosen library. This will involve handling network connections, player authentication, world loading, etc. 3. **Handle Player Input:** Modify the `handlePlayerCommand()` method to receive player input from your MCP server. This will likely involve listening for specific events or packets from the MCP library. 4. **Send Responses to Players:** Modify the `handlePlayerCommand()` method to send the AI-generated response back to the player in the game. This will involve using the appropriate methods from your MCP library to send messages to players. 5. **Configure Spring AI:** Make sure you have a valid OpenAI API key and that you've configured it in your `application.properties` file. You can also experiment with different AI models and prompt templates to get the desired behavior. **Example Scenario:** 1. A player types `/ask what is the best way to find diamonds?` in the game. 2. Your MCP server receives this command. 3. The `handlePlayerCommand()` method is called with `playerName` set to the player's name and `command` set to "what is the best way to find diamonds?". 4. The `PromptTemplate` is used to create a prompt like: "Player Steve issued command: what is the best way to find diamonds?. Respond in a helpful and Minecraft-themed way." 5. The prompt is sent to the OpenAI API. 6. The OpenAI API generates a response, such as: "Ahoy, matey! To find diamonds, ye should dig down to level -58 and look for them near lava pools. Be careful, though, or ye might get burned!" 7. The response is sent back to the player in the game. **Important Notes:** * **Error Handling:** This is a very basic example and doesn't include any error handling. You'll need to add error handling to your code to make it more robust. * **Security:** Be very careful about security when building an MCP server. Make sure you properly authenticate players and protect against exploits. * **Asynchronous Operations:** MCP servers are typically multi-threaded. Make sure you handle player input and AI responses asynchronously to avoid blocking the main server thread. Consider using Spring's `@Async` annotation or other concurrency mechanisms. * **Rate Limiting:** Be mindful of the OpenAI API's rate limits. You may need to implement rate limiting in your code to avoid being throttled. * **Prompt Engineering:** The quality of the AI's responses depends heavily on the prompt you provide. Experiment with different prompts to get the best results. * **Cost:** Using OpenAI's API incurs costs. Be aware of the pricing and monitor your usage. **Chinese Translation of Key Terms:** * **MCP (Minecraft Protocol):** Minecraft 协议 (Minecraft Xiéyì) * **Spring AI:** Spring 人工智能 (Spring Réngōng Zhìnéng) * **Server:** 服务器 (Fúwùqì) * **Player:** 玩家 (Wánjiā) * **Command:** 命令 (Mìnglìng) * **Prompt:** 提示 (Tíshì) * **API Key:** API 密钥 (API Mìyuè) * **Dependency:** 依赖 (Yīlài) * **Configuration:** 配置 (Pèizhì) * **Response:** 回应 (Huíyìng) / 响应 (Xiǎngyìng) This example provides a starting point for building an MCP server with Spring AI. You'll need to adapt it to your specific needs and the MCP library you choose. Remember to consult the documentation for your chosen MCP library and the Spring AI documentation for more information. Good luck!

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.