Discover Awesome MCP Servers

dbt-cloud-migrate

Audits dbt Core projects for migration blockers and generates actionable guidance for migrating to dbt Cloud, including auto-fixing deprecated syntax.

onyx-paid-mcp

Build a paid MCP server that charges AI agents per call in USDC, with automatic payment handling via HTTP 402 and EIP-3009.

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.

MotorAPI MCP Server

MCP server for looking up Danish vehicle information by registration number or VIN via MotorAPI.dk, including vehicle details, environmental data, equipment, and API usage.

Melchizedek

Persistent memory for Claude Code. Automatically indexes every conversation and provides production-grade hybrid search (BM25 + vectors + reranker) via MCP tools. 100% local, zero config, zero API keys, zero invoice.

neo4j-gds

Enables LLMs to run complex graph algorithms on Neo4j databases, answering graph-related questions by selecting and executing appropriate parameterised graph algorithms.

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 é uma biblioteca de interface de dados financeiros baseada em Python, com o objetivo de implementar um conjunto de ferramentas para dados fundamentais, dados de mercado em tempo real e históricos, e dados derivados de produtos financeiros como ações, futuros, opções, fundos, câmbio, títulos, índices e criptomoedas, desde a coleta de dados, limpeza de dados até o armazenamento de dados, principalmente para fins de pesquisa acadêmica.

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.

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_server

Okay, I understand. You want me to describe how to implement a weather MCP (Message Client Protocol) server that can be called by a client IDE like Cursor. Here's a breakdown of the implementation, covering key aspects and considerations: **1. Understanding the Requirements** * **MCP (Message Client Protocol):** MCP is a relatively simple protocol, often used for communication between applications. It's typically text-based and uses delimiters to separate messages. We'll need to define the specific MCP format for our weather server. * **Weather Data Source:** You'll need a reliable source of weather data. This could be: * **A free weather API:** Examples include OpenWeatherMap, WeatherAPI.com (check their free tiers and usage limits). * **A paid weather API:** Provides more features, higher limits, and potentially better accuracy. * **A local weather data file:** For testing or if you have your own data source. * **Client IDE (Cursor):** The server needs to be designed so that Cursor can easily send requests and receive responses. This means using a standard communication method (like TCP sockets) and a well-defined MCP format. * **Functionality:** At a minimum, the server should be able to: * Get the current weather for a given location (e.g., city, zip code, latitude/longitude). * Potentially provide a forecast for a given location. **2. Defining the MCP Format** This is crucial. Let's define a simple MCP format for our weather server. We'll use a newline character (`\n`) as the delimiter between messages. * **Request Format (Client to Server):** ``` GET_WEATHER <location>\n GET_FORECAST <location>\n ``` * `GET_WEATHER`: Requests the current weather for the specified location. * `GET_FORECAST`: Requests a weather forecast for the specified location. * `<location>`: The location to get weather data for (e.g., "London", "90210", "40.7128,-74.0060"). You'll need to decide how you want to handle different location formats. * **Response Format (Server to Client):** ``` WEATHER <location> <temperature> <condition> <humidity>\n FORECAST <location> <day1_condition> <day1_high> <day1_low> <day2_condition> ...\n ERROR <message>\n ``` * `WEATHER`: Indicates the current weather data. * `<location>`: The location the weather data is for. * `<temperature>`: The current temperature (e.g., in Celsius or Fahrenheit). * `<condition>`: A brief description of the weather (e.g., "Sunny", "Cloudy", "Rainy"). * `<humidity>`: The current humidity (e.g., as a percentage). * `FORECAST`: Indicates the weather forecast data. * `<location>`: The location the forecast is for. * `<day1_condition>`, `<day1_high>`, `<day1_low>`, etc.: Forecast data for each day. You'll need to define how many days of forecast you'll provide and the format of the data. * `ERROR`: Indicates an error occurred. * `<message>`: A description of the error. **3. Server Implementation (Python Example)** Here's a basic Python example using the `socket` module. This is a simplified version; you'll need to add error handling, more robust data parsing, and potentially threading for handling multiple clients concurrently. ```python import socket import json # For parsing JSON responses from weather APIs import requests # For making HTTP requests to weather APIs # Configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) WEATHER_API_KEY = "YOUR_OPENWEATHERMAP_API_KEY" # Replace with your API key WEATHER_API_URL = "http://api.openweathermap.org/data/2.5/weather?q={}&appid={}&units=metric" # Example URL def get_weather_data(location): """Fetches weather data from a weather API.""" try: url = WEATHER_API_URL.format(location, WEATHER_API_KEY) response = requests.get(url) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() temperature = data['main']['temp'] condition = data['weather'][0]['description'] humidity = data['main']['humidity'] return temperature, condition, humidity except requests.exceptions.RequestException as e: print(f"Error fetching weather data: {e}") return None, None, None except (KeyError, IndexError) as e: print(f"Error parsing weather data: {e}") return None, None, None def handle_client(conn, addr): """Handles communication with a single client.""" print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive data from the client if not data: break # Client disconnected message = data.decode('utf-8').strip() print(f"Received: {message}") if message.startswith("GET_WEATHER"): try: location = message.split(" ")[1] temperature, condition, humidity = get_weather_data(location) if temperature is not None: response = f"WEATHER {location} {temperature} {condition} {humidity}\n" else: response = f"ERROR Could not retrieve weather for {location}\n" except IndexError: response = "ERROR Invalid request format. Use GET_WEATHER <location>\n" except Exception as e: response = f"ERROR An unexpected error occurred: {e}\n" elif message.startswith("GET_FORECAST"): # Implement forecast logic here (similar to GET_WEATHER) location = message.split(" ")[1] response = f"ERROR Forecast functionality not yet implemented for {location}\n" else: response = "ERROR Invalid command\n" conn.sendall(response.encode('utf-8')) # Send the response back to the client conn.close() print(f"Connection closed with {addr}") def main(): """Main server function.""" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() # Accept incoming connections handle_client(conn, addr) # Handle the client in a separate function (or thread) if __name__ == "__main__": main() ``` Key improvements and explanations: * **Error Handling:** Includes `try...except` blocks to catch potential errors during API requests, JSON parsing, and other operations. This prevents the server from crashing and provides more informative error messages to the client. * **Weather API Integration:** Uses the `requests` library to make HTTP requests to a weather API (OpenWeatherMap in this example). You'll need to replace `"YOUR_OPENWEATHERMAP_API_KEY"` with your actual API key. The `get_weather_data` function handles the API call and parses the JSON response. * **JSON Parsing:** Uses the `json` library to parse the JSON response from the weather API. * **Clearer Response Messages:** The server now sends more informative error messages to the client when something goes wrong. * **`handle_client` Function:** The code that handles communication with a single client is now in a separate function, `handle_client`. This makes the code more organized and easier to read. * **UTF-8 Encoding:** Explicitly encodes and decodes messages using UTF-8 to handle a wider range of characters. * **`response.raise_for_status()`:** This line in `get_weather_data` is important. It raises an `HTTPError` if the API returns a bad status code (4xx or 5xx), which indicates a problem with the request or the API itself. * **`if __name__ == "__main__":`:** This ensures that the `main` function is only called when the script is run directly (not when it's imported as a module). **4. Client Implementation (Cursor IDE)** You'll need to write code within Cursor to connect to the server, send requests, and display the responses. Here's a conceptual outline (the exact code will depend on Cursor's API and capabilities): ```python import socket HOST = '127.0.0.1' PORT = 65432 def get_weather(location): """Gets weather data from the server.""" try: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) request = f"GET_WEATHER {location}\n" s.sendall(request.encode('utf-8')) data = s.recv(1024) response = data.decode('utf-8').strip() return response except Exception as e: return f"Error: {e}" # Example usage (within Cursor): location = "London" # Or get the location from user input in Cursor weather_data = get_weather(location) print(weather_data) # Display the weather data in Cursor's output window ``` **5. Key Considerations and Enhancements** * **Threading/Asynchronous Handling:** For a production server, use threading or asynchronous I/O (e.g., `asyncio` in Python) to handle multiple client connections concurrently. The basic example above handles only one client at a time. * **Error Handling:** Implement robust error handling on both the client and server sides. Handle network errors, API errors, invalid input, etc. * **Input Validation:** Validate the location input to prevent errors and potential security issues. * **Security:** If you're exposing the server to the internet, consider security measures like authentication and authorization. For local development, this is less critical. * **Configuration:** Use a configuration file (e.g., a `.ini` or `.json` file) to store settings like the host, port, API key, and other parameters. This makes the server more flexible and easier to configure. * **Logging:** Implement logging to track server activity, errors, and other important events. This is helpful for debugging and monitoring. * **Data Caching:** Cache weather data to reduce the number of API calls and improve performance. Use a caching library like `cachetools` or `redis`. * **More Sophisticated MCP:** Consider a more structured MCP format using JSON or another data serialization format for more complex data structures. However, keep it relatively simple for ease of implementation. * **Unit Testing:** Write unit tests to ensure that the server is working correctly. **Example Interaction** 1. **Client (Cursor) sends:** `GET_WEATHER London\n` 2. **Server receives:** `GET_WEATHER London` 3. **Server fetches weather data for London from the API.** 4. **Server sends:** `WEATHER London 15 Cloudy 80\n` (if the temperature is 15 degrees, the condition is cloudy, and the humidity is 80%) 5. **Client (Cursor) receives:** `WEATHER London 15 Cloudy 80` 6. **Client (Cursor) displays:** "Weather in London: 15 degrees, Cloudy, Humidity: 80%" This detailed explanation and the Python example should give you a solid foundation for building your weather MCP server. Remember to adapt the code and the MCP format to your specific needs and the capabilities of Cursor. Good luck!

NOUZ MCP Server

MCP Server for local knowledge management. Semantic + keywords + tags

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.

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.

RealTest MCP Server

Provides structured access to RealTest backtesting documentation and example scripts to help LLM agents generate accurate RealScript code. It offers tools for semantic search, authoritative function references, and verified script retrieval to prevent hallucinations.

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.

Somnia MCP Server

Enables AI agents to interact with the Somnia blockchain network, including documentation search, blockchain queries, wallet management, cryptographic signing, and on-chain operations.

MCP Server with Azure Communication Services Email

Azure Communication Services - Email MCP (MCP pode se referir a "Managed Communication Provider" ou outro termo específico dependendo do contexto. Se for o caso, forneça mais contexto para uma tradução mais precisa.)

i1n

Localization as code — push, pull, translate, and extract strings from code with AI. 7 MCP tools for type-safe i18n across 182 languages.

Memory-IA MCP Server

Enables AI agents with persistent memory using SQLite and local LLM models through Ollama integration. Provides chat with context retention and multi-client support across VS Code, Gemini-CLI, and terminal interfaces.

Model Context Protocol (MCP) + Spring Boot Integration

Testando um novo recurso do servidor MCP usando Spring Boot.

Gopher & Gemini MCP Server

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

household-agent

Enables AI-powered household management including inventory tracking, restock predictions, meal planning from available ingredients, and baby supply monitoring through natural language commands.

kd-mcp

Controls kd.exe for KDNET kernel debugging on Windows, often paired with winrm-mcp for guest VM setup over WinRM.

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

Um servidor MCP para processamento de imagens que utiliza a biblioteca Sharp para fornecer funcionalidades de manipulação de imagem.