Discover Awesome MCP Servers

Make Monitor MCP

Read-only MCP server for monitoring Make.com scenario errors from ChatGPT, enabling listing scenarios, viewing recent errors, and getting execution details.

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.

Cohort

An autonomous multi-agent orchestration layer that generates a bespoke software engineering organization for a given objective, runs parallel OpenCode workers in isolated git worktrees, and integrates reviewed code through a replan loop.

mcp-jordy

MCP server for managing the complete workflow of bank meeting minutes, from capture to approval and Word document generation.

Agentic Ads

Google AdSense for AI agents, enabling MCP server monetization by serving privacy-respecting contextual ads and earning 70% revenue share on clicks.

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.

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.

Nexus MCP

MCP server with X402 payment integration, enabling AI agents to access paid tools like weather, web search, and image generation with crypto payments via MetaMask on Base network.

jupiter-quotes

Enables fetching best swap quotes on Solana via Jupiter aggregator with pay-per-call x402 micropayments.

oh-my-cassette

Chat raw clips into a finished cut. Ingest local media, then drive a persistent multi-turn editing thread on the Cassette agent.

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.

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.

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.

cukaimax-tax-authority

CukaiMax Tax Authority is an MCP server that gives AI agents source-linked Malaysian individual tax information and deterministic draft preparation checks for YA2025 Form BE/B and YA2026 planning, via a public read-only Streamable HTTP endpoint.

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.

pons-hoodly MCP Server

Enables AI assistants to interact with the pons token launchpad on Robinhood Chain for token discovery, verification, price tracking, and trading with built-in safety controls and user approval.

ima-mcp-server

Wraps IMA knowledge base OpenAPI into a standard MCP server, enabling search, browse, read, and add web pages to knowledge bases from any MCP-compatible agent.

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.

Firmware MCP Server

A local stdio MCP server for embedded firmware automation that exposes tools to build, flash, reset devices, and capture serial logs through a device configuration file.

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.

PlantUML CSA MCP Server

Generate Control System Architecture (CSA) diagrams using PlantUML via the Model Context Protocol (MCP). Supports ISA-95 Purdue model, industrial symbols, and multiple protocols.

MCP Observer Server

A file monitoring server that tracks filesystem events and provides real-time notifications to AI assistants, enabling them to automatically respond to file changes without manual updates.

Amp MCP

Provides developer-focused documentation and tools for building applications on Amp, a high-performance blockchain ETL system. Includes guides, schemas, code examples, and troubleshooting resources for querying and transforming blockchain data.

Obsidian MCP Server

Enables users to search, list, and read notes in an Obsidian vault via a CLI or HTTP API, integrating with Obsidian for note management.

Discogs MCP Server

Enables finding the best-sounding pressing of an album and mood- and taste-based music recommendations via Discogs.

figma-console-mcp-autodocs

Enables AI assistants to read, create, and modify Figma designs, synchronize design tokens bidirectionally, and auto-document component-variant sets via Obra Autodocs integration.

MCP Bridge

Converts existing HTTP operations and cURL commands into structured, local-first MCP tools that AI agents can call safely.

VulnerabilityMCPServer

MCP server for retrieving vulnerability data (CVE) via HTTP, testable with MCP Inspector and OpenCode.