Discover Awesome MCP Servers

MyPostmanServer

A lightweight Node.js-based MCP server that exposes custom tools via HTTP and Server-Sent Events (SSE) for clients like Postman. It allows users to register tools with type-safe validation to establish bidirectional communication with MCP clients.

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.

browser-connect-mcp

Enables AI assistants to connect to browser DevTools and backend debuggers for full-stack debugging, including frontend console, network, performance, and backend log analysis.

MCP Servers Hub

Gương của

PubMed MCP Server

A bridge connecting AI agents to NCBI's PubMed database through the Model Context Protocol, enabling seamless searching, retrieval, and analysis of biomedical literature and data.

Claude MCP x Google Docs

A Model Context Protocol server that enables AI assistants like Claude to read from, append to, and format text in Google Documents programmatically.

MCP Epic Free Games

Provides tools to retrieve information about current and upcoming free games on the Epic Games Store. It allows users to access game details including titles, descriptions, and claim URLs through Model Context Protocol clients.

Memento Protocol Enhanced

An enhanced memory management system that wraps memento-mcp with sophisticated features including protocol enforcement, quality scoring, hybrid search strategies, and synthesis reports. Enables intelligent memory storage, retrieval, and analysis with automatic archival and confidence tracking.

@networkselfmd/mcp

Expose a decentralized P2P agent as an MCP server so Claude Code and other AI tools can discover peers, create groups, and send encrypted messages without intermediaries.

ticktick-mcp-server

A Model Context Protocol (MCP) server that connects AI assistants to your TickTick tasks, enabling task management through natural language.

mcp-pdf-reader

mcp-pdf-reader

pension-pro-mcp

A local, open-source MCP server that provides AI assistants with tools to interact with the PensionPro REST API.

mcp

Máy chủ 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.

@demostudio/mcp-server

MCP server for DemoStudio — lets any MCP-compatible AI assistant generate short-form video ads directly from a conversation.

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.

xiaozhi MCP Aggregate

Aggregates MCP tools for remote control, email, system monitoring, and web search, enabling AI to interact with external systems.

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.

TrendRadar

An AI-powered news and trend aggregator that tracks real-time hot topics and RSS feeds with personalized filtering and summaries. It enables users to monitor global trends and receive automated reports across multiple platforms including WeChat, Telegram, and Slack.

Z3/SMT MCP Server

Enables constraint solving, logical reasoning, and satisfiability checking using the Z3 theorem prover via natural language.

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.

aws-cost-mcp

Enables querying AWS Cost and Usage Report data via Amazon Athena for cost-effective and detailed cost analysis.

gurufocus-mcp

MCP server that exposes GuruFocus financial data to AI assistants via 50+ tools for stocks, gurus, insiders, politicians, and economic data with token-efficient TOON format support.

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

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.