Discover Awesome MCP Servers

Airtable Server

Un servidor de Protocolo de Contexto de Modelo que proporciona acceso de lectura y escritura a bases de datos de Airtable. Este servidor permite a los LLMs inspeccionar los esquemas de la base de datos y, a continuación, leer y escribir registros.

LinkedIn Profile Scraper MCP Server

Servidor MCP que obtiene información de perfiles de LinkedIn utilizando la API Fresh LinkedIn Profile Data, permitiendo a los usuarios recuperar datos de perfiles en formato JSON proporcionando una URL de perfil de LinkedIn.

BoardGameGeek MCP Server

Un servidor MCP que se integra con la API XML de BoardGameGeek, permitiendo a Claude buscar juegos de mesa, obtener detalles de los juegos y acceder a las colecciones de usuarios.

IGN API Carto MCP Server

Access French geographic data from IGN (Institut national de l'information géographique et forestière) including cadastral parcels, agricultural land registry, protected natural areas, urban planning zones, and wine appellations through natural language queries.

AppleScript MCP Server

A Model Context Protocol server that enables running AppleScript code to interact with Mac applications and system features including Notes, Calendar, Contacts, Messages, file management, and more.

FlightRadar MCP Server

Un servidor de Protocolo de Contexto de Modelo (MCP) que proporciona información de seguimiento y estado de vuelos en tiempo real utilizando la API de AviationStack.

Microsoft MCP

A powerful MCP server that enables AI assistants to interact with Microsoft Graph API for managing Outlook emails, Calendar events, OneDrive files, and Contacts through natural language commands.

Niledatabase_nile Mcp Server

Espejo de

curl mcp

A Multi-modal Conversation Protocol (MCP) server that enables interacting with web APIs through a curl-like interface, providing access to various websites and APIs with user authentication and response transformations.

MCP Server für Kerykeion

This template provides a streamlined foundation for building Model Context Protocol (MCP) servers in Python. It's designed to make AI-assisted development of MCP tools easier and more efficient.

Vimeo MCP Server

Provides a Multi-Agent Conversation Protocol server for interfacing with the Vimeo API, allowing agents to interact with Vimeo's video platform services through natural language.

MCPMake

Enables management and execution of Python scripts with automatic LLM-extracted argument schemas and validation. Provides script registry, execution history, and intelligent argument parsing like make but for Python scripts.

Cloud Storage MCP Server

Here are a few ways to translate "MCP Server to interact with Google Cloud Storage" into Spanish, depending on the specific context and desired nuance: **Option 1 (Most straightforward):** * **Servidor MCP para interactuar con Google Cloud Storage** * This is a direct translation and is perfectly understandable. **Option 2 (Emphasizing the connection/integration):** * **Servidor MCP para la interacción con Google Cloud Storage** * This uses "interacción" which emphasizes the process of interaction. **Option 3 (More formal, emphasizing communication):** * **Servidor MCP para comunicarse con Google Cloud Storage** * This uses "comunicarse" which means "to communicate" and might be suitable if the server's primary function is data exchange. **Option 4 (Focusing on access):** * **Servidor MCP para acceder a Google Cloud Storage** * This uses "acceder" which means "to access" and is appropriate if the server's main purpose is to read or write data in Google Cloud Storage. **Option 5 (More descriptive, if the server is acting as an interface):** * **Servidor MCP como interfaz para Google Cloud Storage** * This translates to "MCP Server as an interface for Google Cloud Storage." **Which option is best depends on the specific role of the MCP server.** If you can provide more context about what the server *does* with Google Cloud Storage, I can give you a more precise translation. For example: * Is it uploading files? * Is it downloading files? * Is it managing data within Google Cloud Storage? In most cases, **Option 1 (Servidor MCP para interactuar con Google Cloud Storage)** is a safe and accurate choice.

IBM Cloud Object Storage MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for IBM Cloud Object Storage (beta): https://www.cdata.com/download/download.aspx?sku=GMZK-V&type=beta

Time Tracking MCP

Enables natural language time tracking through Claude with markdown file storage. Supports multi-company tracking, flexible time parsing, auto-calculated summaries, and commitment warnings all through conversational input.

sample-cpp-mcp-servers

Aquí tienes un ejemplo de servidores MCP (Minecraft Protocol) en C++: Debido a la complejidad de implementar un servidor MCP completo en C++, te proporcionaré un ejemplo simplificado que ilustra los conceptos clave. Este ejemplo se centra en la conexión inicial y el handshake. **Ten en cuenta que un servidor MCP real es *mucho* más complejo y requiere un conocimiento profundo del protocolo Minecraft.** ```cpp #include <iostream> #include <asio.hpp> #include <asio/ts/buffer.hpp> #include <asio/ts/internet.hpp> #include <vector> using asio::ip::tcp; // Estructura para representar un paquete MCP (simplificado) struct MCPPacket { int length; int id; std::vector<char> data; }; // Función para leer un paquete MCP desde el socket MCPPacket read_packet(tcp::socket& socket) { MCPPacket packet; // Leer la longitud del paquete (VarInt) unsigned char length_byte; int length = 0; int shift = 0; do { asio::read(socket, asio::buffer(&length_byte, 1)); length |= (length_byte & 0x7F) << shift; shift += 7; } while ((length_byte & 0x80) != 0); packet.length = length; // Leer el ID del paquete (VarInt) unsigned char id_byte; int id = 0; shift = 0; do { asio::read(socket, asio::buffer(&id_byte, 1)); id |= (id_byte & 0x7F) << shift; shift += 7; } while ((id_byte & 0x80) != 0); packet.id = id; // Leer los datos del paquete int data_length = length - (id > 127 ? 2 : 1); // Ajuste para la longitud del VarInt del ID packet.data.resize(data_length); asio::read(socket, asio::buffer(packet.data.data(), data_length)); return packet; } // Función para escribir un paquete MCP al socket void write_packet(tcp::socket& socket, int id, const std::vector<char>& data) { // Calcular la longitud total del paquete int length = data.size() + (id > 127 ? 2 : 1); // Ajuste para la longitud del VarInt del ID // Escribir la longitud (VarInt) std::vector<unsigned char> length_bytes; int remaining_length = length; do { unsigned char byte = remaining_length & 0x7F; remaining_length >>= 7; if (remaining_length != 0) { byte |= 0x80; } length_bytes.push_back(byte); } while (remaining_length != 0); asio::write(socket, asio::buffer(length_bytes.data(), length_bytes.size())); // Escribir el ID (VarInt) std::vector<unsigned char> id_bytes; int remaining_id = id; do { unsigned char byte = remaining_id & 0x7F; remaining_id >>= 7; if (remaining_id != 0) { byte |= 0x80; } id_bytes.push_back(byte); } while (remaining_id != 0); asio::write(socket, asio::buffer(id_bytes.data(), id_bytes.size())); // Escribir los datos asio::write(socket, asio::buffer(data.data(), data.size())); } int main() { try { asio::io_context io_context; tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), 25565)); // Escuchar en el puerto 25565 std::cout << "Servidor MCP escuchando en el puerto 25565..." << std::endl; while (true) { tcp::socket socket(io_context); acceptor.accept(socket); std::cout << "Cliente conectado desde: " << socket.remote_endpoint() << std::endl; try { // 1. Handshake MCPPacket handshake_packet = read_packet(socket); std::cout << "Recibido Handshake: ID = " << handshake_packet.id << ", Longitud = " << handshake_packet.length << std::endl; // Procesar el Handshake (aquí deberías validar la versión del protocolo, etc.) // Por simplicidad, solo imprimimos los datos. std::string handshake_data(handshake_packet.data.begin(), handshake_packet.data.end()); std::cout << "Datos del Handshake: " << handshake_data << std::endl; // 2. Request MCPPacket request_packet = read_packet(socket); std::cout << "Recibido Request: ID = " << request_packet.id << ", Longitud = " << request_packet.length << std::endl; // 3. Response (Simulado) std::string json_response = R"({"version":{"name":"1.20.4","protocol":765},"players":{"max":20,"online":0,"sample":[]},"description":{"text":"Un servidor MCP de ejemplo en C++"}})"; std::vector<char> response_data(json_response.begin(), json_response.end()); write_packet(socket, 0x00, response_data); // ID 0x00 para la respuesta de estado // 4. Ping (Opcional) MCPPacket ping_packet = read_packet(socket); std::cout << "Recibido Ping: ID = " << ping_packet.id << ", Longitud = " << ping_packet.length << std::endl; // 5. Pong (Simulado) write_packet(socket, 0x01, ping_packet.data); // ID 0x01 para el Pong (devolver los mismos datos del Ping) } catch (std::exception& e) { std::cerr << "Excepción en la conexión: " << e.what() << std::endl; } std::cout << "Cliente desconectado." << std::endl; socket.close(); } } catch (std::exception& e) { std::cerr << "Excepción: " << e.what() << std::endl; } return 0; } ``` **Explicación del código:** 1. **Incluir Cabeceras:** Incluye las cabeceras necesarias de Asio para la red y las cabeceras estándar de C++. 2. **Estructura `MCPPacket`:** Define una estructura simple para representar un paquete MCP. Contiene la longitud, el ID y los datos. 3. **Función `read_packet`:** Lee un paquete MCP desde el socket. Esto incluye leer la longitud (como un VarInt), el ID (como un VarInt) y los datos. **Importante:** El protocolo Minecraft usa VarInts para representar números de longitud variable. Esta función maneja la lectura de VarInts. 4. **Función `write_packet`:** Escribe un paquete MCP al socket. Esto incluye escribir la longitud (como un VarInt), el ID (como un VarInt) y los datos. 5. **`main` Función:** * Crea un `io_context` de Asio y un `tcp::acceptor` para escuchar conexiones en el puerto 25565. * Entra en un bucle infinito para aceptar conexiones entrantes. * Para cada conexión: * Lee el paquete de Handshake. * Lee el paquete de Request. * Envía una respuesta simulada (un JSON simple con información del servidor). * Lee el paquete de Ping (opcional). * Envía un Pong (devolviendo los mismos datos del Ping). * Cierra el socket. 6. **Manejo de Excepciones:** El código incluye bloques `try...catch` para manejar excepciones que puedan ocurrir durante la comunicación. **Cómo compilar y ejecutar:** 1. **Instalar Asio:** Asegúrate de tener instalada la biblioteca Asio. La forma de instalarla depende de tu sistema operativo y gestor de paquetes. Por ejemplo, en Debian/Ubuntu: `sudo apt-get install libasio-dev` 2. **Compilar:** Usa un compilador de C++ (como g++) para compilar el código: ```bash g++ -std=c++17 -o mcpserver mcpserver.cpp -lasio -pthread ``` * `-std=c++17`: Especifica el estándar C++17 (o superior). * `-o mcpserver`: Especifica el nombre del archivo ejecutable de salida. * `mcpserver.cpp`: El nombre del archivo fuente. * `-lasio`: Enlaza la biblioteca Asio. * `-pthread`: Enlaza la biblioteca pthreads (necesaria para Asio en algunos sistemas). 3. **Ejecutar:** Ejecuta el archivo ejecutable: ```bash ./mcpserver ``` **Cómo probar:** 1. **Minecraft Client:** Abre el cliente de Minecraft. 2. **Añadir Servidor:** Añade un nuevo servidor con la dirección `localhost` y el puerto `25565`. 3. **Refrescar:** Refresca la lista de servidores. Deberías ver el servidor de ejemplo con la información que has configurado en el JSON. 4. **Unirse:** **No podrás unirte al servidor.** Este ejemplo solo implementa el handshake y la respuesta de estado. Para permitir que los jugadores se unan, necesitas implementar el resto del protocolo Minecraft, que es significativamente más complejo. **Limitaciones y Próximos Pasos:** * **Incompleto:** Este es un ejemplo *muy* básico. No implementa todas las características de un servidor Minecraft real. * **Falta Autenticación:** No hay autenticación de jugadores. * **No hay Mundo:** No hay generación de mundo ni manejo de entidades. * **No hay Chat:** No hay soporte para chat. * **Complejidad del Protocolo:** El protocolo Minecraft es binario y complejo. Necesitarás una comprensión profunda del protocolo para implementar un servidor completo. **Para construir un servidor Minecraft completo en C++, necesitarás:** * **Estudiar el Protocolo Minecraft:** Consulta la documentación oficial del protocolo Minecraft (si existe) o recursos de la comunidad como el wiki de Minecraft. * **Implementar el Protocolo Completo:** Implementa todos los paquetes y estados del protocolo. * **Generación de Mundo:** Implementa un sistema de generación de mundo. * **Manejo de Entidades:** Implementa el manejo de entidades (jugadores, mobs, objetos). * **Multithreading:** Utiliza multithreading para manejar múltiples conexiones de jugadores simultáneamente. * **Base de Datos:** Considera usar una base de datos para almacenar información del mundo y de los jugadores. **Alternativas:** * **Minetest:** Considera usar Minetest, que es un motor de juegos de código abierto similar a Minecraft, pero más simple y con una API más accesible. Puedes escribir mods y servidores en Lua. * **Bibliotecas Existentes:** Busca bibliotecas de C++ que ya implementen partes del protocolo Minecraft. Sin embargo, ten en cuenta que muchas de estas bibliotecas pueden estar desactualizadas o incompletas. Este ejemplo te da un punto de partida. Construir un servidor Minecraft completo es un proyecto grande y desafiante. ¡Buena suerte!

MCP Weather Server

A Model Context Protocol server that provides real-time weather data and forecasts for any city.

MCP CheatEngine Toolkit

Conjunto de herramientas basado en Python que se comunica con Cheat Engine a través de la interfaz MCP, lo que permite la lectura de memoria y el análisis de código ensamblador.

Informix MCP Server

Enables interaction with Informix databases through a Model Context Protocol server, supporting database exploration, table inspection, and custom SQL query execution.

YNAB MCP Server

Enables AI assistants to help manage your You Need A Budget (YNAB) finances through comprehensive budget operations. Supports account management, transaction handling, category budgeting, split transactions, scheduled payments, and spending analytics with robust error handling and automatic retry logic.

Cloud Tasks MCP Server

Permite interactuar con las colas y tareas de Google Cloud Tasks a través del lenguaje natural, lo que permite a los usuarios listar, administrar, pausar/reanudar colas y gestionar tareas a través de Claude Desktop.

Databricks MCP Server Template

Enables AI assistants like Claude to interact with Databricks workspaces through secure OAuth authentication. Supports custom prompts, tools for workspace management, and SQL query execution via a deployable MCP server on Databricks Apps.

Memory Cache Server

Un servidor de Protocolo de Contexto de Modelo que reduce el consumo de tokens al almacenar en caché de manera eficiente los datos entre interacciones del modelo de lenguaje, guardando y recuperando automáticamente la información para minimizar el uso redundante de tokens.

MCP Weather Server

A Model Context Protocol server that provides real-time weather information and 5-day forecasts to AI assistants, supporting multiple languages and flexible units.

Supabase MCP Lite

Enables minimal interaction with Supabase databases through 4 essential tools for data querying, mutations, file storage, and user authentication. Designed for 70% less context usage than standard implementations with auto-truncated results and simplified parameters.

Dune API MCP Server

Allows LLM agents and MCP clients to analyze blockchain data including wallet balances, token information, and transaction history across EVM and Solana chains through the Dune API.