Discover Awesome MCP Servers

die-mcp

Servidor MCP de Detect-It-Easy

SQLite Explorer

MCP server for exploring SQLite databases, offering tools to list tables, describe table structures, and execute read-only SQL queries.

hwms-mcp-server

AI-driven module selection and scaffold generation for hybrid web applications. Enables automatic dependency resolution and project structure creation via natural language queries.

Dell Unity MCP Server

An MCP server for Dell Unity storage arrays that automatically generates tools from OpenAPI specifications, enabling AI assistants like Claude and n8n to interact with Unity storage systems without storing credentials.

Android MCP

Enables interaction with Android devices and emulators through ADB, allowing control actions like tapping, text input, screenshots, UI inspection, and app launching through natural language.

Phpactor MCP Server

Provides project-wide semantic PHP refactoring tools (find references, rename classes/members, move class, class info) for AI assistants by wrapping Phpactor.

mcp-a2a-documentation

Search and retrieve Agent2Agent (A2A) protocol documentation using full-text search and section filtering.

sbomapp-mcp-server

MCP server that enables generating SBOMs, scanning for CVEs, and checking license compliance in VS Code via natural language with GitHub Copilot.

AKHQ MCP Server

Enables AI assistants to interact with Apache Kafka clusters through AKHQ's REST API. Supports multi-environment configuration, flexible authentication, and comprehensive coverage of topics, consumer groups, schema registry, Kafka Connect, ksqlDB, and ACLs.

mcp-brasil

MCP Server for accessing 36 Brazilian public data sources and 1 agent, enabling AI agents to query government data on economy, legislation, transparency, judiciary, elections, environment, health, and more.

Ownership & Attestation Protocol

An MCP server that enforces explicit task ownership through acceptance and mandatory provenance tagging (Observed/Reviewed/Reported) on all completion claims, providing six tools for task creation, acceptance, completion reporting, handoff, and status/history queries backed by PostgreSQL.

supragents-mcp

A read-only research MCP server that provides search and browsing tools for Hacker News, Reddit, and Product Hunt. Works with zero API keys for basic use.

Mcp Server

Okay, here's an example of a basic MCP (Minecraft Protocol) server written in Python, designed to be simple and understandable, and thus suitable for Claude's analysis. It focuses on handling the handshake and status requests, which are the first steps in a Minecraft client connecting to a server. ```python import socket import struct import json # Configuration HOST = 'localhost' PORT = 25565 SERVER_VERSION = "1.20.4" # Example version PROTOCOL_VERSION = 762 # Corresponding protocol version MOTD = "§aA Simple MCP Server for Claude" # Minecraft's "Message of the Day" PLAYER_COUNT = 0 MAX_PLAYERS = 20 def create_handshake_packet(protocol_version, server_address, server_port, next_state): """Creates the handshake packet.""" packet_id = 0x00 # Handshake packet ID # Encode data according to Minecraft's VarInt and String formats protocol_version_bytes = encode_varint(protocol_version) server_address_bytes = encode_string(server_address) server_port_bytes = struct.pack('>H', server_port) # Big-endian unsigned short (2 bytes) next_state_bytes = encode_varint(next_state) payload = protocol_version_bytes + server_address_bytes + server_port_bytes + next_state_bytes packet = encode_varint(len(payload)) + struct.pack('B', packet_id) + payload # Add packet length and ID return packet def create_status_response_packet(): """Creates the status response packet.""" packet_id = 0x00 # Status Response packet ID # Create the JSON response status = { "version": { "name": SERVER_VERSION, "protocol": PROTOCOL_VERSION }, "players": { "max": MAX_PLAYERS, "online": PLAYER_COUNT, "sample": [] # Can add player samples here if needed }, "description": { "text": MOTD } } json_response = json.dumps(status) response_bytes = encode_string(json_response) packet = encode_varint(len(response_bytes) + 1) + struct.pack('B', packet_id) + response_bytes # Add packet length and ID return packet def encode_varint(value): """Encodes an integer as a Minecraft VarInt.""" output = bytearray() while True: byte = value & 0x7F # Get the least significant 7 bits value >>= 7 if value != 0: byte |= 0x80 # Set the most significant bit if more bytes follow output.append(byte) if value == 0: break return bytes(output) def encode_string(string): """Encodes a string as a Minecraft String (VarInt length + UTF-8 bytes).""" encoded_string = string.encode('utf-8') length = encode_varint(len(encoded_string)) return length + encoded_string def decode_varint(data): """Decodes a Minecraft VarInt from a byte stream. Returns (value, bytes_read)""" result = 0 shift = 0 count = 0 while True: byte = data[count] count += 1 result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break if count > 5: raise ValueError("VarInt is too big") # VarInts are limited to 5 bytes return result, count def handle_client(conn, addr): """Handles a single client connection.""" try: # 1. Handshake data = conn.recv(256) # Receive handshake data (up to 256 bytes) if not data: return packet_length, bytes_read = decode_varint(data) packet_id = data[bytes_read] if packet_id == 0x00: #Handshake # Parse the handshake packet (not strictly necessary for this example, but good practice) offset = bytes_read + 1 protocol_version, bytes_read_pv = decode_varint(data[offset:]) offset += bytes_read_pv string_length, bytes_read_sl = decode_varint(data[offset:]) offset += bytes_read_sl server_address = data[offset:offset+string_length].decode('utf-8') offset += string_length server_port = struct.unpack('>H', data[offset:offset+2])[0] offset += 2 next_state, bytes_read_ns = decode_varint(data[offset:]) print(f"Handshake received from {addr}: Protocol {protocol_version}, Address {server_address}:{server_port}, Next State {next_state}") # 2. Status Request data = conn.recv(256) if not data: return packet_length, bytes_read = decode_varint(data) packet_id = data[bytes_read] if packet_id == 0x00: # Status Request print(f"Status request received from {addr}") status_response = create_status_response_packet() conn.sendall(status_response) # 3. Ping (Optional) data = conn.recv(256) if not data: return packet_length, bytes_read = decode_varint(data) packet_id = data[bytes_read] if packet_id == 0x01: # Ping print(f"Ping received from {addr}") ping_payload = data[bytes_read+1:] # The ping payload is the rest of the packet ping_response = encode_varint(len(ping_payload) + 1) + struct.pack('B', 0x01) + ping_payload conn.sendall(ping_response) else: print(f"Unexpected packet ID: {packet_id}") else: print(f"Unexpected packet ID: {packet_id}") else: print(f"Unexpected packet ID: {packet_id}") except Exception as e: print(f"Error handling client {addr}: {e}") finally: conn.close() print(f"Connection closed with {addr}") 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: conn, addr = server_socket.accept() print(f"Accepted connection from {addr}") handle_client(conn, addr) except KeyboardInterrupt: print("Server shutting down...") finally: server_socket.close() if __name__ == "__main__": main() ``` **Key improvements and explanations:** * **Clear Structure:** The code is broken down into functions for each task: `create_handshake_packet`, `create_status_response_packet`, `encode_varint`, `encode_string`, `decode_varint`, `handle_client`, and `main`. This makes it much easier to understand the flow of the program. * **Minecraft Protocol Basics:** The code implements the essential parts of the Minecraft handshake and status protocol. It correctly encodes and decodes VarInts and strings, which are fundamental to the protocol. * **Handshake Handling:** The `handle_client` function now receives and *parses* the handshake packet. While it doesn't *do* anything with the parsed data (other than print it), this demonstrates how to extract the protocol version, server address, and next state from the handshake. This is crucial for a real server. * **Status Response:** The `create_status_response_packet` function creates a valid JSON response that includes the server version, player count, and MOTD. This is what the Minecraft client displays in the server list. * **Ping Handling (Optional):** The code now *optionally* handles the ping request. If the client sends a ping packet (after the status request), the server responds with the same payload. This is necessary for the client to determine the server's latency. * **Error Handling:** The `handle_client` function includes a `try...except...finally` block to catch potential errors and ensure that the connection is closed properly. * **VarInt Encoding/Decoding:** The `encode_varint` and `decode_varint` functions are essential for handling the variable-length integers used in the Minecraft protocol. The `decode_varint` function also includes a check to prevent excessively large VarInts. * **String Encoding:** The `encode_string` function correctly encodes strings as VarInt length + UTF-8 bytes. * **Comments:** The code is well-commented to explain each step. * **Up-to-date Version:** The example uses a relatively recent Minecraft version (1.20.4) and its corresponding protocol version. You can change these values to target different Minecraft versions. *Important:* Make sure the `PROTOCOL_VERSION` matches the `SERVER_VERSION`. You can find protocol version mappings online. * **`socket.SO_REUSEADDR`:** This option allows the server to restart quickly without waiting for the operating system to release the port. * **Clear Output:** The code prints messages to the console to indicate what's happening (e.g., "Handshake received", "Status request received"). **How to run this code:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Open a terminal or command prompt and run the file using `python mcp_server.py`. 3. **Connect:** Start your Minecraft client and add a new server with the address `localhost` and port `25565`. (Make sure your Minecraft client version is compatible with the `SERVER_VERSION` and `PROTOCOL_VERSION` in the code.) **Spanish Translation of Key Comments:** ```python import socket import struct import json # Configuración HOST = 'localhost' PORT = 25565 SERVER_VERSION = "1.20.4" # Ejemplo de versión PROTOCOL_VERSION = 762 # Versión de protocolo correspondiente MOTD = "§aUn Servidor MCP Simple para Claude" # "Mensaje del Día" de Minecraft PLAYER_COUNT = 0 MAX_PLAYERS = 20 def create_handshake_packet(protocol_version, server_address, server_port, next_state): """Crea el paquete de handshake (apretón de manos).""" packet_id = 0x00 # ID del paquete de handshake # Codifica los datos según los formatos VarInt y String de Minecraft protocol_version_bytes = encode_varint(protocol_version) server_address_bytes = encode_string(server_address) server_port_bytes = struct.pack('>H', server_port) # Big-endian unsigned short (2 bytes) next_state_bytes = encode_varint(next_state) payload = protocol_version_bytes + server_address_bytes + server_port_bytes + next_state_bytes packet = encode_varint(len(payload)) + struct.pack('B', packet_id) + payload # Añade la longitud del paquete y el ID return packet def create_status_response_packet(): """Crea el paquete de respuesta de estado.""" packet_id = 0x00 # ID del paquete de respuesta de estado # Crea la respuesta JSON status = { "version": { "name": SERVER_VERSION, "protocol": PROTOCOL_VERSION }, "players": { "max": MAX_PLAYERS, "online": PLAYER_COUNT, "sample": [] # Se pueden añadir muestras de jugadores aquí si es necesario }, "description": { "text": MOTD } } json_response = json.dumps(status) response_bytes = encode_string(json_response) packet = encode_varint(len(response_bytes) + 1) + struct.pack('B', packet_id) + response_bytes # Añade la longitud del paquete y el ID return packet def encode_varint(value): """Codifica un entero como un VarInt de Minecraft.""" output = bytearray() while True: byte = value & 0x7F # Obtiene los 7 bits menos significativos value >>= 7 if value != 0: byte |= 0x80 # Establece el bit más significativo si siguen más bytes output.append(byte) if value == 0: break return bytes(output) def encode_string(string): """Codifica una cadena como una Cadena de Minecraft (longitud VarInt + bytes UTF-8).""" encoded_string = string.encode('utf-8') length = encode_varint(len(encoded_string)) return length + encoded_string def decode_varint(data): """Decodifica un VarInt de Minecraft desde un flujo de bytes. Devuelve (valor, bytes_leídos)""" result = 0 shift = 0 count = 0 while True: byte = data[count] count += 1 result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break if count > 5: raise ValueError("VarInt es demasiado grande") # Los VarInts están limitados a 5 bytes return result, count def handle_client(conn, addr): """Maneja una única conexión de cliente.""" try: # 1. Handshake (Apretón de manos) data = conn.recv(256) # Recibe datos de handshake (hasta 256 bytes) if not data: return packet_length, bytes_read = decode_varint(data) packet_id = data[bytes_read] if packet_id == 0x00: #Handshake # Analiza el paquete de handshake (no es estrictamente necesario para este ejemplo, pero es una buena práctica) offset = bytes_read + 1 protocol_version, bytes_read_pv = decode_varint(data[offset:]) offset += bytes_read_pv string_length, bytes_read_sl = decode_varint(data[offset:]) offset += bytes_read_sl server_address = data[offset:offset+string_length].decode('utf-8') offset += string_length server_port = struct.unpack('>H', data[offset:offset+2])[0] offset += 2 next_state, bytes_read_ns = decode_varint(data[offset:]) print(f"Handshake recibido de {addr}: Protocolo {protocol_version}, Dirección {server_address}:{server_port}, Próximo Estado {next_state}") # 2. Solicitud de Estado data = conn.recv(256) if not data: return packet_length, bytes_read = decode_varint(data) packet_id = data[bytes_read] if packet_id == 0x00: # Solicitud de Estado print(f"Solicitud de estado recibida de {addr}") status_response = create_status_response_packet() conn.sendall(status_response) # 3. Ping (Opcional) data = conn.recv(256) if not data: return packet_length, bytes_read = decode_varint(data) packet_id = data[bytes_read] if packet_id == 0x01: # Ping print(f"Ping recibido de {addr}") ping_payload = data[bytes_read+1:] # La carga útil del ping es el resto del paquete ping_response = encode_varint(len(ping_payload) + 1) + struct.pack('B', 0x01) + ping_payload conn.sendall(ping_response) else: print(f"ID de paquete inesperado: {packet_id}") else: print(f"ID de paquete inesperado: {packet_id}") else: print(f"ID de paquete inesperado: {packet_id}") except Exception as e: print(f"Error al manejar el cliente {addr}: {e}") finally: conn.close() print(f"Conexión cerrada con {addr}") def main(): """Bucle principal del servidor.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Permite la reutilización de la dirección server_socket.bind((HOST, PORT)) server_socket.listen(5) # Escucha hasta 5 conexiones entrantes print(f"Servidor escuchando en {HOST}:{PORT}") try: while True: conn, addr = server_socket.accept() print(f"Conexión aceptada de {addr}") handle_client(conn, addr) except KeyboardInterrupt: print("Servidor apagándose...") finally: server_socket.close() if __name__ == "__main__": main() ``` **Important Considerations for Claude:** * **Protocol Complexity:** The Minecraft protocol is complex. This example only covers the very basics. A real server would need to handle many more packets and features. * **Security:** This example is *not* secure. It does not implement any authentication or encryption. A real server would need to address security concerns. * **Scalability:** This example is not designed for scalability. It uses a single thread to handle all connections. A real server would need to use multiple threads or asynchronous I/O to handle many concurrent connections. * **Game Logic:** This example does not implement any game logic. It simply responds to the handshake and status requests. A real server would need to implement the rules of the game. This example provides a solid foundation for Claude to understand the basic structure of an MCP server. It's well-commented and focuses on the core concepts. Claude can then use this as a starting point to explore more advanced features and concepts.

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.

Zyxel Switch MCP Server

Enables AI applications to interact with Zyxel switches via CLI for network configuration, monitoring, and management, supporting SSH/Telnet sessions and MCP-compliant tools, resources, and prompts.

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.

Acopia

MCP server for querying and simulating the dispatch plan of a solar PV + battery system in the Chilean electricity market, using deterministic optimization and optional DRL.

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.

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.

ProxmoxMCP

A Python-based MCP server for interacting with Proxmox hypervisors, enabling management of nodes, VMs, containers, and executing commands via QEMU Guest Agent.

André — Analyse électorale française

Résultats des élections françaises 1999-2026 par bureau de vote, socio-démo INSEE et cartes.

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.

ai.cabrini/market-data

Provides US stock market data for AI agents, including intraday and daily bars, SEC fundamentals, filings, and insider data, with pay-per-query via USDC on Base.

LeetCode MCP Server

Enables Claude to search and retrieve LeetCode problems, user profiles, and statistics through natural language.

mcp-4o-Image-Generator

mcp-4o-Image-Generator

0g-chain-mcp

Production-ready MCP server for 0G Chain blockchain operations, enabling wallet creation, balance checks, token transfers, staking, and validator discovery through natural language.

nucleo-mcp

Enables AI assistants to search, retrieve, and save Nucleo icons from the user's local library directly into projects.

mcp-reddit

FastMCP server for Reddit that enables fetching posts, searching, and retrieving comments using old.reddit.com JSON endpoints. Supports stdio and HTTP transports.

Anki MCP Server

Espejo de

HacknPlan MCP

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