发现优秀的 MCP 服务器

Shell-MCP

一个安全的 MCP 服务器，用于执行白名单中的 shell 命令，并具有资源和超时控制，专为与 Claude 和其他 MCP 兼容的 LLM 集成而设计。

Flight Ticket MCP Server

A server that provides real-time flight information query capabilities to AI assistants, allowing them to access detailed flight statuses, airport details, and related travel information.

Binance Cryptocurrency MCP

提供对币安加密货币市场数据的实时访问的 MCP 服务，允许 AI 代理通过自然语言查询获取当前价格、订单簿、蜡烛图和交易统计数据。

Honeybadger MCP Server

Integrates Honeybadger error tracking with Cursor IDE, allowing developers to fetch, analyze, and troubleshoot application errors directly from their development environment.

Aider MCP Server

允许 Claude Code 将 AI 编码任务卸载到 Aider，从而降低成本并能够更好地控制哪些模型处理特定的编码任务。

🌐 Web Browser MCP Server

镜子 (jìng zi)

MCP Stock Details Server

A Model Context Protocol server providing comprehensive Korean stock market analysis, including financial data, valuation metrics, ESG information, and investment insights.

MySQL MCP Server

镜子 (jìng zi)

Naver MCP Server

一个 MCP 服务器，提供对 Naver OpenAPI 服务的访问，使用户能够通过标准化的模型上下文协议接口搜索博客、新闻、书籍、图像和其他内容。

Databutton MCP Server

一个 MCP 服务器，用于进行初步的应用程序规划，并在 Databutton 中创建一个良好的起点——它启动一个新的应用程序并生成初始的 MVP（最小可行产品）任务。

MemGPT MCP Server

一个基于 TypeScript 的服务器，为大型语言模型 (LLM) 提供记忆系统，允许用户与多个 LLM 提供商交互，同时保持对话历史记录，并提供管理提供商和模型配置的工具。

Second Opinion MCP Server

利用谷歌 Gemini AI 提供 AI 驱动的编码问题协助，结合 Perplexity 的洞察和 Stack Overflow 的参考资料，促进上下文分析和自动响应存档，以改进故障排除。

Serper MCP Server

A Model Context Protocol server that enables LLMs to perform Google searches via the Serper API, allowing models to retrieve current information from the web.

Notion MCP Integration

Notion MCP 集成是一个轻量级的模型上下文协议 (MCP) 服务器，它与 Notion 的 API 无缝集成，通过 Claude 管理一个极简的个人待办事项列表。该项目提供了专门为简单 Notion 数据库结构量身定制的基本功能，从而实现高效的任务管理，而无需不必要的复杂性。

Serveur MCP Simple pour Service d'Heure

一个简单的MCP服务器，提供当前时间服务。

DBCode

DBCode 是一个 Visual Studio Code 扩展，它允许你管理许多数据库，包括 PostgreSQL、MySQL、SQL Server、DuckDB、Redis、MongoDB 等等。 DBCode 提供了运行 MCP 服务器的选项，从而可以访问这些数据库、它们的模式，以及执行查询的能力。

Playwright Universal MCP

用于在容器化环境中进行浏览器自动化的通用 Playwright MCP 服务器

MCP Server Manager

用于创建、管理和运行 MCP（模型上下文协议）服务器的图形界面和 CLI，具有实时监控和简化的配置。

Google Home MCP Server

允许用户使用带有 OAuth2 身份验证的智能家居 API 控制 Google Home 智能插座，提供实时设备状态管理和控制操作。

Goose App Maker MCP

This MCP server allows users to create, manage, and serve web applications through Goose, storing apps in configurable directories and providing web app serving capabilities.

Resend MCP Server

允许通过标准化的模型上下文协议 (MCP) 接口，使用 Resend 服务发送电子邮件，并提供 TypeScript 支持。

MCP Starter Project

Okay, here's a breakdown of how to set up an MCP (Mod Configuration Protocol) server and client, along with explanations and considerations: **Understanding MCP (Mod Configuration Protocol)** MCP is a protocol used in Minecraft modding to allow mods to communicate configuration information between the server and the client. This is particularly useful for: * **Synchronizing Configuration:** Ensuring that both the server and client are using the same settings for a mod. This prevents inconsistencies and potential errors. * **Server-Side Configuration:** Allowing the server administrator to control certain aspects of a mod's behavior, even for clients. * **Dynamic Configuration:** Enabling mods to change their behavior based on server-side settings. **General Steps (Conceptual)** The exact implementation of MCP varies depending on the modding framework you're using (Forge, Fabric, etc.) and the specific mod. However, the general steps are: 1. **Mod Implementation:** * **Server-Side:** The mod needs to have code that defines the configuration options it wants to synchronize. This code will typically: * Define the configuration options (e.g., using a configuration file or a data structure). * Implement logic to send these configuration options to connected clients. * Handle changes to the configuration on the server. * **Client-Side:** The mod needs to have code that: * Receives the configuration options from the server. * Applies these options to the mod's behavior. * Potentially allows the client to override certain options (if the mod allows it). 2. **Networking:** * MCP relies on a networking channel between the server and the client. This channel is used to send the configuration data. * The mod needs to register a channel with the modding framework (Forge, Fabric) and define how data is serialized and deserialized for transmission. 3. **Configuration Management:** * The mod needs a way to store and manage the configuration options. This could involve: * Configuration files (e.g., `.cfg` files). * In-memory data structures. * Databases (for more complex configurations). **Example (Conceptual - Forge)** This is a simplified example to illustrate the concepts. The actual code will be more complex. **Server-Side (Example - Forge)** ```java import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.common.event.FMLServerStartingEvent; import net.minecraftforge.fml.common.network.NetworkRegistry; import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper; import net.minecraftforge.fml.relauncher.Side; @Mod(modid = "mymod", name = "My Mod", version = "1.0") public class MyMod { public static SimpleNetworkWrapper network; @Mod.EventHandler public void serverStarting(FMLServerStartingEvent event) { network = NetworkRegistry.INSTANCE.newSimpleChannel("mymod_channel"); network.registerMessage(ConfigMessage.Handler.class, ConfigMessage.class, 0, Side.CLIENT); // Register message for client // Load configuration from file (example) MyConfig.loadConfig(); // Send config to all players when they join (example) event.getServer().getPlayerList().addListener(new ServerPlayerListListener()); } public static class MyConfig { public static int myValue = 10; // Example config value public static void loadConfig() { // Load from config file (implementation omitted) // Example: myValue = ConfigHandler.getInt("myValue", 10); } } } // Message class to send config data public class ConfigMessage implements IMessage { public int myValue; public ConfigMessage() {} // Required empty constructor public ConfigMessage(int myValue) { this.myValue = myValue; } @Override public void fromBytes(ByteBuf buf) { myValue = buf.readInt(); } @Override public void toBytes(ByteBuf buf) { buf.writeInt(myValue); } public static class Handler implements IMessageHandler<ConfigMessage, IMessage> { @Override public IMessage onMessage(ConfigMessage message, MessageContext ctx) { // This is executed on the CLIENT side Minecraft.getMinecraft().addScheduledTask(() -> { MyModClient.myValue = message.myValue; // Update client-side config }); return null; } } } // Listener to send config to players when they join public class ServerPlayerListListener implements IPlayerListListener { @Override public void playerLoggedOut(EntityPlayerMP player) {} @Override public void playerLoggedOut(ITextComponent chatComponent) {} @Override public void playerLoggedIn(EntityPlayerMP player) { // Send the config to the player MyMod.network.sendTo(new ConfigMessage(MyMod.MyConfig.myValue), player); } @Override public void playerLoggedIn(ITextComponent chatComponent) {} } ``` **Client-Side (Example - Forge)** ```java import net.minecraft.client.Minecraft; import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.common.event.FMLInitializationEvent; @Mod(modid = "mymod_client", name = "My Mod Client", version = "1.0", clientSideOnly = true) public class MyModClient { public static int myValue = 0; // Default value @Mod.EventHandler public void init(FMLInitializationEvent event) { // No need to register the channel here, it's already registered on the server. // The ConfigMessage.Handler will be executed when the message is received. } } ``` **Explanation of the Forge Example:** * **`SimpleNetworkWrapper`:** Forge's class for managing network channels. * **`registerMessage`:** Registers a message type (`ConfigMessage`) with the network channel. It specifies the handler class, the message class, a message ID, and the side (client or server) where the handler should run. * **`ConfigMessage`:** A class that implements `IMessage`. It contains the data you want to send (in this case, `myValue`). It also has `fromBytes` and `toBytes` methods to serialize and deserialize the data. * **`ConfigMessage.Handler`:** A class that implements `IMessageHandler`. This is where you handle the received message. In this example, it updates the client-side `myValue` with the value received from the server. **Important:** The handler runs on the *client* side. You need to use `Minecraft.getMinecraft().addScheduledTask()` to ensure that the update happens on the main client thread. * **`ServerPlayerListListener`:** A listener that is triggered when a player joins the server. It sends the current server-side configuration to the newly joined player. * **`sendTo`:** Sends the `ConfigMessage` to a specific player. **Key Considerations:** * **Modding Framework:** The specific classes and methods you use will depend on the modding framework you're using (Forge, Fabric, etc.). Refer to the documentation for your framework. * **Message IDs:** Each message type needs a unique ID. These IDs are used to identify the message when it's received. * **Serialization:** You need to carefully serialize and deserialize the data you're sending. Use the `ByteBuf` class to read and write data. * **Thread Safety:** Minecraft is a multi-threaded environment. Make sure your code is thread-safe, especially when updating client-side data. Use `Minecraft.getMinecraft().addScheduledTask()` to execute code on the main client thread. * **Configuration Files:** Use a configuration library (e.g., Forge's configuration system) to manage your configuration files. * **Error Handling:** Implement proper error handling to catch exceptions and prevent crashes. * **Security:** Be careful about what data you send over the network. Don't send sensitive information. **Fabric Example (Conceptual)** Fabric uses a different approach to networking. Here's a conceptual outline: ```java import net.fabricmc.api.ModInitializer; import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking; import net.fabricmc.fabric.api.networking.v1.ClientPlayNetworking; import net.minecraft.util.Identifier; import net.minecraft.network.PacketByteBuf; import net.minecraft.server.network.ServerPlayerEntity; import net.minecraft.client.MinecraftClient; public class MyMod implements ModInitializer { public static final String MOD_ID = "mymod"; public static final Identifier CONFIG_SYNC_ID = new Identifier(MOD_ID, "config_sync"); public static int myValue = 10; // Example config value @Override public void onInitialize() { // Server-side ServerPlayNetworking.registerGlobalReceiver(CONFIG_SYNC_ID, (server, player, handler, buf, responseSender) -> { // This is executed on the SERVER thread int receivedValue = buf.readInt(); server.execute(() -> { // Update server-side config (if needed) // MyMod.myValue = receivedValue; // Example }); }); // Client-side ClientPlayNetworking.registerGlobalReceiver(CONFIG_SYNC_ID, (client, handler, buf, responseSender) -> { // This is executed on the CLIENT thread int receivedValue = buf.readInt(); client.execute(() -> { // Update client-side config MyModClient.myValue = receivedValue; }); }); } // Method to send config to a player (server-side) public static void sendConfigToPlayer(ServerPlayerEntity player) { PacketByteBuf buf = new PacketByteBuf(Unpooled.buffer()); buf.writeInt(MyMod.myValue); ServerPlayNetworking.send(player, CONFIG_SYNC_ID, buf); } } // Client-side class public class MyModClient { public static int myValue = 0; } ``` **Explanation of the Fabric Example:** * **`Identifier`:** Used to uniquely identify the network channel. * **`ServerPlayNetworking.registerGlobalReceiver`:** Registers a handler for incoming packets on the server. * **`ClientPlayNetworking.registerGlobalReceiver`:** Registers a handler for incoming packets on the client. * **`PacketByteBuf`:** Fabric's equivalent of Forge's `ByteBuf`. Used for serializing and deserializing data. * **`server.execute()` and `client.execute()`:** Used to execute code on the main server or client thread, respectively. **Steps to Set Up (General):** 1. **Set up your mod development environment:** Install the appropriate modding framework (Forge, Fabric) and set up your IDE (IntelliJ IDEA, Eclipse). 2. **Create your mod project:** Create a new mod project using the framework's tools. 3. **Define your configuration options:** Decide what configuration options you want to synchronize. 4. **Implement the server-side code:** Implement the code to load the configuration, register the network channel, and send the configuration to clients. 5. **Implement the client-side code:** Implement the code to receive the configuration and apply it to the mod's behavior. 6. **Test your mod:** Test your mod in a single-player and multiplayer environment to ensure that the configuration is synchronized correctly. **Important Notes:** * **Refer to the documentation:** The documentation for your modding framework is your best resource for detailed information and examples. * **Start simple:** Start with a simple configuration option and gradually add more complexity. * **Debug carefully:** Use debugging tools to identify and fix any issues. This information should give you a good starting point for setting up an MCP server and client. Remember to adapt the code to your specific needs and the modding framework you're using. Good luck!

SAP MCP Server

Enables interaction with SAP systems through RESTful APIs via MCP protocol. Supports calling SAP functions like BAPI with parameters and returns structured responses for SAP data operations.

MCP Telemetry

可观测性有所帮助。此 MCP 服务器为你在 Claude（或合适的 MCP 客户端）上的所有对话添加追踪功能，以便你可以追踪、理解、调试和报告你的所有互动。

Slack Lists MCP Server

Enables AI assistants to interact with Slack Lists through comprehensive tools for creating, retrieving, filtering, and managing list items. Supports bulk operations, data export, subtask creation, and all Slack List field types with robust error handling and production-ready implementation.