MCP Servers

Discover Awesome MCP Servers

Extend your agent with 16,059 capabilities via MCP servers.

All16,059

GenAIScript MCP Demo 🚀

GenAIScript 的 MCP 服务器功能演示

spring-mcp-server-sample

MCP服务器示例 (MCP fúwùqì shìlì)

mcp-changtianML

MCP 服务器访问 ChangtianML

XACHE - Crypto Trader Website

鹅雁 AI 与 MCP 服务器

Filesystem MCP Server

镜子 (jìng zi)

Bear MCP Server

镜子 (jìng zi)

NYT MCP Server

一个消息集中协议 (MCP) 服务器，它为纽约时报 API 提供一个统一、简单的接口。该服务器通过一个单一的端点简化了与多个 NYT API 的交互。

Postgers_MCP_for_AWS_RDS

这是一个用于访问 AWS RDS 上的 PostgreSQL 数据库的 MCP 服务器。

Hello, MCP server.

一个基础的 MCP 服务器 (Yī gè jīchǔ de MCP fúwùqì)

mcp-edge-search

一个模型上下文协议（Model Context Protocol，MCP）服务器，为像 Claude Desktop 这样的 MCP 客户端提供网络搜索功能。

Mcp Server Python

cursor_agents

Okay, here are a few ways you could use an MCP (presumably referring to a Media Control Platform or similar system) server to add a team of experts into an agent flow, along with explanations and considerations: **Understanding the Goal** First, let's clarify what "adding a team of experts into the agent flow" means. This likely involves: * **Routing:** Directing specific types of customer interactions (calls, chats, emails) to the appropriate expert(s). * **Escalation:** Transferring an interaction from a general agent to an expert when the agent needs assistance. * **Collaboration:** Allowing agents to consult with experts in real-time (e.g., via chat, conference call) without transferring the customer. * **Knowledge Sharing:** Providing agents with access to expert knowledge bases or documentation. **Methods Using an MCP Server** Here are some common approaches, assuming your MCP server has capabilities like routing, presence management, and integration with other systems: **1. Skill-Based Routing (Most Common)** * **Concept:** Configure the MCP server to route interactions based on the skills required to handle them. The "experts" are defined as having specific skills. * **Implementation:** * **Skill Definition:** Define skills in the MCP server (e.g., "Product A Expert," "Technical Support - Level 2," "Spanish Language"). * **Expert Skill Assignment:** Assign the appropriate skills to each expert agent in the MCP system. * **Routing Rules:** Create routing rules that direct interactions with specific requirements (e.g., "Product A" inquiries) to agents with the "Product A Expert" skill. This often involves analyzing the customer's input (e.g., IVR selections, chat keywords, email subject) to determine the required skills. * **Queue Management:** The MCP server manages queues for each skill. If no experts are immediately available, the interaction is placed in the appropriate queue. * **Advantages:** Efficiently routes interactions to the right experts. Scalable as the team of experts grows. * **Considerations:** Requires accurate skill definition and assignment. Needs a mechanism to determine the required skills for each interaction (e.g., IVR, AI-powered intent analysis). **2. Presence-Based Routing** * **Concept:** Route interactions to experts based on their availability (presence status). * **Implementation:** * **Presence Integration:** The MCP server integrates with the expert's communication tools (e.g., softphone, chat client) to track their presence (available, busy, away, etc.). * **Routing Rules:** Create routing rules that only send interactions to experts who are currently available. * **Overflow Handling:** Define what happens if no experts are available (e.g., send to a general queue, offer a callback). * **Advantages:** Avoids sending interactions to unavailable experts. Improves customer experience. * **Considerations:** Requires reliable presence information. Needs a strategy for handling overflow situations. **3. Escalation/Transfer Functionality** * **Concept:** Allow general agents to transfer interactions to experts when they need assistance. * **Implementation:** * **Transfer Options:** Provide agents with a way to easily transfer interactions to specific experts or to a queue of experts. This might be a button in their agent desktop application. * **Warm Transfer vs. Cold Transfer:** Decide whether the agent should introduce the customer to the expert (warm transfer) or simply transfer the interaction without introduction (cold transfer). * **Context Transfer:** Ensure that relevant information about the interaction (e.g., customer history, previous interactions) is transferred along with the interaction. * **Advantages:** Allows agents to handle a wider range of issues. Provides access to expert knowledge when needed. * **Considerations:** Requires a user-friendly transfer interface. Needs a mechanism to ensure that context is transferred. **4. Collaboration Tools (Consultation)** * **Concept:** Enable agents to consult with experts in real-time without transferring the customer. * **Implementation:** * **Chat Integration:** Integrate a chat system into the agent desktop application that allows agents to communicate with experts. * **Conference Calling:** Allow agents to add experts to a conference call with the customer. * **Screen Sharing:** Enable agents to share their screen with experts for assistance. * **Advantages:** Allows agents to resolve complex issues quickly. Reduces the need for transfers. * **Considerations:** Requires a reliable communication platform. Needs a mechanism to manage expert availability. **5. Knowledge Base Integration** * **Concept:** Provide agents with access to a knowledge base that contains expert knowledge. * **Implementation:** * **Knowledge Base Platform:** Use a knowledge base platform to store and organize expert knowledge. * **Integration with Agent Desktop:** Integrate the knowledge base into the agent desktop application so that agents can easily search for information. * **AI-Powered Search:** Use AI to improve the accuracy and relevance of search results. * **Advantages:** Empowers agents to resolve issues independently. Reduces the need to consult with experts. * **Considerations:** Requires a well-maintained knowledge base. Needs a mechanism to ensure that the knowledge is accurate and up-to-date. **Example Scenario (Skill-Based Routing)** Let's say you have a team of experts who specialize in different products (Product A, Product B, Product C). 1. **Define Skills:** In your MCP server, define skills: "Product A Expert," "Product B Expert," "Product C Expert." 2. **Assign Skills:** Assign the appropriate skills to each expert agent. For example, Agent John might have the "Product A Expert" skill. 3. **Configure IVR:** In your IVR (Interactive Voice Response) system, ask the customer which product they need help with. 4. **Routing Rule:** Create a routing rule in the MCP server that says: "If the customer selects 'Product A' in the IVR, route the call to an agent with the 'Product A Expert' skill." 5. **Queue Management:** If no "Product A Expert" agents are available, the call is placed in a "Product A Expert" queue. **Chinese Translation of Key Terms** Here are some translations of key terms that might be helpful when discussing this with Chinese-speaking colleagues: * **MCP Server:** 媒体控制平台服务器 (Méitǐ Kòngzhì Píngtái Fúwùqì) * **Agent Flow:** 代理流程 (Dàilǐ Liúchéng) * **Team of Experts:** 专家团队 (Zhuānjiā Tuánduì) * **Skill-Based Routing:** 基于技能的路由 (Jīyú Jìnéng de Lùyóu) * **Presence-Based Routing:** 基于状态的路由 (Jīyú Zhuàngtài de Lùyóu) * **Escalation:** 升级 (Shēngjí) * **Transfer:** 转接 (Zhuǎnjiē) * **Collaboration:** 协作 (Xiézuò) * **Knowledge Base:** 知识库 (Zhīshì Kù) * **IVR (Interactive Voice Response):** 交互式语音应答 (Jiāohùshì Yǔyīn Yìngdá) * **Queue:** 队列 (Duìliè) * **Routing Rules:** 路由规则 (Lùyóu Guīzé) * **Agent Desktop:** 代理桌面 (Dàilǐ Zhuōmiàn) **Important Considerations** * **MCP Server Capabilities:** The specific features and capabilities of your MCP server will determine which methods are possible. Consult your MCP server documentation or vendor for details. * **Integration:** Integration with other systems (e.g., IVR, CRM, knowledge base) is crucial for many of these methods. * **Agent Training:** Ensure that agents are properly trained on how to use the new features and processes. * **Monitoring and Optimization:** Monitor the performance of the system and make adjustments as needed to optimize routing and efficiency. To give you more specific advice, please provide more details about your MCP server and the specific requirements of your agent flow. For example: * What is the name of your MCP server? * What features does it support (e.g., skill-based routing, presence management, API integration)? * What type of interactions are you handling (e.g., calls, chats, emails)? * What are the specific skills of your experts?

Prometheus Alertmanager MCP Server

一个与 Prometheus Alertmanager 集成的模型上下文协议 (MCP) 服务器。 (Yī gè yǔ Prometheus Alertmanager jíchéng de móxíng shàngxiàwén xiéyì (MCP) fúwùqì.)

Modes MCP Server

镜子 (jìng zi)

Symbol MCP Server (REST API tools)

MCP 服务器符号。（REST API 工具）

MCP LLM Bridge

一个简单的从 Ollama 到 fetch url mcp 服务器的桥梁。 (Yī gè jiǎndān de cóng Ollama dào fetch url mcp fúwùqì de qiáoliáng.)

SQLGenius - AI-Powered SQL Assistant

SQLGenius 是一款由 AI 驱动的 SQL 助手，它使用 Vertex AI 的 Gemini Pro 将自然语言转换为 SQL 查询。它基于 MCP 和 Streamlit 构建，提供了一个直观的界面，用于 BigQuery 数据探索，并具有实时可视化和模式管理功能。

Structured Thinking

一个统一的 MCP 服务器，用于结构化思维工具，包括模板思维和验证思维。 (Alternatively, depending on the specific context and target audience, you could also say:) 一个整合的 MCP 服务器，提供结构化思维工具，例如模板思维和验证思维。

Thirdweb Mcp

Weather MCP Server

Okay, here's an example of a simple weather MCP (Minecraft Protocol) server in Python. This is a very basic example and doesn't implement the full Minecraft protocol. It focuses on sending a custom packet to a client that's expecting weather information. **Important Considerations:** * **MCP (Minecraft Protocol) Complexity:** The actual Minecraft protocol is quite complex. This example simplifies things significantly. A real-world server would need to handle authentication, world data, player movement, and much more. * **Client-Side Mod:** This server *requires* a client-side mod (or a modified client) that knows how to interpret the custom weather packet this server sends. The standard Minecraft client won't understand it. * **Python Libraries:** This example uses the `socket` library for basic network communication and `struct` for packing data into binary format. ```python import socket import struct import time # Configuration HOST = '127.0.0.1' # Listen on localhost PORT = 25565 # Use a port (not the default Minecraft port unless you know what you're doing) WEATHER_UPDATE_INTERVAL = 5 # Seconds between weather updates def create_weather_packet(temperature, humidity, rain): """ Creates a custom weather packet. Args: temperature: Temperature value (float). humidity: Humidity value (float). rain: Rain intensity (float, 0.0 - 1.0). Returns: A bytes object representing the weather packet. """ packet_id = 0x01 # Custom packet ID (must match client-side mod) # Pack the data into a binary format packet_data = struct.pack('!bff', temperature, humidity, rain) # ! = network byte order, b = byte (packet ID), f = float # Prepend the packet ID packet = struct.pack('!b', packet_id) + packet_data # Prepend the packet length packet_length = len(packet) packet = struct.pack('!i', packet_length) + packet return packet def main(): """ Main server loop. """ server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow address reuse server_socket.bind((HOST, PORT)) server_socket.listen(1) # Listen for one connection print(f"Weather MCP Server listening on {HOST}:{PORT}") conn, addr = server_socket.accept() print(f"Client connected from {addr}") try: while True: # Simulate weather data (replace with real data source) temperature = 25.5 + (time.time() % 10) - 5 # Temperature between 20.5 and 30.5 humidity = 0.6 + (time.time() % 5) / 10 # Humidity between 0.6 and 1.1 rain = 0.0 if temperature > 28 else (time.time() % 3) / 3 # Rain if temp is below 28 weather_packet = create_weather_packet(temperature, humidity, rain) try: conn.sendall(weather_packet) print(f"Sent weather update: Temp={temperature:.1f}, Humidity={humidity:.2f}, Rain={rain:.2f}") except BrokenPipeError: print("Client disconnected.") break # Exit the loop if the client disconnects time.sleep(WEATHER_UPDATE_INTERVAL) except KeyboardInterrupt: print("Server shutting down.") finally: conn.close() server_socket.close() if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports necessary libraries (`socket`, `struct`, `time`). 2. **Configuration:** Sets the host, port, and weather update interval. *Change the port if you're running a real Minecraft server on the default port (25565).* 3. **`create_weather_packet()`:** * Takes temperature, humidity, and rain intensity as input. * `packet_id = 0x01`: This is a *crucial* part. This is a custom packet ID. Your client-side mod *must* be programmed to recognize this ID and know how to interpret the data that follows. If the client doesn't know about this ID, it will likely crash or ignore the packet. * `struct.pack('!bff', ...)`: This packs the data into a binary format. * `!`: Specifies network byte order (big-endian), which is standard for network communication. * `b`: Represents a single byte (for the packet ID). * `f`: Represents a float (for temperature, humidity, and rain). * The packet length is prepended to the packet. This is important for the client to know how many bytes to read. 4. **`main()`:** * Creates a socket, binds it to the host and port, and listens for connections. * `server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)`: This allows you to quickly restart the server without waiting for the port to be released. * Accepts a connection from a client. * Enters a `while True` loop to continuously send weather updates. * **Simulates Weather Data:** The example generates random weather data. In a real application, you would get this data from a weather API or some other source. * `conn.sendall(weather_packet)`: Sends the weather packet to the client. * `time.sleep(WEATHER_UPDATE_INTERVAL)`: Waits before sending the next update. * Handles `BrokenPipeError`: This exception is raised if the client disconnects. * Handles `KeyboardInterrupt`: Allows you to gracefully shut down the server with Ctrl+C. * Closes the connection and the socket in the `finally` block. **How to Use:** 1. **Client-Side Mod:** You *must* create a client-side mod (using Forge, Fabric, or another modding framework) that: * Connects to this server on the specified host and port. * Listens for packets with the packet ID `0x01`. * Unpacks the data from the packet (using `struct.unpack('!bff', data)`) to get the temperature, humidity, and rain values. * Displays the weather information in the game or uses it to affect the game world. 2. **Run the Server:** Save the Python code as a `.py` file (e.g., `weather_server.py`) and run it from your terminal: `python weather_server.py` 3. **Run Minecraft with the Mod:** Start Minecraft with your client-side mod installed. The mod should connect to the server and start receiving weather updates. **Example Client-Side Mod (Conceptual - Forge, Simplified):** ```java // (This is a very simplified example - you'll need to adapt it to your modding framework) import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.common.event.FMLInitializationEvent; import java.net.Socket; import java.io.DataInputStream; import java.nio.ByteBuffer; @Mod(modid = "weather_mod", name = "Weather Mod", version = "1.0") public class WeatherMod { private static final String SERVER_HOST = "127.0.0.1"; private static final int SERVER_PORT = 25565; private static Socket socket; private static DataInputStream in; private float temperature = 0.0f; private float humidity = 0.0f; private float rain = 0.0f; @Mod.EventHandler public void init(FMLInitializationEvent event) { new Thread(() -> { try { socket = new Socket(SERVER_HOST, SERVER_PORT); in = new DataInputStream(socket.getInputStream()); while (true) { // Read packet length int packetLength = in.readInt(); // Read packet ID byte packetId = in.readByte(); if (packetId == 0x01) { // Read the rest of the packet data byte[] data = new byte[packetLength - 1]; in.readFully(data); ByteBuffer buffer = ByteBuffer.wrap(data); buffer.order(java.nio.ByteOrder.BIG_ENDIAN); // Network byte order temperature = buffer.getFloat(); humidity = buffer.getFloat(); rain = buffer.getFloat(); System.out.println("Received weather: Temp=" + temperature + ", Humidity=" + humidity + ", Rain=" + rain); // Update game world (e.g., change sky color, add rain particles) // This part requires more Forge-specific code } } } catch (Exception e) { e.printStackTrace(); } }).start(); } // Getter methods to access weather data from other parts of your mod public float getTemperature() { return temperature; } public float getHumidity() { return humidity; } public float getRain() { return rain; } } ``` **Important Notes about the Client Mod:** * **Threading:** The client mod uses a separate thread to connect to the server and receive data. This prevents the main game thread from blocking. * **Error Handling:** The client mod needs proper error handling (e.g., handling connection errors, invalid packet data). * **Forge/Fabric Specifics:** The example uses some basic Forge annotations. You'll need to adapt it to the specific modding framework you're using. The code to update the game world (e.g., changing sky color, adding rain particles) will be very framework-specific. * **Byte Order:** Make sure the client uses the same byte order (`java.nio.ByteOrder.BIG_ENDIAN`) as the server when unpacking the data. * **Packet Length:** The client reads the packet length first to know how many bytes to read for the rest of the packet. **Chinese Translation (Simplified):** ```chinese # 这是一个用 Python 编写的简单天气 MCP (Minecraft 协议) 服务器的例子。 # 重要注意事项： # * MCP (Minecraft 协议) 非常复杂。这个例子大大简化了。 # * 这个服务器需要一个客户端模组（或修改过的客户端），它知道如何解释这个服务器发送的自定义天气数据包。 # * 这个例子使用 socket 库进行基本的网络通信，并使用 struct 库将数据打包成二进制格式。 import socket import struct import time # 配置 HOST = '127.0.0.1' # 监听本地主机 PORT = 25565 # 使用一个端口（除非你知道自己在做什么，否则不要使用默认的 Minecraft 端口） WEATHER_UPDATE_INTERVAL = 5 # 天气更新之间的秒数 def create_weather_packet(temperature, humidity, rain): """ 创建一个自定义天气数据包。参数： temperature: 温度值 (浮点数)。 humidity: 湿度值 (浮点数)。 rain: 降雨强度 (浮点数, 0.0 - 1.0)。返回值：表示天气数据包的字节对象。 """ packet_id = 0x01 # 自定义数据包 ID（必须与客户端模组匹配） # 将数据打包成二进制格式 packet_data = struct.pack('!bff', temperature, humidity, rain) # ! = 网络字节顺序，b = 字节 (数据包 ID)，f = 浮点数 # 在前面加上数据包 ID packet = struct.pack('!b', packet_id) + packet_data # 在前面加上数据包长度 packet_length = len(packet) packet = struct.pack('!i', packet_length) + packet return packet def main(): """ 主服务器循环。 """ server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 允许地址重用 server_socket.bind((HOST, PORT)) server_socket.listen(1) # 监听一个连接 print(f"天气 MCP 服务器监听在 {HOST}:{PORT}") conn, addr = server_socket.accept() print(f"客户端从 {addr} 连接") try: while True: # 模拟天气数据（用真实数据源替换） temperature = 25.5 + (time.time() % 10) - 5 # 温度在 20.5 和 30.5 之间 humidity = 0.6 + (time.time() % 5) / 10 # 湿度在 0.6 和 1.1 之间 rain = 0.0 if temperature > 28 else (time.time() % 3) / 3 # 如果温度低于 28，则下雨 weather_packet = create_weather_packet(temperature, humidity, rain) try: conn.sendall(weather_packet) print(f"发送天气更新：温度={temperature:.1f}, 湿度={humidity:.2f}, 降雨={rain:.2f}") except BrokenPipeError: print("客户端断开连接。") break # 如果客户端断开连接，则退出循环 time.sleep(WEATHER_UPDATE_INTERVAL) except KeyboardInterrupt: print("服务器正在关闭。") finally: conn.close() server_socket.close() if __name__ == "__main__": main() ``` **Key Takeaways:** * This is a *very* simplified example. A real Minecraft server is much more complex. * The client-side mod is essential. Without it, the standard Minecraft client will not understand the custom weather packets. * Pay close attention to packet IDs, data packing/unpacking, and byte order. * Use threading in your client mod to avoid blocking the main game thread. * Handle errors gracefully. This should give you a good starting point. Good luck!

Time-MCP

For the time and date, an MCP (Minecraft Protocol) server doesn't directly provide that information. The Minecraft protocol focuses on game-related data. However, here are a few ways you could get the time and date in relation to a Minecraft server: * **Server-Side Mod/Plugin:** The most common and reliable way. You would need a server-side mod or plugin (like for Bukkit, Spigot, Paper, Fabric, or Forge) that exposes the server's current time and date. This mod/plugin could then: * Display the time/date in the server console. * Send the time/date to players in-game (e.g., via chat message, scoreboard, or a custom GUI). * Expose the time/date via an API that other programs can query. * **External Script/Program:** You could write a script (e.g., in Python, Java, etc.) that runs on the same machine as the Minecraft server. This script would: 1. Get the current system time and date from the operating system. 2. Potentially interact with the Minecraft server (if needed) to display the time/date in-game (using `rcon` or a similar method). This is less common because it requires more setup. * **In-Game Clock (Minecraft Feature):** Minecraft itself has a day/night cycle. While not a real-world clock, players can use the in-game clock to estimate the time. You could potentially use commands or mods to display the in-game time in a more readable format. **In summary, you'll need a server-side mod/plugin or an external script to get the actual time and date in relation to your Minecraft server.** The MCP itself doesn't handle this. Here's the translation to Chinese: 对于时间和日期，MCP（Minecraft 协议）服务器不直接提供这些信息。 Minecraft 协议专注于与游戏相关的数据。但是，以下是一些您可以获取与 Minecraft 服务器相关的时间和日期的方法： * **服务器端模组/插件：** 这是最常见和最可靠的方法。您需要一个服务器端模组或插件（例如 Bukkit、Spigot、Paper、Fabric 或 Forge），该模组或插件公开服务器的当前时间和日期。然后，此模组/插件可以： * 在服务器控制台中显示时间/日期。 * 在游戏中将时间/日期发送给玩家（例如，通过聊天消息、记分牌或自定义 GUI）。 * 通过其他程序可以查询的 API 公开时间/日期。 * **外部脚本/程序：** 您可以编写一个脚本（例如，使用 Python、Java 等），该脚本与 Minecraft 服务器在同一台机器上运行。该脚本将： 1. 从操作系统获取当前的系统时间和日期。 2. （如果需要）可能与 Minecraft 服务器交互，以在游戏中显示时间/日期（使用 `rcon` 或类似方法）。这不太常见，因为它需要更多设置。 * **游戏内时钟（Minecraft 功能）：** Minecraft 本身具有昼夜循环。虽然不是真实世界的时钟，但玩家可以使用游戏内时钟来估计时间。您可以潜在地使用命令或模组以更易读的格式显示游戏内时间。 **总而言之，您需要一个服务器端模组/插件或外部脚本来获取与您的 Minecraft 服务器相关的实际时间和日期。** MCP 本身不处理此问题。