MCP Servers

Discover Awesome MCP Servers

Extend your agent with 15,422 capabilities via MCP servers.

All15,422

Bilibili MCP 服务器

WIP: MCP Server Superset

大規模言語モデルがREST APIを通じてApache Supersetデータベースとやり取りできるようにするモデルコンテキストプロトコルサーバー。データベースクエリ、テーブルルックアップ、フィールド情報取得、SQL実行をサポートします。

MCP Server

FastAPIをベースとしたModel Context Protocolの実装。AIモデルと開発環境間の標準化されたやり取りを可能にし、開発者がAIタスクをより簡単に統合および管理できるようにする。

FastMCP 🚀

Model Context Protocolサーバーを構築するための高速でPythonicな方法🚀

Workers MCP Server

Claude DesktopからCloudflare Workerと通信しましょう！

Query MCP (Supabase MCP Server)

Podman MCP Server

コンテナランタイム（PodmanおよびDocker）用のModel Context Protocol（MCP）サーバー

Recall MCP Server

基本的なRecall機能（バケットの一覧表示、アカウント残高の取得、オブジェクトの作成など）を公開するシンプルなMCPサーバー

HAN JIE

123123 (そのまま)

What is Model Context Protocol (MCP)?

軽量なモデルコンテキストプロトコル（MCP）サーバー。LLMがメールアドレスを検証できるようにします。このツールは、AbstractAPI Email Validation APIを使用して、メールの形式、ドメインの有効性、および配信可能性をチェックします。Claude DesktopのようなAIアプリケーションにメール検証を統合するのに最適です。

Claude Desktop Commander MCP

Claude があなたのコンピューター上でターミナルコマンドを実行し、差分ベースの置換による外科的なコード編集を含むファイルシステム操作を実行できるようにします。

Dify as MCP Server

Difyアプリケーション（ChatflowとWorkflowの両方）をMCP（Model Context Protocol）サーバーとして公開し、Claudeやその他のMCPクライアントが標準化されたプロトコルを通じてDifyアプリと直接やり取りできるようにします。

imagegen-go MCP 服务器

MCPサーバーで、OpenAIに画像の生成をトリガーさせる。

Weather MCP Server

天気情報を提供するモデルコンテキストプロトコルサーバー

🤖 Claude AI Documentation Assistant 📚

複数のAI/MLライブラリにわたって、自然言語によるクエリを通じて技術情報を取得・処理できるように、Claudeと連携してスマートなドキュメント検索機能を提供するMCPサーバー。

mcp-oceanbase

OceanBase データベース用の MCP サーバーとそのツール

@modelcontextprotocol/server-terminal

鏡 (Kagami)

Code Analyzer MCP Server

コードのバグ、エラー、および機能上の問題を分析するためのMCPサーバー

ModelContextProtocol (MCP) Java SDK v0.8.0 Specification

Okay, here are instructions for an AI on how to create a Java-based Minecraft Protocol (MCP) server and client. This is a complex task, so these instructions are high-level and will require significant coding and understanding of the Minecraft protocol. **Overall Goal:** To create a basic Java application that can: 1. **Server:** Listen for incoming Minecraft client connections, handle the handshake and status requests, and potentially send a simple game state. 2. **Client:** Connect to a Minecraft server (either the one you create or a standard Minecraft server), perform the handshake, request the server status, and potentially send simple game actions. **I. Understanding the Minecraft Protocol (MCP)** * **Crucial:** You *must* understand the Minecraft Protocol. It's a binary protocol with specific packet structures. Refer to these resources: * **Wiki.vg:** This is the *definitive* resource. It documents the protocol versions, packet structures, data types, and state transitions. [https://wiki.vg/Protocol](https://wiki.vg/Protocol) * **Other Online Resources:** Search for tutorials and examples, but *always* verify against Wiki.vg. Many older tutorials are outdated. * **Key Concepts:** * **Protocol Versions:** Minecraft uses different protocol versions for different game versions. You *must* choose a specific version to target. Start with a relatively recent, stable version (e.g., 1.19.x or 1.20.x). * **States:** The connection goes through different states: Handshaking, Status, Login, Play. Each state has its own set of packets. * **Packets:** Data is exchanged in packets. Each packet has an ID and a data payload. The structure of the payload depends on the packet ID and the protocol version. * **Data Types:** The protocol uses specific data types like VarInt, VarLong, strings, integers, booleans, etc. You need to handle these correctly. * **Compression:** The protocol can use compression to reduce bandwidth. You'll need to implement compression/decompression if enabled. * **Encryption:** The protocol can use encryption to secure the connection. You'll need to implement encryption/decryption if enabled. **II. Project Setup (Java)** 1. **IDE:** Use a Java IDE like IntelliJ IDEA, Eclipse, or VS Code with Java support. 2. **Project Structure:** Create a project with separate packages for: * `server`: Server-side code. * `client`: Client-side code. * `protocol`: Classes for handling the Minecraft protocol (packets, data types, etc.). * `util`: Utility classes (e.g., for logging, data conversion). 3. **Dependencies:** You might need external libraries: * **Netty (io.netty):** A powerful asynchronous event-driven network application framework. Highly recommended for handling network connections efficiently. (Add as a Maven or Gradle dependency). * **Gson (com.google.code.gson):** For JSON serialization/deserialization (used in the status response). (Add as a Maven or Gradle dependency). * **SLF4J (org.slf4j):** A logging facade. Use it with a logging implementation like Logback or Log4j2. (Add as a Maven or Gradle dependency). * **Zlib (java.util.zip):** For compression/decompression. Java's built-in Zlib library is sufficient. * **Bouncy Castle (org.bouncycastle):** For encryption/decryption. (Add as a Maven or Gradle dependency). **III. Server Implementation** 1. **Server Class:** * Create a `MinecraftServer` class. * Use `ServerSocket` or, preferably, Netty's `ServerBootstrap` to listen for incoming connections on a specific port (e.g., 25565). * Handle incoming connections in a separate thread or using Netty's event loop. 2. **Connection Handling:** * Create a `ClientConnection` class to represent each connected client. * Maintain the connection state (Handshaking, Status, Login, Play). * Read data from the client's socket. * Parse the incoming data into Minecraft packets. * Handle the packets based on the current state. 3. **Handshaking State:** * Handle the `Handshake` packet (ID 0x00 in most versions). * Extract the protocol version, server address, and port. * Set the connection state based on the "next state" value in the handshake packet (1 for Status, 2 for Login). 4. **Status State:** * Handle the `Status Request` packet (ID 0x00). * Create a `Status Response` packet (ID 0x00). This packet contains a JSON string with server information (MOTD, player count, version name, etc.). Use Gson to create the JSON. Example: ```json { "version": { "name": "My Awesome Server", "protocol": 763 // Example protocol version }, "players": { "max": 100, "online": 10, "sample": [] // Optional: List of player names }, "description": { "text": "Welcome to my server!" } } ``` * Send the `Status Response` packet to the client. * Handle the `Ping` packet (ID 0x01). * Send a `Pong` packet (ID 0x01) with the same payload as the Ping packet. * Close the connection. 5. **Login State (Optional):** * This is more complex and involves authentication. For a basic server, you can skip this and just disconnect the client. 6. **Play State (Optional):** * This is where the actual game logic would go. It's very complex. For a basic server, you can skip this. **IV. Client Implementation** 1. **Client Class:** * Create a `MinecraftClient` class. * Use `Socket` or, preferably, Netty's `Bootstrap` to connect to the server. 2. **Connection Handling:** * Maintain the connection state (Handshaking, Status, Login, Play). * Write data to the server's socket. * Read data from the server's socket. * Parse the incoming data into Minecraft packets. * Handle the packets based on the current state. 3. **Handshaking State:** * Create a `Handshake` packet (ID 0x00). * Set the protocol version, server address, and port. * Set the "next state" to 1 (Status). * Send the `Handshake` packet to the server. 4. **Status State:** * Create a `Status Request` packet (ID 0x00). * Send the `Status Request` packet to the server. * Receive the `Status Response` packet (ID 0x00). * Parse the JSON data from the `Status Response` packet using Gson. * Print the server information (MOTD, player count, version name, etc.). * Create a `Ping` packet (ID 0x01) with a timestamp. * Send the `Ping` packet to the server. * Receive the `Pong` packet (ID 0x01). * Calculate the ping time. * Close the connection. 5. **Login State (Optional):** * This is more complex and involves authentication. For a basic client, you can skip this. 6. **Play State (Optional):** * This is where the actual game logic would go. It's very complex. For a basic client, you can skip this. **V. Packet Handling** 1. **Packet Class:** * Create an abstract `Packet` class. * Define methods for: * `write(OutputStream out)`: Writes the packet data to an output stream. * `read(InputStream in)`: Reads the packet data from an input stream. * `getPacketId()`: Returns the packet ID. 2. **Packet Implementations:** * Create concrete classes for each packet type (e.g., `HandshakePacket`, `StatusRequestPacket`, `StatusResponsePacket`, `PingPacket`, `PongPacket`). * Implement the `write()` and `read()` methods for each packet, handling the specific data types and structure of the packet. 3. **Packet Registry:** * Create a `PacketRegistry` class to map packet IDs to packet classes. * Use a `Map<Integer, Class<? extends Packet>>` to store the mappings. * Provide methods to register packets and to get a packet class by ID. 4. **Data Input/Output:** * Create utility classes for reading and writing Minecraft data types (VarInt, VarLong, strings, etc.). These classes should handle the specific encoding and decoding required by the protocol. **VI. Error Handling** * Implement proper error handling to catch exceptions and log errors. * Handle invalid packets, connection errors, and other potential issues. **VII. Testing** * Test your server and client thoroughly. * Use a Minecraft client to connect to your server and verify that the status information is displayed correctly. * Test with different protocol versions. **VIII. Advanced Features (Optional)** * **Compression:** Implement compression/decompression using Zlib. * **Encryption:** Implement encryption/decryption using Bouncy Castle. * **Login:** Implement the login sequence to authenticate players. * **Play State:** Implement basic game logic in the Play state. * **Plugins:** Design your server to support plugins. **Important Considerations:** * **Complexity:** This is a *very* complex project. Start small and build incrementally. * **Protocol Changes:** The Minecraft protocol changes frequently. Be prepared to update your code when new versions are released. * **Security:** Be aware of security vulnerabilities and take steps to protect your server. * **Performance:** Optimize your code for performance, especially if you plan to handle a large number of players. * **Debugging:** Use a debugger to step through your code and identify issues. Network packet sniffers (like Wireshark) can be invaluable for debugging protocol issues. **Example Code Snippets (Illustrative - Requires Adaptation):** ```java // Example: Writing a VarInt public static void writeVarInt(OutputStream out, int value) throws IOException { while (true) { if ((value & ~0x7F) == 0) { out.write(value); return; } out.write((value & 0x7F) | 0x80); value >>>= 7; } } // Example: Reading a VarInt public static int readVarInt(InputStream in) throws IOException { int numRead = 0; int result = 0; byte read; do { read = (byte) in.read(); int value = (read & 0x7f); result |= (value << (7 * numRead)); numRead++; if (numRead > 5) { throw new RuntimeException("VarInt is too big"); } } while ((read & 0x80) != 0); return result; } // Example: Handshake Packet (Simplified) public class HandshakePacket extends Packet { private int protocolVersion; private String serverAddress; private int serverPort; private int nextState; // Constructor, getters, setters @Override public void write(OutputStream out) throws IOException { writeVarInt(out, protocolVersion); // Write serverAddress (String) - requires writing length first // Write serverPort (int) writeVarInt(out, nextState); } @Override public void read(InputStream in) throws IOException { protocolVersion = readVarInt(in); // Read serverAddress (String) - requires reading length first // Read serverPort (int) nextState = readVarInt(in); } @Override public int getPacketId() { return 0x00; // Handshake packet ID } } ``` **AI Tasks:** 1. **Code Generation:** Generate Java code for specific packets, data types, or server/client components based on the Minecraft protocol documentation. 2. **Error Detection:** Analyze existing code for potential protocol errors or security vulnerabilities. 3. **Protocol Updates:** Automatically update code to support new Minecraft protocol versions. 4. **Documentation:** Generate documentation for the code and the Minecraft protocol. 5. **Testing:** Generate test cases to verify the correctness of the server and client. This is a challenging but rewarding project. Good luck! Remember to start small, test frequently, and consult the Minecraft protocol documentation.

GitHub MCP Server Practice Repository

鏡 (Kagami)