Discover Awesome MCP Servers

@modelcontextprotocol/server-terminal

Mirror of

Podman MCP Server

Model Context Protocol (MCP) server for container runtimes (Podman and Docker)

FastMCP 🚀

The fast, Pythonic way to build Model Context Protocol servers 🚀

Dify as MCP Server

Mengekspos aplikasi Dify (baik Chatflow maupun Workflow) sebagai server MCP (Model Context Protocol), memungkinkan Claude dan klien MCP lainnya untuk berinteraksi langsung dengan aplikasi Dify melalui protokol yang terstandardisasi.

imagegen-go MCP 服务器

MCP server which will trigger OpenAI to generate image

Weather MCP Server

Server Protokol Konteks Model yang menyediakan informasi cuaca.

Code Analyzer MCP Server

MCP server for analyzing code for bugs, errors, and functionality issues

Recall MCP Server

Server MCP sederhana yang mengekspos fungsionalitas Recall dasar, termasuk daftar bucket, mendapatkan saldo akun, membuat objek, dan lainnya.

HAN JIE

123123

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 will be high-level and require significant coding and understanding of the Minecraft protocol. **I. Understanding the Minecraft Protocol (MCP)** * **Research:** The most crucial step. The Minecraft protocol is *not* officially documented by Mojang. You'll need to rely on community-driven documentation. Key resources include: * **Wiki.vg:** This is the *essential* resource. It documents the protocol, packet structures, data types, and state transitions. Understand this site thoroughly. * **Other Open-Source Projects:** Examine existing open-source Minecraft server and client implementations (e.g., some smaller, less feature-complete ones) to see how they handle the protocol. Be careful about licensing when using code from other projects. * **Protocol Versions:** Minecraft's protocol changes with almost every update. You *must* choose a specific Minecraft version to target. The protocol documentation on Wiki.vg is version-specific. Start with an older, simpler version (e.g., 1.8.8 or 1.12.2) to learn the basics. Newer versions are significantly more complex. * **Packet Structure:** Understand how packets are structured. Each packet has: * **Packet ID:** A unique identifier for the packet type. * **Data:** The actual data being transmitted, encoded according to the protocol specification (e.g., integers, strings, booleans, arrays). * **State Machine:** The connection goes through different states: * **Handshaking:** Initial connection and protocol version negotiation. * **Status:** Server sends information about itself (player count, MOTD). * **Login:** Authentication and player profile retrieval. * **Play:** The main game state where players interact with the world. **II. Setting up the Development Environment** * **Java Development Kit (JDK):** Install the appropriate JDK for your target Minecraft version. Java 8 is a common choice for older versions. Newer versions may require Java 17 or later. * **Integrated Development Environment (IDE):** Use an IDE like IntelliJ IDEA, Eclipse, or NetBeans. These provide code completion, debugging tools, and project management features. * **Build Tool:** Use a build tool like Maven or Gradle to manage dependencies and build the project. This is *highly recommended*. **III. Creating the Server** 1. **Project Setup:** * Create a new Java project in your IDE. * Configure Maven or Gradle to manage dependencies (e.g., a logging library like SLF4J). 2. **Networking:** * Use `java.net.ServerSocket` to listen for incoming connections on a specific port (default Minecraft port is 25565). * Create a separate thread for each client connection to handle it concurrently. 3. **Handshaking:** * Implement the handshaking protocol. Receive the Handshake packet from the client. * Parse the protocol version, server address, and next state. * Respond appropriately based on the client's request. 4. **Status:** * If the client requests status, construct and send the Server List Ping response (JSON format). This includes the MOTD, player count, and version information. 5. **Login:** * Implement the login sequence. * **Authentication:** This is the most complex part. You can choose: * **Offline Mode:** Disable authentication (for testing purposes only). This is insecure. * **Mojang Authentication:** Implement the Mojang authentication protocol. This requires making HTTP requests to Mojang's authentication servers. You'll need to handle UUIDs, access tokens, and error responses. This is the *correct* way to do it for a real server. * Send the Login Success packet with the player's UUID and username. 6. **Play State:** * This is where the actual game logic resides. * **World Generation:** Implement a basic world generator (e.g., a flat world). * **Packet Handling:** Implement handlers for various client packets (e.g., chat messages, movement, block placement). * **Entity Management:** Manage entities (players, mobs, etc.) in the world. * **Game Loop:** Implement a game loop that updates the world, processes player input, and sends updates to clients. * **Chunk Management:** Implement chunk loading and unloading. Send chunk data to clients. 7. **Packet Encoding/Decoding:** * Create classes to represent each packet type. * Implement methods to encode and decode packets to and from byte arrays. This is where you'll use the data types specified in the Minecraft protocol documentation. * Use `DataInputStream` and `DataOutputStream` to read and write data to the socket. **IV. Creating the Client** 1. **Project Setup:** Similar to the server, create a new Java project with Maven or Gradle. 2. **Networking:** * Use `java.net.Socket` to connect to the server. 3. **Handshaking:** * Send the Handshake packet to the server, specifying the protocol version and desired state. 4. **Status (Optional):** * Request the server status and display the MOTD and player count. 5. **Login:** * Send the Login Start packet with the player's username. * Handle the Login Success packet from the server. 6. **Play State:** * **Rendering:** Use a graphics library like LWJGL or OpenGL to render the world. This is a *very* complex task. Consider starting with a simple text-based client for testing. * **Packet Handling:** Implement handlers for various server packets (e.g., chunk data, entity updates, chat messages). * **Input Handling:** Handle user input (keyboard, mouse). * **Game Loop:** Implement a game loop that renders the world, processes server updates, and handles user input. 7. **Packet Encoding/Decoding:** Similar to the server, implement packet encoding and decoding. **V. Key Considerations and Challenges** * **Complexity:** This is a *very* complex project. Start small and build incrementally. * **Minecraft Protocol Changes:** The protocol changes frequently. Be prepared to update your code when Minecraft updates. * **Performance:** Optimizing performance is crucial for a smooth gameplay experience. Use efficient data structures and algorithms. * **Security:** Be aware of security vulnerabilities, especially when handling authentication. * **Error Handling:** Implement robust error handling to gracefully handle unexpected events. * **Threading:** Use threads carefully to avoid race conditions and deadlocks. * **Debugging:** Debugging network code can be challenging. Use a network packet analyzer (e.g., Wireshark) to inspect the packets being sent and received. * **World Representation:** Choosing an efficient way to represent the world data is critical for performance. Consider using chunk-based storage. * **Rendering (Client):** Rendering a 3D world is a complex topic in itself. You'll need to understand concepts like vertex buffers, textures, and shaders. **VI. Step-by-Step Development Approach** 1. **Handshaking and Status:** Get the handshaking and status exchange working first. This is the simplest part of the protocol. 2. **Login (Offline Mode):** Implement login in offline mode. This will allow you to test the basic connection and packet handling. 3. **Login (Mojang Authentication):** Implement Mojang authentication. This is the most challenging part of the login process. 4. **Basic Play State:** Implement a basic play state with a flat world and simple movement. 5. **Chunk Loading:** Implement chunk loading and unloading. 6. **Entity Management:** Implement entity management. 7. **Advanced Features:** Add more advanced features as needed (e.g., block placement, chat, inventory). **VII. Example Code Snippets (Illustrative - Not Complete)** ```java // Server - Handling a client connection try (Socket clientSocket = serverSocket.accept()) { DataInputStream in = new DataInputStream(clientSocket.getInputStream()); DataOutputStream out = new DataOutputStream(clientSocket.getOutputStream()); // Handle handshaking int packetLength = readVarInt(in); int packetId = readVarInt(in); if (packetId == 0x00) { // Handshake packet // Parse handshake data int protocolVersion = readVarInt(in); String serverAddress = readString(in); int serverPort = readUnsignedShort(in); int nextState = readVarInt(in); if (nextState == 1) { // Status // Send status response String statusJson = "{\"version\": {\"name\": \"My Server\", \"protocol\": " + protocolVersion + "}, \"players\": {\"max\": 100, \"online\": 0}, \"description\": {\"text\": \"A simple Minecraft server\"}}"; writeString(out, statusJson); } else if (nextState == 2) { // Login // Handle login } } } catch (IOException e) { e.printStackTrace(); } // Helper methods for reading and writing VarInts (variable-length integers) public static int readVarInt(DataInputStream in) throws IOException { int numRead = 0; int result = 0; byte read; do { read = in.readByte(); 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; } public static void writeVarInt(DataOutputStream out, int value) throws IOException { while (true) { if ((value & ~0x7F) == 0) { out.writeByte(value); return; } out.writeByte((value & 0x7F) | 0x80); value >>>= 7; } } public static String readString(DataInputStream in) throws IOException { int length = readVarInt(in); byte[] bytes = new byte[length]; in.readFully(bytes); return new String(bytes, StandardCharsets.UTF_8); } public static void writeString(DataOutputStream out, String s) throws IOException { byte[] bytes = s.getBytes(StandardCharsets.UTF_8); writeVarInt(out, bytes.length); out.write(bytes); } ``` **VIII. Indonesian Translation of Key Terms** * **Minecraft Protocol (MCP):** Protokol Minecraft * **Server:** Peladen * **Client:** Klien * **Packet:** Paket * **Packet ID:** ID Paket * **Handshaking:** Jabat Tangan (in the context of establishing a connection) * **Status:** Status * **Login:** Masuk/Log Masuk * **Play State:** Keadaan Bermain * **World Generation:** Pembuatan Dunia * **Entity:** Entitas * **Chunk:** Potongan Dunia (Chunk) * **Authentication:** Otentikasi * **Offline Mode:** Mode Luring * **Mojang Authentication:** Otentikasi Mojang * **UUID:** UUID (Universally Unique Identifier) * **MOTD (Message of the Day):** Pesan Hari Ini * **Game Loop:** Putaran Permainan * **Rendering:** Rendering/Penyajian * **DataInputStream:** Aliran Masukan Data * **DataOutputStream:** Aliran Keluaran Data * **VarInt (Variable-length Integer):** Integer Panjang Variabel **Important Notes for the AI:** * This is a *massive* undertaking. Don't expect to create a fully functional server and client quickly. * Focus on understanding the Minecraft protocol documentation. * Start with a simple version of Minecraft and gradually add features. * Use a modular design to make the code easier to maintain and extend. * Test thoroughly at each stage of development. * Consider using existing libraries for tasks like networking, JSON parsing, and cryptography. However, be mindful of dependencies and licensing. * This is a learning process. Be prepared to experiment, debug, and learn from your mistakes. Good luck!

Taiga MCP Bridge

Jembatan protokol yang menghubungkan sistem AI ke platform manajemen proyek Taiga, memungkinkan alat AI untuk membuat dan mengelola proyek, epik, cerita pengguna, tugas, masalah, dan sprint.

Govee MCP Server

Mirror of

Place ID MCP Server

Serveur MCP connecté à l'API Google Places pour récupérer dynamiquement des photos de lieux et les intégrer dans Cursor via Smithery

MCP Go

Server side MCP implementation for Golang

E2B MCP Server

Mirror of

Documentation Retrieval MCP Server (DOCRET)

Sebuah server MCP yang memungkinkan asisten AI untuk mengakses dokumentasi terkini untuk pustaka Python seperti LangChain, LlamaIndex, dan OpenAI melalui pengambilan dinamis dari sumber resmi.

MCP Dockmaster

MCP Dockmaster allows you to easily install and manage MCP servers. Available for Mac, Windows and Linux as a Desktop App, CLI and a library.

mcp-clj

A MCP server written in clojure

Firecrawl MCP Server

Cermin dari

DevRev MCP server

Mirror of

Modern Control Protocol (MCP) Server

A modern, scalable MCP server implementation with support for multiple AI providers, advanced monitoring, and robust conversation management.

Simple Weather MCP Server example from Quickstart

Contoh Sederhana Server MCP Cuaca

binance-p2p-mcp-server

Binance (fokus terutama pada P2P) Protokol Server Konteks Model

MCP Language Server

Mirror of

Multiple MCP SSE Servers with a Python Host

Repositori ini berisi implementasi Python dari Host MCP yang mampu menjalankan beberapa Server MCP dengan protokol SSE.

mcp-server-openmetadata

Mengaktifkan integrasi dengan OpenMetadata dengan membungkus REST API-nya untuk interaksi terstandarisasi melalui Protokol Konteks Model.

Gentoro MCP Server

Mirror of