Discover Awesome MCP Servers

MCP Gmail Server

Enables users to read unread emails and create drafts in Gmail via the Model Context Protocol. It leverages Google OAuth 2.0 for secure authentication and integrates with tools like Claude Desktop for natural language email management.

Math Calculator MCP Server

Provides basic mathematical operations (addition, subtraction, multiplication, division) through a calculate tool. Supports both stdio and HTTP/SSE transport modes.

Piwik PRO MCP Server

Enables AI assistants to manage Piwik PRO Analytics resources including apps, tags, triggers, variables, audiences, and tracker settings through natural language commands. Supports comprehensive analytics configuration and tag management operations.

Playwright MCP

A Model Context Protocol server that provides browser automation capabilities using Playwright, enabling LLMs to interact with web pages through structured accessibility snapshots without requiring screenshots or vision models.

arXiv MCP Server

Enables searching and retrieving academic papers from arXiv with support for advanced filtering by author, category, and date, plus full paper content extraction.

TasksMultiServer

Multi-interface task management system that enables AI agents and users to manage hierarchical tasks (projects, task lists, tasks) with dependency tracking, tags, and search through MCP Server, REST API, or React UI.

Rhombus MCP Server

Enables AI assistants to interact with Rhombus physical security systems, providing access to smart cameras, access control, IoT sensors, and alarm monitoring through the Rhombus API.

MCP Server Demo 项目文档

Aquí tienes una traducción de la frase "一个基于Spring Boot 的MCP（Model Control Protocol）服务示例项目" al español: **Un proyecto de ejemplo de un servicio MCP (Model Control Protocol) basado en Spring Boot.** O, ligeramente más fluida: **Un proyecto de ejemplo de servicio MCP (Protocolo de Control de Modelos) implementado con Spring Boot.** Ambas traducciones son correctas y transmiten el mismo significado. La elección entre ellas depende del contexto y de la preferencia personal.

Project Context MCP Server

Provides unified project context and monitoring capabilities including project health metrics, build diagnostics, Git integration, and infrastructure validation to initialize development sessions with comprehensive project information.

Multi-Database SQL MCP Server

Enables interaction with SQLite, MySQL, PostgreSQL, and SQL Server databases through tools for connection management, parameterized query execution, and schema inspection.

Google Search Engine MCP Server

Enables Google search queries and webpage content extraction through an MCP server deployed on Cloudflare Workers. Supports single and batch webpage content extraction with integrated OAuth authentication.

RAG Documentation

Una implementación de servidor MCP que proporciona herramientas para recuperar y procesar documentación a través de búsqueda vectorial, permitiendo a los asistentes de IA aumentar sus respuestas con contexto de documentación relevante.

MCP-ShellJS

Un servidor MCP seguro que proporciona acceso controlado a ShellJS para LLMs, permitiendo que los sistemas de IA ejecuten comandos de shell de forma segura e interactúen con el sistema de archivos dentro de un entorno de pruebas de seguridad configurable.

WikiMCP

An MCP server for Wiki.js projects that enables full-text search, page retrieval, and page management capabilities. It allows LLMs to interact with wiki content through specialized tools for searching, listing, and creating pages.

Vulpes Spotify MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a asistentes de IA como Claude interactuar con Spotify, permitiéndoles buscar canciones, controlar la reproducción y administrar listas de reproducción.

MCP Visual Language

Enables intelligent image analysis using GLM-4.5V model, specializing in extracting and analyzing code from screenshots with support for file paths and clipboard input.

MCP Docs RAG Server

Un servidor MCP en TypeScript que permite consultar documentos utilizando LLMs con contexto de repositorios y archivos de texto almacenados localmente a través de un sistema RAG (Generación Aumentada por Recuperación).

KnowledgeBaseMCP

Enables AI assistants to extract and analyze text content from various document formats (PDF, DOCX, PPTX, XLSX) in local knowledge bases, and create new formatted Word and Excel documents with structured data and reports.

Basic MCP Server

A basic TypeScript implementation of the Model Context Protocol (MCP) server designed as a starting point for MCP development. Provides a minimal foundation for building custom MCP servers with stdio configuration for local integration with VS Code and GitHub Copilot.

E01 LNK MCP Server for Digital Forensics

Enables digital forensic analysis of Windows shortcut (LNK) files from E01 disk images. Supports automatic partition detection, LNK file extraction, metadata parsing, and timeline analysis through MCP-compatible agents.

CoolPC MCP Server

A Model Context Protocol server that enables Claude Desktop to query and analyze Taiwan CoolPC computer component prices, helping users generate custom PC quotes through AI assistance.

MCP Multi-Context Hook Generator

Automatically generates typed React hooks for Next.js projects by crawling API routes, GraphQL queries, and components. Analyzes pages to suggest optimal render modes (SSR/CSR/ISR) and produces comprehensive documentation with AI-powered guidance.

Nostr MCP Server

Espejo de

SQLite Database Demo

Aquí hay algunos ejemplos de cómo construir un servidor, un cliente y pruebas en el contexto del protocolo de modelo (MCP). Ten en cuenta que "MCP" es un término bastante genérico, así que asumiré que te refieres a un protocolo que define cómo un cliente y un servidor intercambian información sobre modelos (por ejemplo, modelos de aprendizaje automático). **Ejemplo 1: Un MCP Simple para Servir un Modelo de Predicción** Este ejemplo ilustra un protocolo muy básico donde el cliente envía datos al servidor, el servidor usa un modelo para hacer una predicción y devuelve la predicción al cliente. **1. Definición del Protocolo (MCP):** * **Solicitud (Cliente -> Servidor):** * `input_data`: Un diccionario de datos de entrada para el modelo. Por ejemplo: `{"feature1": 1.0, "feature2": 2.5}` * **Respuesta (Servidor -> Cliente):** * `prediction`: La predicción del modelo. Por ejemplo: `0.85` * `status`: Un código de estado (e.g., "OK", "ERROR"). * `message` (opcional): Un mensaje de error si `status` es "ERROR". **2. Implementación del Servidor (Python con Flask):** ```python from flask import Flask, request, jsonify import pickle # Para cargar el modelo app = Flask(__name__) # Carga el modelo (reemplaza 'modelo.pkl' con tu archivo de modelo) try: with open('modelo.pkl', 'rb') as f: model = pickle.load(f) except FileNotFoundError: print("Error: No se encontró el archivo del modelo.") exit() @app.route('/predict', methods=['POST']) def predict(): try: data = request.get_json() input_data = data['input_data'] # Realiza la predicción usando el modelo prediction = model.predict([list(input_data.values())])[0] # Asume que el modelo espera una lista de valores return jsonify({'prediction': prediction, 'status': 'OK'}) except Exception as e: return jsonify({'status': 'ERROR', 'message': str(e)}) if __name__ == '__main__': app.run(debug=True) ``` **3. Implementación del Cliente (Python con Requests):** ```python import requests import json def make_prediction(input_data): url = 'http://localhost:5000/predict' # Ajusta la URL si es necesario headers = {'Content-type': 'application/json'} data = {'input_data': input_data} try: response = requests.post(url, data=json.dumps(data), headers=headers) response.raise_for_status() # Lanza una excepción para códigos de error HTTP result = response.json() return result except requests.exceptions.RequestException as e: print(f"Error de conexión: {e}") return {'status': 'ERROR', 'message': str(e)} except json.JSONDecodeError as e: print(f"Error al decodificar JSON: {e}") return {'status': 'ERROR', 'message': str(e)} # Ejemplo de uso input_data = {'feature1': 1.5, 'feature2': 3.2} result = make_prediction(input_data) if result['status'] == 'OK': print(f"Predicción: {result['prediction']}") else: print(f"Error: {result['message']}") ``` **4. Pruebas (Python con `unittest`):** ```python import unittest import requests import json class TestPredictionService(unittest.TestCase): def test_successful_prediction(self): url = 'http://localhost:5000/predict' headers = {'Content-type': 'application/json'} data = {'input_data': {'feature1': 2.0, 'feature2': 4.0}} response = requests.post(url, data=json.dumps(data), headers=headers) self.assertEqual(response.status_code, 200) # Verifica que la solicitud fue exitosa result = response.json() self.assertEqual(result['status'], 'OK') self.assertIsInstance(result['prediction'], float) # Verifica que la predicción es un número def test_error_handling(self): url = 'http://localhost:5000/predict' headers = {'Content-type': 'application/json'} data = {'input_data': {'feature1': 'invalid', 'feature2': 4.0}} # Datos inválidos response = requests.post(url, data=json.dumps(data), headers=headers) self.assertEqual(response.status_code, 200) # Aún esperamos un 200 OK (el error se maneja en el JSON) result = response.json() self.assertEqual(result['status'], 'ERROR') self.assertIn('could not convert string to float', result['message']) # Verifica el mensaje de error if __name__ == '__main__': unittest.main() ``` **Explicación del Código:** * **Servidor:** * Usa Flask para crear una API web simple. * Carga un modelo pre-entrenado (usando `pickle` como ejemplo). **Importante:** `pickle` puede ser inseguro si cargas modelos de fuentes no confiables. Considera usar formatos más seguros como `joblib` o guardar los pesos del modelo en un formato como HDF5 y reconstruir el modelo en el servidor. * Define un endpoint `/predict` que recibe datos JSON, los pasa al modelo y devuelve la predicción como JSON. * Maneja errores y devuelve un código de estado y un mensaje de error si algo sale mal. * **Cliente:** * Usa la biblioteca `requests` para enviar solicitudes POST al servidor. * Convierte los datos de entrada a JSON. * Maneja errores de conexión y errores al decodificar la respuesta JSON. * **Pruebas:** * Usa la biblioteca `unittest` para escribir pruebas automatizadas. * `test_successful_prediction`: Verifica que el servidor devuelve una predicción exitosa cuando se le dan datos válidos. * `test_error_handling`: Verifica que el servidor maneja correctamente los errores cuando se le dan datos inválidos. **Ejemplo 2: Un MCP Más Complejo para Actualizar un Modelo** Este ejemplo ilustra un protocolo donde el cliente puede enviar datos de entrenamiento al servidor para actualizar el modelo. **1. Definición del Protocolo (MCP):** * **Solicitud de Predicción (Cliente -> Servidor):** (Igual que antes) * `input_data`: Un diccionario de datos de entrada para el modelo. * **Respuesta de Predicción (Servidor -> Cliente):** (Igual que antes) * `prediction`: La predicción del modelo. * `status`: Un código de estado. * `message` (opcional): Un mensaje de error. * **Solicitud de Actualización (Cliente -> Servidor):** * `training_data`: Una lista de diccionarios, donde cada diccionario representa un ejemplo de entrenamiento. Por ejemplo: `[{"feature1": 1.0, "feature2": 2.0, "label": 0}, {"feature1": 2.0, "feature2": 3.0, "label": 1}]` * **Respuesta de Actualización (Servidor -> Cliente):** * `status`: Un código de estado ("OK", "ERROR"). * `message` (opcional): Un mensaje de error. **2. Implementación del Servidor (Python con Flask):** ```python from flask import Flask, request, jsonify import pickle import numpy as np # Para manejar datos numéricos app = Flask(__name__) # Carga el modelo try: with open('modelo.pkl', 'rb') as f: model = pickle.load(f) except FileNotFoundError: print("Error: No se encontró el archivo del modelo.") exit() @app.route('/predict', methods=['POST']) def predict(): try: data = request.get_json() input_data = data['input_data'] prediction = model.predict([list(input_data.values())])[0] return jsonify({'prediction': prediction, 'status': 'OK'}) except Exception as e: return jsonify({'status': 'ERROR', 'message': str(e)}) @app.route('/update', methods=['POST']) def update_model(): try: data = request.get_json() training_data = data['training_data'] # Prepara los datos para el entrenamiento X = np.array([list(example.values())[:-1] for example in training_data]) # Características y = np.array([example['label'] for example in training_data]) # Etiquetas # Entrena el modelo (aquí se asume un modelo con un método 'partial_fit') model.partial_fit(X, y) # 'partial_fit' es para entrenamiento incremental # Guarda el modelo actualizado with open('modelo.pkl', 'wb') as f: pickle.dump(model, f) return jsonify({'status': 'OK'}) except Exception as e: return jsonify({'status': 'ERROR', 'message': str(e)}) if __name__ == '__main__': app.run(debug=True) ``` **3. Implementación del Cliente (Python con Requests):** ```python import requests import json def make_prediction(input_data): # (Igual que antes) pass def update_model(training_data): url = 'http://localhost:5000/update' headers = {'Content-type': 'application/json'} data = {'training_data': training_data} try: response = requests.post(url, data=json.dumps(data), headers=headers) response.raise_for_status() result = response.json() return result except requests.exceptions.RequestException as e: print(f"Error de conexión: {e}") return {'status': 'ERROR', 'message': str(e)} except json.JSONDecodeError as e: print(f"Error al decodificar JSON: {e}") return {'status': 'ERROR', 'message': str(e)} # Ejemplo de uso training_data = [ {'feature1': 1.0, 'feature2': 2.0, 'label': 0}, {'feature1': 2.0, 'feature2': 3.0, 'label': 1} ] result = update_model(training_data) if result['status'] == 'OK': print("Modelo actualizado exitosamente.") else: print(f"Error al actualizar el modelo: {result['message']}") ``` **4. Pruebas (Python con `unittest`):** ```python import unittest import requests import json import pickle class TestModelUpdateService(unittest.TestCase): def setUp(self): # Guarda una copia del modelo original para restaurarlo después de la prueba with open('modelo.pkl', 'rb') as f: self.original_model = pickle.load(f) def tearDown(self): # Restaura el modelo original with open('modelo.pkl', 'wb') as f: pickle.dump(self.original_model, f) def test_successful_update(self): url = 'http://localhost:5000/update' headers = {'Content-type': 'application/json'} training_data = [ {'feature1': 3.0, 'feature2': 4.0, 'label': 0}, {'feature1': 4.0, 'feature2': 5.0, 'label': 1} ] data = {'training_data': training_data} response = requests.post(url, data=json.dumps(data), headers=headers) self.assertEqual(response.status_code, 200) result = response.json() self.assertEqual(result['status'], 'OK') # Verifica que el modelo ha cambiado (esto es una prueba simple; una prueba más robusta requeriría comparar las predicciones antes y después) with open('modelo.pkl', 'rb') as f: updated_model = pickle.load(f) self.assertNotEqual(self.original_model.__dict__, updated_model.__dict__) # Compara los diccionarios internos del objeto def test_update_error_handling(self): url = 'http://localhost:5000/update' headers = {'Content-type': 'application/json'} training_data = [ {'feature1': 'invalid', 'feature2': 4.0, 'label': 0}, # Datos inválidos {'feature1': 4.0, 'feature2': 5.0, 'label': 1} ] data = {'training_data': training_data} response = requests.post(url, data=json.dumps(data), headers=headers) self.assertEqual(response.status_code, 200) result = response.json() self.assertEqual(result['status'], 'ERROR') self.assertIn('could not convert string to float', result['message']) if __name__ == '__main__': unittest.main() ``` **Puntos Clave de este Ejemplo:** * **Endpoint `/update`:** Este endpoint recibe datos de entrenamiento y actualiza el modelo. * **Entrenamiento Incremental:** El ejemplo usa `model.partial_fit()`. Esto es *crucial* para el entrenamiento en línea, donde no tienes todos los datos disponibles de antemano. No todos los modelos tienen un método `partial_fit()`. Si tu modelo no lo tiene, tendrás que re-entrenar el modelo completo con los nuevos datos (lo cual puede ser costoso). * **Persistencia del Modelo:** Después de la actualización, el modelo se guarda de nuevo en el archivo `modelo.pkl`. * **Pruebas:** * `setUp` y `tearDown`: Estos métodos se usan para configurar y limpiar el entorno de prueba. En este caso, guardamos una copia del modelo original antes de la prueba y lo restauramos después para que las pruebas no afecten el estado del modelo a largo plazo. * La prueba `test_successful_update` verifica que el modelo se actualiza correctamente. **Importante:** La verificación de que el modelo ha cambiado es muy básica. Una prueba más robusta requeriría comparar las predicciones del modelo antes y después de la actualización para asegurarse de que las predicciones han mejorado con los nuevos datos. **Consideraciones Adicionales:** * **Seguridad:** La serialización con `pickle` puede ser peligrosa. Considera usar formatos más seguros como `joblib` o guardar los pesos del modelo en un formato como HDF5 y reconstruir el modelo en el servidor. También, valida y sanitiza los datos de entrada para prevenir ataques de inyección. * **Escalabilidad:** Para un sistema de producción, necesitarás una arquitectura más escalable. Considera usar un servidor web más robusto como Gunicorn o uWSGI, un balanceador de carga y una base de datos para almacenar los modelos. * **Control de Versiones del Modelo:** Es importante tener un sistema para controlar las versiones de tus modelos. Puedes usar un sistema de control de versiones como Git para rastrear los cambios en los archivos del modelo, o puedes usar una base de datos para almacenar los modelos y sus metadatos (versión, fecha de entrenamiento, etc.). * **Monitorización:** Monitoriza el rendimiento de tu modelo en producción. Rastrea métricas como la precisión, la latencia y el uso de recursos. Usa estas métricas para detectar problemas y mejorar el rendimiento del modelo. * **Autenticación y Autorización:** Implementa autenticación y autorización para proteger tu API. Asegúrate de que solo los usuarios autorizados puedan acceder a los endpoints de predicción y actualización. * **Validación de Datos:** Valida los datos de entrada tanto en el cliente como en el servidor. Asegúrate de que los datos tienen el formato correcto y que están dentro de los rangos esperados. Esto ayuda a prevenir errores y ataques. * **Manejo de Errores Robusto:** Implementa un manejo de errores robusto en el servidor. Captura todas las excepciones posibles y devuelve mensajes de error informativos al cliente. Registra los errores para que puedas diagnosticar y solucionar problemas. * **Documentación:** Documenta tu MCP claramente. Describe los formatos de solicitud y respuesta, los códigos de estado y los mensajes de error. Esto facilitará que otros desarrolladores usen tu API. * **Serialización:** Considera usar un formato de serialización más eficiente como Protocol Buffers o Apache Thrift, especialmente si estás manejando grandes cantidades de datos. Estos ejemplos te dan un punto de partida. La complejidad de tu MCP dependerá de los requisitos específicos de tu aplicación. Recuerda priorizar la seguridad, la escalabilidad y la mantenibilidad al diseñar tu protocolo.

InfluxDB MCP Server

Un servidor de Protocolo de Contexto de Modelo que proporciona a Claude acceso a instancias de la base de datos de series temporales InfluxDB, permitiendo la escritura, consulta y gestión de datos de organizaciones y buckets a través del lenguaje natural.

MCP Web Search Server

Enables privacy-focused web searches, social media lookups, and web archive retrieval across multiple engines including DuckDuckGo, Brave, Reddit, YouTube, and Wayback Machine with built-in caching and security features.

Personal Productivity MCP Server

A multi-domain productivity tool that currently enables job search automation, application tracking, and pipeline analysis for Career management. Future phases plan to add health tracking, workout management, and family expense monitoring capabilities.

MCP Minecraft Remote

Permite que los asistentes de IA se conecten y controlen a los jugadores de Minecraft en servidores remotos, lo que permite la navegación, la construcción, la minería, la gestión del inventario, la interacción con entidades y la comunicación por chat a través de comandos en lenguaje natural.

Remote MCP Server (Authless)

A template for deploying MCP servers on Cloudflare Workers without authentication. Enables users to create custom remote MCP tools that can be accessed from Claude Desktop or other MCP clients through a simple HTTP endpoint.