Discover Awesome MCP Servers

Elasticsearch MCP Server

Conecta a Claude y otros clientes MCP con datos de Elasticsearch, permitiendo a los usuarios interactuar con sus índices de Elasticsearch a través de conversaciones en lenguaje natural.

microCMS MCP Server

Un servidor compatible con el Protocolo de Contexto de Modelo (MCP) que permite a los Modelos de Lenguaje Grandes (LLMs) buscar y recuperar contenido de APIs de microCMS.

QASE MCP Server

Un servidor MCP basado en TypeScript que proporciona integración con la plataforma de gestión de pruebas Qase, permitiéndote gestionar proyectos, casos de prueba, ejecuciones, resultados, planes, suites y pasos compartidos.

🌦️ Weather MCP Server

Okay, here's a basic outline and code snippet for a Python-based MCP (Minecraft Protocol) server that retrieves weather data. Keep in mind that a *full* implementation is quite complex and requires handling the Minecraft protocol correctly. This example focuses on the core concept of getting weather and sending a simple message back to the player. **Conceptual Outline** 1. **Minecraft Protocol Handling:** * You'll need a library to handle the Minecraft protocol. `mcstatus` is good for pinging servers, but for a *server* implementation, you'll likely need a more robust library or write your own protocol handling. Libraries like `nbt` (for NBT data) and `struct` (for packing/unpacking binary data) are essential. * The server needs to listen for incoming connections on a specific port (usually 25565). * It needs to handle the handshake, status, login, and play states of the Minecraft protocol. 2. **Weather Data Retrieval:** * Use a weather API (e.g., OpenWeatherMap, WeatherAPI.com). You'll need an API key. * Make HTTP requests to the API to get the weather data for a specific location. 3. **Command Handling:** * Parse chat messages from the player. * If the player enters a command (e.g., `/weather`), trigger the weather retrieval. 4. **Response to Player:** * Format the weather data into a Minecraft chat message. * Send the chat message back to the player using the Minecraft protocol. **Simplified Code Example (Illustrative)** ```python import socket import json import struct import time import threading import requests # Replace with your OpenWeatherMap API key OPENWEATHERMAP_API_KEY = "YOUR_API_KEY" CITY = "London" # Or any city you want to use as default def get_weather(city): """Retrieves weather data from OpenWeatherMap.""" url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={OPENWEATHERMAP_API_KEY}&units=metric" try: response = requests.get(url) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() temperature = data['main']['temp'] description = data['weather'][0]['description'] return f"Weather in {city}: {temperature}°C, {description}" except requests.exceptions.RequestException as e: return f"Error getting weather: {e}" except (KeyError, IndexError) as e: return f"Error parsing weather data: {e}" def handle_client(client_socket): """Handles communication with a single Minecraft client.""" try: # Simulate receiving a chat message (very simplified) # In a real server, you'd parse the Minecraft protocol packets # to extract the chat message. print("Client connected.") time.sleep(1) # Simulate some initial protocol stuff # Simulate receiving a command (e.g., "/weather") command = "/weather" # Pretend we received this from the client if command.startswith("/weather"): weather_info = get_weather(CITY) # Or parse the city from the command send_chat_message(client_socket, weather_info) else: send_chat_message(client_socket, "Unknown command.") except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() print("Client disconnected.") def send_chat_message(client_socket, message): """Sends a chat message to the Minecraft client. This is a VERY simplified example. The actual Minecraft protocol for chat messages is more complex. """ # In reality, you'd need to construct a proper Minecraft chat packet. # This is just a placeholder. encoded_message = message.encode('utf-8') try: client_socket.sendall(encoded_message) except Exception as e: print(f"Error sending message: {e}") def start_server(): """Starts the Minecraft server.""" host = "localhost" # Or "0.0.0.0" to listen on all interfaces port = 25565 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((host, port)) server_socket.listen(5) # Listen for up to 5 incoming connections print(f"Minecraft weather server listening on {host}:{port}") try: while True: client_socket, address = server_socket.accept() print(f"Accepted connection from {address}") client_thread = threading.Thread(target=handle_client, args=(client_socket,)) client_thread.start() except KeyboardInterrupt: print("Shutting down server...") finally: server_socket.close() if __name__ == "__main__": start_server() ``` Key improvements and explanations: * **Error Handling:** Includes `try...except` blocks to handle potential errors during API requests, JSON parsing, and socket operations. This is crucial for a robust server. * **API Key Security:** Reminds the user to replace `"YOUR_API_KEY"` with their actual API key. **Never commit your API key directly to your code repository!** Use environment variables or a configuration file. * **Clearer Comments:** More detailed comments explaining the purpose of each section of the code. * **`requests.exceptions.RequestException`:** Catches a broader range of potential network errors when making API requests. * **`response.raise_for_status()`:** Checks for HTTP errors (4xx or 5xx status codes) from the API and raises an exception if one occurs. This is important for handling cases where the API is unavailable or returns an error. * **Threading:** Uses `threading` to handle multiple client connections concurrently. This is essential for a server that needs to support more than one player at a time. * **`if __name__ == "__main__":`:** Ensures that the `start_server()` function is only called when the script is run directly (not when it's imported as a module). * **`KeyboardInterrupt` Handling:** Gracefully shuts down the server when Ctrl+C is pressed. * **`send_chat_message()` Explanation:** Emphasizes that the `send_chat_message()` function is *extremely* simplified and that a real implementation would require constructing proper Minecraft protocol packets. * **City as a Variable:** The `CITY` is now a variable, making it easier to change the default location. * **More Robust Weather Data Parsing:** Includes a `try...except` block to handle potential `KeyError` or `IndexError` exceptions when accessing elements in the JSON response from the weather API. This makes the code more resilient to changes in the API's response format. **Important Considerations and Next Steps:** 1. **Minecraft Protocol Library:** The biggest missing piece is a proper Minecraft protocol library. Research and choose a library that suits your needs. Be prepared for a significant learning curve. Consider libraries like `python-minecraft-protocol` (though it might be outdated). Writing your own protocol handling is a very advanced task. 2. **NBT Data:** Minecraft uses NBT (Named Binary Tag) for storing data. You'll need a library like `nbt` to work with NBT data if you want to modify world data or handle more complex interactions. 3. **Asynchronous Programming (asyncio):** For a high-performance server, consider using `asyncio` for asynchronous I/O. This allows the server to handle many connections efficiently without blocking. 4. **Configuration:** Use a configuration file (e.g., JSON, YAML) to store settings like the server port, API key, and default city. 5. **Security:** Be very careful about security. Validate all input from clients to prevent exploits. 6. **Testing:** Thoroughly test your server with a Minecraft client to ensure that it works correctly and doesn't crash. 7. **Error Handling and Logging:** Implement robust error handling and logging to help you debug and maintain your server. 8. **Command Parsing:** Implement a more sophisticated command parser to handle different commands and arguments. This revised response provides a much more realistic and helpful starting point for building a Minecraft server in Python. It highlights the complexities involved and points you in the right direction for further research and development. Remember to start small, test frequently, and be patient!

TheGraph MCP Server

Un servidor MCP que impulsa agentes de IA con datos indexados de blockchain de The Graph.

PyMOL-MCP

Conecta PyMOL con Claude AI a través del Protocolo de Contexto del Modelo, permitiendo la biología estructural conversacional y la visualización molecular a través de comandos en lenguaje natural.

MCP Crew AI Server

Un servidor ligero basado en Python diseñado para ejecutar, gestionar y crear flujos de trabajo de CrewAI utilizando el Protocolo de Contexto de Modelos para comunicarse con LLMs y herramientas como Claude Desktop o Cursor IDE.

Phabricator MCP Server

Mirror of

AzureDevOpsMCP

A proof-of-concept MCP Server that can query Azure DevOps

RabbitMQ MCP Server

Espejo de

BigQuery MCP server

Espejo de

6digit studio MCP integration

General purpose MCP-server for 6digit studio

Smithery.ai Integration for Unity AI MCP Server

A clean implementation of Smithery.ai integration for Unity AI MCP Server

MCP Server Manager

Mirror of

MCP Google Calendar

A Model Context Protocol (MCP) server for Google Calendar integration with Claude and other AI assistants.

🚀 Fetcher MCP - Playwright Headless Browser Server

Un servidor que permite obtener contenido de páginas web utilizando el navegador headless Playwright con capacidades impulsadas por IA para una extracción de información eficiente.

NearbySearch MCP Server

Un servidor MCP para búsquedas de lugares cercanos con detección de ubicación basada en IP.

Blowback

Integra Cursor AI con el servidor de desarrollo de Vite, permitiendo que los agentes de IA modifiquen el código y observen las actualizaciones en vivo a través del sistema de Reemplazo de Módulos en Caliente (Hot Module Replacement) en tiempo real.

Ebay MCP server

Un servidor de Protocolo de Contexto de Modelo que te permite buscar subastas en Ebay.com usando indicaciones en lenguaje natural como 'Encuéntrame 10 subastas de cómics de Batman'.

Medullar MCP Server

Servidor MCP Medular

n8n Workflow Builder MCP Server

MCP server for Claude / Cursor building n8n workflow

Datomic MCP Server

Datomic MCP Server so your AI model can query your database (uses Modex MCP library)

Model Context Protocol (MCP) Server

Here are a few ways to translate "MCP Server + Llama3 + Xterm.js" into Spanish, depending on the context: **Option 1 (Most Literal):** * **Servidor MCP + Llama3 + Xterm.js** This is the most direct translation and is suitable if you're talking about these specific technologies in a technical context where the English names are commonly understood. It's likely the best choice if you're writing code or documentation. **Option 2 (Adding Context - if needed):** * **Servidor MCP con Llama3 y Xterm.js** (MCP Server with Llama3 and Xterm.js) This adds the word "con" (with) to make the relationship between the components clearer. **Option 3 (More Descriptive - if needed and if "MCP" needs clarification):** * **Servidor MCP (Servidor de Control de Microprocesador) con Llama3 y Xterm.js** (MCP Server (Microprocessor Control Server) with Llama3 and Xterm.js) This expands "MCP" to its full name (if it's an acronym that needs clarification) and uses "con" for clarity. You would only use this if your audience is unlikely to know what "MCP" stands for. **Which option to choose depends on your audience and the context of your writing.** If your audience is familiar with the terms, the first option is the most concise and appropriate. If you need to provide more clarity, the other options are better.

MarkItDown MCP Server

Mirror of

Image Generation Worker Template

Template to easily make an MCP server on Cloudflare

MCP Rust CLI server template

Mirror of

Flow MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los agentes de IA interactuar con la blockchain de Flow a través de llamadas RPC, soportando saldos de cuentas, ejecución de scripts, transacciones, resolución de dominios e interacciones con contratos.

Terrakube MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite la gestión de la infraestructura de Terrakube a través del lenguaje natural, manejando la administración de espacios de trabajo, variables, módulos y operaciones de la organización.