Discover Awesome MCP Servers

Google Workspace MCP Server

Provides 84 specialized tools for comprehensive Google Workspace automation including Gmail, Calendar, and Drive operations. Features persistent background service with centralized OAuth authentication through Composio for secure enterprise integration.

Zerodha Kite MCP Server

Implements a Model Context Protocol server that connects with Zerodha Kite API, allowing users to buy/sell stocks and retrieve holdings and positions information.

MCP Server Demo in python

Okay, here's a basic implementation of a Model Communication Protocol (MCP) server in Python using Server-Sent Events (SSE) for network transport. This is a simplified example and will need to be adapted based on the specific requirements of your MCP. ```python import asyncio import json import uuid from aiohttp import web # In-memory model (replace with your actual model) model_state = {"value": 0} # Function to simulate model processing (replace with your actual model logic) async def process_model(data): """Simulates model processing based on received data.""" global model_state try: # Assuming data is a dictionary with instructions instruction = data.get("instruction") if instruction == "increment": model_state["value"] += 1 elif instruction == "decrement": model_state["value"] -= 1 elif instruction == "set": new_value = data.get("value") if isinstance(new_value, int): model_state["value"] = new_value else: print("Invalid value for 'set' instruction.") else: print(f"Unknown instruction: {instruction}") # Simulate some processing time await asyncio.sleep(0.1) # Simulate processing delay return model_state # Return the updated model state except Exception as e: print(f"Error processing model: {e}") return None # SSE event stream handler async def sse_handler(request): """Handles SSE connections and sends model updates.""" queue = asyncio.Queue() request.app['websockets'][request] = queue # Store the queue for this connection response = web.StreamResponse( status=200, headers={ 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', } ) await response.prepare(request) try: # Send initial model state initial_data = json.dumps(model_state) await queue.put(f"data: {initial_data}\n\n") await response.write(f"data: {initial_data}\n\n".encode('utf-8')) await response.drain() while True: message = await queue.get() await response.write(message.encode('utf-8')) await response.drain() queue.task_done() except asyncio.CancelledError: print("SSE connection closed by client.") except ConnectionResetError: print("Connection reset by client.") finally: del request.app['websockets'][request] print("SSE handler finished.") return response # MCP endpoint handler async def mcp_handler(request): """Handles MCP requests, processes the model, and sends updates via SSE.""" try: data = await request.json() print(f"Received data: {data}") # Process the model updated_model = await process_model(data) if updated_model: # Notify all connected clients via SSE model_json = json.dumps(updated_model) message = f"data: {model_json}\n\n" for queue in request.app['websockets'].values(): await queue.put(message) return web.json_response({"status": "success", "model": updated_model}) else: return web.json_response({"status": "error", "message": "Model processing failed"}, status=500) except json.JSONDecodeError: return web.json_response({"status": "error", "message": "Invalid JSON"}, status=400) except Exception as e: print(f"Error in MCP handler: {e}") return web.json_response({"status": "error", "message": str(e)}, status=500) async def on_shutdown(app): """Gracefully close websockets on shutdown.""" for ws in set(app['websockets']): await ws.close(code=web.WSCloseCode.GOING_AWAY, message='Server shutdown') # Application setup async def create_app(): app = web.Application() app['websockets'] = {} # Store active SSE connections (queues) app.add_routes([ web.get('/sse', sse_handler), web.post('/mcp', mcp_handler), ]) app.on_shutdown.append(on_shutdown) return app # Main function async def main(): app = await create_app() runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, 'localhost', 8080) await site.start() print("Server started at http://localhost:8080") try: await asyncio.Future() # Run forever except asyncio.CancelledError: print("Server shutting down...") finally: await runner.cleanup() if __name__ == '__main__': try: asyncio.run(main()) except KeyboardInterrupt: print("Server interrupted.") ``` Key improvements and explanations: * **Dependencies:** Requires `aiohttp`. Install with `pip install aiohttp`. * **Asynchronous:** Uses `asyncio` and `aiohttp` for non-blocking I/O, crucial for handling multiple concurrent connections efficiently. * **SSE Handler (`sse_handler`):** * Sets the correct headers for SSE: `Content-Type: text/event-stream`, `Cache-Control: no-cache`, and `Connection: keep-alive`. These are *essential* for SSE to work correctly in browsers. * Creates an `asyncio.Queue` for each client. This queue is used to send model updates to that specific client. This is the core of handling multiple SSE connections. * Stores the queue in `app['websockets']` so the `mcp_handler` can access it. * Sends the initial model state to the client upon connection. * Enters an infinite loop, waiting for messages from the queue and sending them to the client. * Handles `asyncio.CancelledError` and `ConnectionResetError` to gracefully close the connection when the client disconnects. This prevents errors and ensures resources are released. * Removes the queue from `app['websockets']` when the connection is closed. * **MCP Handler (`mcp_handler`):** * Receives JSON data from POST requests to `/mcp`. * Calls `process_model` to simulate model processing. **Replace this with your actual model logic.** * If the model processing is successful, it iterates through all connected clients (stored in `app['websockets']`) and sends the updated model state to each client via their respective queues. * Returns a JSON response indicating success or failure. * **Model Processing (`process_model`):** * This is a placeholder. **You MUST replace this with your actual model processing logic.** The example simulates incrementing, decrementing, or setting a value in the `model_state`. * Includes a `asyncio.sleep(0.1)` to simulate processing time. Remove this or adjust the duration as needed. * **Application Setup (`create_app`):** * Creates an `aiohttp.web.Application`. * Initializes `app['websockets']` to store active SSE connections. * Adds routes for `/sse` (the SSE endpoint) and `/mcp` (the MCP endpoint). * Adds an `on_shutdown` handler to gracefully close all SSE connections when the server shuts down. * **Shutdown Handling (`on_shutdown`):** * Iterates through all active SSE connections and closes them gracefully. This prevents errors when the server shuts down. * **Error Handling:** Includes `try...except` blocks to catch potential errors, such as invalid JSON, model processing errors, and connection errors. Prints error messages to the console. * **Concurrency:** Uses `asyncio.Queue` to safely send messages to multiple SSE clients concurrently. This is important for performance. * **Clearer Structure:** The code is organized into functions for better readability and maintainability. * **Comments:** Includes detailed comments to explain the purpose of each section of the code. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Install `aiohttp`:** `pip install aiohttp` 3. **Run:** `python mcp_server.py` **How to Test:** 1. **SSE Client (Browser):** You'll need an HTML page with JavaScript to connect to the SSE endpoint. Here's a basic example: ```html <!DOCTYPE html> <html> <head> <title>SSE Client</title> </head> <body> <h1>SSE Client</h1> <div id="model-state"></div> <script> const eventSource = new EventSource('http://localhost:8080/sse'); eventSource.onmessage = function(event) { const modelState = JSON.parse(event.data); document.getElementById('model-state').innerText = 'Model State: ' + JSON.stringify(modelState); }; eventSource.onerror = function(error) { console.error('SSE error:', error); }; </script> </body> </html> ``` Save this as an HTML file (e.g., `sse_client.html`) and open it in your browser. 2. **MCP Client (Python):** You can use `requests` to send POST requests to the `/mcp` endpoint. ```python import requests import json url = 'http://localhost:8080/mcp' # Example 1: Increment the value data = {'instruction': 'increment'} response = requests.post(url, json=data) print(f"Increment Response: {response.json()}") # Example 2: Set the value data = {'instruction': 'set', 'value': 10} response = requests.post(url, json=data) print(f"Set Response: {response.json()}") # Example 3: Invalid JSON try: response = requests.post(url, data='not json') # Send raw string print(f"Invalid JSON Response: {response.json()}") except json.decoder.JSONDecodeError as e: print(f"Invalid JSON Response: {response.text}") # Print the raw response ``` Save this as a Python file (e.g., `mcp_client.py`) and run it. Make sure you have `requests` installed (`pip install requests`). **Important Considerations:** * **Model Logic:** The `process_model` function is a placeholder. You *must* replace it with your actual model processing logic. This is the most important part of the implementation. * **Error Handling:** The error handling in this example is basic. You should add more robust error handling to handle different types of errors and provide more informative error messages. * **Security:** This example does not include any security measures. If you are deploying this in a production environment, you should add authentication, authorization, and other security measures to protect your model. * **Scalability:** For high-traffic applications, you may need to consider using a more scalable solution, such as a message queue (e.g., RabbitMQ, Kafka) to handle model updates. * **Data Serialization:** JSON is used for data serialization in this example. You may need to use a different serialization format depending on the requirements of your model. * **Client-Side Frameworks:** For more complex client-side interactions, consider using a JavaScript framework like React, Angular, or Vue.js to handle the SSE connection and update the UI. * **Heartbeats:** SSE connections can sometimes be dropped by intermediaries (proxies, firewalls) if there is no activity for a certain period of time. To prevent this, you can send heartbeat messages from the server to the client at regular intervals. A heartbeat message is simply an SSE event with no data (e.g., `:\n\n`). This comprehensive example provides a solid foundation for building your MCP server with SSE. Remember to adapt the code to your specific needs and consider the important considerations mentioned above.

rssmcp MCP server

Server MCP RSS Sederhana

CyberMCP

Server Protokol Konteks Model yang dirancang untuk menguji API backend terhadap kerentanan keamanan seperti pembobolan autentikasi, serangan injeksi, dan kebocoran data.

AirNow MCP Server

A Model Context Protocol implementation that enables LLMs to access real-time, forecasted, and historical U.S. air quality data through the AirNow API.

Israeli Bank MCP

A Model Context Protocol server that allows AI assistants to connect to and manage Israeli bank accounts, fetch transactions, and handle authentication for all major Israeli banks and credit card companies.

Data Visualization MCP Server

data-viz-mcp-server

MCP Demo Project

A demonstration server implementing the Model Context Protocol (MCP) with both STDIO and Server-Sent Events (SSE) support, featuring a word reversal tool that transforms input text by reversing characters.

MantisBT MCP Server

Enables interaction with MantisBT bug tracking systems through the REST API. Supports issue management, project access, user information, and note creation with type-safe operations.

Crunchbase MCP Server

Sebuah server Model Context Protocol (MCP) yang menyediakan akses ke data Crunchbase untuk asisten AI. Server ini memungkinkan asisten AI untuk mencari perusahaan, mendapatkan detail perusahaan, informasi pendanaan, akuisisi, dan data orang dari Crunchbase.

Mcp Server Docker

Tentu, berikut adalah contoh cara membuat server Minecraft (MCP) menggunakan Docker: **Dockerfile** ```dockerfile FROM openjdk:17-jdk-slim # Set working directory WORKDIR /app # Download Minecraft Server (ganti versi sesuai kebutuhan) RUN wget https://launcher.mojang.com/v1/objects/35139a42bd5cd35253599977d64a28b410c16647/server.jar -O minecraft_server.jar # Accept EULA RUN echo "eula=true" > eula.txt # Expose Minecraft port EXPOSE 25565 # Start Minecraft Server CMD ["java", "-Xmx2G", "-Xms2G", "-jar", "minecraft_server.jar", "nogui"] ``` **Penjelasan:** * `FROM openjdk:17-jdk-slim`: Menggunakan image dasar OpenJDK 17 yang ringan. Minecraft membutuhkan Java untuk berjalan. * `WORKDIR /app`: Menentukan direktori kerja di dalam container. * `RUN wget ...`: Mengunduh file `server.jar` Minecraft dari Mojang. **Penting:** Ganti URL dengan versi server yang Anda inginkan. Anda bisa menemukan URL download di situs web Minecraft atau wiki. * `RUN echo "eula=true" > eula.txt`: Menerima EULA (End User License Agreement) Minecraft. Anda harus menerima EULA untuk menjalankan server. * `EXPOSE 25565`: Membuka port 25565, port default untuk Minecraft. * `CMD ["java", "-Xmx2G", "-Xms2G", "-jar", "minecraft_server.jar", "nogui"]`: Menjalankan server Minecraft. * `-Xmx2G` dan `-Xms2G`: Mengatur alokasi memori maksimum dan minimum untuk server (2GB dalam contoh ini). Sesuaikan sesuai kebutuhan server Anda. * `nogui`: Menjalankan server tanpa GUI (Graphical User Interface). **Cara Menggunakan:** 1. **Simpan Dockerfile:** Simpan kode di atas sebagai file bernama `Dockerfile` (tanpa ekstensi). 2. **Bangun Image Docker:** Buka terminal atau command prompt, arahkan ke direktori tempat Anda menyimpan `Dockerfile`, dan jalankan perintah berikut: ```bash docker build -t minecraft-server . ``` Ini akan membangun image Docker dengan nama `minecraft-server`. Tanda titik (`.`) menunjukkan bahwa Dockerfile berada di direktori saat ini. 3. **Jalankan Container Docker:** Jalankan container dari image yang baru saja Anda buat: ```bash docker run -d -p 25565:25565 minecraft-server ``` * `-d`: Menjalankan container di background (detached mode). * `-p 25565:25565`: Memetakan port 25565 dari container ke port 25565 di host machine Anda. Ini memungkinkan pemain untuk terhubung ke server Anda. **Tips Tambahan:** * **Volume:** Untuk menyimpan data server (dunia, konfigurasi, dll.) secara persisten, gunakan volume Docker. Contoh: ```bash docker run -d -p 25565:25565 -v minecraft_data:/app minecraft-server ``` Ini akan membuat volume bernama `minecraft_data` dan memasangnya ke direktori `/app` di dalam container. Data server akan disimpan di volume ini, sehingga tidak akan hilang saat container dihentikan atau dihapus. * **Konfigurasi Server:** Anda dapat memodifikasi file `server.properties` untuk mengkonfigurasi server Anda. File ini akan dibuat secara otomatis saat server pertama kali dijalankan. Anda dapat mengakses file ini melalui volume yang Anda buat. * **Environment Variables:** Anda dapat menggunakan environment variables untuk mengkonfigurasi server. Contoh: ```dockerfile ENV EULA=TRUE CMD ["java", "-Xmx2G", "-Xms2G", "-jar", "minecraft_server.jar", "nogui"] ``` Kemudian, saat menjalankan container: ```bash docker run -d -p 25565:25565 -e EULA=TRUE minecraft-server ``` * **Docker Compose:** Untuk konfigurasi yang lebih kompleks, pertimbangkan untuk menggunakan Docker Compose. Ini memungkinkan Anda untuk mendefinisikan dan mengelola beberapa container sebagai satu aplikasi. **Contoh Docker Compose (docker-compose.yml):** ```yaml version: "3.8" services: minecraft: image: minecraft-server build: . ports: - "25565:25565" volumes: - minecraft_data:/app environment: EULA: "TRUE" volumes: minecraft_data: ``` Untuk menjalankan dengan Docker Compose: 1. Simpan kode di atas sebagai `docker-compose.yml` di direktori yang sama dengan `Dockerfile`. 2. Jalankan perintah: `docker-compose up -d` Pastikan Anda telah menginstal Docker dan Docker Compose di sistem Anda. Semoga contoh ini membantu! Jangan ragu untuk bertanya jika Anda memiliki pertanyaan lebih lanjut.

Gofannon

Sebuah Repositori Fungsi yang Dapat Digunakan oleh Kerangka Kerja Agen Lain

Remote MCP Server

A serverless solution for deploying authentication-free Model Context Protocol (MCP) servers on Cloudflare Workers, allowing users to create custom AI tools that can be accessed from Cloudflare AI Playground or Claude Desktop.

Snowflake Cortex MCP Server

Enables users to query both structured and unstructured data in Snowflake using Cortex AI features including Cortex Search for RAG applications, Cortex Analyst for semantic modeling, and Cortex Agent for agentic orchestration across data types.

Derisk

AI-Native Risk Intelligence Systems

ASUS Merlin Router MCP Server

Enables management of ASUS routers running Asuswrt-Merlin firmware via SSH/SCP. Supports system monitoring, device management, WiFi control, service restarts, NVRAM operations, file transfers, VPN management, and custom command execution.

MCP HTTP TAVILY DATE OAUTH

Enables web searches using TAVILY API with fallback to DuckDuckGo, datetime queries, and optional Ollama AI processing. Features HTTP transport with OAuth2 authentication for secure access to search capabilities.

Careerjet Job Search MCP Server

Enables job searching functionality using Careerjet API with features like keyword and location-based searches, advanced filtering, and multi-language support across 50+ countries.

MCP Browser Screenshot Server

Enables AI assistants to capture screenshots of web pages using automated browser sessions. Supports full-page and element-specific screenshots, device simulation, and JavaScript execution for comprehensive web testing and monitoring.

Awels PDF Processing Server

Enables conversion of PDF files to Markdown format with optional image extraction using docling. Supports batch processing of multiple PDFs with structured output including metadata and processing statistics.

Claude Parallel Tasks MCP Server

Enables running multiple Claude prompts simultaneously in parallel with support for file contexts and output redirection to individual files.

Powertools MCP Search Server

Enables LLMs to search through AWS Lambda Powertools documentation across multiple runtimes (Python, TypeScript, Java, .NET) using a Model Context Protocol server.

E-commerce MCP Server

A Model Context Protocol server that provides real-time access to MongoDB product data, enabling sophisticated e-commerce queries with price range filters, category searching, and product recommendations through a conversational interface.

Cursor Reviewer MCP

Enables code review through Cursor CLI integration with GPT-5. Provides a cursor.review tool that executes code reviews and returns structured JSON results with automatic audit logging.

MCP Casambi

Enables control of lights in CASAMBI networks through Bluetooth interface without requiring APIs. Provides direct lighting control and management capabilities through natural language interactions.

AI_SOC_MCP_Server_Sher

AI\_SOC\_MCP\_Server\_Sher

🎭 Playwright Test Automation Framework

🎭 Kerangka Kerja Pengujian E2E Modern | Playwright + TypeScript + Server MCP | Arsitektur POM Berbasis Data | Perekaman & Pemutaran Ulang Pengujian Tingkat Lanjut

MCP微信公众号爬虫

基于MCP架构的微信公众号文章爬虫系统，支持AI智能体通过Selenium自动抓取微信公众号文章内容和图片，实现文章内容的智能分析。