Discover Awesome MCP Servers

digital-twin

Enables natural language control of a digital twin simulation pipeline for phone drop tests, converting LS-DYNA .k meshes to solid .k files with hand grip poses using 7 MCP tools.

storybook-mcp

Integrates with a running Storybook instance to let AI-powered coding tools browse, inspect, and scaffold components from natural language.

CloakBrowser MCP

CloakBrowser MCP is a Python MCP server that lets agents control a CloakBrowser-backed browser from Linux servers, CI jobs, and other environments where a normal desktop browser is not available.

terminal-mcp-server

Enables secure remote and local command execution via SSH, with session management and environment variable support.

Model Context Protocol .NET Template

这个仓库包含一个用于在 .NET 中创建模型上下文协议 (MCP) 应用程序的模板。

db-mcp

数据库模型上下文协议（DB-MCP）服务器

mcp-calculator

An MCP server that integrates the MathJS library to provide AI models with advanced calculation capabilities, including support for complex numbers, matrices, and unit conversions. It supports both stdio and HTTP transports for seamless integration with clients like Claude Desktop and GitHub Copilot.

Clay.com MCP Server

MCP server for Clay.com API providing people and company enrichment, and Clay table operations.

Azure DevOps MCP Server

Enables interaction with Azure DevOps work items through AI assistants like VS Code/GitHub Copilot. Supports fetching work item details and updating work item statuses using natural language commands.

MCP Alchemy Server

Provides access to financial transaction data from XB database, enabling lookup of payout transactions by UUID or Client Transaction ID.

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.

sqlite-explorer-mcp

Read-only SQLite database explorer for MCP clients. Allows discovery of tables and columns via resources and running SELECT queries via a tool.

Mcp Server

Okay, here's an example of how you might structure a simple MCP (Minecraft Protocol) server in Python, designed to interact with a client (like a Minecraft game client) and tailored for use with Claude (or any other LLM) for potential game logic or content generation. This is a simplified example and doesn't cover all the complexities of the Minecraft protocol. It focuses on the core concepts. **Important Considerations:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex and version-dependent. This example is highly simplified and likely won't work directly with a modern Minecraft client without significant modification. You'll need to research the specific protocol version you want to support. * **Libraries:** Using a library like `mcstatus` or `python-minecraft-nbt` can greatly simplify working with the Minecraft protocol. However, for this example, I'll try to keep it relatively library-free to illustrate the core concepts. * **Security:** This example is for demonstration purposes only and is not secure. Do not expose this to the internet without proper security measures. * **Claude Integration:** The Claude integration is represented by placeholder comments. You'll need to use a Claude API client (e.g., Anthropic's Python SDK) to actually interact with Claude. ```python import socket import struct import json import threading # Configuration HOST = '127.0.0.1' # Localhost PORT = 25565 # Default Minecraft port (can be changed) # --- Minecraft Protocol Helper Functions --- def read_varint(sock): """Reads a Minecraft VarInt from the socket.""" result = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return None # Connection closed byte = byte[0] result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break return result def write_varint(sock, value): """Writes a Minecraft VarInt to the socket.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 sock.send(bytes([byte])) if value == 0: break def read_string(sock): """Reads a Minecraft string (prefixed with a VarInt length).""" length = read_varint(sock) if length is None: return None data = sock.recv(length) return data.decode('utf-8') def write_string(sock, string): """Writes a Minecraft string (prefixed with a VarInt length).""" encoded = string.encode('utf-8') write_varint(sock, len(encoded)) sock.send(encoded) def pack_data(data_type, data): """Packs data according to the Minecraft data type.""" if data_type == "varint": return write_varint(data) elif data_type == "string": return write_string(data) elif data_type == "byte": return struct.pack("!b", data) elif data_type == "ubyte": return struct.pack("!B", data) elif data_type == "short": return struct.pack("!h", data) elif data_type == "ushort": return struct.pack("!H", data) elif data_type == "int": return struct.pack("!i", data) elif data_type == "long": return struct.pack("!q", data) elif data_type == "float": return struct.pack("!f", data) elif data_type == "double": return struct.pack("!d", data) elif data_type == "bool": return struct.pack("!?", data) else: raise ValueError(f"Unknown data type: {data_type}") def create_packet(packet_id, data): """Creates a Minecraft packet.""" packet_data = b"" for data_type, value in data: if data_type == "varint": packet_data += value elif data_type == "string": packet_data += value else: packet_data += pack_data(data_type, value) packet = b"" write_varint(packet, packet_id) packet += packet_data length = len(packet) packet_length = b"" write_varint(packet_length, length) return packet_length + packet # --- Packet Handling Functions --- def handle_handshake(sock): """Handles the initial handshake packet.""" protocol_version = read_varint(sock) server_address = read_string(sock) server_port = struct.unpack("!H", sock.recv(2))[0] # Unpack unsigned short (2 bytes) 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 (ping).""" print("Status Request received") # Example status response (replace with dynamic data if needed) status = { "version": { "name": "My Claude Server", "protocol": 757 # Example protocol version }, "players": { "max": 10, "online": 0, "sample": [] }, "description": { "text": "A Minecraft server powered by Claude!" } } status_json = json.dumps(status) write_string(sock, status_json) # Send the packet packet_id = 0x00 # Status Response packet ID packet_data = [("string", status_json)] packet = create_packet(packet_id, packet_data) write_varint(sock, len(packet)) sock.sendall(packet) def handle_ping(sock): """Handles the ping request.""" payload = sock.recv(8) # 8-byte payload print(f"Ping received with payload: {payload}") # Send back the same payload packet_id = 0x01 # Pong packet ID packet_data = [("long", struct.unpack("!q", payload)[0])] packet = create_packet(packet_id, packet_data) write_varint(sock, len(packet)) sock.sendall(packet) def handle_login_start(sock): """Handles the login start packet (username).""" username = read_string(sock) print(f"Login Start: Username {username}") # --- Claude Integration Point --- # Here, you would send the username (and potentially other data) to Claude. # Claude could then generate a response, such as a welcome message, # a custom world seed, or even modify the player's starting inventory. # # Example (replace with actual Claude API call): # claude_response = claude.generate_response(f"Minecraft player joined: {username}") # print(f"Claude response: {claude_response}") # For now, just send a simple login success packet. uuid = "00000000-0000-0000-0000-000000000000" # Dummy UUID packet_id = 0x02 # Login Success packet ID packet_data = [("string", uuid), ("string", username)] packet = create_packet(packet_id, packet_data) write_varint(sock, len(packet)) sock.sendall(packet) # Example: Send a chat message to the player (after login) chat_message = {"text": f"Welcome to the server, {username}!"} chat_json = json.dumps(chat_message) packet_id = 0x0F # Chat Message packet ID (example) packet_data = [("string", chat_json), ("byte", 0), ("string", "00000000-0000-0000-0000-000000000000")] packet = create_packet(packet_id, packet_data) write_varint(sock, len(packet)) sock.sendall(packet) def handle_client(sock, addr): """Handles a single client connection.""" print(f"Accepted connection from {addr}") try: state = handle_handshake(sock) if state == 1: # Status handle_status_request(sock) handle_ping(sock) elif state == 2: # Login handle_login_start(sock) # After login, you would enter the "play" state and handle game packets. # This is where you'd receive player actions (movement, chat, etc.) # and send world updates. This is a very complex part of the protocol. while True: # Example: Receive a packet and print its ID (for debugging) packet_length = read_varint(sock) if packet_length is None: break # Connection closed packet_id = read_varint(sock) print(f"Received packet with ID: 0x{packet_id:02X}") # --- Claude Integration Point --- # You could send the packet data to Claude for analysis or processing. # For example, Claude could analyze chat messages, detect suspicious # player behavior, or generate new game events. # # Example: # claude_analysis = claude.analyze_packet(packet_id, packet_data) # print(f"Claude analysis: {claude_analysis}") else: print(f"Unknown state: {state}") except Exception as e: print(f"Error handling client: {e}") finally: print(f"Closing connection from {addr}") sock.close() # --- Main Server Loop --- def main(): """Main server function.""" 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 connections print(f"Listening on {HOST}:{PORT}") try: while True: sock, addr = server_socket.accept() client_thread = threading.Thread(target=handle_client, args=(sock, addr)) client_thread.start() except KeyboardInterrupt: print("Shutting down server...") finally: server_socket.close() if __name__ == "__main__": main() ``` **Explanation and Key Points:** 1. **Socket Setup:** The code creates a basic TCP socket server. 2. **Minecraft Protocol Functions:** * `read_varint`, `write_varint`: Minecraft uses VarInts (variable-length integers) for packet lengths and IDs. These functions handle reading and writing them. * `read_string`, `write_string`: Handle reading and writing strings, which are prefixed with a VarInt length. * `pack_data`: Packs data into bytes according to the specified Minecraft data type. * `create_packet`: Creates a Minecraft packet by combining the packet ID and data. 3. **Packet Handling:** * `handle_handshake`: Handles the initial handshake packet, which determines the client's intended state (status or login). * `handle_status_request`, `handle_ping`: Handle the status request (used to get server information) and the ping (used to measure latency). * `handle_login_start`: Handles the login start packet, which contains the player's username. **This is a key integration point for Claude.** 4. **Claude Integration (Placeholders):** * The `handle_login_start` function contains comments indicating where you would integrate with the Claude API. You would: * Send the player's username (and potentially other data) to Claude. * Receive a response from Claude. * Use Claude's response to customize the player's experience (e.g., generate a welcome message, modify the world, etc.). * The `handle_client` function also has a placeholder for Claude integration during the "play" state, where you could analyze player actions and generate dynamic game events. 5. **Threading:** Each client connection is handled in a separate thread, allowing the server to handle multiple clients concurrently. 6. **Error Handling:** Includes basic `try...except` blocks to catch potential errors. 7. **Simplified Protocol:** This example only implements a very small subset of the Minecraft protocol. It's enough to get a basic connection and login working, but it doesn't handle the full game logic. **To use this code:** 1. **Install Python:** Make sure you have Python 3 installed. 2. **Install Anthropic's Python SDK (if using Claude):** ```bash pip install anthropic ``` 3. **Replace Placeholders:** Replace the Claude integration placeholders with your actual Claude API calls. You'll need to set up an Anthropic API key. 4. **Run the Server:** Run the Python script. 5. **Connect with a Minecraft Client:** You'll need to use a Minecraft client that supports the protocol version you're targeting. You might need to modify the client or use a proxy to connect to this simplified server. **This is the tricky part, as the protocol is complex.** **Chinese Translation of Key Concepts:** * **Minecraft Protocol:** Minecraft 协议 (Minecraft Xiéyì) * **Server:** 服务器 (Fúwùqì) * **Client:** 客户端 (Kèhùduān) * **Packet:** 数据包 (Shùjùbāo) * **Handshake:** 握手 (Wòshǒu) * **Status:** 状态 (Zhuàngtài) * **Login:** 登录 (Dēnglù) * **VarInt:** 变长整数 (Biàn cháng zhěngshù) * **Socket:** 套接字 (Tàojiēzì) * **Thread:** 线程 (Xiànchéng) * **Claude Integration:** Claude 集成 (Claude Jíchéng) * **Protocol Version:** 协议版本 (Xiéyì Bǎnběn) * **Username:** 用户名 (Yònghùmíng) * **UUID:** 通用唯一识别码 (Tōngyòng Wéiyī Shìbiémǎ) **Example Chinese Comments for the Code:** ```python # --- Minecraft 协议助手函数 --- (Minecraft Protocol Helper Functions) def read_varint(sock): """从套接字读取 Minecraft 变长整数。""" # Reads a Minecraft VarInt from the socket. # ... def handle_login_start(sock): """处理登录开始数据包（用户名）。""" # Handles the login start packet (username). username = read_string(sock) print(f"登录开始: 用户名 {username}") # Login Start: Username {username} # --- Claude 集成点 --- (Claude Integration Point) # 在这里，你可以将用户名（以及其他数据）发送给 Claude。 # Claude 可以生成一个响应，例如欢迎消息、自定义世界种子， # 甚至修改玩家的起始物品栏。 # ... ``` This provides a starting point. Building a fully functional Minecraft server is a significant undertaking, but this example gives you a basic framework and highlights the areas where you can integrate Claude to add AI-powered features to your Minecraft world. Remember to consult the Minecraft protocol documentation for the specific version you are targeting. Good luck!

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.

Anki MCP Server

镜子 (jìng zi)

HacknPlan MCP

Enables Claude to manage game development projects on HacknPlan, including tasks, boards, milestones, and GDD documents through natural language.

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.

agenticpay

agenticpay lets MCP server developers monetize tools via per-call USDC micropayments on Solana, using the x402 protocol. Each tool declares a price; agents pay via signed Solana transactions; settlement happens on-chain in ~1.5–2 seconds.

Remote MCP Server

A server implementation of the Model Context Protocol (MCP) that runs on Cloudflare Workers, enabling AI assistants like Claude to securely access external tools and APIs through OAuth authentication.

KiotViet MCP Server

Enables AI assistants to manage KiotViet retail and F\&B operations including products, orders, customers, invoices, and inventory through the Public API. Features 36 integrated tools with automatic token refresh, middleware chain support, and configurable presets for different access levels.

yfinance-mcp

MCP server wrapping yfinance to provide stock market data, financials, and analytics via 24 tools.

MCP Server

MCP 服务器 (MCP fúwùqì)

OSC MCP Server

Enables control of digital mixers (Behringer X32, Midas M32) through natural language commands in Claude Desktop, supporting fader control, muting, EQ, dynamics, effects, scenes, routing, and more via OSC protocol.

Leantime MCP Bridge

A robust proxy bridge that connects MCP clients to the Leantime project management system, enabling seamless interaction with projects and tasks. It supports multiple authentication methods and implements the official MCP SDK for reliable protocol handling.

Synchronity

Enables AI assistants to search, compare, and buy products across connected WooCommerce stores with human-in-the-loop approval.

yoto-mcp-server

Enables audio uploads and MYO card creation for Yoto players directly from the terminal, using OAuth authentication and Warp AI integration.

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.

Find Flights MCP Server

Enables searching and retrieving flight information using Duffel API, supporting one-way, round-trip, and multi-city queries with flexible search parameters.