Discover Awesome MCP Servers

Awesome MCPs

Uma coleção incrível de ferramentas do Protocolo de Contexto de Modelo (MCP).

OpenRouter Web Search MCP Server

Um servidor MCP que fornece pesquisa na web usando openrouter :online

Agentic MCP Client

Um executor de agente autônomo que executa tarefas usando ferramentas MCP (Model Context Protocol) através das APIs Anthropic Claude, AWS BedRock e OpenAI. Ele permite que agentes de IA operem autonomamente em ambientes de nuvem e interajam com vários sistemas de forma segura.

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.

MS Access MCP Explorer

Servidor MCP para bancos de dados Microsoft Access

simple-mcp-server

Um servidor meteorológico MCP simples escrito em TypeScript.

Lingshu FastMCP Medical AI Service

Enables medical image analysis, structured medical report generation, and medical Q\&A through the Lingshu medical AI model. Provides healthcare professionals and developers with AI-powered medical assistance capabilities via a FastMCP server interface.

Python Codebase Analysis RAG System

An MCP server that analyzes Python codebases using AST, stores code elements in a vector database, and enables natural language queries about code structure and functionality using RAG with Google's Gemini models.

LinkedIn Scraper MCP Server

Enables extraction of comprehensive LinkedIn profile data including experience, education, skills, and contact information through browser automation. Requires manual LinkedIn credentials input and uses anti-detection measures for reliable scraping.

n8n MCP Server

Enables creation, management, and execution of n8n workflows through a secure HTTP API. Provides tools to build workflows with schema validation, activate/deactivate them, and execute automation tasks programmatically.

Vercel AI SDK Documentation MCP Agent

Um servidor de Protocolo de Contexto de Modelo (MCP) que fornece recursos de pesquisa e consulta com tecnologia de IA para a documentação do Vercel AI SDK. Este projeto permite que desenvolvedores façam perguntas sobre o Vercel AI SDK e recebam respostas precisas e contextualizadas com base na documentação oficial.

Qweather Mcp Server

API de Clima He Feng Serviço MCP (para fins de prática)

Nano Currency MCP Server

Send Nano currency from AI agents/LLMs

MCP Database Server

Espelho de

Epicor Kinetic MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Epicor Kinetic (beta): https://www.cdata.com/download/download.aspx?sku=UEZK-V&type=beta

MLX Whisper MCP Server

Local MCP server for MLX Whisper transcription

Unifi MCP Server

Um servidor MCP para interagir com redes Unifi.

Linkup Search

I understand you're asking me to translate the following English text into Portuguese: "Give Claude access to real-time knowledge and premium content. Get rid of Claude's cutoff data and transform Claude's responses with current events, and trusted, premium sources through Linkup's powerful search capability." Here's the translation: "Dê ao Claude acesso a conhecimento em tempo real e conteúdo premium. Elimine os dados desatualizados do Claude e transforme as respostas do Claude com eventos atuais e fontes premium confiáveis, através da poderosa capacidade de busca do Linkup."

NodeJS API Docs MCP Server

An MCP Server for Node.js API documentation

npm-run-mcp-server

Exposes your project's package.json scripts as MCP tools, allowing AI assistants to discover and execute npm/yarn/pnpm/bun scripts directly. Automatically detects your package manager and enables running scripts with optional arguments through natural language commands.

MCP Math Gmail Client

Um agente com um servidor MCP resolve uma tarefa matemática e envia o resultado por e-mail.

hyper-mcp

A configurable MCP server wrapper for Cursor that eliminates tool count limits when using the Model Context Protocol.

OmniMCP

Um servidor que fornece contexto rico de interface do usuário e capacidades de interação para modelos de IA, permitindo uma compreensão profunda das interfaces do usuário por meio de análise visual e interação precisa via Protocolo de Contexto do Modelo.

Korea Stock Analyzer MCP Server

Provides comprehensive Korean stock market analysis using investment strategies from 6 legendary investors including Warren Buffett and Peter Lynch. Offers real-time KOSPI/KOSDAQ data, technical indicators, DCF valuations, and buy/hold/sell recommendations through natural language queries.