Discover Awesome MCP Servers

SEO AI Assistant

Servidor MCP que permite a los asistentes de IA realizar tareas de automatización de SEO, incluyendo la investigación de palabras clave, el análisis SERP y el análisis de la competencia a través de la integración de la API de Google Ads.

Date Operations MCP

Enables date and time operations including formatting, arithmetic, comparisons, and duration calculations using date-fns library. Provides tools for getting current time, adding/subtracting durations, finding differences between dates, and comparing dates.

Remote Math MCP Server

A Cloudflare Workers-hosted MCP server that provides basic mathematical operations with OAuth authentication. Demonstrates how to deploy and connect remote MCP servers to Claude Desktop and other MCP clients.

Hello World MCP Server

A simple Model Context Protocol server that demonstrates basic functionality with greeting tools, allowing Claude to say hello and generate custom greetings with different styles and timestamps.

Excel to PDF Converter

Un servidor MCP que convierte archivos de Excel y Apple Numbers a formato PDF, permitiendo que asistentes de IA como Claude realicen la conversión de archivos directamente a través de la conversación.

MCP Web Fetch Server

Enables fetching content from any URL with support for different HTTP methods, custom headers, and request bodies. Designed to work with ChatGPT and other AI assistants for web scraping and API interactions.

A Share MCP

A Model Context Protocol server providing tools for querying A-share stock market data, including historical prices, financial reports, market indices, and macroeconomic indicators.

Shopify Update MCP Server

Shopify Update MCP Server

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.

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

Este es solo un proyecto privado, para tu referencia.

Insights Knowledge Base MCP Server

A free, plug-and-play knowledge base server that provides access to 10,000+ insight reports with secure local data storage.

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.

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.

MCP Server for Apache Gravitino

A FastMCP integration server that provides access to Apache Gravitino metadata management APIs, allowing users to manage catalog/schema/table metadata, tags, and user-role information through a structured interface.

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.

exif-mcp

An offline MCP server that allows LLMs or humans to extract and analyze metadata from images using the exifr library, supporting various image formats and metadata segments without external tools.

WeRead MCP Server

A lightweight bridge server that connects WeChat Reading (WeRead) data with Claude Desktop, allowing seamless access to reading notes and book collections through natural language interactions.

Breez MCP Server

Enables Lightning Network wallet operations through the Breez SDK, allowing users to check balances, send/receive payments, create invoices, and manage Bitcoin Lightning transactions via natural language.

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.

Databricks MCP Server

Enables AI assistants like Claude to interact with Databricks workspaces through secure OAuth authentication. Supports custom prompts, tools for cluster management, SQL execution, and job operations via the Databricks SDK.

Giphy MCP Server

This MCP server enables interaction with the Giphy API through natural language, allowing users to search, retrieve, and manage GIFs through the Multi-Agent Conversation Protocol.

OpenAPI to MCP Server Converter

Here are a few options for translating the English phrase "A tool for automatically converting OpenAPI specifications into Model Context Protocol (MCP) Server" into Spanish, with slight variations in nuance: * **Una herramienta para convertir automáticamente especificaciones OpenAPI en un servidor de Protocolo de Contexto de Modelo (MCP).** (This is a very direct and common translation.) * **Una herramienta para la conversión automática de especificaciones OpenAPI a un servidor de Protocolo de Contexto de Modelo (MCP).** (This emphasizes the *conversion* process a bit more.) * **Una utilidad para convertir automáticamente especificaciones OpenAPI a un servidor de Protocolo de Contexto de Modelo (MCP).** (Using "utilidad" instead of "herramienta" can sometimes imply a smaller, more focused tool.) * **Herramienta para la conversión automática de especificaciones OpenAPI en servidores MCP (Protocolo de Contexto de Modelo).** (This is a more concise option, and it puts the acronym first, which is common in technical writing.) I would recommend the first option, "Una herramienta para convertir automáticamente especificaciones OpenAPI en un servidor de Protocolo de Contexto de Modelo (MCP)," unless you have a specific reason to prefer one of the others. It's clear, direct, and uses common vocabulary.

Kayzen Analytics MCP Server

Una implementación que permite a los modelos de IA acceder y analizar datos de campañas publicitarias de Kayzen a través de una interfaz estandarizada con funciones como la autenticación automatizada y la gestión de informes.

Coding Todo Server

Un servidor MCP que proporciona herramientas y recursos para gestionar la lista de tareas pendientes de un proyecto de programación, permitiendo a los usuarios ver, añadir, actualizar y eliminar elementos de la lista con detalles como prioridad, estado y etiquetas.