Discover Awesome MCP Servers

Spiral MCP Server

一个模型上下文协议（Model Context Protocol）服务器实现，它为与 Spiral 的语言模型交互提供了一个标准化的接口，并提供从提示词、文件或 Web URL 生成文本的工具。

uniprot-link

An MCP server that grounds protein research in the UniProt SPARQL endpoint, providing tools for querying proteins, sequences, variants, diseases, and more via intent-named tools and raw SPARQL.

email-agent-mcp-server

Enables AI-powered Gmail triage: fetches unread emails, classifies them, drafts replies for important ones, and sends only after user approval via conversational review. Exposes tools for checking unread emails and submitting review feedback from Claude Desktop or any MCP client.

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.

mcp-gtags-server

Provides fast, indexed code navigation (definitions, references, callers, etc.) for AI coding agents by leveraging GNU Global (gtags), dramatically reducing context noise compared to grep.

@deepidv/mcp-server

Enables AI agents to perform identity verification, KYC/KYB, PEP & sanctions screening, bank statement analysis, and workflow automation via the Model Context Protocol.

Xero MCP Server

一个允许客户端与 Xero 会计软件交互的 MCP 服务器。

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.

Bitbucket Cloud MCP Server

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

Mcp Akshare

AKShare 是一个基于 Python 的金融数据接口库，旨在提供一套工具，用于采集、清洗和存储股票、期货、期权、基金、外汇、债券、指数、加密货币等金融产品的基本面数据、实时和历史行情数据以及衍生数据。它主要用于学术研究目的。

Peru Payments MCP

Enables AI agents to accept payments in Peru including Yape, PagoEfectivo, cards, and Mercado Pago wallet via hosted checkout. Acts as a stateless translation layer without storing funds or credentials.

Salesforce MCP Server

A comprehensive server that transforms Claude Desktop into a Salesforce IDE for managing metadata, executing SOQL queries, and automating multi-org operations. It provides 60 optimized tools for intelligent debugging, bulk data management, and Apex testing through natural language commands.

Datalog Studio MCP Server

Integrates with the Datalog Studio REST API to explore projects, tables, and assets within a workspace. It enables users to understand data schemas and upload plain text content directly for AI processing.

Kibana MCP Server

Enables AI assistants to interact with Kibana dashboards, visualizations, and Elasticsearch data through read-only resources and executable tools for searching logs, exporting dashboards, and querying data.

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.

AI Sticky Notes MCP Server

Enables AI assistants to save and retrieve persistent sticky notes across conversations, with tools, a resource, and a prompt for note management and summarization.

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.

AI Voice Assistant MCP Server

Enables a voice-enabled AI assistant to call 7 built-in MCP tools including calculator, web search (DuckDuckGo), weather (wttr.in), date/time, and local file read/write/list operations, integrating with Gemini 2.0 Flash for tool-calling conversations.

Hacker News MCP Server

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

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.

brocogni

semantic browser observation for AI agents via MCP, 100% local, zero telemetry

Tarot MCP Server

Provides tarot card reading capabilities with a complete 78-card deck, multiple spread layouts (Celtic Cross, Past-Present-Future, etc.), and detailed card interpretations for divination and daily guidance.

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.

mcp_server

Okay, I understand. You want me to describe how to implement a "weather MCP server" that can be called by a client IDE like Cursor. Here's a breakdown of the concept, implementation considerations, and a simplified example (using Python and a basic HTTP API) to illustrate the core ideas. **What is an MCP Server (in this context)?** In this scenario, "MCP" likely refers to a *Microservice Communication Protocol* or a similar concept. It means you're building a small, independent service (the weather server) that provides weather information and communicates with other applications (like the Cursor IDE) using a defined protocol. In practice, this often translates to a RESTful API over HTTP. **Key Components** 1. **Weather Data Source:** * This is where your server gets the actual weather information. You'll likely use a third-party weather API (e.g., OpenWeatherMap, AccuWeather, WeatherAPI.com). These APIs typically require you to sign up for an account and obtain an API key. * Consider caching the weather data to reduce the number of API calls and improve response times. 2. **Server-Side Implementation (e.g., Python with Flask/FastAPI):** * This is the core of your weather server. It handles incoming requests, fetches weather data from the data source, and formats the response. * **Framework Choice:** * **Flask:** A lightweight and flexible framework, good for simple APIs. * **FastAPI:** A modern, high-performance framework with automatic data validation and API documentation (using OpenAPI/Swagger). Generally preferred for new projects. * **API Endpoints:** You'll define endpoints like: * `/weather?city={city_name}`: Returns weather information for a specific city. * `/weather?zip={zip_code}`: Returns weather information for a specific zip code. * `/forecast?city={city_name}`: Returns a weather forecast for a specific city. 3. **Client-Side Integration (in Cursor IDE):** * The Cursor IDE (or any other client) will need to make HTTP requests to your weather server's API endpoints. * This might involve writing code within Cursor (e.g., using JavaScript or Python within a Cursor extension) to: * Get user input (e.g., the city name). * Construct the API request URL. * Send the request to the weather server. * Parse the JSON response from the server. * Display the weather information in the Cursor IDE. **Implementation Steps (Simplified Example with Python and Flask)** **1. Set up your environment:** ```bash # Create a project directory mkdir weather_server cd weather_server # Create a virtual environment (recommended) python3 -m venv venv source venv/bin/activate # On Linux/macOS # venv\Scripts\activate # On Windows # Install Flask and requests (for making HTTP requests to the weather API) pip install Flask requests ``` **2. `weather_server.py` (Flask Server):** ```python from flask import Flask, request, jsonify import requests import os app = Flask(__name__) # Replace with your actual OpenWeatherMap API key API_KEY = os.environ.get("OPENWEATHERMAP_API_KEY") or "YOUR_OPENWEATHERMAP_API_KEY" # Get from environment variable or hardcode (not recommended for production) BASE_URL = "https://api.openweathermap.org/data/2.5/weather" def get_weather_data(city): """Fetches weather data from OpenWeatherMap.""" params = { "q": city, "appid": API_KEY, "units": "metric", # Use Celsius } try: response = requests.get(BASE_URL, params=params) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() return data except requests.exceptions.RequestException as e: print(f"Error fetching weather data: {e}") return None @app.route("/weather") def weather(): """API endpoint to get weather by city.""" city = request.args.get("city") if not city: return jsonify({"error": "City parameter is required"}), 400 weather_data = get_weather_data(city) if weather_data: # Extract relevant information temperature = weather_data["main"]["temp"] description = weather_data["weather"][0]["description"] humidity = weather_data["main"]["humidity"] wind_speed = weather_data["wind"]["speed"] return jsonify({ "city": city, "temperature": temperature, "description": description, "humidity": humidity, "wind_speed": wind_speed }) else: return jsonify({"error": "Could not retrieve weather data for that city"}), 500 if __name__ == "__main__": app.run(debug=True) # Don't use debug=True in production! ``` **3. Running the Server:** ```bash # Set your OpenWeatherMap API key (replace with your actual key) export OPENWEATHERMAP_API_KEY="YOUR_OPENWEATHERMAP_API_KEY" # Linux/macOS # set OPENWEATHERMAP_API_KEY="YOUR_OPENWEATHERMAP_API_KEY" # Windows # Run the Flask server python weather_server.py ``` **4. Example Client-Side Code (Conceptual - in Cursor IDE):** This is a *very* simplified example of how you *might* integrate this into Cursor. The exact implementation will depend on Cursor's extension API and how you want to display the information. This assumes you can execute JavaScript or Python code within Cursor. ```javascript // Example JavaScript code (Conceptual - adapt to Cursor's API) async function getWeather(city) { const apiUrl = `http://127.0.0.1:5000/weather?city=${city}`; // Replace with your server's address try { const response = await fetch(apiUrl); const data = await response.json(); if (response.ok) { // Display the weather information in the Cursor IDE console.log(`Weather in ${data.city}:`); console.log(`Temperature: ${data.temperature}°C`); console.log(`Description: ${data.description}`); console.log(`Humidity: ${data.humidity}%`); console.log(`Wind Speed: ${data.wind_speed} m/s`); // You'd need to use Cursor's API to actually display this in the editor or a panel. // For example, Cursor might have a function like: // cursor.showInformationMessage(`Weather in ${data.city}: ...`); } else { console.error(`Error: ${data.error}`); // Display an error message in Cursor } } catch (error) { console.error("Error fetching weather:", error); // Display a network error in Cursor } } // Example usage: const cityName = "London"; // Or get the city from user input in Cursor getWeather(cityName); ``` **Explanation and Improvements** * **Error Handling:** The code includes basic error handling (checking for API errors, missing city parameter). Robust error handling is crucial for production. * **API Key Security:** *Never* hardcode your API key directly in the code, especially if you're sharing it. Use environment variables (as shown) or a configuration file. * **Asynchronous Operations:** Use `async/await` (as in the JavaScript example) to avoid blocking the UI thread while waiting for the API response. * **Data Validation:** Use a library like `marshmallow` (in Python) or a similar validation library in your chosen language to validate the data received from the weather API. This helps prevent unexpected errors. * **Caching:** Implement caching to store frequently accessed weather data. This reduces the load on the weather API and improves response times. You could use a simple in-memory cache (for small-scale deployments) or a more robust caching solution like Redis or Memcached. * **Rate Limiting:** Be aware of the rate limits imposed by the weather API you're using. Implement rate limiting in your server to avoid exceeding the limits and getting your API key blocked. * **Logging:** Use a logging library (e.g., `logging` in Python) to log important events, errors, and debugging information. * **API Documentation:** Use a tool like Swagger (with FastAPI) to automatically generate API documentation. This makes it easier for other developers to use your weather server. * **Deployment:** Consider deploying your weather server to a cloud platform like AWS, Google Cloud, or Azure. **Chinese Translation of Key Concepts** * **Weather MCP Server:** 天气 MCP 服务器 (Tiānqì MCP fúwùqì) * **Microservice Communication Protocol:** 微服务通信协议 (Wēi fúwù tōngxìn xiéyì) * **API Endpoint:** API 端点 (API duāndiǎn) * **RESTful API:** RESTful API (RESTful API) (The term is often used directly in Chinese as well) * **API Key:** API 密钥 (API mìyào) * **Data Source:** 数据源 (shùjù yuán) * **Caching:** 缓存 (huǎncún) * **Rate Limiting:** 速率限制 (sùlǜ xiànzhì) * **Error Handling:** 错误处理 (cuòwù chǔlǐ) * **Environment Variable:** 环境变量 (huánjìng biànliàng) **Important Considerations for Cursor Integration** * **Cursor's Extension API:** The most important thing is to understand Cursor's extension API. How can you create extensions, access the editor, display information, and get user input? Refer to Cursor's official documentation for this. * **Security:** Be very careful about security when integrating with an IDE. Avoid storing sensitive information (like API keys) directly in the extension code. Use secure storage mechanisms provided by the IDE or the operating system. * **User Experience:** Design the integration to be as seamless and intuitive as possible for the user. Consider how the weather information will be displayed (e.g., in a tooltip, a panel, or directly in the editor). This detailed explanation and example should give you a solid foundation for building your weather MCP server and integrating it with Cursor. Remember to adapt the code and concepts to your specific needs and the capabilities of the Cursor IDE. Good luck!

@kimagure-dd/xirr-mcp

MCP server for calculating XIRR (Extended Internal Rate of Return) from cash flows and Rakuten Securities CSV, enabling natural language portfolio performance queries.

Browser AI Debate MCP

An MCP server that orchestrates structured multi-round debates between ChatGPT Web and Gemini Web in the same Chrome browser via CDP, requiring no API keys.

linkedin-analyzer

MCP server that lets you analyze your own LinkedIn profile with a local LLM (LM Studio). It uses Playwright to reuse your browser session, fetch profile data as JSON, and provides tools for session management and profile analysis.