Discover Awesome MCP Servers

Hue MCP Server

Enables AI assistants to interact with Hadoop Hue for executing SQL queries using Hive, SparkSQL, or Impala and managing HDFS files. It supports directory browsing, file transfers, and exporting query results to CSV through the Model Context Protocol.

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.

Bluesky MCP (Model Context Protocol)

Bluesky MCP es un servidor basado en Go para la red social Bluesky, que ofrece funciones impulsadas por IA a través de puntos finales de la API JSON-RPC 2.0. Admite una configuración flexible y sigue las mejores prácticas de la industria en cuanto a seguridad, rendimiento y manejo de errores.

AI Video Generator MCP Server

Servidor de Protocolo de Contexto de Modelo que permite generar videos a partir de indicaciones de texto y/o imágenes utilizando modelos de IA (Luma Ray2 Flash y Kling v1.6 Pro) con parámetros configurables como la relación de aspecto, la resolución y la duración.

Remote MCP Server Authless

A deployable Model Context Protocol server on Cloudflare Workers that doesn't require authentication, allowing tools to be added and used from Cloudflare AI Playground or Claude Desktop.

mcp-jira-stdio

MCP server for Jira integration with stdio transport. Enables reading, writing, and managing Jira issues and projects directly from Claude Desktop. Supports issue creation, updates, comments, JQL search, and project management.

Ethora MCP Server

Enables integration with the Ethora platform through user authentication, registration, and application management operations. Supports creating, updating, deleting, and listing applications within the Ethora service.

Logseq MCP Tools

Un servidor de Protocolo de Contexto de Modelo que permite a los agentes de IA interactuar con gráficos de conocimiento locales de Logseq, admitiendo operaciones como la creación/edición de páginas y bloques, la búsqueda de contenido y la gestión de entradas de diario.

baidu-ai-search

I am sorry, I do not have the capability to directly access the internet or use specific search engines like Baidu. I am a language model, not a web browser. Therefore, I cannot perform web searches for you.

NotionMCP

Enables AI assistants to search, read, summarize, and analyze sentiment of Notion pages and databases, turning your Notion workspace into an intelligent, queryable knowledge system.

ssh-mcp-server

Enables secure remote command execution and bidirectional file transfers on SSH servers through the Model Context Protocol. It features robust security controls including command whitelisting, credential isolation, and support for multiple SSH connection profiles.

FastAPI MCP SSE

Demonstrates how to integrate Model Context Protocol with Server-Sent Events (SSE) in a FastAPI web application, including a weather service example with tools for getting forecasts and alerts.

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.

Financial MCP Server

Provides access to real-time currency exchange rates, live stock market data via Alpha Vantage, and local transaction analysis from CSV databases. It enables AI assistants to perform currency conversions, stock comparisons, and budget tracking through natural language.

LangSmith MCP Server

Enables language models to access LangSmith observability platform features including fetching conversation history, managing prompts, retrieving traces and runs, working with datasets and examples, and analyzing experiments.

Brazilian ZIP Code Lookup

Enables lookup of Brazilian addresses by CEP (postal code) using the ViaCEP API, returning formatted address information including street, neighborhood, city, and state.

PocketBase MCP Server

Enables MCP-compatible applications to directly interact with PocketBase databases for collection management, record operations, schema generation, and data analysis.

FLUX MCP Server

Exposes Replicate's FLUX image generation models to Claude, enabling text-to-image generation, image variations, inpainting, and edge-guided creation with 6 different FLUX models.

Vercel MCP Relay Server

Enables AI assistants to interact with the Vercel REST API to manage projects, deployments, domains, environment variables, and teams through natural language commands.

Gemini RAG MCP Server

Enables creation and querying of knowledge bases using Google's Gemini API File Search feature, allowing AI applications to upload documents and retrieve information through RAG (Retrieval-Augmented Generation).

MCSManager MCP Server

Enables management of Minecraft servers through the MCSManager API. Supports executing server commands, checking player status, retrieving server information, and controlling game settings like weather.

Memos MCP Server

Un servidor de Protocolo de Contexto de Modelo (MCP) para la API de Memos con capacidades de búsqueda, creación, recuperación y listado de etiquetas.

ChiCTR MCP Server

Enables querying clinical trial information from the Chinese Clinical Trial Registry (ChiCTR) by searching trials with keywords, registration numbers, or years, and retrieving detailed trial information.

Remote MCP Server

A Cloudflare Workers-based MCP server that allows users to deploy and customize tools without authentication requirements, compatible with Cloudflare AI Playground and Claude Desktop.

GitHub Configuration

Un servidor de Protocolo de Contexto de Modelo (MCP) para la aplicación de gestión de tareas TickTick.

EntityIdentification

A MCP server that helps determine if two sets of data belong to the same entity by comparing both exact and semantic equality through text normalization and language model integration.

MasterGo Magic MCP

Connects AI models to MasterGo design tools, enabling retrieval of DSL data, component documentation, and metadata from MasterGo design files for structured component development workflows.