Discover Awesome MCP Servers

Linux Command MCP (Model Context Protocol)

MCP server and client for running Linux commands

MCP Demo Project

A demo repository to showcase MCP Server functionality

Weekly Report Checker MCP Server

Un servidor MCP que monitorea y proporciona análisis sobre las entregas de informes semanales en una Hoja de Cálculo de Google, permitiendo a los usuarios verificar las entregas faltantes, ver estadísticas y rastrear el estado de los informes individuales.

LLM Chat Replay

chat replay visualizer for sesssions saved in your LLM. create transcripts using your LLM + MCP filesystem server, and replay them here, to share with others

McpDotNet

MCP client and server implementations for .NET

CrateDocs MCP

An MCP server for rust crate docs

MCP Server

Espejo de

SingleStore MCP Server

Mirror of

Browserbase MCP Server

Este servidor proporciona capacidades de automatización de navegadores en la nube utilizando Browserbase, Puppeteer y Stagehand. Este servidor permite a los LLM interactuar con páginas web, tomar capturas de pantalla y ejecutar JavaScript en un entorno de navegador en la nube.

MCP Servers Schemas

Espejo de

MCP GitLab Review Server

gitlabでレビュー用のMCP Server

MCP Radarr and Sonarr Server

MCP Server for Radarr and Sonarr services

The Pensieve MCP Server

One simply siphons the excess thoughts from one's mind, pours them into the basin, and examines them at one's leisure. It becomes easier to spot patterns and links, you understand, when they are in this form.

tRPC <-> MCP

Serve tRPC routes as an MCP server

Snowflake MCP Server for Windsurf

Model Context Protocol (MCP) Server for Snowflake, tailored for Windsurf

MCP Template

A barebones MCP server implementation in Swift using loopwork-ai's mcp-swift-sdk.

SSH Tools MCP

SSH tools and utilities for MCP servers

MCP_Servers

Okay, here are some top MCP (Minecraft Protocol) servers that are often used in conjunction with AI, along with some considerations: **Important Considerations Before Listing Servers:** * **"MCP" is Broad:** When you say "MCP servers," it's important to clarify what you mean. "MCP" refers to the Minecraft Protocol, which is how clients (like the Minecraft game) communicate with servers. *All* Minecraft servers use the MCP. I'm assuming you mean servers that are well-suited for AI-driven bots or agents to connect to and interact with. * **Purpose Matters:** The best server depends *heavily* on what you want your AI to *do*. Is it for: * **Testing AI Navigation?** * **Building and Construction?** * **Combat and PvP?** * **Resource Gathering?** * **Complex Interactions (e.g., trading, questing)?** * **Server Software:** The underlying server software (e.g., Vanilla, Spigot, Paper, Fabric) affects performance, modding capabilities, and API availability. Paper is generally preferred for performance. Fabric is preferred for modding. * **API Access:** You'll need a way for your AI to interact with the server programmatically. This usually involves a Minecraft bot library (see below). **Minecraft Bot Libraries (Essential for AI):** Before I list servers, you *must* have a Minecraft bot library. These libraries handle the low-level MCP communication and provide a higher-level API for your AI to use. Popular choices include: * **Mineflayer (JavaScript/Node.js):** Very popular, well-documented, and actively maintained. Excellent for beginners. Supports a wide range of Minecraft versions. * **Python-Minecraft:** A Python library for interacting with Minecraft servers. * **Baritone (Java):** A powerful pathfinding and automation bot. Can be used as a library within your own Java AI. More complex to set up. * **PrismarineJS:** A collection of JavaScript libraries for working with Minecraft data and protocols. **Top MCP Server Options (Considering AI Use):** Given the above, here are some options, categorized by use case: 1. **Local Development/Testing Servers (Highly Recommended):** * **Vanilla Minecraft Server (Local):** The official Minecraft server. Good for basic testing and ensuring compatibility. You can download it from the Minecraft website. Run it on your own computer. * **PaperMC (Local):** A highly optimized fork of Spigot. Provides better performance than Vanilla, which is crucial when you have an AI constantly interacting with the server. Download from [https://papermc.io/downloads](https://papermc.io/downloads). Run it on your own computer. * **Fabric (Local):** A modding API that allows you to create custom mods for your server. This is useful if you want to add custom features or modify the game's behavior. Download from [https://fabricmc.net/use/server/](https://fabricmc.net/use/server/). Run it on your own computer. **Why Local is Best for Development:** * **Control:** You have complete control over the server configuration, world generation, and plugins/mods. * **Debugging:** Easier to debug your AI and the server simultaneously. * **No Restrictions:** No rules or limitations imposed by a public server. * **Cost:** Free (after you own a Minecraft account). * **Latency:** Lowest possible latency, which is critical for real-time AI interaction. **Setup:** 1. Download the server software (Vanilla, Paper, or Fabric). 2. Follow the instructions to set up the server on your computer. 3. Configure the `server.properties` file (e.g., set the game mode, difficulty, etc.). 4. Start the server. 5. Connect to the server from your Minecraft client (usually `localhost`). 6. Connect your AI bot to the server using your chosen bot library. 2. **Public Servers (Use with Caution):** * **Generally Not Recommended for AI Development:** Most public servers have rules against bots or automated clients. You risk getting banned. * **If You Must:** Look for servers that explicitly allow bots or have a "developer" or "testing" area. Read the server rules *very* carefully. * **Examples (Potentially Suitable, but Verify Rules):** * **Servers with Creative Mode:** Some creative servers might be more tolerant of bots that are building things. * **Servers with a "Testing" Area:** If a server has a designated area for testing, it might be okay to use bots there, but *ask the server admins first*. **Risks of Public Servers:** * **Bans:** Most likely outcome if you violate the rules. * **Griefing:** Even if you don't intend to, your AI could accidentally grief other players' builds. * **Performance Issues:** Public servers are often crowded, which can impact your AI's performance. * **Security Risks:** Connecting to unknown servers can pose security risks. 3. **Cloud-Based Servers (For Scalability and Accessibility):** * **Minecraft Realms:** Simple to set up, but limited in terms of customization and API access. Not ideal for serious AI development. * **Dedicated Server Hosting (e.g., Apex Hosting, BisectHosting, Shockbyte):** Gives you more control than Realms. You can install Paper or Fabric and configure the server as needed. Good for larger-scale AI projects. * **Cloud Computing Platforms (e.g., AWS, Google Cloud, Azure):** The most flexible option, but also the most complex. You can run a Minecraft server on a virtual machine and have full control over the operating system and software. Suitable for advanced AI applications. **Recommendations:** * **Start with a local PaperMC server.** This is the best way to learn and experiment without risking bans or performance issues. * **Use Mineflayer (JavaScript) or Python-Minecraft for your AI bot.** These libraries are easy to use and well-documented. * **Focus on a specific task for your AI.** Don't try to do everything at once. Start with something simple, like navigating to a specific location or building a simple structure. * **If you need to use a public server, contact the admins first and ask for permission.** Be transparent about what you're doing. * **Consider using a cloud-based server for larger-scale projects or if you need to access the server from multiple locations.** **Example Scenario (Local PaperMC Server with Mineflayer):** 1. Download and set up a PaperMC server on your computer. 2. Write a Node.js script using Mineflayer to connect to the server. 3. Use Mineflayer's API to control your bot: * `bot.chat("Hello, world!");` (Sends a message to the chat) * `bot.goto(new Vec3(10, 64, 20));` (Navigates the bot to coordinates 10, 64, 20) * `bot.dig(block);` (Digs a block) **In summary, the "best" MCP server for AI is usually a local PaperMC server, combined with a good Minecraft bot library like Mineflayer or Python-Minecraft. This gives you the control, performance, and flexibility you need to develop and test your AI.**

Cloud Foundry MCP Server

Servidor MCP de Cloud Foundry

mcp-server-diff-python

Mirror of

MCP Server Template

Mirror of

Jupiter MCP Server

Un servidor MCP para ejecutar intercambios de tokens en la blockchain de Solana utilizando la API Ultra de Jupiter, que permite a los usuarios obtener órdenes de intercambio óptimas y ejecutar transacciones con control de deslizamiento.

spring-boot-mcp-server-hello-world

Hello World MCP Server

ConnectWise Manage MCP Server

A Model Context Protocol (MCP) server for ConnectWise PSA API integration with Claude Desktop

Covid Mcp Server

Here are a few options for an MCP (presumably meaning "Minimal, Complete, and Verifiable") server setup for fetching real-time COVID-19 data by country, along with considerations for each: **Option 1: Simple Python Flask API with a Single Data Source** This is the easiest to implement for a quick prototype. * **Language:** Python * **Framework:** Flask (lightweight web framework) * **Data Source:** Johns Hopkins University CSSE COVID-19 Data (widely used, updated frequently) * **Libraries:** `requests`, `pandas` ```python from flask import Flask, jsonify import pandas as pd import requests app = Flask(__name__) DATA_URL = "https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv" @app.route('/covid/country/<country_name>') def get_covid_data(country_name): """ Returns COVID-19 confirmed cases for a given country. """ try: df = pd.read_csv(DATA_URL) country_data = df[df['Country/Region'] == country_name] if country_data.empty: return jsonify({"error": "Country not found"}), 404 # Sum across provinces/states within the country country_data = country_data.groupby('Country/Region').sum() # Extract the time series data (dates as columns) data = country_data.iloc[:, 3:].to_dict(orient='records')[0] # Skip lat/long columns return jsonify({"country": country_name, "data": data}) except Exception as e: print(f"Error: {e}") return jsonify({"error": "Internal server error"}), 500 if __name__ == '__main__': app.run(debug=True) ``` **Explanation:** 1. **Imports:** Imports necessary libraries. 2. **`DATA_URL`:** Defines the URL for the Johns Hopkins data. 3. **`get_covid_data(country_name)`:** * Reads the CSV data into a Pandas DataFrame. * Filters the DataFrame to get data for the specified `country_name`. * Handles the case where the country is not found. * Groups by country to sum cases across provinces/states. * Extracts the time series data (dates as columns) into a dictionary. * Returns the data as a JSON response. 4. **Error Handling:** Includes basic error handling. 5. **`if __name__ == '__main__':`:** Starts the Flask development server. **To run this:** 1. Save the code as `app.py`. 2. Install dependencies: `pip install flask pandas requests` 3. Run: `python app.py` 4. Access the API: `http://127.0.0.1:5000/covid/country/US` (replace "US" with the country you want). **Advantages:** * Simple to implement. * Uses a well-known data source. * Easy to understand. **Disadvantages:** * Relies on a single data source. If that source goes down, your API is down. * Limited error handling. * No data caching. Each request re-downloads the entire CSV. * No data cleaning or validation. * Only provides confirmed cases. You might want deaths, recovered, etc. * The Johns Hopkins data format can change, breaking your code. **Option 2: More Robust with Caching and Multiple Data Sources (Conceptual)** This is a more production-ready approach. * **Language:** Python * **Framework:** Flask or FastAPI (FastAPI is generally preferred for APIs) * **Data Sources:** * Johns Hopkins CSSE * Worldometer * Our World in Data * **Libraries:** `requests`, `pandas`, `cachetools` (for caching) * **Database (Optional):** Consider a database (e.g., PostgreSQL, MySQL) for storing cleaned and aggregated data if you need more complex queries or historical data analysis. **Key Improvements:** * **Data Source Redundancy:** Fetch data from multiple sources and implement logic to handle discrepancies or missing data. This makes your API more resilient. * **Caching:** Use `cachetools` or a similar library to cache the data in memory. This significantly reduces the load on the data sources and speeds up responses. Implement a cache invalidation strategy (e.g., refresh the cache every hour). * **Data Cleaning and Validation:** Clean and validate the data before storing it or returning it. This includes handling missing values, correcting inconsistencies, and ensuring data types are correct. * **Error Handling:** Implement robust error handling and logging. * **Data Aggregation:** Pre-aggregate the data by country and date to improve query performance. * **API Documentation:** Use Swagger/OpenAPI (built into FastAPI) to automatically generate API documentation. * **Rate Limiting:** Implement rate limiting to prevent abuse of your API. **Conceptual Code Snippet (Caching):** ```python from flask import Flask, jsonify import pandas as pd import requests import cachetools import time app = Flask(__name__) DATA_URL = "https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv" # Cache configuration cache = cachetools.TTLCache(maxsize=100, ttl=3600) # Cache for 1 hour (3600 seconds) def fetch_covid_data_from_source(): """Fetches data from the data source and returns a Pandas DataFrame.""" try: df = pd.read_csv(DATA_URL) return df except Exception as e: print(f"Error fetching data: {e}") return None def get_covid_data_from_cache(): """Gets COVID-19 data from the cache, or fetches it if not in the cache.""" if 'covid_data' in cache: print("Fetching data from cache") return cache['covid_data'] else: print("Fetching data from source") data = fetch_covid_data_from_source() if data is not None: cache['covid_data'] = data return data else: return None @app.route('/covid/country/<country_name>') def get_covid_data(country_name): """ Returns COVID-19 confirmed cases for a given country. """ try: df = get_covid_data_from_cache() if df is None: return jsonify({"error": "Failed to fetch data"}), 500 country_data = df[df['Country/Region'] == country_name] if country_data.empty: return jsonify({"error": "Country not found"}), 404 # Sum across provinces/states within the country country_data = country_data.groupby('Country/Region').sum() # Extract the time series data (dates as columns) data = country_data.iloc[:, 3:].to_dict(orient='records')[0] # Skip lat/long columns return jsonify({"country": country_name, "data": data}) except Exception as e: print(f"Error: {e}") return jsonify({"error": "Internal server error"}), 500 if __name__ == '__main__': app.run(debug=True) ``` **Option 3: Using an Existing COVID-19 API** Instead of building your own, consider using a well-maintained existing API. This can save you a lot of time and effort. * **Example:** There are several public COVID-19 APIs available. Search for "public covid api" on Google. Be sure to check the terms of service and reliability of any API you choose. **Spanish Translation of Key Terms:** * **MCP Server:** Servidor MCP (Minimal, Completo y Verificable) * **Real-time data:** Datos en tiempo real * **Country:** País * **Confirmed cases:** Casos confirmados * **Deaths:** Muertes * **Recovered:** Recuperados * **Data source:** Fuente de datos * **Caching:** Almacenamiento en caché * **API:** API (Interfaz de Programación de Aplicaciones) * **Error handling:** Manejo de errores * **Rate limiting:** Limitación de velocidad * **Database:** Base de datos **Recommendations:** * Start with Option 1 to get a basic API working. * If you need more reliability and features, move to Option 2. * Consider Option 3 if you want to avoid building your own API. * Always prioritize data quality and reliability. * Be aware of the terms of service of any data sources or APIs you use. * Implement proper error handling and logging. * Consider using a database for storing and querying data. * Use a framework like Flask or FastAPI to simplify API development. * Deploy your API to a cloud platform like AWS, Google Cloud, or Azure for scalability and reliability. Remember to adapt the code and architecture to your specific needs and requirements. Good luck!

AWS Resources MCP Server

Espejo de