Discover Awesome MCP Servers

nano-banana-mcp

Enables AI image generation and editing using Google's Gemini models via natural language, supporting multi-turn editing, search grounding, storyboards, icon sets, and video-to-image.

Nav2 MCP Server

Enables control and monitoring of Nav2 navigation operations, including navigation, waypoints, costmap management, and lifecycle control, through the MCP protocol.

GeneChat MCP Server

A local-first MCP server that annotates whole-genome VCF files and lets you query pharmacogenomics, disease risk, and carrier status through natural language.

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.

munich-mensa-mcp

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

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

Sebuah server MCP berbasis Azure Functions yang memungkinkan interaksi dengan data karakter dan komik Marvel melalui API Pengembang Marvel resmi.

maya-mcp-server

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

turbovec-mcp

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

Planning MCP Server

Provides comprehensive Australian planning property reports, including zoning, overlays, land size, and utility information for AI assistants. This high-performance MCP server is built for Cloudflare Workers and enables real-time property data retrieval through an HTTP-based interface.

crawl4ai-mcp

```python from crawl4ai import Crawl4AI # Assuming crawl4ai is installed class MCP_Server: """ MCP (Model Context Protocol) server wrapping the Crawl4AI library. This class provides a simplified interface to the Crawl4AI library, exposing its functionality as functions that can be easily integrated into an MCP server environment. """ def __init__(self, api_key=None, proxy=None): """ Initializes the MCP_Server with Crawl4AI. Args: api_key (str, optional): Your Crawl4AI API key. Defaults to None. proxy (str, optional): Proxy server to use for requests. Defaults to None. """ self.crawl4ai = Crawl4AI(api_key=api_key, proxy=proxy) def crawl_website(self, url, max_depth=1, max_pages=10, follow_robots_txt=True, include_images=False, include_pdfs=False): """ Crawls a website and returns the extracted content. Args: url (str): The URL of the website to crawl. max_depth (int, optional): The maximum depth to crawl. Defaults to 1. max_pages (int, optional): The maximum number of pages to crawl. Defaults to 10. follow_robots_txt (bool, optional): Whether to follow robots.txt. Defaults to True. include_images (bool, optional): Whether to include image URLs in the output. Defaults to False. include_pdfs (bool, optional): Whether to include PDF URLs in the output. Defaults to False. Returns: dict: A dictionary containing the crawled data. The structure will depend on the Crawl4AI library's output. Likely to include keys like 'pages', 'images', 'pdfs', etc. Returns None if an error occurs. """ try: result = self.crawl4ai.crawl_website( url, max_depth=max_depth, max_pages=max_pages, follow_robots_txt=follow_robots_txt, include_images=include_images, include_pdfs=include_pdfs ) return result except Exception as e: print(f"Error during website crawl: {e}") return None def extract_text_from_url(self, url): """ Extracts text content from a single URL. Args: url (str): The URL to extract text from. Returns: str: The extracted text content, or None if an error occurs. """ try: text = self.crawl4ai.extract_text_from_url(url) return text except Exception as e: print(f"Error extracting text from URL: {e}") return None def extract_links_from_url(self, url): """ Extracts all links from a single URL. Args: url (str): The URL to extract links from. Returns: list: A list of URLs found on the page, or None if an error occurs. """ try: links = self.crawl4ai.extract_links_from_url(url) return links except Exception as e: print(f"Error extracting links from URL: {e}") return None # Add more functions as needed, wrapping other Crawl4AI functionalities # Example Usage (assuming you have an API key): if __name__ == '__main__': # Replace with your actual API key api_key = "YOUR_CRAWL4AI_API_KEY" mcp_server = MCP_Server(api_key=api_key) # Crawl a website url_to_crawl = "https://www.example.com" crawl_data = mcp_server.crawl_website(url_to_crawl, max_depth=2, max_pages=5) if crawl_data: print(f"Crawled data from {url_to_crawl}:") print(crawl_data) # Print the entire crawled data dictionary # You can then access specific parts of the data, e.g., # if 'pages' in crawl_data: # for page in crawl_data['pages']: # print(f" Page URL: {page['url']}") # print(f" Page Title: {page['title']}") # print(f" Page Content: {page['content']}") # Extract text from a URL url_to_extract = "https://www.example.com/some-page" extracted_text = mcp_server.extract_text_from_url(url_to_extract) if extracted_text: print(f"\nExtracted text from {url_to_extract}:") print(extracted_text[:200] + "...") # Print the first 200 characters # Extract links from a URL url_to_extract_links = "https://www.example.com/another-page" extracted_links = mcp_server.extract_links_from_url(url_to_extract_links) if extracted_links: print(f"\nExtracted links from {url_to_extract_links}:") for link in extracted_links: print(link) ``` **Explanation:** 1. **Import `Crawl4AI`:** The code starts by importing the `Crawl4AI` library. Make sure you have it installed (`pip install crawl4ai`). 2. **`MCP_Server` Class:** - **`__init__`:** The constructor initializes the `Crawl4AI` object with your API key and optional proxy settings. This is where you'll need to provide your actual Crawl4AI API key. - **`crawl_website`:** This function wraps the `crawl4ai.crawl_website()` method. It takes the URL and other crawling parameters as input and returns the crawled data (likely a dictionary). It also includes error handling using a `try...except` block. If an error occurs, it prints an error message and returns `None`. - **`extract_text_from_url`:** This function wraps the `crawl4ai.extract_text_from_url()` method. It extracts the text content from a given URL and returns it. It also includes error handling. - **`extract_links_from_url`:** This function wraps the `crawl4ai.extract_links_from_url()` method. It extracts all links from a given URL and returns them as a list. It also includes error handling. - **Error Handling:** Each function includes a `try...except` block to catch potential exceptions during the Crawl4AI operations. This is important for a robust server implementation. The error messages are printed to the console, but in a real server environment, you'd likely want to log them to a file or use a more sophisticated error reporting mechanism. 3. **Example Usage (`if __name__ == '__main__':`)** - **API Key:** The example code shows where to put your Crawl4AI API key. **Replace `"YOUR_CRAWL4AI_API_KEY"` with your actual key.** - **Instantiation:** It creates an instance of the `MCP_Server` class. - **Calling Functions:** It demonstrates how to call the `crawl_website`, `extract_text_from_url`, and `extract_links_from_url` functions. - **Printing Results:** It prints the results of the crawling and extraction operations. The `crawl_data` is printed as a dictionary. You'll need to examine the structure of the `crawl_data` dictionary to access the specific information you need (e.g., page titles, content, etc.). The example shows how to iterate through the `pages` if the `crawl_data` contains a 'pages' key. - **String Slicing:** The `extracted_text[:200] + "..."` part truncates the extracted text to the first 200 characters to avoid printing a very long string. **How to Integrate into an MCP Server:** This code provides the *functions* you need. To integrate it into an MCP server, you'll need to: 1. **Choose an MCP Server Framework:** Popular choices include: - **Flask:** A lightweight and flexible Python web framework. - **FastAPI:** A modern, high-performance web framework for building APIs. - **gRPC:** A high-performance, open-source universal RPC framework. 2. **Define API Endpoints:** Create API endpoints (routes) that correspond to the functions in the `MCP_Server` class. For example, you might have an endpoint `/crawl` that calls the `crawl_website` function. 3. **Receive Requests and Pass Parameters:** Your API endpoints will receive HTTP requests (or gRPC requests) containing the parameters for the Crawl4AI functions (e.g., the URL to crawl, the maximum depth, etc.). You'll need to extract these parameters from the request and pass them to the corresponding `MCP_Server` function. 4. **Return Results:** After calling the `MCP_Server` function, you'll need to format the results (e.g., as JSON) and return them as the response to the HTTP request (or gRPC response). **Example using Flask:** ```python from flask import Flask, request, jsonify from crawl4ai import Crawl4AI # Assuming crawl4ai is installed app = Flask(__name__) class MCP_Server: # (Same MCP_Server class as above) def __init__(self, api_key=None, proxy=None): """ Initializes the MCP_Server with Crawl4AI. Args: api_key (str, optional): Your Crawl4AI API key. Defaults to None. proxy (str, optional): Proxy server to use for requests. Defaults to None. """ self.crawl4ai = Crawl4AI(api_key=api_key, proxy=proxy) def crawl_website(self, url, max_depth=1, max_pages=10, follow_robots_txt=True, include_images=False, include_pdfs=False): """ Crawls a website and returns the extracted content. Args: url (str): The URL of the website to crawl. max_depth (int, optional): The maximum depth to crawl. Defaults to 1. max_pages (int, optional): The maximum number of pages to crawl. Defaults to 10. follow_robots_txt (bool, optional): Whether to follow robots.txt. Defaults to True. include_images (bool, optional): Whether to include image URLs in the output. Defaults to False. include_pdfs (bool, optional): Whether to include PDF URLs in the output. Defaults to False. Returns: dict: A dictionary containing the crawled data. The structure will depend on the Crawl4AI library's output. Likely to include keys like 'pages', 'images', 'pdfs', etc. Returns None if an error occurs. """ try: result = self.crawl4ai.crawl_website( url, max_depth=max_depth, max_pages=max_pages, follow_robots_txt=follow_robots_txt, include_images=include_images, include_pdfs=include_pdfs ) return result except Exception as e: print(f"Error during website crawl: {e}") return None def extract_text_from_url(self, url): """ Extracts text content from a single URL. Args: url (str): The URL to extract text from. Returns: str: The extracted text content, or None if an error occurs. """ try: text = self.crawl4ai.extract_text_from_url(url) return text except Exception as e: print(f"Error extracting text from URL: {e}") return None def extract_links_from_url(self, url): """ Extracts all links from a single URL. Args: url (str): The URL to extract links from. Returns: list: A list of URLs found on the page, or None if an error occurs. """ try: links = self.crawl4ai.extract_links_from_url(url) return links except Exception as e: print(f"Error extracting links from URL: {e}") return None # Replace with your actual API key api_key = "YOUR_CRAWL4AI_API_KEY" mcp_server = MCP_Server(api_key=api_key) @app.route('/crawl', methods=['POST']) def crawl_endpoint(): """ API endpoint for crawling a website. """ try: data = request.get_json() url = data['url'] max_depth = data.get('max_depth', 1) # Use .get() for optional parameters max_pages = data.get('max_pages', 10) follow_robots_txt = data.get('follow_robots_txt', True) include_images = data.get('include_images', False) include_pdfs = data.get('include_pdfs', False) crawl_data = mcp_server.crawl_website( url, max_depth=max_depth, max_pages=max_pages, follow_robots_txt=follow_robots_txt, include_images=include_images, include_pdfs=include_pdfs ) if crawl_data: return jsonify(crawl_data), 200 # Return JSON with status code 200 (OK) else: return jsonify({"error": "Crawl failed"}), 500 # Return error with status code 500 (Internal Server Error) except Exception as e: print(f"Error in /crawl endpoint: {e}") return jsonify({"error": str(e)}), 400 # Return error with status code 400 (Bad Request) @app.route('/extract_text', methods=['POST']) def extract_text_endpoint(): """ API endpoint for extracting text from a URL. """ try: data = request.get_json() url = data['url'] extracted_text = mcp_server.extract_text_from_url(url) if extracted_text: return jsonify({"text": extracted_text}), 200 else: return jsonify({"error": "Text extraction failed"}), 500 except Exception as e: print(f"Error in /extract_text endpoint: {e}") return jsonify({"error": str(e)}), 400 @app.route('/extract_links', methods=['POST']) def extract_links_endpoint(): """ API endpoint for extracting links from a URL. """ try: data = request.get_json() url = data['url'] extracted_links = mcp_server.extract_links_from_url(url) if extracted_links: return jsonify({"links": extracted_links}), 200 else: return jsonify({"error": "Link extraction failed"}), 500 except Exception as e: print(f"Error in /extract_links endpoint: {e}") return jsonify({"error": str(e)}), 400 if __name__ == '__main__': app.run(debug=True) # Use debug=False in production ``` **To run the Flask example:** 1. **Install Flask:** `pip install Flask` 2. **Save the code:** Save the code as a Python file (e.g., `mcp_server.py`). 3. **Run the file:** `python mcp_server.py` 4. **Test the endpoints:** You can use `curl`, `Postman`, or any other HTTP client to send requests to the API endpoints. For example: ```bash # Crawl a website curl -X POST -H "Content-Type: application/json" -d '{"url": "https://www.example.com", "max_depth": 2}' http://127.0.0.1:5000/crawl # Extract text from a URL curl -X POST -H "Content-Type: application/json" -d '{"url": "https://www.example.com/some-page"}' http://127.0.0.1:5000/extract_text # Extract links from a URL curl -X POST -H "Content-Type: application/json" -d '{"url": "https://www.example.com/another-page"}' http://127.0.0.1:5000/extract_links ``` **Key improvements in the Flask example:** * **Flask Integration:** The code is now a complete Flask application. * **API Endpoints:** It defines three API endpoints: `/crawl`, `/extract_text`, and `/extract_links`. * **Request Handling:** It uses `request.get_json()` to parse the JSON data sent in the request body. * **Parameter Extraction:** It extracts the parameters from the JSON data and passes them to the `MCP_Server` functions. It uses `data.get('max_depth', 1)` to handle optional parameters, providing default values if they are not present in the request. * **JSON Responses:** It uses `jsonify()` to format the results as JSON and returns them as the response to the HTTP request. * **Error Handling:** It includes `try...except` blocks to catch exceptions in the API endpoints and returns appropriate error responses with HTTP status codes (400, 500). * **HTTP Status Codes:** It returns appropriate HTTP status codes (200 OK, 400 Bad Request, 500 Internal Server Error) to indicate the success or failure of the request. * **Clearer Error Messages:** The error messages returned in the JSON responses are more informative. Remember to replace `"YOUR_CRAWL4AI_API_KEY"` with your actual API key. Also, in a production environment, you should use a more robust web server (like Gunicorn or uWSGI) instead of the Flask development server. You should also set `debug=False` in `app.run()`. This comprehensive example provides a solid foundation for building an MCP server that wraps the Crawl4AI library. You can adapt it to your specific needs by adding more API endpoints, customizing the error handling, and integrating it with other components of your MCP system.

Vision-OCR-MCP

Enables OCR on images and PDFs, including full-page OCR, region OCR by description or bounding box, and caching with summary capabilities.

UniProt MCP Server

UniProt MCP Server

mcp-voice-hooks

Voice Mode for Claude Code

HueMCP

Enables discovery and control of Philips Hue lighting devices via a local bridge using the CLIP v2 API, without any cloud dependency.

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.

RAGSHIELD

RAG corpus poisoning detector that scans for embedding anomalies and backdoor triggers, with an MCP server for AI agent integration.

CSOAI Governance Crosswalk MCP

CSOAI Governance Crosswalk - MCP server providing AI-powered tools and automation by MEOK AI Labs

memex

Zettelkasten-based persistent memory for AI coding agents. Auto-saves atomic knowledge cards with \[\[bidirectional links]] after tasks and auto-recalls before new ones. No vector DB — plain markdown files with git sync. Works as Claude Code plugin or MCP server for Cursor, VS Code Copilot, Codex, and Windsurf.

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.

Etsy MCP Server

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

meetup-mcp-server

An MCP server for automating Meetup event tracking with an AI agent. It equips the agent with tools to browse Meetup.com, detect new events since the last known record, and return structured event data.

@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.