Discover Awesome MCP Servers

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.

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.

R2R FastMCP Server

Integrates R2R (Retrieval-Augmented Generation) with Claude Desktop, enabling semantic search across knowledge bases and RAG-based question answering with support for vector, graph, web, and document search.

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.

@cloud9-labs/mcp-github

MCP (Model Context Protocol) server for GitHub API integration. This server provides comprehensive tools for interacting with GitHub repositories, issues, pull requests, branches, and code search through a unified interface.

velora-mcp-copilote

Enables AI agents to assist sales advisors of the fictional e-commerce Velora by providing tools to search products, check stock, get order status, and handle returns.

Zhipu AI Image Generator MCP Server

Enables text-to-image generation using Zhipu AI's CogView4 model with support for multiple image sizes (1024x1024, 768x768, 576x1024) and automatic local saving of generated images.

grazer-mcp

Multi-platform content discovery for AI agents over MCP — graze worthy content across BoTTube and an extensible set of sources.

unitypilot

MCP server that lets AI agents drive the full Unity lifecycle on macOS without opening the Unity Editor.

yoto-mcp-server

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

Apple Health MCP

Local-first MCP server that reads Apple Health export files (export.xml/zip) and exposes activity, sleep, HRV, and workout data to AI agents, keeping all data on your machine.

mcp-opencode-blender

Enables programmatic control of Blender via OpenCode, supporting 3D model creation, material application, and export through a Model Context Protocol server.

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.

Synchronity

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

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.

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

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.

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.

database-remote-mcp

Enables remote database access (RDBMS and MongoDB) through MCP tools, supporting read/write queries, schema management, and more.

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.

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.

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.

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.