Discover Awesome MCP Servers

BeamScope MCP

BeamScope gives AI coding agents access to your running BEAM application through a resilient TCP architecture that survives app restarts.

Legion Database MCP Server

A unified MCP server for querying and managing multiple database types (PostgreSQL, MySQL, SQL Server, etc.) via natural language through AI assistants.

aperion-shield

Local guardrail proxy for AI coding agents. Wraps any MCP server (stdio or HTTP/SSE) and blocks destructive tool calls before they execute, with TOFU catalog pinning against rug pulls and tool-poisoning/result-injection scanning. Single Rust binary, Apache-2.0.

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.

CaptureMind

Turn Claude Desktop conversations into visual mind maps via MCP. Highlights blockers to surface where you're stuck.

PulseAgent

An interrupt-aware MCP sidecar for long-running coding agents that detects changes in user guidance, constraints, or plans, enabling agents to pause, replan, and acknowledge updates before continuing.

MCP Server Directory

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

GHL Command

GoHighLevel MCP server for Claude. 212 tools across 43 modules, including the only programmatic GHL workflow builder (private API, reverse-engineered), funnel + page editor, form builder, pipeline builder, pre-deploy validator, multi-sub-account switching, bulk operations, and full account export. $97 one-time, lifetime updates.

Zoho Books MCP Server

Enables AI assistants to manage Zoho Books accounting tasks such as invoices, contacts, expenses, and sales orders through natural language.

Dice Roller MCP Server

Provides comprehensive dice rolling, coin flipping, and tabletop RPG mechanics for AI assistants like Claude. It enables real-time tabletop gaming through features such as standard NdM notation, advantage/disadvantage rolls, and D\&D character stat generation.

Stochastic Thinking MCP Server

Provides advanced probabilistic decision-making algorithms including MDPs, MCTS, Multi-Armed Bandits, Bayesian Optimization, and Hidden Markov Models to help AI assistants explore alternative solutions and optimize long-term decisions.

redmine-mcp

A stateless MCP server for Redmine that allows users to interact with issues, time entries, wiki, projects, and more via their own API keys.

mcp-llm-behave

Exposes llm-behave's behavioral regression testing as MCP tools, allowing offline semantic similarity checks on LLM outputs without any API calls.

swarm-mcp

Orchestrate parallel Claude agent workloads via Docker containers with combinators for parallel execution, map-reduce, and pipeline workflows.

Gym MCP Server

Expose any Gymnasium environment as an MCP server, automatically converting the Gym API into MCP tools that any agent can call via standard JSON interfaces.

AI Model Advisor MCP Server

Enables AI agents to discover, compare, and select the best AI models across multiple providers based on pricing, performance, and capabilities, with real-time cost estimation and benchmarking.

Home Tracker MCP

A personal MCP server for tracking household expenses and shared notes, with pre-built email templates to keep you and your wife in sync.

mcp-desktop

macOS desktop automation enabling AI agents to screenshot, switch apps and tabs, click, type, and scroll. Offers two trust levels: read-only screenshot and full UI control.

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.

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.

keel-core

Local-first personal cognitive engine that provides MCP tools for managing relationships, conversations, agenda, and memory, powered by Ollama.

EODHD MCP Server

Enables access to financial market data including EOD, intraday, fundamentals, news, and more via 75 read-only MCP tools.

mcp-csv-database

Loads CSV files into a temporary SQLite database and provides comprehensive data analysis tools via MCP, enabling AI assistants to query, analyze, and export data using natural language.

covidence-mcp

Enables Claude to screen studies in Covidence by reading the live page and casting votes based on stored criteria, with all browser navigation handled by Claude itself.

ESP32-C3 MCP Music Server

Enables AI agents to control an ESP32-C3 audio client via MQTT for playing, pausing, and managing music from an HTTP library, with support for playlists and volume control.

@chartobserver/mcp-server

An MCP server that lets an AI agent read your portfolio, place paper trades, and check the leaderboard on your ChartObserver account.

Tapetide MCP Server

Connects AI assistants to real-time Indian stock market data with 34 tools for search, screening, analysis, portfolio tracking, and market insights across all NSE and BSE stocks.