Discover Awesome MCP Servers

E-phy MCP Server

Provides access to the French e-phy catalog for detailed information on pesticides, fertilizers, and other phytosanitary products. It enables users to search for products, retrieve authorized usage specifications, and check the approval status of active substances.

Proxmox MCP Server

An enterprise-grade management tool that enables Claude Code to securely interact with Proxmox VE for full VM and LXC container management. It provides single-command installation and comprehensive security controls for production-ready deployments.

MCP Fullstack

A comprehensive operations platform providing browser automation, web search/crawling, database operations, deployment tools, secrets management, and analytics capabilities for full-stack software engineering workflows. Features AI-driven automation, real-time monitoring dashboard, and cross-platform service management.

MCP Autostarter

An intelligent MCP server that enables seamless restarting of Claude's MCP handler process without disrupting the UI, allowing for plugin reloading without closing the entire Claude Desktop application.

Advanced MCP Server

Provides real-time weather alerts from the National Weather Service, news search capabilities via NewsAPI, and safe local directory exploration for AI assistants.

File Rank MCP Server

A tool that helps rank codebase files by importance (1-10 scale), track file dependencies, and provide summaries, all accessible through a simple JSON-based interface.

Local LLM MCP Server

Bridges local LLMs running in LM Studio with MCP clients like Claude Desktop to perform reasoning and analysis tasks while keeping sensitive data private. It features a suite of tools for local code review, privacy scanning, and content transformation using auto-discovered local models.

Remote MCP Server (Authless)

Deploys a Model Context Protocol server on Cloudflare Workers without authentication requirements, allowing you to create and expose custom AI tools to clients like Claude Desktop or Cloudflare AI Playground.

MCP Server MySQL

Enables LLMs to interact with MySQL databases through standardized protocol, supporting database management, table operations, data queries, and modifications with configurable permission controls.

MCP Server Directory

Descubre y comparte servidores de Protocolo de Contexto de Modelos para aplicaciones, desarrollo e integración de IA.

Gaia-Protocol

Gaia Protocol—a planetary DAO for global resource management using quantum-entangled ledgers and algorithmic governance.

Airtable MCP Server

Enables complete interaction with Airtable databases through 16 CRUD operations including batch processing, schema management, and record manipulation. Designed for AI applications and n8n workflows with HTTP streaming support.

Sanka MCP Server

A Model Context Protocol server that integrates the Sanka TypeScript SDK to provide document search and code execution capabilities. It allows clients to interact with Sanka's public API through a hosted HTTP or SSE interface.

WarpGBM MCP Service

Provides GPU-accelerated gradient boosting model training and inference through a cloud service. Enables AI agents to train models on NVIDIA A10G GPUs and get fast cached predictions with portable model artifacts.

lafe-blog MCP Server

Enables creating and managing text notes with a simple note-taking system. Provides tools to create notes, access them via URIs, and generate summaries of all stored notes.

DA Live Admin MCP Server

Enables LLM assistants to manage Document Authoring (DA) repositories through the DA Live Admin API, supporting operations like listing, creating, updating, and deleting source files, managing configurations, and looking up media and fragment references.

kintone OAuth MCP Server on Cloudflare Workers

Enables secure interaction with kintone through OAuth authentication, supporting record operations, app configuration management, file operations, and access control without storing API keys locally.

MCPLab

Aquí tienes ejemplos, código, diseños y tutoriales sobre MCP (Model Context Protocol) servidor-cliente: **Es importante notar que "MCP (Model Context Protocol)" no es un término ampliamente reconocido o estandarizado en la industria del software. Es posible que te refieras a un protocolo específico que se usa internamente en un proyecto o empresa, o quizás a un concepto más general. Por lo tanto, la información que puedo proporcionar será basada en la *interpretación* de lo que podría significar un protocolo de este tipo, asumiendo que se trata de un protocolo para la comunicación entre un servidor y un cliente para el intercambio de información sobre modelos (de datos, de machine learning, etc.).** **Asunciones:** * **Propósito:** Permitir que un cliente solicite y reciba información sobre modelos disponibles en un servidor. Esto podría incluir metadatos del modelo, la estructura del modelo, ejemplos de datos, o incluso el propio modelo (dependiendo de la seguridad y el propósito). * **Arquitectura:** Un modelo cliente-servidor donde el servidor mantiene información sobre los modelos y el cliente la solicita. * **Formato de Datos:** JSON es un formato común para el intercambio de datos, por lo que lo usaremos en los ejemplos. Sin embargo, se podría usar otros formatos como Protocol Buffers, Avro, o incluso XML. * **Transporte:** HTTP/HTTPS es un protocolo de transporte común para este tipo de comunicación. También se podría usar gRPC o WebSockets. **Ejemplo Conceptual (Usando HTTP/JSON):** **1. Definición del Protocolo (Conceptual):** * **Solicitud (Cliente -> Servidor):** * `GET /models` - Obtiene una lista de todos los modelos disponibles. * `GET /models/{model_id}` - Obtiene información detallada sobre un modelo específico. * `GET /models/{model_id}/schema` - Obtiene el esquema del modelo (estructura de datos esperada). * `GET /models/{model_id}/example` - Obtiene un ejemplo de datos para el modelo. * **Respuesta (Servidor -> Cliente):** * JSON con la información solicitada. Los códigos de estado HTTP estándar (200 OK, 404 Not Found, 500 Internal Server Error, etc.) se utilizan para indicar el éxito o el fracaso de la solicitud. **2. Ejemplo de Código (Python - Flask para el Servidor, Requests para el Cliente):** **Servidor (Flask):** ```python from flask import Flask, jsonify app = Flask(__name__) # Simulación de datos de modelos models = { "model1": { "id": "model1", "name": "Predicción de Precios de Viviendas", "description": "Un modelo para predecir el precio de una vivienda basado en sus características.", "version": "1.0" }, "model2": { "id": "model2", "name": "Clasificación de Imágenes", "description": "Un modelo para clasificar imágenes en diferentes categorías.", "version": "2.0" } } model_schemas = { "model1": { "type": "object", "properties": { "area": {"type": "number"}, "bedrooms": {"type": "integer"}, "bathrooms": {"type": "integer"} }, "required": ["area", "bedrooms", "bathrooms"] } } model_examples = { "model1": { "area": 1500, "bedrooms": 3, "bathrooms": 2 } } @app.route('/models', methods=['GET']) def list_models(): return jsonify(list(models.values())) @app.route('/models/<model_id>', methods=['GET']) def get_model(model_id): if model_id in models: return jsonify(models[model_id]) else: return jsonify({"error": "Modelo no encontrado"}), 404 @app.route('/models/<model_id>/schema', methods=['GET']) def get_model_schema(model_id): if model_id in model_schemas: return jsonify(model_schemas[model_id]) else: return jsonify({"error": "Esquema del modelo no encontrado"}), 404 @app.route('/models/<model_id>/example', methods=['GET']) def get_model_example(model_id): if model_id in model_examples: return jsonify(model_examples[model_id]) else: return jsonify({"error": "Ejemplo del modelo no encontrado"}), 404 if __name__ == '__main__': app.run(debug=True) ``` **Cliente (Python - Requests):** ```python import requests SERVER_URL = "http://127.0.0.1:5000" # Cambia si el servidor está en otra dirección def list_models(): response = requests.get(f"{SERVER_URL}/models") if response.status_code == 200: print("Lista de Modelos:") print(response.json()) else: print(f"Error: {response.status_code} - {response.text}") def get_model_details(model_id): response = requests.get(f"{SERVER_URL}/models/{model_id}") if response.status_code == 200: print(f"Detalles del Modelo {model_id}:") print(response.json()) elif response.status_code == 404: print(f"Modelo {model_id} no encontrado.") else: print(f"Error: {response.status_code} - {response.text}") def get_model_schema(model_id): response = requests.get(f"{SERVER_URL}/models/{model_id}/schema") if response.status_code == 200: print(f"Esquema del Modelo {model_id}:") print(response.json()) elif response.status_code == 404: print(f"Esquema del Modelo {model_id} no encontrado.") else: print(f"Error: {response.status_code} - {response.text}") def get_model_example(model_id): response = requests.get(f"{SERVER_URL}/models/{model_id}/example") if response.status_code == 200: print(f"Ejemplo del Modelo {model_id}:") print(response.json()) elif response.status_code == 404: print(f"Ejemplo del Modelo {model_id} no encontrado.") else: print(f"Error: {response.status_code} - {response.text}") if __name__ == '__main__': list_models() get_model_details("model1") get_model_details("model3") # Modelo inexistente get_model_schema("model1") get_model_example("model1") ``` **3. Diseño:** * **Servidor:** * **API RESTful:** Usar una API RESTful con endpoints claros y bien definidos. * **Autenticación y Autorización:** Implementar mecanismos de autenticación (e.g., API keys, OAuth) y autorización para controlar el acceso a los modelos. Esto es *crucial* si los modelos son sensibles. * **Control de Versiones:** Gestionar las versiones de los modelos para permitir la compatibilidad con versiones anteriores. * **Logging y Monitoring:** Implementar logging y monitoring para rastrear el uso de la API y detectar problemas. * **Escalabilidad:** Diseñar el servidor para que pueda escalar horizontalmente para manejar un gran número de solicitudes. * **Cliente:** * **Manejo de Errores:** Implementar un manejo robusto de errores para lidiar con fallos de red, errores del servidor, etc. * **Reintentos:** Implementar lógica de reintento para solicitudes fallidas. * **Cache:** Implementar un mecanismo de cache para almacenar en caché la información del modelo y reducir la carga en el servidor. * **Asincronía:** Usar operaciones asíncronas para evitar bloquear la interfaz de usuario mientras se espera la respuesta del servidor. **4. Tutoriales y Recursos Adicionales:** * **Flask (Python):** [https://flask.palletsprojects.com/](https://flask.palletsprojects.com/) * **Requests (Python):** [https://requests.readthedocs.io/](https://requests.readthedocs.io/) * **RESTful APIs:** Busca tutoriales sobre cómo diseñar y construir APIs RESTful. * **Autenticación y Autorización:** Investiga sobre OAuth 2.0, JWT (JSON Web Tokens), y otros mecanismos de autenticación. * **gRPC:** Si necesitas un protocolo de alto rendimiento, considera gRPC: [https://grpc.io/](https://grpc.io/) * **Protocol Buffers:** Un formato de serialización eficiente para gRPC: [https://developers.google.com/protocol-buffers](https://developers.google.com/protocol-buffers) **Consideraciones Adicionales:** * **Seguridad:** La seguridad es primordial. Asegúrate de proteger los modelos y la información que se intercambia entre el cliente y el servidor. * **Rendimiento:** Optimiza el rendimiento del servidor y del cliente para garantizar una experiencia de usuario fluida. * **Documentación:** Documenta el protocolo y la API de forma clara y concisa. * **Pruebas:** Escribe pruebas unitarias y de integración para garantizar la calidad del código. **En resumen, el "MCP" que he interpretado es un protocolo para el intercambio de información sobre modelos entre un cliente y un servidor. La implementación específica dependerá de tus necesidades y requisitos. Los ejemplos de código y las consideraciones de diseño proporcionadas son un punto de partida para construir tu propio protocolo.** Si "MCP" significa algo diferente, por favor, proporciona más detalles para que pueda darte una respuesta más precisa.

Water Bar Email MCP Server

Enables sending branded wellness booking confirmation emails through Resend integration. Supports multiple email flows including AOI experience bookings with AI-suggested drink pairings and timeline layouts.

Fraim Context MCP

Enables semantic search of project documentation using hybrid vector and full-text search with fast and deep query modes for immediate results or complex multi-round synthesis.

whois-mcp

A WHOIS domain name query server based on Model Context Protocol (MCP), supporting the resolution of over 877 top-level domains and 169 country code top-level domains, and providing comprehensive domain name registration information query functions.

Ashby MCP Server

Connects Claude to the Ashby ATS to manage the hiring pipeline through natural conversation. It enables users to browse jobs, manage candidate profiles, track applications, and coordinate interview stages.

Brave Search MCP Server

An MCP implementation that integrates the Brave Search API, providing comprehensive search capabilities including web, local business, image, video, news searches, and AI-powered summarization.

Google Ad Manager MCP Server

Enables AI assistants to manage Google Ad Manager campaigns, line items, creatives, and advertisers through natural language, automating ad operations that normally require countless clicks through the UI.

ProxmoxMCP-Plus

Enhanced MCP server for managing Proxmox virtualization platforms with complete VM lifecycle management, LXC container support, and OpenAPI integration. Enables natural language VM creation, power management, and comprehensive cluster monitoring through secure API access.

Service Health MCP Server

A professional-grade MCP server that enables AI assistants to monitor web services, APIs, and HTTP endpoints with enterprise-level security.

gqai

gqai

AstrBot MCP

Provides operational control and automation tools for AstrBot developers, enabling plugin debugging, configuration management, message sending, log monitoring, and bot restart capabilities through AI agents.