Discover Awesome MCP Servers

Langbase MCP

LangBase MCP server

Gitee MCP Server

Tích hợp Gitee API, quản lý kho lưu trữ, vấn đề (issue), yêu cầu kéo (pull request) và nhiều hơn nữa.

.NET MCP Servers

Collection of my MCP (Model Context Protocol) servers written in .NET

Figma to Vue MCP Server

MCP server that generates Vue components from Figma designs following Hostinger's design system

AWS Model Context Protocol (MCP) Server

Một dịch vụ gọn nhẹ cho phép các trợ lý AI thực thi các lệnh AWS CLI thông qua Giao thức Ngữ cảnh Mô hình (MCP), cho phép các công cụ AI truy xuất tài liệu AWS và tương tác với các dịch vụ AWS.

Memory Cache Server

Gương của

codemirror-mcp

CodeMirror extension to hook up a Model Context Provider (MCP)

Memory Bank MCP Server 2.2.1

Một máy chủ để quản lý tài liệu dự án và ngữ cảnh trên các phiên Claude AI thông qua các ngân hàng bộ nhớ toàn cục và theo nhánh cụ thể, cho phép quản lý kiến thức nhất quán với việc lưu trữ tài liệu JSON có cấu trúc.

MCP Server

MCP server implementation for handling run_python requests

MCP Server - Oracle DB Context

Máy chủ MCP để làm việc với các cơ sở dữ liệu Oracle lớn

MCP服务器项目说明

Một máy chủ nền tảng điện toán đa chức năng được thiết kế để tích hợp với các mô hình ngôn ngữ lớn như Qwen, cung cấp khả năng truy cập tệp, kết nối cơ sở dữ liệu, tích hợp API và chức năng cơ sở dữ liệu vector.

MCP Chunk Editor

Một máy chủ MCP cung cấp một trình soạn thảo văn bản hiệu quả và an toàn cho các LLM.

mariadb-mcp-server

An mcp server that provides read-only access to MariaDB.

vigilant-adventure

hey,i wanted to play with some mods but when i try to open the game it says; The game crashed whilst initializing game Error: java.lang.NoClassDefFoundError: cpw/mods/fml/common/IPlayerTracker Exit Code: -1 what can i do to make it work?the log is; ---- Minecraft Crash Report ---- WARNING: coremods are present: MekanismCoremod (Mekanism-1.12.2-9…

Better Qdrant MCP Server

Một máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol) cho phép các khả năng tìm kiếm ngữ nghĩa bằng cách cung cấp các công cụ để quản lý các bộ sưu tập cơ sở dữ liệu vector Qdrant, xử lý và nhúng tài liệu bằng cách sử dụng các dịch vụ nhúng khác nhau, và thực hiện các tìm kiếm ngữ nghĩa trên các nhúng vector.

TimezoneToolkit MCP Server

Máy chủ MCP nâng cao cung cấp các công cụ toàn diện về thời gian và múi giờ.

Perplexity MCP Server

Mirror of

mcp-server-web3

The web3 function plugin server base on MCP of Anthropic.

mem0 MCP Server

Một triển khai TypeScript của máy chủ Model Context Protocol, cho phép tạo, quản lý và tìm kiếm ngữ nghĩa các luồng bộ nhớ với tích hợp Mem0.

MCP Command History

Một công cụ mạnh mẽ để khám phá, tìm kiếm và quản lý lịch sử lệnh shell của bạn thông qua giao diện MCP (Model Control Protocol). Dự án này cho phép bạn dễ dàng truy cập, tìm kiếm và truy xuất các lệnh shell đã thực thi trước đó.

kagi-server MCP Server

Mirror of

MCP Image Generation Server

Mirror of

WCGW

Send code snippet and paths to Claude. Designed to work with wcgw mcp server.

mcp-server-testWhat is MCP Server Test?How to use MCP Server Test?Key features of MCP Server Test?Use cases of MCP Server Test?FAQ from MCP Server Test?

Test MCP Server

Server

Okay, here's a basic outline and code snippets to get you started with a simple "Weather MCP" (assuming you mean a Minecraft Protocol server that provides weather information) in Python. Keep in mind that a *full* implementation is quite complex and requires deep understanding of the Minecraft protocol. This example focuses on the core concepts. **Disclaimer:** This is a simplified example. A real Minecraft server needs to handle much more, including player authentication, world generation, chunk loading, entity management, and a lot more protocol details. This is just a starting point to illustrate the weather aspect. **Conceptual Outline** 1. **Minecraft Protocol Basics:** * Minecraft uses a custom TCP-based protocol. You'll need to understand how to send and receive packets in the correct format. The protocol has evolved over different Minecraft versions, so you'll need to target a specific version. * The protocol involves handshaking, status requests, login, and then gameplay packets. * We'll focus on sending the relevant weather-related packets. 2. **Networking:** * Use Python's `socket` module to listen for incoming connections from Minecraft clients. * Handle each client connection in a separate thread or using asynchronous programming (e.g., `asyncio`). 3. **Weather Data:** * For simplicity, we'll simulate weather. In a real application, you might fetch weather data from an external API. 4. **Packet Construction:** * You'll need to construct Minecraft packets according to the protocol specification. This involves packing data (integers, strings, etc.) into byte arrays in the correct order and format. **Simplified Code Example (Python)** ```python import socket import struct import threading import time # Configuration HOST = '0.0.0.0' # Listen on all interfaces PORT = 25565 # Default Minecraft port PROTOCOL_VERSION = 763 # Example: Minecraft 1.16.5 SERVER_VERSION_NAME = "WeatherMCP-0.1" MAX_PLAYERS = 10 # --- Minecraft Protocol Helper Functions --- def pack_varint(data): """Packs an integer into a Minecraft-style VarInt.""" out = bytearray() while True: byte = data & 0x7F data >>= 7 if data != 0: byte |= 0x80 out.append(byte) if data == 0: break return bytes(out) def pack_string(data): """Packs a string into a Minecraft-style string (VarInt length + UTF-8 encoded string).""" encoded = data.encode('utf-8') length = len(encoded) return pack_varint(length) + encoded def create_packet(packet_id, data): """Creates a Minecraft packet with a VarInt packet ID and data.""" packet_id_bytes = pack_varint(packet_id) packet_data = packet_id_bytes + data packet_length = pack_varint(len(packet_data)) return packet_length + packet_data # --- Weather Simulation --- is_raining = False rain_level = 0.0 # 0.0 = no rain, 1.0 = heavy rain thunder_level = 0.0 # 0.0 = no thunder, 1.0 = heavy thunder is_thundering = False def update_weather(): """Simulates weather changes.""" global is_raining, rain_level, thunder_level, is_thundering import random while True: # Simulate a chance of rain starting or stopping if random.random() < 0.01: # 1% chance per second is_raining = not is_raining if is_raining: print("It started raining!") rain_level = 0.1 # Start with light rain else: print("It stopped raining!") rain_level = 0.0 # Simulate rain intensity changes if is_raining: rain_level = min(1.0, rain_level + random.uniform(0.001, 0.005)) # Increase rain else: rain_level = max(0.0, rain_level - random.uniform(0.001, 0.005)) # Decrease rain # Simulate thunder (similar to rain) if random.random() < 0.005: is_thundering = not is_thundering if is_thundering: print("Thunder started!") thunder_level = 0.1 else: print("Thunder stopped!") thunder_level = 0.0 if is_thundering: thunder_level = min(1.0, thunder_level + random.uniform(0.001, 0.005)) else: thunder_level = max(0.0, thunder_level - random.uniform(0.001, 0.005)) time.sleep(1) # Check every second # --- Packet Sending Functions --- def send_time_update(client_socket, world_age, time_of_day): """Sends a Time Update packet (ID 0x4E for 1.16.5).""" packet_id = 0x4E # Time Update packet ID data = struct.pack("!qq", world_age, time_of_day) # Long Long packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending time update: {e}") def send_change_game_state(client_socket, reason, value): """Sends a Change Game State packet (ID 0x1F for 1.16.5).""" packet_id = 0x1F data = struct.pack("!bq", reason, value) # Byte Float packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending change game state: {e}") def send_login_success(client_socket, uuid, username): """Sends a Login Success packet (ID 0x26 for 1.16.5).""" packet_id = 0x26 uuid_bytes = uuid.encode('utf-8') username_bytes = username.encode('utf-8') data = pack_string(uuid) + pack_string(username) packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending login success: {e}") def send_join_game(client_socket): """Sends a Join Game packet (ID 0x25 for 1.16.5).""" packet_id = 0x25 entity_id = 0 gamemode = 1 # Creative dimension = 0 # Overworld hashed_seed = 0 max_players = 20 level_type = "default" view_distance = 32 reduced_debug_info = False enable_respawn_screen = True is_debug = False is_flat = False data = struct.pack("!ibbqql", entity_id, gamemode, dimension, hashed_seed, max_players, view_distance) data += pack_string(level_type) data += struct.pack("!??", reduced_debug_info, enable_respawn_screen) packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending join game: {e}") def send_player_position_and_look(client_socket): """Sends a Player Position and Look packet (ID 0x34 for 1.16.5).""" packet_id = 0x34 x = 0.0 y = 64.0 z = 0.0 yaw = 0.0 pitch = 0.0 flags = 0x00 teleport_id = 0 data = struct.pack("!ddddbff", x, y, z, yaw, pitch, flags, teleport_id) packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending player position and look: {e}") def send_world_border(client_socket): """Sends a World Border packet (ID 0x41 for 1.16.5).""" packet_id = 0x41 action = 3 # Initialize border_diameter = 60000000.0 new_border_diameter = 60000000.0 speed = 0 x = 0.0 z = 0.0 warning_time = 0 warning_blocks = 0 data = struct.pack("!iqqdqql", action, border_diameter, new_border_diameter, speed, x, z, warning_time, warning_blocks) packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending world border: {e}") def send_server_list_response(client_socket): """Sends a Server List Response packet (ID 0x00).""" packet_id = 0x00 description = { "version": { "name": SERVER_VERSION_NAME, "protocol": PROTOCOL_VERSION }, "players": { "max": MAX_PLAYERS, "online": 0 }, "description": { "text": "Weather MCP Server" } } import json json_data = json.dumps(description, separators=(',', ':')) data = pack_string(json_data) packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending server list response: {e}") def send_set_slot(client_socket): """Sends a Set Slot packet (ID 0x16 for 1.16.5).""" packet_id = 0x16 window_id = 0 slot = 36 item_id = 276 # Diamond Sword item_count = 1 nbt_data = b'\x0a\x00\x04Name\x08\x00\x00\x00\x0bWeather Sword\x00' data = struct.pack("!bh", window_id, slot) data += pack_varint(item_id) data += struct.pack("!b", item_count) data += nbt_data packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending set slot: {e}") def send_entity_equipment(client_socket): """Sends an Entity Equipment packet (ID 0x47 for 1.16.5).""" packet_id = 0x47 entity_id = 0 slot = 0 # Main Hand item_id = 276 # Diamond Sword item_count = 1 nbt_data = b'\x0a\x00\x04Name\x08\x00\x00\x00\x0bWeather Sword\x00' data = pack_varint(entity_id) data += struct.pack("!b", slot) data += pack_varint(item_id) data += struct.pack("!b", item_count) data += nbt_data data += b'\xff' # End of equipment list packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending entity equipment: {e}") def send_update_weather(client_socket, entity_id, type, value): """Sends an Update Weather packet (ID 0x08 for 1.16.5).""" packet_id = 0x08 data = struct.pack("!ibf", entity_id, type, value) packet = create_packet(packet_id, data) try: client_socket.sendall(packet) except Exception as e: print(f"Error sending update weather: {e}") # --- Client Handling --- def handle_client(client_socket, client_address): """Handles a single client connection.""" print(f"Accepted connection from {client_address}") try: # --- Handshaking --- packet_length_bytes = client_socket.recv(1) packet_length = struct.unpack("!b", packet_length_bytes)[0] packet_data = client_socket.recv(packet_length) packet_id = struct.unpack("!b", packet_data[:1])[0] if packet_id == 0x00: protocol_version, server_address_length = struct.unpack("!bi", packet_data[1:6]) server_address = client_socket.recv(server_address_length) server_port, next_state = struct.unpack("!hi", packet_data[6+server_address_length:12+server_address_length]) if next_state == 1: send_server_list_response(client_socket) client_socket.recv(1) # Ping client_socket.sendall(create_packet(0x01, struct.pack("!q", int(time.time() * 1000)))) elif next_state == 2: send_login_success(client_socket, "00000000-0000-0000-0000-000000000000", "WeatherPlayer") send_join_game(client_socket) send_player_position_and_look(client_socket) send_world_border(client_socket) send_set_slot(client_socket) send_entity_equipment(client_socket) # --- Main Game Loop (Send Weather Updates) --- while True: send_time_update(client_socket, 100, 6000) send_update_weather(client_socket, 0, 1, rain_level) # Rain send_update_weather(client_socket, 1, 2, thunder_level) # Thunder time.sleep(0.5) # Send weather updates every 0.5 seconds except Exception as e: print(f"Error handling client: {e}") finally: print(f"Closing connection from {client_address}") client_socket.close() # --- Main Server --- def main(): """Main server function.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of the address server_socket.bind((HOST, PORT)) server_socket.listen(5) # Listen for up to 5 incoming connections print(f"Weather MCP Server listening on {HOST}:{PORT}") # Start the weather simulation thread weather_thread = threading.Thread(target=update_weather) weather_thread.daemon = True # Exit when the main thread exits weather_thread.start() try: while True: client_socket, client_address = server_socket.accept() client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address)) client_thread.daemon = True client_thread.start() except KeyboardInterrupt: print("Shutting down server...") finally: server_socket.close() if __name__ == "__main__": main() ``` **Key Improvements and Explanations:** * **Clearer Structure:** The code is organized into functions for packet packing, weather simulation, and client handling. * **VarInt Packing:** Includes `pack_varint` and `pack_string` functions to handle Minecraft's variable-length integer format. This is *essential* for the protocol. * **Packet Creation:** The `create_packet` function simplifies packet construction. * **Weather Simulation:** The `update_weather` function now simulates rain and thunder, changing the `rain_level` and `thunder_level` variables. It runs in its own thread. * **Weather Packets:** The `send_update_weather` function sends the correct packets to update the client's weather. It uses the `rain_level` and `thunder_level` values. The `send_change_game_state` function is *not* the correct way to change weather in modern Minecraft. The `Update Weather` packet is the correct one. * **Time Updates:** The `send_time_update` function sends time updates, which are important for the Minecraft client. * **Basic Handshaking and Login:** The `handle_client` function now includes basic handshaking and login to get the client into the game. It sends the necessary packets (Login Success, Join Game, Player Position and Look). This is *minimal* but allows the client to connect. * **Error Handling:** Includes `try...except` blocks to catch potential errors during network operations. * **Threading:** Uses threads to handle multiple clients concurrently. The weather simulation also runs in a separate thread. * **Comments:** More comments to explain the code. * **`struct.pack`:** Uses `struct.pack` for efficient packing of data into byte arrays. The `!` prefix in the format strings indicates network byte order (big-endian), which is required by the Minecraft protocol. * **Server List Ping:** Responds to the server list ping request so the server shows up in the Minecraft client's server list. * **Example Item:** Gives the player a diamond sword named "Weather Sword" to demonstrate sending item data. * **World Border:** Sends a world border packet to prevent the player from wandering too far. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `weather_mcp.py`). 2. **Run:** Execute the script from your terminal: `python weather_mcp.py` 3. **Minecraft Client:** * Start your Minecraft client (version 1.16.5 or the version you targeted). * Add a new server with the IP address of the machine running the script (usually `localhost` or `127.0.0.1`). * Connect to the server. **Important Considerations and Next Steps:** * **Minecraft Protocol Version:** The Minecraft protocol changes frequently. This example is based on 1.16.5. You'll need to adapt the packet IDs and data formats if you're targeting a different version. Refer to the Minecraft protocol documentation for your target version. A good resource is the [wiki.vg](https://wiki.vg/Protocol) wiki. * **Authentication:** This example skips authentication. In a real server, you'll need to handle player authentication with Mojang's servers. * **World Generation:** This example doesn't generate a world. You'll need to implement world generation and chunk loading to create a playable environment. * **Entity Management:** You'll need to manage entities (players, mobs, etc.) and send packets to update their positions and states. * **Asynchronous Programming:** For a more scalable server, consider using Python's `asyncio` library for asynchronous networking. This can handle many more concurrent connections than threading. * **Libraries:** Consider using a Minecraft server library to simplify protocol handling. However, be aware that many libraries may be outdated or incomplete. * **Security:** Be very careful about security when writing a Minecraft server. There are many potential vulnerabilities that can be exploited. This improved example provides a much better foundation for building a simple Minecraft server that can control the weather. Remember that building a full-fledged server is a significant undertaking. Start small, test frequently, and consult the Minecraft protocol documentation. Good luck!