Discover Awesome MCP Servers

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.

🤖 Claude AI Documentation Assistant 📚

Sebuah server MCP yang terintegrasi dengan Claude untuk menyediakan kemampuan pencarian dokumentasi cerdas di berbagai pustaka AI/ML, memungkinkan pengguna untuk mengambil dan memproses informasi teknis melalui kueri bahasa alami.

Firecrawl MCP Server

Cermin dari

DevRev MCP server

Mirror of

FastMCP 🚀

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

Modern Control Protocol (MCP) Server

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

@modelcontextprotocol/server-terminal

Mirror of

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!

Recall MCP Server

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

binance-p2p-mcp-server

Binance (fokus terutama pada P2P) Protokol Server Konteks Model

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.

GitLab-MCP-Server

Ini adalah server Model Context Protocol (MCP) yang menyediakan integrasi dengan GitLab. Server ini mengambil informasi kegagalan pipeline dan item umpan balik pada permintaan penggabungan dari proyek GitLab tertentu dan menyediakannya untuk asisten AI.

MCP Go

Server side MCP implementation for Golang

GitHub MCP Server Practice Repository

Mirror of

mcp-server-openmetadata

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

police-uk-api-mcp-server

Sebuah server MCP berbasis Python yang menyediakan alat untuk mengakses dan berinteraksi dengan API police.uk, menawarkan data tentang kejahatan, kepolisian, lingkungan, dan insiden penggeledahan dan penahanan.

MCP server for io.livecode.ch

Run io.livecode.ch as an MCP server

Ntfy Mcp

Server MCP yang membuat Anda selalu mendapatkan informasi dengan mengirimkan notifikasi ke ponsel menggunakan ntfy.sh.

Sefaria Jewish Library MCP Server

Cermin dari

Test Neon MCP Server in React Server Components

Demo RSC menggunakan MCP Server Neon dan Waku ⛩️

NetBox MCP Server

Server Model Context Protocol (MCP) untuk interaksi baca-saja dengan data NetBox di LLM.

MCP Server Docker TypeScript

TypeScript version of MCP server Docker with remote connection support

Bookworm

Here are a few ways to translate "MCP server for Rust documentation" into Indonesian, depending on the specific context and what you want to emphasize: **Option 1 (Most straightforward):** * **Server MCP untuk dokumentasi Rust** This is a direct translation and is generally understood. It's suitable if you're simply stating the existence of such a server. **Option 2 (Emphasizing the purpose):** * **Server MCP untuk keperluan dokumentasi Rust** This translates to "MCP server for the purpose of Rust documentation." It clarifies the server's function. **Option 3 (More descriptive, if "MCP" needs explanation):** * **Server MCP yang digunakan untuk dokumentasi Rust** This translates to "MCP server that is used for Rust documentation." It's helpful if the audience might not know what "MCP" is. **Option 4 (If you're talking about *a* specific MCP server):** * **Server MCP untuk dokumentasi Rust ini** (This MCP server for Rust documentation) * **Server MCP khusus untuk dokumentasi Rust** (A specific MCP server for Rust documentation) **Which option is best depends on the context. Consider these questions:** * **Does your audience know what "MCP" refers to?** If not, Option 3 or adding a brief explanation of "MCP" is best. * **Are you emphasizing the server's purpose?** If so, Option 2 is a good choice. * **Are you referring to a specific server?** If so, Option 4 is better. In most cases, **Option 1 (Server MCP untuk dokumentasi Rust)** is a good starting point.

GitHub MCP Server Practice RepositoryGitHub MCP Server Practice Repository

Practice repository for MCP server implementation

Webscraper MCP

MCP server that extracts text content from webpages, YouTube videos, and PDFs for LLMs to use.

SearXNG MCP Server

Cermin dari