发现优秀的 MCP 服务器

execution-proofs

Verifies AI agent completion claims by checking that claimed output files exist and are fresh, acting as a lightweight physical telemetry gate.

Schwab Read-Only MCP

MCP server for read-only access to Charles Schwab market data and account information. It provides quotes, price history, technical indicators, fundamentals, option chains, market hours, movers, and account/transaction data via the official Schwab API.

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!

memos-api-mcp

MCP server that enables AI assistants to interact with the MemOS API, providing memory search, feedback management, and knowledge base operations via MCP-compliant tools.

Weather MCP Server

一个模型上下文协议（Model Context Protocol）服务器，它使用 Open-Meteo API 获取指定城市的当前天气信息，且无需 API 密钥。

SonarQube MCP Server

Enables seamless integration with SonarQube Server or Cloud for code quality and security analysis. Supports querying project metrics, issues, and analyzing code snippets directly within the agent context.

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.

Roam MCP

MCP server for Roam Research that enables AI assistants like Claude and Cursor to read, write, search, and query your Roam graph with full write access.

portal-api

A read-only MCP server for Portal.io that enables browsing proposals, users, contacts, and catalog items through secure HMAC-signed API requests.

zotero-grounded-mcp

An MCP server that gives any MCP-compatible assistant access to your Zotero reference library, enabling search, citation, bibliography generation, and .docx processing while keeping Zotero as the ground truth for references.

threlte-mcp

An MCP server for inspecting and manipulating Three.js/Threlte scenes in real-time.

ghost-dev-mcp

An MCP server on AWS Lambda that gives AI assistants read-only access to SQS dead-letter queues and CloudWatch logs for fast incident triage.

Infrações Trabalhistas (MTE)

Consulta infrações trabalhistas registradas pelo Ministério do Trabalho e Emprego a partir de CPF ou CNPJ. Enables read-only querying of labor infractions for individuals or companies via MCP.

Notion MCP Integration

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

fortytwo-guide

A semantic-memory MCP server that stores text 'memories' with provenance and enables recall by meaning (vector search), keyword (FTS5), or structured filters.

web-mcp

Worker that turns any URL into agent-callable MCP tools, plus a Chrome extension, open-source adapters, and SDKs. On top of that sits an independent A–F trust graph for the whole MCP ecosystem

Emacs MCP Server

一个模型上下文协议服务器，它能够在运行中的 Emacs 进程中生成和执行 Elisp 代码，从而允许 AI 助手控制 Emacs 并与之交互。

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.

Vision MCP Server

A local MCP server that gives LLMs eyes for images by performing object detection (YOLOv8) and text recognition (EasyOCR), outputting descriptive statements about objects and text positions without any API key or cloud dependency.

MBBank MCP Server

MCP server that provides monitoring and analytics capabilities for MBBank accounts, allowing users to check balances, transaction history, card details, and savings information.

MCP-OPENAPI-DOCX

Enterprise-grade document editing and management server that enables AI-powered operations on Microsoft Word DOCX files, including creating, editing, formatting, and exporting documents through both MCP protocol and RESTful API.

Amazon Connect MCP Server

An MCP server that enables AI assistants to interact with Amazon Connect contact centers, providing 88 tools, 91 configuration templates, and multi-region support.

Grok Web MCP

Automates Grok web interface to provide chat, web search, and conversation management via MCP, supporting multiple accounts and local/remote deployment.

pysnowball MCP Server

MCP server that provides 56 API interfaces covering real-time quotes, financial data, funds, indices, and more from Xueqiu stock data, supporting both MCP and REST protocols.

COBOL Bridge MCP

AI-assisted COBOL to modern stack bridge that parses COBOL programs, maps to Python/Java/Go, generates test harnesses, and plans migration for legacy mainframe modernization.

SQLite Database MCP Server with Google OAuth

Enables AI assistants to perform CRUD operations on a SQLite database, with all tools protected by Google OAuth 2.0 authentication.

personal-mcp

Enables Claude to send you a Discord message through a Cloudflare Workers MCP server, triggering a notification with your Discord mention.

pinterest-mcp

Enables AI agents to manage Pinterest boards and pins, create and update pins, and track analytics via the Pinterest API v5.

agent-browser-mcp

Enables background control of real Chrome browser sessions with persistent session binding and colored tab groups, allowing automation without interfering with user interaction.