Discover Awesome MCP Servers

Super-MCP

Dynamically generates MCP tools from any OData or OpenAPI spec, enabling natural-language queries via SAP AI Core.

cursor-bridge-mcp

Enables any MCP-compatible AI tool to read and leverage Cursor's context files (rules, agents, and skills) with their activation logic, allowing teams to maintain a single source of context across different AI coding assistants.

Feishu/Lark OpenAPI MCP

Enables AI assistants to interact with Feishu/Lark platform through comprehensive OpenAPI integration, supporting message management, document operations, calendar scheduling, group chats, Bitable operations, and more automation scenarios with dual authentication support.

@paypal/mcp

Enables integration with PayPal APIs for managing invoices, payments, disputes, subscriptions, and more through natural language.

telegram-bot-mcp

Lets Claude manage a Telegram channel through the Bot API, including tracking subscriber growth and publishing, editing, pinning, or deleting posts.

Flight Control MCP Server

Provides read-only access to query and retrieve information about devices, fleets, events, and configurations managed by Flight Control through a safe integration layer supporting filtering and selector-based queries.

mcp-playwright-weather-israel

An MCP server that uses Playwright to scrape Israeli weather forecasts from weather2day.co.il by automating a real browser, enabling an LLM to answer questions about current conditions and hourly forecasts for Israeli cities.

Google Sheets MCP Server 📊🤖

Google Sheets Servidor MCP 📊🤖

SmartBear MCP

Provides AI assistants with seamless access to SmartBear's suite of testing and monitoring tools, enabling querying testing data, analyzing performance metrics, and managing test automation through natural language.

chuk-mcp-time

Provides high-accuracy time information by querying multiple NTP servers for consensus time, and comprehensive timezone support using IANA tzdata for conversions, DST handling, and clock drift detection independent of system time.

memory-mcp

Persistent memory for AI agents over the Model Context Protocol (MCP).

Eigenlayer MCP Server

Provides agent-ready access to the Eigenlayer API through MCP, enabling natural language interaction with Eigenlayer protocols.

Todo MCP Server

A minimal todo app MCP server for ChatGPT that exposes tools for managing tasks and provides an interactive HTML widget interface. It demonstrates how to build MCP servers with React-based UIs and includes development OAuth for ChatGPT connector setup.

NBMEcalc MCP

An open-source MCP server for offline, uncertainty-aware practice-exam score conversion across NBME, UWSA, Free 120, AMBOSS, and CMS inputs.

ssh-mcp-server-secured

A secured MCP server for safe remote server management via SSH with command filtering, network device support, and bulk connection management.

MCP-FRED

A comprehensive MCP server providing access to all FRED API endpoints with intelligent large data handling, project-based storage, and async job processing for AI assistants like Claude.

Hyperliquid MCP Server

Enables interaction with the Hyperliquid exchange to trade perpetuals, check positions, and manage risk through natural language. It provides tools for fetching real-time market data, tracking portfolio value, and executing orders with a focus on safety through default paper trading.

nimble-js-mcp

Enables AI assistants to interact with the Nimble REST API, allowing them to explore endpoints, make test requests, and use documentation to help integrate this SDK into your application.

posthog-mcp-server

Connects AI assistants to PostHog to query events, persons, insights, dashboards, feature flags, cohorts, and experiments through the Model Context Protocol.

pokemon-tcg-mcp

An MCP server that gives Claude access to Pokémon TCG card data and competitive meta information, including card search, deck validation, and meta snapshot tools.

CalDAV MCP Server

Enables managing calendars, events, contacts, and todos via a CalDAV server (Radicale) through MCP tools.

TradeLab-MCP

Quantitative research MCP server that lets AI define strategies and uses MetaTrader 5's official Strategy Tester to execute backtests, managing experiments and results via tools like run_backtest, get_run, and compare_runs.

MCP Tauri Automation

Enables AI-driven testing and automation of Tauri desktop applications through natural language, allowing users to interact with UI elements, capture screenshots, execute commands, and test application flows without manual clicking or complex scripts.

wrapmcp

Universal MCP server that wraps any CLI tool, enabling AI assistants to run commands via natural language.

高德地图

高德地图

MCP Swift Example Server

Aquí tienes un ejemplo de implementación de un servidor MCP (Protocolo de Contexto de Modelo): ```python import socket import threading import json # Configuración del servidor HOST = '127.0.0.1' # Dirección IP del servidor PORT = 65432 # Puerto de escucha del servidor # Clase para manejar cada conexión de cliente class ClientHandler(threading.Thread): def __init__(self, conn, addr): threading.Thread.__init__(self) self.conn = conn self.addr = addr print(f"Conectado con {addr[0]}:{addr[1]}") def run(self): try: while True: # Recibir datos del cliente data = self.conn.recv(1024) if not data: break # Decodificar los datos (asumiendo que son JSON) try: request = json.loads(data.decode('utf-8')) print(f"Recibido: {request}") # Procesar la solicitud (ejemplo) response = self.process_request(request) # Enviar la respuesta al cliente self.conn.sendall(json.dumps(response).encode('utf-8')) except json.JSONDecodeError: print(f"Error: Datos no válidos recibidos de {self.addr[0]}:{self.addr[1]}") self.conn.sendall(json.dumps({"error": "Invalid JSON"}).encode('utf-8')) except Exception as e: print(f"Error al procesar la solicitud: {e}") self.conn.sendall(json.dumps({"error": str(e)}).encode('utf-8')) finally: # Cerrar la conexión self.conn.close() print(f"Conexión cerrada con {self.addr[0]}:{self.addr[1]}") def process_request(self, request): """ Procesa la solicitud recibida y devuelve una respuesta. Este es un ejemplo básico, debes adaptarlo a tu caso de uso específico. """ if "action" in request: action = request["action"] if action == "get_context": # Ejemplo: Devolver un contexto de modelo ficticio context = { "model_name": "MiModeloGenial", "version": "1.0", "description": "Un modelo de ejemplo para demostración." } return {"status": "success", "context": context} elif action == "process_data": # Ejemplo: Procesar datos (simplemente devolverlos) data = request.get("data", {}) return {"status": "success", "result": data} else: return {"status": "error", "message": "Acción desconocida"} else: return {"status": "error", "message": "Acción no especificada"} # Función principal del servidor def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Servidor escuchando en {HOST}:{PORT}") while True: conn, addr = s.accept() client = ClientHandler(conn, addr) client.start() if __name__ == "__main__": main() ``` **Explicación del código:** 1. **Importaciones:** - `socket`: Para la comunicación de red. - `threading`: Para manejar múltiples clientes concurrentemente. - `json`: Para serializar y deserializar datos JSON. 2. **Configuración del servidor:** - `HOST`: La dirección IP en la que el servidor escuchará (aquí se usa `127.0.0.1` para localhost). - `PORT`: El puerto en el que el servidor escuchará. 3. **Clase `ClientHandler`:** - Hereda de `threading.Thread` para manejar cada conexión de cliente en un hilo separado. - `__init__`: Inicializa el hilo con la conexión (`conn`) y la dirección (`addr`) del cliente. - `run`: El método principal del hilo. Escucha datos del cliente, los decodifica como JSON, los procesa y envía una respuesta. Maneja errores de decodificación JSON y excepciones generales. Finalmente, cierra la conexión. - `process_request`: **Esta es la parte más importante y donde debes implementar la lógica específica de tu servidor MCP.** En este ejemplo, simplemente verifica la "acción" en la solicitud y devuelve una respuesta basada en ella. Las acciones de ejemplo son `get_context` (devuelve un contexto de modelo ficticio) y `process_data` (simplemente devuelve los datos recibidos). Debes adaptar esta función para que coincida con las acciones y el contexto de modelo que tu servidor necesita manejar. 4. **Función `main`:** - Crea un socket TCP (`socket.SOCK_STREAM`). - Enlaza el socket a la dirección y el puerto especificados (`s.bind((HOST, PORT))`). - Comienza a escuchar conexiones entrantes (`s.listen()`). - Entra en un bucle infinito para aceptar nuevas conexiones. - Para cada conexión, crea una instancia de `ClientHandler` y la inicia como un nuevo hilo (`client.start()`). **Cómo usarlo:** 1. **Guarda el código:** Guarda el código como un archivo Python (por ejemplo, `mcp_server.py`). 2. **Ejecuta el servidor:** Ejecuta el archivo desde la línea de comandos: `python mcp_server.py`. 3. **Crea un cliente:** Necesitarás un cliente que se conecte a este servidor y envíe solicitudes JSON. Aquí tienes un ejemplo básico de cliente en Python: ```python import socket import json HOST = '127.0.0.1' PORT = 65432 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) # Ejemplo de solicitud para obtener el contexto del modelo request = {"action": "get_context"} s.sendall(json.dumps(request).encode('utf-8')) data = s.recv(1024) print(f"Recibido: {data.decode('utf-8')}") # Ejemplo de solicitud para procesar datos request = {"action": "process_data", "data": {"input": "algún dato"}} s.sendall(json.dumps(request).encode('utf-8')) data = s.recv(1024) print(f"Recibido: {data.decode('utf-8')}") ``` 4. **Ejecuta el cliente:** Guarda el código del cliente como un archivo Python (por ejemplo, `mcp_client.py`) y ejecútalo: `python mcp_client.py`. **Puntos importantes a considerar:** * **Protocolo MCP:** Este es un ejemplo básico. Un protocolo MCP real podría tener una estructura de mensajes más definida, manejo de errores más robusto y mecanismos de autenticación/autorización. * **`process_request`:** Esta función es el corazón de tu servidor. Debes implementarla para que maneje las solicitudes específicas que tu modelo necesita. Esto podría incluir cargar el modelo, ejecutar inferencia, acceder a bases de datos, etc. * **Seguridad:** Si vas a usar este servidor en un entorno de producción, debes considerar la seguridad. Esto podría incluir el uso de TLS/SSL para cifrar la comunicación, autenticación para verificar la identidad de los clientes y autorización para controlar qué acciones pueden realizar los clientes. * **Manejo de errores:** El manejo de errores en este ejemplo es básico. Debes implementar un manejo de errores más robusto para manejar situaciones inesperadas y proporcionar información útil a los clientes. * **Escalabilidad:** Si necesitas manejar un gran número de clientes, debes considerar la escalabilidad. Esto podría incluir el uso de un servidor web asíncrono (como `asyncio` o `Tornado`) o la implementación de un sistema de colas de mensajes. * **Serialización:** JSON es un formato de serialización común, pero puedes usar otros formatos como Protocol Buffers o MessagePack si necesitas un mejor rendimiento o un esquema más estricto. Este ejemplo te proporciona un punto de partida para construir tu propio servidor MCP. Recuerda adaptarlo a tus necesidades específicas.

j-can-see

MCP server that adds vision capabilities to text-only AI models by sending images (local files, URLs, clipboard, screenshots) to a vision model and returning text descriptions.

Browser MCP Server

A Docker-based workspace providing headless Chrome browser with CDP proxy and noVNC interface for browser automation and monitoring.