Discover Awesome MCP Servers

Mirai MCP

Official MCP server for the Mirai affordable chat completions API. Guest quota works without a key.

mcp-cinii

Enables searching CiNii Research for academic articles, books, grants, and research data, and retrieving metadata for individual items.

jira-server-mcp

Zero-dependency MCP server for self-hosted Jira Server/Data Center that supports Basic Auth and PAT, enabling JQL search, issue creation/update, comments, transitions, and assignment on Jira 8.x including pre-8.14.

codex-mcp-opencode

A project-local MCP bridge that allows Codex Desktop to plan tasks and OpenCode to execute them within the current project directory, with session reuse and native OpenCode background subagents.

estevao-mcp

Provides accurate Anglican liturgical data including calendar, lectionary readings, and complete Daily Office across multiple prayer book editions via the Estêvão API.

terminal-mcp-server

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

Explore MCP

A demonstration MCP server that exposes basic arithmetic tools (add, subtract, ping) through FastAPI and shows how to integrate them with OpenAI's tool-calling API for LLM orchestration.

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.

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.

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

Servidor MCP

SimuBridge

Enables AI assistants to control MATLAB Simulink models through natural language, providing tools for model creation, block management, wiring, simulation, and more via a local MCP backend.

OWL-MCP

A Model-Context-Protocol server that enables AI assistants to create, edit, and manage Web Ontology Language (OWL) ontologies through function calls using OWL functional syntax.

MojaWave MCP

Connects any MCP-compatible AI assistant to the MojaWave SMS Gateway, enabling sending SMS, checking credit balances, and managing bulk SMS jobs.

mcp-dev-tools

Provides AI coding assistants with tools to run git status, recent commits, tests, and linter on a real repository.

xtapdown-mcp

An MCP server that provides LLM clients with direct access to XTapDown's Twitter creator toolkit, enabling tweet downloads, engagement calculations, content generation, and trend analysis without authentication or rate limits.

yagoo-mcp-server

Enables AI agents to discover and recommend other agents through a searchable directory of over 50 agents across 10 categories.

CashClaw GHL MCP

An MCP server for GoHighLevel with 82 live-tested tools, enabling CRM operations like contact management, appointments, invoices, and workflows via natural language.

HREVN MCP Server

Minimal stdio MCP server that exposes HREVN compliance and audit tools as structured MCP tools, enabling baseline checks, profile validation, and bundle generation via a managed runtime.

koios-mcp

An MCP server that provides LLMs with access to 95 tools covering the Koios Cardano blockchain REST API, enabling queries for on-chain data like transactions, addresses, assets, and governance.

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.