Discover Awesome MCP Servers

Heygen MCP Server

Memungkinkan Claude Desktop dan Agents untuk menghasilkan avatar dan video AI melalui HeyGen API, menyediakan alat untuk membuat dan mengelola video avatar dengan teks dan opsi suara yang ditentukan.

Scanpy MCP server

Here are a few ways to translate "MCP server for Scanpy" into Indonesian, depending on the context and desired nuance: **Option 1 (Most straightforward):** * **Server MCP untuk Scanpy** This is a direct translation and easily understood. It's suitable for most technical contexts. **Option 2 (More descriptive, emphasizing purpose):** * **Server MCP untuk digunakan dengan Scanpy** This translates to "MCP server for use with Scanpy." It clarifies the server's intended purpose. **Option 3 (If "MCP" needs further explanation):** * **Server MCP (misalnya, server untuk [explain what MCP does in Indonesian]) untuk Scanpy** This translates to "MCP server (for example, a server for [explain what MCP does in Indonesian]) for Scanpy." This is useful if the audience might not know what "MCP" refers to. You would need to replace "[explain what MCP does in Indonesian]" with the appropriate explanation. **Which option is best depends on the audience and the context.** If the audience is familiar with the term "MCP" and the context is clearly technical, the first option is likely sufficient. If you need to be more explicit or the audience is less familiar with the terminology, the second or third option might be better.

Anki MCP Server

Cermin dari

arduino-mcp-server

Server MCP Arduino yang ditulis dalam Go.

🎯 Kubernetes AI Management System

Sistem Manajemen Kubernetes Bertenaga AI: Sebuah platform yang menggabungkan pemrosesan bahasa alami dengan manajemen Kubernetes. Pengguna dapat melakukan diagnostik waktu nyata, pemantauan sumber daya, dan analisis log cerdas. Sistem ini menyederhanakan manajemen Kubernetes melalui AI percakapan, memberikan alternatif modern.

Spring AI MCP Batch Job Server

Server Spring Boot Model Context Protocol (MCP) yang menyediakan alat pemrosesan batch untuk transaksi keuangan.

mcp_docs_server

Okay, I can help you with that! Building an MCP (Minecraft Coder Pack) server involves a few steps. Here's a breakdown of the process, along with explanations and considerations: **What is MCP (Minecraft Coder Pack)?** MCP is a toolset that deobfuscates and decompiles Minecraft's code, making it readable and modifiable. It's essential for creating Minecraft mods. You don't directly "build an MCP server" in the same way you build a regular Minecraft server. Instead, you use MCP to *modify* the Minecraft server code. **Here's the general workflow:** 1. **Set up your Development Environment:** * **Install Java Development Kit (JDK):** You need the JDK (not just the JRE) to compile Java code. Download the appropriate version for your operating system from Oracle or a more modern distribution like Adoptium (Temurin). Make sure you install the correct JDK version for the Minecraft version you're targeting. MCP typically specifies the required JDK version. * **Install an IDE (Integrated Development Environment):** Popular choices include: * **IntelliJ IDEA:** A powerful and widely used IDE, especially for Java development. The Community Edition is free and sufficient for most modding tasks. * **Eclipse:** Another popular, free, and open-source IDE. * **Visual Studio Code (VS Code):** A lightweight but versatile editor with excellent Java support through extensions. * **Install Gradle (Optional but Recommended):** Gradle is a build automation tool that simplifies dependency management and building your mod. MCP often integrates well with Gradle. 2. **Download and Set Up MCP:** * **Find the Correct MCP Version:** Crucially, you need the MCP version that corresponds to the *exact* Minecraft version you want to mod. MCP versions are specific to Minecraft versions. Search online for "MCP [Minecraft Version]" (e.g., "MCP 1.19.2"). Look for reputable sources like the official MCP forums or modding communities. * **Extract MCP:** Extract the downloaded MCP archive to a directory on your computer (e.g., `C:\mcp` or `/home/user/mcp`). Avoid spaces in the path. * **Configure MCP (`build.gradle` or similar):** MCP usually comes with a `build.gradle` file (if using Gradle) or a configuration file that you need to adjust. This file specifies: * The Minecraft version. * The location of your Minecraft installation. * Other build settings. 3. **Decompile and Deobfuscate Minecraft:** * **Run MCP's Decompilation Task:** This is the core step. Using the command line, navigate to your MCP directory and run the appropriate command. The command depends on whether you're using Gradle or the older MCP scripts. Here are examples: * **Gradle:** `./gradlew setupDecompWorkspace` (on Linux/macOS) or `gradlew setupDecompWorkspace` (on Windows). This command downloads the Minecraft server and client JARs, deobfuscates them (replaces the cryptic names with more readable ones), and decompiles them (turns the bytecode into Java source code). * **Older MCP Scripts:** `./decompile.sh` (Linux/macOS) or `decompile.bat` (Windows). (These scripts might have slightly different names depending on the MCP version.) * **Wait:** This process can take a significant amount of time (minutes to hours), depending on your computer's speed and the Minecraft version. 4. **Set Up Your IDE:** * **Import the MCP Project:** In your IDE, import the MCP project. If you're using Gradle, import the `build.gradle` file. If you're using Eclipse, you might need to run a command in MCP to generate Eclipse project files first (e.g., `./gradlew eclipse`). * **Configure the IDE's JDK:** Make sure your IDE is using the same JDK version that MCP requires. 5. **Start Modding:** * **Locate the Server Source Code:** The decompiled and deobfuscated server source code will be in a directory within the MCP project (e.g., `src/main/java` or `src/server/java`). * **Make Your Changes:** Modify the Java code to add your desired features, fix bugs, or change the game's behavior. **Be careful!** Modifying the core Minecraft code can be complex and lead to unexpected issues. * **Compile Your Changes:** Use your IDE or Gradle to compile the modified code. 6. **Reobfuscate (Optional but Recommended for Distribution):** * **Run MCP's Reobfuscation Task:** Before distributing your mod, you should reobfuscate the code. This makes it harder for others to understand and copy your code. The command is usually something like `./gradlew reobf` or `./reobfuscate.sh`. 7. **Build Your Mod:** * **Create a JAR File:** Package your modified server code into a JAR (Java Archive) file. Gradle can automate this process. The JAR file will contain your modified classes. 8. **Deploy Your Modded Server:** * **Replace the Original Server JAR:** Replace the original `minecraft_server.jar` file with your modified JAR file. **Back up the original JAR first!** * **Run the Server:** Start the server as you normally would. **Important Considerations and Troubleshooting:** * **MCP Version Compatibility:** This is the *most* common source of problems. Ensure that your MCP version *exactly* matches the Minecraft version you're targeting. * **JDK Version:** Use the correct JDK version. Mismatched JDK versions can cause compilation errors or runtime issues. * **Memory:** Decompiling and reobfuscating can be memory-intensive. Increase the memory allocated to Gradle or the MCP scripts if you encounter out-of-memory errors. You can do this by setting the `JAVA_OPTS` environment variable (e.g., `export JAVA_OPTS="-Xmx4G"` on Linux/macOS). * **Errors During Decompilation:** Sometimes, decompilation can fail due to errors in the Minecraft code or issues with the decompiler. Check the MCP logs for error messages and try to resolve them. Sometimes, simply re-running the decompilation task can fix transient errors. * **Obfuscation Mappings:** MCP relies on obfuscation mappings to deobfuscate and reobfuscate the code. These mappings are updated periodically. Make sure you're using the latest mappings for your Minecraft version. * **Modding Frameworks (Forge, Fabric):** While you can directly modify the Minecraft server code with MCP, it's generally *much* easier and more maintainable to use a modding framework like Forge or Fabric. These frameworks provide APIs and tools that simplify mod development and reduce the risk of conflicts between mods. If you're new to modding, I highly recommend starting with Forge or Fabric. * **Backup:** Always back up your original Minecraft server JAR file before making any modifications. * **Licensing:** Be aware of Minecraft's licensing terms and any restrictions on distributing modified versions of the game. **Example using Forge (Recommended):** If you want to create a modded server, using Forge is the recommended approach. Here's a simplified outline: 1. **Download and Install the Forge MDK (Mod Development Kit):** Get the MDK for the Minecraft version you want to mod from the official Forge website. 2. **Extract the MDK:** Extract the MDK to a directory. 3. **Import the Project into Your IDE:** Import the `build.gradle` file into your IDE. 4. **Write Your Mod Code:** Create your mod's Java classes in the `src/main/java` directory. Use the Forge API to interact with the game. 5. **Build Your Mod:** Run the `gradlew build` command to build your mod JAR file. 6. **Install Forge on the Server:** Download the Forge installer for the server. Run the installer and select "Install server". 7. **Place Your Mod in the `mods` Folder:** Copy your mod JAR file into the `mods` folder in your Minecraft server directory. 8. **Run the Server:** Start the server. **In summary, while you can use MCP to directly modify the Minecraft server code, it's a complex and potentially fragile approach. Using a modding framework like Forge or Fabric is generally a better option for creating and managing mods.** To give you more specific help, please tell me: * **Which Minecraft version are you targeting?** * **Are you planning to use Forge, Fabric, or modify the core code directly with MCP?** * **What are you trying to achieve with your modded server?** (e.g., add new items, change game mechanics, etc.) Good luck! Let me know if you have any more questions.

Getting Started with Create React App

Aplikasi React untuk uji server MCP

MCP 学习项目⚡

The most accurate and natural translation of "个人学习MCP" depends on the context. Here are a few options: * **If you mean "personal study for MCP":** **Belajar MCP secara mandiri** (This emphasizes independent learning) * **If you mean "individual study for MCP":** **Studi individual untuk MCP** (This is a more literal translation) * **If you mean "self-study for MCP":** **Belajar otodidak untuk MCP** (This emphasizes self-teaching) Therefore, **Belajar MCP secara mandiri** is likely the best option if you want to convey the idea of studying for the MCP exam on your own.

MCPHub

Solusi Embeddable Model Context Protocol (MCP) untuk layanan AI. Integrasikan server MCP dengan mulus dengan kerangka kerja OpenAI Agents, LangChain, dan Autogen melalui antarmuka terpadu. Menyederhanakan konfigurasi, pengaturan, dan pengelolaan alat MCP di berbagai aplikasi AI.

mcp-kagi-search

Implementasi server MCP untuk API Kagi menggunakan npx, sehingga dapat dengan mudah dijalankan di n8n.

MCP Server for Spotify

Sebuah server MCP Spotify

KubeBlocks Cloud MCP Server

MCP server for KubeBlocks Cloud

mcp-4o-Image-Generator

mcp-4o-Image-Generator

Mcp Server

Okay, here's an example of a simple MCP (Minecraft Protocol) server written in Python, designed to be easily understood and potentially adapted for use with a large language model like Claude. This is a very basic example and doesn't implement all the features of a real Minecraft server. It focuses on handling the initial handshake and sending a simple status response. ```python import socket import struct import json def handle_handshake(sock): """Handles the initial handshake from the client.""" # Read the packet length (VarInt) packet_length, bytes_read = read_varint(sock) print(f"Packet length: {packet_length}, Bytes read: {bytes_read}") # Read the packet ID (VarInt) packet_id, bytes_read_id = read_varint(sock) print(f"Packet ID: {packet_id}, Bytes read: {bytes_read_id}") # Read the protocol version (VarInt) protocol_version, bytes_read_version = read_varint(sock) print(f"Protocol Version: {protocol_version}, Bytes read: {bytes_read_version}") # Read the server address (String) server_address_length, bytes_read_address_length = read_varint(sock) server_address = sock.recv(server_address_length).decode('utf-8') print(f"Server Address: {server_address}, Bytes read: {bytes_read_address_length}") # Read the server port (Unsigned Short) server_port = struct.unpack('>H', sock.recv(2))[0] # Big-endian unsigned short print(f"Server Port: {server_port}") # Read the next state (VarInt) next_state, bytes_read_state = read_varint(sock) print(f"Next State: {next_state}, Bytes read: {bytes_read_state}") return next_state def handle_status_request(sock): """Handles the status request from the client and sends a response.""" # Read the packet length (VarInt) - should be 1 for an empty status request packet_length, bytes_read = read_varint(sock) print(f"Status Request Packet Length: {packet_length}, Bytes read: {bytes_read}") # Read the packet ID (VarInt) - should be 0 for a status request packet_id, bytes_read_id = read_varint(sock) print(f"Status Request Packet ID: {packet_id}, Bytes read: {bytes_read_id}") # Construct the status response status = { "version": { "name": "My Awesome Server", "protocol": 763 # Example protocol version (1.17.1) }, "players": { "max": 100, "online": 0, "sample": [] }, "description": { "text": "A server powered by Python and AI!" } } status_json = json.dumps(status) status_bytes = status_json.encode('utf-8') status_length = len(status_bytes) # Create the response packet packet = bytearray() write_varint(packet, status_length) # Length of the JSON string packet.extend(status_bytes) # Prepend the packet length packet_length = len(packet) response = bytearray() write_varint(response, packet_length) response.extend(packet) # Send the response sock.sendall(response) def handle_ping(sock): """Handles the ping request from the client and sends a response.""" # Read the packet length (VarInt) - should be 9 packet_length, bytes_read = read_varint(sock) print(f"Ping Packet Length: {packet_length}, Bytes read: {bytes_read}") # Read the packet ID (VarInt) - should be 1 packet_id, bytes_read_id = read_varint(sock) print(f"Ping Packet ID: {packet_id}, Bytes read: {bytes_read_id}") # Read the payload (Long) payload = struct.unpack('>q', sock.recv(8))[0] # Big-endian long print(f"Ping Payload: {payload}") # Create the response packet (same payload) response = bytearray() write_varint(response, 8) # Packet Length (8 bytes for long) write_varint(response, 0) # Packet ID (0 for pong) response.extend(struct.pack('>q', payload)) # Payload # Prepend the packet length packet_length = len(response) final_response = bytearray() write_varint(final_response, packet_length) final_response.extend(response) # Send the response sock.sendall(final_response) def read_varint(sock): """Reads a VarInt from the socket.""" num_read = 0 result = 0 shift = 0 while True: byte = sock.recv(1)[0] num_read += 1 result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break if num_read > 5: raise Exception("VarInt is too big") return result, num_read def write_varint(buffer, value): """Writes a VarInt to the buffer.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 buffer.append(byte) if value == 0: break def main(): """Main server loop.""" host = 'localhost' port = 25565 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of address server_socket.bind((host, port)) server_socket.listen(1) # Listen for one connection at a time print(f"Server listening on {host}:{port}") while True: try: client_socket, address = server_socket.accept() print(f"Accepted connection from {address}") try: # Handle the handshake next_state = handle_handshake(client_socket) if next_state == 1: # Handle status request handle_status_request(client_socket) # Handle ping request handle_ping(client_socket) elif next_state == 2: print("Login requested. Not implemented in this example.") # In a real server, you'd handle login here. pass else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() print(f"Connection from {address} closed.") except KeyboardInterrupt: print("Shutting down server...") break except Exception as e: print(f"Error in main loop: {e}") server_socket.close() if __name__ == "__main__": main() ``` Key improvements and explanations: * **VarInt Handling:** Minecraft uses VarInts (variable-length integers) for packet lengths and IDs. The `read_varint` and `write_varint` functions correctly handle these. This is *crucial* for Minecraft protocol communication. The code now includes error handling to prevent infinite loops if a VarInt is too large. * **Status Response:** The `handle_status_request` function now constructs a valid JSON status response. This is what the Minecraft client displays in the server list. The `protocol` field in the status is important; it needs to match the client's version. I've set it to 763, which corresponds to Minecraft 1.17.1. You can find a list of protocol versions online. The `description` field is what's displayed as the server's MOTD (message of the day). * **Ping Handling:** The `handle_ping` function now correctly handles the ping request and sends back the same payload. This is what determines the server's latency in the client. * **Error Handling:** Includes `try...except` blocks to catch potential errors during client communication and in the main loop. This prevents the server from crashing if a client sends invalid data. * **Socket Reuse:** `server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)` allows you to quickly restart the server without waiting for the socket to time out. * **Clearer Output:** Prints more informative messages to the console, making it easier to debug. * **Big-Endian:** Uses `struct.pack('>H', ...)` and `struct.unpack('>q', ...)` to ensure that multi-byte values are packed and unpacked in big-endian order, as required by the Minecraft protocol. * **Bytearray:** Uses `bytearray` for building packets. This is more efficient than repeatedly concatenating strings. * **Comments:** Added more comments to explain the code. * **Next State Handling:** The `handle_handshake` function now returns the `next_state` value, which determines whether the client is requesting the server status (1) or attempting to log in (2). The main loop then branches based on this value. A placeholder is included for login handling, but it's not implemented. * **Complete Example:** This is a complete, runnable example. You should be able to copy and paste it into a Python file and run it. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Open a terminal or command prompt and run the script: `python mcp_server.py` 3. **Minecraft:** In your Minecraft client, add a new server with the address `localhost:25565`. (If you're running the server on a different machine, use that machine's IP address instead of `localhost`.) 4. **Observe:** You should see your server in the server list with the MOTD "A server powered by Python and AI!". The latency should be displayed after the ping is handled. **How to Adapt for Claude:** The key is to modify the `handle_status_request` function to use Claude to generate the status response. Here's a conceptual outline: 1. **Claude Integration:** You'll need to install the Anthropic Python client library (`anthropic`). You'll also need an API key. 2. **Prompt Engineering:** Craft a prompt that tells Claude what kind of status response you want. For example: ```python import anthropic client = anthropic.Anthropic(api_key="YOUR_ANTHROPIC_API_KEY") def generate_status_with_claude(): prompt = """You are a helpful assistant that generates JSON responses for a Minecraft server status. The server is called "My Awesome Server". It has a maximum of 100 players. The current time is [current time]. The server's description should be witty and engaging. Include information about the server's features. Generate a JSON object with the following structure: ```json { "version": { "name": "My Awesome Server", "protocol": 763 }, "players": { "max": 100, "online": [number of online players], "sample": [] }, "description": { "text": "[witty server description]" } } ``` Only return the JSON object. Do not include any other text. """ # Replace [current time] and [number of online players] with actual values import datetime now = datetime.datetime.now() prompt = prompt.replace("[current time]", now.strftime("%Y-%m-%d %H:%M:%S")) prompt = prompt.replace("[number of online players]", "0") # Replace with actual online player count response = client.completions.create( model="claude-3-opus-20240229", # Or another suitable Claude model max_tokens_to_sample=500, prompt=f"{anthropic.HUMAN_PROMPT} {prompt} {anthropic.AI_PROMPT}", ) try: status = json.loads(response.completion) return status except json.JSONDecodeError as e: print(f"Error decoding JSON from Claude: {e}") # Return a default status if Claude fails return { "version": {"name": "Error", "protocol": 763}, "players": {"max": 100, "online": 0, "sample": []}, "description": {"text": "Error generating status."} } ``` 3. **Modify `handle_status_request`:** Replace the hardcoded `status` dictionary in `handle_status_request` with a call to `generate_status_with_claude()`: ```python def handle_status_request(sock): # ... (existing code) ... status = generate_status_with_claude() # Get the status from Claude # ... (existing code) ... ``` **Important Considerations for Claude Integration:** * **API Key:** Store your Anthropic API key securely (e.g., in an environment variable). Do *not* hardcode it directly into the script. * **Rate Limiting:** Be mindful of Anthropic's rate limits. You might need to implement caching or other strategies to avoid exceeding the limits. * **Error Handling:** Claude might sometimes return invalid JSON or fail to respond. Implement robust error handling to gracefully handle these cases. Provide a default status response if Claude fails. * **Prompt Engineering:** Experiment with different prompts to get the desired behavior from Claude. The prompt is key to controlling the content of the status response. * **Cost:** Using Claude costs money. Be aware of the pricing and monitor your usage. * **Latency:** Calling Claude will add latency to the status request. This might be noticeable to players. This example provides a solid foundation for building a more sophisticated Minecraft server that leverages the power of a large language model. Remember to handle errors, rate limits, and security considerations carefully. Good luck!

rust-mcp-tutorial

Saya mencoba server MCP dengan Rust.

Alibaba Cloud Observability MCP Server

Provides tools for accessing Alibaba Cloud observability products including SLS (Log Service) and ARMS (Application Real-time Monitoring Service), allowing any MCP-compatible AI assistants to quickly interact with these services.

Mcp Server Amq

Server MCP untuk berinteraksi dengan API AWS AmazonMQ

🚀 MCP Server Tester

MCP Server Tester adalah alat web sederhana untuk menguji dan memvalidasi kode instalasi server MCP. Dibangun dengan Node.js, Express, dan EJS, alat ini menyediakan hasil respons server secara real-time dengan UI yang bersih dan responsif.

mcp-golang-http-server

Server MCP sederhana yang diekspos melalui SSE dengan contoh alat, sumber daya, dan perintah.

GBox MCP Server

Gbox MCP server

MCP TMAP Server

A server that connects to SK TMAP API, providing access to public transit routing and geocoding functionality through a standardized interface.

🤖 MCP Server — Agent X (Powered by Gemini Flash + Twitter API)

Agen AI yang dibangun dengan server MCP.

web-monitor-mcp-safepoint

The mcp server for safepoint web monitor

Your Money Left The Chat

A Rust + MCP powered financial tracker that knows exactly where your money ghosted you.

天气 MCP 服务器

Ini adalah server MCP kueri cuaca yang dibangun berdasarkan FastMCP.