Discover Awesome MCP Servers

Tauri + React + Typescript

一个使用 Tauri 实现的 MCP 天气服务器和客户端应用

Moneybird MCP Server

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

Introduction

提供 MCP（模型控制协议）工具，用于通过 OAuth2 身份验证访问 Google Chat 空间和消息并与之交互。

MCP API Server

MCP 服务器 (MCP fúwùqì)

cognee-mcp-server

镜子 (jìng zi)

CockroachDB MCP Server

镜子 (jìng zi)

Jira MCP Server

JIRA 的 MCP 服务器

MCP Sample

使用 Claude Desktop 和 MCP 服务器集成创建的测试存储库。

Mindmap MCP Server

一个模型上下文协议服务器，可以将 Markdown 内容转换为交互式思维导图，从而允许 AI 助手通过 HTML 内容或保存的文件来可视化分层信息。 (Alternatively, a slightly more literal translation:) 一个模型上下文协议服务器，可以将 Markdown 内容转换成交互式的思维导图，允许 AI 助手通过 HTML 内容或保存的文件来可视化层级信息。

MCP Server for Paper Analytical Devices (PAD)

用于纸质分析设备 (PAD) 的 Python MCP 服务器

Prajwalnayak7_mcp Server Redis

镜子 (jìng zi)

Structured Thinking MCP Server

一个 TypeScript 模型上下文协议 (MCP) 服务器，允许 LLM 以编程方式构建思维导图，以探索一个想法空间，并强制执行“元认知”的自我反思。

mcp-server-unitycatalog: An Unity Catalog MCP server

一个模型上下文协议（Model Context Protocol）服务器，提供对 Unity Catalog 函数的访问，允许 AI 助手通过一个标准化的接口直接在 Unity Catalog 中列出、获取、创建和删除函数。

ESP32 MCP Server

允许AI模型连接到ESP32暴露的接口。为ESP32生成AI驱动的MCP服务器。 (Alternative, more literal translation:) 允许人工智能模型连接到ESP32暴露的接口。用于ESP32的AI生成MCP服务器。

WildFly MCP

一个 WildFly MCP 服务器，用于与您的 AI 聊天机器人（例如 claude.ai）集成。

ExploitDB MCP Server

一个模型上下文协议服务器，使 AI 助手能够从漏洞利用数据库中搜索和检索有关安全漏洞和弱点的信息，从而增强网络安全研究能力。

Sanity MCP server

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

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.

Tinypng Mcp Server

使用 MCP 通过 TinyPNG

Notion MCP Server

一个允许在 Notion MCP 中使用块、切换和其他功能的服务器。

MCP API Connect

允许 MCP 发起 REST API 调用的 MCP 服务器

OpenAI Speech-to-Text transcriptions MCP Server

一个 MCP 服务器，可以使用 OpenAI 的语音转文本 API 来转录音频文件，并支持多种语言和文件保存选项。 (Alternatively, a slightly more formal translation:) 一个 MCP 服务器，它能够利用 OpenAI 的语音转文本 API 实现音频文件的转录，并支持多种语言和文件保存选项。

Awesome MCP Servers

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

Prem MCP Server

一个模型上下文协议（Model Context Protocol, MCP）服务器的实现，它能够与 Claude 和其他兼容 MCP 的客户端无缝集成，从而访问 Prem AI 的语言模型、检索增强生成（Retrieval-Augmented Generation, RAG）能力以及文档管理功能。