发现优秀的 MCP 服务器

Browser-use-claude-mcp

一个浏览器自动化 MCP 服务器，适用于 Claude 和 Gemini 2.5 等 AI 模型，通过自然语言实现网页浏览功能。

MCP Memory

An MCP server that gives AI assistants like Cursor, Claude and Windsurf the ability to remember user information across conversations using vector search technology.

DART-mcp-server

使用韩国电子公示系统 API 的 MCP 服务器 (Shǐyòng Hánguó diànzǐ gōngshì xìtǒng API de MCP fúwùqì)

Artsy Analytics MCP Server

A Model Context Protocol server that provides Artsy partner analytics tools for Claude Desktop, allowing users to query gallery metrics, sales data, audience insights, and content performance through natural language.

Apktool MCP Server

An MCP server that integrates with Apktool to provide live reverse engineering support for Android applications using Claude and other LLMs through the Model Context Protocol.

Crawl4AI Web Scraper MCP Server

MCP服务器利用crawl4ai进行网络爬虫，并使用基于LLM的内容提取（Markdown、文本片段、智能提取）。专为AI代理集成而设计。

Google MCP

这是一个用于 MCP 协议的 Google 原生工具（例如 Gmail、日历）集合，旨在与 Claude 或 Cursor 等 AI 客户端无缝集成。

EDA Tools MCP Server

A comprehensive Model Context Protocol server that connects AI assistants to Electronic Design Automation tools, enabling Verilog synthesis, simulation, ASIC design flows, and waveform analysis through natural language interaction.

MCP Server Logger

好的，这是将 "console.log for your stdio MCP server" 翻译成中文的几种方式，根据不同的语境，表达的侧重点会有所不同： **1. 最直接的翻译 (偏技术):** * **为你的标准输入输出 MCP 服务器使用 console.log** 这个翻译比较直白，适合技术文档或者代码注释。 **2. 更自然的翻译 (强调调试):** * **使用 console.log 来调试你的标准输入输出 MCP 服务器** 这个翻译强调了 `console.log` 的用途是调试。 **3. 更加口语化的翻译:** * **在你的标准输入输出 MCP 服务器里用 console.log 来输出信息** 这个翻译更加口语化，更容易理解。 **4. 如果 "stdio" 指的是标准输入/输出流，可以这样翻译：** * **为你的基于标准输入/输出流的 MCP 服务器使用 console.log** **选择哪个翻译取决于你想要表达的具体含义和目标读者。** 总的来说，`console.log` 在编程中通常用于输出信息进行调试，所以强调调试的含义通常是合适的。 希望这些翻译对您有帮助！

Google Places MCP Server

Integrates with Google Places API to allow searching, retrieving details, and finding nearby places through an MCP server interface.

Next.js MCP Server Template

A template for building MCP servers in Next.js applications using the Vercel MCP Adapter. Provides a foundation for adding custom tools, prompts, and resources to any Next.js project with deployment support on Vercel.

Backlogr MCP Server

Enables AI assistants to create and manage development projects with structured backlogs, including tasks, requirements, and progress tracking. Provides a bridge between AI development assistants and project management workflows through standardized MCP tools.

MSSQL MCP Server

A Model Context Protocol server that enables LLMs like Claude to interact with Microsoft SQL Server databases through natural language, supporting queries, data manipulation, and table management.

IoT Realm MCP Server 🌐🔌

🌐🔌 一个 MCP 服务器，它通过模型上下文协议将来自 IoT Realm 设备的实时传感器数据（例如基于 ESP32 的 DHT11 客户端）暴露给 LLM。这使得 AI 代理能够访问、分析和处理实时环境数据。

JADX-AI-MCP

将 MCP 服务器集成到 JADX 的插件

MCP-DayOne

A Message Control Protocol server that enables Claude Desktop and other applications to interact with Day One journals, allowing automated journal entry creation through a simple API.

Call For Papers MCP

A Smithery MCP server that allows users to search for upcoming academic conferences and events from WikiCFP based on keywords, returning detailed event information including names, descriptions, dates, locations, and submission deadlines.

Rini MCP Server

A collection of custom MCP servers providing various AI-powered capabilities including web search, YouTube video analysis, GitHub repository analysis, reasoning, code generation/execution, and web crawling.

Workers MCP Server

镜子 (jìng zi)

Zig MCP Server

镜子 (jìng zi)

Apple Health MCP Server

An MCP server that allows users to query and analyze their Apple Health data using SQL and natural language, utilizing DuckDB for fast and efficient health data analysis.

DuckDuckGo MCP Server

A Model Context Protocol server that enables AI applications like Claude Desktop and Cursor IDE to perform web searches via DuckDuckGo's search engine.

Hologres MCP Server

镜子 (jìng zi)

MCP Server Office

镜子 (jìng zi)

PAELLADOC

A Model Context Protocol (MCP) server that implements AI-First Development framework principles, allowing LLMs to interact with context-first documentation tools and workflows for preserving knowledge and intent alongside code.

MCP-ChatBot

Okay, here's a simple example of an MCP (Minecraft Coder Pack) client-server setup, focusing on the core concepts and using simplified code for clarity. This example demonstrates a basic message exchange. Keep in mind that a real-world Minecraft mod would be significantly more complex. **Important Considerations:** * **MCP Setup:** This assumes you have a working MCP development environment set up. This is *essential* before you can run any of this code. Follow the official MCP documentation for your Minecraft version. * **Minecraft Forge:** You'll need Minecraft Forge to create mods. Make sure you have the correct Forge version for your MCP version. * **Simplified:** This is a *very* simplified example. It doesn't handle error conditions, complex data, or proper Minecraft threading. It's meant to illustrate the basic structure. * **Networking:** Minecraft Forge provides its own networking system, which is what you should use for real mods. This example uses standard Java sockets for simplicity, but it's not recommended for production mods. **1. Common Code (Shared between Client and Server)** Create a class to hold constants and shared data. This helps keep things organized. ```java // CommonConstants.java public class CommonConstants { public static final String MOD_ID = "simplemcp"; public static final String MOD_NAME = "Simple MCP Mod"; public static final String MOD_VERSION = "1.0"; public static final int SERVER_PORT = 12345; // Choose a port public static final String MESSAGE_TO_SERVER = "Hello from the client!"; public static final String MESSAGE_FROM_SERVER = "Hello from the server!"; } ``` **2. Server-Side (Minecraft Server Mod)** Create a class that will run on the Minecraft server. ```java // ServerProxy.java (or ServerSide.java, etc.) import java.io.*; import java.net.*; public class ServerProxy { public void init() { // Server-side initialization code here (e.g., registering commands, event handlers) System.out.println("ServerProxy init"); startServer(); } private void startServer() { new Thread(() -> { // Run the server in a separate thread try (ServerSocket serverSocket = new ServerSocket(CommonConstants.SERVER_PORT)) { System.out.println("Server started on port " + CommonConstants.SERVER_PORT); while (true) { // Keep listening for connections try (Socket clientSocket = serverSocket.accept(); PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) { System.out.println("Client connected: " + clientSocket.getInetAddress().getHostAddress()); String inputLine = in.readLine(); System.out.println("Received from client: " + inputLine); out.println(CommonConstants.MESSAGE_FROM_SERVER); // Send a response System.out.println("Sent to client: " + CommonConstants.MESSAGE_FROM_SERVER); } catch (IOException e) { System.err.println("Exception handling client: " + e.getMessage()); } } } catch (IOException e) { System.err.println("Could not listen on port " + CommonConstants.SERVER_PORT + ": " + e.getMessage()); } }).start(); } } ``` **3. Client-Side (Minecraft Client Mod)** Create a class that will run on the Minecraft client. ```java // ClientProxy.java (or ClientSide.java, etc.) import java.io.*; import java.net.*; public class ClientProxy { public void init() { // Client-side initialization code here (e.g., registering keybindings, event handlers) System.out.println("ClientProxy init"); startClient(); } private void startClient() { new Thread(() -> { // Run the client in a separate thread try (Socket socket = new Socket("localhost", CommonConstants.SERVER_PORT); // Connect to the server PrintWriter out = new PrintWriter(socket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) { out.println(CommonConstants.MESSAGE_TO_SERVER); // Send a message System.out.println("Sent to server: " + CommonConstants.MESSAGE_TO_SERVER); String response = in.readLine(); System.out.println("Received from server: " + response); } catch (UnknownHostException e) { System.err.println("Don't know about host localhost"); } catch (IOException e) { System.err.println("Couldn't get I/O for the connection to localhost: " + e.getMessage()); } }).start(); } } ``` **4. Main Mod Class** This is the core class that Forge uses to load your mod. ```java // SimpleMCPMod.java import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.common.event.FMLInitializationEvent; import net.minecraftforge.fml.common.event.FMLPreInitializationEvent; import net.minecraftforge.fml.common.SidedProxy; @Mod(modid = CommonConstants.MOD_ID, name = CommonConstants.MOD_NAME, version = CommonConstants.MOD_VERSION) public class SimpleMCPMod { @SidedProxy(clientSide = "ClientProxy", serverSide = "ServerProxy") public static ServerProxy proxy; // Changed to ServerProxy @Mod.EventHandler public void preInit(FMLPreInitializationEvent event) { // Pre-initialization code (e.g., configuration loading) } @Mod.EventHandler public void init(FMLInitializationEvent event) { // Initialization code (e.g., registering blocks, items, recipes) proxy.init(); // Call the init method of the appropriate proxy } } ``` **5. `mcmod.info` (Required)** Create a `mcmod.info` file in the root of your mod's source directory (usually `src/main/resources`). This file tells Minecraft about your mod. ```json [ { "modid": "simplemcp", "name": "Simple MCP Mod", "description": "A simple example mod demonstrating client-server communication.", "version": "1.0", "mcversion": "1.12.2", // Or your Minecraft version "authorList": ["Your Name"], "credits": "MCP, Forge, and you!", "url": "" } ] ``` **How to Run:** 1. **MCP Setup:** Ensure your MCP environment is correctly set up for your Minecraft version. 2. **Forge Installation:** Make sure Forge is installed in your development environment. 3. **Code Placement:** Place the Java files in the correct package structure within your `src/main/java` directory. Place the `mcmod.info` file in `src/main/resources`. 4. **Recompile:** Recompile your mod using the MCP commands (e.g., `gradlew build`). 5. **Run Minecraft:** Run Minecraft from your development environment (using the MCP run configurations). Make sure you run both the client and the server. 6. **Check Logs:** Look at the Minecraft client and server logs (usually in the `logs` directory) to see the output from the `System.out.println` statements. You should see the messages being exchanged. **Explanation:** * **`CommonConstants`:** Holds shared information like the mod ID, name, version, and the port number for the server. * **`ServerProxy`:** This class runs on the *server* side. It creates a `ServerSocket` to listen for incoming connections on the specified port. When a client connects, it reads a message from the client and sends a response. The server runs in a separate thread to avoid blocking the main Minecraft server thread. * **`ClientProxy`:** This class runs on the *client* side. It creates a `Socket` to connect to the server. It sends a message to the server and then waits for a response. The client also runs in a separate thread. * **`SimpleMCPMod`:** This is the main mod class. The `@Mod` annotation tells Forge that this is a mod. The `@SidedProxy` annotation tells Forge to load either the `ClientProxy` or the `ServerProxy` depending on whether the code is running on the client or the server. The `init` method is called during the Minecraft initialization process. * **`mcmod.info`:** Provides metadata about your mod. **Important Notes:** * **Threading:** Using `new Thread(() -> ...).start()` is a basic way to handle networking in a separate thread. In a real Minecraft mod, you should use Forge's built-in threading mechanisms for better integration with the game. * **Error Handling:** The error handling in this example is very basic. You should add more robust error handling to catch exceptions and prevent crashes. * **Forge Networking:** For a real mod, *use Forge's networking system*. It provides a more reliable and efficient way to communicate between the client and the server. Look into `SimpleNetworkWrapper` and message handlers. * **Security:** Be very careful about what data you send between the client and the server. Never trust data from the client. Validate all data on the server side to prevent exploits. * **Synchronization:** If you are modifying Minecraft data (e.g., player inventories, world data) from the networking threads, you will need to use proper synchronization to avoid race conditions and data corruption. Use `Minecraft.getMinecraft().addScheduledTask()` on the client and `MinecraftServer.addScheduledTask()` on the server to execute code on the main thread. **Chinese Translation (Simplified Chinese):** 好的，这是一个简单的 MCP (Minecraft Coder Pack) 客户端-服务器设置的例子，重点在于核心概念，并使用简化的代码以求清晰。 这个例子演示了一个基本的消息交换。 请记住，一个真实的 Minecraft Mod 会复杂得多。 **重要注意事项：** * **MCP 设置：** 这假设你已经设置了一个可用的 MCP 开发环境。 这是运行任何这些代码的*必要条件*。 请按照你的 Minecraft 版本的官方 MCP 文档进行操作。 * **Minecraft Forge：** 你需要 Minecraft Forge 来创建 Mod。 确保你拥有适用于你的 MCP 版本的正确 Forge 版本。 * **简化：** 这是一个*非常*简化的例子。 它不处理错误情况、复杂数据或正确的 Minecraft 线程处理。 它的目的是说明基本结构。 * **网络：** Minecraft Forge 提供了自己的网络系统，这才是你应该用于真实 Mod 的。 这个例子为了简单起见使用了标准的 Java 套接字，但不建议用于生产 Mod。 **1. 通用代码（客户端和服务器之间共享）** 创建一个类来保存常量和共享数据。 这有助于保持组织性。 ```java // CommonConstants.java public class CommonConstants { public static final String MOD_ID = "simplemcp"; public static final String MOD_NAME = "Simple MCP Mod"; public static final String MOD_VERSION = "1.0"; public static final int SERVER_PORT = 12345; // 选择一个端口 public static final String MESSAGE_TO_SERVER = "来自客户端的问候！"; public static final String MESSAGE_FROM_SERVER = "来自服务器的问候！"; } ``` **2. 服务器端（Minecraft 服务器 Mod）** 创建一个将在 Minecraft 服务器上运行的类。 ```java // ServerProxy.java (或 ServerSide.java 等) import java.io.*; import java.net.*; public class ServerProxy { public void init() { // 服务器端初始化代码（例如，注册命令、事件处理程序） System.out.println("ServerProxy init"); startServer(); } private void startServer() { new Thread(() -> { // 在单独的线程中运行服务器 try (ServerSocket serverSocket = new ServerSocket(CommonConstants.SERVER_PORT)) { System.out.println("服务器在端口 " + CommonConstants.SERVER_PORT + " 上启动"); while (true) { // 持续监听连接 try (Socket clientSocket = serverSocket.accept(); PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) { System.out.println("客户端已连接: " + clientSocket.getInetAddress().getHostAddress()); String inputLine = in.readLine(); System.out.println("从客户端收到: " + inputLine); out.println(CommonConstants.MESSAGE_FROM_SERVER); // 发送响应 System.out.println("发送到客户端: " + CommonConstants.MESSAGE_FROM_SERVER); } catch (IOException e) { System.err.println("处理客户端时发生异常: " + e.getMessage()); } } } catch (IOException e) { System.err.println("无法监听端口 " + CommonConstants.SERVER_PORT + ": " + e.getMessage()); } }).start(); } } ``` **3. 客户端（Minecraft 客户端 Mod）** 创建一个将在 Minecraft 客户端上运行的类。 ```java // ClientProxy.java (或 ClientSide.java 等) import java.io.*; import java.net.*; public class ClientProxy { public void init() { // 客户端初始化代码（例如，注册按键绑定、事件处理程序） System.out.println("ClientProxy init"); startClient(); } private void startClient() { new Thread(() -> { // 在单独的线程中运行客户端 try (Socket socket = new Socket("localhost", CommonConstants.SERVER_PORT); // 连接到服务器 PrintWriter out = new PrintWriter(socket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) { out.println(CommonConstants.MESSAGE_TO_SERVER); // 发送消息 System.out.println("发送到服务器: " + CommonConstants.MESSAGE_TO_SERVER); String response = in.readLine(); System.out.println("从服务器收到: " + response); } catch (UnknownHostException e) { System.err.println("不知道主机 localhost"); } catch (IOException e) { System.err.println("无法获取到 localhost 的连接的 I/O: " + e.getMessage()); } }).start(); } } ``` **4. 主 Mod 类** 这是 Forge 用于加载你的 Mod 的核心类。 ```java // SimpleMCPMod.java import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.common.event.FMLInitializationEvent; import net.minecraftforge.fml.common.event.FMLPreInitializationEvent; import net.minecraftforge.fml.common.SidedProxy; @Mod(modid = CommonConstants.MOD_ID, name = CommonConstants.MOD_NAME, version = CommonConstants.MOD_VERSION) public class SimpleMCPMod { @SidedProxy(clientSide = "ClientProxy", serverSide = "ServerProxy") public static ServerProxy proxy; // 更改为 ServerProxy @Mod.EventHandler public void preInit(FMLPreInitializationEvent event) { // 预初始化代码（例如，配置加载） } @Mod.EventHandler public void init(FMLInitializationEvent event) { // 初始化代码（例如，注册方块、物品、配方） proxy.init(); // 调用相应代理的 init 方法 } } ``` **5. `mcmod.info` (必需)** 在你的 Mod 的源目录的根目录（通常是 `src/main/resources`）中创建一个 `mcmod.info` 文件。 此文件告诉 Minecraft 关于你的 Mod 的信息。 ```json [ { "modid": "simplemcp", "name": "Simple MCP Mod", "description": "一个简单的示例 Mod，演示客户端-服务器通信。", "version": "1.0", "mcversion": "1.12.2", // 或你的 Minecraft 版本 "authorList": ["你的名字"], "credits": "MCP, Forge, 和你!", "url": "" } ] ``` **如何运行：** 1. **MCP 设置：** 确保你的 MCP 环境已为你的 Minecraft 版本正确设置。 2. **Forge 安装：** 确保 Forge 已安装在你的开发环境中。 3. **代码放置：** 将 Java 文件放置在 `src/main/java` 目录中的正确包结构中。 将 `mcmod.info` 文件放置在 `src/main/resources` 中。 4. **重新编译：** 使用 MCP 命令重新编译你的 Mod（例如，`gradlew build`）。 5. **运行 Minecraft：** 从你的开发环境运行 Minecraft（使用 MCP 运行配置）。 确保你同时运行客户端和服务器。 6. **检查日志：** 查看 Minecraft 客户端和服务器日志（通常在 `logs` 目录中）以查看 `System.out.println` 语句的输出。 你应该看到消息正在交换。 **解释：** * **`CommonConstants`：** 保存共享信息，例如 Mod ID、名称、版本和服务器的端口号。 * **`ServerProxy`：** 此类在*服务器*端运行。 它创建一个 `ServerSocket` 以侦听指定端口上的传入连接。 当客户端连接时，它从客户端读取消息并发送响应。 服务器在单独的线程中运行，以避免阻塞主 Minecraft 服务器线程。 * **`ClientProxy`：** 此类在*客户端*端运行。 它创建一个 `Socket` 以连接到服务器。 它向服务器发送消息，然后等待响应。 客户端也在单独的线程中运行。 * **`SimpleMCPMod`：** 这是主 Mod 类。 `@Mod` 注释告诉 Forge 这是一个 Mod。 `@SidedProxy` 注释告诉 Forge 根据代码是在客户端还是服务器上运行来加载 `ClientProxy` 或 `ServerProxy`。 `init` 方法在 Minecraft 初始化过程中被调用。 * **`mcmod.info`：** 提供关于你的 Mod 的元数据。 **重要提示：** * **线程处理：** 使用 `new Thread(() -> ...).start()` 是一种在单独的线程中处理网络的基本方法。 在真实的 Minecraft Mod 中，你应该使用 Forge 的内置线程机制，以便更好地与游戏集成。 * **错误处理：** 此示例中的错误处理非常基本。 你应该添加更强大的错误处理来捕获异常并防止崩溃。 * **Forge 网络：** 对于真实的 Mod，*使用 Forge 的网络系统*。 它提供了一种更可靠和高效的方式来在客户端和服务器之间进行通信。 查找 `SimpleNetworkWrapper` 和消息处理程序。 * **安全性：** 非常小心你在客户端和服务器之间发送的数据。 永远不要信任来自客户端的数据。 在服务器端验证所有数据以防止漏洞利用。 * **同步：** 如果你要从网络线程修改 Minecraft 数据（例如，玩家库存、世界数据），你将需要使用适当的同步来避免竞争条件和数据损坏。 在客户端上使用 `Minecraft.getMinecraft().addScheduledTask()`，在服务器上使用 `MinecraftServer.addScheduledTask()` 以在主线程上执行代码。 This translation should be helpful. Remember to adapt the code and comments to your specific needs and Minecraft version. Good luck!

Remote MCP Server

A Cloudflare Workers-based implementation of a Model Context Protocol server that enables AI assistants like Claude to access external tools through OAuth authentication.

Knowledge MCP Service

Enables AI-powered document analysis and querying for project documentation using vector embeddings stored in Redis. Supports document upload, context-aware Q\&A, automatic test case generation, and requirements traceability through OpenAI integration.

FiveM MCP Server

A TypeScript-based server that provides debugging and management capabilities for FiveM plugin development, allowing developers to control plugins, monitor server logs, and execute RCON commands.

@mcpdotdirect/template-mcp-server

快速设置您自己的 MCP 服务器的模板