Discover Awesome MCP Servers

MCP-server-HF-papers

Repositori ini adalah server MCP yang memungkinkan saya untuk berkomunikasi dengan koran harian HF melalui WhatsApp.

SearchAPI MCP Server

Model Context Protocol server that enables AI assistants like Claude to access searchapi.io API for searching Google Maps, flights, hotels, and other web information.

Voice Mode

Natural voice conversations for AI assistants that brings human-like voice interactions to Claude, ChatGPT, and other LLMs through the Model Context Protocol (MCP).

Facebook Insights Metrics v23

Provides access to 120+ Facebook Graph API v23.0 Insights metrics through MCP tools and resources. Features intelligent fuzzy search capabilities and real-time metric discovery for comprehensive Facebook analytics data.

Model Context Protocol .NET Template

Repositori ini berisi templat untuk membuat aplikasi Model Context Protocol (MCP) di .NET.

db-mcp

Server Protokol Konteks Model Basis Data (DB-MCP)

Jira MCP Server

Connects Jira with Claude, enabling users to search issues, view issue details, update issues, add comments, and retrieve project information through natural language commands.

Unofficial WCA MCP Server

Enables AI assistants to access World Cube Association speedcubing data including world records, competitor profiles, competition information, and championship results. Supports queries about rankings, competition schedules, and detailed speedcubing statistics through natural language.

Azure DevOps MCP Server

Enables interaction with Azure DevOps work items through AI assistants like VS Code/GitHub Copilot. Supports fetching work item details and updating work item statuses using natural language commands.

MSI Metadata MCP Server

Enables reading MSI installer metadata, analyzing Windows software packages, and generating silent installation commands. Provides comprehensive MSI file analysis including features, components, and registry-based installed application management.

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.

Obsidian Diary MCP Server

Enables AI-powered journaling in Obsidian with dynamic reflection prompts generated from recent entries and automatic backlinks between related diary entries. Supports adaptive templates that learn from writing patterns and smart content similarity linking.

Getting Started with Create React App

Aplikasi React untuk uji server MCP

MCP Server for Splunk

Enables AI agents to interact seamlessly with Splunk environments through 20+ tools for search, analytics, data discovery, administration, and health monitoring. Features AI-powered troubleshooting workflows and supports multiple Splunk instances with production-ready security.

mcp-4o-Image-Generator

mcp-4o-Image-Generator

rust-mcp-tutorial

Saya mencoba server MCP dengan Rust.

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!

Autotask MCP Server

A Model Context Protocol server that enables natural language querying of Kaseya's Autotask PSA data through AI assistants, supporting contract analysis, ticket tracking, agent activities, and project status monitoring.

Warden Magento MCP Server

A Model Context Protocol server that enables AI assistants to interact directly with Warden-managed Magento 2 development environments, automating common tasks like project initialization, environment management, database operations, and Magento CLI commands.

Peekaboo MCP

A macOS utility that captures screenshots and analyzes them with AI vision, enabling AI assistants to see and interpret what's on your screen.

Spring AI MCP Batch Job Server

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

Vercel MCP Python Server

A serverless MCP server deployed on Vercel that provides basic utility tools including echo, time retrieval, arithmetic operations, and mock weather information. Includes an interactive client application for testing and demonstration purposes.

JSON DB MCP Server

Enables users to manage data in a simple JSON file database through MCP tools and REST API. Supports creating, reading, updating, and deleting items organized in collections with auto-generated UUIDs.

O'RLY MCP Server

Generates O'Reilly parody book covers that display directly in Claude Desktop application, allowing users to create custom covers with titles, subtitles, authors, and visual themes.

Investidor10 MCP Server

Investidor10 MCP Server

MCPez - 微服务命令代理管理平台

Mikro server MCP terpadu

die-mcp

Detect It Easy (DIE) MCP Server

mcp_repo_4a01eabf

Ini adalah repositori pengujian yang dibuat oleh skrip pengujian MCP Server untuk GitHub.