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

Un servidor que permite la interacción en lenguaje natural con AutoCAD a través de modelos de lenguaje grandes como Claude, permitiendo a los usuarios crear y modificar dibujos utilizando comandos conversacionales.

template-mcp-server

Okay, here's a PDM template structure and some key considerations for developing an MCP (Minecraft Protocol) server in Python. This template focuses on project organization, dependency management, and basic server structure. **Project Structure (using PDM)** ``` mcp_server/ ├── pyproject.toml # PDM configuration file ├── src/ │ ├── mcp_server/ # Main package directory │ │ ├── __init__.py # Makes 'mcp_server' a package │ │ ├── server.py # Core server logic │ │ ├── protocol/ # Protocol handling │ │ │ ├── __init__.py │ │ │ ├── packets.py # Packet definitions (classes) │ │ │ ├── serialization.py # Packet serialization/deserialization │ │ │ ├── handshake.py # Handshake logic │ │ │ ├── status.py # Status logic (ping, server info) │ │ │ ├── login.py # Login logic │ │ │ ├── play.py # In-game logic (chat, movement, etc.) │ │ ├── player.py # Player class │ │ ├── world/ # World management │ │ │ ├── __init__.py │ │ │ ├── chunk.py # Chunk representation │ │ │ ├── world.py # World class │ │ │ ├── generator.py # World generation │ │ ├── config.py # Server configuration │ │ ├── utils.py # Utility functions │ ├── main.py # Entry point to start the server ├── tests/ │ ├── __init__.py │ ├── conftest.py # Pytest configuration │ ├── test_packets.py # Unit tests for packet handling │ ├── test_server.py # Unit tests for server logic ├── README.md ├── LICENSE ``` **1. `pyproject.toml` (PDM Configuration)** ```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" # Minimum Python version keywords = ["minecraft", "server", "mcp", "protocol"] classifiers = [ "Development Status :: 3 - Alpha", "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", "Operating System :: OS Independent", ] [project.urls] "Homepage" = "https://github.com/yourusername/mcp_server" "Bug Tracker" = "https://github.com/yourusername/mcp_server/issues" [tool.pdm] version = {source = "scm"} [tool.pdm.dev-dependencies] dev = [ "pytest", "pytest-cov", "mypy", "flake8", "black", ] [tool.pdm.scripts] test = "pytest -v --cov=src/mcp_server" lint = "flake8 src/mcp_server tests" format = "black src/mcp_server tests" typecheck = "mypy src/mcp_server" start = "python src/main.py" [tool.pytest.ini_options] testpaths = ["tests"] addopts = ["-v", "--cov=src/mcp_server"] [tool.mypy] strict = true ignore_missing_imports = true [build-system] requires = ["pdm-backend"] build-backend = "pdm.backend" ``` **Explanation of `pyproject.toml`:** * **`[project]`:** Metadata about your project (name, version, description, authors, license, etc.). * **`[tool.pdm]`:** PDM-specific settings. * `version = {source = "scm"}`: Automatically manages the version based on Git tags (requires `pdm-plugin-version`). You can also use a static version. * **`[tool.pdm.dev-dependencies]`:** Development dependencies (testing, linting, formatting, type checking). These are *not* required for running the server, only for development. * **`[tool.pdm.scripts]`:** Defines convenient commands you can run with `pdm run <script_name>`. For example, `pdm run test` will run your tests. * **`[tool.pytest.ini_options]`:** Configuration for `pytest`. * **`[tool.mypy]`:** Configuration for `mypy` (static type checker). * **`[build-system]`:** Specifies the build backend (PDM in this case). **2. `src/mcp_server/server.py` (Core Server Logic)** ```python import asyncio import logging import socket from typing import Tuple from .protocol.handshake import handle_handshake from .protocol.login import handle_login from .protocol.status import handle_status from .player import Player class MinecraftServer: def __init__(self, host: str, port: int): self.host = host self.port = port self.running = False self.players: list[Player] = [] self.logger = logging.getLogger("MinecraftServer") self.logger.setLevel(logging.INFO) # Adjust as needed self.logger.addHandler(logging.StreamHandler()) async def handle_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter): addr = writer.get_extra_info('peername') self.logger.info(f"New connection from {addr}") try: # Handshake protocol_version, server_address, server_port, next_state = await handle_handshake(reader) if next_state == 1: # Status await handle_status(writer) elif next_state == 2: # Login player = await handle_login(reader, writer) if player: self.players.append(player) self.logger.info(f"Player {player.name} logged in.") # TODO: Start the play sequence (game loop) await self.play_sequence(player, reader, writer) else: self.logger.warning(f"Login failed for {addr}") else: self.logger.warning(f"Unknown next state: {next_state}") except Exception as e: self.logger.exception(f"Error handling client {addr}: {e}") finally: writer.close() await writer.wait_closed() self.logger.info(f"Connection closed with {addr}") async def play_sequence(self, player: Player, reader: asyncio.StreamReader, writer: asyncio.StreamWriter): """Handles the in-game play sequence for a connected player.""" try: while True: # TODO: Implement packet handling for in-game actions # Example: # packet_id, packet_data = await read_packet(reader) # if packet_id == 0x03: # Chat Message # message = parse_chat_message(packet_data) # self.broadcast_message(f"<{player.name}> {message}") await asyncio.sleep(0.01) # Prevent busy-waiting except Exception as e: self.logger.exception(f"Error in play sequence for {player.name}: {e}") finally: self.players.remove(player) self.logger.info(f"Player {player.name} disconnected.") writer.close() await writer.wait_closed() async def start(self): self.running = True try: server = await asyncio.start_server( self.handle_client, self.host, self.port ) addr = server.sockets[0].getsockname() self.logger.info(f"Serving on {addr}") async with server: await server.serve_forever() except Exception as e: self.logger.error(f"Server error: {e}") finally: self.running = False async def stop(self): self.running = False # TODO: Implement graceful shutdown (disconnect clients, save data) self.logger.info("Server stopping...") # Example usage (in main.py): async def main(): server = MinecraftServer("127.0.0.1", 25565) await server.start() if __name__ == "__main__": asyncio.run(main()) ``` **3. `src/mcp_server/protocol/` (Protocol Handling)** This directory contains modules for handling different stages of the Minecraft protocol. Each module (e.g., `handshake.py`, `status.py`, `login.py`, `play.py`) will contain functions to: * **Read packets:** Parse the incoming byte stream to identify the packet ID and extract the data. * **Serialize/Deserialize packets:** Convert Python objects to byte streams for sending, and vice versa. Use a library like `struct` or `construct` for this. * **Implement the protocol logic:** Handle the specific steps for each stage (e.g., responding to a status request, authenticating a player). **Example: `src/mcp_server/protocol/handshake.py`** ```python import asyncio import struct import logging async def read_varint(reader: asyncio.StreamReader) -> int: """Reads a Minecraft VarInt from the stream.""" 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: raise ValueError("VarInt is too big") return result async def handle_handshake(reader: asyncio.StreamReader) -> tuple[int, str, int, int]: """Handles the initial handshake with the client.""" packet_length = await read_varint(reader) packet_id = await read_varint(reader) if packet_id != 0x00: raise ValueError(f"Unexpected packet ID in handshake: {packet_id}") protocol_version = await read_varint(reader) server_address_length = await read_varint(reader) server_address_bytes = await reader.readexactly(server_address_length) server_address = server_address_bytes.decode('utf-8') server_port = struct.unpack('>H', await reader.readexactly(2))[0] # Big-endian unsigned short next_state = await read_varint(reader) logging.info(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, Next State {next_state}") return protocol_version, server_address, server_port, next_state ``` **Example: `src/mcp_server/protocol/status.py`** ```python import asyncio import json import struct async def write_varint(writer: asyncio.StreamWriter, value: int): """Writes a Minecraft VarInt to the stream.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 writer.write(struct.pack('B', byte)) if value == 0: break await writer.drain() async def handle_status(writer: asyncio.StreamWriter): """Handles the status request from the client.""" # Respond to Request (empty packet) await write_varint(writer, 1) # Packet Length await write_varint(writer, 0x00) # Packet ID await writer.drain() # Prepare Status Response status = { "version": { "name": "1.20.4", # Replace with your supported version "protocol": 762 }, "players": { "max": 20, "online": 0, "sample": [] }, "description": { "text": "My Awesome Minecraft Server" } } status_json = json.dumps(status) status_bytes = status_json.encode('utf-8') packet_length = len(status_bytes) + 1 # +1 for the packet ID # Send Response await write_varint(writer, packet_length) await write_varint(writer, 0x00) # Packet ID writer.write(status_bytes) await writer.drain() ``` **4. `src/mcp_server/player.py`** ```python class Player: def __init__(self, name: str, uuid: str): self.name = name self.uuid = uuid # Add other player-related attributes (position, health, etc.) here def __repr__(self): return f"Player(name='{self.name}', uuid='{self.uuid}')" ``` **5. `src/main.py` (Entry Point)** ```python import asyncio import logging from mcp_server.server import MinecraftServer async def main(): logging.basicConfig(level=logging.INFO) # Configure basic logging server = MinecraftServer("127.0.0.1", 25565) await server.start() if __name__ == "__main__": asyncio.run(main()) ``` **Key Considerations and Next Steps:** * **Minecraft Protocol Documentation:** The *most important* resource is the official Minecraft protocol documentation. It's complex, but essential. Search for "Minecraft Protocol Documentation" to find up-to-date resources. The wiki.vg site is a good starting point. * **Asynchronous Programming (asyncio):** This template uses `asyncio` for handling multiple client connections concurrently. Make sure you understand how `async`, `await`, `asyncio.StreamReader`, and `asyncio.StreamWriter` work. * **Packet Serialization/Deserialization:** This is a critical part. You'll need to precisely pack and unpack data according to the Minecraft protocol. Libraries like `struct` (built-in) and `construct` (more powerful, but requires installation) are helpful. `construct` is often preferred for complex binary formats. * **VarInt/VarLong:** Minecraft uses variable-length integers (VarInt and VarLong) to efficiently encode numbers. Implement functions to read and write these. The example `handshake.py` shows how to read a VarInt. * **Error Handling:** Robust error handling is crucial. Use `try...except` blocks to catch exceptions and prevent the server from crashing. Log errors appropriately. * **Logging:** Use the `logging` module to record server events, errors, and debugging information. * **Configuration:** Use a configuration file (e.g., `config.py` or a `.toml` file) to store server settings (port, MOTD, max players, etc.). * **World Generation:** Implement a world generator to create the game world. This can be simple (flat world) or complex (using algorithms like Perlin noise). * **Game Logic:** This is where you implement the actual gameplay: player movement, block placement, chat, entities, etc. * **Security:** Consider security aspects, such as preventing exploits and protecting against denial-of-service attacks. * **Testing:** Write unit tests to verify the correctness of your code, especially packet handling and game logic. * **Libraries:** * **`struct`:** Built-in for packing and unpacking binary data. * **`construct`:** A more powerful library for defining binary data structures. Install with `pdm add construct`. * **`PyCryptodome`:** For encryption (if you implement online mode authentication). Install with `pdm add pycryptodome`. * **`nbt`:** For reading and writing NBT data (used for storing world data). Install with `pdm add nbt`. **How to Use This Template:** 1. **Install PDM:** `pip install pdm` 2. **Create the Project:** `pdm init` (Follow the prompts to create a new project.) 3. **Replace `pyproject.toml`:** Copy the contents of the `pyproject.toml` example above into your project's `pyproject.toml` file. 4. **Create the Directory Structure:** Create the `src`, `tests`, and other directories as shown in the project structure. 5. **Create the Files:** Create the Python files (`server.py`, `handshake.py`, etc.) and copy the example code into them. 6. **Install Dependencies:** `pdm install` (This will install the development dependencies.) 7. **Run the Server:** `pdm run start` (This will execute the `start` script defined in `pyproject.toml`, which runs `src/main.py`.) 8. **Start Developing:** Begin implementing the Minecraft protocol and game logic. This template provides a solid foundation for building your MCP server. Remember to consult the Minecraft protocol documentation and break down the project into smaller, manageable tasks. Good luck!

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.