Discover Awesome MCP Servers

postgres-mcp MCP server

Postgres Pro adalah server Model Context Protocol (MCP) sumber terbuka yang dibangun untuk mendukung Anda dan agen AI Anda di sepanjang proses pengembangan—mulai dari pengkodean awal, melalui pengujian dan penerapan, hingga penyesuaian dan pemeliharaan produksi.

What is Model Context Protocol (MCP)?

Sebuah server Model Context Protocol (MCP) ringan yang memungkinkan LLM Anda untuk memvalidasi alamat email. Alat ini memeriksa format email, validitas domain, dan kemampuan pengiriman menggunakan AbstractAPI Email Validation API. Sempurna untuk mengintegrasikan validasi email ke dalam aplikasi AI seperti Claude Desktop.

Waldzell MCP Servers

Monorepo server MCP Waldzell AI. Digunakan di Claude Desktop, Cline, Roo Code, dan lainnya!

My Slack MCP Server Extension

Sebuah ekstensi untuk server MCP Slack

Cortellis MCP Server

An MCP server enabling AI assistants to search and analyze pharmaceutical data through Cortellis. Features comprehensive drug search, ontology exploration, and real-time clinical trial data access.

Coinmarket MCP server

Mirror of

WIP: MCP Server Superset

A Model Context Protocol server that enables large language models to interact with Apache Superset databases through REST API, supporting database queries, table lookups, field information retrieval, and SQL execution.

Google Analytics MCP Server

Cermin dari

mcp-server-proxy

Converts MCP protocol's SSE transport layer to a standard HTTP request/response.

Bishop MCP (Master Control Program)

Ini adalah skrip Server MCP tingkat lanjut yang telah saya kembangkan dan ingin saya bagikan.

mcp-oceanbase

Here are a few ways to translate "MCP Server for OceanBase database and its tools" into Indonesian, depending on the context and desired level of formality: **Option 1 (Most straightforward):** * **Server MCP untuk database OceanBase dan alat-alatnya.** * This is a direct translation and easily understood. **Option 2 (Slightly more formal):** * **Server MCP untuk basis data OceanBase beserta alat-alatnya.** * Using "basis data" instead of "database" is slightly more formal. **Option 3 (Emphasizing the purpose):** * **Server MCP untuk database OceanBase dan perangkat pendukungnya.** * This translates "tools" as "perangkat pendukung" which means "supporting devices/tools." This might be useful if you want to emphasize that the tools are there to support the database. **Option 4 (If MCP is an acronym and needs explanation):** * **Server MCP (Management Control Plane) untuk database OceanBase dan alat-alatnya.** * This provides the full name of MCP in parentheses. You might also consider translating "Management Control Plane" if appropriate for your audience. **Which option is best depends on the context:** * If you're writing technical documentation for experienced users, Option 1 or 2 is likely fine. * If you're writing for a broader audience, Option 3 might be better. * If you need to clarify what MCP is, use Option 4. Therefore, the best translation is likely **Server MCP untuk database OceanBase dan alat-alatnya.** unless you have a specific reason to choose one of the other options.

Workers MCP Server

Talk to a Cloudflare Worker from Claude Desktop!

Podman MCP Server

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

HAN JIE

123123

Code Analyzer MCP Server

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

🤖 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.

imagegen-go MCP 服务器

MCP server which will trigger OpenAI to generate image

Weather MCP Server

Server Protokol Konteks Model yang menyediakan informasi cuaca.

Claude Desktop Commander MCP

Memungkinkan Claude untuk menjalankan perintah terminal di komputer Anda dan melakukan operasi sistem berkas termasuk pengeditan kode yang presisi dengan penggantian berbasis diff.

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.

MCP Server

Implementasi Model Context Protocol berbasis FastAPI yang memungkinkan interaksi terstandarisasi antara model AI dan lingkungan pengembangan, sehingga memudahkan pengembang untuk mengintegrasikan dan mengelola tugas-tugas AI.

Recall MCP Server

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

@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!

GitHub MCP Server Practice Repository

Mirror of

FastMCP 🚀

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