Discover Awesome MCP Servers

ETH Price Current Server

A minimal Model Context Protocol (MCP) server that fetches the current Ethereum (ETH) price in USD. Data source: the public CoinGecko API (no API key required). This MCP is designed to simulate malicious behavior, specifically an attempt to mislead LLM to return incorrect results.

Teable MCP Server

Connects Teable no-code databases to LLMs, enabling AI agents to query records, explore schema structures, retrieve data history, and interact with spaces, bases, tables, and views using natural language.

MCP Demo Server

A minimal fastmcp demonstration server that provides a simple addition tool through the MCP protocol, supporting deployment via Docker with multiple transport modes.

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!

applemail-mcp-server

A local MCP server that lets Claude read macOS Mail.app via JXA, with tools for listing accounts/mailboxes, searching and reading messages. Read-only by default, with optional opt-in write tools for compose drafts and Apple Calendar events.

jira-minimal-mcp

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

MCP-Odoo

A bridge that allows AI agents to access and manipulate Odoo ERP data through a standardized Model Context Protocol interface, supporting partner information, accounting data, financial records reconciliation, and invoice queries.

Google Workspace MCP Server

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

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.

demandscope

MCP server that provides demand-signal scanning tools from GitHub, Hacker News, npm, and PyPI to validate digital-product and dev-tool ideas. Enables agents to query repo signals, trends, and download counts via stdio JSON-RPC.

flstudio-mcp-mac

Enables controlling FL Studio on macOS via MCP, including transport, mixer, channel, MIDI export, and Piano Roll note insertion.

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.

musfiraai-mcp-server

Exposes Musfiraai's company info, services, AI stack, FAQ, reviews, and contact details as MCP tools/resources/prompts, enabling any MCP-compatible AI client to query this data via natural language.

Score de Crédito

Enables credit score and risk analysis queries for Brazilian individuals (CPF) and companies (CNPJ) via MCP over HTTP, with a single read-only tool and prepaid usage.

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.

mcp-cli-catalog

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

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.

Dynatrace MCP Server

Enables interaction with Dynatrace Grail and API endpoints by executing DQL queries, retrieving logs, reporting active problems, and querying metrics.

context-ledger

Provides local, explicitly scoped memory for coding agents via MCP, storing durable project knowledge in a per-repository SQLite database with tools to record, search, and retrieve context.

samskriti-project

A local MCP server that enables multiple AI coding tools to share structured project state (decisions, tasks, bugs) so they coordinate without re-explaining.

CRM Agent Tools

Provides Claude agents with CRM contact lookup, action logging, and prompt cost auditing tools. Includes a Streamlit UI to demo the same tools without an MCP client.

Hyperion V2

Universal MCP server that enables any LLM agent (Claude, Cursor, Cline) to control a real Chrome browser with 5 perception engines, resilient heartbeat, and real-time vision streaming.

Gopher & Gemini MCP Server

Enables AI assistants to browse and interact with both Gopher and Gemini protocol resources safely and efficiently.

Image Process MCP Server

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

pixso-mcp-server

Brings Pixso design context into AI coding workflows, enabling AI assistants to understand design layers, component variants, variables, and local styles for design-to-code tasks.

TickDB MCP

Unified real-time & historical market data API for Forex, stocks (US/HK/A-share), crypto, indices & precious metals. Tick, order book depth & K-line via REST + WebSocket. AI-native: MCP server, Skill & CLI.

herald

An MCP server that allows AI assistants to send formatted text, files, and updates to Telegram topics, and to capture incoming messages from work chats into a local inbox for retrieval.

withings-mcp

Read-only Model Context Protocol server for Withings weight and body-composition history, providing normalized measurements, weight history, and latest measurements via OAuth 2.0.

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.