Discover Awesome MCP Servers

Hong Kong Open Data MCP Server

Enables access to Hong Kong government's official open data portal (DATA.GOV.HK) through natural language queries. Supports searching datasets, browsing categories, and retrieving detailed information about Hong Kong's public data resources.

MCP Server for NovaCV

A Model Context Protocol server for accessing NovaCV resume services API, enabling users to generate PDF resumes, analyze resume content, convert resume text to JSON format, and get available resume templates.

Simple Code Review Assistant

Enables AI models to access GitHub repository information and search local documentation files. Provides three basic tools: fetching repository details, retrieving file contents from GitHub, and searching through local markdown documentation.

simple-mcp-server

TypeScript で書かれたシンプルな MCP 天気サーバー

Statelessor MCP Server

Analyzes .NET and Java projects to detect stateful code patterns and provides remediation guidance for migrating to stateless architectures.

Awesome MCPs

An awesome collection of Model Context Protocol (MCP) tools

OpenRouter Web Search MCP Server

OpenRouter を利用してウェブ検索を提供する MCP サーバー :オンライン

Agentic MCP Client

MCP（モデルコンテキストプロトコル）ツールを介して、Anthropic Claude、AWS BedRock、OpenAI APIを使用してタスクを実行するスタンドアロンのエージェントランナーです。AIエージェントがクラウド環境で自律的に実行され、さまざまなシステムと安全にやり取りすることを可能にします。

AutoCAD MCP Server

Claudeのような大規模言語モデルを通じて、AutoCADとの自然言語インタラクションを可能にするサーバー。ユーザーは会話形式のコマンドを使って図面を作成・修正できます。

template-mcp-server

Okay, here's a PDM template structure and some example files to help you get started developing an MCP (Minecraft Protocol) server in Python. This template focuses on setting up a good project structure, dependency management with PDM, and basic scaffolding for handling network connections. **Project Structure:** ``` mcp_server_template/ ├── pyproject.toml # PDM configuration file ├── pdm.lock # PDM lockfile (generated) ├── src/ │ └── mcp_server/ │ ├── __init__.py │ ├── server.py # Main server logic │ ├── protocol/ │ │ ├── __init__.py │ │ ├── packets.py # Packet definitions │ │ ├── handlers.py # Packet handling logic │ ├── config.py # Server configuration │ ├── utils.py # Utility functions ├── tests/ │ ├── __init__.py │ ├── conftest.py # Pytest configuration │ ├── test_server.py # Example tests ├── README.md └── .gitignore ``` **Explanation:** * **`mcp_server_template/`:** The root directory of your project. * **`pyproject.toml`:** This is the heart of your PDM project. It defines your project metadata, dependencies, and build settings. * **`pdm.lock`:** PDM uses this file to lock down the exact versions of your dependencies, ensuring reproducible builds. *Do not edit this file directly.* * **`src/mcp_server/`:** This is where your main application code lives. Using `src` is a best practice for Python projects. * **`__init__.py`:** Makes `mcp_server` a Python package. * **`server.py`:** Contains the core server logic: socket setup, connection handling, main loop. * **`protocol/`:** Handles the Minecraft protocol itself. * **`packets.py`:** Defines the structure of Minecraft packets (e.g., using `struct` or a more advanced serialization library). This is *crucial* for MCP. * **`handlers.py`:** Contains functions to handle incoming packets. This is where you'll implement the game logic. * **`config.py`:** Loads and manages server configuration (port, max players, etc.). * **`utils.py`:** Utility functions that don't fit elsewhere (logging, data conversion, etc.). * **`tests/`:** Contains your unit tests. * **`conftest.py`:** Pytest configuration (fixtures, etc.). * **`test_server.py`:** Example tests for your server. * **`README.md`:** A description of your project. * **`.gitignore`:** Specifies files that should not be tracked by Git (e.g., `__pycache__`, `.venv`, `pdm.lock`). **Example Files:** **1. `pyproject.toml`:** ```toml [project] name = "mcp_server" version = "0.1.0" description = "A Minecraft Protocol (MCP) server implementation in Python." authors = [ {name = "Your Name", email = "your.email@example.com"} ] license = {text = "MIT"} # Or your preferred license readme = "README.md" requires-python = ">=3.8" keywords = ["minecraft", "server", "mcp", "protocol"] classifiers = [ "Development Status :: 3 - Alpha", "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", "Operating System :: OS Independent", ] [tool.pdm] version = {source = "scm"} auto_global = true [tool.pdm.dev-dependencies] dev = [ "pytest", "pytest-cov", "mypy", "flake8", "black", ] [build-system] requires = ["pdm-backend"] build-backend = "pdm.backend" [tool.pdm.scripts] start = "python src/mcp_server/server.py" test = "pytest -v --cov=src/mcp_server tests/" lint = "flake8 src/mcp_server tests/" format = "black src/mcp_server tests/" typecheck = "mypy src/mcp_server" [tool.pytest.ini_options] testpaths = ["tests"] addopts = ["-v", "--cov=src/mcp_server"] [tool.mypy] strict = true ignore_missing_imports = true [tool.flake8] max-line-length = 120 exclude = [".venv", "__pycache__", "migrations"] ``` **2. `src/mcp_server/server.py`:** ```python import socket import threading import logging from .config import Config # Import the Config class from .protocol.handlers import handle_packet # Import the packet handler logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') class MinecraftServer: def __init__(self, config: Config): self.config = config self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of the address self.server_socket.bind((self.config.host, self.config.port)) self.server_socket.listen(self.config.max_connections) self.clients = [] # List to store connected clients logging.info(f"Server listening on {self.config.host}:{self.config.port}") def run(self): try: while True: client_socket, client_address = self.server_socket.accept() logging.info(f"Accepted connection from {client_address}") self.clients.append(client_socket) # Add the client to the list client_thread = threading.Thread(target=self.handle_client, args=(client_socket,)) client_thread.start() except KeyboardInterrupt: logging.info("Shutting down server...") finally: self.stop() def handle_client(self, client_socket): try: while True: data = client_socket.recv(1024) # Adjust buffer size as needed if not data: break # Client disconnected # Process the received data (Minecraft packets) handle_packet(client_socket, data) # Pass the socket and data to the handler except ConnectionResetError: logging.warning("Client disconnected abruptly.") except Exception as e: logging.error(f"Error handling client: {e}") finally: self.clients.remove(client_socket) # Remove the client from the list client_socket.close() logging.info("Connection closed.") def stop(self): for client in self.clients: client.close() self.server_socket.close() logging.info("Server stopped.") if __name__ == "__main__": config = Config(host="127.0.0.1", port=25565, max_connections=10) # Example configuration server = MinecraftServer(config) server.run() ``` **3. `src/mcp_server/config.py`:** ```python class Config: def __init__(self, host: str, port: int, max_connections: int): self.host = host self.port = port self.max_connections = max_connections def __repr__(self): return f"Config(host='{self.host}', port={self.port}, max_connections={self.max_connections})" ``` **4. `src/mcp_server/protocol/packets.py`:** ```python # This file will define the structure of Minecraft packets. # You'll likely use the `struct` module for packing and unpacking data. # Example (very simplified): import struct # Example packet: Handshake (ID 0x00) # Fields: Protocol Version (VarInt), Server Address (String), Server Port (Unsigned Short), Next State (VarInt) def pack_handshake(protocol_version: int, server_address: str, server_port: int, next_state: int) -> bytes: """Packs a Handshake packet.""" # Implement VarInt encoding (see Minecraft protocol documentation) def encode_varint(value: int) -> bytes: data = bytearray() while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 data.append(byte) if value == 0: break return bytes(data) protocol_version_bytes = encode_varint(protocol_version) server_address_bytes = server_address.encode('utf-8') server_address_length = encode_varint(len(server_address_bytes)) server_port_bytes = struct.pack("!H", server_port) # Unsigned short (big-endian) next_state_bytes = encode_varint(next_state) packet_data = protocol_version_bytes + server_address_length + server_address_bytes + server_port_bytes + next_state_bytes packet_length = encode_varint(len(packet_data)) return packet_length + packet_data def unpack_handshake(data: bytes) -> tuple[int, str, int, int]: """Unpacks a Handshake packet.""" # Implement VarInt decoding (see Minecraft protocol documentation) def decode_varint(data: bytes) -> tuple[int, int]: # Returns (value, bytes_read) result = 0 shift = 0 index = 0 while True: byte = data[index] index += 1 result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break if shift > 35: raise ValueError("VarInt is too big") # Prevent infinite loop return result, index protocol_version, bytes_read = decode_varint(data) data = data[bytes_read:] server_address_length, bytes_read = decode_varint(data) data = data[bytes_read:] server_address = data[:server_address_length].decode('utf-8') data = data[server_address_length:] server_port = struct.unpack("!H", data[:2])[0] data = data[2:] next_state, bytes_read = decode_varint(data) return protocol_version, server_address, server_port, next_state # Add more packet definitions here as needed. ``` **5. `src/mcp_server/protocol/handlers.py`:** ```python import logging from .packets import unpack_handshake # Import packet unpacking functions def handle_packet(client_socket, data: bytes): """Handles incoming Minecraft packets.""" # Determine packet ID (first byte or VarInt) # For simplicity, assuming Handshake (ID 0x00) for now. You'll need a proper packet ID system. try: protocol_version, server_address, server_port, next_state = unpack_handshake(data) logging.info(f"Received Handshake: Protocol {protocol_version}, Address {server_address}, Port {server_port}, Next State {next_state}") # Handle the next state (e.g., Status or Login) if next_state == 1: # Status handle_status(client_socket) elif next_state == 2: # Login handle_login(client_socket) else: logging.warning(f"Unknown next state: {next_state}") except Exception as e: logging.error(f"Error handling packet: {e}") def handle_status(client_socket): """Handles Status requests.""" # Implement Status handling logic (e.g., send server info) logging.info("Handling Status request") # Example: Send a simple JSON response (you'll need to format it correctly) status_response = '{"version": {"name": "My Server", "protocol": 757}, "players": {"max": 10, "online": 0}, "description": {"text": "A simple Minecraft server"}}' # You need to pack this into a Minecraft packet (length-prefixed string) # See Minecraft protocol documentation for details. # For now, just sending the raw string (this won't work correctly with a real client) client_socket.sendall(status_response.encode('utf-8')) def handle_login(client_socket): """Handles Login requests.""" # Implement Login handling logic (e.g., authentication, encryption) logging.info("Handling Login request") # Placeholder pass ``` **6. `tests/test_server.py`:** ```python import pytest import socket import threading import time from src.mcp_server.server import MinecraftServer from src.mcp_server.config import Config @pytest.fixture def server(): config = Config(host="127.0.0.1", port=25566, max_connections=1) # Use a different port for testing server = MinecraftServer(config) server_thread = threading.Thread(target=server.run, daemon=True) # Daemon thread so it exits with the test server_thread.start() time.sleep(0.1) # Give the server a moment to start yield server server.stop() def test_server_connection(server): """Tests that the server can accept a connection.""" try: client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client_socket.connect(("127.0.0.1", 25566)) client_socket.close() assert True # Connection was successful except ConnectionRefusedError: assert False # Connection failed ``` **7. `.gitignore`:** ``` __pycache__/ .venv/ pdm.lock .idea/ *.pyc *.log ``` **How to Use This Template:** 1. **Install PDM:** `pip install pdm` 2. **Create the Project:** Create the directory structure and save the files above. 3. **Initialize PDM:** `pdm init` (Answer the questions to set up your project.) 4. **Install Dependencies:** `pdm install` (This will install the dependencies listed in `pyproject.toml`.) 5. **Run the Server:** `pdm run start` (This will execute the `start` script defined in `pyproject.toml`.) 6. **Run Tests:** `pdm run test` 7. **Lint Code:** `pdm run lint` 8. **Format Code:** `pdm run format` 9. **Type Check:** `pdm run typecheck` **Key Concepts and Next Steps:** * **Minecraft Protocol:** The *most important* thing is to thoroughly understand the Minecraft protocol. Refer to the official documentation (if available) and community resources like the Wiki.vg page on the Minecraft protocol. Pay close attention to: * **VarInt and VarLong:** Variable-length integers are used extensively. The example code includes basic encoding/decoding. * **Packet IDs:** Each packet has a unique ID that identifies its type. * **Data Types:** Strings, integers, booleans, arrays, etc., are encoded in specific ways. * **States:** The connection goes through different states (Handshake, Status, Login, Play). * **Asynchronous I/O (asyncio):** For a production-quality server, consider using `asyncio` for asynchronous network handling. This will allow you to handle many connections concurrently without using threads for each connection. This template uses threads for simplicity. * **Serialization Libraries:** Instead of manually packing and unpacking packets with `struct`, consider using a serialization library like `construct` or `protogen`. These libraries can make your code much cleaner and easier to maintain. * **Authentication:** Implement proper authentication to prevent unauthorized access to your server. * **Game Logic:** Start implementing the core game logic (world generation, player movement, block placement, etc.). * **Error Handling:** Robust error handling is crucial for a stable server. * **Logging:** Use logging extensively to help debug issues. * **Configuration:** Make your server configurable through a configuration file. * **Testing:** Write comprehensive unit tests to ensure your code is working correctly. **Important Considerations for MCP Servers:** * **Performance:** Minecraft servers can be resource-intensive. Optimize your code for performance. Profiling tools can help you identify bottlenecks. * **Security:** Security is paramount. Protect your server from attacks (e.g., denial-of-service, exploits). * **Scalability:** If you plan to support a large number of players, design your server to be scalable. This template provides a solid foundation for building your MCP server. Good luck! Let me know if you have any more questions.

Reachy Claude MCP

Integrates the Reachy Mini robot or its simulation with Claude Code to provide interactive physical feedback through emotions, speech, and celebratory animations. It features advanced capabilities like sentiment analysis, semantic problem search, and cross-project memory to enhance the developer experience.

MS Access MCP Explorer

Microsoft Access データベース用 MCP サーバー

Simplicate MCP Server

Enables AI assistants to securely access and interact with Simplicate business data including CRM, projects, timesheets, and invoices through natural language. Supports searching across resources and retrieving detailed information about organizations, contacts, and project data.

Windows-MCP

An MCP server designed for managing files and folders specifically on the Windows Desktop. It enables users to perform file operations like deletion while implementing security measures to prevent path traversal outside the Desktop directory.

Gemini MCP Server

A TypeScript implementation of a Model Context Protocol server that integrates with Google's Gemini 2.0 Flash model, enabling Claude Desktop users to interact with Gemini through natural language conversations.

Nano Currency MCP Server

Send Nano currency from AI agents/LLMs

kube-lint-mcp

MCP server to lint and validate Kubernetes-related manifests(Helm, FluxCD, ArgoCD, Kustomize, etc.)

claude-memory-fts

Long-term memory MCP server for Claude Code with SQLite FTS5 full-text search, BM25 ranking, access tracking, and upsert deduplication. Zero config via npx.

MCP MD2PDF Server

Provides tools for converting Markdown content and files into professional PDF documents with full support for Mermaid diagrams and LaTeX rendering. It allows for high-quality output customization, including paper size, table of contents, and syntax highlighting styles.

Seitrace Insights MCP Server

Enables natural language access to blockchain data and insights through the Seitrace API. Supports querying address details, token information (ERC-20, ERC-721, ERC-1155, CW20, CW721), transaction data, and smart contract details across multiple blockchain networks.

MCP Calculator Server

A containerized MCP (Model Context Protocol) server that provides a simple calculator tool for adding two numbers, deployable to Kubernetes/EKS environments.

Switzerland Farm Safety MCP

Enables querying of Swiss farm workplace safety regulations including BUL/SPAA rules, Suva occupational requirements, EKAS standards, and Agriss accident statistics. Provides tools for risk assessments, machinery safety compliance, chemical exposure limits, young worker protections, and accident reporting guidelines.

Taoke MCP

Enables affiliate marketing and product promotion across Taobao, JD.com, and Pinduoduo platforms with link conversion, product search, and order tracking capabilities.

Linkup Search

Claudeにリアルタイムの知識とプレミアムコンテンツへのアクセスを提供します。Linkupの強力な検索機能を通じて、Claudeのカットオフデータを解消し、最新のイベントや信頼できるプレミアムソースでClaudeの応答を変換します。

FHIR MCP Server

Enables LLM-based agents to interact with FHIR healthcare data through natural language prompts, providing full CRUD operations on FHIR resources, document processing, and semantic search capabilities.

YApi MCP Server

Enables access to YApi interface documentation by retrieving API details through interface IDs or direct YApi URLs.

Cursor MCP File Organizer

ダウンロードフォルダ内のファイルを、ファイルの種類に基づいて適切なディレクトリに自動的に分類して整理します。

Memory MCP

An MCP server that provides AI assistants with persistent, semantic memory using Turso for storage and OpenAI for vector search. It enables natural language operations to store, retrieve, and refine information with automatic duplicate detection and quality validation.