Discover Awesome MCP Servers

agentgraph-trust

Security scanner and trust verification for AI agent tools. Scans GitHub repositories for vulnerabilities and returns signed trust attestations (Ed25519/JWS) with trust-tiered rate limiting recommendations.

A sample MCP server for understanding cloud spend

针对 AWS Cost Explorer 和 CloudWatch 日志的 MCP (Most Common Practices) Or, more formally: 针对 AWS Cost Explorer 和 CloudWatch Logs 的最佳实践 (zhēn duì AWS Cost Explorer hé CloudWatch Logs de zuì jiā shí jiàn)

Substreams Search MCP Server

MCP server that lets AI agents search the substreams.dev package registry.

AI Naming Standard MCP Server

Enables automatic generation and validation of standardized file names using AI-driven conventions for microservices architecture. Supports multi-language naming with structured components like microservice, layer, domain, and action identifiers.

ClawHire MCP

An employer-facing MCP server that enables hiring managers to post jobs, search for candidates, and manage applications through natural language conversation. It integrates with WonderCV's hiring infrastructure and features a unique system for identifying and filtering talent with AI-agent fluency.

WYGIWYH Expense Tracking MCP Server

Enables AI agents to interact with the WYGIWYH expense tracking API through 75 dynamically generated MCP tools. Supports comprehensive financial operations including transaction management, account handling, recurring expenses, and investment tracking.

Token Revoke MCP

一个 MCP 服务器，用于跨多个区块链检查和撤销 ERC-20 代币授权。

HeadHunter MCP Server

Enables AI assistants to search job vacancies, manage resumes, and apply to jobs on HeadHunter (hh.ru), Russia's largest job search platform. Includes OAuth 2.0 integration for secure job applications and an automated vacancy hunter agent with intelligent matching.

Maple

Maple is a unified MCP server for agent observability, safety control, and behavior evolution, acting as a monitoring and auditing layer for high-agency agents. It enables developers to capture session timelines, replay risky branches, detect anomalies using ML, and enforce action guardrails.

ArXiv MCP Server

一个连接人工智能助手和 ArXiv 研究库的桥梁，它可以通过消息控制协议实现学术论文的搜索、下载和阅读。

otparse-mcp

A containerized MCP server for parsing OT/ICS packet captures, specifically supporting Modbus and BACnet protocols via tshark. It provides structured JSON output from PCAP files to enable LLMs to analyze industrial network traffic and derive device inventories.

cutie-mcp

Enables interaction with the Cuti-E admin API to manage conversations, reply to user feedback, and monitor platform analytics. It allows for tracking active user stats, managing team members, and updating app configurations directly through MCP-compatible clients.

CodeWiki MCP Server

Integrates with Google CodeWiki to search, fetch, and cache documentation for GitHub repositories, enabling easy access to repository documentation through natural language queries.

NTV Scaffolding MCP Server

Enables AI assistants to discover, understand, and generate code for NTV Scaffolding Angular components, including documentation lookup, template generation, and complete component file scaffolding.

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.

Liara MCP Server

Enables AI assistants to deploy and manage applications, databases, object storage, VMs, DNS, and infrastructure on the Liara cloud platform through natural language commands.

Azure Kusto MCP Server

用于 Azure Kusto 的 MCP 服务器 (Yòng yú Azure Kusto de MCP fúwùqì)

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!

AutoBrowser MCP

Autobrowser MCP 是一个模型上下文提供器 (MCP) 服务器，它允许 AI 应用程序控制您的浏览器。

MCP Notion Server

MCP server for using the Notion API

ORAS MCP Server

Enables users to interact with container registries through the ORAS CLI, providing information about container images, platforms, and signatures via natural language queries.

Jira JQL Tool for Claude

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

Nanoleaf MCP Server

A Model Context Protocol server that enables controlling Nanoleaf smart lights through Warp terminal or any MCP-compatible client, providing tools for device discovery, authorization, and control of lights, brightness, colors, and effects.

AURA MCP Server

Enables Claude and ChatGPT to interact with AdEx AURA API for DeFi portfolio analysis, yield opportunity scanning, and automated trading strategy execution across multiple EVM chains. Includes risk management guardrails and on-chain payment verification.

Betaflight MCP Server

Enables natural language interaction with Betaflight FPV drone flight controllers for configuration, PID tuning, sensor monitoring, VTX control, and blackbox management through Claude AI.

edu_video_gen

edu_video_gen

Swagger MCP

An MCP server that connects to a Swagger specification and helps an AI to build all the required models to generate a MCP server for that service.

LLM Server

一个 MCP 服务器，为大型语言模型提供访问其他大型语言模型的能力。 (Or, more formally:) 一个 MCP 服务器，为 LLM 提供访问其他 LLM 的权限。

WeiWanMcpServer

私人 Minecraft 服务器 (Sīrén Minecraft fúwùqì)