Discover Awesome MCP Servers

agent-bus

Enables multiple coding agents (Claude Code, Codex, Cursor) to discover each other's sessions, search transcripts, ask questions, and handoff tasks through a shared MCP server.

prelaunch-mcp

Analyzes startup ideas against 6 sources (GitHub, HN, npm, PyPI, Google, Reddit) with LLM-powered intent parsing to assess competition, demand, and gaps.

claude-session-bus

Enables coordination and communication between multiple Claude Code sessions across machines via a chat server, providing tools for sending messages, waiting for responses, and managing session status.

Hacker News MCP Server

Enables LLMs to browse Hacker News stories, inspect items, and look up user profiles via the official Firebase API.

Slack Universal MCP Server

Provides a standardized interface for interacting with Slack's tools and services through a unified API, enabling integration with MCP-compliant applications.

kernel-mcp

An MCP server that enables AI-powered Linux kernel development, exposing tools for symbol search, static analysis, build automation, QEMU/GDB debugging, and more via IBM Bob.

Bitbucket Cloud MCP Server

Enables AI assistants to read Bitbucket Cloud pull requests and diffs through natural conversation.

Mcp Akshare

AKShareは、Pythonをベースとした金融データインターフェースライブラリであり、株式、先物、オプション、ファンド、外国為替、債券、指数、暗号通貨などの金融商品のファンダメンタルデータ、リアルタイムおよび過去の相場データ、派生データを、データ収集、データクレンジングからデータ格納まで一貫して行うためのツールです。主に学術研究を目的としています。

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!

fallmind-v2-mcp

MCP server for foldkit that exposes the 7-prime spine, 7 κ-bands, and 6 fold operations as tools and resources, enabling interaction with fold state analysis and manipulation via natural language in any MCP client.

UK Bus Departures MCP Server

Enables users to get real-time UK bus departure information and validate bus stop ATCO codes by scraping bustimes.org. Provides structured data including service numbers, destinations, scheduled and expected departure times for any UK bus stop.

Open Mind

Self-hosted personal knowledge base with semantic search, enabling AI agents to capture, search, and manage thoughts using PostgreSQL with pgvector.

Reddit MCP

Enables browsing, searching, and reading Reddit posts, comments, and subreddits through Reddit's API using PRAW.

XERT Cycling Training

Connect Claude to XERT cycling analytics - access fitness signature (FTP, LTP, HIE), training load, workouts, and activities.

Applitools MCP Server

Enables AI assistants to set up, manage, and analyze visual tests using Applitools Eyes within Playwright JavaScript and TypeScript projects. It supports adding visual checkpoints, configuring cross-browser testing via Ultrafast Grid, and retrieving structured test results.

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.

a207-his-mcp

Read-only MCP server providing pediatric CKD patient master data with tools for patient profiles, diagnosis, nutrition ceilings, guardian verification, and patient lists, designed for the CKDNutri project.

trae-memory

智能记忆系统，为TRAE IDE提供自动对话记录、上下文恢复和任务管理功能。

MCP Tailwind Gemini Server

Advanced Model Context Protocol server that integrates Gemini AI with Tailwind CSS, providing intelligent component generation, class optimization, and cross-platform design assistance across major development environments.

ha-mcp

A self-hosted MCP server for Home Assistant that exposes full control over entity states, service calls, history, templates, and areas via local stdio, enabling AI assistants to manage your smart home.

Bureau of Economic Analysis (BEA) MCP Server

Provides access to comprehensive U.S. economic data including GDP, personal income, and regional statistics via the Bureau of Economic Analysis API. It enables users to query datasets and retrieve specific economic indicators for states, counties, and industries through natural language.

mcp-servers

サーバーレス環境での MCP サーバー

Quack MCP Server

A continuous integration server that automates Python code analysis, providing linting and static type checking tools for quality assurance.

solana-infra-mcp

Provides Solana infrastructure awareness including RPC health, priority fee estimation, leader schedule, chain state, latency comparison, and keyless transaction submission.

COMSOL MCP Server

Enables AI agents to automate COMSOL Multiphysics simulations, including model management, geometry building, physics configuration, meshing, solving, and results visualization through the MCP protocol.

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.