Discover Awesome MCP Servers

Skill Management MCP Server

Enables Claude to create, edit, run, and manage reusable skills stored locally, including executing scripts with automatic dependency management and environment variables. Works across all MCP-compatible clients like Cursor, Claude Desktop, and claude.ai.

BlenderMCP

Connects Blender to Claude AI through the Model Context Protocol (MCP), enabling prompt-assisted 3D modeling, scene creation, and manipulation.

ZeroTrusted-ai PII Detection Agent

ZeroTrusted-ai PII Detection Agent

Bargainer MCP Server

A Model Context Protocol server that aggregates and compares deals from multiple sources including Slickdeals, RapidAPI marketplace, and web scraping, enabling users to search, filter, and compare deals through a chat interface.

Gemini Context MCP Server

镜子 (jìng zi)

Greenhouse MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Greenhouse (beta): https://www.cdata.com/download/download.aspx?sku=PGZK-V&type=beta

Flexible Key-Value Extracting MCP Server

Extracts structured key-value pairs from arbitrary, noisy, or unstructured text using LLMs and provides output in multiple formats (JSON, YAML, TOML) with type safety.

MCP Documentation Server

A server that provides organized documentation content for various applications using the Model Context Protocol, enabling AI assistants to access quickstart guides and code examples.

Weekly Weather

Weather forecast server which returns 7 days of detailed weather anywhere in the world, using the OpenWeatherMap One Call API 3.0.

steampipe-mcp

steampipe-mcp

İhale MCP

Enables users to search and access Turkish public procurement data from EKAP v2 portal. Provides comprehensive tender search, detailed tender information, announcements, and authority/classification code lookups through natural language interactions.

python-base-mcp-server

一个用于快速引导基于 Python 的 MCP 服务器的 Cookiecutter 模板。

IoT Realm MCP Server 🌐🔌

🌐🔌 An MCP server that exposes real-time sensor data from IoT Realm devices—such as ESP32-based DHT11 clients—to LLMs via the Model Context Protocol. This enables AI agents to access, analyze, and act upon live environmental data.

Hubble MCP Server

A Python-based Model Context Protocol server that integrates with Claude Desktop, allowing users to connect to Hubble API services by configuring the server with their Hubble API key.

Jina AI Remote MCP Server

Provides access to Jina AI's suite of tools including web search, URL reading, image search, embeddings, and reranking capabilities. Enables users to extract web content as markdown, search academic papers, capture screenshots, and perform semantic operations through natural language.

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.

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!

MCP Link - Convert Any OpenAPI V3 API to MCP Server

Okay, here's the translation of "Convert Any OpenAPI V3 API to MCP Server" into Chinese, along with a few options depending on the nuance you want to convey: **Option 1 (Most Literal and General):** * **将任何 OpenAPI V3 API 转换为 MCP 服务器** * (Jiāng rènhé OpenAPI V3 API zhuǎnhuàn wéi MCP fúwùqì) This is a direct translation and suitable for most contexts. It's clear and understandable. **Option 2 (More Technical and Emphasizing the Conversion Process):** * **把任意 OpenAPI V3 API 转换成 MCP 服务器** * (Bǎ rènyì OpenAPI V3 API zhuǎnhuàn chéng MCP fúwùqì) This is very similar to Option 1, but using "把" (bǎ) can subtly emphasize the action of converting. "任意" (rènyì) is a slightly more formal way of saying "any" than "任何" (rènhé). **Option 3 (Focusing on Enabling an API as an MCP Server):** * **使任何 OpenAPI V3 API 能够作为 MCP 服务器运行** * (Shǐ rènhé OpenAPI V3 API nénggòu zuòwéi MCP fúwùqì yùnxíng) This option emphasizes the *result* of the conversion, which is that the API can now function as an MCP server. It's a bit longer but more descriptive. **Option 4 (Concise and Common in Technical Contexts):** * **OpenAPI V3 API 到 MCP 服务器转换** * (OpenAPI V3 API dào MCP fúwùqì zhuǎnhuàn) This is a more concise, noun-phrase version, common in titles or headings. It translates to "OpenAPI V3 API to MCP Server Conversion." **Which option is best depends on the specific context:** * For general communication, **Option 1** is a good choice. * If you want to emphasize the *process* of conversion, **Option 2** is suitable. * If you want to highlight the *functionality* gained after conversion, **Option 3** is better. * For a title or heading, **Option 4** is often preferred. Therefore, without more context, I recommend **Option 1: 将任何 OpenAPI V3 API 转换为 MCP 服务器** as the most generally applicable translation.

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.

Weather MCP Server

Provides weather information for cities through a protected MCP interface with Nevermined payment integration. Demonstrates both high-level and low-level MCP server implementations with paywall protection for tools, resources, and prompts.

Serverless VPC Access MCP Server

An auto-generated MCP server for Google's Serverless VPC Access API, enabling communication with Google Cloud VPC networks through natural language interactions.

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.

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.

ddg--mcp6

A basic MCP server template with example tools for echoing messages and retrieving server information. Built with FastMCP framework and supports both stdio and HTTP transports for integration with various clients.

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.