Discover Awesome MCP Servers

arduino-mcp-server

Um servidor Arduino MCP escrito em 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.

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.

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

Here's an example of a simple MCP (Minecraft Protocol) server written in Python, designed to be easily understood and potentially adapted for use with Claude. This is a *very* basic example and doesn't implement the full Minecraft protocol. It's intended to illustrate the core concepts of listening for connections and sending/receiving data. ```python import socket import struct import json # Configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 25565 # Standard Minecraft port # --- Minecraft Protocol Helper Functions --- def read_varint(sock): """Reads a variable-length integer from the socket.""" result = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return None # Connection closed byte = ord(byte) result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break return result def write_varint(sock, value): """Writes a variable-length integer to the socket.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 sock.send(struct.pack("B", byte)) if value == 0: break def read_string(sock): """Reads a string from the socket, prefixed by a varint length.""" length = read_varint(sock) if length is None: return None # Connection closed data = sock.recv(length) try: return data.decode('utf-8') except UnicodeDecodeError: return None # Invalid string def write_string(sock, string): """Writes a string to the socket, prefixed by a varint length.""" encoded_string = string.encode('utf-8') write_varint(sock, len(encoded_string)) sock.send(encoded_string) def send_packet(sock, packet_id, data): """Sends a packet with a given ID and data.""" packet = struct.pack(">b", packet_id) + data write_varint(sock, len(packet)) sock.send(packet) # --- Server Logic --- 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 as big-endian unsigned short next_state = read_varint(sock) print(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, State {next_state}") return next_state def handle_status_request(sock): """Handles the status request and sends a response.""" # Receive empty status request packet (ID 0x00) packet_id = read_varint(sock) if packet_id != 0x00: print(f"Unexpected packet ID in status request: {packet_id}") return # Craft a simple status response status = { "version": { "name": "My Claude Server", "protocol": 763 # Example protocol version }, "players": { "max": 20, "online": 0, "sample": [] }, "description": { "text": "A server powered by Claude (sort of)!" } } status_json = json.dumps(status) print(f"Sending status: {status_json}") # Send status response packet (ID 0x00) write_string(sock, status_json) send_packet(sock, 0x00, b"") # Ping response (empty packet) def handle_login_start(sock): """Handles the login start packet (player name).""" player_name = read_string(sock) print(f"Login attempt from: {player_name}") # For simplicity, we'll just accept the connection. In a real server, # you'd handle authentication, UUID generation, etc. # Send Login Success packet (ID 0x02) uuid = "00000000-0000-0000-0000-000000000000" # Dummy UUID send_packet(sock, 0x02, write_string(sock, uuid).encode('utf-8') + write_string(sock, player_name).encode('utf-8')) # Send Join Game packet (ID 0x26) - Minimal data for joining entity_id = 0 gamemode = 1 # Creative dimension = 0 # Overworld hashed_seed = 0 max_players = 20 level_type = "default" reduced_debug_info = False enable_respawn_screen = True join_game_data = struct.pack(">iBbql", entity_id, gamemode, dimension, hashed_seed, max_players) + \ write_string(sock, level_type).encode('utf-8') + \ struct.pack("?b", reduced_debug_info, enable_respawn_screen) send_packet(sock, 0x26, join_game_data) # Send Player Position & Rotation packet (ID 0x36) x, y, z = 0.0, 64.0, 0.0 yaw, pitch = 0.0, 0.0 flags = 0x00 # No flags set teleport_id = 0 position_data = struct.pack(">dddbbi", x, y, z, yaw, pitch, flags, teleport_id) send_packet(sock, 0x36, position_data) # Send Clientbound Plugin Message (ID 0x18) - Required for some clients channel = "minecraft:brand" brand = "vanilla" plugin_message_data = write_string(sock, channel).encode('utf-8') + write_string(sock, brand).encode('utf-8') send_packet(sock, 0x18, plugin_message_data) def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") try: # Handshake next_state = handle_handshake(conn) if next_state == 1: # Status handle_status_request(conn) elif next_state == 2: # Login handle_login_start(conn) # After login, you'd enter the game loop and handle player input. # This example doesn't implement that. else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") # --- Main Server Loop --- with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of the address s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) ``` Key improvements and explanations: * **Clearer Structure:** The code is now organized into functions for each stage of the Minecraft protocol (handshake, status, login). This makes it much easier to understand and extend. * **VarInt Handling:** Correctly implements reading and writing variable-length integers (VarInts), which are crucial for the Minecraft protocol. The `read_varint` function now handles connection closed gracefully. * **String Handling:** Includes functions for reading and writing strings, prefixed by their length as a VarInt. Handles potential `UnicodeDecodeError`. * **Status Response:** Crafts a valid JSON status response that a Minecraft client can understand. Includes version, player count, and description. * **Login Handling:** Handles the `Login Start` packet and sends a `Login Success` packet. **Important:** This is a *very* simplified login. A real server would need to handle authentication and UUID generation. * **Join Game Packet:** Sends a minimal `Join Game` packet, which is necessary for the client to actually enter the game world. Includes entity ID, gamemode, dimension, etc. * **Player Position Packet:** Sends a `Player Position & Rotation` packet to set the player's initial position in the world. * **Clientbound Plugin Message:** Sends a `Clientbound Plugin Message` with the "minecraft:brand" channel. Some clients require this. * **Error Handling:** Includes basic `try...except` blocks to catch potential errors during client handling. * **Comments:** Extensive comments explain each step of the process. * **`SO_REUSEADDR`:** Sets the `SO_REUSEADDR` socket option to allow the server to be restarted quickly without waiting for the port to be released. * **Correct Unpacking:** Uses `struct.unpack(">H", ...)` to correctly unpack the port number from the handshake packet as a big-endian unsigned short. * **UTF-8 Encoding:** Explicitly encodes strings to UTF-8 before sending them. * **Packet Sending Helper:** The `send_packet` function simplifies sending packets by handling the VarInt length prefix. * **Minimal Dependencies:** Only uses the standard `socket`, `struct`, and `json` libraries. * **Connection Closed Handling:** `read_varint` now returns `None` if the connection is closed, allowing the server to handle it gracefully. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Execute the file from your terminal: `python mcp_server.py` 3. **Connect:** In your Minecraft client, add a new server with the address `127.0.0.1` and port `25565`. **Important:** You may need to disable client-side authentication or use a development client that allows connecting to servers without proper authentication. This server *does not* implement authentication. You will likely need to set "online-mode=false" in your client's `server.properties` file (if applicable) or use a cracked/offline client. 4. **Observe:** Watch the server's output in the terminal to see the handshake, status request, and login information. **Important Considerations for Claude Integration:** * **Claude's Role:** Think about what you want Claude to *do* with the Minecraft server. Some possibilities: * **AI-Controlled Entities:** Use Claude to control the behavior of non-player characters (NPCs) in the game. You'd need to extend the server to handle entity movement, AI logic, and communication with Claude. * **World Generation:** Use Claude to generate interesting terrain or structures. You'd need to modify the server to send the appropriate chunk data to the client. * **Chatbot:** Use Claude to create a more intelligent chatbot that can interact with players in the game. You'd need to handle chat messages and send responses back to the client. * **Game Logic:** Use Claude to dynamically adjust game rules or events based on player actions. * **Communication:** You'll need a way for the Python server to communicate with Claude. This could involve: * **API Calls:** The server can make API calls to Claude's API to get responses or instructions. This is the most common approach. * **Message Queues:** Use a message queue (e.g., RabbitMQ, Redis) to asynchronously send data between the server and Claude. * **Shared Memory:** (Less common) Use shared memory to allow the server and Claude to directly access the same data. * **Protocol Complexity:** The Minecraft protocol is complex. This example only implements a small subset of it. You'll likely need to use a more complete Minecraft library or implement more of the protocol yourself to achieve your desired functionality. Consider libraries like `mcproto` or `python-minecraft-protocol`. * **Security:** If you're exposing your server to the internet, be very careful about security. The Minecraft protocol has known vulnerabilities. Implement proper authentication and input validation to prevent attacks. **Example: Claude as a Chatbot (Conceptual)** 1. **Receive Chat Message:** Extend the server to receive chat messages from the client. This involves parsing the appropriate Minecraft packet. 2. **Send to Claude:** Send the chat message to Claude's API. You might include additional context, such as the player's name, location, and current game state. 3. **Receive Response:** Receive a response from Claude. 4. **Send Chat Message:** Send a chat message back to the client (or to all clients) with Claude's response. **Portuguese Translation of Key Concepts:** * **MCP (Minecraft Protocol):** Protocolo Minecraft * **Server:** Servidor * **Client:** Cliente * **Handshake:** Handshake (aperto de mão inicial, negociação) * **Status:** Status (estado) * **Login:** Login (autenticação) * **Packet:** Pacote (dados enviados pela rede) * **VarInt (Variable-length Integer):** Inteiro de Comprimento Variável * **JSON:** JSON (formato de dados) * **API (Application Programming Interface):** API (Interface de Programação de Aplicações) * **Message Queue:** Fila de Mensagens * **Shared Memory:** Memória Compartilhada * **Entity:** Entidade (personagem, objeto no jogo) * **Chunk:** Chunk (pedaço do mundo do Minecraft) * **Authentication:** Autenticação * **UUID (Universally Unique Identifier):** UUID (Identificador Único Universal) This comprehensive example and explanation should give you a solid foundation for building a Minecraft server that integrates with Claude. Remember to start small, test frequently, and focus on one specific goal at a time. 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.

Datadog MCP Server

Enables AI assistants to access full Datadog observability, including log search, APM trace filtering, smart sampling, and cross-correlation between logs, traces, and metrics.

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

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.

Ecommerce AI MCP

Ecommerce AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

Email MCP Server

Enables AI to send, read, search, delete and reply to emails through SMTP or Gmail API, supporting common email services like QQ, 163, Gmail and Outlook with HTML/text formats and attachments.

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.

Anki MCP Server

Espelho de

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.

Shiori MCP Server

Student productivity MCP. Ask Claude what assignments are due, calculate grades needed, summarize notes, review flashcards. Works with Google Classroom and Gemini AI.

Crestron Home MCP Server

Enables LLMs to discover and control Crestron Home automation systems through natural language, including lights, shades, scenes, thermostats, and sensors with multi-language support and fuzzy device name matching.

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.

mcp-kagi-search

Uma implementação de servidor MCP para a API da Kagi usando npx, para que possa ser facilmente executada no n8n.

File Operations MCP Server

Provides tools for common file processing operations including reading files, listing directories, searching across files, getting file info, and counting lines with built-in security features like path traversal protection.

Cocos MCP

Bridge for Cocos Creator 3.8.x enabling code agents to control the editor via 43+ tools for scene manipulation, asset management, UI creation, animation, and more.

Barkme MCP Server

Enables sending iOS push notifications through the Bark service directly from Claude conversations. Supports device aliases, all Bark API parameters, and async delivery.

Katana MCP Server

Integrates ProjectDiscovery's Katana web crawler with Claude Desktop, enabling users to crawl websites, discover endpoints and hidden resources, extract JavaScript files, and perform reconnaissance with customizable depth, scope, and filtering options.

tmux-claude MCP Server

Enables hierarchical orchestration of Claude instances via tmux with a bridge pattern architecture reducing memory usage by 85%.

origin-MCP

Enables AI assistants to control Origin 2025b for scientific plotting via natural language, with support for data import, 52+ chart types, curve fitting, statistics, and export.

Habit Tracker AI MCP

Habit Tracker AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

MCP-Blender

Enables Claude AI to directly interact with and control Blender for rapid, natural language-based 3D modeling. Supports parametric design and relational design through direct Blender integration.

Greenloom CAD MCP Server

Enables automated CAD operations via natural language, supporting both AutoCAD LT on Windows and headless DXF generation on any platform.

gorgias-mcp

Enables AI agents to manage Gorgias support tickets: list open tickets, read conversation history, draft internal notes, send outbound replies (gated), and look up customer history.