Discover Awesome MCP Servers

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.

mcp-markdown-vault

Headless semantic MCP server for Obsidian, Logseq, Dendron, Foam, and any markdown folder. Features built-in hybrid semantic search, surgical AST editing, template scaffolding, zero-config local embeddings, and workflow tracking.

Clixon MCP Server

Enables AI agents to fetch and query network device configurations from Clixon-based or other RESTCONF-capable devices. It provides tools to extract specific configuration sections, such as interfaces and routing, through the Model Context Protocol.

MCP Server Starter

A TypeScript template for building Model Context Protocol (MCP) servers that enables developers to quickly create custom tools and integrate them with AI platforms like Claude, Cursor, Windsurf, and Cline.

Dell PowerStore MCP Server

Enables AI assistants and automation platforms to interact with Dell PowerStore storage arrays by dynamically generating over 260 tools from OpenAPI specifications. It features a credential-free architecture for secure, multi-host management of storage, networking, and system health.

Hardened Google Workspace MCP

A security-hardened integration that enables Claude to interact with Google Workspace tools like Gmail, Drive, and Docs while preventing data exfiltration by disabling features like email sending and external file sharing. It allows users to safely manage emails, documents, and calendars through natural language without risking unauthorized external communication.

Moralis MCP Server

A TypeScript wrapper for the Moralis REST API that enables interaction with blockchain data through the Model Context Protocol (MCP).

Slack Max API MCP

An MCP server that provides comprehensive access to the Slack Web API, enabling AI agents to search messages, manage channels, and create canvases. It features 13 core tools and over 300 dynamic methods for complete automation of Slack workspace operations.

FeelFit MCP Server

Provides access to body composition data from FeelFit smart scales, including measurements like weight, BMI, and body fat. Supports multi-account management and health goal tracking via the FeelFit Cloud API.

Alfresco MCP Server

Python-based server that provides AI-native access to Alfresco content management operations through the Model Context Protocol, enabling search, document lifecycle management, version control, and other content operations.

Kollektiv

Kollektiv

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.

Figma i18n MCP Server

Extracts text nodes from Figma designs and organizes them into structured JSON for internationalization workflows. It enables users to pull content from specific frames or entire files to automatically generate translation keys.

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.

focus_mcp_data

Plugin truy vấn dữ liệu thông minh của DataFocus hỗ trợ hội thoại nhiều vòng, cung cấp khả năng ChatBI cắm và chạy.

MCP Director

An intelligent orchestration server that routes user requests to appropriate specialized MCP servers and manages complex workflows.

PDF MCP Server

Enables LLMs to read and extract content from PDF files with high-fidelity LaTeX recognition and layout awareness using a Python-based extraction engine. It includes a robust Node.js fallback and supports page range filtering for efficient processing of large documents.

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.

eDistrict Odisha ServicePlus MCP Server

An MCP Server that enables interaction with Odisha's eDistrict services through the API Setu interface, allowing users to access and utilize Odisha government digital services through natural language.

yop-mcp

yop-mcp 是一个专为易宝支付开放平台(YOP)设计的 MCP (Model Context Protocol) Server，提供了一套完整的工具函数，帮助开发者通过AI助手（如Claude、Cursor等）更便捷地获取YOP平台的相关信息、生成密钥对、下载证书等操作。

streamable-mcp-server

A TypeScript boilerplate for building Model Context Protocol servers using the Streamable HTTP transport and session management. It serves as a foundational template with pre-configured development tools to help developers quickly build and deploy streamable MCP services.

geeknews-mcp-server

Dự án này là một máy chủ Giao thức Ngữ cảnh Mô hình (MCP) lấy các bài viết từ GeekNews. Nó được triển khai bằng Python và thực hiện thu thập dữ liệu web bằng BeautifulSoup.

Veeam VBR v13 MCP Server

Enables AI agents to control and monitor Veeam Backup & Replication v13 infrastructure through 328 MCP tools using the official REST API. Supports both stdio mode for local clients like Claude Desktop and streamable HTTP mode for remote integration with platforms like Dify.