MCP Servers

Discover Awesome MCP Servers

Extend your agent with 17,206 capabilities via MCP servers.

All17,206

Inbox Zero AI MCP

一个 MCP 可以帮助你管理你的电子邮件。例如，它可以识别哪些邮件需要回复或跟进。它提供的功能超越了基本的 Gmail 功能。

Raygun MCP Server

镜子 (jìng zi)

Moneybird MCP Server

一个模型上下文协议服务器，可以将 Claude 等 AI 助手连接到 Moneybird 会计软件，从而可以通过自然语言管理联系人、财务数据、产品和业务运营。

Prajwalnayak7_mcp Server Redis

镜子 (jìng zi)

first-mcp-server

Sequential Thinking MCP Server

一个 MCP 服务器，它通过构建思维过程并自动将每个会话记录到 Recall，从而实现动态的、反思性的问题解决。

StrongApps_MCPE_servers

镜子 (jìng zi)

Multichain MCP Server 🌐

一个连接所有 MCP 服务器的 MCP 服务器路由中心 (Yī gè liánjiē suǒyǒu MCP fúwùqì de MCP fúwùqì lùyóu zhōngxīn)

JetBrains MCP Proxy Server

服务器代理来自客户端到 JetBrains IDE 的请求。

claude_mcp

Okay, here's a breakdown of different methods and libraries you can use to create MCP (Minecraft Protocol) servers in Python, along with explanations and considerations: **Understanding the Minecraft Protocol (MCP)** Before diving into the code, it's crucial to understand that the Minecraft Protocol is a complex, binary protocol used for communication between Minecraft clients and servers. It involves: * **Handshaking:** The initial connection and negotiation of protocol versions. * **Authentication:** Verifying the player's identity (usually through Mojang's authentication servers). * **Data Packets:** Structured binary data representing various game events, player actions, world data, etc. These packets have specific formats and IDs. * **Compression:** Optional compression to reduce bandwidth usage. * **Encryption:** Optional encryption to secure the connection. **Libraries and Approaches** Here are several approaches, ranging from low-level to higher-level libraries: **1. Raw Socket Programming (Low-Level)** * **Concept:** You directly use Python's `socket` module to listen for connections, receive data, and send data. You're responsible for *everything* – parsing the binary protocol, handling authentication, and implementing game logic. * **Pros:** Maximum control and flexibility. You can optimize for specific needs. * **Cons:** Extremely complex and time-consuming. Requires a deep understanding of the Minecraft Protocol. Error-prone. Not recommended unless you have very specific requirements and a lot of time. * **Example (Very Basic - Just Listening):** ```python import socket HOST = '0.0.0.0' # Listen on all interfaces PORT = 25565 # Default Minecraft port with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break print(f"Received: {data}") # You would need to parse 'data' according to the MCP # and send appropriate responses. conn.sendall(b"Hello, client!") # Example response ``` * **Key Considerations:** * **Binary Data:** You'll be working with `bytes` objects, not strings. Use `struct` module for packing and unpacking binary data. * **VarInts/VarLongs:** The Minecraft Protocol uses variable-length integers. You'll need to implement functions to read and write these. * **Packet IDs:** Each packet has a unique ID that identifies its type. You need to know these IDs and the corresponding data structures. * **State Management:** Keep track of the connection state (handshaking, status, login, play). **2. `mcproto` Library (Mid-Level)** * **Concept:** `mcproto` is a Python library that provides a more structured way to interact with the Minecraft Protocol. It handles some of the low-level details like packet parsing and VarInts, but you still need to implement much of the server logic. * **Pros:** Reduces the complexity compared to raw sockets. Provides a more object-oriented interface. * **Cons:** Still requires a good understanding of the Minecraft Protocol. May not be as actively maintained as some other libraries. * **Example (Conceptual - Requires `mcproto` installation):** ```python # This is a simplified example and requires more code to be functional. # Install: pip install mcproto from mcproto import server async def handle_client(client): print(f"Client connected: {client.address}") try: await client.handshake() await client.status_response({ "version": {"name": "My Server", "protocol": 754}, "players": {"max": 10, "online": 0}, "description": {"text": "A Python Minecraft Server"} }) await client.login() print(f"Player {client.username} logged in.") # Main game loop (send/receive packets) while True: packet = await client.read_packet() print(f"Received packet: {packet.id}") # Process the packet based on its ID and data # Example: If it's a chat message, broadcast it to other players. except Exception as e: print(f"Error: {e}") finally: print(f"Client disconnected: {client.address}") async def main(): server_instance = server.Server("0.0.0.0", 25565) server_instance.start(handle_client) await server_instance.wait_for_close() if __name__ == "__main__": import asyncio asyncio.run(main()) ``` * **Key Considerations:** * **Asynchronous Programming:** `mcproto` often uses `asyncio`, so you'll need to be familiar with asynchronous programming concepts. * **Packet Handling:** You'll need to write code to handle different packet types and respond appropriately. * **Game Logic:** You're responsible for implementing the core game mechanics. **3. Higher-Level Frameworks (e.g., AIOgramine - Less Common)** * **Concept:** Some frameworks aim to provide a more complete abstraction over the Minecraft Protocol, handling more of the low-level details and providing higher-level APIs for managing players, worlds, and game events. These are less common and may be less actively maintained. AIOgramine was one such project, but its current status is uncertain. * **Pros:** Potentially faster development. More features out of the box. * **Cons:** Less flexibility. May be harder to customize. Reliance on the framework's design decisions. May be outdated. * **Example:** (Illustrative - AIOgramine may not be fully functional) ```python # This is a conceptual example and may not work directly. # It's based on how AIOgramine *might* have worked. # import aiogramine # server = aiogramine.Server("0.0.0.0", 25565) # @server.event # async def on_player_join(player): # print(f"{player.username} joined the server.") # player.send_message("Welcome to the server!") # @server.command("say") # async def say_command(player, message): # server.broadcast(f"<{player.username}> {message}") # server.start() ``` * **Key Considerations:** * **Framework Maturity:** Check the framework's documentation, community support, and recent activity. * **Customization:** Evaluate how easily you can extend or modify the framework to meet your specific needs. **4. Using Existing Server Implementations (Proxy/Plugin)** * **Concept:** Instead of building a server from scratch, you can use an existing Minecraft server implementation (like Spigot, Paper, or Bungeecord) and write a plugin or proxy that interacts with it. This is often the most practical approach for many use cases. * **Pros:** Leverages the existing server infrastructure. Easier to develop specific features or modifications. * **Cons:** Limited control over the core server behavior. Requires knowledge of the server's plugin API. * **Example (Conceptual - Requires a Spigot/Paper server):** ```python # This is a conceptual example of a Spigot plugin using a Python bridge. # It requires a Spigot/Paper server with a plugin that allows Python scripting. # (In your Spigot plugin's Python script): # def on_player_join(event): # player = event.getPlayer() # player.sendMessage("Hello from Python!") # def on_chat_message(event): # player = event.getPlayer() # message = event.getMessage() # print(f"{player.getName()} said: {message}") # # Example: Censor bad words # if "badword" in message.lower(): # event.setCancelled(True) # player.sendMessage("Please don't use that word.") ``` * **Key Considerations:** * **Server API:** Learn the API provided by the server platform (e.g., Spigot API, Bungeecord API). * **Plugin Development:** Understand how to create and deploy plugins for the server. * **Performance:** Be mindful of the performance impact of your plugin code. **Which Approach to Choose?** * **Simple Status Server:** If you just want to provide a server status (MOTD, player count), `mcproto` might be sufficient. * **Custom Game Logic:** If you need to implement complex game mechanics, consider using an existing server implementation and writing a plugin. * **Learning Exercise:** If you want to learn the Minecraft Protocol in detail, start with raw sockets, but be prepared for a significant time investment. * **Proxy Server:** If you want to intercept and modify traffic between clients and a real server, you might need to use raw sockets or a library like `mcproto` to handle the protocol. **Important Notes:** * **Minecraft Protocol Versions:** The Minecraft Protocol changes with each Minecraft version. Make sure your code is compatible with the version you're targeting. Libraries like `mcproto` often have support for specific versions. * **Authentication:** Handling authentication correctly is crucial. You'll need to interact with Mojang's authentication servers. Be aware of rate limits and security best practices. * **Security:** Be very careful about security vulnerabilities. Improperly handling data can lead to exploits. * **Performance:** Minecraft servers can be resource-intensive. Optimize your code for performance, especially if you're handling a large number of players. **In summary:** Building a Minecraft server from scratch in Python is a challenging task. Using existing server implementations and writing plugins is often the most practical approach for many use cases. If you need more control or want to learn the protocol in detail, `mcproto` is a good starting point, but be prepared for a significant amount of work. Raw sockets are only recommended for very specific and advanced scenarios. Remember to always prioritize security and performance.

Awesome MCP Servers

很棒的 MCP 服务器 - 一个精选的模型上下文协议服务器列表

Android Studio AI Chat Integration

Modular MCP Server

Sanity MCP server

理智MCP服务器 (Lǐzhì MCP fúwùqì)

mcp-server

用于实验 LLM 工具的 MCP 服务器 (Yòng yú shíyàn LLM gōngjù de MCP fúwùqì) Alternatively, you could also say: 用于 LLM 工具实验的 MCP 服务器 (Yòng yú LLM gōngjù shíyàn de MCP fúwùqì) Both translations are accurate and convey the same meaning. The first one is slightly more verbose, while the second is more concise.