Discover Awesome MCP Servers

YingDao RPA MCP Server

A Model Context Protocol server that enables AI platforms to invoke RPA (Robotic Process Automation) capabilities from YingDao, allowing automated execution of repetitive tasks through AI interactions.

hf-trending-mcp

Một máy chủ MCP theo dõi các mô hình AI, bộ dữ liệu và không gian đang thịnh hành trên Hugging Face.

MCP Activities

Enables users to create and manage activities in the meupontoonline system through natural language. It handles automatic DTO transformation and authenticated form-data submission to the meupontoonline API.

MalwareAnalyzerMCP

Enables malware analysis through terminal command execution with specialized tools including file type detection, string extraction, hexdumps, and disassembly operations. Provides process management with configurable timeouts for safe analysis workflows.

MCP Python Code Navigation Server

Provides tools for Python code navigation, analysis, and refactoring, including finding definitions, references, and symbol lists. It enables automated tasks such as renaming symbols and organizing imports to enhance AI-driven development.

MCP PostgreSQL Server

Enables secure read-only access to PostgreSQL databases, allowing users to list tables, query schemas, execute SELECT statements, and inspect table structures through natural language interactions.

Maine Burn Permit MCP Server

Enables checking real-time fire danger levels and automating burn permit applications for Maine locations through the Maine Fire Weather system and official burn permit portal.

Outlook OAuth MCP Server

Enables interaction with Microsoft Outlook for managing emails and calendars through OAuth2 delegated access. It provides a stateless, spec-compliant server that allows users to authenticate and perform mail and calendar operations with their own Microsoft accounts.

mcp-md-vector-search

Một triển khai máy chủ MCP (Model Context Protocol) gọn nhẹ, tận dụng PGLite và pgvector để thực hiện các tìm kiếm tương đồng hiệu quả trên các tài liệu Markdown cục bộ.

MCP_3

Provides paper search and management capabilities along with weather queries, demonstrating MCP integration for AI systems to interact with external resources and tools.

Date MCP Server

Provides AI assistants with accurate current date and day of week information through simple tools for retrieving ISO-formatted dates and day names.

Dot MCP

Enables AI assistants to send text notifications with titles, messages, signatures, icons, and links to Dot e-ink display devices. Supports immediate or scheduled display for proactive AI-to-user notifications.

Codebase Context

Provides AI assistants with real-time visibility into your codebase's internal libraries, team patterns, naming conventions, and usage frequencies to generate code that matches your team's actual practices.

mcp-gitpro

A context-efficient GitHub MCP server designed for AI agents to manage repositories, issues, pull requests, and actions directly via cloud workflows. It focuses on a compact tool surface to minimize context waste while providing comprehensive read and write coverage without requiring a local Git CLI.

Obsidian MCP

Enables AI agents to manage Obsidian vaults through full CRUD operations, wikilink management, and section-level manipulation. It supports frontmatter editing, tag-based searching, and automated link updates to maintain vault integrity.

Z-Image Studio

A local text-to-image generation server that enables AI agents to generate images, manage models, and browse history using the Z-Image-Turbo model. It supports hardware acceleration across NVIDIA, Apple Silicon, and AMD GPUs via multiple MCP transport protocols.

开发 SSE 类型的 MCP 服务

Okay, here's a breakdown of how you might approach building a Claude MCP (presumably meaning "Message Passing") SSE (Server-Sent Events) demo with a server and both CLI (command-line interface) and web clients, along with considerations for Vietnamese translation: **I. Conceptual Overview** * **Purpose:** The goal is to demonstrate real-time communication between a server and multiple clients (CLI and web) using Server-Sent Events. The server will likely be pushing updates or messages to the clients. "Claude MCP" suggests a specific message format or protocol, but without more details, we'll assume a simple text-based message passing. * **SSE (Server-Sent Events):** A one-way communication protocol where the server pushes data to the client over a single HTTP connection. It's simpler than WebSockets for scenarios where the client doesn't need to send data back to the server frequently. * **Server:** Responsible for: * Accepting client connections. * Generating and sending SSE events. * Potentially managing a queue of messages to send. * (If needed) Handling some basic client registration/identification. * **CLI Client:** A command-line application that: * Connects to the SSE server. * Receives and displays SSE events. * **Web Client:** A web page that: * Connects to the SSE server using JavaScript. * Receives and displays SSE events in the browser. **II. Technology Choices (with considerations for Vietnamese)** * **Server-Side Language:** * **Python (with Flask or FastAPI):** Excellent for rapid prototyping and easy to learn. Flask is simpler for basic demos, while FastAPI is faster and offers automatic API documentation. Good library support. * **Node.js (with Express):** JavaScript on the server. Good if you're already comfortable with JavaScript. * **Go:** Fast and efficient, but might be overkill for a simple demo. * **Java (with Spring Boot):** Robust and scalable, but more complex to set up. * **Client-Side (Web):** * **JavaScript:** Essential for handling SSE in the browser. You can use plain JavaScript or a framework like React, Vue, or Angular. For a simple demo, plain JavaScript is fine. * **Client-Side (CLI):** * **Python:** Easy to use with libraries like `requests` to connect to the SSE server. * **Node.js:** If you're using Node.js on the server, you can use it for the CLI client as well. * **Go:** If you're using Go on the server, you can use it for the CLI client as well. * **Vietnamese Translation:** * **Server-Side:** If you need to translate messages *before* sending them to the clients, you'll need a translation library. Consider: * **Google Translate API:** Accurate but requires an API key and can be costly for high volumes. * **DeepL API:** Another excellent translation service, also requiring an API key. * **Open-Source Libraries:** Less accurate but free. Examples include `translate` in Python. * **Client-Side (Web):** You can translate messages in the browser using JavaScript and a translation API or library. This allows for per-user language preferences. * **Client-Side (CLI):** Similar to the web client, you can translate messages in the CLI application. **III. Example Implementation (Python with Flask)** This is a simplified example to illustrate the core concepts. ```python # server.py (Flask) from flask import Flask, Response, stream_with_context import time import random app = Flask(__name__) def generate_sse_events(): """Generates SSE events with random data.""" try: while True: data = f"Data: Hello from the server! Random number: {random.randint(1, 100)}\n\n" yield f"data: {data}" time.sleep(1) # Send an event every 1 second except GeneratorExit: print("Client disconnected") @app.route('/stream') def stream(): return Response(stream_with_context(generate_sse_events()), mimetype='text/event-stream') if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) ``` ```python # cli_client.py (Python) import requests import time def main(): url = 'http://localhost:5000/stream' try: with requests.get(url, stream=True) as response: response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) for line in response.iter_lines(): if line: decoded_line = line.decode('utf-8') if decoded_line.startswith("data:"): message = decoded_line[5:].strip() print(f"Received: {message}") except requests.exceptions.RequestException as e: print(f"Error connecting to server: {e}") if __name__ == "__main__": main() ``` ```html <!-- web_client.html --> <!DOCTYPE html> <html> <head> <title>SSE Demo</title> </head> <body> <h1>SSE Demo</h1> <div id="output"></div> <script> const eventSource = new EventSource('http://localhost:5000/stream'); eventSource.onmessage = (event) => { const outputDiv = document.getElementById('output'); outputDiv.innerHTML += `<p>${event.data}</p>`; }; eventSource.onerror = (error) => { console.error("SSE error:", error); eventSource.close(); // Close the connection on error }; </script> </body> </html> ``` **Explanation:** * **`server.py`:** * Uses Flask to create a web server. * The `/stream` route returns a `Response` with `mimetype='text/event-stream'`, which is crucial for SSE. * `generate_sse_events()` is a generator function that yields SSE-formatted data. Each event is formatted as `data: <your data>\n\n`. The double newline is important to signal the end of the event. * `time.sleep(1)` pauses for 1 second between events. * Error handling is included to catch client disconnections. * **`cli_client.py`:** * Uses the `requests` library to make a streaming GET request to the `/stream` endpoint. * `response.iter_lines()` iterates over the lines of the response. * It decodes the lines from UTF-8 and prints the data. * Includes error handling for connection issues. * **`web_client.html`:** * Creates an `EventSource` object, pointing to the `/stream` endpoint. * The `onmessage` event handler is called whenever the server sends a new event. It appends the data to the `output` div. * The `onerror` event handler logs errors and closes the connection. **How to Run:** 1. **Install Flask and Requests:** ```bash pip install Flask requests ``` 2. **Run the Server:** ```bash python server.py ``` 3. **Run the CLI Client:** ```bash python cli_client.py ``` 4. **Open `web_client.html` in your browser.** You should see the messages from the server appearing in the CLI client and the web page in real-time. **IV. Adding Vietnamese Translation (Example using Google Translate API)** **Important:** You'll need a Google Cloud project and enable the Cloud Translation API. You'll also need to set up authentication (e.g., using a service account). This example assumes you have the `google-cloud-translate` library installed and your credentials configured. ```python # server.py (with translation) from flask import Flask, Response, stream_with_context import time import random from google.cloud import translate_v2 as translate app = Flask(__name__) # Replace with your Google Cloud project ID PROJECT_ID = "your-project-id" translate_client = translate.Client() def translate_text(text, target_language="vi"): """Translates text to the target language using Google Translate API.""" try: translation = translate_client.translate( text, target_language=target_language, source_language="en" ) return translation["translatedText"] except Exception as e: print(f"Translation error: {e}") return text # Return the original text on error def generate_sse_events(): """Generates SSE events with random data, translated to Vietnamese.""" try: while True: english_message = f"Hello from the server! Random number: {random.randint(1, 100)}" vietnamese_message = translate_text(english_message) data = f"Data: {vietnamese_message}\n\n" yield f"data: {data}" time.sleep(1) # Send an event every 1 second except GeneratorExit: print("Client disconnected") @app.route('/stream') def stream(): return Response(stream_with_context(generate_sse_events()), mimetype='text/event-stream') if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) ``` **Key Changes:** * **Import `google.cloud.translate_v2`:** Imports the Google Cloud Translation library. * **`PROJECT_ID`:** Replace `"your-project-id"` with your actual Google Cloud project ID. * **`translate_client`:** Creates a translation client object. * **`translate_text()` function:** * Takes the text to translate and the target language (defaulting to "vi" for Vietnamese). * Calls the Google Translate API to translate the text. * Includes error handling in case the translation fails. * **`generate_sse_events()`:** * Generates the English message. * Calls `translate_text()` to translate it to Vietnamese. * Sends the Vietnamese message as the SSE data. **Important Considerations for Vietnamese:** * **Character Encoding:** Make sure your files are saved in UTF-8 encoding to handle Vietnamese characters correctly. * **Translation Accuracy:** Machine translation is not perfect. Review the translated text carefully, especially if it's for critical applications. Consider using a human translator for important content. * **Context:** The meaning of words can change depending on the context. Provide as much context as possible to the translation API to improve accuracy. * **API Costs:** Be aware of the costs associated with using translation APIs, especially for high volumes of text. **Further Improvements:** * **Message Types:** Instead of just sending text, you could send JSON objects with different message types (e.g., `{"type": "status", "message": "Server is up"}`). The clients could then handle different message types accordingly. * **Client Registration:** Implement a way for clients to register with the server and receive specific messages. * **Error Handling:** Add more robust error handling to both the server and the clients. * **Configuration:** Use environment variables or configuration files to store settings like the server port, translation API key, etc. * **User Interface (Web):** Create a more sophisticated user interface for the web client, perhaps using a framework like React or Vue. * **Logging:** Add logging to the server to track events and errors. * **Authentication/Authorization:** If you need to secure the SSE stream, implement authentication and authorization. This comprehensive guide should give you a solid foundation for building your Claude MCP SSE demo with server and CLI/web clients, including considerations for Vietnamese translation. Remember to adapt the code and technology choices to your specific needs and requirements. Good luck!

Airbnb MCP Server

Enables searching for Airbnb listings and retrieving detailed property information including pricing, amenities, and host details without requiring an API key.

Canvas MCP

Enables AI agents to interact with Canvas LMS and Gradescope, allowing users to query courses, assignments, modules, calendar events, and find relevant resources using natural language.

Jupiter MCP Server

Máy chủ Giao thức Bối cảnh Mô hình cung cấp cho Claude AI quyền truy cập vào API hoán đổi của Jupiter trên Solana.

Canvelete

Enables programmatic design creation and manipulation on the Canvelete platform through AI assistants. Supports design management, canvas element manipulation, template application, asset management, and real-time synchronization with the design editor.

MCPServer

Một máy chủ MCP đơn giản để kích hoạt quy trình làm việc theo kiểu agent.

OpenBudget MCP Server

Provides access to Israel's OpenBudget API, allowing users to query and search various government budget datasets including budget items, contracts, and support payments.

Simple MCP Client

A sample project testing Model Context Protocol (MCP) server and client interaction.

Gmail MCP Server

Enables AI assistants to read unread Gmail messages and compose draft replies while maintaining thread continuity. It includes optional Notion integration to fetch and apply specific style guides for consistent professional communication.

APEX MCP Server

Enables AI assistants to interact with the APEX AI operating system to manage waitlist registrations, request demos, and retrieve detailed documentation. It provides tools for founders to explore the autonomous digital twin platform and its integrations with email, Slack, and CRMs.

eu-regulations

Query 37 EU regulations — from GDPR and AI Act to DORA, MiFID II, eIDAS, Medical Device Regulation, and more — directly from Claude, Cursor, or any MCP-compatible client.

Greenplum MCP Server by CData

Greenplum MCP Server by CData

base-gasless-deploy-mcp

Gasless ERC-20 token deployment on Base using CDP Paymaster. Deploy tokens, verify contracts, check status.