Discover Awesome MCP Servers

SpecLinter MCP

An AI-powered tool that transforms natural language specifications into structured, actionable development tasks with quality grading and Gherkin test scenarios. It also features semantic similarity detection to prevent duplicate work and validates implementations against original requirements.

Decision Tree MCP Server

Un servidor MCP de Node.js que carga y gestiona árboles de decisión desde archivos .rtdq y proporciona funcionalidad básica de lista de tareas pendientes utilizando Redis para el almacenamiento.

SailPoint MCP Server

An MCP server that enables interaction with SailPoint IdentityNow and Identity Security Cloud for identity governance and access management. It provides comprehensive tools to manage identities, accounts, roles, workflows, and certifications through API integration.

Breadcrumb MCP Server

Enables AI assistants to interact with the Breadcrumbs project memory system, allowing creation and management of project documentation including sessions, components, ADRs, patterns, and providing search capabilities across project knowledge.

Threads MCP Server

An MCP server that exposes Threads CLI data for managing hierarchical threads, containers, and progress logs. It enables users to create, organize, and track task history while maintaining compatibility with the Threads CLI storage.

WhatsApp Cloud API MCP Server

Enables AI agents to send WhatsApp messages, templates, and retrieve media through the WhatsApp Cloud API. Provides webhook handling and seamless integration with Meta's WhatsApp Business platform.

KIMP MCP Server

Enables users to query Kimchi Premium (KIMP) data for cryptocurrencies, showing the price difference between Korean and international exchanges for assets like Bitcoin and Ethereum.

MCP Calculator Demo

A simple demonstration MCP server built with FastMCP that exposes basic calculator operations (add, subtract, multiply, divide) as tools for MCP clients like GitHub Copilot Agent mode.

EdgeOne Pages MCP Server

Enables AI assistants to deploy and manage static websites directly through EdgeOne Pages. This self-hosted solution allows for direct file management and website hosting using EdgeOne's infrastructure and KV storage.

Confluence Knowledge Base MCP Server

Turns Confluence documentation into an AI-powered knowledge base, enabling natural language questions about your systems with answers retrieved from your actual documentation through semantic search.

OmniMCP

A semantic router that provides unified access to multiple MCP servers through a single tool interface, using vector search to discover and execute tools across your entire MCP ecosystem while minimizing context token usage.

X (Twitter) MCP server

X (Twitter) MCP server

Remote MCP Server Authless

A deployable MCP server on Cloudflare Workers that doesn't require authentication, allowing users to create and use custom AI tools through the Model Context Protocol.

Ghost CMS MCP Server

Enables comprehensive automation and management of Ghost CMS blogs through AI assistants, supporting full CRUD operations for posts, pages, members, media uploads, and bulk content management with enterprise-grade security and performance features.

SimBrief Flight Planning MCP Server

Enables access to SimBrief flight planning data through Claude Desktop with secure Google OAuth authentication. Provides tools to retrieve flight plans, dispatch briefings, NOTAMs, weather data, and other aviation planning information.

ton-mcp

Este servidor MCP te permite interactuar con la cadena de bloques TON.

Dust MCP Server

A TypeScript-based MCP server that enables advanced agent conversations and workspace management via the Dust platform. It provides tools for managing messaging sessions, retrieving agent configurations, and interacting with Dust assistants.

MCP Server: Youtube Subtitles Extractor

Este es un servidor MCP que extrae subtítulos de un enlace de YouTube dado.

Rust MCP Filesystem

Rust MCP Filesystem

Hetzner Cloud MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los modelos de lenguaje gestionar recursos de Hetzner Cloud a través de funciones estructuradas, incluyendo servidores, volúmenes, firewalls y claves SSH.

PySqlitMCP

Enables comprehensive SQLite database management through natural language, including database creation, table operations, data CRUD operations, backup/restore functionality, and CSV import/export capabilities.

Trafilatura MCP Server

Enables web scraping and content extraction from URLs using the Trafilatura library. Extracts main text content and metadata (title, author, date) from web pages with configurable options for comments and tables.

MCP Server Sentry

Aquí tienes una implementación en TypeScript de un servidor de Protocolo de Contexto de Modelo que se conecta al servicio de seguimiento de errores Sentry, permitiendo a los modelos de IA consultar y analizar informes de errores y eventos: ```typescript import * as Sentry from "@sentry/node"; import { ProfilingIntegration } from "@sentry/profiling-node"; import { ModelContextProtocolServer } from "@your-library/model-context-protocol"; // Reemplaza con tu librería de MCP import { z } from "zod"; // Para validación de datos // Configuración de Sentry Sentry.init({ dsn: "TU_DSN_DE_SENTRY", // Reemplaza con tu DSN de Sentry integrations: [ new ProfilingIntegration(), ], // Set tracesSampleRate to 1.0 to capture 100% // of transactions for performance monitoring. tracesSampleRate: 1.0, // Set `profilesSampleRate` to 1.0 to profile 100% // of sampled transactions. profilesSampleRate: 1.0, environment: process.env.NODE_ENV || "development", }); // Definición de esquemas de validación con Zod const querySchema = z.object({ query: z.string().describe("Consulta en lenguaje natural sobre los errores en Sentry."), filters: z.object({ environment: z.string().optional().describe("Entorno (ej: production, staging)."), level: z.enum(["error", "warning", "info", "debug", "fatal"]).optional().describe("Nivel del error."), dateRange: z.object({ start: z.string().datetime().optional().describe("Fecha de inicio (ISO 8601)."), end: z.string().datetime().optional().describe("Fecha de fin (ISO 8601)."), }).optional().describe("Rango de fechas para filtrar."), }).optional().describe("Filtros para la consulta."), }); const responseSchema = z.object({ results: z.array(z.object({ id: z.string().describe("ID del evento en Sentry."), message: z.string().describe("Mensaje del error."), level: z.string().describe("Nivel del error."), environment: z.string().describe("Entorno del error."), timestamp: z.string().datetime().describe("Fecha y hora del error (ISO 8601)."), url: z.string().url().describe("URL del evento en Sentry."), })).describe("Resultados de la consulta."), summary: z.string().describe("Resumen de los resultados de la consulta."), }); // Función para consultar Sentry async function querySentry(query: string, filters: any): Promise<any> { try { // Construye la consulta a la API de Sentry basándote en la consulta y los filtros. // Esto requerirá usar la API de Sentry (https://docs.sentry.io/api/) // y posiblemente convertir la consulta en lenguaje natural en una consulta más estructurada. // Ejemplo simplificado (requiere implementación real): const sentryQuery = { query: query, environment: filters?.environment, level: filters?.level, start: filters?.dateRange?.start, end: filters?.dateRange?.end, }; // Reemplaza esto con la lógica real para consultar la API de Sentry // y transformar los resultados al formato esperado. const sentryResults = await fetchSentryData(sentryQuery); // Formatea los resultados para que coincidan con el responseSchema const formattedResults = sentryResults.map((result: any) => ({ id: result.id, message: result.message, level: result.level, environment: result.environment, timestamp: result.timestamp, url: `https://sentry.io/organizations/${Sentry.getCurrentHub()?.getClient()?.getOptions().organization}/issues/${result.id}/events/latest/`, // Construye la URL del evento })); // Genera un resumen de los resultados (esto podría usar un modelo de lenguaje) const summary = await generateSummary(formattedResults, query); return { results: formattedResults, summary: summary, }; } catch (error) { Sentry.captureException(error); console.error("Error al consultar Sentry:", error); throw new Error("Error al consultar Sentry: " + error); } } // Función placeholder para obtener datos de Sentry (requiere implementación real) async function fetchSentryData(query: any): Promise<any[]> { // TODO: Implementar la lógica para consultar la API de Sentry. // Esto podría involucrar la autenticación y la paginación de resultados. console.log("Consultando Sentry con:", query); return []; // Retorna un array vacío por ahora. } // Función placeholder para generar un resumen (requiere implementación real) async function generateSummary(results: any[], query: string): Promise<string> { // TODO: Implementar la lógica para generar un resumen de los resultados. // Esto podría usar un modelo de lenguaje para generar un resumen conciso. console.log("Generando resumen para:", results, query); return "Resumen de los resultados."; } // Creación del servidor de Model Context Protocol const server = new ModelContextProtocolServer({ name: "SentryErrorAnalyzer", description: "Analiza errores y eventos de Sentry para ayudar a los modelos de IA a comprender problemas en el software.", version: "1.0.0", querySchema: querySchema, responseSchema: responseSchema, handler: async (request: any) => { try { const parsedRequest = querySchema.parse(request); // Valida la solicitud const result = await querySentry(parsedRequest.query, parsedRequest.filters); return responseSchema.parse(result); // Valida la respuesta } catch (error: any) { Sentry.captureException(error); console.error("Error en el handler:", error); throw new Error("Error en el handler: " + error.message); } }, }); // Inicia el servidor (ejemplo) const port = process.env.PORT || 3000; server.listen(port, () => { console.log(`Servidor MCP escuchando en el puerto ${port}`); }); // Manejo de errores globales process.on("unhandledRejection", (error) => { Sentry.captureException(error); console.error("Unhandled promise rejection:", error); }); process.on("uncaughtException", (error) => { Sentry.captureException(error); console.error("Uncaught exception:", error); }); ``` **Explicación del código:** 1. **Importaciones:** * `@sentry/node`: Librería para interactuar con Sentry desde Node.js. * `@sentry/profiling-node`: Librería para el profiling de rendimiento en Sentry. * `@your-library/model-context-protocol`: **Debes reemplazar esto con la librería real que estés usando para el Protocolo de Contexto de Modelo (MCP).** Esta librería proporciona la base para crear un servidor MCP. * `zod`: Librería para la validación de datos. 2. **Configuración de Sentry:** * `Sentry.init()`: Inicializa el cliente de Sentry. * `dsn`: **Reemplaza `TU_DSN_DE_SENTRY` con tu DSN (Data Source Name) de Sentry.** El DSN es la URL que Sentry usa para recibir eventos. * `integrations`: Configura las integraciones de Sentry, incluyendo el profiling. * `tracesSampleRate`: Define la tasa de muestreo para las transacciones (para el monitoreo del rendimiento). * `profilesSampleRate`: Define la tasa de muestreo para los perfiles (para el profiling del rendimiento). * `environment`: Define el entorno (ej: `production`, `staging`, `development`). 3. **Esquemas de Validación con Zod:** * `querySchema`: Define la estructura esperada para la consulta que recibe el servidor MCP. Incluye: * `query`: La consulta en lenguaje natural. * `filters`: Un objeto opcional con filtros para la consulta: * `environment`: El entorno. * `level`: El nivel del error. * `dateRange`: Un rango de fechas. * `responseSchema`: Define la estructura esperada para la respuesta que devuelve el servidor MCP. Incluye: * `results`: Un array de objetos, cada uno representando un evento de Sentry. * `id`: El ID del evento. * `message`: El mensaje del error. * `level`: El nivel del error. * `environment`: El entorno del error. * `timestamp`: La fecha y hora del error. * `url`: La URL del evento en Sentry. * `summary`: Un resumen de los resultados. 4. **`querySentry()` Función:** * Esta función es el corazón de la integración con Sentry. Recibe la consulta en lenguaje natural y los filtros. * **TODO: Implementar la lógica para convertir la consulta en lenguaje natural y los filtros en una consulta válida para la API de Sentry.** Esto es la parte más compleja y dependerá de la API de Sentry y de cómo quieras permitir que los modelos de IA consulten los datos. Podrías usar un modelo de lenguaje para traducir la consulta en lenguaje natural a una consulta más estructurada. * **TODO: Implementar la lógica para consultar la API de Sentry.** Esto requerirá autenticación y posiblemente paginación de resultados. * Formatea los resultados de la API de Sentry para que coincidan con el `responseSchema`. * Genera un resumen de los resultados. **TODO: Implementar la lógica para generar un resumen. Podrías usar un modelo de lenguaje para esto.** * Maneja los errores y los reporta a Sentry. 5. **`fetchSentryData()` Función (Placeholder):** * **TODO: Implementar la lógica real para consultar la API de Sentry.** Este es un placeholder. 6. **`generateSummary()` Función (Placeholder):** * **TODO: Implementar la lógica real para generar un resumen de los resultados.** Este es un placeholder. 7. **Creación del Servidor MCP:** * `new ModelContextProtocolServer()`: Crea una instancia del servidor MCP. * `name`: El nombre del servidor. * `description`: Una descripción del servidor. * `version`: La versión del servidor. * `querySchema`: El esquema de validación para las consultas. * `responseSchema`: El esquema de validación para las respuestas. * `handler`: La función que maneja las consultas. Esta función: * Valida la solicitud usando `querySchema.parse()`. * Llama a `querySentry()` para obtener los resultados de Sentry. * Valida la respuesta usando `responseSchema.parse()`. * Maneja los errores y los reporta a Sentry. 8. **Inicia el Servidor:** * `server.listen()`: Inicia el servidor en un puerto específico. 9. **Manejo de Errores Globales:** * `process.on("unhandledRejection", ...)`: Captura las promesas rechazadas no manejadas. * `process.on("uncaughtException", ...)`: Captura las excepciones no capturadas. * En ambos casos, reporta el error a Sentry y lo imprime en la consola. **Puntos Clave:** * **Reemplaza los placeholders:** Las funciones `fetchSentryData()` y `generateSummary()` son placeholders y necesitan ser implementadas con la lógica real para interactuar con la API de Sentry y generar resúmenes. * **Autenticación con Sentry:** Asegúrate de configurar la autenticación correcta para acceder a la API de Sentry. Esto podría involucrar el uso de tokens de autenticación. * **Consulta en Lenguaje Natural:** La parte más desafiante es convertir la consulta en lenguaje natural en una consulta válida para la API de Sentry. Considera usar un modelo de lenguaje para esto. * **Validación de Datos:** La validación de datos con Zod es importante para asegurar que las solicitudes y respuestas tengan el formato correcto. * **Manejo de Errores:** El manejo de errores es crucial para asegurar que el servidor sea robusto y que los errores se reporten a Sentry. * **Librería MCP:** Asegúrate de usar la librería correcta para el Protocolo de Contexto de Modelo. Reemplaza `@your-library/model-context-protocol` con la librería real. * **Seguridad:** Considera las implicaciones de seguridad al permitir que los modelos de IA accedan a los datos de Sentry. Asegúrate de implementar las medidas de seguridad adecuadas para proteger los datos sensibles. Este código proporciona una base sólida para construir un servidor MCP que se conecta a Sentry. La implementación real dependerá de tus necesidades específicas y de la API de Sentry. Recuerda reemplazar los placeholders y configurar la autenticación correctamente.

Derive MCP

Provides comprehensive access to Lyra Finance's Derive API with 31+ tools for trading options, perpetuals, and spot markets, including real-time market data, historical analytics, account management, and order execution.

Sherlog MCP

Provides persistent IPython shell sessions per conversation with DataFrame-centric architecture, enabling stateful data analysis, CLI tool execution, and integration of external MCP servers within the same workspace context.

Taiwan Central Weather Administration MCP Server

Un servidor de Protocolo de Contexto de Modelo (MCP) que interactúa con la API de la Administración Meteorológica Central (CWA) de Taiwán.

MCP Reasoning Engine

A production-ready reasoning engine that integrates Claude AI with specialized MCP tools for knowledge retrieval, schema validation, and domain-specific rubric evaluation. It enables structured RAG-based analysis across legal, health, and science domains via a RESTful API.