Discover Awesome MCP Servers

Clear Thought 1.5

Provides 30+ unified reasoning operations including systematic thinking, mental models, debugging approaches, statistical analysis, interactive notebooks, and advanced problem-solving frameworks for enhanced decision-making and complex reasoning tasks.

SAP Note Search MCP Server

This MCP server allows Cursor AI users to search and retrieve SAP Notes and Knowledge Base articles using SAP Passport authentication and Playwright automation.

Pipedrive MCP Server

Provides full CRUD access to Pipedrive CRM API, enabling Claude and other LLM applications to manage deals, persons, organizations, activities, notes, and leads with advanced filtering and fuzzy search capabilities.

Translations MCP Server

Enables automatic discovery and fast searching of translation files in projects, supporting partial/exact key-value matching with file watching and multiple translation file formats.

Structurizr DSL Debugger for Cursor

Okay, here's a translation of the English text you provided into Spanish, along with some considerations for clarity and context, especially regarding the technical terms: **Translation:** "Conectar un servidor MCP al DSL de Structurizer renderizado en el navegador y devolver mensajes de error relacionados con el análisis sintáctico (parsing) a Cursor IDE." **Explanation of Choices and Considerations:** * **"Mcp server"**: I've kept "MCP server" as is. MCP likely refers to a specific technology or system, and it's best to avoid translating acronyms unless there's a well-established Spanish equivalent. If you have more context about what MCP stands for, I can refine the translation. * **"to connect"**: "Conectar" is the direct translation of "to connect." * **"structurizer dsl"**: I've kept "Structurizer DSL" as is. DSL stands for Domain Specific Language. * **"rendered in the browser"**: "Renderizado en el navegador" is the standard translation. * **"and return error messages"**: "Y devolver mensajes de error" is the direct translation. * **"regarding parsing"**: "Relacionados con el análisis sintáctico (parsing)" is the most accurate translation. I've included "parsing" in parentheses because it's a common term in English and might be understood by some Spanish-speaking developers. * **"to Cursor IDE"**: "A Cursor IDE" is the direct translation. I've kept "Cursor IDE" as is, assuming it's a specific product name. **Alternative phrasing (slightly more formal):** "Establecer una conexión entre un servidor MCP y el DSL de Structurizer, renderizado en el navegador, y retornar mensajes de error de análisis sintáctico a Cursor IDE." **Key Considerations for Context:** * **Audience:** Who is the intended audience for this translation? If it's highly technical developers, you might be able to use more English terms directly. If it's a broader audience, more explanation might be needed. * **MCP Definition:** Knowing what "MCP" stands for would allow for a more precise translation. * **"Cursor IDE" Specifics:** Is "Cursor IDE" a well-known product in the Spanish-speaking developer community? If not, you might consider adding a brief description. I hope this helps! Let me know if you have any other questions or need further refinement.

Example MCP Server

A Node.js and TypeScript implementation that provides system information and health check tools for Claude Desktop. It serves as a boilerplate for building and integrating custom tools using the Model Context Protocol.

imessage-mcp

Provides read-only access to local iMessage databases on macOS for searching message history and analyzing conversation patterns. It includes 25 tools to explore contacts, attachments, reaction statistics, and messaging trends through natural language queries.

AppSignal MCP

Enables AI assistants to query and fetch error and performance monitoring data from AppSignal through the Model Context Protocol. Supports searching and retrieving detailed information about application errors and performance samples with flexible filtering options.

OneTool MCP

One MCP for developers — no tool tax, no context rot. 100+ tools including Brave, Google, Tavily, Context7, Excalidraw, AWS, Excel, Database, Playwright, Chrome DevTools, and more. Install once, access everything.

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.

VSAX MCP Server

Provides comprehensive access to the Kaseya VSAX (VSA 10) REST API v3 through 67 specialized tools. It enables users to manage devices, run workflows, execute scripts, and oversee organizational data using natural language and OData query support.

MCP Server: Youtube Subtitles Extractor

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

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.

KFabric

KFabric is a platform for building traceable and weighted documentary corpora from heterogeneous sources, prioritizing data quality before RAG implementation. It provides tools for document discovery, scoring, and fragment synthesis via an MCP server to prepare high-quality indexable artifacts.

MCP-ABI

Enables interaction with Ethereum-compatible smart contracts through their ABI, allowing both read operations (querying state) and write operations (executing transactions) dynamically based on the contract's interface.

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.

Hugo MCP Server

Un potente servidor MCP (Protocolo de Control de Modelos) para gestionar el generador de sitios estáticos Hugo.

Tessie MCP Extension

Enables Claude Desktop to access Tesla vehicle data through the Tessie API. Users can query their car's location, battery level, mileage, driving history, and charging status using natural language.

MIDI File MCP

Una potente herramienta MCP para analizar y manipular archivos MIDI que permite a los usuarios leer, analizar y modificar archivos MIDI a través de comandos en lenguaje natural, admitiendo operaciones como leer información del archivo, modificar pistas, añadir notas y establecer el tempo.

MCP Simple Server

A minimal reference implementation of an MCP server with two basic math tools (add and multiply), designed as a starting point for learning MCP protocol and deploying remote servers to cloud platforms.

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.

Postman MCP Generator

An MCP-compatible server that provides tools for integrating selected Postman API requests, allowing LLMs like Claude to interact with APIs through natural language.

ECharts MCP Server

A Model Context Protocol server that generates beautiful chart images from ECharts configurations, supporting various chart types with customizable dimensions.

MCP Fetch

Enables browser automation using Puppeteer through the MCP interface. Allows launching browsers, creating pages, and executing arbitrary JavaScript for web scraping, testing, and debugging tasks.

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.

Coreflux MQTT MCP Server

Connects to a Coreflux MQTT broker and provides tools for managing Coreflux commands (models, actions, rules, routes) and executing MQTT operations through natural language interactions with AI assistants.