Discover Awesome MCP Servers

Cline Notification Server

MCP (presumably referring to a Minecraft server) から Telegram 経由で通知を送信する

Dida365 MCP Server

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

mcp-box

MCPサーバー用のmcp-box

cal2prompt

✨ Googleカレンダーからスケジュールを取得し、それを単一のLLMプロンプトとして出力します（オプションでMCPサーバーモードも利用可能）。

mcp-golang

Please provide the link to the documentation you are referring to. I need the documentation to understand the Model Context Protocol and write the Go code for the servers. Without the documentation, I can only provide a very generic example, which is unlikely to be what you need. For example, if I *assume* it's a simple request-response protocol over TCP, I could provide something like this: ```go package main import ( "fmt" "net" "os" ) func handleConnection(conn net.Conn) { defer conn.Close() buf := make([]byte, 1024) reqLen, err := conn.Read(buf) if err != nil { fmt.Println("Error reading:", err.Error()) return } request := string(buf[:reqLen]) fmt.Println("Received:", request) // Process the request (replace with actual Model Context Protocol logic) response := "Processed: " + request _, err = conn.Write([]byte(response)) if err != nil { fmt.Println("Error writing:", err.Error()) } } func main() { ln, err := net.Listen("tcp", ":8080") // Listen on port 8080 if err != nil { fmt.Println("Error listening:", err.Error()) os.Exit(1) } defer ln.Close() fmt.Println("Server listening on :8080") for { conn, err := ln.Accept() if err != nil { fmt.Println("Error accepting:", err.Error()) continue } go handleConnection(conn) } } ``` **Explanation (of the generic example):** 1. **`package main`**: Declares the package as `main`, making it an executable program. 2. **`import`**: Imports necessary packages: - `fmt`: For printing to the console. - `net`: For networking operations. - `os`: For exiting the program. 3. **`handleConnection(conn net.Conn)`**: This function handles each individual client connection. - `defer conn.Close()`: Ensures the connection is closed when the function exits. - `buf := make([]byte, 1024)`: Creates a buffer to read data from the connection. - `conn.Read(buf)`: Reads data from the connection into the buffer. - `request := string(buf[:reqLen])`: Converts the received bytes to a string. - `response := "Processed: " + request`: **Placeholder:** This is where you would implement the actual Model Context Protocol logic to process the request and generate a response. This example just prepends "Processed: " to the request. - `conn.Write([]byte(response))`: Sends the response back to the client. 4. **`main()`**: The main function of the program. - `net.Listen("tcp", ":8080")`: Creates a TCP listener on port 8080. - `defer ln.Close()`: Ensures the listener is closed when the program exits. - `for {}`: An infinite loop to accept incoming connections. - `conn, err := ln.Accept()`: Accepts a new connection. - `go handleConnection(conn)`: Starts a new goroutine to handle the connection concurrently. **To make this code useful, you MUST provide the documentation for the Model Context Protocol.** I need to know: * **What is the protocol?** (e.g., TCP, UDP, HTTP, gRPC, etc.) * **What is the message format?** (e.g., JSON, Protocol Buffers, plain text, binary format, etc.) * **What are the expected requests and responses?** * **What is the purpose of the protocol?** (What kind of data is being exchanged?) Once you provide the documentation, I can give you a much more accurate and helpful Go implementation.

📱 MCP Server for iOS Simulator

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

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サーバー

MCP Atlassian Jira Server

Atlassian Jira 連携のための Model Context Protocol (MCP) サーバー。boilerplate-mcp-server からフォークされました。

AppTweak MCP Server

AppTweak MCP サーバー（Cline用） - アプリストア分析と競合分析のためのツールを提供します。

LSP MCP

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

Puppeteer MCP Server

鏡 (Kagami)

mcp-server-sql-analyzer

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

MCP-RSS-Crawler

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

Upbit MCP Server

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

MCP Web UI

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

MCP Calculate Server

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

PDF Search for Zed

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

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)

AWS Service Reference MCP Server

AWS プログラマティックサービス認証リファレンスにアクセスするための MCP サーバー

MCP Weather

AIエージェントがリアルタイムの気象データにアクセスできるようにするための、気象モデルコンテキストプロトコル（MCP）ツールサーバー。