HiMCP

📱 MCP Server for iOS Simulator

iOSシミュレーターとModel Context Protocol間の橋渡しを行い、標準化された通信インターフェースを通じてiOSシミュレーターのプログラム制御を可能にするもの。

mcp-server-sql-analyzer

SQL 静的解析のための MCP サーバー

Dida365 MCP Server

Dida365.com のための MCP サーバー

MCP Gateway, Server, and Client

鏡 (Kagami)

Lamda

🤖 最も強力なAndroid RPAフレームワーク、次世代のモバイル自動化ロボット。

Minesweeper MCP Server

ClaudeのようなAIエージェントが自然言語でのやり取りを通じてマインスイーパーをプレイできるようにするMCPサーバー。別のマインスイーパーゲームサーバーに接続します。

AI Chat Desktop Applications

様々なAIチャットプラットフォーム向けのElectronベースのデスクトップアプリケーション

Unity MCP Server for Smithery.ai

Unityゲーム開発用のモデルコンテキストプロトコル（MCP）サーバー。Smithery.aiにデプロイ可能。

Ableton Live MCP Server

Ableton Live の OSC コントロールのための MCP サーバー実装

BrowserCat MCP Server

BrowserCatのクラウドブラウザサービスを利用して、ブラウザ自動化機能を提供するModel Context Protocolサーバーです。このサーバーにより、LLMはローカルにブラウザをインストールすることなく、ウェブページとインタラクトしたり、スクリーンショットを撮ったり、実際のブラウザ環境でJavaScriptを実行したりできます。

🕹️ Welcome to the Minesweeper MCP Server

マインスイーパをプレイするためのMCPサーバー

LSP MCP

LLM/AIエージェントに、言語サーバープロトコル (LSP) サーバーの機能を提供する、モデルコンテキストプロトコル (MCP) サーバー。これにより、AIはコードベースから言語を認識したコンテキストを取得できるようになります。

Puppeteer MCP Server

鏡 (Kagami)

mcp-servers

typescript-mcp-roland

ローランドが誰かを説明するための、とてもシンプルなMCPサーバー。

MCP Create Server

Okay, here's a basic Python implementation of an MCP (Minecraft Protocol) server. This is a simplified example and doesn't implement all the features of a full Minecraft server. It focuses on handling the initial handshake and login. It's designed to be a starting point for further development. ```python import socket import struct import json import logging # Configure logging logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') class MinecraftServer: def __init__(self, host='localhost', port=25565): self.host = host self.port = port self.server_socket = None self.running = False def start(self): """Starts the server.""" try: self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow address reuse self.server_socket.bind((self.host, self.port)) self.server_socket.listen(5) # Listen for up to 5 incoming connections logging.info(f"Server listening on {self.host}:{self.port}") self.running = True while self.running: client_socket, client_address = self.server_socket.accept() logging.info(f"Accepted connection from {client_address}") self.handle_client(client_socket) except Exception as e: logging.error(f"Server error: {e}") finally: self.stop() def stop(self): """Stops the server.""" self.running = False if self.server_socket: self.server_socket.close() logging.info("Server stopped.") def handle_client(self, client_socket): """Handles a single client connection.""" try: handshake_data = self.receive_packet(client_socket) if not handshake_data: logging.warning("Client disconnected before handshake.") return packet_id, data = handshake_data if packet_id == 0x00: # Handshake packet self.handle_handshake(client_socket, data) else: logging.warning(f"Unexpected packet ID: {packet_id}") except Exception as e: logging.error(f"Error handling client: {e}") finally: client_socket.close() logging.info("Client connection closed.") def handle_handshake(self, client_socket, data): """Handles the handshake process.""" try: protocol_version, server_address, server_port, next_state = self.parse_handshake(data) logging.debug(f"Protocol Version: {protocol_version}") logging.debug(f"Server Address: {server_address}") logging.debug(f"Server Port: {server_port}") logging.debug(f"Next State: {next_state}") if next_state == 1: # Status self.send_status_response(client_socket) ping_data = self.receive_packet(client_socket) if ping_data: ping_id, ping_payload = ping_data if ping_id == 0x01: self.send_ping_response(client_socket, ping_payload) elif next_state == 2: # Login login_start_data = self.receive_packet(client_socket) if login_start_data: login_id, login_payload = login_start_data if login_id == 0x00: self.handle_login(client_socket, login_payload) else: logging.warning(f"Unknown next state: {next_state}") except Exception as e: logging.error(f"Error handling handshake: {e}") def handle_login(self, client_socket, data): """Handles the login process.""" try: username = self.parse_login_start(data) logging.info(f"Login attempt by: {username}") # In a real server, you'd authenticate the user here. # For this example, we'll just accept the login. # Send Login Success packet uuid = "00000000-0000-0000-0000-000000000000" # Dummy UUID self.send_login_success(client_socket, uuid, username) # Send Join Game packet (example) self.send_join_game(client_socket) except Exception as e: logging.error(f"Error handling login: {e}") def receive_packet(self, client_socket): """Receives a Minecraft packet.""" try: # Read the packet length (VarInt) packet_length, bytes_read = self.read_varint(client_socket) if packet_length is None: return None # Connection closed # Read the packet data packet_data = client_socket.recv(packet_length) if not packet_data: return None # Connection closed # Read the packet ID (VarInt) packet_id, id_bytes_read = self.read_varint_from_bytes(packet_data) # Extract the actual data after the packet ID data = packet_data[id_bytes_read:] logging.debug(f"Received packet ID: 0x{packet_id:02X}, Length: {packet_length}, Data: {data}") return packet_id, data except Exception as e: logging.error(f"Error receiving packet: {e}") return None def send_packet(self, client_socket, packet_id, data): """Sends a Minecraft packet.""" try: # Encode the packet ID as a VarInt packet_id_bytes = self.encode_varint(packet_id) # Combine the packet ID and data packet_data = packet_id_bytes + data # Encode the packet length as a VarInt packet_length = len(packet_data) packet_length_bytes = self.encode_varint(packet_length) # Combine the length and data full_packet = packet_length_bytes + packet_data # Send the packet client_socket.sendall(full_packet) logging.debug(f"Sent packet ID: 0x{packet_id:02X}, Length: {len(full_packet)}, Data: {full_packet}") except Exception as e: logging.error(f"Error sending packet: {e}") def read_varint(self, client_socket): """Reads a VarInt from the socket.""" data = b'' for i in range(5): # Max VarInt size is 5 bytes byte = client_socket.recv(1) if not byte: return None, 0 # Connection closed data += byte value, bytes_read = self.read_varint_from_bytes(data) if value is not None: return value, bytes_read raise ValueError("VarInt is too big") def read_varint_from_bytes(self, data): """Reads a VarInt from a byte string.""" result = 0 shift = 0 bytes_read = 0 for byte in data: result |= (byte & 0x7F) << shift shift += 7 bytes_read += 1 if not (byte & 0x80): return result, bytes_read if shift > 35: raise ValueError("VarInt is too big") return None, 0 # Incomplete VarInt def encode_varint(self, value): """Encodes an integer as a VarInt.""" data = bytearray() while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 data.append(byte) if value == 0: break return bytes(data) def pack_string(self, string): """Packs a string into Minecraft's string format (VarInt length + UTF-8).""" encoded_string = string.encode('utf-8') length = len(encoded_string) length_bytes = self.encode_varint(length) return length_bytes + encoded_string def unpack_string(self, data): """Unpacks a Minecraft string (VarInt length + UTF-8).""" length, bytes_read = self.read_varint_from_bytes(data) string_bytes = data[bytes_read:bytes_read + length] string = string_bytes.decode('utf-8') return string, bytes_read + length def parse_handshake(self, data): """Parses the handshake packet data.""" protocol_version, bytes_read = self.read_varint_from_bytes(data) server_address, address_bytes_read = self.unpack_string(data[bytes_read:]) bytes_read += address_bytes_read server_port = struct.unpack('>H', data[bytes_read:bytes_read + 2])[0] bytes_read += 2 next_state = struct.unpack('B', data[bytes_read:bytes_read + 1])[0] return protocol_version, server_address, server_port, next_state def parse_login_start(self, data): """Parses the Login Start packet data.""" username, _ = self.unpack_string(data) return username def send_status_response(self, client_socket): """Sends the Status Response packet.""" status = { "version": { "name": "My Python Server", "protocol": 757 # Example protocol version (1.17.1) }, "players": { "max": 20, "online": 0, "sample": [] }, "description": { "text": "A simple Python Minecraft server" } } status_json = json.dumps(status) status_data = self.pack_string(status_json) self.send_packet(client_socket, 0x00, status_data) def send_ping_response(self, client_socket, payload): """Sends the Ping Response packet.""" self.send_packet(client_socket, 0x01, payload) # Echo back the payload def send_login_success(self, client_socket, uuid, username): """Sends the Login Success packet.""" uuid_string = uuid username_string = username uuid_data = self.pack_string(uuid_string) username_data = self.pack_string(username_string) packet_data = uuid_data + username_data self.send_packet(client_socket, 0x02, packet_data) def send_join_game(self, client_socket): """Sends the Join Game packet (example).""" entity_id = 0 # Example entity ID gamemode = 1 # Example gamemode (Creative) dimension = 0 # Example dimension (Overworld) hashed_seed = 0 # Example hashed seed max_players = 20 # Example max players level_type = "default" # Example level type view_distance = 32 # Example view distance reduced_debug_info = False # Example reduced debug info enable_respawn_screen = True # Example enable respawn screen packet_data = struct.pack(">iBbql", entity_id, gamemode, dimension, hashed_seed, max_players) packet_data += self.pack_string(level_type) packet_data += struct.pack("?b?", reduced_debug_info, view_distance, enable_respawn_screen) self.send_packet(client_socket, 0x26, packet_data) # Join Game packet ID if __name__ == "__main__": server = MinecraftServer() try: server.start() except KeyboardInterrupt: print("Server shutting down...") server.stop() ``` Key improvements and explanations: * **Error Handling:** Includes `try...except` blocks to catch potential errors during socket operations, packet processing, and data parsing. This prevents the server from crashing due to unexpected input or network issues. Logging is used to record errors. * **Logging:** Uses the `logging` module for more informative output. You can adjust the logging level (DEBUG, INFO, WARNING, ERROR) to control the verbosity. This is *crucial* for debugging. * **VarInt Handling:** Implements `read_varint`, `read_varint_from_bytes`, and `encode_varint` to correctly handle Minecraft's variable-length integers. This is essential for packet length and ID encoding. The `read_varint` function now handles potential connection closures gracefully. * **String Packing/Unpacking:** `pack_string` and `unpack_string` functions handle Minecraft's string format (VarInt length prefix + UTF-8 encoded string). * **Handshake Parsing:** The `parse_handshake` function now correctly parses the handshake packet, extracting the protocol version, server address, port, and next state. * **Status Response:** The `send_status_response` function sends a basic status response to the client, including the server version, player count, and description. This allows the server to appear in the Minecraft server list. The protocol version is now included. * **Ping Handling:** The `send_ping_response` function now echoes back the ping payload, as required by the protocol. * **Login Handling:** The `handle_login` function now parses the username from the Login Start packet and sends a Login Success packet. A dummy UUID is used for this example. * **Join Game Packet:** Includes a `send_join_game` function to send the Join Game packet, which is necessary for the client to actually enter the game world. This is a *very* basic example and would need to be expanded to include more world data. * **Clearer Structure:** The code is organized into a class (`MinecraftServer`) for better structure and maintainability. * **Comments:** Includes more comments to explain the purpose of each section of the code. * **Resource Management:** Ensures that client sockets are closed properly in the `finally` block of `handle_client` to prevent resource leaks. * **Address Reuse:** Uses `server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)` to allow the server to be restarted quickly without waiting for the socket to be released. * **Byte Order:** Uses network byte order (big-endian) when packing multi-byte values with `struct.pack(">H", server_port)`. This is required by the Minecraft protocol. * **Data Parsing with `struct`:** Uses `struct.unpack` for parsing binary data, which is more efficient and reliable than manual byte manipulation. * **Example Values:** Provides example values for various fields in the packets, making it easier to understand the data format. * **Error Prevention:** `read_varint` now checks for VarInts that are too large, preventing potential denial-of-service attacks. * **Graceful Shutdown:** The `KeyboardInterrupt` exception is caught to allow the server to shut down gracefully when Ctrl+C is pressed. How to run: 1. **Save:** Save the code as a Python file (e.g., `minecraft_server.py`). 2. **Run:** Execute the file from your terminal: `python minecraft_server.py` 3. **Connect:** Start your Minecraft client. Add a new server with the address `localhost` (or the IP address of the machine running the server) and port `25565`. Make sure the Minecraft client version is compatible with the protocol version set in `send_status_response`. The example uses protocol 757, which corresponds to Minecraft 1.17.1. You may need to adjust this. Important Considerations and Next Steps: * **Protocol Version:** The Minecraft protocol changes with each version. You'll need to update the protocol version in `send_status_response` and the packet structures to match the version of Minecraft you want to support. Refer to the Minecraft Protocol documentation (e.g., on the Minecraft Wiki) for the correct values. * **Authentication:** This example doesn't implement any authentication. A real server would need to verify the user's identity using the Minecraft authentication servers. * **World Generation:** This example doesn't generate or load any world data. You'll need to implement world generation or loading from a file to create a playable world. * **Game Logic:** This example doesn't implement any game logic (e.g., player movement, block breaking, item interactions). You'll need to add code to handle these events. * **Threading/Asynchronous Operations:** For a more robust server, consider using threading or asynchronous operations (e.g., `asyncio`) to handle multiple clients concurrently. The current implementation is single-threaded and will block while handling each client. * **Security:** Implement security measures to protect against common Minecraft server attacks (e.g., denial-of-service attacks, exploits). * **Libraries:** Consider using libraries like `nbt` for handling NBT data (used for storing world data) and `cryptography` for encryption and authentication. This improved example provides a much more solid foundation for building a functional Minecraft server in Python. Remember to consult the Minecraft Protocol documentation for the specific version you are targeting.

Metaplex MCP Server

鏡 (Kagami)

MCP Calculate Server

MCPプロトコルを通じて、基本的な算術、代数、微積分、方程式の求解、行列演算などの記号計算をユーザーが行えるようにする数学計算サービス。

PDF Search for Zed

Zed用のMCPサーバー拡張機能で、PDFファイルから関連する部分を取得するもの

Ubuntu SSH Docker Container

MCP-RSS-Crawler

MCPサーバーは、RSSフィードを取得し、それをLLM（大規模言語モデル）と共有することで、AIアシスタントが設定されたフィードから最新のニュースや記事にアクセスし、提示できるようにするものです。

Upbit MCP Server

Upbit暗号資産取引所のサービスと連携し、市場データの取得、アカウント管理、取引の実行を行います。注文管理、入出金、テクニカル分析のツールで、取引体験を簡素化します。

MCP Web UI

MCP Web UIは、Model Context Protocol（MCP）アーキテクチャ内でホストとして機能する、ウェブベースのユーザーインターフェースです。クライアントとサーバー間のコンテキスト集約と連携を管理しながら、大規模言語モデル（LLM）と対話するための、強力でユーザーフレンドリーなインターフェースを提供します。