Discover Awesome MCP Servers

Jokes MCP Server

Fetches jokes from multiple APIs including Chuck Norris, Dad jokes, and Yo Mama jokes, providing humor-focused content through standardized MCP tools.

Query Analytics

Builds valid Google Analytics 4 API requests from plain parameters with automatic date range resolution, metric formatting, and filter expression parsing. Eliminates manual GA4 API syntax construction and raw data formatting for analytics queries.

Remote MCP with Azure Functions (Python)

A quickstart template to build and deploy a remote MCP server on Azure Functions using Python, secured with keys and HTTPS.

IL Bank MCP

Finance assistant that brings your Israeli bank data to any AI assistant, enabling transaction analysis, spending patterns, and financial insights.

bilibili-mcp

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

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.

Tafa MCP Server

A production-ready Model Context Protocol server that provides comprehensive file system management capabilities for seamless integration with Claude Desktop.

Website Contacts Scraper

Enables scraping of emails, phone numbers, and social profile links from website domains. Supports batch processing of up to 20 domains and can find company websites by keyword/company name.

Excalidraw MCP App Server

Enables users to create and interact with hand-drawn sketches and architecture diagrams directly within chat interfaces using Excalidraw. It leverages the Model Context Protocol to provide interactive HTML visualizations with smooth viewport control and fullscreen editing capabilities.

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.

Disruption Intelligence MCP

Disruption Intelligence MCP gives AI agents access to commercial disruption signals through a public MCP server backed by the hosted Forgemesh API. It supports WARN/layoff intelligence, company context, geospatial territory disruption, x402 payment challenge inspection, and economic signal workflows without exposing private scoring logic, ingestion systems, schemas, or infrastructure.

mnemos

Persistent memory engine for AI coding agents. Single Go binary, zero runtime dependencies, MCP-native. Stores, searches, and deduplicates memories across sessions using embedded SQLite with hybrid FTS + semantic search, memory decay, relation graph, and token-budget context assembly.

Figma MCP Server

Enables AI assistants to interact with Figma designs using natural language commands, supporting file analysis, component extraction, asset export, comment management, and design system queries through the Figma API.

Cobalt Strike MCP Server

Bridges large language models with the Cobalt Strike C2 framework, enabling AI assistants to control adversary simulation workflows through natural language.

MediaWiki MCP adapter

A custom Model Context Protocol adapter for MediaWiki and WikiBase APIs

Talk to Figma MCP

Enables Cursor AI to interact with Figma designs, allowing users to read design information and programmatically modify elements through natural language commands.

lifeos-mcp

Provides MCP-compatible AI agents with read access to a LifeOS knowledge base, exposing identity, preferences, projects, wiki, skills, and rules via tools and resources.

Firestore MCP Server

Provides secure, permission-controlled access to Firebase Firestore databases with full CRUD operations, advanced queries, batch operations, and transactions through a standardized MCP interface.

smart-webfetch-mcp

Context-aware web fetching for LLMs, providing 7 tools to check page size, fetch with truncation, extract code/sections/links/tables, and paginate large documents.

SimpleLocalize MCP Server

Server Protokol Konteks Model yang memungkinkan pengguna untuk mengelola terjemahan untuk aplikasi mereka melalui platform lokalisasi SimpleLocalize melalui perintah bahasa alami di Cursor.

Exasol MCP Server

Provides an LLM access to the Exasol database via MCP tools, enabling reading of database metadata and execution of data reading queries.

Government Contracts MCP

Enables AI agents to search and analyze federal government contract opportunities and awards from SAM.gov and USASpending.gov, with tools for contract search, detail, agency spending, and trending sectors.

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.

Forgetful

A storage and retrieval MCP server for AI agents using FastMCP, enabling persistent knowledge base with semantic search and automatic linking.

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.

emcp

MCP server providing filesystem operations, shell execution, and web search capabilities.

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.

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.

SUMO-MCP-Server

Enables AI agents to interact with Eclipse SUMO traffic simulations, automating tasks from data acquisition to signal optimization.

HUDU MCP Server

Enables interaction with HUDU technical documentation and customer management platform through API integration. Supports retrieving company information, searching knowledge base articles, and managing assets and credentials.