Discover Awesome MCP Servers

fastmail-mcp

Unified MCP server for Fastmail email (JMAP), calendar (CalDAV), and contacts (CardDAV). Enables sending emails, managing events, and syncing contacts through natural language.

@opc/skill-content-policies

MCP server that reads OPC policy information from the OPC personal tool station via API key, enabling users to query policy updates.

New Relic MCP Server

Connects AI assistants to New Relic with read-only access to NRQL, logs, metrics, traces, alerts, and more. Offers optional, gated write operations with a dry-run and confirmation workflow.

Investors MCP Server

Enables semantic search and ingestion of investor content using Upstash Vector and Vercel Blob storage, with optional filtering by author, company, and date.

tutu-compass

A travel negotiation agent for Russian trips that turns one natural-language request into a plan_trip MCP tool, surfacing budget-vs-connection trade-offs and offering instant plan B rerouting.

Remote MCP Server Authless

A serverless MCP implementation on Cloudflare Workers that doesn't require authentication, allowing you to deploy custom AI tools that can be accessed from Cloudflare AI Playground or Claude Desktop.

Sessionize

MCP server for accessing Sessionize event data. Query speakers, sessions, and schedules from any Sessionize-powered conference using natural language.

SiYuan MCP Server

An MCP server for SiYuan Note that enables comprehensive management of notebooks, documents, and blocks through AI integration. It supports advanced operations like SQL querying, OCR, multi-format exports, and automated content searching for intelligent knowledge management.

bruno-mcp

MCP server that executes requests from Bruno API collections via the Bruno CLI tool, enabling API request execution and collection management.

DocuSign MCP Server (patched)

Provides DocuSign eSignature operations via JWT Grant for headless AI agents, enabling envelope management, document signing, and template access through MCP tools.

JSON Contracts

JSON Contracts is a local MCP server for transforming natural language into Git-controlled JSON contracts, JSON Schema validation, and structured LLM/agent outputs.

ddq

Enables AI coding agents to retrieve QA cases from a curated knowledge base grounded in real bugs, supporting symptom search and feature-wide coverage for test planning.

DoorDash MCP Server

Enables AI agents to search restaurants, place delivery orders, and track real-time delivery status using the DoorDash Drive API. It includes a built-in mock data mode that allows for testing and demonstrating delivery lifecycles without requiring live API credentials.

Rootstock MCP Server

Enables Claude AI to interact with the Rootstock blockchain, including calling contracts, checking ERC20 token balances, transferring tokens, and querying gas prices.

gemini-mcp

MCP server providing Google Search grounding with source citations using Gemini Code Assist.

yonote-mcp

MCP server for managing Yonote workspace, providing 56 tools for documents, collections, users, groups, comments, sharing, favorites, revisions, events, and views via AI assistants.

My HTTP MCP Server

A Model Context Protocol server that provides cryptocurrency data tools and resources via an HTTP endpoint. It enables users to fetch real-time market data from Binance, track activity logs, and generate cryptocurrency executive summaries.

map-server

A minimal MCP server built on the official Python SDK, running over Streamable HTTP. It provides demo tools (echo, add) and a time resource for testing MCP clients.

Iconify-Icon

Provide access to Iconify's MCP server with over 200,000 open-source vector ICONS, supporting icon set browsing, searching, and obtaining multi-framework usage examples.

carapace-mcp

Enables AI agents to semantically search and contribute insights to a shared knowledge base built from other agents' experiences.

Azure Terraform MCP Server

Provides intelligent assistance for Azure Terraform development, including documentation retrieval, code validation, security scanning, and best practices guidance.

bgagents

Enables turning AI code agents like Anthropic Claude and OpenAI Codex into background agents accessible via MCP protocol for code generation, branch creation, and PR automation.

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

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.

AutoCAD MCP Server

An MCP server that enables natural-language control of AutoCAD via file IPC or headless DXF generation, with tools for drawing, entities, layers, blocks, annotations, P&ID, views, and system operations.

EventCatalog MCP Server

Enables querying event-driven architecture documentation including domains, services, messages, and schemas through MCP clients like Claude and Cursor.

Google Ads MCP Server

Enables comprehensive Google Ads campaign management and analytics through the Google Ads API. Supports querying campaigns, ad groups, keywords, performance metrics, and executing custom GAQL queries with token-efficient implementation.

vault-health-mcp

MCP server for Obsidian vault structural health checks. Find broken wikilinks, orphaned notes, and missing frontmatter, with optional auto-repair.