Discover Awesome MCP Servers

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol (MCP) servers using TypeScript SDK, with example calculator and greeting tools, and resource management capabilities.

Vega-Lite MCP Server

Provides AI assistants with access to Vega-Lite documentation, visualization examples, and specification validation tools. Enables searching docs, retrieving examples by category, validating JSON specs, and accessing schema information for creating data visualizations.

Claude Kubernetes MCP Server

Server Protokol Konteks Model (MCP) untuk API Kubernetes.

Meta-Dynamic MCP Server

Aggregates multiple remote Model Context Protocol endpoints and exposes them through a unified SSE interface, allowing an LLM client to interact with specialized servers without configuration changes.

MCP Headless Gmail Server

Server tanpa kepala yang memungkinkan membaca dan mengirim email Gmail melalui panggilan API tanpa memerlukan kredensial lokal atau akses browser, dirancang untuk dijalankan dari jarak jauh di lingkungan container.

MCP Audio Transcriber

A portable, Dockerized Python tool that implements Model Context Protocol for audio transcription using Whisper models, featuring both CLI and web UI interfaces for converting audio files to JSON transcriptions.

BrowserLoop

A Model Context Protocol (MCP) server for taking screenshots of web pages using Playwright, allowing AI agents to automatically capture and analyze screenshots for UI verification or other tasks.

Gemini MCP Server

A Python-based MCP server that enables integration of Gemini AI models with MCP-compatible applications like Cursor/Claude, allowing for interaction with Gemini APIs through the Model Context Protocol.

Bloodhound-MCP

Here are a few possible translations, depending on the specific context you're looking for: **More literal translations:** * **Server MCP untuk API Bloodhound:** This is a fairly direct translation and understandable. * **Server MCP untuk API BloodHound:** Keeping "BloodHound" capitalized is also common. **More descriptive translations (if you want to be clearer about the purpose):** * **Server MCP untuk mengakses API BloodHound:** (Server MCP for accessing the BloodHound API) * **Server MCP yang menggunakan API BloodHound:** (MCP server that uses the BloodHound API) * **Implementasi server MCP untuk API BloodHound:** (MCP server implementation for the BloodHound API) - This is more technical. **Which translation is best depends on the context. If you're just talking about a server, the first two options are fine. If you're describing what the server *does*, the more descriptive options are better.**

API Registry MCP Server

Enables discovery, registration, and management of external API endpoints through natural language, supporting multiple authentication methods (public, API key, bearer token) with automatic endpoint testing and documentation parsing.

Example MCP Server

A simple demonstration MCP server that provides a basic 'say_hello' tool for greeting users by name, serving as a template for building MCP servers with TypeScript.

MCP Framework

Kerangka kerja TypeScript untuk membangun server Model Context Protocol (MCP) dengan penemuan dan pemuatan alat, sumber daya, dan perintah secara otomatis.

Model Context Provider (MCP) Server

Memfasilitasi interaksi yang lebih baik dengan model bahasa besar (LLM) dengan menyediakan manajemen konteks yang cerdas, integrasi alat, dan koordinasi model AI multi-penyedia untuk alur kerja berbasis AI yang efisien.

Customer Registration MCP Server

Enables creating and managing customer records via an external API with Bearer token authentication, supporting required fields (name, email, phone) and extensive optional data including addresses, UTM parameters, and tags.

Remote MCP Server (Authless)

Enables deployment of MCP servers on Cloudflare Workers without authentication requirements. Allows users to create custom tools accessible via remote MCP clients like Claude Desktop or Cloudflare AI Playground.

GABI MCP Server

An MCP server that exposes GABI functionality, allowing users to run queries against a target endpoint with proper authentication.

hyperspell-mcp

Hyperspell memungkinkan Anda menghubungkan aplikasi bertenaga AI ke data apa pun — ini adalah Plaid untuk data tidak terstruktur dan semi-terstruktur.

Bing Flights MCP Server

Enables flight search and price comparison by scraping flight information from Bing Flights. Supports one-way and round-trip searches with customizable passenger counts, cabin classes, and booking details.

Webex Messaging MCP Server

Enables AI assistants to interact with Cisco Webex messaging through 52 comprehensive tools covering messages, rooms, teams, people management, webhooks, and enterprise features. Supports both personal and enterprise Webex environments with complete API coverage for messaging operations.

Calibre RAG MCP Server

Enables semantic search and contextual conversations with your Calibre ebook library using vector-based RAG technology. Supports project-based organization, multi-format book processing, and OCR capabilities for enhanced content extraction and retrieval.

MCP TypeScript Template

A TypeScript template for building remote Model Context Protocol (MCP) servers with modern tooling including Vite, Express, ESLint, Prettier, and Docker support. Includes an example echo tool to demonstrate MCP tool implementation patterns.

mcp

Server MCP

Model Coupling Platform Server

A FastAPI-based JSON-RPC 2.0 server implementation that enables users to work with HDF5 files, submit Slurm jobs, retrieve CPU information, and visualize CSV data through standardized API endpoints.

开发 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!

Roblox Studio MCP Assistant

Enables AI assistants to interact with Roblox Studio in real-time, allowing creation and manipulation of game objects through natural language commands via an HTTP-based plugin system.

Jupiter MCP Server

Server Protokol Konteks Model yang menyediakan Claude AI dengan akses ke API swap Jupiter di Solana.