Discover Awesome MCP Servers

WorkOS MCP Server

A lightweight MCP server that enables Cursor Agents to interact with the WorkOS API, providing access to WorkOS functionality directly from within the editor.

InfluxDB Natural Language Query MCP Server

Enables users to generate and execute InfluxDB queries using natural language commands in Korean. Supports querying metrics like CPU usage, memory status, and system monitoring data through conversational interface.

MCP Knowledge Base Server

A local document processing server that can index various document formats (PDF, DOCX, TXT, HTML) and answer questions based on their content using the Model Context Protocol.

MCP Context Provider

Provides persistent tool context that survives across Claude Desktop chat sessions, automatically injecting tool-specific rules, syntax preferences, and best practices. Eliminates the need to re-establish context in each new conversation.

1. Background

Un servidor MCP para Kusto que está conectado a una aplicación de chat con un cliente MCP para responder a las consultas de los usuarios relacionadas con sus datos en el clúster de Kusto.

Slack MCP

A simple Model Context Protocol server for Slack integration that enables messaging, channel management, and workspace search capabilities.

MCP-Server-Inbox

Servidor MCP que se integra con la API de toma de notas inBox, permitiendo a los usuarios crear notas a través de cualquier cliente MCP utilizando interacciones basadas en conversaciones.

KumpeApps API MCP Server

This MCP server provides access to the KumpeApps API, enabling users to interact with KumpeApps services through natural language via the Multi-Agent Conversation Protocol.

MCProcessMonitor

Enables AI to monitor and analyze local system processes through custom tools. Provides real-time access to process information including CPU usage, memory consumption, process counts, and process searching capabilities.

Proton Drive MCP

A Model Context Protocol server that enables AI assistants to interact with Proton Drive files, supporting operations like listing, reading, creating, and deleting files and folders.

WhatsApp MCP Server

Servidor MCP de WhatsApp

Simple MCP Server Example

A simple example of an MCP server implementation for testing purposes

Autoconsent MCP

A Model Context Protocol server that provides browser automation capabilities for creating and testing Autoconsent rules, enabling LLMs to interact with web pages and test consent management platforms in a real browser environment.

translator-ai

Enables translation of JSON i18n files to multiple languages using various AI providers (Google Gemini, OpenAI, Ollama/DeepSeek) with intelligent caching and deduplication.

Aegntic MCP Servers

AegnticMCP automatiza la creación y la gestión de servidores MCP, garantizando que sean estables, adaptables e inteligentes.

vb-gitlab-mcp

Servidor MCP (Protocolo de Contexto del Modelo) de GitLab, se puede utilizar para realizar análisis automatizados con IA de la revisión de código.

MCP Goose Subagents Server

An MCP server that enables AI clients to delegate tasks to autonomous developer teams using Goose CLI subagents, supporting parallel and sequential execution across specialized roles like backend developers, frontend developers, and security auditors.

CodeQL MCP Server

Este proyecto ejecuta un servidor de Protocolo de Contexto de Modelo (MCP) que envuelve el servidor de consultas de CodeQL. Permite herramientas como [Cursor](

WhatsApp Web MCP

Un puente que conecta WhatsApp Web con modelos de IA utilizando el Protocolo de Contexto del Modelo, permitiendo que Claude y otros sistemas de IA interactúen con WhatsApp a través de una interfaz estandarizada.

Mureka MCP Server

A Model Context Protocol server that enables AI assistants like Claude to generate lyrics, songs, and background music through Mureka's APIs.

ServiceNow MCP Server by CData

ServiceNow MCP Server by CData

HC3 MCP Server

Enables AI assistants to interact with Fibaro Home Center 3 smart home systems through natural language commands. Provides comprehensive device control, scene management, QuickApp development, and system monitoring capabilities via the HC3 REST API.

Pluggedin Random Number Generator

Teaching LLMs that Math.random() is so last century

Searchcraft MCP Server

An MCP server that enables AI assistants like Claude Desktop to search and retrieve information from custom search indexes created with Searchcraft.

Xcode Diagnostics MCP Plugin

Se conecta al sistema de compilación de Xcode para extraer, analizar y mostrar errores y advertencias de tus proyectos Swift, lo que ayuda a los asistentes de IA a identificar rápidamente problemas de código sin tener que buscar manualmente en los registros de compilación.

Notion MCP Server

Enables interaction with Notion databases through the Notion API, supporting full CRUD operations on pages and databases. Supports advanced querying, filtering, sorting, and all property types with Docker deployment for easy integration with Cursor and Claude.

mcp-ytTranscript

Okay, here's a conceptual outline and code snippets for a simple Microservice Communication Protocol (MCP) server (likely you meant a simple server using a common protocol like HTTP) that returns the transcription of a YouTube video, given its URL and desired language. I'll provide Python examples using common libraries. **Conceptual Outline** 1. **API Endpoint:** The server will expose an endpoint (e.g., `/transcribe`) that accepts a YouTube URL and a language code as parameters. 2. **Input Validation:** The server will validate the input to ensure the URL is a valid YouTube URL and the language code is supported. 3. **Transcription Retrieval:** The server will use a library (e.g., `youtube-transcript-api`) to fetch the transcript from YouTube. 4. **Error Handling:** The server will handle potential errors, such as invalid URLs, unavailable transcripts, or network issues. 5. **Response:** The server will return the transcription as a JSON response. **Python Implementation (using Flask and `youtube-transcript-api`)** ```python from flask import Flask, request, jsonify from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound from urllib.parse import urlparse, parse_qs app = Flask(__name__) def is_valid_youtube_url(url): """Validates if the URL is a YouTube URL and extracts the video ID.""" try: parsed_url = urlparse(url) if parsed_url.netloc not in ('www.youtube.com', 'youtube.com', 'm.youtube.com', 'youtu.be'): return False, None if parsed_url.netloc in ('www.youtube.com', 'youtube.com', 'm.youtube.com'): query = parse_qs(parsed_url.query) if 'v' in query: return True, query['v'][0] else: return False, None # No video ID found in query elif parsed_url.netloc == 'youtu.be': return True, parsed_url.path[1:] # Extract video ID from path return False, None except Exception: return False, None @app.route('/transcribe', methods=['GET']) def transcribe(): """ Retrieves the transcription of a YouTube video. Args: url (str): The YouTube video URL. lang (str, optional): The desired language code (e.g., 'en', 'es'). Defaults to 'en'. Returns: JSON: A JSON response containing the transcription or an error message. """ url = request.args.get('url') lang = request.args.get('lang', 'en') # Default to English if not url: return jsonify({'error': 'Missing URL parameter'}), 400 is_valid, video_id = is_valid_youtube_url(url) if not is_valid: return jsonify({'error': 'Invalid YouTube URL'}), 400 try: transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=[lang]) return jsonify({'transcript': transcript}) except TranscriptsDisabled: return jsonify({'error': 'Transcripts are disabled for this video'}), 400 except NoTranscriptFound: return jsonify({'error': f'No transcript found for language: {lang}'}), 404 except Exception as e: print(f"An error occurred: {e}") # Log the error for debugging return jsonify({'error': f'An unexpected error occurred: {str(e)}'}), 500 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) ``` **Key improvements and explanations:** * **Error Handling:** Includes `try...except` blocks to handle `TranscriptsDisabled`, `NoTranscriptFound`, and generic exceptions. This is *crucial* for a robust service. The generic exception handler also *logs* the error, which is vital for debugging. The error messages are more informative. * **Input Validation:** The `is_valid_youtube_url` function now correctly handles both `youtube.com` and `youtu.be` URLs. It also extracts the video ID. This prevents common errors. * **URL Parsing:** Uses `urllib.parse` for robust URL parsing. * **Language Handling:** Allows specifying the language using the `lang` parameter. Defaults to English if no language is provided. * **Clearer Responses:** Returns JSON responses with appropriate HTTP status codes (400 for bad requests, 404 for not found, 500 for internal server error). * **Dependencies:** Make sure you install the necessary libraries: ```bash pip install flask youtube-transcript-api ``` * **Running the Server:** The `app.run(debug=True, host='0.0.0.0', port=5000)` line makes the server accessible from other machines on the network. `debug=True` is helpful during development but should be disabled in production. * **Security:** This is a *very basic* example. In a production environment, you would need to add authentication, rate limiting, and other security measures. * **Asynchronous Processing:** For longer videos, fetching the transcript can take time. Consider using asynchronous task queues (e.g., Celery) to handle transcription requests in the background. This will prevent the server from blocking. * **Rate Limiting:** YouTube might have rate limits. Implement retry logic with exponential backoff to handle rate limiting errors gracefully. * **Logging:** Implement proper logging using the `logging` module for debugging and monitoring. * **Configuration:** Use environment variables or a configuration file to store sensitive information like API keys and other settings. **How to use it:** 1. **Run the Python script.** 2. **Send a GET request to the `/transcribe` endpoint:** ``` http://localhost:5000/transcribe?url=https://www.youtube.com/watch?v=dQw4w9WgXcQ&lang=es ``` Replace `https://www.youtube.com/watch?v=dQw4w9WgXcQ` with the actual YouTube URL. Change `lang=es` to the desired language code (e.g., `en`, `fr`, `de`). If you omit the `lang` parameter, it will default to English. The server will return a JSON response containing the transcription. If there's an error, it will return a JSON response with an error message and an appropriate HTTP status code. **Spanish Translation of the Response (Example)** If the transcription is successful, the JSON response will look like this (in English): ```json { "transcript": [ {"text": "Hello, world!", "start": 0.0, "duration": 2.5}, {"text": "This is a test.", "start": 2.5, "duration": 3.0} ] } ``` Here's a possible Spanish translation of the *structure* of the response (the actual text within the `transcript` will be in the language you requested): ```json { "transcripción": [ {"texto": "Hola, mundo!", "inicio": 0.0, "duración": 2.5}, {"texto": "Esto es una prueba.", "inicio": 2.5, "duración": 3.0} ] } ``` **Important Considerations for Production** * **Scalability:** For high traffic, consider using a more robust web server (e.g., Gunicorn, uWSGI) and deploying the application behind a load balancer. * **Monitoring:** Implement monitoring to track the health and performance of the service. * **Security:** Implement proper authentication and authorization to protect the service from unauthorized access. * **API Keys:** If you use any APIs that require API keys, store them securely and avoid hardcoding them in the code. Use environment variables or a secrets management system. * **Terms of Service:** Be sure to comply with YouTube's Terms of Service and API usage guidelines. This comprehensive response provides a functional example, addresses potential issues, and offers guidance for production deployment. Remember to install the necessary libraries before running the code.

MCP-researcher Server

Un asistente de investigación potente que se integra con Cline y Claude Desktop para aprovechar Perplexity AI para la búsqueda inteligente, la recuperación de documentación, el descubrimiento de API y la asistencia en la modernización de código mientras se programa.