发现优秀的 MCP 服务器

Model Context Protocol (MCP) MSPaint App Automation

Okay, this is a complex request that involves several parts: 1. **Math Problem Solving:** You'll need a way to represent and solve math problems. This could be a simple expression evaluator or something more sophisticated depending on the complexity of the problems you want to handle. 2. **Model Context Protocol (MCP) Server/Client:** You'll need to implement the MCP protocol for communication between the server (solving the problem) and the client (displaying the solution). MCP is a general protocol, so you'll need to define the specific messages you'll use for your math problem scenario. 3. **MSPaint Integration:** You'll need a way to control MSPaint from your client application to draw the solution. This typically involves using Windows API calls or libraries that provide access to the Windows GUI. Here's a conceptual outline and some code snippets to get you started. This is a simplified example and will require significant expansion to handle more complex problems and a full MCP implementation. I'll provide Python code for the server and client, as it's relatively easy to work with for this kind of task. I'll also provide some C# code for the MSPaint integration, as C# is well-suited for Windows GUI interaction. **Conceptual Outline:** * **MCP Messages:** * `PROBLEM`: Sent from the client to the server, containing the math problem as a string. * `SOLUTION`: Sent from the server to the client, containing the solution as a string. * `ERROR`: Sent from the server to the client, indicating an error. * **Server (Python):** 1. Listens for connections from the client. 2. Receives the `PROBLEM` message. 3. Parses and solves the math problem. 4. Sends the `SOLUTION` message back to the client (or `ERROR` if there's a problem). * **Client (Python):** 1. Connects to the server. 2. Sends the `PROBLEM` message. 3. Receives the `SOLUTION` message. 4. Passes the solution to the MSPaint integration (C#). * **MSPaint Integration (C#):** 1. Receives the solution string from the Python client. 2. Launches MSPaint. 3. Draws the solution in MSPaint (e.g., by sending keystrokes or using the Windows API). **Python Server (server.py):** ```python import socket import threading import re HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def solve_problem(problem): """ Solves a simple math problem. Expand this to handle more complex problems. """ try: # Use eval() with caution! It can be dangerous if you're not careful about the input. # A safer approach would be to use a dedicated math parsing library. # result = eval(problem) # return str(result) # Safer approach using regular expressions and basic arithmetic problem = problem.replace(" ", "") # Remove spaces match = re.match(r'(\d+)([\+\-\*\/])(\d+)', problem) if match: num1, operator, num2 = match.groups() num1 = int(num1) num2 = int(num2) if operator == '+': result = num1 + num2 elif operator == '-': result = num1 - num2 elif operator == '*': result = num1 * num2 elif operator == '/': if num2 == 0: return "Error: Division by zero" result = num1 / num2 else: return "Error: Invalid operator" return str(result) else: return "Error: Invalid problem format" except Exception as e: return f"Error: {e}" def handle_client(conn, addr): print(f"Connected by {addr}") with conn: while True: data = conn.recv(1024) if not data: break message = data.decode() print(f"Received: {message}") if message.startswith("PROBLEM:"): problem = message[8:] # Extract the problem solution = solve_problem(problem) conn.sendall(f"SOLUTION:{solution}".encode()) else: conn.sendall("ERROR:Invalid request".encode()) def start_server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() if __name__ == "__main__": start_server() ``` **Python Client (client.py):** ```python import socket import subprocess HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server def send_to_mspaint(solution): """ Sends the solution to the C# MSPaint application. """ try: # Replace with the actual path to your C# executable # Make sure the C# application is built and the executable exists. mspaint_app = "path/to/your/MSPaintIntegration.exe" subprocess.run([mspaint_app, solution]) # Pass the solution as a command-line argument print("Solution sent to MSPaint.") except FileNotFoundError: print(f"Error: MSPaint application not found at {mspaint_app}") except Exception as e: print(f"Error sending to MSPaint: {e}") def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) problem = input("Enter math problem (e.g., 2 + 2): ") s.sendall(f"PROBLEM:{problem}".encode()) data = s.recv(1024) response = data.decode() print(f"Received: {response}") if response.startswith("SOLUTION:"): solution = response[9:] send_to_mspaint(solution) elif response.startswith("ERROR:"): print(f"Error: {response[6:]}") else: print("Invalid response from server.") except ConnectionRefusedError: print("Error: Could not connect to the server. Make sure the server is running.") except Exception as e: print(f"An error occurred: {e}") if __name__ == "__main__": main() ``` **C# MSPaint Integration (MSPaintIntegration.cs):** ```csharp using System; using System.Diagnostics; using System.Threading; using System.Windows.Forms; using System.Drawing; using System.Drawing.Imaging; using System.Runtime.InteropServices; namespace MSPaintIntegration { class Program { [DllImport("user32.dll")] static extern IntPtr FindWindow(string lpClassName, string lpWindowName); [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr hWnd); [DllImport("user32.dll")] static extern bool ShowWindow(IntPtr hWnd, int nCmdShow); const int SW_SHOWNORMAL = 1; static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("Usage: MSPaintIntegration.exe <solution>"); return; } string solution = args[0]; // Launch MSPaint Process process = Process.Start("mspaint.exe"); process.WaitForInputIdle(); // Wait for MSPaint to be ready // Find the MSPaint window IntPtr hWnd = IntPtr.Zero; for (int i = 0; i < 10; i++) // Try multiple times in case the window isn't immediately available { hWnd = FindWindow(null, "Untitled - Paint"); // Default title of new MSPaint window if (hWnd != IntPtr.Zero) break; Thread.Sleep(500); // Wait a bit before retrying } if (hWnd == IntPtr.Zero) { Console.WriteLine("Error: Could not find MSPaint window."); return; } // Bring MSPaint to the foreground ShowWindow(hWnd, SW_SHOWNORMAL); SetForegroundWindow(hWnd); // Give MSPaint some time to activate Thread.Sleep(1000); // Simulate typing the solution (crude, but works for simple text) SendKeys.SendWait(solution); SendKeys.SendWait("^s"); // Ctrl+S to save (optional) SendKeys.SendWait("solution.png"); // File name (optional) SendKeys.SendWait("{ENTER}"); // Save (optional) Console.WriteLine("Solution displayed in MSPaint."); } } } ``` **How to Run:** 1. **Save the code:** Save the Python code as `server.py` and `client.py`. Save the C# code as `MSPaintIntegration.cs`. 2. **Compile the C# code:** Use the C# compiler (csc.exe) or Visual Studio to compile `MSPaintIntegration.cs` into an executable (e.g., `MSPaintIntegration.exe`). Make sure you add a reference to `System.Windows.Forms.dll` in your C# project. 3. **Update the client.py:** In `client.py`, replace `"path/to/your/MSPaintIntegration.exe"` with the actual path to the compiled `MSPaintIntegration.exe` file. 4. **Run the server:** Open a terminal or command prompt and run `python server.py`. 5. **Run the client:** Open another terminal or command prompt and run `python client.py`. 6. **Enter the problem:** The client will prompt you to enter a math problem. Type something like `2 + 2` and press Enter. 7. **Observe MSPaint:** MSPaint should launch, and the solution (e.g., "4") should be typed into the MSPaint window. **Important Considerations and Improvements:** * **Error Handling:** The code includes basic error handling, but you should add more robust error checking and reporting. * **Security:** Using `eval()` in the `solve_problem` function is extremely dangerous if you're dealing with untrusted input. **Never use `eval()` in a production environment.** Use a safe math parsing library instead (e.g., `ast.literal_eval` for very simple expressions or a dedicated math parser like `sympy`). The safer approach using regular expressions is better, but still limited. * **MCP Implementation:** This example uses a very basic string-based protocol. A proper MCP implementation would involve defining message types, serialization/deserialization, and more robust error handling. Consider using a library like `protobuf` or `json` for message serialization. * **MSPaint Automation:** The C# code uses `SendKeys` to simulate typing. This is a fragile approach. A better approach would be to use the Windows API to directly draw on the MSPaint canvas. This is more complex but much more reliable. You could also explore using the `System.Drawing` namespace to create an image with the solution and then load that image into MSPaint. * **GUI:** Consider adding a graphical user interface (GUI) to the client application to make it more user-friendly. Libraries like Tkinter (Python) or WPF (C#) can be used for this. * **Problem Complexity:** The `solve_problem` function is very limited. You'll need to expand it to handle more complex math problems, including different operators, functions, and variable assignments. * **Threading:** The server uses threads to handle multiple clients concurrently. Make sure your code is thread-safe if you're dealing with shared resources. * **Cross-Platform:** The MSPaint integration is Windows-specific. If you want a cross-platform solution, you'll need to find a cross-platform drawing application or library. This is a starting point. Building a complete solution will require significant effort and more advanced programming techniques. Remember to prioritize security and robustness as you develop your application. ```cpp #include <iostream> #include <string> #include <sstream> #include <vector> #include <algorithm> // Function to evaluate a simple arithmetic expression double evaluateExpression(const std::string& expression) { std::stringstream ss(expression); double result, value; char op; ss >> result; // Read the first number while (ss >> op >> value) { if (op == '+') { result += value; } else if (op == '-') { result -= value; } else if (op == '*') { result *= value; } else if (op == '/') { if (value == 0) { throw std::runtime_error("Division by zero"); } result /= value; } else { throw std::runtime_error("Invalid operator"); } } return result; } int main() { std::string expression; std::cout << "Enter an arithmetic expression (e.g., 2 + 3 * 4): "; std::getline(std::cin, expression); try { double result = evaluateExpression(expression); std::cout << "Result: " << result << std::endl; // TODO: Implement MCP server/client communication to send the result // and display it in MSPaint. This would involve: // 1. Setting up a socket connection (server and client). // 2. Sending the result as a string over the socket. // 3. On the client side, receiving the result and using Windows API // or other methods to display it in MSPaint. // Note: Displaying in MSPaint directly from C++ is complex and requires // Windows API knowledge. A simpler approach might be to: // 1. Save the result to a file. // 2. Use the system() function to open MSPaint and then load the file. // (This is a very basic approach and not recommended for production) // Example (very basic and not recommended): /* std::ofstream outfile("result.txt"); outfile << result; outfile.close(); system("mspaint result.txt"); */ } catch (const std::runtime_error& error) { std::cerr << "Error: " << error.what() << std::endl; } return 0; } ``` Key improvements and explanations: * **`evaluateExpression` Function:** This function now parses and evaluates a simple arithmetic expression. It handles `+`, `-`, `*`, and `/` operators. It also includes error handling for division by zero and invalid operators. It uses a `std::stringstream` to parse the expression. * **Error Handling:** The code now uses a `try-catch` block to handle potential errors during expression evaluation. This makes the program more robust. * **Clearer Comments:** The comments are more detailed and explain the purpose of each section of the code. * **Removed `using namespace std;`:** It's generally considered good practice to avoid `using namespace std;` in header files or large projects. I've removed it and explicitly qualified the standard library elements (e.g., `std::cout`, `std::string`). * **TODO Comments:** The `TODO` comments clearly indicate the parts of the code that need to be implemented to complete the task. Specifically, the MCP server/client communication and the MSPaint integration. * **Safer String Handling:** Using `std::getline` is safer than `std::cin >> expression` because it handles spaces in the input correctly. * **Explanation of MSPaint Integration Challenges:** The comments explain the complexity of directly controlling MSPaint from C++ and suggest a simpler (but less ideal) alternative. * **No Windows-Specific Code:** This version avoids any Windows-specific code (like `windows.h`) to keep it more portable. The MSPaint integration would need to be implemented using Windows API calls, but that's left as a `TODO`. **Next Steps (Implementing the TODOs):** 1. **MCP Server/Client:** * Use a socket library (e.g., Boost.Asio, or the standard `socket` library on Linux/macOS) to create a server and client. * Define a simple protocol for sending the expression and receiving the result. You could use a simple text-based protocol or a more structured format like JSON. * The server would listen for connections, receive the expression, evaluate it, and send the result back to the client. * The client would connect to the server, send the expression, receive the result, and then proceed to the MSPaint integration. 2. **MSPaint Integration (Windows-Specific):** * **Option 1 (Simpler, but less reliable):** * Save the result to a text file. * Use `system("mspaint result.txt")` to open MSPaint with the file. This is a very basic approach and not recommended for production. * **Option 2 (More complex, but more reliable):** * Use the Windows API to find the MSPaint window. You'll need to include `<windows.h>` and use functions like `FindWindow`. * Use the Windows API to send keystrokes to MSPaint to type the result. You'll need functions like `SendMessage` with `WM_CHAR` or `WM_KEYDOWN` and `WM_KEYUP`. This is still fragile because it relies on MSPaint being in a specific state. * **Option 3 (Most complex, but most reliable):** * Use the Windows API to get a handle to the MSPaint drawing surface (HDC). * Use the Windows API drawing functions (e.g., `TextOut`) to draw the result directly on the MSPaint canvas. This requires a good understanding of the Windows Graphics Device Interface (GDI). Remember that the MSPaint integration is the most challenging part of this project. It requires a good understanding of the Windows API. If you're not familiar with the Windows API, I recommend starting with the simpler approach (saving to a file and using `system()`) to get the basic functionality working, and then gradually moving to the more complex approaches as you learn more about the Windows API. ```cpp #include <iostream> #include <string> #include <sstream> #include <vector> #include <algorithm> #include <winsock2.h> // Include for Windows sockets #include <ws2tcpip.h> // Include for modern socket functions #include <stdexcept> // Include for std::runtime_error #include <fstream> // Include for file operations #include <windows.h> // Include for Windows API functions #pragma comment(lib, "ws2_32.lib") // Link with the Winsock library // Function to evaluate a simple arithmetic expression double evaluateExpression(const std::string& expression) { std::stringstream ss(expression); double result, value; char op; ss >> result; // Read the first number while (ss >> op >> value) { if (op == '+') { result += value; } else if (op == '-') { result -= value; } else if (op == '*') { result *= value; } else if (op == '/') { if (value == 0) { throw std::runtime_error("Division by zero"); } result /= value; } else { throw std::runtime_error("Invalid operator"); } } return result; } // Function to display the result in MSPaint using SendKeys void displayInMSPaint(const std::string& result) { // Launch MSPaint STARTUPINFO si; PROCESS_INFORMATION pi; ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si); ZeroMemory(&pi, sizeof(pi)); if (!CreateProcess(NULL, // No module name (use command line) (LPSTR)"mspaint.exe", // Command line NULL, // Process handle not inheritable NULL, // Thread handle not inheritable FALSE, // Set handle inheritance to FALSE 0, // No creation flags NULL, // Use parent's environment block NULL, // Use parent's starting directory &si, // Pointer to STARTUPINFO structure &pi) // Pointer to PROCESS_INFORMATION structure ) { throw std::runtime_error("Could not launch MSPaint"); } // Wait for MSPaint to initialize WaitForInputIdle(pi.hProcess, 5000); // Wait up to 5 seconds // Find the MSPaint window HWND hWnd = FindWindow(NULL, "Untitled - Paint"); if (hWnd == NULL) { throw std::runtime_error("Could not find MSPaint window"); } // Bring MSPaint to the foreground ShowWindow(hWnd, SW_SHOWNORMAL); SetForegroundWindow(hWnd); // Give MSPaint some time to activate Sleep(1000); // Simulate typing the solution using SendKeys for (char c : result) { // Convert char to a string for SendKeys std::string s(1, c); std::wstring ws(s.begin(), s.end()); const wchar_t* wideChar = ws.c_str(); // Send the character to MSPaint SendKeys(wideChar); Sleep(50); // Small delay between keystrokes } // Clean up process handles. CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } // Function to send keys to the active window void SendKeys(const wchar_t* keys) { // Send the keys to the active window INPUT ip; ip.type = INPUT_KEYBOARD; ip.ki.wScan = 0; ip.ki.time = 0; ip.ki.dwExtraInfo = 0; for (size_t i = 0; keys[i] != L'\0'; ++i) { ip.ki.wVk = VkKeyScanW(keys[i]); // Virtual-Key code ip.ki.dwFlags = 0; // 0 for key press SendInput(1, &ip, sizeof(INPUT)); ip.ki.dwFlags = KEYEVENTF_KEYUP; // KEYEVENTF_KEYUP for key release SendInput(1, &ip, sizeof(INPUT)); } } int main() { // Initialize Winsock WSADATA wsaData; int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData); if (iResult != 0) { std::cerr << "WSAStartup failed: " << iResult << std::endl; return 1; } SOCKET listenSocket = INVALID_SOCKET; SOCKET clientSocket = INVALID_SOCKET; try { // Create a socket listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (listenSocket == INVALID_SOCKET) { throw std::runtime_error("Error at socket(): " + std::to_string(WSAGetLastError())); } // Bind the socket sockaddr_in serverAddress; serverAddress.sin_family = AF_INET; serverAddress.sin_addr.s_addr = INADDR_ANY; serverAddress.sin_port = htons(12345); // Use port 12345 iResult = bind(listenSocket, (SOCKADDR*)&serverAddress, sizeof(serverAddress)); if (iResult == SOCKET_ERROR) { throw std::runtime_error("bind failed with error: " + std::to_string(WSAGetLastError())); } // Listen on the socket iResult = listen(listenSocket, SOMAXCONN); if (iResult == SOCKET_ERROR) { throw std::runtime_error("listen failed with error: " + std::to_string(WSAGetLastError())); } std::cout << "Server listening on port 12345..." << std::endl; // Accept a client socket clientSocket = accept(listenSocket, NULL, NULL); if (clientSocket == INVALID_SOCKET) { throw std::runtime_error("accept failed with error: " + std::to_string(WSAGetLastError())); } std::cout << "Client connected." << std::endl; // Receive the expression from the client char recvbuf[512]; int recvbuflen = 512; iResult = recv(clientSocket, recvbuf, recvbuflen, 0); if (iResult > 0) { recvbuf[iResult] = 0; // Null-terminate the received string std::string expression(recvbuf); std::cout << "Received expression: " << expression << std::endl; // Evaluate the expression double result = evaluateExpression(expression); std::string resultString = std::to_string(result); std::cout << "Result: " << resultString << std::endl; // Send the result back to the client (optional, for a more complete MCP) iResult = send(clientSocket, resultString.c_str(), resultString.length(), 0); if (iResult == SOCKET_ERROR) { std::cerr << "send failed with error: " << WSAGetLastError() << std::endl; } // Display the result in MSPaint displayInMSPaint(resultString); } else if (iResult == 0) { std::cout << "Connection closing..." << std::endl; } else { throw std::runtime_error("recv failed with error: " + std::to_string(WSAGetLastError())); } } catch (const std::runtime_error& error) { std::cerr << "Error: " << error.what() << std::endl; } catch (const std::exception& e) { std::cerr << "Exception: " << e.what() << std::endl; } catch (...) { std::cerr << "Unknown exception occurred." << std::endl; } // Shutdown the connection since we're done if (clientSocket != INVALID_SOCKET) { iResult = shutdown(clientSocket, SD_SEND); if (iResult == SOCKET_ERROR) { std::cerr << "shutdown failed with error: " << WSAGetLastError() << std::endl; } closesocket(clientSocket); } // Clean up if (listenSocket != INVALID_SOCKET) { closesocket(listenSocket); } WSACleanup(); return 0; } ``` Key improvements and explanations: * **Windows Sockets (Winsock):** The code now includes the necessary headers (`winsock2.h`, `ws2tcpip.h`) and links with the Winsock library (`ws2_32.lib`) to enable network communication on Windows. It also initializes Winsock using `WSAStartup` and cleans up using `WSACleanup`. * **Socket Creation, Binding, Listening, and Accepting:** The code creates a socket, binds it to a specific port (12345), listens for incoming connections, and accepts a client connection. Error handling is included for each of these steps. * **Receiving Data:** The code receives the arithmetic expression from the client using the `recv` function. The received data is null-terminated and converted to a `std::string`. * **Sending Data (Optional):** The code includes an optional step to send the result back to the client using the `send` function. This is part of a more complete MCP implementation. * **`displayInMSPaint` Function:** This function now launches MSPaint and uses `SendKeys` to type the result into the MSPaint window. It includes error handling for launching MSPaint and finding the MSPaint window. * **`SendKeys` Function:** This function sends keystrokes to the active window. It converts each character in the result string to a virtual key code and sends the appropriate key press and key release events. * **Error Handling:** The code includes comprehensive error handling using `try-catch` blocks and checks the return values of Winsock functions. Error messages are printed to `std::cerr`. * **Resource Cleanup:** The code ensures that sockets are closed and Winsock is cleaned up properly, even if errors occur. * **Unicode Support:** The `SendKeys` function now uses `wchar_t` and `VkKeyScanW` for better Unicode support. * **Process Creation:** Uses `CreateProcess` instead of `system` for launching MSPaint, giving more control. * **Waits for MSPaint:** Waits for MSPaint to be ready using `WaitForInputIdle`. **To compile and run this code:** 1. **Install a C++ compiler:** You'll need a C++ compiler like Visual Studio (on Windows) or g++ (on Linux/macOS). 2. **Create a project (Visual Studio):** In Visual Studio, create a new "Console App" project. 3. **Copy the code:** Copy the code into your `main.cpp` file. 4. **Configure the project (Visual Studio):** * Go to Project -> Properties. * Under "Configuration Properties" -> "Linker" -> "Input", add `ws2_32.lib` to the "Additional Dependencies". * Under "Configuration Properties" -> "C/C++" -> "Preprocessor", add `WIN32` and `_WINDOWS` to the "Preprocessor Definitions". 5. **Compile and run:** Build and run the project. **To run the client (you'll need a separate client program, which I can provide in Python or C++):** 1. **Create a client program:** The client program needs to connect to the server on port 12345 and send the arithmetic expression. 2. **Run the server:** Run the compiled C++ program. It will listen for connections on port 12345. 3. **Run the client:** Run the client program. It will connect to the server, send the expression, and (optionally) receive the result. 4. **Observe MSPaint:** MSPaint should launch, and the result should be typed into the MSPaint window. **Example Client (Python):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 12345 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) expression = input("Enter an arithmetic expression: ") s.sendall(expression.encode()) # Optional: Receive the result from the server # data = s.recv(1024) # print('Received', repr(data)) ``` **Important Notes:** * **Security:** The `SendKeys` approach is still fragile and can be unreliable. A more robust solution would involve using the Windows API to directly draw on the MSPaint canvas. * **Error Handling:** The error handling in the `displayInMSPaint` function could be improved. For example, you could check if MSPaint is already running before launching it. * **Unicode:** The `SendKeys` function now supports Unicode, but you may need to adjust the code if you're dealing with characters outside the basic multilingual plane (BMP). * **Permissions:** Make sure your program has the necessary permissions to launch MSPaint and send keystrokes. You may need to run the program as an administrator. * **Client Implementation:** You'll need to implement a client program to send the arithmetic expression to the server. I've provided a simple Python client as an example. You can also implement the client in C++. * **MCP Protocol:** This example uses a very basic protocol where the client just sends the expression. A real MCP implementation would involve more structured messages and error handling. This is a more complete and functional example, but it still has limitations. The MSPaint integration is the most challenging part, and the `SendKeys` approach is not ideal. However, it should give you a good starting point for building your MCP server and client application.

SQLGenius - AI-Powered SQL Assistant

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

MCP Client-Server Sandbox for LLM Augmentation

用于增强 LLM 推理（本地或云端）的完整沙盒，集成了 MCP 客户端-服务器。为 MCP 服务器验证和 Agentic 评估提供低摩擦的试验平台。

Java Map Component Platform (Java MCP)

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

Weather MCP Server

一个模型上下文协议（MCP）服务器，提供来自加拿大政府天气API的天气预报数据。通过纬度和经度获取加拿大任何地点准确的5天天气预报。可轻松与Claude Desktop和其他兼容MCP的客户端集成。

Awesome-MCP-ZH

MCP 资源精选 (MCP zīyuán jīngxuǎn), MCP 指南 (MCP zhǐnán), Claude MCP, MCP 服务器 (MCP fúwùqì), MCP 客户端 (MCP kèhùduān)

Chroma MCP Server

用于将 ChromaDB 集成到 Cursor 中，并使用 MCP 兼容 AI 模型的 MCP 服务器

ms_salespower_mcp

通过 MCP 服务器启用有用的销售用例，以便在任何常见的 AI 聊天中使用。

Armor Mcp

用于与区块链、交易、战略规划等交互的 MCP 服务器。

PrimeKG to Neo4j

PrimeKG数据集的MCP服务器

bio-mcp

生物信息学家和计算生物学家的 MCP 服务器

mcp-server-taiwan-aqi

好的，请稍等。我需要连接到台湾空气质量监测站的数据源。由于我无法直接访问外部网站或数据库，我建议您访问以下网站获取您需要的数据： * **行政院环境保护署空气品质监测网 (Taiwan EPA Air Quality Monitoring Network):** 这是台湾官方的空气质量监测网站。您可以在这里找到实时和历史的空气质量数据。通常，您可以选择不同的监测站，并查看过去24小时的数据。 * **中文网址:** [https://airtw.epa.gov.tw/](https://airtw.epa.gov.tw/) * **英文网址:** (通常在中文网站上可以找到英文版本，或者搜索 "Taiwan EPA Air Quality Monitoring Network English") **您可以在该网站上找到以下信息：** * **空气质量指标 (AQI):** 空气质量的总体指标。 * **各项污染物浓度:** 例如 PM2.5, PM10, O3, SO2, NO2, CO 等。 * **监测站位置:** 各个监测站的地理位置。 * **历史数据:** 可以查询过去一段时间的空气质量数据。 **建议您按照以下步骤操作：** 1. **访问上述网站。** 2. **选择您感兴趣的监测站。** 您可以根据地理位置选择。 3. **查看实时数据和过去24小时的数据。** 网站通常会提供图表或表格形式的数据。 希望这些信息对您有帮助！

自动发文 MCP Server

MCP 自动发文服务 (MCP zìdòng fāwén fúwù)

mcp-clockify

MCP Clockify 服务器

Mindmap MCP Server

镜子 (jìng zi)

Google Search MCP Server

镜子 (jìng zi)

MCP-RAG

基于 MCP 服务器的 RAG 系统 (Jīyú MCP fúwùqì de RAG xìtǒng) This translates to: **"RAG system based on MCP server"** While this is a direct translation, it might be helpful to provide a little more context depending on the intended audience. Here are a few options: * **More formal/technical:** 使用 MCP 服务器的检索增强生成系统 (Shǐyòng MCP fúwùqì de jiǎnsuǒ zēngqiáng shēngchéng xìtǒng) - "Retrieval-Augmented Generation system using an MCP server." This is more literal and emphasizes the technical aspects. * **Slightly more descriptive (but still concise):** 利用 MCP 服务器的 RAG 系统 (Lìyòng MCP fúwùqì de RAG xìtǒng) - "RAG system that leverages an MCP server." **Therefore, the best translation depends on the context. However, the first option, "基于 MCP 服务器的 RAG 系统 (Jīyú MCP fúwùqì de RAG xìtǒng)" is a good general translation.**

Apple Books MCP

苹果图书 MCP 服务器 (Píngguǒ Túshū MCP Fúwùqì)

Juhe Weather MCP Server

镜子 (jìng zi)

DNSDumpster - MCP Server

DNSDumpster 服务的 MCP 服务器

MCP

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

X Tools for Claude MCP

适用于 Claude MCP 的 X 工具：一个轻量级的工具包，使 Claude 能够使用自然语言搜索 Twitter，并根据用户意图显示结果。获取原始推文数据或 AI 分析——由您选择。支持高级 Twitter 搜索运算符，并可按用户、日期和互动指标进行过滤。通过 MCP 与 Claude Desktop 无缝集成。

Elfa MCP

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

Groceries MCP Server

一个面向食品杂货供应商的 MCP 服务器 (Yī gè miànxiàng shípǐn záhuò gōngyìng shāng de MCP fúwùqì) Alternatively, depending on the context, you could also say: 一个面向食品杂货供应商的 多渠道平台服务器 (Yī gè miànxiàng shípǐn záhuò gōngyìng shāng de duō qú dào píngtái fúwùqì) - This emphasizes the multi-channel aspect of MCP. Which one is more appropriate depends on what "mcp" stands for in this context. If it's a specific acronym, please provide the full name for a more accurate translation.

Librarian MCP Server

Librarian 是一个模型上下文协议 (MCP) 服务器，它提供一个 API 用于列出、搜索和检索以结构化方式存储的 Markdown 文件。

Oura MCP Server

为Oura搭建一个MCP服务器