MCP Servers

Discover Awesome MCP Servers

Extend your agent with 14,392 capabilities via MCP servers.

All14,392

mysqldb-mcp-server MCP server

一个 MCP 服务器，可以实现 MySQL 数据库与 Claude 的集成。你可以执行 SQL 查询并管理数据库连接。

Tauri + React + Typescript

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

Inbox Zero AI MCP

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

Raygun MCP Server

镜子 (jìng zi)

Moneybird MCP Server

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

Introduction

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

ExMCP Test ServerExMCP Test Server Summary

好的，这是将 "Test implementation of mcp server in Elixir" 翻译成中文的几种选择，根据不同的语境和侧重点，可以选择最合适的： **1. 比较直接的翻译：** * **Elixir 中 MCP 服务器的测试实现** (Elixir zhōng MCP fúwùqì de cèshì shíxiàn) - 这个翻译比较直白，适合技术文档或者需要精确表达的场合。 **2. 更自然的翻译：** * **在 Elixir 中测试 MCP 服务器的实现** (Zài Elixir zhōng cèshì MCP fúwùqì de shíxiàn) - 强调测试的动作。 **3. 更加口语化的翻译：** * **用 Elixir 实现 MCP 服务器并进行测试** (Yòng Elixir shíxiàn MCP fúwùqì bìng jìnxíng cèshì) - 更加强调实现和测试两个步骤。 **4. 如果上下文已经明确是关于实现，可以简化为：** * **Elixir MCP 服务器的测试** (Elixir MCP fúwùqì de cèshì) - 如果读者已经知道是在讨论实现，可以省略 "实现" 二字。 **选择哪个翻译取决于具体的语境。** 例如，如果是在讨论代码实现细节，第一个或第二个翻译可能更合适。如果是在讨论项目计划，第三个翻译可能更合适。如果上下文已经很明确，第四个翻译可能就足够了。

Apple MCP Server

OpenAI Speech-to-Text transcriptions MCP Server

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

MCP Client & Server Example

Frappe MCP Server

一个实现了 Anthropic 模型控制协议 (MCP) 服务器，用于访问 Frappe 的服务器。

GitHub Actions MCP Server

一个 MCP 服务器，它通过 GitHub API 提供列出、查看、触发、取消和重新运行工作流的工具，从而使 AI 助手能够管理 GitHub Actions 工作流。

mcp-server-pdfme

Awesome MCP Servers

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

Android Studio AI Chat Integration

Prem MCP Server

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

gemini-mcp-server

一个 TypeScript 服务器，通过模型上下文协议将 Google 的 Gemini Pro 模型与 Claude Desktop 集成，从而允许 Claude 用户访问 Gemini 的文本生成能力。

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.