Discover Awesome MCP Servers

OpenLink MCP Server for ODBC

Enables LLMs to query ODBC-accessible databases via DSN, supporting SQL, SPARQL, and schema exploration.

mcp-server-duckdb

Enables DuckDB database interaction through MCP, supporting SQL queries, table creation, and schema inspection with optional read-only mode.

mcp-server-3gpp

Enables AI assistants to search and retrieve information from 3GPP specification documents, including full-text search and specific lookup for LTE and 5G NAS cause values. It comes with pre-processed data for major specifications covering NAS, RRC, and protocol conformance testing.

MemoryBase MCP Server

MCP server that logs insights from Claude sessions and sends them via HTTP to a server for Telegram notification and storage in memoryBase.

unitypilot

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

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.

Weather MCP Server

Enables real-time weather queries for 12 major Chinese cities and global cities using the wttr.in API. Provides tools to get weather, list supported cities, and server info.

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.

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.

mcp-ff2026

An MCP server that helps an AI agent run a Sleeper fantasy football team from draft night through the championship. It syncs league data, imports FantasyPros rankings, and recommends draft picks, lineups, waivers, and trades.

MCP Alchemy Server

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

solinkify-mcp

Agentic payments on Solana: an agent can pay x402 / HTTP 402 paywalls in USDC, hold a pre-paid balance or a subscription, and buy datasets or settle store checkouts. All 15 tools run behind fail-closed spending caps ($1 per payment, $10 per day by default), and settlement is non-custodial through a program-owned escrow that releases 99% to the creator.

Vercel MCP Python Server

A serverless MCP server deployed on Vercel that provides basic utility tools including echo, time retrieval, arithmetic operations, and mock weather information. Includes an interactive client application for testing and demonstration purposes.

Spring AI MCP Batch Job Server

Un servidor de Protocolo de Contexto de Modelo (MCP) de Spring Boot que proporciona herramientas de procesamiento por lotes para transacciones financieras.

neptunesoftware-dxp-mcp-inventory-counting

MCP server for SAP Physical Inventory Counting, enabling materials retrieval, stock display, quantity entry, and posting counts to SAP.

mcp-polymarket

Provides access to Polymarket prediction-market data via Gamma and CLOB public APIs, enabling AI agents to query market information.

Firecrawl MCP Server

A Model Context Protocol (MCP) server implementation that integrates with Firecrawl for web scraping capabilities.

Peekaboo MCP

A macOS utility that captures screenshots and analyzes them with AI vision, enabling AI assistants to see and interpret what's on your screen.

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.

yoto-mcp-server

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

agent-locks

A filesystem-based MCP server for AI coding agents to coordinate work across git worktrees by claiming files, checking for conflicts, and logging progress without affecting the repository's git history.

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.

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.

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 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.