Discover Awesome MCP Servers

Dockerized MCP Server Template

Una plantilla reutilizable de servidor Python en Docker que implementa el Protocolo de Contexto de Modelo (MCP) con Eventos Enviados por el Servidor (SSE), construida utilizando la biblioteca FastMCP para una fácil integración con Modelos de Lenguaje Grandes (LLMs).

mc-server-clash-of-clans

Servidor MCP para la API de Clash of Clans. Puede obtener información de jugadores y clanes, analizar guerras en curso, así como registros de guerra (siempre y cuando sean públicos).

UseScraper

Un servidor MCP basado en TypeScript que utiliza la API UseScraper para proporcionar capacidades de web scraping, permitiendo a los usuarios extraer contenido de páginas web en varios formatos.

Google Meet MCP Server

El servidor MCP de Google Meet permite a los agentes de IA crear, gestionar y recuperar reuniones de Google Meet. Construido sobre el Protocolo de Contexto de Modelo, expone herramientas para programar, actualizar y eliminar reuniones, facilitando la integración de las funcionalidades de Google Meet.

Polar Signals Remote MCP

MCP server for Polar Signals Cloud continuous profiling platform, enabling AI assistants to analyze CPU performance, memory usage, and identify optimization opportunities in production systems.

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!

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.

MCP Greetings Server

Enables AI assistants to greet users in 7 different languages including English, Spanish, French, German, Japanese, Chinese, and Korean. A lightweight multilingual greeting tool for the Model Context Protocol.

nft-analytics-mcp

An MCP server that delivers NFT collection analytics powered by data from Dune Analytics.

MCP Template Server

A Python starter template for building MCP servers with client connection management and Jupyter notebook integration. Provides a structured foundation for adding custom tools, prompts, and workflows to create AI-powered applications.

MCPatterns

An MCP server that enables users to store and retrieve personalized coding patterns, serving as a persistent memory layer for LLM agents. It allows AI models to generate code and refactor projects according to a user's specific styles, technologies, and established development conventions.

EEA GeoNetwork MCP Server

Enables interaction with the European Environment Agency (EEA) GeoNetwork Catalogue API to search, manage, and edit geographic metadata records. It supports advanced spatial searches, metadata exports in multiple formats, and authenticated updates to records and their attachments.

Tiny Chat

This is an LLM application with chat functionality, featuring chat using RAG, a database, and MCP server capabilities. The UI is designed for Japanese users.

Unichat

Okay, I understand. I can translate English text to Spanish for you. Please provide the English text you would like me to translate. I will use my capabilities to provide the best possible translation.

ComfyUI MCP Server

Bridges ComfyUI's AI image generation workflows with game development, enabling dynamic generation of game assets like character portraits, item icons, and environment textures through natural language prompts.

duckduckgo-mcp

Search the web using DuckDuckGo and fetch/convert web content using Jina Reader. Privacy-focused search with no API key required.

ExpressJS MCP

Exposes Express.js API endpoints as MCP tools, preserving existing schemas and authentication behavior. Supports streaming responses and can be mounted directly to existing Express apps or run as a standalone gateway.

AWS Nova Canvas MCP Server

Un servidor MCP que te permite generar y editar imágenes utilizando el modelo Nova Canvas de Amazon Bedrock, con soporte para funciones como generación de texto a imagen, "inpainting" (relleno generativo), "outpainting" (extensión generativa), variación de imagen y eliminación de fondo.

Spurs Blog Mcp Server

Un servidor MCP para el blog Pounding The Rock, que ofrece una cobertura exhaustiva de los San Antonio Spurs.

MCP Healthcare System

A production-grade MCP server that enables AI assistants to securely manage healthcare data through clinical tools for patient vitals, lab results, and medication ordering. It prioritizes security and compliance with features like HIPAA-ready audit logging, PII redaction, and role-based access control.

SAP Business One MCP Server

Enables interaction with SAP Business One API through Azure Container Apps with VNet connectivity. Provides secure access to SAP data and operations through natural language interface.

Qiita API MCP Server

Enables interaction with Qiita, a Japanese developer community platform, through its API v2. Supports comprehensive operations including article management, user interactions, tag following, and commenting with Japanese language support.

Web3 Assistant MCP

Enables secure interaction with blockchain smart contracts across multiple chains, including ABI analysis, contract method invocation (view/nonpayable/payable), and local wallet management for Ethereum and Base networks.

mcp-server-cve-knowledge-base

Servidor MCP que proporciona una base de conocimientos en tiempo real para CVE.

MCP Jibun Server

Enables AI agents to read and retrieve the latest posts from Jibun and Ech0 instances. It allows users to list configured sources and fetch content with support for pagination and source selection.

🔗 Unified MCP Tool Graph: A Neo4j-Powered API Intelligence Layer for Dynamic Tool Retrieval

En lugar de volcar más de 100 herramientas en el prompt de un modelo y esperar que elija sabiamente, el Gráfico de Herramientas MCP Unificado equipa a tu LLM con estructura, claridad y relevancia. Soluciona la confusión de herramientas, previene bucles infinitos y permite flujos de trabajo de agentes modulares e inteligentes.

Web-QA

An AI-powered MCP server that automates web testing workflows by enabling recording, execution, and discovery of tests through natural language prompts.

Enkrypt AI MCP Server

Espejo de

REAPER MCP Server

A Model Context Protocol server that exposes REAPER digital audio workstation functionality through a clean API interface, enabling programmatic control of 169+ REAPER operations across track management, MIDI editing, effects, automation and more.