HiMCP

Desktop Commander MCP

これは、Claude にターミナル制御、ファイルシステム検索、および差分ファイル編集機能を提供する MCP サーバーです。

MCP Server for Prometheus

鏡 (Kagami)

Hyperliquid MCP Server

MCPサーバーでHyperliquid APIからデータを取得する

Docs Fetch MCP Server

LLMが自律的にウェブコンテンツを取得・探索できるようにし、ページを取得し、指定された深さまでリンクを再帰的にたどります。特にドキュメントからトピックについて学習するのに役立ちます。

MCP Notify Server

python-pip-mcp

Okay, here's a minimal example implementation of an MCP (Minecraft Protocol) server and client in Python, using `pip` for dependency management. This example focuses on the handshake and status request/response, which is the initial part of the protocol. It's designed to be debuggable in VS Code on Windows. **Important Considerations:** * **Simplicity:** This is a *very* basic example. It doesn't implement full Minecraft server functionality. It only handles the initial handshake and status request. * **Minecraft Protocol:** The Minecraft protocol is complex. This example only covers a tiny fraction of it. Refer to the official Minecraft protocol documentation for a complete understanding. * **Error Handling:** Error handling is minimal for clarity. A production-ready implementation would need much more robust error handling. * **Dependencies:** We'll use the `struct` module for packing and unpacking data according to the Minecraft protocol's specifications. * **VS Code Debugging:** The code is structured to allow you to set breakpoints and step through the server and client code in VS Code. **1. Project Setup:** Create a new directory for your project (e.g., `mcp_example`). Inside that directory, create the following files: * `server.py` * `client.py` * `requirements.txt` **2. `requirements.txt`:** This file lists the dependencies for your project. For this example, we don't need any external libraries beyond the Python standard library. You can leave this file empty. **3. `server.py`:** ```python import socket import struct import json def pack_varint(data): output = b'' while True: byte = data & 0x7F data >>= 7 if data != 0: byte |= 0x80 output += struct.pack('B', byte) if data == 0: break return output def pack_string(data): encoded_data = data.encode('utf-8') length = len(encoded_data) return pack_varint(length) + encoded_data def handle_handshake(sock): # Read handshake packet length = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return False # Connection closed prematurely byte_val = byte[0] length |= (byte_val & 0x7F) << shift shift += 7 if not (byte_val & 0x80): break packet_data = sock.recv(length) packet_id = packet_data[0] if packet_id == 0x00: protocol_version, server_address_length = struct.unpack('>bi', packet_data[1:6]) server_address = packet_data[6:6 + server_address_length].decode('utf-8') server_port, next_state = struct.unpack('>hi', packet_data[6 + server_address_length:6 + server_address_length + 6]) print(f"Protocol Version: {protocol_version}") print(f"Server Address: {server_address}") print(f"Server Port: {server_port}") print(f"Next State: {next_state}") return next_state == 1 else: print("Unexpected packet ID in handshake") return False def handle_status_request(sock): # Read status request packet (should be empty) length = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return False # Connection closed prematurely byte_val = byte[0] length |= (byte_val & 0x7F) << shift shift += 7 if not (byte_val & 0x80): break packet_data = sock.recv(length) if len(packet_data) != 1 or packet_data[0] != 0x00: print("Unexpected status request packet") return False # Construct status response status = { "version": { "name": "My Awesome Server", "protocol": 763 # Example protocol version }, "players": { "max": 100, "online": 0, "sample": [] }, "description": { "text": "A simple Minecraft server example." } } status_json = json.dumps(status) status_packet = pack_varint(0x00) + pack_string(status_json) status_packet_length = pack_varint(len(status_packet)) sock.sendall(status_packet_length + status_packet) # Handle ping request length = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return False # Connection closed prematurely byte_val = byte[0] length |= (byte_val & 0x7F) << shift shift += 7 if not (byte_val & 0x80): break packet_data = sock.recv(length) if len(packet_data) < 1: print("Unexpected ping request packet") return False ping_id = struct.unpack('>q', packet_data[1:9])[0] # Send pong response pong_packet = pack_varint(0x01) + struct.pack('>q', ping_id) pong_packet_length = pack_varint(len(pong_packet)) sock.sendall(pong_packet_length + pong_packet) return True def main(): host = '127.0.0.1' port = 25565 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow address reuse server_socket.bind((host, port)) server_socket.listen(1) print(f"Server listening on {host}:{port}") while True: conn, addr = server_socket.accept() print(f"Connection from {addr}") try: if handle_handshake(conn): if handle_status_request(conn): print("Status request handled successfully.") else: print("Failed to handle status request.") else: print("Handshake failed.") except Exception as e: print(f"Error handling connection: {e}") finally: conn.close() print(f"Connection to {addr} closed.") if __name__ == "__main__": main() ``` **4. `client.py`:** ```python import socket import struct import json def pack_varint(data): output = b'' while True: byte = data & 0x7F data >>= 7 if data != 0: byte |= 0x80 output += struct.pack('B', byte) if data == 0: break return output def pack_string(data): encoded_data = data.encode('utf-8') length = len(encoded_data) return pack_varint(length) + encoded_data def read_varint(sock): result = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return None # Connection closed byte_val = byte[0] result |= (byte_val & 0x7F) << shift shift += 7 if not (byte_val & 0x80): break return result def main(): host = '127.0.0.1' port = 25565 client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: client_socket.connect((host, port)) print(f"Connected to {host}:{port}") # Handshake protocol_version = 763 # Example protocol version server_address = host server_port = port next_state = 1 # Status handshake_packet_data = struct.pack('>bi', protocol_version, len(server_address)) + server_address.encode('utf-8') + struct.pack('>hi', server_port, next_state) handshake_packet = pack_varint(0x00) + handshake_packet_data handshake_packet_length = pack_varint(len(handshake_packet)) client_socket.sendall(handshake_packet_length + handshake_packet) # Status Request status_request_packet = pack_varint(0x00) status_request_packet_length = pack_varint(len(status_request_packet)) client_socket.sendall(status_request_packet_length + status_request_packet) # Read Status Response response_length = read_varint(client_socket) if response_length is None: print("Connection closed while reading response length.") return response_packet = client_socket.recv(response_length) packet_id = response_packet[0] if packet_id == 0x00: status_json_length = read_varint(client_socket) status_json_data = client_socket.recv(status_json_length).decode('utf-8') status = json.loads(status_json_data) print("Server Status:") print(json.dumps(status, indent=4)) else: print(f"Unexpected packet ID: {packet_id}") # Send Ping Request ping_id = 12345 # Example ping ID ping_packet = pack_varint(0x01) + struct.pack('>q', ping_id) ping_packet_length = pack_varint(len(ping_packet)) client_socket.sendall(ping_packet_length + ping_packet) # Read Pong Response pong_length = read_varint(client_socket) if pong_length is None: print("Connection closed while reading pong length.") return pong_packet = client_socket.recv(pong_length) pong_packet_id = pong_packet[0] if pong_packet_id == 0x01: pong_id_received = struct.unpack('>q', pong_packet[1:9])[0] print(f"Received Pong with ID: {pong_id_received}") else: print(f"Unexpected pong packet ID: {pong_packet_id}") except Exception as e: print(f"Error: {e}") finally: client_socket.close() print("Connection closed.") if __name__ == "__main__": main() ``` **5. Explanation:** * **`pack_varint(data)`:** This function packs an integer into a Minecraft-style VarInt. VarInts are used to represent variable-length integers in the protocol. Each byte represents 7 bits of the integer, with the most significant bit (MSB) set to 1 if there are more bytes to follow, and 0 for the last byte. * **`pack_string(data)`:** This function packs a string into a VarInt-prefixed UTF-8 encoded string, as required by the Minecraft protocol. * **`read_varint(sock)`:** Reads a VarInt from the socket. * **Server (`server.py`):** * Creates a socket and listens for connections. * `handle_handshake(conn)`: Reads the handshake packet, extracts the protocol version, server address, port, and next state. It returns `True` if the handshake is successful and the next state is 1 (status). * `handle_status_request(conn)`: Reads the status request packet (which should be empty). Constructs a JSON status response and sends it back to the client. * The status response is a JSON object containing information about the server, such as the version, player count, and description. * **Client (`client.py`):** * Creates a socket and connects to the server. * Constructs and sends the handshake packet. * Constructs and sends the status request packet. * Reads the status response from the server, parses the JSON, and prints it. * Sends a ping request and receives a pong response. * **Protocol Flow:** 1. **Handshake:** The client sends a handshake packet to the server, indicating the protocol version it's using and the desired next state (status). 2. **Status Request:** The client sends an empty status request packet. 3. **Status Response:** The server sends a JSON-formatted status response. 4. **Ping Request:** The client sends a ping request with a unique ID. 5. **Pong Response:** The server sends a pong response with the same ID. **6. Running the Example:** 1. **Install Dependencies:** Since we don't have any external dependencies, you don't need to run `pip install -r requirements.txt`. 2. **Run the Server:** Open a terminal or command prompt, navigate to the project directory, and run `python server.py`. 3. **Run the Client:** Open another terminal or command prompt, navigate to the project directory, and run `python client.py`. You should see output in both the server and client terminals, indicating the connection, handshake, status request/response, and ping/pong. **7. Debugging in VS Code:** 1. **Create Launch Configurations:** In VS Code, go to the "Run and Debug" view (Ctrl+Shift+D). Click "Create a launch.json file". Choose "Python". You'll need to create two configurations, one for the server and one for the client. * **Server Launch Configuration (`launch.json`):** ```json { "version": "0.2.0", "configurations": [ { "name": "Python: Server", "type": "python", "request": "launch", "program": "${workspaceFolder}/server.py", "console": "integratedTerminal" }, { "name": "Python: Client", "type": "python", "request": "launch", "program": "${workspaceFolder}/client.py", "console": "integratedTerminal" } ] } ``` 2. **Set Breakpoints:** In both `server.py` and `client.py`, click in the left margin to set breakpoints at the lines of code you want to examine. For example, you might set breakpoints in the `handle_handshake` and `handle_status_request` functions in `server.py`, and in the main loop of `client.py`. 3. **Start Debugging:** In the "Run and Debug" view, select the "Python: Server" configuration and click the green "Start Debugging" button. Then, select the "Python: Client" configuration and click the green "Start Debugging" button. VS Code will start both the server and client, and execution will pause at your breakpoints. 4. **Inspect Variables:** When execution pauses at a breakpoint, you can use the VS Code debugger to inspect the values of variables, step through the code line by line, and examine the call stack. **Key Improvements and Explanations:** * **VarInt Packing/Unpacking:** The `pack_varint` and `read_varint` functions are crucial for handling the variable-length integers used in the Minecraft protocol. These functions correctly encode and decode the VarInt format. * **String Packing:** The `pack_string` function handles packing strings with a VarInt length prefix. * **Error Handling:** Basic error handling is included to catch connection errors and unexpected packet formats. More robust error handling would be needed for a production system. * **Clearer Structure:** The code is organized into functions to improve readability and maintainability. * **Comments:** Comments explain the purpose of each section of the code. * **JSON Status Response:** The server constructs a valid JSON status response that a Minecraft client can understand. * **Ping/Pong:** The client sends a ping request and the server responds with a pong, demonstrating a simple form of keep-alive. * **Byte-Level Operations:** The code uses `struct.pack` and `struct.unpack` to work with binary data at the byte level, which is essential for interacting with the Minecraft protocol. * **Debuggability:** The code is structured to be easily debugged in VS Code, with clear entry points and the ability to set breakpoints. This example provides a solid foundation for building a more complete Minecraft server or client. Remember to consult the official Minecraft protocol documentation for more details on the protocol's specifications. Good luck!