Discover Awesome MCP Servers

MCP Server: Youtube Subtitles Extractor

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

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.

Etherscan MCP Tool

Una herramienta que permite a los usuarios interactuar con datos de blockchain para recuperar el suministro total de tokens, los ID de cadena y los puntos finales RPC filtrados en diferentes redes de blockchain.

GitHub MCP Server

MCP server exposing tools to fetch GitHub repository details, issues, and commits, enabling AI agents to query and summarize GitHub data via local LLMs.

vmware-harden

VMware vSphere compliance and hardening — read-only baseline scanning plus drift detection across CIS, DISA STIG, vSphere SCG, China DJCP 2.0, and PCI-DSS frameworks. Includes LLM-powered remediation suggestions; apply-side gated through the vmware-pilot approval workflow.

fw-context-mcp

Exposes tools for AI assistants to query a persistent SQLite+FTS5 index of C/C++ symbols parsed from real build commands, enabling sub-millisecond lookup, full-text search, and natural-language explanation without hallucination.

gemini-mcp

MCP server that exposes tools for document judging and summarization using Gemini Flash Lite, designed to be called by Claude.

OpenPages Local MCP Server

Enables AI agents to securely interact with IBM OpenPages GRC platform through a standardized interface, supporting CRUD operations on objects like issues and controls.

Granola MCP Server

Enables searching and retrieving local Granola meeting notes, including transcripts, AI-generated summaries, and action items. It supports filtering by date or attendee and automatically reloads when the local Granola cache is updated.

Quotations MCP Server

A read-only MCP server that provides conversational querying of quotations data (counts, values, lookups) via tools like quotation_stats, search_quotations, and find_by_number.

Termii MCP

A hosted MCP server that enables AI assistants to send SMS and WhatsApp messages, run campaigns, and manage phonebooks through the Termii API using natural language.

MCP Server Scaffold Generator

Generates production-ready MCP server projects from a single command, providing project structure, tool examples, and optional advanced templates.

jira-worklog-mcp

MCP server for logging and checking Jira Cloud worklogs from AI agents such as Claude Code, Claude Desktop, Cursor, or any MCP client that supports stdio.

MS-MCP

Enables MCP clients to execute Materials Studio modeling and computation tasks via MaterialsScript runtime, with a local Dashboard for monitoring.

Simple MCP Server

A Python-based MCP server demonstrating tools for math calculations, time retrieval, and echo messages, along with resources and prompt templates.

asset-finder-mcp

All-in-one asset search MCP server for AI coding agents, enabling search for icons, logos, stock photos, vectors, and emoji from a single tool call.

AviBase MCP Server

A Model Context Protocol server that provides AI assistants with access to comprehensive bird data, enabling queries across taxonomic classifications, conservation statuses, and geographic distributions from the AviBase dataset.

@chaosintelligence/mcp

MCP server for Chaos Intelligence to access Capture thoughts and Resonate posts from AI tools like Claude and Cursor.

Masset MCP Tools

Provides honest A/B test verdicts using interactive cards, with statistical calculations for conversion rates, sample sizes, and Bayesian probability-to-beat.

PocketLantern

Blocker-aware decision layer for AI coding agents. Adds source-linked, time-sensitive blockers to AI technical choices — breaking changes, EOLs, lock-in, pricing shifts, and migration risk.

Yaver

P2P dev-machine MCP for phone-driven coding agents: hot reload, builds, deploys.

Tribunal TJSP: Processos do 1º Grau

Enables querying official first-degree court case information from the São Paulo Court of Justice (TJSP). It provides a read-only MCP tool, accessible via HTTP, with pay-per-use pricing and no platform credentials required.

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.

Document Organizer MCP

Enables agents to manage and organize local documents by listing, inspecting, extracting text, searching, and renaming files, with optional Google Drive integration.

chord-player-mcp

An MCP server that plays chord progressions via MIDI/WAV synthesis.

WhatsHot

WhatsHot MCP server aggregates trending hotlists, real-time news flashes, gold prices, and RSS feeds from 330+ sources, offering read-only tools to list sources, fetch current data, and query historical search and trend data via DuckDB.

PiR2 Academy Sheets Reader MCP

A read-only MCP server that lets Claude Desktop read bounded data from Google Sheets using the learner's own Google account, offering tools to check connection status, connect, and fetch spreadsheet metadata or specific ranges.

dav-mcp

Authenticated proxy for forwarding WebDAV requests to DAV servers, supporting CalDAV and CardDAV operations.

msf-harness

Enables AI agents to conduct authorized penetration tests by providing scope-enforced access to Metasploit Framework's RPC, with tools for reconnaissance, exploitation, session management, and post-exploitation.

Godot MCP Server

Bridges Claude Code with the Godot editor via WebSocket, enabling AI-driven game development commands such as scene tree inspection and code generation.