Discover Awesome MCP Servers

File System Utility MCP Server

Enables interaction with the local file system and retrieval of system information. Provides tools for listing directories, reading files, getting current time, and basic greeting functionality.

Playwright MCP Server

Enables web browser automation through Playwright, providing tools for navigation, element interaction, screenshot capture, and accessibility snapshots. Uses streamableHttp transport for seamless integration with MCP clients.

Figma MCP Demo

A server that enables Cursor AI to generate code from Figma components by connecting to Figma's MCP Dev Server.

MCP Server

Máy chủ MCP

Mode Manager MCP

MCP Memory Agent Server - A VS Code chatmode and instruction manager with library integration

MCP Server Boilerplate

A starter template for building custom MCP servers that can integrate with Claude, Cursor, or other MCP-compatible AI assistants. Provides a clean foundation with TypeScript support, example implementations, and easy installation scripts for quickly creating tools, resources, and prompt templates.

MCP Crypto Market Data Server

Provides real-time and historical cryptocurrency market data from major exchanges through CCXT. Supports live price lookups, historical OHLCV queries, and includes lightweight caching for improved performance.

AWS Documentation MCP Server

Enables users to access, search, and get recommendations from AWS documentation through natural language queries. Supports both global AWS documentation and AWS China documentation with tools to fetch pages, search content, and discover related resources.

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 helpful tips: **Understanding MCP and its Purpose** * **What is MCP?** Minecraft Coder Pack (MCP) is a toolset that deobfuscates and decompiles the Minecraft Java Edition client and server code. This makes it readable and modifiable, allowing modders to create custom content. * **Why use MCP for a server?** You generally *don't* directly run an MCP server. MCP is used to *develop* mods. You then use those mods with a standard Minecraft server (Vanilla, Forge, Fabric, etc.). The purpose of using MCP in the context of a server is to: * **Develop Server-Side Mods:** MCP allows you to understand and modify the server's code to add new features, change existing mechanics, or create custom gameplay experiences. * **Understand Minecraft Internals:** Even if you're not directly modifying the base code, MCP helps you learn how Minecraft works, which is invaluable for advanced modding. **Here's a general outline of the process:** **1. Set Up Your Development Environment** * **Java Development Kit (JDK):** You'll need the correct version of the JDK. **Crucially, the JDK version must match the Minecraft version you're targeting.** For example, Minecraft 1.16.5 requires Java 8, Minecraft 1.17 requires Java 16, Minecraft 1.18 requires Java 17, Minecraft 1.19 requires Java 17, and Minecraft 1.20 requires Java 17. Download the appropriate JDK from Oracle or a distribution like Adoptium (Temurin). Make sure to set the `JAVA_HOME` environment variable to point to your JDK installation directory. * **Integrated Development Environment (IDE):** IntelliJ IDEA (Community Edition is free and excellent) or Eclipse are popular choices. They provide code completion, debugging tools, and project management features. * **MCP (Minecraft Coder Pack):** Download the correct MCP version for the Minecraft version you want to mod. You can find MCP releases on various forums and websites (search for "MCP [Minecraft Version]"). **Important:** Make sure you download MCP from a reputable source to avoid malicious code. **2. Install and Configure MCP** 1. **Extract MCP:** Extract the downloaded MCP archive to a directory on your computer (e.g., `C:\mcp`). 2. **Configure `build.gradle` (Important):** MCP uses Gradle for building. You'll need to configure the `build.gradle` file in your MCP directory. This file tells Gradle where to find the Minecraft server and client JAR files. The exact configuration depends on the MCP version, but generally, you'll need to: * **Specify the Minecraft Version:** Make sure the `minecraft_version` variable in `build.gradle` is set to the correct Minecraft version. * **Configure Dependencies:** The `build.gradle` file will likely have dependencies on the Minecraft server and client JARs. MCP will download these automatically, but you might need to adjust the repositories if you're using a custom Minecraft version. 3. **Run MCP Tasks:** Open a command prompt or terminal, navigate to your MCP directory, and run the following commands: * `gradlew setupDecompWorkspace` (or `./gradlew setupDecompWorkspace` on Linux/macOS): This task downloads the Minecraft JARs, deobfuscates them, and sets up your development workspace. This is the most time-consuming step. * `gradlew eclipse` (if using Eclipse) or `gradlew idea` (if using IntelliJ IDEA): This task generates the project files for your IDE. * `gradlew genEclipseRuns` (for Eclipse) or `gradlew genIntellijRuns` (for IntelliJ IDEA): This creates run configurations for launching the Minecraft client and server from your IDE. **3. Import the Project into Your IDE** * **IntelliJ IDEA:** Open IntelliJ IDEA and select "Open." Navigate to your MCP directory and select the `build.gradle` file. IntelliJ IDEA will import the project. * **Eclipse:** Open Eclipse and select "Import." Choose "Gradle" -> "Existing Gradle Project." Navigate to your MCP directory and select the `build.gradle` file. Eclipse will import the project. **4. Understanding the MCP Structure** * **`src/main/java`:** This is where you'll write your mod code. The deobfuscated Minecraft source code is also available here for reference. * **`src/main/resources`:** This directory contains resources like textures, models, and configuration files. * **`build.gradle`:** The Gradle build file, which defines dependencies, tasks, and other build settings. **5. Writing Your Mod** * **Start with a Simple Mod:** Begin with a small, manageable mod to get familiar with the MCP environment. For example, you could create a mod that adds a new block or item. * **Use the Deobfuscated Code as a Guide:** The deobfuscated Minecraft code is your best resource for understanding how the game works. Look at existing classes and methods to see how they're implemented. * **Use Forge or Fabric (Recommended):** While you *can* directly modify the base Minecraft code with MCP, it's generally much better to use a modding API like Forge or Fabric. These APIs provide hooks and events that make it easier to modify the game without breaking compatibility with other mods. They also handle many of the complexities of mod loading and management. To use Forge or Fabric, you'll need to set up a Forge or Fabric development environment *within* your MCP project. This involves adding the appropriate dependencies to your `build.gradle` file and using the Forge/Fabric APIs in your code. **6. Building and Testing Your Mod** * **Build the Mod:** In your IDE, run the Gradle task to build your mod. This will typically create a JAR file in the `build/libs` directory. The task is usually called `build`. * **Set up a Test Server:** Create a standard Minecraft server (Vanilla, Forge, or Fabric, depending on how you developed your mod). * **Install Your Mod:** Place the mod JAR file in the `mods` directory of your Minecraft server. * **Start the Server:** Start the server and test your mod. Check the server logs for any errors. **7. Running the Server** * Once you have your modded server JAR, you can run it like any other Minecraft server. Use the command: ```bash java -Xmx4G -Xms4G -jar your_server.jar nogui ``` * `-Xmx4G` and `-Xms4G` allocate 4GB of RAM to the server. Adjust these values based on your server's needs and available memory. * `your_server.jar` is the name of your modded server JAR file. * `nogui` disables the graphical user interface, which is generally preferred for dedicated servers. **Important Considerations and Tips** * **Version Compatibility:** Make sure your MCP version, JDK version, Forge/Fabric version (if using), and Minecraft version are all compatible. Mismatched versions can lead to errors and crashes. * **Deobfuscation Issues:** Sometimes, the deobfuscation process can fail or produce incorrect results. If you encounter issues, try cleaning your MCP workspace and running the setup tasks again. * **Mod Conflicts:** When using multiple mods, conflicts can occur. Test your mods thoroughly to identify and resolve any conflicts. * **Backup Your World:** Always back up your Minecraft world before installing or updating mods. Mods can sometimes corrupt your world data. * **Read the Documentation:** Refer to the MCP documentation and the documentation for Forge or Fabric (if using) for detailed information and instructions. * **Join the Community:** Join the Minecraft modding community for support and guidance. There are many forums, Discord servers, and other online communities where you can ask questions and share your experiences. * **Use a Version Control System (Git):** Use Git to track your changes and collaborate with others. This is essential for managing your mod's codebase. * **Learn Java:** A strong understanding of Java is essential for Minecraft modding. Take the time to learn the basics of Java programming. * **Understand Minecraft's Code:** The more you understand how Minecraft's code works, the better you'll be at modding it. Study the deobfuscated code and experiment with different approaches. * **Start Small and Iterate:** Don't try to create a massive mod right away. Start with a small, simple mod and gradually add more features as you gain experience. **In summary, building an MCP server isn't about running MCP directly. It's about using MCP as a development tool to create server-side mods, and then running those mods on a standard Minecraft server (Vanilla, Forge, or Fabric).** Let me know if you have any specific questions about any of these steps, or if you're trying to do something specific with your mod. I can provide more detailed guidance. For example, tell me: * What Minecraft version are you targeting? * Are you planning to use Forge or Fabric? * What kind of mod are you trying to create?

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

Ứng dụng React để kiểm tra máy chủ MCP

Gmail MCP Server

Provides complete Gmail API integration for email management, including sending/receiving messages, managing labels and threads, creating drafts, and configuring settings through OAuth2 authentication.

mcp-4o-Image-Generator

mcp-4o-Image-Generator

rust-mcp-tutorial

Tuyệt vời! Bạn muốn thử nghiệm một máy chủ MCP (Minecraft Protocol) bằng Rust. Đây là bản dịch chính xác và tự nhiên nhất: **"Thử nghiệm máy chủ MCP bằng Rust."** Hoặc, nếu bạn muốn nhấn mạnh hơn về việc "thử nghiệm": **"Thử nghiệm máy chủ MCP với Rust."** Cả hai đều truyền tải ý nghĩa bạn muốn. Chúc bạn thành công với dự án của mình!

Mcp Server

Okay, here's an example of a simple MCP (Minecraft Protocol) server written in Python, along with a Vietnamese translation of the explanation: **Python Code (Example):** ```python import socket import struct def handle_handshake(sock): """Handles the initial handshake from the client.""" data = sock.recv(256) # Receive up to 256 bytes if not data: return False # Decode the data (very basic example, needs proper VarInt handling) protocol_version = data[1] server_address_length = data[2] server_address = data[3:3 + server_address_length].decode('utf-8') server_port = struct.unpack('>H', data[3 + server_address_length:5 + server_address_length])[0] next_state = data[5 + server_address_length] print(f"Protocol Version: {protocol_version}") print(f"Server Address: {server_address}") print(f"Server Port: {server_port}") print(f"Next State: {next_state}") if next_state == 1: # Status handle_status(sock) elif next_state == 2: # Login handle_login(sock) else: print("Unknown next state") return False return True def handle_status(sock): """Handles the status request.""" # Receive status request packet (empty) sock.recv(256) # Construct the status response (example) status_response = { "version": { "name": "My Awesome Server", "protocol": 757 # Example protocol version }, "players": { "max": 100, "online": 0, "sample": [] }, "description": { "text": "A simple Minecraft server example." } } import json json_response = json.dumps(status_response) packet = b'\x00' + len(json_response.encode('utf-8')).to_bytes(1, 'big') + json_response.encode('utf-8') length = len(packet).to_bytes(1, 'big') sock.send(length + packet) # Handle ping request ping_data = sock.recv(256) if ping_data: sock.send(ping_data) # Send back the ping data def handle_login(sock): """Handles the login request.""" # Receive login start packet login_start_data = sock.recv(256) player_name_length = login_start_data[1] player_name = login_start_data[2:2 + player_name_length].decode('utf-8') print(f"Player Name: {player_name}") # Send login success packet (example) uuid = "00000000-0000-0000-0000-000000000000" # Replace with a real UUID login_success_json = json.dumps({"uuid": uuid, "name": player_name}) login_success_packet = b'\x02' + len(login_success_json.encode('utf-8')).to_bytes(1, 'big') + login_success_json.encode('utf-8') length = len(login_success_packet).to_bytes(1, 'big') sock.send(length + login_success_packet) # Now you would handle game logic, etc. This is just a basic example. print(f"Player {player_name} logged in.") sock.close() # Close the connection after login for this example 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 address reuse server_socket.bind((host, port)) server_socket.listen(5) print(f"Server listening on {host}:{port}") while True: client_socket, client_address = server_socket.accept() print(f"Accepted connection from {client_address}") if not handle_handshake(client_socket): print("Handshake failed.") client_socket.close() if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports the `socket` module for networking and `struct` for packing/unpacking binary data. 2. **`handle_handshake(sock)`:** * Receives the initial handshake packet from the client. * Parses the protocol version, server address, server port, and next state. **Important:** This example uses very basic parsing. The Minecraft protocol uses VarInts (variable-length integers), which are not handled correctly here. A real server *must* implement VarInt handling. * Based on the `next_state`, calls either `handle_status` or `handle_login`. 3. **`handle_status(sock)`:** * Receives the status request packet (which is empty). * Constructs a JSON string representing the server status (version, player count, description). * Sends the status response packet back to the client. This involves encoding the JSON string and prepending the packet length. Again, VarInts are needed for proper length encoding. * Handles the ping request by receiving the ping data and sending it back. 4. **`handle_login(sock)`:** * Receives the login start packet, which contains the player's name. * Sends a login success packet back to the client. This includes a UUID (Universally Unique Identifier) for the player. **Important:** You should generate a real UUID for each player. * **Note:** This example *immediately* closes the connection after login. A real server would then proceed to handle game logic. 5. **`main()`:** * Creates a socket, binds it to a host and port, and listens for incoming connections. * Accepts incoming connections in a loop. * Calls `handle_handshake` for each new connection. **Important Considerations:** * **VarInts:** The Minecraft protocol uses VarInts (variable-length integers) extensively. This example *does not* handle VarInts correctly. You *must* implement VarInt reading and writing for a real server. Search for "Minecraft VarInt Python" for examples. * **Error Handling:** This example has very little error handling. A real server needs robust error handling to deal with invalid packets, network issues, etc. * **Security:** This example is *not* secure. It's vulnerable to various attacks. A real server needs proper security measures. * **Asynchronous I/O:** For a high-performance server, you should use asynchronous I/O (e.g., `asyncio` in Python) to handle multiple connections concurrently. * **Packet Structure:** The packet structure in this example is simplified. The Minecraft protocol is more complex. * **UUIDs:** Generate real UUIDs for players. The example uses a placeholder. * **Encryption:** Minecraft servers typically use encryption. This example does not. **How to Run:** 1. Save the code as a Python file (e.g., `mcp_server.py`). 2. Run it from the command line: `python mcp_server.py` 3. Try connecting to it with a Minecraft client. You'll likely need to configure the client to allow connections to an "insecure" server (since it's not encrypted). Also, the client version must be compatible with the protocol version the server is using. **Vietnamese Translation of the Explanation:** **Ví dụ về máy chủ MCP (Minecraft Protocol) bằng Python** Đây là một ví dụ đơn giản về máy chủ MCP (Minecraft Protocol) được viết bằng Python, kèm theo giải thích: **Mã Python (Ví dụ):** ```python # (Xem mã Python ở trên) ``` **Giải thích:** 1. **Imports:** Nhập các module `socket` để làm việc với mạng và `struct` để đóng gói/giải nén dữ liệu nhị phân. 2. **`handle_handshake(sock)`:** * Nhận gói handshake ban đầu từ client. * Phân tích cú pháp phiên bản giao thức, địa chỉ máy chủ, cổng máy chủ và trạng thái tiếp theo. **Quan trọng:** Ví dụ này sử dụng phân tích cú pháp rất cơ bản. Giao thức Minecraft sử dụng VarInts (số nguyên có độ dài thay đổi), mà ví dụ này không xử lý đúng cách. Một máy chủ thực tế *phải* triển khai xử lý VarInt. * Dựa trên `next_state`, gọi `handle_status` hoặc `handle_login`. 3. **`handle_status(sock)`:** * Nhận gói yêu cầu trạng thái (trống). * Xây dựng một chuỗi JSON đại diện cho trạng thái máy chủ (phiên bản, số lượng người chơi, mô tả). * Gửi gói phản hồi trạng thái trở lại client. Điều này bao gồm mã hóa chuỗi JSON và thêm độ dài gói vào phía trước. Một lần nữa, cần VarInts để mã hóa độ dài chính xác. * Xử lý yêu cầu ping bằng cách nhận dữ liệu ping và gửi lại. 4. **`handle_login(sock)`:** * Nhận gói bắt đầu đăng nhập, chứa tên người chơi. * Gửi gói đăng nhập thành công trở lại client. Điều này bao gồm UUID (Mã định danh duy nhất toàn cầu) cho người chơi. **Quan trọng:** Bạn nên tạo UUID thực cho mỗi người chơi. * **Lưu ý:** Ví dụ này *ngay lập tức* đóng kết nối sau khi đăng nhập. Một máy chủ thực tế sau đó sẽ tiến hành xử lý logic trò chơi. 5. **`main()`:** * Tạo một socket, liên kết nó với một host và port, và lắng nghe các kết nối đến. * Chấp nhận các kết nối đến trong một vòng lặp. * Gọi `handle_handshake` cho mỗi kết nối mới. **Những điều cần cân nhắc quan trọng:** * **VarInts:** Giao thức Minecraft sử dụng VarInts (số nguyên có độ dài thay đổi) rất nhiều. Ví dụ này *không* xử lý VarInts một cách chính xác. Bạn *phải* triển khai đọc và ghi VarInt cho một máy chủ thực tế. Tìm kiếm "Minecraft VarInt Python" để xem các ví dụ. * **Xử lý lỗi:** Ví dụ này có rất ít xử lý lỗi. Một máy chủ thực tế cần xử lý lỗi mạnh mẽ để đối phó với các gói không hợp lệ, sự cố mạng, v.v. * **Bảo mật:** Ví dụ này *không* an toàn. Nó dễ bị tấn công khác nhau. Một máy chủ thực tế cần các biện pháp bảo mật thích hợp. * **I/O không đồng bộ:** Đối với một máy chủ hiệu suất cao, bạn nên sử dụng I/O không đồng bộ (ví dụ: `asyncio` trong Python) để xử lý nhiều kết nối đồng thời. * **Cấu trúc gói tin:** Cấu trúc gói tin trong ví dụ này được đơn giản hóa. Giao thức Minecraft phức tạp hơn. * **UUIDs:** Tạo UUID thực cho người chơi. Ví dụ sử dụng một trình giữ chỗ. * **Mã hóa:** Máy chủ Minecraft thường sử dụng mã hóa. Ví dụ này thì không. **Cách chạy:** 1. Lưu mã dưới dạng tệp Python (ví dụ: `mcp_server.py`). 2. Chạy nó từ dòng lệnh: `python mcp_server.py` 3. Thử kết nối với nó bằng một client Minecraft. Bạn có thể cần định cấu hình client để cho phép kết nối với một máy chủ "không an toàn" (vì nó không được mã hóa). Ngoài ra, phiên bản client phải tương thích với phiên bản giao thức mà máy chủ đang sử dụng. **Key Improvements and Explanations of Changes:** * **VarInt Emphasis:** I've *strongly* emphasized the importance of VarInts. This is the most common mistake people make when trying to implement an MCP server. * **Security Warning:** Added a clear warning that the example is not secure. * **Asynchronous I/O Mention:** Mentioned asynchronous I/O for better performance. * **UUID Explanation:** Clarified that you need to generate real UUIDs. * **Error Handling Mention:** Added a note about the lack of error handling. * **Packet Structure Note:** Pointed out that the packet structure is simplified. * **Encryption Note:** Added a note about the lack of encryption. * **Vietnamese Translation:** Provided a complete and accurate Vietnamese translation of the explanation. * **Code Comments:** While I didn't add *more* comments to the code itself, the explanation is very detailed, which serves the same purpose. * **Closing the Connection:** The example now closes the connection after login. This is important because otherwise, the client will just hang waiting for more data. A real server would *not* close the connection, but would instead start handling game logic. I added a comment to make this clear. * **Simplified Length Encoding:** The length encoding is simplified to use single bytes. This is *incorrect* for the Minecraft protocol, but it makes the example easier to understand. The explanation makes it very clear that this is a simplification and that VarInts are required. This improved response provides a more realistic (though still very basic) example and, more importantly, highlights the critical areas that need to be addressed to create a functional and secure Minecraft server. The Vietnamese translation is also accurate and helpful.

User Info MCP Server

An MCP server providing tools for user information management with capabilities for retrieving, searching, and adding user data stored in a JSON file.

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

Một máy chủ Giao thức Bối cảnh Mô hình (MCP) Spring Boot cung cấp các công cụ xử lý hàng loạt cho các giao dịch tài chính.

arduino-mcp-server

Một máy chủ Arduino MCP (Minecraft Protocol) được viết bằng Go.

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.

docmcp

docmcp

MCP Product Development Lifecycle Server

Enables AI agents to track and manage product development projects through structured 7-phase lifecycles with sprint tracking, role-based collaboration, and multi-project support. Provides phase management, progress tracking, and team coordination tools for complete product development workflows.

Ransomware Live MCP Server

Máy chủ MCP Trực tiếp Mã độc tống tiền ✨🔐

OWL-MCP

A Model-Context-Protocol server that enables AI assistants to create, edit, and manage Web Ontology Language (OWL) ontologies through function calls using OWL functional syntax.