Discover Awesome MCP Servers

Jira MCP Server

Un servidor MCP compatible con las API de Jira V2 y V3 y campos personalizados.

Video Content Summarization MCP Server

Extracts content from multiple video platforms (Douyin, Bilibili, Xiaohongshu, Zhihu) and generates intelligent knowledge graphs with OCR text recognition capabilities.

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.

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

MCP Job Search

Helps users find suitable LinkedIn job opportunities by automatically scraping listings, analyzing compatibility with user profiles using AI, and sending custom match reports via email.

JSON-RPC クライアントツール

Este es solo un proyecto privado, para tu referencia.

Unicode Puzzles MCP

Crea y gestiona mensajes codificados utilizando caracteres de ancho cero y técnicas avanzadas de esteganografía Unicode, permitiendo la generación de puzles con temática cuántica con secretos ocultos.

Mozilla Readability Parser MCP Server

Extracts and transforms webpage content into clean, LLM-optimized Markdown. Returns article title, main content, excerpt, byline and site name. Uses Mozilla's Readability algorithm to remove ads, navigation, footers and non-essential elements while preserving the core content structure.

Trivy

Trivy

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.

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.

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

kube-mcp

Un servidor MCP que permite la interacción con clústeres de Kubernetes/Minikube a través del lenguaje natural, permitiendo que agentes de IA como Codename Goose gestionen recursos de Kubernetes mediante el Protocolo de Contexto de Modelo.

MCP Video Parser

A video analysis system that uses AI vision models to process, analyze, and query video content through natural language, enabling users to search videos by time, location, and content.

MCP Microsoft Teams Server

Servidor MCP que integra mensajería de Microsoft Teams (leer, publicar, mencionar, listar miembros e hilos).

myAI Memory Sync

Una herramienta MCP que sincroniza las preferencias del usuario, los detalles personales y los estándares de código en múltiples interfaces de Claude, permitiendo a los usuarios mantener interacciones de IA personalizadas y consistentes sin tener que repetirse.

Remotion Video Editing MCP Server

Web-based video editing platform that provides direct editing functionality through a Model Context Protocol server, supporting media file management, timeline editing, and advanced transformation effects.

ardour-mcp

Here are a few ways to translate "mcp server to connect Ardour 9 DAW", depending on the specific meaning you want to convey: **Option 1 (Most General):** * **Spanish:** Servidor MCP para conectar con Ardour 9 DAW * This is a direct translation and works well if you're simply stating the purpose. **Option 2 (More Specific - Emphasizing Connection):** * **Spanish:** Servidor MCP para conectar a Ardour 9 DAW * This emphasizes the connection *to* Ardour. **Option 3 (If "MCP" is an acronym and you want to clarify):** * **Spanish:** Servidor MCP (Protocolo de Control Maestro) para conectar con/a Ardour 9 DAW * This assumes "MCP" stands for "Master Control Protocol" (or something similar) and clarifies the acronym. Replace "Protocolo de Control Maestro" with the correct Spanish translation if it's something else. **Option 4 (Focusing on Integration):** * **Spanish:** Servidor MCP para integrar con Ardour 9 DAW * This suggests a deeper level of connection, like integration or working together. **Which option is best depends on the context. If you can provide more information about what the MCP server *does* in relation to Ardour, I can give you a more precise translation.**

PDF.co MCP Server

Provides PDF.co API functionality through the Model Context Protocol, enabling AI assistants to perform various PDF processing tasks like conversion, editing, searching, and security operations.

Mercado Pago MCP Server

Mercado Pago's Official MCP Server offers tools so that developers can easily interact with our API using natural language, which simplifies tasks and product integration. Remotely hosted by Mercadolibre supporting Streamable HTTP Transport. Details on how to connect: https://mcp.mercadopago.com/

MCP Example Express

A basic example of developing and running serverless Model Context Protocol (MCP) using Netlify Functions, demonstrating how to deploy and access MCP functionality through customized URLs.