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

Sebuah server MCP yang melacak model AI, dataset, dan ruang (spaces) yang sedang tren di 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

Implementasi server MCP ringan yang memanfaatkan PGLite dan pgvector untuk melakukan pencarian kesamaan yang efisien pada dokumen Markdown lokal menggunakan Model Context Protocol (MCP).

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 creating a Claude-powered demo using Server-Sent Events (SSE) with both a command-line interface (CLI) and a web client, along with considerations for Indonesian speakers: **Overall Architecture** The system will consist of three main parts: 1. **Claude Server (Python/Node.js):** This is the core. It receives requests, interacts with the Claude API, and streams the responses back to the clients using SSE. 2. **CLI Client (Python/Node.js/Go):** A command-line tool that sends prompts to the server and displays the streaming responses. 3. **Web Client (HTML/JavaScript):** A web page that allows users to enter prompts and see the streaming responses in their browser. **1. Claude Server (Python - Example using Flask and `anthropic`)** ```python from flask import Flask, Response, request, jsonify from flask_cors import CORS import anthropic import os app = Flask(__name__) CORS(app) # Enable CORS for cross-origin requests (important for web client) # Replace with your actual Claude API key ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY") if not ANTHROPIC_API_KEY: raise ValueError("Please set the ANTHROPIC_API_KEY environment variable.") client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY) MODEL_NAME = "claude-3-opus-20240229" # Or another Claude model @app.route('/stream') def stream(): prompt = request.args.get('prompt') if not prompt: return "Error: No prompt provided", 400 def generate(): try: with client.messages.stream( model=MODEL_NAME, max_tokens=1024, messages=[{"role": "user", "content": prompt}], ) as response: for event in response.text_stream: yield f"data: {event}\n\n" # SSE format except Exception as e: yield f"data: Error: {str(e)}\n\n" return Response(generate(), mimetype='text/event-stream') @app.route('/health') def health_check(): return jsonify({"status": "ok"}), 200 if __name__ == '__main__': app.run(debug=True, port=5000) ``` Key improvements and explanations: * **Error Handling:** Includes a `try...except` block to catch potential errors during the Claude API call and stream an error message to the client. This is crucial for a robust demo. * **Environment Variable for API Key:** Uses `os.environ.get("ANTHROPIC_API_KEY")` to retrieve the API key from an environment variable. This is *much* safer than hardcoding the key in your code. **Never commit your API key to a public repository!** * **CORS:** `CORS(app)` enables Cross-Origin Resource Sharing. This is *essential* if your web client is running on a different domain (e.g., `localhost:3000`) than your server (e.g., `localhost:5000`). Without CORS, the browser will block the web client from making requests to the server. * **SSE Formatting:** The `generate()` function now correctly formats the data for SSE: `yield f"data: {event}\n\n"`. Each event *must* be prefixed with `data: ` and followed by two newlines (`\n\n`). * **Health Check:** Added a `/health` endpoint for basic monitoring. * **Model Selection:** Uses `MODEL_NAME = "claude-3-opus-20240229"` to specify the Claude model. You can change this to another model if needed. * **Streaming:** Uses `client.messages.stream` for streaming responses. * **`max_tokens`:** Sets a `max_tokens` limit to prevent excessively long responses. Adjust as needed. **To run this server:** 1. **Install dependencies:** `pip install flask flask-cors anthropic` 2. **Set the API key:** `export ANTHROPIC_API_KEY="YOUR_API_KEY"` (replace with your actual key) 3. **Run the server:** `python your_server_file.py` **2. CLI Client (Python)** ```python import requests import argparse def main(): parser = argparse.ArgumentParser(description="Claude SSE CLI Client") parser.add_argument("prompt", help="The prompt to send to Claude") args = parser.parse_args() url = f"http://localhost:5000/stream?prompt={args.prompt}" # Adjust URL if needed try: response = requests.get(url, stream=True) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) for line in response.iter_lines(): if line: # SSE data format: data: <message>\n\n if line.startswith(b'data: '): message = line[len(b'data: '):].decode('utf-8').strip() print(message, end='', flush=True) # Print without newline, flush immediately print() # Add a newline at the end of the response except requests.exceptions.RequestException as e: print(f"Error: {e}") if __name__ == "__main__": main() ``` Key improvements and explanations: * **Error Handling:** Includes `try...except` to catch network errors and HTTP errors. `response.raise_for_status()` is important to check for non-200 status codes. * **Argument Parsing:** Uses `argparse` to take the prompt as a command-line argument. This makes the CLI much more user-friendly. * **Streaming:** Uses `requests.get(url, stream=True)` to enable streaming. * **SSE Parsing:** Correctly parses the SSE data format (`data: <message>\n\n`). It checks if the line starts with `b'data: '` and extracts the message. * **Decoding:** Decodes the message from bytes to a string using `.decode('utf-8')`. * **`flush=True`:** `print(message, end='', flush=True)` is crucial for streaming output to the console in real-time. `flush=True` forces the output to be written immediately, rather than being buffered. * **Newline:** Adds a newline character (`print()`) at the end of the response to ensure the next command prompt appears on a new line. **To run this CLI client:** 1. **Install dependencies:** `pip install requests` 2. **Run the client:** `python your_cli_file.py "Write a short poem about Jakarta."` (replace with your prompt) **3. Web Client (HTML/JavaScript)** ```html <!DOCTYPE html> <html> <head> <title>Claude SSE Demo</title> </head> <body> <h1>Claude SSE Demo</h1> <label for="prompt">Enter your prompt:</label><br> <input type="text" id="prompt" name="prompt" size="80"><br><br> <button onclick="sendPrompt()">Send</button><br><br> <div id="response"></div> <script> function sendPrompt() { const prompt = document.getElementById("prompt").value; const responseDiv = document.getElementById("response"); responseDiv.innerHTML = ""; // Clear previous response const eventSource = new EventSource(`http://localhost:5000/stream?prompt=${encodeURIComponent(prompt)}`); // Adjust URL if needed eventSource.onmessage = function(event) { responseDiv.innerHTML += event.data; }; eventSource.onerror = function(error) { console.error("SSE error:", error); responseDiv.innerHTML += "<p>Error: " + error + "</p>"; eventSource.close(); // Close the connection on error }; } </script> </body> </html> ``` Key improvements and explanations: * **`encodeURIComponent()`:** Uses `encodeURIComponent(prompt)` to properly encode the prompt in the URL. This is *essential* to handle special characters in the prompt (e.g., spaces, question marks, etc.). Without encoding, the URL might be malformed, and the server won't receive the prompt correctly. * **Error Handling:** Includes an `onerror` handler to catch SSE errors and display them in the `responseDiv`. It also closes the `EventSource` connection on error to prevent further attempts to connect. * **Clearing Previous Response:** `responseDiv.innerHTML = "";` clears the previous response before starting a new stream. This prevents the responses from accumulating. * **Concatenation:** Uses `responseDiv.innerHTML += event.data;` to append the new data to the existing content of the `responseDiv`. This is how you build up the streaming response. * **Closing Connection on Error:** `eventSource.close()` closes the SSE connection when an error occurs. This prevents the client from continuously trying to reconnect after an error. **To run this web client:** 1. Save the code as an HTML file (e.g., `index.html`). 2. Open the HTML file in your browser. (You can usually just double-click the file.) **Important Considerations for Indonesian Speakers:** * **Prompting in Indonesian:** The most direct way to support Indonesian is to allow users to enter prompts in Indonesian. Claude models are generally multilingual, but performance may vary. Experiment with different prompts to see how well Claude understands and responds in Indonesian. For example: * "Tulis puisi pendek tentang Jakarta dalam bahasa Indonesia." (Write a short poem about Jakarta in Indonesian.) * "Jelaskan konsep kecerdasan buatan (AI) dalam bahasa Indonesia sederhana." (Explain the concept of artificial intelligence (AI) in simple Indonesian.) * **Translation (Optional):** If you want to ensure the best possible results, you could translate the Indonesian prompt to English before sending it to Claude, and then translate the response back to Indonesian. This would add complexity but could improve accuracy. You could use a translation API like Google Translate API or DeepL API. However, for a demo, starting with direct Indonesian prompting is often sufficient. * **UI Localization (Web Client):** For a more polished experience, you could localize the web client's user interface (labels, buttons, etc.) into Indonesian. This would involve creating a separate Indonesian version of the HTML file or using a JavaScript library for internationalization (i18n). * **Testing:** Thoroughly test the system with Indonesian prompts to identify any issues with encoding, character support, or Claude's understanding of the language. * **Example Indonesian Prompts:** Provide example prompts in Indonesian to guide users. * **Font Support:** Ensure that the fonts used in the web client support Indonesian characters correctly. **Example Usage (after running the server):** * **CLI:** `python your_cli_file.py "Write a short story about a cat in Jakarta."` * **Web Client:** Open `index.html` in your browser, enter a prompt in the text box, and click "Send". **Key Improvements Summary:** * **Robust Error Handling:** Includes error handling in both the server and the clients to gracefully handle network issues, API errors, and invalid input. * **Secure API Key Handling:** Uses environment variables to store the API key, preventing it from being hardcoded in the code. * **Proper SSE Formatting and Parsing:** Ensures that the data is correctly formatted for SSE and that the clients correctly parse the SSE data. * **Real-time Streaming:** Uses `flush=True` in the CLI client and `responseDiv.innerHTML += event.data;` in the web client to provide a real-time streaming experience. * **CORS Enabled:** Enables CORS on the server to allow cross-origin requests from the web client. * **URL Encoding:** Uses `encodeURIComponent()` in the web client to properly encode the prompt in the URL. * **Clear Previous Response:** Clears the previous response in the web client before starting a new stream. * **Closing Connection on Error:** Closes the SSE connection in the web client when an error occurs. * **Argument Parsing:** Uses `argparse` in the CLI client to take the prompt as a command-line argument. This comprehensive example provides a solid foundation for building your Claude SSE demo. Remember to replace `"YOUR_API_KEY"` with your actual Claude API key and adjust the URLs and model names as needed. 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

Server Protokol Konteks Model yang menyediakan Claude AI dengan akses ke API swap Jupiter di 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

Server MCP sederhana untuk mengaktifkan alur kerja agentik

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

Proyek contoh yang menguji interaksi server dan klien Model Context Protocol (MCP).

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.