发现优秀的 MCP 服务器

CharityPro MCP Server

Query and analyze charity projects from a project management dashboard using natural language via Claude Desktop, with support for multiple organizations and Arabic language.

VeniAI-Hukuk-EmsalKarar-MCPServer

An AI-powered legal research tool that enables users to search for and retrieve legal precedents and case law decisions through a Model Context Protocol server. It supports both Turkish and English, providing lawyers and researchers with streamlined access to a comprehensive database of jurisprudence.

Jira JQL Tool for Claude

简单实用的MCP工具 (Jiǎndān shíyòng de MCP gōngjù)

Gradle Tomcat MCP Server

Enables management of Gradle-based Tomcat applications with capabilities for starting, stopping, restarting processes and querying application logs.

build-simple-mcp

Okay, here's a breakdown of how to build a simple Minecraft Protocol (MCP) server in Python. This will be a very basic server, focusing on the handshake and status phases. It won't handle actual gameplay. It's designed to be a starting point for learning the protocol. **Important Considerations:** * **Complexity:** The Minecraft Protocol is complex. This example simplifies things significantly. A full-fledged server requires handling many more packets, game logic, and world data. * **Security:** This example is *not* secure. It doesn't include encryption or authentication. Do not expose this to the internet without adding proper security measures. * **Libraries:** We'll use the `struct` module for packing and unpacking data, and `socket` for network communication. No external libraries are strictly required for this basic example, but libraries like `nbt` (for handling NBT data) and `cryptography` (for encryption) would be essential for a more complete server. * **Minecraft Version:** The Minecraft protocol changes with each version. This example is based on a relatively recent version (e.g., 1.19+), but you'll need to adjust the protocol version and packet IDs if you're targeting a different version. Refer to the Minecraft Protocol documentation for your target version. [https://wiki.vg/Protocol](https://wiki.vg/Protocol) is an excellent resource. **Python Code (Simple MCP Server):** ```python import socket import struct import json # Configuration HOST = 'localhost' # Listen on all interfaces PORT = 25565 PROTOCOL_VERSION = 762 # Example: Minecraft 1.19.2 SERVER_VERSION_NAME = "My Simple Server" MAX_PLAYERS = 20 MOTD = "§aA Simple Minecraft Server\n§bWelcome!" # Supports Minecraft color codes def create_varint(data): """Encodes an integer as a Minecraft VarInt.""" out = bytearray() while True: byte = data & 0x7F data >>= 7 if data != 0: byte |= 0x80 out.append(byte) if data == 0: break return bytes(out) def read_varint(sock): """Reads a Minecraft VarInt from the socket.""" result = 0 shift = 0 while True: byte = sock.recv(1)[0] result |= (byte & 0x7F) << shift shift += 7 if not byte & 0x80: break if shift > 35: raise ValueError("VarInt is too big") # Prevent infinite loop return result def create_string(data): """Creates a Minecraft string (VarInt length + UTF-8 encoded string).""" encoded_string = data.encode('utf-8') length = create_varint(len(encoded_string)) return length + encoded_string def create_packet(packet_id, data): """Creates a Minecraft packet (VarInt length + VarInt packet ID + data).""" packet_id_bytes = create_varint(packet_id) packet_data = packet_id_bytes + data packet_length = create_varint(len(packet_data)) return packet_length + packet_data def handle_handshake(sock): """Handles the Handshake phase.""" protocol_version = read_varint(sock) server_address_length = read_varint(sock) server_address = sock.recv(server_address_length).decode('utf-8') server_port = struct.unpack('>H', sock.recv(2))[0] # Unpack unsigned short (big endian) next_state = read_varint(sock) print(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, Next State {next_state}") return next_state def handle_status_request(sock): """Handles the Status Request and Response.""" # Status Request (empty packet) packet_length = read_varint(sock) packet_id = read_varint(sock) if packet_id != 0x00: print(f"Unexpected packet ID in status request: {packet_id}") return # Create Status Response status = { "version": { "name": SERVER_VERSION_NAME, "protocol": PROTOCOL_VERSION }, "players": { "max": MAX_PLAYERS, "online": 0, "sample": [] # Can add player samples here }, "description": { "text": MOTD } } status_json = json.dumps(status, ensure_ascii=False).encode('utf-8') # Ensure proper UTF-8 encoding status_string = create_string(status_json.decode('utf-8')) # Decode back to string for create_string status_packet = create_packet(0x00, status_string) sock.sendall(status_packet) def handle_ping(sock): """Handles the Ping Request and Response.""" # Ping Request (payload) packet_length = read_varint(sock) packet_id = read_varint(sock) payload = sock.recv(8) # 8-byte payload if packet_id != 0x01: print(f"Unexpected packet ID in ping request: {packet_id}") return # Create Ping Response (same payload) ping_packet = create_packet(0x01, payload) sock.sendall(ping_packet) def handle_client(sock, address): """Handles a single client connection.""" print(f"Accepted connection from {address}") try: # Handshake next_state = handle_handshake(sock) if next_state == 1: # Status handle_status_request(sock) handle_ping(sock) # Client expects a ping after status elif next_state == 2: # Login (not implemented in this example) print("Login requested, but not implemented.") # In a real server, you'd handle login here else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: sock.close() print(f"Connection from {address} closed.") def main(): """Main server loop.""" 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) # Listen for up to 5 incoming connections print(f"Server listening on {HOST}:{PORT}") try: while True: client_socket, client_address = server_socket.accept() handle_client(client_socket, client_address) except KeyboardInterrupt: print("Server shutting down...") finally: server_socket.close() if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports necessary modules (`socket`, `struct`, `json`). 2. **Configuration:** Sets server parameters like host, port, protocol version, MOTD, etc. Adjust these to your liking. The `PROTOCOL_VERSION` is *critical* and must match the Minecraft client version you're using. 3. **`create_varint(data)`:** Encodes an integer into a Minecraft VarInt. VarInts are used for variable-length integer representation in the protocol. 4. **`read_varint(sock)`:** Reads a VarInt from the socket. 5. **`create_string(data)`:** Creates a Minecraft string, which is a VarInt representing the string length followed by the UTF-8 encoded string. 6. **`create_packet(packet_id, data)`:** Creates a complete Minecraft packet. A packet consists of a VarInt representing the packet length, a VarInt representing the packet ID, and the packet data. 7. **`handle_handshake(sock)`:** Handles the Handshake phase. This is the first phase of the protocol. The client sends a handshake packet containing the protocol version, server address, port, and the "next state" (1 for Status, 2 for Login). 8. **`handle_status_request(sock)`:** Handles the Status Request and Response. The client sends an empty status request packet. The server responds with a JSON string containing server information (version, player count, MOTD). 9. **`handle_ping(sock)`:** Handles the Ping Request and Response. The client sends a ping packet with a payload. The server responds with a pong packet containing the same payload. This is used to measure latency. 10. **`handle_client(sock, address)`:** Handles a single client connection. It calls the appropriate handler functions based on the "next state" received in the handshake. 11. **`main()`:** The main server loop. It creates a socket, binds it to the specified host and port, listens for incoming connections, and spawns a new thread (or process, in a more robust implementation) to handle each client. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Execute the script from your terminal: `python mcp_server.py` 3. **Connect:** Start your Minecraft client. In the multiplayer menu, add a server with the address `localhost:25565` (or the host and port you configured). *Make sure the Minecraft client version matches the `PROTOCOL_VERSION` in the code.* 4. **Observe:** You should see the server in the server list. When you hover over it, you should see the MOTD. You won't be able to join the server because the login phase is not implemented. The server's console output will show the handshake and status requests. **Chinese Translation of Key Concepts:** * **Minecraft Protocol (MCP):** Minecraft 协议 (Minecraft Xiéyì) * **Handshake:** 握手 (Wòshǒu) * **Status:** 状态 (Zhuàngtài) * **Login:** 登录 (Dēnglù) * **Packet:** 数据包 (Shùjù bāo) * **VarInt:** 变长整数 (Biàn cháng zhěngshù) * **MOTD (Message of the Day):** 每日消息 (Měi rì xiāoxī) / 服务器标语 (Fúwùqì biāoyǔ) * **Protocol Version:** 协议版本 (Xiéyì bǎnběn) * **Server Address:** 服务器地址 (Fúwùqì dìzhǐ) * **Port:** 端口 (Duānkǒu) * **Payload:** 载荷 (Zàihè) **Further Development:** * **Login Phase:** Implement the login phase to handle player authentication. This involves encryption and communication with Mojang's authentication servers. * **Gameplay:** Implement the gameplay loop, including handling player movement, chunk loading, entity management, and game logic. * **World Generation:** Generate or load a Minecraft world. You'll need to use an NBT library to read and write world data. * **Multi-threading/Asynchronous I/O:** Use threads or asynchronous I/O to handle multiple clients concurrently. * **Error Handling:** Add more robust error handling to gracefully handle unexpected events. * **Security:** Implement encryption and authentication to protect the server from attacks. This example provides a basic foundation. Building a complete Minecraft server is a significant undertaking. Good luck!

biblebridge-mcp

Provides structured access to Scripture through the BibleBridge API, enabling semantic search, contextual verse retrieval, and cross-reference analysis. It supports natural language reference normalization and comparative theological exploration across different passages.

Toki Toki no Mi

An MCP server that records decisions, rejected alternatives, and justifications, and retrieves them later to avoid re-litigating past choices. It stores data locally in SQLite and Markdown.

mcp-server-dameng

MCP server enabling AI assistants to connect and query Dameng DM8 databases via JDBC. Supports SQL queries, listing tables, and describing schemas.

mcp-weather-server

Provides live weather data (current conditions, forecasts) and city geocoding through Open-Meteo API, enabling AI assistants to answer weather queries without an API key.

io.github.wesseltl/excel-mcp

Enables AI agents to read real Excel files with messy layouts, auto-detecting header rows and handling merged cells to extract clean tabular data via MCP tools.

research

Multi-purpose research MCP server integrating web search, deep research, web scraping, research methodology routing, and GPT Researcher report generation.

askdb

Self-hosted MCP server that bridges your MongoDB or PostgreSQL database to AI agents, with sandbox isolation and field-level control.

skillfm-llm-cost-optimizer-mcp

LLM cost optimization and provider usage visibility for MCP-capable agents.

aspro-mcp

Enables LLMs to interact with the Aspro.Cloud REST API through self-describing tools for discovering and calling modules, entities, and methods.

Jira Enterprise MCP

Small MCP server for connecting to enterprise Jira using a personal access token. It enables issue operations, project listing, JQL searches, and attachment handling.

Fal.ai MCP Server

Enables Claude Desktop and other MCP clients to generate images, videos, music, and audio using Fal.ai models. Supports text-to-image generation, video creation, music composition, text-to-speech, audio transcription, and image enhancement through natural language prompts.

mcp-atlassian

MCP server for Atlassian Confluence and Jira, supporting both Cloud and Server/Data Center deployments with tools for searching, creating, and updating issues and pages.

majincleaning-ops

Enables AI assistants to query and manage real booking data from MajinCleaningSolutions via Supabase, including checking availability, listing bookings, and updating status.

Event Presence Index MCP Server

Enables mapping a company's publicly stated event presence by returning the conferences and trade shows it attends, with years, from a domain. Built on the Mamba Labs Event Presence Index actor on Apify.

MCP Bitbucket Server

Enables automated interaction with Bitbucket, including creating and listing pull requests, through the Model Context Protocol.

PixelCheck

An MCP server that gives AI agents real browser capabilities including screenshotting, action execution, data extraction, and multi-persona auditing for frontend validation.

northbridge-diligence

An MCP server that wraps SEC EDGAR APIs to provide company financial data, screening metrics, and disclosure signals for investment diligence, with every figure traced to its source filing.

SAST MCP Server

Integrates 15+ static application security testing tools (Semgrep, Bandit, TruffleHog, etc.) with Claude Code AI, enabling automated vulnerability scanning and security analysis through natural language commands. Supports cross-platform operation with remote execution on dedicated security VMs.

CHUK Music MCP Server

Enables AI-assisted music composition through copyable pattern templates, style constraints, and arrangement tools that compile to MIDI files. Provides 30+ tools for managing musical structures, layers, patterns, and styles with deterministic compilation from YAML arrangements.

Audit Findings MCP Server

Enables managing audit findings in a SQLite database via natural language, allowing queries and updates without writing SQL.

Leanote MCP

Enables interaction with a self-hosted Leanote note service, allowing users to list notebooks and create notes.

Brewfather MCP Server

Read-only MCP server exposing Brewfather brewing data—batches, recipes, fermentation readings, and inventory—as tools for natural language queries.

Kali Linux MCP Server

An MCP server that integrates Kali Linux security tools with AI assistants, enabling security professionals to run penetration testing, vulnerability assessments, and generate reports through natural language commands.

Feature Evaluation MCP Server

Enables comprehensive feature engineering for classification datasets with automated preprocessing and 13 specialized analysis tools. Supports feature importance calculation, correlation analysis, recursive feature elimination, and model evaluation with integrated visualization capabilities.

Polar MCP

Enables users to query Polar health data (activity, sleep, recovery, training sessions, heart rate) through MCP with secure authentication, redacted personal info, and bounded responses.