Discover Awesome MCP Servers

MCP Reference Server

A comprehensive reference implementation demonstrating all features of the Model Context Protocol (MCP) specification, serving as documentation, learning resource, and testing tool for MCP implementations.

Image Process MCP Server

画像処理を行うためのMCPサーバーで、Sharpライブラリを使用して画像操作機能を提供します。

microsoft-todo-mcp-server-self-hosted

A self-hosted Model Context Protocol server for Microsoft To Do. The key problem this solves: the Microsoft Graph API silently omits user-created lists on personal accounts (GET /me/todo/lists only returns well-known lists like "Flagged Emails"). This server works around it with a local SQLite registry that tracks every list you create, so your lists always show up.

ai-visibility-mcp

Audits AI-bot visibility: robots.txt per-bot for 22 AI user-agents (GPTBot/ClaudeBot/PerplexityBot/etc), Cloudflare flags, JSON-LD, sitemap, llms.txt, SPA shell, plus cross-model brand mentions via Perplexity + OpenRouter. 0-100 score. SSRF-guarded, spend-capped.

drawio-mcp

Enables AI assistants to generate professional UML diagrams (class, use case, activity, sequence) from natural language descriptions, producing editable .drawio files compatible with diagrams.net.

codesafer

CodeSafer is an MCP server that scans AI-generated code for 9 categories of hidden security threats — including invisible Unicode, Trojan Source, homoglyphs, and rules file backdoors — using static analysis plus CodeBERT deep learning. Runs locally, free tier available.

Schedule MCP Server

Integrates Google Calendar and Notion to enable Claude to manage your schedule, plan tasks, detect conflicts, and keep appointments and tasks synchronized.

Skyvern MCP

Skyvern MCP server lets AI agents control a real browser to navigate websites, fill forms, authenticate, and extract structured data. Supports multi-step automation workflows via natural language.

VA-MCP

An MCP server for checking OWASP Top 10 vulnerabilities during API development testing. It analyzes API information and returns security assessment results to help developers identify potential security issues.

Piazza MCP Server

Enables AI agents to browse, search, and read content from Piazza course forums. It provides tools to list enrolled classes, search posts by keywords or folders, and retrieve full discussion threads including answers and follow-ups.

@noticed/cli

CLI and stdio MCP server for noticed. Exposes ~50 noticed agent capabilities (network search across GitHub + LinkedIn, missions, PRM, memory, workspace, web search, cron, ...) via two meta-tools — search + execute — to any MCP-aware client (Claude Code, Claude Desktop, Cursor, ChatGPT).

Enhanced Gemini MCP Server

Leverages Google's Gemini AI with a 1M token context window for comprehensive codebase analysis, enabling intelligent code search, architecture analysis, and targeted improvement suggestions.

Google Workspace MCP Server

Enables management of Google Workspace apps (Docs, Sheets, Gmail, Calendar, Drive) from the command line via Gemini CLI.

Remote MCP Server on Cloudflare

A Model Context Protocol server that runs on Cloudflare Workers with OAuth login, allowing clients like Claude Desktop to connect to it for tool-augmented AI interactions.

Confluence MCP Server

Enables integration with Atlassian Confluence to browse spaces, search content using CQL, and manage pages directly from MCP-compatible applications. It automatically converts Confluence storage formats into markdown for seamless interaction with AI-driven editors and tools.

Freedcamp MCP Server

A Model Context Protocol server that enables seamless integration with Freedcamp API for enterprise-level project management with advanced filtering, full CRUD operations, and extensive customization options.

angular-i18n-mcp

Manages Angular internationalization (i18n) by extracting, listing, and updating translation strings in XLIFF format through MCP tools.

MCP Servers for Teams

MCPサーバーのデプロイ例

jira-minimal-mcp

Minimal MCP server for Jira with configurable tools to reduce token usage, starting from ~150 tokens for basic issue retrieval.

MCP DateTime Server

Provides current local datetime information with timezone support. Serves as a minimal blueprint for building simple, single-purpose MCP servers.

max2021-mcp

Enables execution of Python and MaxScript code inside Autodesk 3ds Max 2021 from Cursor or other MCP clients via HTTP+TCP bridge.

MCP Agent & Server Ecosystem

An autonomous agent ecosystem that leverages Groq for high-performance reasoning and Playwright for web automation via the Model Context Protocol. It features an interactive CLI and a custom server providing a run_task tool for orchestrating multi-server workflows.

Subwatch MCP

Enables reading public Reddit posts and comments on demand, with tools to search, get recent posts, post details, top comments, and server status. Runs on Cloudflare Workers for use with Claude and Open WebUI.

ha-nexus-agent

MCP server for Home Assistant — 202 tools across 21 domains; full control of your smart home from Claude / Cursor / VS Code / any MCP client

mcp-cli-catalog

An MCP server that publishes CLI tools on your machine for discoverability by LLMs

todo2code

MCP server that extracts and links code, tasks, documentation, and git history into a graph, then diagnoses discrepancies and generates reports.

minesweeper-mcp

A stdio-based MCP server that enables users to play and manage Minesweeper games through a Rails 8 REST API. It provides tools to start games, track states, and perform actions like opening cells and flagging mines.

React USWDS MCP Server

Indexes the locally-installed @trussworks/react-uswds package and helps code assistants discover components, inspect props, generate correct imports and usage snippets, and suggest appropriate components for UI use cases.

temporal-mcp-server

Enables AI assistants to observe and manage Temporal workflows, including listing, starting, signaling, resetting, terminating, querying, and retrieving history, with support for wait_for_activity and webhook utilities.

mcp_server

Okay, I understand. You want me to describe how to implement a weather MCP (Message Passing Communication) server that can be called by a client IDE like Cursor. Here's a breakdown of the implementation, covering key aspects and considerations: **1. Core Concepts and Technologies** * **MCP (Message Passing Communication):** The server and client will communicate by exchanging messages. This is a general concept, and you'll need to choose a specific protocol for message formatting and transport. Common choices include: * **JSON-RPC:** A simple, lightweight RPC protocol that uses JSON for message encoding. It's well-suited for this kind of application. * **gRPC:** A high-performance RPC framework developed by Google. It uses Protocol Buffers for message serialization and supports multiple languages. It's more complex than JSON-RPC but offers better performance and type safety. * **WebSockets:** Provides full-duplex communication over a single TCP connection. Useful if you want real-time updates or a persistent connection. * **Server-Side Language/Framework:** Choose a language and framework suitable for building a server. Good options include: * **Python (with Flask or FastAPI):** Easy to learn, has excellent libraries for web development and JSON handling. Flask is a microframework, while FastAPI is a modern, high-performance framework. * **Node.js (with Express):** JavaScript runtime environment. Express is a popular web framework. * **Go (with net/http or Gin):** A fast, efficient language. Gin is a lightweight web framework. * **Java (with Spring Boot):** A robust and widely used framework for building enterprise applications. * **Weather Data Source:** You'll need an API to fetch weather data. Popular options include: * **OpenWeatherMap:** Offers a free tier with limitations and paid plans for more features. * **WeatherAPI.com:** Another popular option with a free tier and paid plans. * **AccuWeather:** Provides weather data and forecasts. * **National Weather Service (NWS) API (US):** Free and open data, but only for the US. * **IDE Client (Cursor):** You'll need to write code within Cursor (or a similar IDE) to send requests to the weather server and display the results. This will likely involve using the IDE's capabilities for making HTTP requests or establishing a WebSocket connection. **2. Server-Side Implementation (Example using Python and Flask/FastAPI with JSON-RPC)** ```python # Example using Flask from flask import Flask, request, jsonify import requests import os app = Flask(__name__) # Replace with your actual API key and weather API endpoint WEATHER_API_KEY = os.environ.get("WEATHER_API_KEY") # Get API key from environment variable WEATHER_API_URL = "http://api.openweathermap.org/data/2.5/weather" def get_weather(city): """Fetches weather data from the OpenWeatherMap API.""" try: params = { 'q': city, 'appid': WEATHER_API_KEY, 'units': 'metric' # Use Celsius } response = requests.get(WEATHER_API_URL, params=params) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() return { 'city': data['name'], 'temperature': data['main']['temp'], 'description': data['weather'][0]['description'], 'humidity': data['main']['humidity'], 'wind_speed': data['wind']['speed'] } except requests.exceptions.RequestException as e: return {'error': f"Error fetching weather data: {e}"} except KeyError: return {'error': "Invalid weather data format received."} except Exception as e: return {'error': f"An unexpected error occurred: {e}"} @app.route('/', methods=['POST']) def handle_request(): """Handles JSON-RPC requests.""" try: request_data = request.get_json() method = request_data.get('method') params = request_data.get('params', {}) request_id = request_data.get('id') if method == 'get_weather': city = params.get('city') if not city: result = {'error': 'City parameter is required'} else: result = get_weather(city) else: result = {'error': 'Method not found'} response = { 'jsonrpc': '2.0', 'result': result, 'id': request_id } return jsonify(response) except Exception as e: response = { 'jsonrpc': '2.0', 'error': str(e), 'id': None } return jsonify(response), 500 # Internal Server Error if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) # Listen on all interfaces ``` **Explanation of the Python/Flask Example:** 1. **Imports:** Imports necessary libraries (Flask, requests, jsonify). 2. **API Key:** Stores the OpenWeatherMap API key. **Important:** It's best practice to store API keys in environment variables rather than hardcoding them in your script. The code uses `os.environ.get("WEATHER_API_KEY")` to retrieve the key from the environment. 3. **`get_weather(city)` Function:** * Takes a city name as input. * Constructs the API request URL with the city and API key. * Uses the `requests` library to make the API call. * Handles potential errors (e.g., network errors, invalid API key, city not found). * Parses the JSON response from the weather API and extracts relevant information (temperature, description, etc.). * Returns a dictionary containing the weather data or an error message. 4. **`handle_request()` Function:** * This is the Flask route that handles incoming requests. It's mapped to the root URL (`/`) and only accepts POST requests. * Parses the JSON request body using `request.get_json()`. * Extracts the `method`, `params`, and `id` from the JSON-RPC request. * If the `method` is `get_weather`: * Extracts the `city` parameter from the `params`. * Calls the `get_weather()` function to fetch the weather data. * Constructs a JSON-RPC response with the `result` (weather data or error) and the original `id`. * Returns the JSON response using `jsonify()`. * Includes error handling to catch exceptions and return appropriate JSON-RPC error responses. 5. **`if __name__ == '__main__':` Block:** * Starts the Flask development server when the script is run directly. * `debug=True` enables debugging mode (useful during development). **Important:** Disable debugging mode in production. * `host='0.0.0.0'` makes the server accessible from any IP address (useful for testing on different machines). In production, you might want to bind to a specific IP address. * `port=5000` specifies the port the server will listen on. **Example using FastAPI** ```python from fastapi import FastAPI, HTTPException from pydantic import BaseModel import requests import os app = FastAPI() WEATHER_API_KEY = os.environ.get("WEATHER_API_KEY") WEATHER_API_URL = "http://api.openweathermap.org/data/2.5/weather" class WeatherResponse(BaseModel): city: str temperature: float description: str humidity: int wind_speed: float class ErrorResponse(BaseModel): error: str @app.post("/get_weather", response_model=WeatherResponse, responses={500: {"model": ErrorResponse}}) async def get_weather(city: str): """Fetches weather data for a given city.""" try: params = { 'q': city, 'appid': WEATHER_API_KEY, 'units': 'metric' } response = requests.get(WEATHER_API_URL, params=params) response.raise_for_status() data = response.json() return WeatherResponse( city=data['name'], temperature=data['main']['temp'], description=data['weather'][0]['description'], humidity=data['main']['humidity'], wind_speed=data['wind']['speed'] ) except requests.exceptions.RequestException as e: raise HTTPException(status_code=500, detail=f"Error fetching weather data: {e}") except KeyError: raise HTTPException(status_code=500, detail="Invalid weather data format received.") except Exception as e: raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {e}") ``` **Explanation of the Python/FastAPI Example:** 1. **Imports:** Imports necessary libraries (FastAPI, pydantic, requests). 2. **API Key:** Same as Flask example, retrieves API key from environment variable. 3. **Data Models (Pydantic):** Defines `WeatherResponse` and `ErrorResponse` models using Pydantic. This provides type validation and automatic data serialization/deserialization. 4. **`get_weather(city: str)` Function:** * Uses FastAPI's dependency injection to receive the `city` as a query parameter. * The rest of the logic is similar to the Flask example, but it uses `raise HTTPException` to return HTTP error responses with appropriate status codes and error messages. * Returns a `WeatherResponse` object if successful. 5. **FastAPI Decorators:** * `@app.post("/get_weather", response_model=WeatherResponse, responses={500: {"model": ErrorResponse}})`: This decorator defines the endpoint: * `/get_weather`: The URL path. * `response_model=WeatherResponse`: Specifies the data model for successful responses. * `responses={500: {"model": ErrorResponse}}`: Specifies the data model for 500 Internal Server Error responses. **3. Client-Side Implementation (Cursor IDE)** ```javascript // Example JavaScript code to run within Cursor (or a similar IDE) async function getWeather(city) { const serverUrl = 'http://localhost:5000/'; // Replace with your server URL const requestBody = { jsonrpc: '2.0', method: 'get_weather', params: { city: city }, id: 1 // Unique ID for the request }; try { const response = await fetch(serverUrl, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(requestBody) }); if (!response.ok) { throw new Error(`HTTP error! Status: ${response.status}`); } const data = await response.json(); if (data.error) { console.error('Error from server:', data.error); return null; // Or handle the error appropriately } const weatherData = data.result; if (weatherData.error) { console.error('Error from weather API:', weatherData.error); return null; } console.log('Weather in', weatherData.city); console.log('Temperature:', weatherData.temperature, '°C'); console.log('Description:', weatherData.description); console.log('Humidity:', weatherData.humidity, '%'); console.log('Wind Speed:', weatherData.wind_speed, 'm/s'); return weatherData; // Return the weather data } catch (error) { console.error('Error:', error); return null; // Or handle the error appropriately } } // Example usage: getWeather('London') .then(weather => { if (weather) { // Do something with the weather data (e.g., display it in the IDE) console.log('Weather data received:', weather); } else { console.log('Failed to get weather data.'); } }); ``` **Explanation of the JavaScript Client Code:** 1. **`getWeather(city)` Function:** * Takes a city name as input. * Defines the `serverUrl` (the address of your weather server). **Important:** Make sure this URL is correct. * Constructs the JSON-RPC request body with the `method`, `params`, and `id`. * Uses the `fetch` API to make a POST request to the server. * Sets the `Content-Type` header to `application/json`. * Stringifies the request body using `JSON.stringify()`. * Handles potential errors (e.g., network errors, server errors). * Parses the JSON response from the server using `response.json()`. * Checks for errors in the response (both JSON-RPC errors and errors from the weather API). * Extracts the weather data from the `data.result` field. * Logs the weather information to the console. * Returns the weather data. 2. **Example Usage:** * Calls the `getWeather()` function with a city name. * Uses a `.then()` block to handle the result of the asynchronous `getWeather()` function. * If the weather data is successfully retrieved, it logs the data to the console. * If there's an error, it logs an error message. **How to Use in Cursor:** 1. **Create a JavaScript File:** Create a new JavaScript file (e.g., `weather_client.js`) in your Cursor project. 2. **Paste the Code:** Paste the JavaScript code into the file. 3. **Modify the `serverUrl`:** Make sure the `serverUrl` in the code points to the correct address of your weather server (e.g., `http://localhost:5000/`). 4. **Run the Code:** You can run the code in Cursor's integrated terminal or by using a JavaScript execution environment within the IDE. The output (weather information or error messages) will be displayed in the console. **4. Key Considerations and Enhancements** * **Error Handling:** Implement robust error handling on both the server and client sides. This includes handling network errors, API errors, invalid input, and unexpected exceptions. Return informative error messages to the client. * **API Key Security:** Never hardcode your API key directly in your code. Store it in an environment variable or a configuration file and load it at runtime. This prevents your API key from being exposed if you share your code. * **Rate Limiting:** Be aware of the rate limits of the weather API you're using. Implement caching or other strategies to avoid exceeding the rate limits. * **Data Validation:** Validate the input data (e.g., city name) on the server side to prevent errors and security vulnerabilities. * **Asynchronous Operations:** Use asynchronous operations (e.g., `async/await` in JavaScript and Python) to avoid blocking the main thread and improve performance. * **Logging:** Implement logging on the server side to track requests, errors, and other important events. This can be helpful for debugging and monitoring. * **Authentication/Authorization:** If you need to restrict access to your weather server, implement authentication and authorization mechanisms. * **Deployment:** Consider how you will deploy your weather server. Options include: * **Local Development:** Run the server on your local machine for testing. * **Cloud Platform (e.g., AWS, Google Cloud, Azure):** Deploy the server to a cloud platform for production use. * **Containerization (Docker):** Package the server in a Docker container for easy deployment and portability. * **Testing:** Write unit tests and integration tests to ensure that your server and client code are working correctly. * **Documentation:** Document your API and code to make it easier for others (and yourself) to understand and use. * **JSON-RPC Library:** Consider using a dedicated JSON-RPC library for your chosen language. These libraries can simplify the process of handling JSON-RPC requests and responses. For example, in Python, you could use `jsonrpcserver`. * **CORS (Cross-Origin Resource Sharing):** If your client-side code is running in a browser and your server is running on a different domain, you'll need to configure CORS on the server to allow cross-origin requests. Flask and FastAPI have built-in support for CORS. **Example JSON-RPC Request (from Client to Server):** ```json { "jsonrpc": "2.0", "method": "get_weather", "params": { "city": "New York" }, "id": 123 } ``` **Example JSON-RPC Response (from Server to Client - Success):** ```json { "jsonrpc": "2.0", "result": { "city": "New York", "temperature": 25.5, "description": "Clear sky", "humidity": 60, "wind_speed": 5.2 }, "id": 123 } ``` **Example JSON-RPC Response (from Server to Client - Error):** ```json { "jsonrpc": "2.0", "error": "City not found", "id": 123 } ``` This comprehensive guide should give you a solid foundation for implementing your weather MCP server and client. Remember to adapt the code and configurations to your specific needs and environment. Good luck!