Discover Awesome MCP Servers

Muapi

Access 400+ generative AI models directly from your AI assistant — generate images (FLUX, Midjourney, GPT-4o), create videos (Veo3, Kling), make music (Suno), and enhance photos, all via a single MCP server.

thunderbird-mcp

A read-only MCP server that lets Claude read and search emails from Thunderbird accounts and access contacts, working directly with profile files.

MCP Data Analyzer

Enables loading and statistical analysis of .xlsx and .csv files with visualization capabilities using matplotlib and plotly to generate various graphs and charts.

Excel MCP Server

Enables reading and writing Excel files (text, formulas, and images on Windows) via MCP tools with pagination support.

Etsy MCP Server

An MCP server for interacting with the Etsy API, enabling listing management, shop information, shipping profiles, and image uploads.

@nogoo9/mcp-server-cloud-fs

A cloud replacement for mcp-server-filesystem that provides 30 tools for S3, Azure Blob, and Google Cloud Storage, deployable locally via STDIO or remotely over HTTP/WebSocket with OAuth 2.1 authentication.

Plex Assistant MCP

Enables users to manage and control their Plex media library through natural language commands in MCP-compatible AI clients. It supports searching content, managing playlists, tracking library statistics, and monitoring live viewing sessions.

@1claw/mcp

MCP server for secure, just-in-time secret retrieval from 1claw vault and malicious content inspection, enabling AI agents to access secrets and security analysis.

deptrust

deptrust is a CLI that checks package versions for known vulnerabilities across npm, PyPI, crates.io, Go modules, RubyGems, NuGet, Maven, Packagist, pub.dev, CocoaPods, Hex.pm, Hackage, GitHub Actions, and more. It runs locally as a CLI and as an MCP server. It calls public package registry and OSV APIs directly; there is no hosted deptrust service to trust or configure.

discord-mcp

Enables managing a Discord server using natural language through AI clients like Claude, with 139 admin tools across 20 categories for roles, channels, members, messages, threads, moderation, and more.

munich-mensa-mcp

Remote MCP Server for listing and getting the menus of the official mensas in munich

patternfetch

MCP server for crypto market analysis providing compact market-state briefs, patterns, support/resistance, trend, and indicators via tools like patternfetch_brief, patternfetch_delta, and patternfetch_analogs.

mcp-mayo

MCP server that exposes MAYO Apollo HRM platform's Foundation, Attendance, and Payroll APIs as AI-callable tools, enabling natural language queries for employee profiles, attendance summaries, and payroll reports.

codex-agent-mem

Portable, auditable, local-first MCP memory for MCP-compatible AI agents and coding workflows. It keeps durable project memory outside the model runtime, compresses continuity into smaller working packs, and carries forward operational state so agents can resume with less repetition.

remote-mcp-server

Enables remote MCP server deployment on Cloudflare Workers with OAuth login and SSE transport for connecting MCP clients like Claude Desktop.

SharePoint-Cleyrop MCP

Enables users to access SharePoint files via Microsoft Graph and transfer them to Cleyrop project work data, supporting multi-tenant authentication.

Demo Server

A simple MCP server built with Python's FastMCP that exposes a calculator tool for addition operations and a dynamic greeting resource for personalized messages.

jetlag-mcp

Enables listing and running Ansible playbooks, managing roles, reading docs, and creating vars files for the jetlag project.

token-rugcheck

MCP server for real-time Solana token risk analysis. Cross-references RugCheck.xyz, DexScreener, and GoPlus Security to generate three-layer reports: machine verdict → LLM analysis → raw on-chain evidence. Live on Solana mainnet with USDC micropayments ($0.02/audit). Give any AI agent the ability to check if a token is safe before trading.

Marvel MCP Server using Azure Functions

Un servidor MCP basado en Azure Functions que permite la interacción con datos de personajes y cómics de Marvel a través de la API oficial de desarrolladores de Marvel.

maya-mcp-server

MCP server for interacting with Autodesk Maya sessions, enabling multi-session management, arbitrary Python execution, and streaming output capture.

athenahealth MCP Server

Enables AI-powered clinical decision support by integrating with athenahealth's API to access patient data, manage prescriptions, check drug interactions, and generate clinical assessments. Provides HIPAA-compliant healthcare workflows with comprehensive audit logging and data sanitization.

perplexity-server

A TypeScript-based MCP server that implements a simple notes system with resources, tools for creating notes, and prompts for summarization.

cmux-agent-mcp

A programmable terminal control plane that enables AI agents to orchestrate, monitor, and interact with multiple parallel AI CLI sessions and browser instances within CMUX. It provides over 80 tools for workspace management, pane manipulation, and cross-agent communication to facilitate complex multi-project workflows.

fossick-mcp

Enables AI agents to prospect across GitHub, PyPI, and npm, searching repositories, packages, and code patterns with read-only tools.

Prism MCP

Production-ready MCP server with session memory, Brave Search, Vertex AI Discovery Engine, Google Gemini analysis, and sandboxed code-mode transforms.

turbovec-mcp

Enables local semantic code search using compressed vectors from turbovec and any OpenAI-compatible embeddings endpoint.

sonar-mcp

A Model Context Protocol (MCP) server for interacting with SonarQube code quality platform.

crawl4ai-mcp

Okay, here's a Python outline and conceptual structure for wrapping the Crawl4AI library within an MCP (Model Context Protocol) server. This is a complex task, so I'll break it down into key components and provide code snippets to illustrate the core ideas. **Conceptual Overview** 1. **Crawl4AI Library:** Assume you have the Crawl4AI library installed and accessible in your Python environment. This library provides functions for web crawling, data extraction, and AI-related tasks. Let's say it has functions like: * `crawl_website(url, max_depth)`: Crawls a website up to a specified depth. * `extract_text(html_content)`: Extracts text from HTML content. * `analyze_content(text)`: Analyzes the extracted text using AI models (e.g., sentiment analysis, topic extraction). 2. **MCP Server:** The MCP server will act as a central point for receiving requests to use the Crawl4AI functions. It will expose these functions as services that can be called remotely. We'll use a framework like Flask or FastAPI to create the server. 3. **MCP Protocol:** MCP defines a standard way for clients to communicate with the server. Requests are typically sent as JSON payloads, and responses are also in JSON format. The requests will specify which Crawl4AI function to call and the parameters to pass to it. 4. **Python Implementation:** We'll use Python to: * Wrap the Crawl4AI functions. * Create the MCP server using Flask or FastAPI. * Handle incoming MCP requests. * Call the Crawl4AI functions. * Format the results as JSON responses. **Code Structure (Illustrative)** ```python # Import necessary libraries from flask import Flask, request, jsonify import json # Assume Crawl4AI is installed and accessible # import Crawl4AI # Replace with the actual import app = Flask(__name__) # Mock Crawl4AI functions (replace with actual Crawl4AI calls) def crawl_website(url, max_depth): """Mocks crawling a website.""" print(f"Crawling {url} with max depth {max_depth}") # Simulate crawling and getting HTML content html_content = f"<html><body><h1>Crawled Content from {url}</h1><p>Some text.</p></body></html>" return html_content def extract_text(html_content): """Mocks extracting text from HTML.""" print("Extracting text from HTML") text = "Crawled Content from a website. Some text." return text def analyze_content(text): """Mocks analyzing content.""" print("Analyzing content") analysis_result = {"sentiment": "neutral", "topic": "general"} return analysis_result @app.route('/mcp', methods=['POST']) def mcp_handler(): """Handles MCP requests.""" try: data = request.get_json() print(f"Received MCP request: {data}") # Extract function name and parameters from the MCP request function_name = data.get('function') params = data.get('params', {}) # Default to empty dictionary if no params # Call the appropriate Crawl4AI function based on the function name if function_name == 'crawl_website': url = params.get('url') max_depth = params.get('max_depth', 1) # Default max_depth result = crawl_website(url, max_depth) # Call the Crawl4AI function response_data = {"result": result} # Wrap the result elif function_name == 'extract_text': html_content = params.get('html_content') result = extract_text(html_content) response_data = {"result": result} elif function_name == 'analyze_content': text = params.get('text') result = analyze_content(text) response_data = {"result": result} else: return jsonify({"error": "Invalid function name"}), 400 # Return the result as a JSON response return jsonify(response_data), 200 except Exception as e: print(f"Error processing request: {e}") return jsonify({"error": str(e)}), 500 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) ``` **Explanation:** 1. **Imports:** Imports Flask for creating the web server and `json` for handling JSON data. 2. **Mock Crawl4AI Functions:** These are placeholder functions. **You must replace these with actual calls to your Crawl4AI library.** They simulate the behavior of the Crawl4AI functions for demonstration purposes. 3. **`mcp_handler` Function:** * This function is the endpoint that receives MCP requests (at the `/mcp` route). * It parses the JSON request body using `request.get_json()`. * It extracts the `function` name and `params` from the request. * It uses an `if/elif/else` block to determine which Crawl4AI function to call based on the `function_name`. * It calls the appropriate Crawl4AI function with the provided parameters. * It formats the result as a JSON response using `jsonify()`. * It handles potential errors using a `try...except` block and returns an error response if something goes wrong. 4. **`if __name__ == '__main__':`:** This ensures that the Flask app is only run when the script is executed directly (not when it's imported as a module). It starts the Flask development server. **How to Run:** 1. **Install Flask:** `pip install flask` 2. **Replace Mock Functions:** Replace the mock Crawl4AI functions with actual calls to your Crawl4AI library. 3. **Run the Script:** `python your_script_name.py` **Example MCP Request (sent to the server):** ```json { "function": "crawl_website", "params": { "url": "https://www.example.com", "max_depth": 2 } } ``` **Example MCP Response (from the server):** ```json { "result": "<html><body><h1>Crawled Content from https://www.example.com</h1><p>Some text.</p></body></html>" } ``` **Key Improvements and Considerations:** * **Error Handling:** The `try...except` block provides basic error handling. You should add more robust error handling, including logging and more specific exception handling. * **Input Validation:** Validate the input parameters in the `mcp_handler` function to prevent errors and security vulnerabilities. For example, check if the `url` is a valid URL. * **Security:** If this server will be exposed to the internet, implement proper security measures, such as authentication and authorization. Consider using HTTPS. * **Asynchronous Operations:** Web crawling can be time-consuming. Consider using asynchronous tasks (e.g., with `asyncio` or Celery) to prevent the server from blocking while crawling. This will improve the server's responsiveness. * **Configuration:** Use a configuration file (e.g., a `.ini` or `.yaml` file) to store settings such as the server port, logging level, and API keys. * **Logging:** Implement comprehensive logging to track requests, errors, and other important events. * **Documentation:** Document the API endpoints and the expected request/response formats. Consider using a tool like Swagger/OpenAPI to generate API documentation. * **Rate Limiting:** Implement rate limiting to prevent abuse of the API. * **Framework Choice:** While Flask is a good starting point, FastAPI is often preferred for modern APIs due to its performance and automatic data validation. The code structure would be similar, but you'd use FastAPI's decorators and data validation features. **Example using FastAPI:** ```python from fastapi import FastAPI, HTTPException from pydantic import BaseModel from typing import Optional app = FastAPI() # Define data models for request parameters (using Pydantic) class CrawlWebsiteParams(BaseModel): url: str max_depth: Optional[int] = 1 class ExtractTextParams(BaseModel): html_content: str class AnalyzeContentParams(BaseModel): text: str # Mock Crawl4AI functions (replace with actual Crawl4AI calls) def crawl_website(url: str, max_depth: int): """Mocks crawling a website.""" print(f"Crawling {url} with max depth {max_depth}") # Simulate crawling and getting HTML content html_content = f"<html><body><h1>Crawled Content from {url}</h1><p>Some text.</p></body></html>" return html_content def extract_text(html_content: str): """Mocks extracting text from HTML.""" print("Extracting text from HTML") text = "Crawled Content from a website. Some text." return text def analyze_content(text: str): """Mocks analyzing content.""" print("Analyzing content") analysis_result = {"sentiment": "neutral", "topic": "general"} return analysis_result @app.post("/crawl_website") async def crawl_website_endpoint(params: CrawlWebsiteParams): try: result = crawl_website(params.url, params.max_depth) return {"result": result} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.post("/extract_text") async def extract_text_endpoint(params: ExtractTextParams): try: result = extract_text(params.html_content) return {"result": result} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.post("/analyze_content") async def analyze_content_endpoint(params: AnalyzeContentParams): try: result = analyze_content(params.text) return {"result": result} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) ``` In the FastAPI example: * **Pydantic:** Pydantic is used to define data models (`CrawlWebsiteParams`, `ExtractTextParams`, `AnalyzeContentParams`). This provides automatic data validation and serialization. * **Type Hints:** Type hints are used extensively to improve code readability and help with static analysis. * **FastAPI Decorators:** FastAPI's decorators (`@app.post`) are used to define the API endpoints and the HTTP methods they handle. * **HTTPException:** `HTTPException` is used to raise HTTP errors with appropriate status codes and error messages. * **Separate Endpoints:** Each Crawl4AI function has its own dedicated endpoint (e.g., `/crawl_website`, `/extract_text`). This is generally a cleaner and more RESTful approach than a single `/mcp` endpoint. Remember to replace the mock functions with your actual Crawl4AI library calls. This comprehensive outline should give you a solid foundation for building your MCP server. Good luck!