Discover Awesome MCP Servers

MCP Crypto Market Data Server

Provides real-time and historical cryptocurrency market data from major exchanges through CCXT. Supports live price lookups, historical OHLCV queries, and includes lightweight caching for improved performance.

Puppeteer MCP Server

Enables AI agents to automate browser interactions including navigation, content extraction, form filling, screenshots, and JavaScript execution across multiple tabs using Puppeteer.

Playwright MCP Server

Enables web browser automation through Playwright, providing tools for navigation, element interaction, screenshot capture, and accessibility snapshots. Uses streamableHttp transport for seamless integration with MCP clients.

Interactive Voice MCP Server

Enables voice-based interactions with Claude by converting text to speech using Kokoro TTS and transcribing user responses using NVIDIA NeMo ASR, creating interactive voice dialogues.

Autotask MCP Server

A Model Context Protocol server that enables natural language querying of Kaseya's Autotask PSA data through AI assistants, supporting contract analysis, ticket tracking, agent activities, and project status monitoring.

Sitecore Send

Unofficial Sitecore Send MCP Server.

Warden Magento MCP Server

A Model Context Protocol server that enables AI assistants to interact directly with Warden-managed Magento 2 development environments, automating common tasks like project initialization, environment management, database operations, and Magento CLI commands.

Soccer V3 Scores MCP Server

An MCP server that enables agents to interact with soccer data including scores, matches, players, and teams using the sportsdata.io Soccer V3 Scores API.

gh-mcp

Refined MCP server for GitHub GraphQL API. GitHub's official MCP Server exposes dozens of low-level tools that bloat token usage and are mostly impractical for LLMs. gh-mcp achieves the best of both worlds by providing a single, powerful interface: GitHub GraphQL, wrapped with smart abstractions.

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.

Perplexity Ask MCP Server

Integrates the Sonar API to provide Claude with real-time web-wide research capabilities. Enables conversational web searches through Perplexity's AI-powered search engine for up-to-date information retrieval.

mcp-label-studio: A Label Studio MCP server

Here are a few ways to translate "mcp server for label studio" into Spanish, depending on the context: * **Servidor MCP para Label Studio:** This is a direct translation and is generally understood. It's suitable if you're talking about a specific server named "MCP." * **Servidor MCP para usar con Label Studio:** This adds a bit more clarity, specifying that the server is intended for use with Label Studio. * **Servidor MCP para el uso con Label Studio:** Similar to the previous option, but using "el uso" (the use) for a slightly more formal tone. * **Servidor MCP para Label Studio:** This is the most concise and common translation. The best option depends on the specific context and your audience. If "MCP" is a well-known term in your context, the first option is fine. If you need to be more explicit, the second or third options are better.

nf-core MCP Server

Permite a los usuarios gestionar y navegar repositorios de pipelines bioinformáticos de nf-core, permitiendo operaciones de listar, buscar y explorar en configuraciones de pipelines, flujos de trabajo y módulos.

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.

Pipedream MCP Server

Enables interaction with over 2,800 APIs and applications through Pipedream's Connect platform. Provides managed OAuth authentication and API request capabilities for integrating multiple services through natural language.

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.

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.

MCP Server with OpenAI Integration

Production-ready MCP server that integrates OpenAI API with extensible tool support, enabling dynamic plugin loading and knowledge search capabilities through multiple interfaces including CLI and browser UI.

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.

KubeBlocks Cloud MCP Server

MCP server for KubeBlocks Cloud

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

Stimulus Docs MCP Server

An MCP server that provides access to up-to-date Stimulus JS documentation directly within Claude conversations and VS Code.

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.

MCP 学习项目⚡

The most accurate and natural-sounding translation of "个人学习MCP" depends on the context. Here are a few options, with explanations: * **Estudio individual para la certificación MCP:** This is a very literal translation and is generally a good option. It emphasizes the individual nature of the study and the goal of achieving MCP certification. * **Autoestudio para la certificación MCP:** "Autoestudio" is a more concise and common way to say "self-study" in Spanish. * **Preparación individual para el MCP:** This focuses on the preparation aspect, implying the person is getting ready for the MCP exam. * **Estudio por mi cuenta para el MCP:** This emphasizes that the person is studying independently, "on their own." **Recommendation:** I would recommend **Autoestudio para la certificación MCP** or **Estudio individual para la certificación MCP** as the most common and clear translations. Therefore, the best translation is: **Autoestudio para la certificación MCP**

context-portal

context-portal

🎯 Kubernetes AI Management System

Sistema de gestión de Kubernetes impulsado por IA: Una plataforma que combina el procesamiento del lenguaje natural con la gestión de Kubernetes. Los usuarios pueden realizar diagnósticos en tiempo real, monitorización de recursos y análisis inteligente de registros. Simplifica la gestión de Kubernetes a través de la IA conversacional, proporcionando una alternativa moderna.

arduino-mcp-server

Un servidor MCP de Arduino escrito en 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.

Security Infrastructure MCP Server

A comprehensive implementation of Model Context Protocol servers enabling natural language interactions with security platforms including Splunk SIEM, CrowdStrike EDR, and Microsoft MISP for threat intelligence querying and analysis.

Math Agent with Microsoft Word and Gmail Integration

Here are a few ways to translate "MCP server for Math Agent with Microsoft Word and Gmail Integration" into Spanish, depending on the nuance you want to convey: **Option 1 (Most Literal and General):** * **Servidor MCP para Agente Matemático con Integración de Microsoft Word y Gmail.** * This is the most direct translation and is suitable for most technical contexts. **Option 2 (Slightly More Natural Flow):** * **Servidor MCP para un Agente Matemático con Integración en Microsoft Word y Gmail.** * Adding "un" (a/an) before "Agente Matemático" can make it sound slightly more natural in Spanish. **Option 3 (Emphasizing Functionality):** * **Servidor MCP para un Agente Matemático integrado con Microsoft Word y Gmail.** * Using "integrado con" (integrated with) emphasizes the functionality of the integration. **Explanation of Terms:** * **MCP Server:** "Servidor MCP" remains the same. MCP is likely an acronym and should be kept as is unless you know the full Spanish equivalent. * **Math Agent:** "Agente Matemático" is a direct and accurate translation. * **Microsoft Word:** "Microsoft Word" remains the same, as it's a proper noun. * **Gmail:** "Gmail" remains the same, as it's a proper noun. * **Integration:** "Integración" is the standard translation. * **with:** "con" is the standard translation. "en" can also be used to mean "in" or "on" in the context of integration. **Recommendation:** I recommend using **Option 1: Servidor MCP para Agente Matemático con Integración de Microsoft Word y Gmail.** It's clear, concise, and technically accurate. If you want to emphasize the integration, **Option 3** is a good alternative.