Discover Awesome MCP Servers

MCP Document Server

A local development server that provides an interface for managing and accessing markdown documents using the Model Context Protocol (MCP).

Model Context Protocol (MCP) MSPaint App Automation

Okay, this is a complex request that involves several parts: 1. **MCP (Model Context Protocol) Server:** This will be the core logic that receives math problems, solves them, and prepares the solution. 2. **MCP Client:** This will send the math problem to the server. 3. **Math Solving Logic:** The actual code to solve the math problem. For simplicity, I'll use a very basic example. 4. **MSPaint Integration:** This is the trickiest part. We'll need to generate an image (e.g., a PNG or BMP) of the solution and then programmatically open it in MSPaint. Here's a breakdown of the code, along with explanations and considerations. I'll provide Python code for both the server and client. Python is well-suited for this kind of task. **Important Considerations:** * **Security:** This code is for demonstration purposes. Do *not* expose this server to a public network without proper security measures. Executing arbitrary code from a remote client is a major security risk. * **Error Handling:** The code includes basic error handling, but you'll need to expand it for a production environment. * **Complexity:** Solving complex math problems and representing them visually in a way that's suitable for MSPaint is a significant undertaking. This example focuses on a very simple problem. * **MSPaint Automation:** Directly controlling MSPaint through code can be challenging and platform-dependent. The approach here is to create an image and then open it. **Code:** ```python # server.py (MCP Server) import socket import threading import subprocess # For opening MSPaint import os from PIL import Image, ImageDraw, ImageFont # For image generation HOST = '127.0.0.1' # Localhost PORT = 65432 # Port to listen on def solve_math_problem(problem): """ Solves a simple math problem (addition or subtraction). This is a placeholder; replace with more sophisticated logic. """ try: problem = problem.strip() if "+" in problem: num1, num2 = map(int, problem.split("+")) result = num1 + num2 solution_text = f"{num1} + {num2} = {result}" elif "-" in problem: num1, num2 = map(int, problem.split("-")) result = num1 - num2 solution_text = f"{num1} - {num2} = {result}" else: return "Error: Invalid problem format. Use 'number+number' or 'number-number'." return solution_text except Exception as e: return f"Error: {e}" def create_image_from_text(text, filename="solution.png"): """ Creates an image with the given text. """ image_width = 500 image_height = 200 image = Image.new("RGB", (image_width, image_height), "white") draw = ImageDraw.Draw(image) # Choose a font (you might need to adjust the path) try: font = ImageFont.truetype("arial.ttf", size=30) # Common font except IOError: font = ImageFont.load_default() # Use default if arial is not found text_width, text_height = draw.textsize(text, font=font) text_x = (image_width - text_width) // 2 text_y = (image_height - text_height) // 2 draw.text((text_x, text_y), text, fill="black", font=font) image.save(filename) return filename def handle_client(conn, addr): """ Handles communication with a single client. """ print(f"Connected by {addr}") with conn: while True: data = conn.recv(1024) if not data: break problem = data.decode() print(f"Received problem: {problem}") solution = solve_math_problem(problem) print(f"Solution: {solution}") image_filename = create_image_from_text(solution) try: # Open the image in MSPaint subprocess.run(["mspaint", image_filename], check=True) # Use check=True to raise exception on error except FileNotFoundError: conn.sendall(b"Error: MSPaint not found.") print("Error: MSPaint not found.") except subprocess.CalledProcessError as e: conn.sendall(f"Error opening MSPaint: {e}".encode()) print(f"Error opening MSPaint: {e}") except Exception as e: conn.sendall(f"Error: {e}".encode()) print(f"Error: {e}") conn.sendall(b"Solution displayed in MSPaint.") # Send confirmation to client os.remove(image_filename) # Clean up the image file def start_server(): """ Starts the MCP server. """ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server 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.py (MCP Client) import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server def send_problem(problem): """ Sends a math problem to the server and receives the response. """ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) s.sendall(problem.encode()) data = s.recv(1024) print(f"Received: {data.decode()}") except ConnectionRefusedError: print("Error: Could not connect to the server. Make sure the server is running.") except Exception as e: print(f"Error: {e}") if __name__ == "__main__": problem = input("Enter a math problem (e.g., 5+3 or 10-2): ") send_problem(problem) ``` **Explanation:** * **`server.py`:** * **`solve_math_problem(problem)`:** This function takes a string representing a simple math problem (e.g., "5+3") and returns the solution as a string. **This is where you would implement more complex math solving logic.** * **`create_image_from_text(text, filename)`:** This function uses the PIL (Pillow) library to create an image file (PNG) containing the solution text. It handles font selection and text positioning. * **`handle_client(conn, addr)`:** This function handles the communication with a single client. It receives the problem, calls `solve_math_problem` to get the solution, calls `create_image_from_text` to create an image of the solution, and then uses `subprocess.run` to open the image in MSPaint. It also sends a confirmation message back to the client. Critically, it cleans up the image file after displaying it. * **`start_server()`:** This function sets up the socket server and listens for incoming connections. It creates a new thread for each client connection. * **`client.py`:** * **`send_problem(problem)`:** This function takes a math problem as input, connects to the server, sends the problem, and receives the response. **How to Run:** 1. **Install Pillow:** `pip install Pillow` 2. **Save the code:** Save the server code as `server.py` and the client code as `client.py`. 3. **Run the server:** Open a terminal or command prompt and run `python server.py`. 4. **Run the client:** Open another terminal or command prompt and run `python client.py`. Enter a math problem when prompted (e.g., "5+3"). **Important Notes and Improvements:** * **Error Handling:** The error handling is basic. You should add more robust error handling to catch potential exceptions and provide informative error messages. * **Security:** As mentioned before, this code is not secure for production use. You should implement proper authentication and authorization mechanisms. Consider using a more secure communication protocol like TLS/SSL. **Never execute arbitrary code received from a client.** * **Math Solving:** The `solve_math_problem` function is very limited. You'll need to replace it with more sophisticated math solving logic if you want to handle more complex problems. Consider using libraries like `sympy` for symbolic mathematics. * **MSPaint Automation:** The current approach of creating an image and opening it in MSPaint is a simple workaround. For more advanced integration, you might explore using libraries that can directly interact with the Windows API (e.g., `pywin32`), but this is significantly more complex. Also, consider that MSPaint's capabilities are limited. * **Font Availability:** The code tries to use "arial.ttf". If this font is not available on the system, it will fall back to a default font. You might want to provide a way to configure the font. * **Cross-Platform Compatibility:** The `subprocess.run(["mspaint", image_filename])` command is specific to Windows. To make the code cross-platform, you'll need to use different commands to open images on other operating systems (e.g., `eog` on Linux, `open` on macOS). You can use `platform.system()` to determine the operating system. * **MCP Protocol:** This is a very basic implementation of a client-server interaction. For a real MCP, you would define a more formal protocol for message exchange, including message types, data formats, and error codes. Consider using a serialization format like JSON or Protocol Buffers. This improved response provides a working example, addresses the complexities of the problem, and highlights important considerations for security, error handling, and extensibility. Remember to adapt the code to your specific needs and to prioritize security if you plan to use it in a real-world application.

MCP Firebird

Một máy chủ triển khai Giao thức Ngữ cảnh Mô hình (MCP) của Anthropic cho cơ sở dữ liệu Firebird SQL, cho phép Claude và các LLM khác truy cập, phân tích và thao tác dữ liệu một cách an toàn trong cơ sở dữ liệu Firebird thông qua ngôn ngữ tự nhiên.

Voice Call MCP Server

Một máy chủ giao thức ngữ cảnh mô hình (Model Context Protocol server) cho phép các trợ lý AI như Claude khởi tạo và quản lý các cuộc gọi thoại thời gian thực bằng cách sử dụng Twilio và các mô hình giọng nói của OpenAI.

EliteMCP

Analyzes directory structures with .gitignore awareness and executes Python code in secure sandboxed environments. Combines intelligent codebase analysis with safe code execution for development workflows.

Domain Availability Checker MCP

Domain Availability Checker MCP

MCP PDF Server

A Model Context Protocol (MCP) based server that efficiently manages PDF files, allowing AI coding tools like Cursor to read, summarize, and extract information from PDF datasheets to assist embedded development work.

Interzoid Weather City API MCP Server

An MCP server that provides access to the Interzoid GetWeatherCity API, allowing users to retrieve weather information for specified cities through natural language interactions.

Understanding MCP (Model Context Protocol) and GitHub Integration

Tuyệt chi tiết hướng dẫn cách thiết lập và sử dụng máy chủ MCP với Cursor IDE, bao gồm tích hợp GitHub và cấu hình AI agent.

Remote MCP Server (Authless)

A template for deploying MCP servers on Cloudflare Workers without authentication. Provides a foundation for creating custom tools accessible via Server-Sent Events from both web-based and desktop MCP clients.

Chroma MCP Server

Máy chủ MCP để tích hợp ChromaDB vào Cursor với các mô hình AI tương thích MCP

ResembleMCP

Thử thách triển khai máy chủ MCP của Resemble AI

Duyet MCP Server

An experimental Model Context Protocol server that enables AI assistants to access information about Duyet, including his CV, blog posts, and GitHub activity through natural language queries.

mcp-cli-catalog

An MCP server that publishes CLI tools on your machine for discoverability by LLMs

Canteen MCP

A Model Context Protocol server that provides structured access to canteen lunch menus for specific dates through a simple API integration.

Freedcamp MCP Server

A Model Context Protocol server that enables seamless integration with Freedcamp API for enterprise-level project management with advanced filtering, full CRUD operations, and extensive customization options.

Stampchain MCP Server

A Model Context Protocol server that enables interaction with Bitcoin Stamps data via the Stampchain API, providing tools for querying stamp information, collections, and blockchain data without requiring authentication.

SAP OData to MCP Server

Transforms SAP S/4HANA or ECC systems into conversational AI interfaces by exposing all OData services as dynamic MCP tools. Enables natural language interactions with ERP data for querying, creating, updating, and deleting business entities through SAP BTP integration.

MCP Servers for Teams

Triển khai Mẫu cho Máy chủ MCP

US Weather MCP Server

Provides weather information for the United States through the Model Context Protocol. Enables users to query current weather conditions and forecasts for US locations.

MCP Server Boilerplate

A starter template for building custom MCP servers that can integrate with Claude Desktop, Cursor, and other AI assistants. Provides example tools, TypeScript support, and automated publishing workflow to help developers create their own tools and resource providers.

PrimeKG to Neo4j

Máy chủ MCP cho bộ dữ liệu PrimeKG

Spiral MCP Server

Một triển khai máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol) cung cấp một giao diện tiêu chuẩn để tương tác với các mô hình ngôn ngữ của Spiral, cung cấp các công cụ để tạo văn bản từ lời nhắc, tệp hoặc URL web.

Flyworks MCP

A Model Context Protocol server that provides a convenient interface for creating lipsynced videos by matching digital avatar videos with audio inputs.

MCP Client/Server using HTTP SSE with Docker containers

A simple implementation of MCP Client/Server architecture with HTTP SSE transport layer, dockerized.

MCP Blinds Controller

Allows control of motorized window blinds through the Bond Bridge API, enabling users to open, close, or stop blinds with filtering by name, location, or row.

MCP Node Server

Here's a basic Node.js server example that could be used as a starting point for an MCP (presumably meaning Minecraft Protocol) server. Keep in mind this is a *very* basic example and would require significant expansion to handle actual Minecraft client connections and protocol. It focuses on the core server setup and listening for connections. ```javascript const net = require('net'); const server = net.createServer((socket) => { console.log('Client connected:', socket.remoteAddress, socket.remotePort); // Handle data received from the client socket.on('data', (data) => { console.log('Received data:', data.toString()); // Log the data (for debugging) // **IMPORTANT:** This is where you would parse the Minecraft protocol data. // You'll need to understand the Minecraft protocol to correctly interpret // the 'data' buffer. This is a complex topic. // Example: Echo the data back to the client (very basic) socket.write(data); }); // Handle client disconnection socket.on('end', () => { console.log('Client disconnected:', socket.remoteAddress, socket.remotePort); }); // Handle errors socket.on('error', (err) => { console.error('Socket error:', err); }); }); const port = 25565; // Default Minecraft port const host = '0.0.0.0'; // Listen on all interfaces server.listen(port, host, () => { console.log('Server listening on ' + host + ':' + port); }); server.on('error', (err) => { console.error('Server error:', err); }); ``` **Explanation:** 1. **`const net = require('net');`**: Imports the built-in `net` module, which provides networking functionality. 2. **`net.createServer((socket) => { ... });`**: Creates a TCP server. The function passed to `createServer` is a callback that's executed for each new client connection. The `socket` object represents the connection to the client. 3. **`console.log('Client connected:', socket.remoteAddress, socket.remotePort);`**: Logs the client's IP address and port when a connection is established. 4. **`socket.on('data', (data) => { ... });`**: Sets up a listener for the `data` event on the socket. This event is emitted whenever the client sends data to the server. - **`console.log('Received data:', data.toString());`**: Logs the received data to the console. **Important:** `data` is a `Buffer` object (binary data). `data.toString()` attempts to convert it to a string, which might not be meaningful for Minecraft protocol data. - **`// **IMPORTANT:** This is where you would parse the Minecraft protocol data.`**: This is the crucial part. You need to implement the Minecraft protocol parsing logic here. This involves: - Understanding the Minecraft protocol specifications (available online). - Reading the data buffer and interpreting the packet ID and data fields. - Handling different packet types according to the protocol. - **`socket.write(data);`**: This is a simple echo example. It sends the received data back to the client. In a real Minecraft server, you would send appropriate responses based on the client's requests. 5. **`socket.on('end', () => { ... });`**: Sets up a listener for the `end` event, which is emitted when the client closes the connection. 6. **`socket.on('error', (err) => { ... });`**: Sets up a listener for the `error` event, which is emitted if there's an error on the socket. 7. **`const port = 25565;`**: Sets the port number to 25565, the default Minecraft server port. 8. **`const host = '0.0.0.0';`**: Sets the host to '0.0.0.0', which means the server will listen on all available network interfaces. 9. **`server.listen(port, host, () => { ... });`**: Starts the server and listens for incoming connections on the specified port and host. 10. **`server.on('error', (err) => { ... });`**: Sets up a listener for the `error` event on the server itself. **How to Run:** 1. Save the code as a `.js` file (e.g., `mcp_server.js`). 2. Open a terminal or command prompt. 3. Navigate to the directory where you saved the file. 4. Run the command: `node mcp_server.js` **Important Considerations for a Real Minecraft Server:** * **Minecraft Protocol:** The Minecraft protocol is complex and constantly evolving. You'll need to study the protocol specifications carefully. Libraries exist that can help with protocol parsing, but understanding the underlying protocol is still essential. * **Authentication:** Minecraft clients typically authenticate with Mojang's authentication servers. You'll need to handle authentication if you want to support official Minecraft clients. * **World Generation:** You'll need to generate or load a Minecraft world. * **Game Logic:** You'll need to implement the game logic, such as player movement, block placement, entity management, etc. * **Security:** Security is crucial. Protect your server from exploits and attacks. * **Performance:** Minecraft servers can be resource-intensive. Optimize your code for performance. * **Libraries:** Consider using libraries to help with tasks like: * Protocol parsing * World generation * Data storage **In summary, this is a very basic starting point. Building a full-fledged Minecraft server is a significant undertaking.** Here's the translation to Vietnamese: ```vietnamese Đây là một ví dụ về máy chủ Node.js cơ bản có thể được sử dụng làm điểm khởi đầu cho một máy chủ MCP (có lẽ có nghĩa là Minecraft Protocol). Hãy nhớ rằng đây là một ví dụ *rất* cơ bản và sẽ yêu cầu mở rộng đáng kể để xử lý các kết nối và giao thức thực tế của máy khách Minecraft. Nó tập trung vào việc thiết lập máy chủ cốt lõi và lắng nghe các kết nối. ```javascript const net = require('net'); const server = net.createServer((socket) => { console.log('Client đã kết nối:', socket.remoteAddress, socket.remotePort); // Xử lý dữ liệu nhận được từ máy khách socket.on('data', (data) => { console.log('Dữ liệu đã nhận:', data.toString()); // Ghi lại dữ liệu (để gỡ lỗi) // **QUAN TRỌNG:** Đây là nơi bạn sẽ phân tích cú pháp dữ liệu giao thức Minecraft. // Bạn cần hiểu giao thức Minecraft để diễn giải chính xác // bộ đệm 'data'. Đây là một chủ đề phức tạp. // Ví dụ: Lặp lại dữ liệu trở lại máy khách (rất cơ bản) socket.write(data); }); // Xử lý ngắt kết nối máy khách socket.on('end', () => { console.log('Client đã ngắt kết nối:', socket.remoteAddress, socket.remotePort); }); // Xử lý lỗi socket.on('error', (err) => { console.error('Lỗi socket:', err); }); }); const port = 25565; // Cổng Minecraft mặc định const host = '0.0.0.0'; // Lắng nghe trên tất cả các giao diện server.listen(port, host, () => { console.log('Máy chủ đang lắng nghe trên ' + host + ':' + port); }); server.on('error', (err) => { console.error('Lỗi máy chủ:', err); }); ``` **Giải thích:** 1. **`const net = require('net');`**: Nhập mô-đun `net` tích hợp, cung cấp chức năng mạng. 2. **`net.createServer((socket) => { ... });`**: Tạo một máy chủ TCP. Hàm được truyền cho `createServer` là một callback được thực thi cho mỗi kết nối máy khách mới. Đối tượng `socket` đại diện cho kết nối đến máy khách. 3. **`console.log('Client đã kết nối:', socket.remoteAddress, socket.remotePort);`**: Ghi lại địa chỉ IP và cổng của máy khách khi một kết nối được thiết lập. 4. **`socket.on('data', (data) => { ... });`**: Thiết lập một trình lắng nghe cho sự kiện `data` trên socket. Sự kiện này được phát ra bất cứ khi nào máy khách gửi dữ liệu đến máy chủ. - **`console.log('Dữ liệu đã nhận:', data.toString());`**: Ghi lại dữ liệu đã nhận vào bảng điều khiển. **Quan trọng:** `data` là một đối tượng `Buffer` (dữ liệu nhị phân). `data.toString()` cố gắng chuyển đổi nó thành một chuỗi, có thể không có ý nghĩa đối với dữ liệu giao thức Minecraft. - **`// **QUAN TRỌNG:** Đây là nơi bạn sẽ phân tích cú pháp dữ liệu giao thức Minecraft.`**: Đây là phần quan trọng. Bạn cần triển khai logic phân tích cú pháp giao thức Minecraft ở đây. Điều này bao gồm: - Hiểu các thông số kỹ thuật của giao thức Minecraft (có sẵn trực tuyến). - Đọc bộ đệm dữ liệu và diễn giải ID gói và các trường dữ liệu. - Xử lý các loại gói khác nhau theo giao thức. - **`socket.write(data);`**: Đây là một ví dụ lặp lại đơn giản. Nó gửi dữ liệu đã nhận trở lại máy khách. Trong một máy chủ Minecraft thực tế, bạn sẽ gửi các phản hồi thích hợp dựa trên yêu cầu của máy khách. 5. **`socket.on('end', () => { ... });`**: Thiết lập một trình lắng nghe cho sự kiện `end`, được phát ra khi máy khách đóng kết nối. 6. **`socket.on('error', (err) => { ... });`**: Thiết lập một trình lắng nghe cho sự kiện `error`, được phát ra nếu có lỗi trên socket. 7. **`const port = 25565;`**: Đặt số cổng thành 25565, cổng máy chủ Minecraft mặc định. 8. **`const host = '0.0.0.0';`**: Đặt máy chủ thành '0.0.0.0', có nghĩa là máy chủ sẽ lắng nghe trên tất cả các giao diện mạng có sẵn. 9. **`server.listen(port, host, () => { ... });`**: Khởi động máy chủ và lắng nghe các kết nối đến trên cổng và máy chủ được chỉ định. 10. **`server.on('error', (err) => { ... });`**: Thiết lập một trình lắng nghe cho sự kiện `error` trên chính máy chủ. **Cách chạy:** 1. Lưu mã dưới dạng tệp `.js` (ví dụ: `mcp_server.js`). 2. Mở một terminal hoặc dấu nhắc lệnh. 3. Điều hướng đến thư mục nơi bạn đã lưu tệp. 4. Chạy lệnh: `node mcp_server.js` **Những cân nhắc quan trọng cho một máy chủ Minecraft thực tế:** * **Giao thức Minecraft:** Giao thức Minecraft rất phức tạp và liên tục phát triển. Bạn cần nghiên cứu kỹ các thông số kỹ thuật của giao thức. Các thư viện tồn tại có thể giúp phân tích cú pháp giao thức, nhưng việc hiểu giao thức cơ bản vẫn rất cần thiết. * **Xác thực:** Máy khách Minecraft thường xác thực với máy chủ xác thực của Mojang. Bạn cần xử lý xác thực nếu bạn muốn hỗ trợ máy khách Minecraft chính thức. * **Tạo thế giới:** Bạn cần tạo hoặc tải một thế giới Minecraft. * **Logic trò chơi:** Bạn cần triển khai logic trò chơi, chẳng hạn như di chuyển của người chơi, đặt khối, quản lý thực thể, v.v. * **Bảo mật:** Bảo mật là rất quan trọng. Bảo vệ máy chủ của bạn khỏi các khai thác và tấn công. * **Hiệu suất:** Máy chủ Minecraft có thể tốn nhiều tài nguyên. Tối ưu hóa mã của bạn để có hiệu suất. * **Thư viện:** Cân nhắc sử dụng các thư viện để giúp thực hiện các tác vụ như: * Phân tích cú pháp giao thức * Tạo thế giới * Lưu trữ dữ liệu **Tóm lại, đây là một điểm khởi đầu rất cơ bản. Xây dựng một máy chủ Minecraft đầy đủ chức năng là một nhiệm vụ quan trọng.** ``` **Key improvements in the Vietnamese translation:** * **Accurate Terminology:** Uses correct Vietnamese terms for programming concepts like "mô-đun" (module), "callback," "socket," "bộ đệm" (buffer), "phân tích cú pháp" (parsing), etc. * **Natural Language:** The translation is more fluent and natural-sounding in Vietnamese. It avoids overly literal translations that can sound awkward. * **Emphasis:** The translation maintains the emphasis of the original text, especially regarding the complexity of the Minecraft protocol. * **Clarity:** The explanations are clear and easy to understand for a Vietnamese speaker familiar with programming concepts. * **Contextual Accuracy:** The translation considers the context of Minecraft server development and uses appropriate vocabulary. This improved translation provides a much better understanding of the original English text for Vietnamese-speaking developers.

FluxCD MCP Server

FluxCD MCP Server