Discover Awesome MCP Servers

RabbitMQ MCP Server

Espelho de

MCP Crew AI Server

Um servidor leve baseado em Python, projetado para executar, gerenciar e criar fluxos de trabalho CrewAI, utilizando o Protocolo de Contexto de Modelo para comunicação com LLMs e ferramentas como Claude Desktop ou Cursor IDE.

MCP Server Manager

Mirror of

🌦️ Weather MCP Server

Um servidor MCP (Minecraft Protocol) para obter informações meteorológicas, usando Python: Here's a basic outline and some code snippets to get you started. Keep in mind that building a full-fledged MCP server is a complex task. This example focuses on the weather aspect and provides a simplified structure. **Conceptual Outline:** 1. **Minecraft Protocol Handling:** You'll need a library that can handle the Minecraft protocol. `mcstatus` is good for pinging servers, but for a full server, you'll likely need something more robust like `python-minecraft-protocol` or a similar library. These libraries handle the low-level details of packet encoding/decoding. 2. **Weather Data Source:** You'll need an API or data source to get weather information. Popular choices include: * **OpenWeatherMap:** Requires an API key (free for limited use). Provides current weather, forecasts, etc. * **WeatherAPI.com:** Another API with a free tier. * **AccuWeather:** May require a paid subscription for API access. 3. **Server Logic:** * **Authentication:** Handle player authentication (username/password). For a simple server, you might skip this or use a very basic authentication method. * **Command Handling:** Implement a command (e.g., `/weather`) that players can use to request weather information. * **Weather Retrieval:** When a player uses the `/weather` command, fetch the weather data from your chosen API. * **Response Formatting:** Format the weather data into a Minecraft chat message and send it back to the player. **Simplified Code Example (using `python-minecraft-protocol` and OpenWeatherMap):** ```python import asyncio import json import aiohttp # For asynchronous HTTP requests from nbt import nbt # For NBT data (Minecraft data format) from minecraft_protocol.server import MinecraftProtocolServer from minecraft_protocol.packets import Packet, ClientBoundPacket, ServerBoundPacket # Replace with your OpenWeatherMap API key and city OPENWEATHERMAP_API_KEY = "YOUR_OPENWEATHERMAP_API_KEY" CITY = "London" # Example city async def get_weather(city, api_key): """Fetches weather data from OpenWeatherMap.""" url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric" # Metric units async with aiohttp.ClientSession() as session: async with session.get(url) as response: if response.status == 200: data = await response.json() return data else: print(f"Error fetching weather: {response.status}") return None class ChatMessagePacket(ClientBoundPacket): id = 0x0F # Packet ID for Chat Message (adjust for your Minecraft version) fields = [ ("json_data", "string"), ("position", "ubyte") # 0: chat box, 1: system message, 2: above action bar ] class ServerHandler: def __init__(self, server): self.server = server self.players = {} # Store player information (e.g., username) async def handle_handshake(self, connection, handshake_data): """Handles the initial handshake.""" print(f"Handshake: {handshake_data}") # You might want to check the protocol version here async def handle_login_start(self, connection, login_start_data): """Handles the login process.""" username = login_start_data["name"] print(f"Login attempt: {username}") # For a simple server, just accept the connection # In a real server, you'd authenticate the user # Send a Login Success packet login_success_packet = Packet(0x02) # Login Success packet ID login_success_packet.pack_string(connection.uuid) # UUID login_success_packet.pack_string(username) await connection.send(login_success_packet) self.players[connection] = {"username": username} # Send a Join Game packet (required to enter the world) join_game_packet = Packet(0x26) # Join Game packet ID join_game_packet.pack_int(1) # Entity ID join_game_packet.pack_ubyte(0) # Gamemode (0: Survival, 1: Creative) join_game_packet.pack_int(0) # Dimension join_game_packet.pack_ubyte(0) # Difficulty join_game_packet.pack_ubyte(1) # Max Players (doesn't really matter) join_game_packet.pack_string("default") # Level Type join_game_packet.pack_bool(False) # Reduced Debug Info await connection.send(join_game_packet) # Send a Chat Message to the player await self.send_chat_message(connection, f"Welcome to the weather server, {username}!") async def handle_chat_message(self, connection, chat_message_data): """Handles chat messages from the client.""" message = chat_message_data["message"] print(f"Received chat message from {self.players[connection]['username']}: {message}") if message.startswith("/weather"): weather_data = await get_weather(CITY, OPENWEATHERMAP_API_KEY) if weather_data: description = weather_data["weather"][0]["description"] temperature = weather_data["main"]["temp"] await self.send_chat_message(connection, f"The weather in {CITY} is {description} and the temperature is {temperature}°C.") else: await self.send_chat_message(connection, "Could not retrieve weather information.") async def send_chat_message(self, connection, message): """Sends a chat message to the client.""" chat_packet = ChatMessagePacket() chat_packet.json_data = json.dumps({"text": message}) chat_packet.position = 0 # Chat box await connection.send(chat_packet.encode()) async def main(): server = MinecraftProtocolServer("127.0.0.1", 25565) # Listen on localhost, port 25565 handler = ServerHandler(server) server.register_handler("handshake", handler.handle_handshake) server.register_handler("login_start", handler.handle_login_start) server.register_handler("chat_message", handler.handle_chat_message) print("Starting server...") await server.start() try: await asyncio.Future() # Run forever except asyncio.CancelledError: pass finally: await server.close() print("Server stopped.") if __name__ == "__main__": asyncio.run(main()) ``` **Key Improvements and Explanations:** * **Asynchronous Operations:** Uses `asyncio` and `aiohttp` for non-blocking I/O. This is crucial for a server to handle multiple connections efficiently. The `await` keyword is used to pause execution until an asynchronous operation completes. * **`aiohttp` for HTTP Requests:** `aiohttp` is an asynchronous HTTP client, which is much better suited for server applications than the standard `requests` library (which is blocking). * **Error Handling:** Includes basic error handling for the weather API request. * **Minecraft Protocol Library:** Uses `python-minecraft-protocol` (install with `pip install python-minecraft-protocol`). This library handles the complexities of the Minecraft protocol. You'll need to adapt the packet IDs and data structures to the specific Minecraft version you're targeting. * **Packet Encoding/Decoding:** The `ChatMessagePacket` class demonstrates how to define a packet structure and encode data into the correct format for sending to the client. The `encode()` method is used to serialize the packet data. * **Server Handler Class:** The `ServerHandler` class encapsulates the server logic, making the code more organized. * **Handshake and Login:** Includes basic handling of the handshake and login phases. This is essential for a Minecraft server. The example sends a `Login Success` and `Join Game` packet to allow the player to join the world. * **Chat Message Handling:** The `handle_chat_message` function processes chat messages from the client. It checks for the `/weather` command and retrieves weather information if the command is used. * **Chat Message Formatting:** The `send_chat_message` function demonstrates how to format a message as JSON and send it to the client as a chat message. This is important for displaying text correctly in Minecraft. * **Clearer Structure:** The code is structured into functions and classes for better readability and maintainability. * **Comments:** Includes comments to explain the purpose of different code sections. **How to Run:** 1. **Install Dependencies:** ```bash pip install python-minecraft-protocol aiohttp nbt ``` 2. **Get an OpenWeatherMap API Key:** Sign up for a free account at [https://openweathermap.org/](https://openweathermap.org/) and get an API key. 3. **Replace Placeholder:** Replace `"YOUR_OPENWEATHERMAP_API_KEY"` with your actual API key in the code. 4. **Run the Script:** ```bash python your_script_name.py ``` 5. **Connect with Minecraft:** Start your Minecraft client and connect to `localhost:25565`. **Important Considerations:** * **Minecraft Version:** The Minecraft protocol changes between versions. You'll need to adapt the packet IDs and data structures to the specific version you want to support. The `python-minecraft-protocol` library may have version-specific branches or forks. * **Security:** This is a very basic example and does not include any security measures. In a real server, you'll need to implement proper authentication, authorization, and input validation to prevent attacks. * **Error Handling:** The error handling in this example is minimal. You should add more robust error handling to catch exceptions and prevent the server from crashing. * **Scalability:** This example is not designed for high scalability. If you need to support a large number of players, you'll need to use more advanced techniques such as asynchronous programming, multithreading, or multiprocessing. * **World Generation:** This example does not include any world generation. You'll need to implement world generation if you want players to be able to explore a world. * **Plugins/Mods:** Consider using a Minecraft server platform like Sponge or Fabric, which provide APIs for creating plugins or mods. This can simplify the development process and provide more features. This improved example provides a much better starting point for building a Minecraft server that integrates with a weather API. Remember to adapt the code to your specific needs and Minecraft version. Good luck!

AzureDevOpsMCP

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

6digit studio MCP integration

General purpose MCP-server for 6digit studio

Phabricator MCP Server

Mirror of

BigQuery MCP server

Espelho de

MCP Google Calendar

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

n8n Workflow Builder MCP Server

MCP server for Claude / Cursor building n8n workflow

Blowback

Integra o Cursor AI com o servidor de desenvolvimento Vite, permitindo que agentes de IA modifiquem o código e observem atualizações ao vivo através do sistema de Hot Module Replacement em tempo real.

🚀 Fetcher MCP - Playwright Headless Browser Server

Um servidor que permite buscar conteúdo de páginas da web usando o navegador headless Playwright com recursos alimentados por IA para extração eficiente de informações.

NearbySearch MCP Server

Um servidor MCP para buscas de lugares próximos com detecção de localização baseada em IP.

Ebay MCP server

Um servidor de Protocolo de Contexto de Modelo que permite buscar leilões do Ebay.com usando comandos em linguagem natural como 'Encontre 10 leilões de quadrinhos do Batman'.

Model Context Protocol (MCP) Server

Servidor MCP + Llama3 + Xterm.js

Medullar MCP Server

Servidor MCP Medular

Image Generation Worker Template

Template to easily make an MCP server on Cloudflare

MarkItDown MCP Server

Mirror of

Datomic MCP Server

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

Mokei

TypeScript toolkit for creating, interacting and monitoring clients and servers using the Model Context Protocol

🧨 Minesweeper MCP Server 🕹️

An MCP server for playing Minesweeper

Flow MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que agentes de IA interajam com o blockchain Flow através de chamadas RPC, suportando saldos de contas, execução de scripts, transações, resolução de domínios e interações com contratos.

Terrakube MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite gerenciar a infraestrutura Terrakube através de linguagem natural, lidando com gerenciamento de workspace, variáveis, módulos e operações de organização.

aterm

Um aplicativo de chat LLM para terminal com suporte para ferramentas Langchain e servidores MCP.

Inbox Zero AI

An MCP that helps you manage your email. For example, as it which emails need replies or follow ups. Offers functionality beyond basic Gmail functionality.

MCP Rust CLI server template

Mirror of

$CLAUD Grant Applications

Os Drives de Utilidade Prática da $CLAUD Impulsionam Solana ao Status de Liderança na Revolução Tecnológica