Discover Awesome MCP Servers

Tasks MCP Server

A task management MCP server that provides tools to create, list, complete, and delete tasks using pluggable storage backends. It enables users to interact with their task lists through natural language using MCP-compatible clients like Claude Desktop.

Edgar MCP Service

Enables deep analysis of SEC EDGAR filings through universal company search, document content extraction, and advanced filing search capabilities. Provides AI-ready access to business descriptions, risk factors, financial statements, and full-text search across any public company's SEC documents.

Searchfox MCP Server

Provides access to Mozilla's Searchfox code search service, enabling AI assistants to search through Mozilla's codebases and retrieve file contents from repositories like mozilla-central, autoland, and ESR branches.

esa-mcp-server

Cho phép tương tác với API của esa.io thông qua Giao thức Ngữ cảnh Mô hình (Model Context Protocol), hỗ trợ tìm kiếm và truy xuất bài viết với giao diện MCP tuân thủ.

offer-quest mcp

A fast, secure, and LLM-friendly Model Context Protocol (MCP) server that scrapes job listings from major platforms (LinkedIn, Indeed, Google) and converts them into structured Markdown format.

ZenTao MCP Server

Enables LLMs to interact with ZenTao project management system, supporting project and task management operations including creating, querying, and updating projects and tasks through natural language.

Debugg AI MCP

Debugg AI MCP

Gradescope MCP Server

An MCP server that enables AI assistants to interact with Gradescope for course management, grading workflows, and regrade reviews. It provides instructors and TAs with tools for assignment management, individual or batch grading, and rubric manipulation.

MCP Integration Server

Enables agents to interact with Salesforce, Atlassian (Jira/Confluence), and Supabase through standardized tools and resources. Provides both read-only access for querying data and write operations for managing records across these enterprise platforms.

Dify MCP Server

Một triển khai máy chủ cho phép tích hợp quy trình làm việc của Dify với Giao thức Ngữ cảnh Mô hình (Model Context Protocol - MCP), cho phép người dùng truy cập các khả năng của Dify thông qua các ứng dụng khách tương thích với MCP.

Mapbox MCP Server

Enables integration with Mapbox API for navigation and location services, including directions between coordinates or places, travel time/distance matrices, and geocoding to search places and convert addresses to coordinates.

YouTube Data API MCP Server

A FastAPI server that enables interaction with YouTube's data through search, video details, channel information, and comment retrieval endpoints.

AlibabaCloud DevOps MCP Server

Enables AI assistants to interact with Alibaba Cloud Yunxiao platform for managing code repositories, work items, pipelines, packages, and application delivery. Supports project collaboration, code reviews, and automated deployment workflows.

MCP Search Analytics Server

A Model Context Protocol server that provides unified access to Google Analytics 4 and Google Search Console data through real-time analytics queries.

Flutter MCP Server

A TypeScript-based MCP server that implements a simple notes system, enabling users to manage text notes with creation and summarization functionalities through structured prompts.

Waldzell Metagames Server

Provides access to 27+ structured problem-solving frameworks and game-theoretic workflows for software development, project management, and operations research. Helps prevent analysis paralysis and scope creep by transforming open-ended challenges into systematic, time-boxed approaches with clear decision gates.

MCP Local LLM Server

A privacy-first MCP server that provides local LLM-enhanced tools for code analysis, security scanning, and automated task execution using backends like Ollama and LM Studio. It enables symbol-aware code reviews and workspace exploration while ensuring that all code and analysis remain strictly on your local machine.

qring-mcp

A quantum-inspired secret manager that anchors API keys to your OS-native vault, preventing plaintext .env leaks. It empowers AI agents with advanced mechanics like multi-environment superposition, linked entanglements, and ephemeral in-memory tunneling.

Fetch MCP Server

Cung cấp chức năng tìm nạp và chuyển đổi nội dung web ở nhiều định dạng khác nhau (HTML, JSON, văn bản thuần túy và Markdown) thông qua các lệnh gọi API đơn giản.

inked

inked

Logic-Thinking MCP Server

Enables formal logical reasoning, mathematical problem-solving, and proof construction across 11 logic systems including propositional, predicate, modal, fuzzy, and probabilistic logic. Integrates external solvers (Z3, ProbLog, Clingo) for advanced reasoning, with support for proof storage, argument scoring, and cross-system translation.

AI Agent with MCP

Okay, here's a basic outline and code snippets to help you create your first MCP (Model Context Protocol) server in a Playground environment. Keep in mind that MCP is a relatively new and evolving protocol, so the specific libraries and implementations might change. This example focuses on a simplified, conceptual approach. **Conceptual Overview** 1. **What is MCP?** MCP is a protocol designed to facilitate communication between a client (e.g., an application needing a model) and a server (hosting the model). It aims to standardize how models are accessed and used, especially in distributed environments. It handles things like: * Model discovery * Model loading/unloading * Model execution (inference) * Data serialization/deserialization 2. **Simplified Approach:** For a Playground, we'll create a very basic server that: * Hosts a simple "model" (in this case, a function that adds two numbers). * Listens for requests on a specific port. * Receives data (two numbers) from a client. * Executes the "model" (adds the numbers). * Sends the result back to the client. **Code (Python - using `socket` for simplicity)** This example uses Python's built-in `socket` library for network communication. While not a full-fledged MCP implementation, it demonstrates the core concepts. ```python import socket import json # --- Model Definition (Simple Addition) --- def add_numbers(a, b): """Our "model" - adds two numbers.""" return a + b # --- Server Configuration --- HOST = '127.0.0.1' # Localhost PORT = 65432 # Port to listen on (choose a free port) # --- Server Logic --- def run_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}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive data (up to 1024 bytes) if not data: break try: # Attempt to decode the data as JSON received_data = json.loads(data.decode('utf-8')) # Check if the data contains 'a' and 'b' keys if 'a' in received_data and 'b' in received_data: a = received_data['a'] b = received_data['b'] # Execute the "model" result = add_numbers(a, b) # Prepare the response response = {'result': result} response_data = json.dumps(response).encode('utf-8') # Send the response back to the client conn.sendall(response_data) print(f"Sent result: {result}") else: error_message = {'error': 'Invalid input format. Expected JSON with keys "a" and "b".'} conn.sendall(json.dumps(error_message).encode('utf-8')) print("Invalid input received.") except json.JSONDecodeError: error_message = {'error': 'Invalid JSON format.'} conn.sendall(json.dumps(error_message).encode('utf-8')) print("Invalid JSON received.") except Exception as e: error_message = {'error': str(e)} conn.sendall(json.dumps(error_message).encode('utf-8')) print(f"Error processing request: {e}") if __name__ == "__main__": run_server() ``` **Explanation:** * **`add_numbers(a, b)`:** This is our placeholder "model." In a real MCP server, this would be a much more complex model (e.g., a TensorFlow or PyTorch model). * **`HOST` and `PORT`:** Configure the server's address and port. `127.0.0.1` is localhost (your own machine). Choose a port that's not commonly used. * **`socket.socket(...)`:** Creates a socket object, which is the endpoint for network communication. * **`s.bind((HOST, PORT))`:** Binds the socket to the specified address and port. * **`s.listen()`:** Starts listening for incoming connections. * **`s.accept()`:** Accepts a connection from a client. This blocks until a client connects. * **`conn.recv(1024)`:** Receives data from the client (up to 1024 bytes at a time). * **`json.loads(data.decode('utf-8'))`:** Decodes the received data, assuming it's a JSON string. We're expecting the client to send a JSON object like `{"a": 5, "b": 3}`. * **`add_numbers(a, b)`:** Executes the "model" with the received data. * **`json.dumps(response).encode('utf-8')`:** Encodes the result back into a JSON string and then encodes it into bytes for sending over the network. * **`conn.sendall(response_data)`:** Sends the response back to the client. * **Error Handling:** Includes `try...except` blocks to handle potential errors like invalid JSON or other exceptions during processing. Sends error messages back to the client. **Client Code (Python)** ```python import socket import json HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) # Prepare the data to send (as a JSON string) data = {'a': 10, 'b': 5} json_data = json.dumps(data).encode('utf-8') s.sendall(json_data) print(f"Sent: {data}") received_data = s.recv(1024) try: response = json.loads(received_data.decode('utf-8')) print(f"Received: {response}") if 'result' in response: print(f"Result: {response['result']}") elif 'error' in response: print(f"Error: {response['error']}") else: print("Unexpected response format.") except json.JSONDecodeError: print("Received invalid JSON from server.") ``` **Explanation of Client Code:** * **`s.connect((HOST, PORT))`:** Connects to the server. * **`data = {'a': 10, 'b': 5}`:** Creates a dictionary containing the input data for the "model." * **`json.dumps(data).encode('utf-8')`:** Converts the dictionary to a JSON string and then encodes it into bytes. * **`s.sendall(json_data)`:** Sends the data to the server. * **`s.recv(1024)`:** Receives the response from the server. * **`json.loads(received_data.decode('utf-8'))`:** Decodes the JSON response. * **Prints the result or error message.** **How to Run in a Playground (e.g., Google Colab, Jupyter Notebook):** 1. **Run the Server Code:** Copy and paste the server code into a cell in your Playground and run it. It will start listening for connections. **Important:** The server will block at `s.accept()` until a client connects. 2. **Run the Client Code:** Copy and paste the client code into *another* cell in your Playground and run it. The client will connect to the server, send the data, and receive the result. **Important Considerations and Next Steps:** * **Threading/Asynchronous Operations:** The server code above is single-threaded. It can only handle one client at a time. For a real-world MCP server, you'll need to use threading or asynchronous programming (e.g., `asyncio` in Python) to handle multiple concurrent requests. * **Serialization:** MCP often uses more efficient serialization formats than JSON (e.g., Protocol Buffers, Apache Arrow). Consider using these for better performance. * **Model Management:** A real MCP server needs to handle model loading, unloading, versioning, and potentially model discovery. * **Security:** For production environments, you'll need to add security measures (e.g., authentication, authorization, encryption). * **Error Handling:** Implement robust error handling and logging. * **MCP Libraries:** Look for existing MCP libraries or frameworks in your language of choice. These will provide a more complete and standardized implementation of the protocol. However, as of late 2024, MCP is still relatively new, so library support might be limited. You might need to build parts of the protocol yourself. * **gRPC:** gRPC is a popular framework for building high-performance, language-agnostic RPC (Remote Procedure Call) systems. While not strictly MCP, it shares many of the same goals and can be a good alternative or a building block for an MCP-like system. **Example Output (in the Playground):** **Server Output:** ``` Server listening on 127.0.0.1:65432 Connected by ('127.0.0.1', <some_port_number>) Sent result: 15 ``` **Client Output:** ``` Sent: {'a': 10, 'b': 5} Received: {'result': 15} Result: 15 ``` This basic example provides a starting point for understanding the core concepts of an MCP server. To build a production-ready MCP server, you'll need to address the considerations mentioned above and potentially use more specialized libraries and frameworks. Remember to install any necessary libraries (like `protobuf` if you choose to use Protocol Buffers) using `pip install <library_name>` in your Playground environment.

protonmail-mcp

Enables AI clients to interact with ProtonMail accounts through the Proton Bridge using SMTP and IMAP protocols. Provides email management capabilities via secure local bridge connections.

Link Scan MCP Server

Automatically scans and summarizes video links (YouTube, Instagram Reels) and text links (blogs, articles) using AI-powered transcription and summarization. Provides concise 3-sentence summaries without requiring API keys.

YouTube Comments MCP Server

Enables fetching and analyzing YouTube video comments and replies through the YouTube Data API. Supports sorting by relevance or time and returns structured JSON data for comment analysis, summarization, and translation tasks.

Wassenger WhatsApp MCP Server

Enables AI assistants to send messages, analyze conversations, manage chats and groups, schedule messages, and automate WhatsApp business operations through the Wassenger API using natural language commands.

lastminutedeals-api

Real-time last-minute tour and activity booking across 18 suppliers in 15 countries via the OCTO open standard. Search available slots, create Stripe checkout sessions, and check booking status.

MCP Calculator Streamable HTTP

Provides basic arithmetic calculation tools through an HTTP-accessible MCP server. Supports mathematical operations like addition with streamable responses for integration with MCP clients.