Discover Awesome MCP Servers

thoughtproof-mcp

Adversarial multi-model reasoning verification for AI agents. Claude, Grok, and DeepSeek challenge each decision — returns ALLOW or HOLD with JWKS-signed attestation. x402-gated on Base.

MiniMax MCP Server

Bridges MiniMax AI capabilities to the Model Context Protocol, enabling AI agents to perform image understanding, text-to-image generation, and speech synthesis. It provides a standardized interface for accessing MiniMax's core tools via JSON-RPC.

Wayland MCP Server

Enables AI assistants to automate Wayland desktop environments through screenshot analysis, mouse control, and keyboard input simulation. It supports visual context via VLM providers like Gemini and OpenRouter to perform complex, multi-step desktop actions.

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.

Xiaohongshu (RedBook) MCP Server

Enables automated interaction with Xiaohongshu (Little Red Book) platform including searching posts, retrieving content and comments, and posting AI-generated comments with persistent login support.

Twilio MCP Server by CData

This read-only MCP Server allows you to connect to Twilio data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

Stimulus Docs MCP Server

An MCP server that provides access to up-to-date Stimulus JS documentation directly within Claude conversations and VS Code.

Actor-Critic Thinking MCP Server

Provides dual-perspective analysis through alternating actor (creator/performer) and critic (analyzer/evaluator) viewpoints, generating comprehensive performance evaluations with balanced, actionable feedback.

Swagger MCP Server

A lightweight server that enables interaction with the Swagger Petstore API using the Model Context Protocol, allowing operations on pets, stores, and users through dynamically loaded OpenAPI specifications.

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.

Datadog Logs MCP Server

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

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.

SSH Read-Only MCP Server

Enables secure remote SSH command execution with strict read-only enforcement, allowing safe delegation of SSH access to Claude while preventing write operations. Supports connection pooling, command validation, and comprehensive logging for audit trails.

Apple Reminders MCP Server

Enables management of Apple Reminders on macOS, including creating, updating, and querying reminders with due dates, priorities, and completion status across different reminder lists.

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.

Playwright MCP Server

A Model Context Protocol server that enables AI assistants to perform web automation tasks by connecting to remote Playwright/browserless instances, supporting navigation, screenshots, HTML extraction, and element interaction.

GDB MCP Server

Máy chủ MCP để gỡ lỗi GDB.

botindex-mcp-server

BotIndex MCP Server gives AI agents searchable access to verified on-chain and off-chain protocol metadata so they can discover, validate, and act on blockchain ecosystem data with less hallucination risk.

Notion MCP Server

Auto-generated server that enables interaction with Notion's API through the Multi-Agent Conversation Protocol (MCP), allowing users to programmatically manage Notion workspace content through natural language.

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.

strava-mcp

Máy chủ MCP cho Strava

R2R FastMCP Server

Integrates R2R (Retrieval-Augmented Generation) with Claude Desktop, enabling semantic search across knowledge bases and RAG-based question answering with support for vector, graph, web, and document search.

Zhipu AI Image Generator MCP Server

Enables text-to-image generation using Zhipu AI's CogView4 model with support for multiple image sizes (1024x1024, 768x768, 576x1024) and automatic local saving of generated images.

MCP-NetDisk

A private cloud storage system with Model Context Protocol integration that allows AI models to manage files through operations like searching, reading, and creating content. It features a complete web interface for user administration, storage quota management, and rich media previews.

Malaysian Weather MCP Server

Provides real-time weather forecasts for locations across Malaysia by fetching data directly from MET Malaysia's API. It enables AI assistants to query today's conditions and seven-day forecasts for states, districts, and towns.

Alethea World History Engine

A narrative graph engine that enables LLMs to generate, track, and mutate complex fictional worlds while maintaining consistency between factions, characters, and locations. It acts as a specialized RAG framework for storytelling, allowing models to manage thousands of entities without exceeding context limits.

MCP Backup Server

Provides specialized backup and restoration capabilities for AI agents and code editors, enabling instant, context-aware save points for files and folders. It supports version history, pattern filtering, and automated safety backups to protect code during critical refactoring or restructuring tasks.

Interactive Brokers MCP Server

Connects AI assistants to Interactive Brokers for intelligent portfolio management, options analysis, risk monitoring, and automated trading strategy suggestions. Enables real-time account tracking, Greeks calculations, option chain analysis, and playbook-based risk adjustments through natural language.