Discover Awesome MCP Servers

Crypto MCP Server

Provides real-time and historical cryptocurrency market data using ccxt, with tools for ticker, OHLCV, and streaming updates.

Spice MCP

Enables querying and analyzing blockchain data from Dune Analytics with Polars-optimized workflows, including schema discovery, Sui package exploration, and query management through natural language.

bilibili-mcp

A MCP tool to fetch Bilibili hot list videos, supporting configurable top-K results via async HTTP requests.

padlet-mcp

An MCP server that lets AI agents directly manage Padlet boards, including creating boards with sections, posting cards with attachments and polls, adding comments, reactions, and more.

Hello World MCP Server

A simple Model Context Protocol server that demonstrates basic functionality with greeting tools, allowing Claude to say hello and generate custom greetings with different styles and timestamps.

Portfolio Manager MCP Server

A Model Context Protocol server for managing and analyzing investment portfolios. It enables users to create and update portfolios, fetch real-time stock data and news, generate performance reports, and receive investment recommendations through natural language.

n8n MCP Server

Exposes n8n's REST API and local Ollama as MCP tools, allowing natural language instructions to create, execute, and monitor workflows from MCP clients like VS Code Copilot Chat.

AuraImage MCP Server

Enables AI agents to audit images for LCP savings, migrate assets to AuraImage CDN, generate alt text, create responsive tags, and preview smart crops directly from the editor.

safe-migrations-mcp

An MCP server that acts as a gatekeeper for database and configuration changes, requiring proposals, dry-run simulations, and confirmation tokens before applying any modifications.

tlaplus-mcp

Exposes the TLA+ toolchain (TLC, SANY, PlusCal, TLATeX) as structured JSON tools via the Model Context Protocol, enabling AI assistants to parse, check, simulate, and typeset TLA+ specifications.

Apple Notes MCP Server

Reading and writing Apple Notes with native Markdown conversion

x-ai-mcp

An MCP server that integrates X (Twitter) API access with Grok-powered intelligence for real-time social media analysis and account management. It provides tools for reading and writing tweets, managing direct messages, and generating AI-powered topic summaries or daily briefings.

CodeLogic

Interact with CodeLogic, a Software Intelligence platform that graphs complex code and data architecture dependencies, to boost AI accuracy and insight.

Cloudflare MCP Server

Enables AI assistants to manage Cloudflare resources through natural language, including DNS records, zone management, Workers KV storage, cache purging, and analytics. Supports comprehensive Cloudflare operations with secure API token authentication.

mcp-notas

Provides tools, resources, and prompts for managing a local Markdown notes database, including create, read, update, delete, search, and statistics operations, with robust path traversal protection.

midnight-nextjs-mcp

Combines Midnight Network blockchain development tools with Next.js DevTools for building decentralized applications, supporting contract development, wallet management, and Next.js diagnostics.

accessoticketing-mcp

An MCP server for accesso Passport mobile ticket links that reads orders, admissions, barcodes, and Google Wallet passes without login. It provides read-only tools to fetch ticket details, save barcode images, and resolve email tracking links.

Outlook MCP Server

Connects Claude to Microsoft Outlook through the Microsoft Graph API, enabling email management (list, search, read, send) and calendar operations (list, create, accept, decline, delete events) via OAuth 2.0 authentication.

entraadm-mcp

Enables read-only triage of Microsoft Entra ID sign-in and audit logs through fixed tools for sign-in failure analysis, user lookup, directory audits, and daily briefs.

Rope MCP

A Model Context Protocol server that exposes Python Rope refactoring capabilities to Claude Code, enabling safe symbol renaming, method extraction, code analysis, and more.

Lark MCP

개인 계정(봇 설정 불필요)을 사용하여 Feishu/Lark 메시징 플랫폼을 통해 AI 모델이 함수 호출을 수행할 수 있도록 지원하는 모델 컨텍스트 프로토콜 서버로, 완전한 기능을 갖춘 AI 어시스턴트를 만들 수 있습니다.

PixelForge MCP

PixelForge MCP provides a pipeline for converting AI-generated illustrations into in-game dot sprites. It automates background removal, pixelization, palette unification, outlining, and spritesheet packing via MCP tools.

Node Omnibus MCP Server

거울

interactive-mcp

interactive-mcp

mcp-apps-ravenwatch

A stateless MCP server that generates interactive report widgets and survey builder UIs, using MCP Apps for rich visualizations and long-polling for live updates.

MCP Server Demo in python

Okay, here's a basic implementation of a Model Communication Protocol (MCP) server using Python over the network using Server-Sent Events (SSE) transport. This is a simplified example and will need to be adapted based on your specific MCP requirements (e.g., message format, error handling, authentication, etc.). ```python import asyncio import json import uuid from aiohttp import web # In-memory storage for connected clients (replace with a database for persistence) clients = {} # {client_id: response} async def handle_mcp_request(request): """Handles incoming MCP requests (e.g., POST requests with model input).""" try: data = await request.json() # Assuming JSON payload # Process the data (e.g., send it to your model) # Replace this with your actual model inference logic model_output = await run_model(data) # Simulate model inference client_id = data.get("client_id") # Assuming client_id is in the request if not client_id: return web.json_response({"error": "client_id is required"}, status=400) if client_id not in clients: return web.json_response({"error": "Client not connected"}, status=404) # Send the model output back to the client via SSE await send_sse_message(clients[client_id], json.dumps(model_output)) return web.json_response({"status": "success"}) except json.JSONDecodeError: return web.json_response({"error": "Invalid JSON"}, status=400) except Exception as e: print(f"Error processing request: {e}") return web.json_response({"error": str(e)}, status=500) async def run_model(data): """Simulates running a model. Replace with your actual model inference.""" await asyncio.sleep(1) # Simulate processing time # Example: Echo back the input with a "processed" flag return {"input": data, "processed": True} async def sse_handler(request): """Handles SSE connections from clients.""" client_id = str(uuid.uuid4()) # Generate a unique client ID response = web.StreamResponse( status=200, headers={ 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', } ) await response.prepare(request) clients[client_id] = response # Store the client's response object print(f"Client connected: {client_id}") try: # Send a welcome message with the client ID await send_sse_message(response, json.dumps({"message": "Connected", "client_id": client_id})) # Keep the connection alive until the client disconnects while True: await asyncio.sleep(0.1) # Small delay to prevent busy-waiting except asyncio.CancelledError: print(f"Client disconnected: {client_id}") except Exception as e: print(f"Error with client {client_id}: {e}") finally: del clients[client_id] # Remove the client when disconnected await response.write_eof() return response async def send_sse_message(response, message): """Sends an SSE message to the client.""" event_data = f"data: {message}\n\n" await response.write(event_data.encode('utf-8')) await response.drain() # Ensure data is sent immediately async def on_shutdown(app): """Gracefully close all client connections on shutdown.""" for client_id, response in clients.items(): print(f"Closing connection for client: {client_id}") await send_sse_message(response, json.dumps({"message": "Server shutting down"})) await response.write_eof() async def main(): app = web.Application() app.add_routes([ web.get('/sse', sse_handler), web.post('/mcp', handle_mcp_request), # MCP endpoint ]) app.on_shutdown.append(on_shutdown) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, 'localhost', 8080) # Change host/port as needed await site.start() print("Server started at http://localhost:8080") # Keep the server running indefinitely try: await asyncio.Future() # Run forever except asyncio.CancelledError: pass # Handle cancellation if needed finally: await runner.cleanup() if __name__ == '__main__': asyncio.run(main()) ``` Key improvements and explanations: * **Uses `aiohttp`:** `aiohttp` is an asynchronous web framework, crucial for handling SSE efficiently. SSE relies on long-lived connections, and asynchronous handling prevents blocking the server. * **SSE Content Type:** Sets the correct `Content-Type` header (`text/event-stream`) for SSE. Also sets `Cache-Control: no-cache` and `Connection: keep-alive` which are important for SSE. * **Client Tracking:** The `clients` dictionary stores connected clients (using their `client_id`) and their `StreamResponse` objects. This is *essential* for sending data back to specific clients. **Important:** This is an in-memory store. For production, you'll need a persistent store (e.g., Redis, database) to handle server restarts. * **Unique Client IDs:** Generates a unique `client_id` for each connecting client using `uuid`. This is how you'll identify which client to send data to. The client needs to send this ID back in subsequent requests. * **`send_sse_message` function:** Encapsulates the logic for sending SSE messages. It formats the message correctly (`data: ...\n\n`) and encodes it to UTF-8. Critically, it also calls `await response.drain()` to ensure the data is *immediately* sent to the client. Without `drain()`, the data might buffer and not be sent until much later. * **Error Handling:** Includes basic `try...except` blocks to catch potential errors (JSON decoding, model errors, client disconnects). More robust error handling is needed for production. * **Asynchronous Model Simulation:** The `run_model` function is now asynchronous using `asyncio.sleep` to simulate model processing time. This is important to prevent blocking the event loop. **Replace this with your actual asynchronous model inference code.** * **MCP Request Handling:** The `handle_mcp_request` function now expects a `client_id` in the incoming JSON data. It uses this `client_id` to look up the correct client in the `clients` dictionary and send the model output back via SSE. * **Graceful Shutdown:** The `on_shutdown` function iterates through all connected clients and sends a "Server shutting down" message before closing the connections. This is important for a clean shutdown. * **Keep-Alive:** The `sse_handler` function now includes a `while True` loop with a small `asyncio.sleep` to keep the connection alive. This prevents the connection from closing prematurely. * **Client Disconnect Handling:** The `try...except...finally` block in `sse_handler` ensures that the client is removed from the `clients` dictionary when they disconnect (either normally or due to an error). This prevents memory leaks and ensures that you don't try to send data to a disconnected client. * **Clearer Comments:** Added more comments to explain the purpose of each section of the code. **How to Run:** 1. **Install `aiohttp`:** ```bash pip install aiohttp ``` 2. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 3. **Run:** Execute the file from your terminal: ```bash python mcp_server.py ``` **Example Client (JavaScript/HTML):** ```html <!DOCTYPE html> <html> <head> <title>MCP Client</title> </head> <body> <h1>MCP Client</h1> <div id="output"></div> <script> const outputDiv = document.getElementById('output'); let clientId = null; // Store the client ID // Establish SSE connection const eventSource = new EventSource('http://localhost:8080/sse'); eventSource.onopen = () => { outputDiv.innerHTML += '<p>Connected to server.</p>'; }; eventSource.onmessage = (event) => { const data = JSON.parse(event.data); outputDiv.innerHTML += `<p>Received: ${JSON.stringify(data)}</p>`; // Store the client ID when received if (data.client_id) { clientId = data.client_id; outputDiv.innerHTML += `<p>Client ID: ${clientId}</p>`; } }; eventSource.onerror = (error) => { console.error('SSE error:', error); outputDiv.innerHTML += '<p>Error connecting to server.</p>'; }; // Function to send an MCP request function sendMCPRequest(inputData) { if (!clientId) { outputDiv.innerHTML += '<p>Error: Client ID not yet received. Wait for connection.</p>'; return; } fetch('http://localhost:8080/mcp', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ ...inputData, client_id: clientId }), // Include client_id }) .then(response => response.json()) .then(data => { outputDiv.innerHTML += `<p>MCP Request Status: ${JSON.stringify(data)}</p>`; }) .catch(error => { console.error('Error sending MCP request:', error); outputDiv.innerHTML += `<p>Error sending MCP request.</p>`; }); } // Example usage: Send a request after a delay setTimeout(() => { sendMCPRequest({ message: 'Hello from the client!' }); }, 2000); // Wait 2 seconds to ensure connection is established </script> </body> </html> ``` **Explanation of the Client:** 1. **SSE Connection:** Creates an `EventSource` object to connect to the `/sse` endpoint on the server. 2. **Event Handlers:** - `onopen`: Called when the connection is established. - `onmessage`: Called when the server sends an SSE message. It parses the JSON data and displays it in the `outputDiv`. It also *stores* the `client_id` when it receives the initial connection message from the server. - `onerror`: Called if there's an error with the SSE connection. 3. **`sendMCPRequest` Function:** - Sends a `POST` request to the `/mcp` endpoint. - **Crucially, it includes the `client_id` in the JSON payload.** This is how the server knows which client to send the response to. - Handles the response from the server and displays the status. 4. **Example Usage:** The `setTimeout` function sends an example MCP request after a 2-second delay. This gives the SSE connection time to establish and receive the `client_id`. **Important Considerations for Production:** * **Authentication/Authorization:** Implement proper authentication and authorization to secure your MCP endpoint. You don't want unauthorized clients sending requests to your model. * **Error Handling:** Implement more robust error handling on both the server and the client. Log errors, provide informative error messages, and handle unexpected situations gracefully. * **Scalability:** For high-traffic applications, consider using a message queue (e.g., RabbitMQ, Kafka) to decouple the MCP server from the model inference process. This will allow you to scale the server and the model inference independently. * **Connection Management:** Implement more sophisticated connection management, including heartbeats to detect dead connections and automatic reconnection logic on the client. * **Data Validation:** Validate the incoming data to ensure it's in the correct format and within acceptable ranges. This will help prevent errors and security vulnerabilities. * **Model Deployment:** Consider using a model serving framework (e.g., TensorFlow Serving, TorchServe, Triton Inference Server) to deploy your model in a production environment. These frameworks provide features like model versioning, A/B testing, and monitoring. * **Security:** Be aware of potential security risks, such as denial-of-service attacks and injection vulnerabilities. Implement appropriate security measures to protect your server and your model. * **Load Balancing:** Use a load balancer to distribute traffic across multiple MCP server instances. * **Monitoring:** Implement monitoring to track the performance of your MCP server and your model. This will help you identify and resolve issues quickly. * **Client ID Persistence:** If clients need to reconnect and maintain the same ID, you'll need a mechanism to persist the client ID (e.g., using cookies, local storage, or a database). The current implementation generates a new ID on each connection. This comprehensive example provides a solid foundation for building an MCP server using Python and SSE. Remember to adapt it to your specific needs and consider the production considerations outlined above.

Live Marketing Data MCP

Connect AI assistants to live Meta Ads, GA4, and Google Search Console data. 100% local, credentials machine-locked and encrypted. Supports Claude Desktop, Cursor, Windsurf, Cline, and more.

OriginalVoices MCP Server

Enables asking questions to AI twins representing specific audiences for research purposes.

Receita Federal NFS-e: Notas Emitidas

Enables querying issued electronic service invoices (NFS-e) from the Brazilian Federal Revenue via natural language, providing read-only access to official invoice data.

slug-generator

Enables AI agents to generate URL-friendly slugs from text with custom separators and transliteration, paid per call via x402 micropayments.