Discover Awesome MCP Servers

mcp-stat-lv

MCP server that enables querying Latvian official statistics from data.stat.gov.lv via PxWeb tables, allowing retrieval of table definitions and data through natural language or direct tool calls.

civic-awareness-mcp

Provides tools to search and retrieve US federal and state legislative data, including bills, votes, campaign contributions, and legislator information, with provenance tracking.

mcp-curiosity-engine

Surface forgotten notes from markdown vaults using DMN-inspired replay cycle to identify dormant notes and generate cross-domain connections.

email.deadsimple/dead-simple-email

Provides AI agents with real email infrastructure, enabling them to create inboxes, send/receive messages, and extract verification codes from incoming mail.

SDN MCP Template

A reusable MCP server template for AI agents to operate SDN network controllers via tools, built on FastMCP with Streamable HTTP and stdio support.

Roblox Bridge Agent

A local-first MCP bridge and script operations layer that connects coding agents to authorized Roblox Luau development clients via websocket, enabling live execution, file watching, diagnostics, permission-gated script capsules, crash detection, and a dashboard.

Avizo MCP Server

Enables automation of Thermo Scientific Amira-Avizo on Windows by discovering, inspecting, and creating workflows, and launching Avizo or its bundled Python.

mssql-mcp

A read-only MCP server for Microsoft SQL Server that allows running SELECT queries and analyzing query performance with statistics.

prowlarr-mcp

MCP server exposing Prowlarr's API v1 as tools for managing indexers, applications, download clients, and more, including cross-indexer searches and system commands.

AutoCAD MCP Server

Um servidor que permite a interação em linguagem natural com o AutoCAD através de grandes modelos de linguagem como o Claude, permitindo que os usuários criem e modifiquem desenhos usando comandos conversacionais.

template-mcp-server

Okay, here's a PDM template structure and some key considerations for developing an MCP (Minecraft Protocol) server in Python, along with explanations to help you understand the choices: **Project Structure (using PDM):** ``` my_mcp_server/ ├── pyproject.toml # PDM configuration file ├── src/ │ └── my_mcp_server/ # Your actual server code │ ├── __init__.py │ ├── server.py # Main server logic │ ├── protocol/ # Handles Minecraft protocol │ │ ├── __init__.py │ │ ├── packets.py # Packet definitions (classes) │ │ ├── serialization.py # Packet serialization/deserialization │ │ ├── handshake.py # Handshake logic │ │ ├── status.py # Status ping logic │ │ ├── login.py # Login logic │ │ └── ... │ ├── player/ # Player-related logic │ │ ├── __init__.py │ │ ├── player.py # Player class │ │ ├── inventory.py # Inventory management │ │ └── ... │ ├── world/ # World generation and management │ │ ├── __init__.py │ │ ├── world.py # World class │ │ ├── chunk.py # Chunk management │ │ ├── generator.py # World generation algorithms │ │ └── ... │ ├── commands/ # Command handling │ │ ├── __init__.py │ │ ├── command_handler.py │ │ ├── ... │ ├── config.py # Configuration loading │ ├── logging_setup.py # Logging configuration │ └── ... ├── tests/ # Unit tests │ ├── __init__.py │ ├── test_server.py │ ├── test_protocol.py │ └── ... ├── README.md ├── .gitignore └── LICENSE ``` **Explanation of the Structure:** * **`my_mcp_server/` (Root Directory):** The top-level directory for your project. * **`pyproject.toml`:** This is the heart of your PDM project. It defines your project's metadata (name, version, authors), dependencies, and build system configuration. * **`src/my_mcp_server/`:** This is where your actual Python code lives. Using `src/` is a common practice to separate your source code from other project files (like tests, documentation, etc.). The inner `my_mcp_server/` creates a Python package. * **`server.py`:** This file will contain the main server loop, socket handling, and the entry point for your application. * **`protocol/`:** This is a crucial directory. It's responsible for handling the Minecraft protocol itself. * **`packets.py`:** Defines Python classes that represent Minecraft packets. Each packet type (e.g., `HandshakePacket`, `LoginStartPacket`, `ChatMessagePacket`) will have its own class. These classes will hold the data for the packet. * **`serialization.py`:** Handles the conversion of Python packet objects into byte streams (for sending over the network) and byte streams into Python packet objects (for receiving). This is where you'll implement the Minecraft protocol's data types (varints, strings, etc.). * **`handshake.py`, `status.py`, `login.py`:** These modules handle the specific stages of the Minecraft connection process. The handshake determines the protocol version, the status stage provides server information to the client, and the login stage authenticates the player. * **`player/`:** Manages player-related data and logic. * **`player.py`:** Defines the `Player` class, which will hold information about each connected player (username, UUID, position, health, inventory, etc.). * **`inventory.py`:** Handles the player's inventory. * **`world/`:** Deals with world generation and management. * **`world.py`:** Represents the game world. * **`chunk.py`:** Handles the storage and management of world chunks (16x16x256 blocks). * **`generator.py`:** Contains algorithms for generating the world (e.g., flat world, random terrain, etc.). * **`commands/`:** Handles server commands. * **`command_handler.py`:** Parses and executes commands entered by players or the server console. * **`config.py`:** Loads server configuration settings from a file (e.g., `server.properties`). * **`logging_setup.py`:** Configures the Python logging system for your server. Good logging is essential for debugging and monitoring. * **`tests/`:** Contains unit tests to ensure your code is working correctly. * **`README.md`:** A description of your project. * **`.gitignore`:** Specifies files and directories that should be ignored by Git (e.g., `.venv`, `__pycache__`). * **`LICENSE`:** The license under which your project is released. **`pyproject.toml` Example:** ```toml [project] name = "my_mcp_server" version = "0.1.0" description = "A Minecraft Protocol server in Python" authors = [ {name = "Your Name", email = "your.email@example.com"} ] license = {text = "MIT"} # Or choose another license readme = "README.md" requires-python = ">=3.8" keywords = ["minecraft", "server", "mcp"] classifiers = [ "Development Status :: 3 - Alpha", "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", "Operating System :: OS Independent", ] [project.dependencies] # Add your dependencies here. Examples: # asyncio = ">=3.4" # Already part of Python 3.7+ # aiohttp = ">=3.8" # For asynchronous HTTP requests (optional) # python-nbt = ">=1.5" # For reading/writing NBT data (world data) # pycryptodome = ">=3.11" # For encryption (optional, for online mode) # ... other dependencies ... [project.optional-dependencies] dev = [ "pytest", "pytest-asyncio", "mypy", "flake8", "black" ] [build-system] requires = ["pdm-backend"] build-backend = "pdm.backend" [tool.pdm] version = {source = "scm"} [tool.pdm.dev-dependencies] dev = ["pytest", "pytest-asyncio", "mypy", "flake8", "black"] [tool.pdm.scripts] start = "python src/my_mcp_server/server.py" test = "pytest" lint = "flake8 src/my_mcp_server" format = "black src/my_mcp_server" typecheck = "mypy src/my_mcp_server" ``` **Key Considerations and Code Snippets:** 1. **Asynchronous Programming (Crucial):** Minecraft servers are inherently concurrent. You *must* use asynchronous programming (using `asyncio` in Python) to handle multiple client connections efficiently. Blocking operations will kill your server's performance. ```python # Example (server.py): import asyncio async def handle_client(reader, writer): addr = writer.get_extra_info('peername') print(f"Connected by {addr}") try: while True: data = await reader.read(1024) # Read data asynchronously if not data: break message = data.decode() print(f"Received {message} from {addr}") writer.write(f"Echo: {message}".encode()) await writer.drain() # Ensure data is sent asynchronously except ConnectionResetError: print(f"Client {addr} disconnected abruptly.") finally: print(f"Closing connection for {addr}") writer.close() await writer.wait_closed() async def main(): server = await asyncio.start_server( handle_client, '127.0.0.1', 25565) # Standard Minecraft port addr = server.sockets[0].getsockname() print(f"Serving on {addr}") async with server: await server.serve_forever() if __name__ == "__main__": asyncio.run(main()) ``` 2. **Minecraft Protocol Implementation:** This is the most complex part. You'll need to meticulously implement the Minecraft protocol. Refer to the official Minecraft protocol documentation (search for "Minecraft Protocol" on the Minecraft Wiki or look at the wiki.vg site). Pay close attention to: * **VarInts/VarLongs:** Variable-length integers are used extensively in the protocol. You'll need functions to encode and decode them. * **Packet IDs:** Each packet type has a unique ID. * **Data Types:** Strings, integers, booleans, arrays, NBT data, etc. * **Packet Structure:** The order and types of data fields within each packet. * **Compression:** The protocol supports compression to reduce bandwidth usage. ```python # Example (protocol/packets.py): class Packet: packet_id = None # Abstract base class def serialize(self): raise NotImplementedError @classmethod def deserialize(cls, data): raise NotImplementedError class HandshakePacket(Packet): packet_id = 0x00 # Handshake packet ID def __init__(self, protocol_version, server_address, server_port, next_state): self.protocol_version = protocol_version self.server_address = server_address self.server_port = server_port self.next_state = next_state def serialize(self): # Implement serialization logic here (convert to bytes) pass @classmethod def deserialize(cls, data): # Implement deserialization logic here (convert from bytes to object) pass ``` 3. **NBT Data:** Minecraft uses the NBT (Named Binary Tag) format for storing world data, player data, and other game information. Use a library like `python-nbt` to read and write NBT data. 4. **World Generation:** Start with a simple world generator (e.g., a flat world) and gradually add more complex generation algorithms. 5. **Multiplayer Considerations:** Think about how you'll handle multiple players interacting with the world simultaneously. You'll need to implement thread-safe or process-safe data structures and synchronization mechanisms. Consider using a database (e.g., SQLite, PostgreSQL) to store world data and player data persistently. 6. **Security:** Implement proper security measures to prevent cheating and attacks. This includes: * **Authentication:** Verify player identities using the Minecraft authentication system (if you want online mode). * **Input Validation:** Validate all data received from clients to prevent exploits. * **Rate Limiting:** Limit the rate at which clients can send packets to prevent flooding. 7. **Configuration:** Use a configuration file (e.g., `server.properties`) to store server settings like port number, maximum players, world name, etc. The `config.py` module should handle loading these settings. 8. **Logging:** Use the Python `logging` module to log important events and errors. This will help you debug and monitor your server. 9. **Testing:** Write unit tests to ensure your code is working correctly. Use a testing framework like `pytest`. **How to use PDM:** 1. **Install PDM:** `pip install pdm` 2. **Create the project:** `pdm create` (Choose "standard package" or "src layout") 3. **Add dependencies:** `pdm add <package_name>` (e.g., `pdm add asyncio aiohttp python-nbt`) 4. **Install dependencies:** `pdm install` 5. **Run scripts:** `pdm run <script_name>` (e.g., `pdm run start`) **Example `server.py` (basic):** ```python import asyncio import logging from my_mcp_server.protocol.handshake import handle_handshake from my_mcp_server.protocol.status import handle_status from my_mcp_server.protocol.login import handle_login # Configure logging (you'll want to customize this) logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') async def handle_client(reader, writer): addr = writer.get_extra_info('peername') logging.info(f"New connection from {addr}") try: # Handshake protocol_version, next_state = await handle_handshake(reader, writer) if next_state == 1: # Status await handle_status(reader, writer) elif next_state == 2: # Login await handle_login(reader, writer, protocol_version) else: logging.warning(f"Invalid next_state: {next_state}") writer.close() await writer.wait_closed() return # Main game loop (not implemented in this example) # ... except ConnectionResetError: logging.info(f"Client {addr} disconnected abruptly.") except Exception as e: logging.exception(f"Error handling client {addr}: {e}") finally: logging.info(f"Closing connection for {addr}") writer.close() await writer.wait_closed() async def main(): server = await asyncio.start_server( handle_client, '127.0.0.1', 25565) # Standard Minecraft port addr = server.sockets[0].getsockname() logging.info(f"Serving on {addr}") async with server: await server.serve_forever() if __name__ == "__main__": asyncio.run(main()) ``` **Example `protocol/handshake.py`:** ```python import asyncio import logging from my_mcp_server.protocol.serialization import read_varint, read_string async def handle_handshake(reader, writer): """Handles the initial handshake with the client.""" try: # Read the packet length (VarInt) packet_length = await read_varint(reader) logging.debug(f"Handshake packet length: {packet_length}") # Read the packet ID (VarInt) packet_id = await read_varint(reader) logging.debug(f"Handshake packet ID: {packet_id}") if packet_id != 0x00: logging.warning(f"Unexpected packet ID in handshake: {packet_id}") writer.close() await writer.wait_closed() return None, None # Read protocol version (VarInt) protocol_version = await read_varint(reader) logging.debug(f"Protocol version: {protocol_version}") # Read server address (String) server_address = await read_string(reader) logging.debug(f"Server address: {server_address}") # Read server port (Unsigned Short - 2 bytes) server_port_bytes = await reader.readexactly(2) server_port = int.from_bytes(server_port_bytes, 'big') logging.debug(f"Server port: {server_port}") # Read next state (VarInt) next_state = await read_varint(reader) logging.debug(f"Next state: {next_state}") return protocol_version, next_state except asyncio.IncompleteReadError: logging.warning("Incomplete read during handshake.") writer.close() await writer.wait_closed() return None, None except Exception as e: logging.exception(f"Error during handshake: {e}") writer.close() await writer.wait_closed() return None, None ``` **Example `protocol/serialization.py`:** ```python import asyncio async def read_varint(reader): """Reads a VarInt from the given reader.""" result = 0 shift = 0 while True: byte = await reader.readexactly(1) value = byte[0] result |= (value & 0x7F) << shift shift += 7 if not (value & 0x80): break if shift > 35: # Prevent infinite loop raise ValueError("VarInt is too big") return result async def write_varint(writer, value): """Writes a VarInt to the given writer.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 writer.write(bytes([byte])) if value == 0: break await writer.drain() # Ensure data is sent async def read_string(reader): """Reads a string from the given reader (prefixed with a VarInt length).""" length = await read_varint(reader) data = await reader.readexactly(length) return data.decode('utf-8') async def write_string(writer, value): """Writes a string to the given writer (prefixed with a VarInt length).""" encoded = value.encode('utf-8') await write_varint(writer, len(encoded)) writer.write(encoded) await writer.drain() ``` **Important Notes:** * **Start Small:** Don't try to implement the entire Minecraft protocol at once. Focus on the handshake, status, and login stages first. Then, gradually add more features. * **Refer to Existing Implementations:** Look at open-source Minecraft server implementations (e.g., in Java, C++) for inspiration and guidance. However, be careful not to directly copy code, as that could violate copyright. * **Debugging:** Use a debugger to step through your code and inspect variables. Logging is also essential for debugging. * **Error Handling:** Implement robust error handling to prevent your server from crashing. * **Performance:** Profile your code to identify performance bottlenecks and optimize them. * **Community:** Join the Minecraft server development community for help and support. This is a complex project, but with careful planning and a step-by-step approach, you can build your own Minecraft Protocol server in Python. Good luck! Let me know if you have more specific questions.

github-twin

A personal RAG MCP server that indexes your GitHub commits and review comments, surfacing them as retrieval hits to help Claude Code write or review code in your style.

HaloPSA API Gateway MCP Server

Enables interaction with the HaloPSA API for managing tickets, clients, assets, and more through natural language commands in Claude Desktop.

slikk

A minimal MCP server that resolves skill names to filesystem paths + metadata, enabling on-demand skill retrieval without loading full content into context.

Cross-Border Transaction Cost Calculator

Calculates total landed cost of international payments including FX spread, transfer fees, and settlement time across multiple payment methods, and provides free currency conversion and ECB exchange rates.

confluence-mcp

Enables Confluence page lookup, CQL search, page creation/updates, comments, and space discovery through a local MCP server with token-based auth.

mcp-image-previewer

Enables previewing base64-encoded images in a native GUI window using Slint, with support for window reuse, always-on-top, and show/hide functionality.

TickTick MCP Server

A comprehensive Model Context Protocol server providing complete TickTick task management API integration (112 operations) for Claude Code users, enabling seamless task creation, project management, habit tracking, and productivity features.

akka-finance-mcp-server

MCP server for the AKKA Finance DEX aggregator — swap quotes, routes, and execution across EVM chains.

browser-migrate

MCP server to drive browser-migrate operations from Claude, enabling exporting, importing, and migrating browser profiles (bookmarks, history, tabs) between browsers.

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.

IBM MDM MCP Server

A Model Context Protocol (MCP) server that provides AI assistants with seamless access to IBM Master Data Management (MDM) services through standardized REST API interactions.

atlas-przetargow-mcp-py

Enables searching and analyzing Polish public procurement tenders from BZP and TED, including filtering, tender details and timelines, offers and contract values, buyer/contractor profiles, CPV code lookup, and regional statistics, with optional AI-summary endpoints.

mcp-email

A minimal MCP server for reading, searching, managing, and sending email over IMAP and SMTP.

ast-editor

A robust, language-agnostic Model Context Protocol (MCP) server that provides AI coding agents with the ability to edit files surgically via Abstract Syntax Trees (AST) instead of relying on token-heavy, brittle search-and-replace or diff operations.

pgtuner_mcp

provides AI-powered PostgreSQL performance tuning capabilities.

blender-orchestrator

Create 3D models in Blender using natural language via an MCP server that lets AI agents directly control Blender, enabling complex 3D scene creation through conversation.

eSewa-Khalti MCP

Integrates eSewa and Khalti payment gateways into Claude, enabling payment processing via natural language.

Oura MCP server

Enables users to access and query Oura ring health data, including sleep periods, readiness, activity, workouts, heart rate, stress, SpO2, resilience, and more, through Claude.ai or Claude Code using the Oura API v2 with OAuth 2.1 login.

Hive Intelligence

The Ultimate Cryptocurrency MCP for AI Assistants - Unified access to crypto, DeFi, and Web3 analytics | MCP Endpoint.