Discover Awesome MCP Servers

aftr

Enables AI agents to control Adobe After Effects to create videos programmatically, with commands for comps, layers, effects, and rendering.

ProxmoxMCP

A Python-based MCP server for interacting with Proxmox hypervisors, enabling management of nodes, VMs, containers, and executing commands via QEMU Guest Agent.

PostGrid MCP Server

Enables sending letters and MICR-encoded checks, managing contacts and templates, and verifying US/Canadian addresses via the PostGrid Print & Mail and Address Verification APIs from Claude.

Gingugu

Persistent long-term memory for AI coding assistants. Local SQLite, no cloud - 16 MCP tools to store, search, relate, and consolidate typed memories with a confidence lifecycle, hybrid BM25 + semantic search, namespaces, a knowledge graph, and a built-in OS keychain credential vault.

mcp-4o-Image-Generator

mcp-4o-Image-Generator

fallhrpaper-mcp

MCP server for foldkit that exposes 7-prime spine, 7 κ-bands, and 6 fold operations as tools and resources, enabling folding state operations and κ-band classification in MCP clients.

arduino-mcp-server

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

UberEats MCP Server Enhanced

A production-ready MCP server for UberEats automation, featuring Redis-backed sessions, n8n integration, and enterprise-grade security, enabling login, item addition, address setting, and checkout.

nucleo-mcp

Enables AI assistants to search, retrieve, and save Nucleo icons from the user's local library directly into projects.

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.

rlm-tools

An MCP server that provides a persistent sandbox for AI coding agents to explore codebases server-side, returning only compact summaries to reduce context consumption.

Datadog Logs MCP Server

Enables searching and retrieving Datadog logs through the Model Context Protocol with customizable queries, time ranges, and result limits.

mcp-dev-tools

Provides AI coding assistants with tools to run git status, recent commits, tests, and linter on a real repository.

die-mcp

Máy chủ MCP Detect-It-Easy

hwms-mcp-server

AI-driven module selection and scaffold generation for hybrid web applications. Enables automatic dependency resolution and project structure creation via natural language queries.

xtapdown-mcp

An MCP server that provides LLM clients with direct access to XTapDown's Twitter creator toolkit, enabling tweet downloads, engagement calculations, content generation, and trend analysis without authentication or rate limits.

CashClaw GHL MCP

An MCP server for GoHighLevel with 82 live-tested tools, enabling CRM operations like contact management, appointments, invoices, and workflows via natural language.

HREVN MCP Server

Minimal stdio MCP server that exposes HREVN compliance and audit tools as structured MCP tools, enabling baseline checks, profile validation, and bundle generation via a managed runtime.

koios-mcp

An MCP server that provides LLMs with access to 95 tools covering the Koios Cardano blockchain REST API, enabling queries for on-chain data like transactions, addresses, assets, and governance.

SimuBridge

Enables AI assistants to control MATLAB Simulink models through natural language, providing tools for model creation, block management, wiring, simulation, and more via a local MCP backend.

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.

MojaWave MCP

Connects any MCP-compatible AI assistant to the MojaWave SMS Gateway, enabling sending SMS, checking credit balances, and managing bulk SMS jobs.

Acopia

MCP server for querying and simulating the dispatch plan of a solar PV + battery system in the Chilean electricity market, using deterministic optimization and optional DRL.

upnote-mcp

Enables AI assistants to interact with Upnote via its x-callback-url API, allowing creation of notes, notebooks, tag management, and search. It also supports navigation to various Upnote sections and custom filters.

supragents-mcp

A read-only research MCP server that provides search and browsing tools for Hacker News, Reddit, and Product Hunt. Works with zero API keys for basic use.

Dell Unity MCP Server

An MCP server for Dell Unity storage arrays that automatically generates tools from OpenAPI specifications, enabling AI assistants like Claude and n8n to interact with Unity storage systems without storing credentials.

Android MCP

Enables interaction with Android devices and emulators through ADB, allowing control actions like tapping, text input, screenshots, UI inspection, and app launching through natural language.

Phpactor MCP Server

Provides project-wide semantic PHP refactoring tools (find references, rename classes/members, move class, class info) for AI assistants by wrapping Phpactor.

mcp-a2a-documentation

Search and retrieve Agent2Agent (A2A) protocol documentation using full-text search and section filtering.