Discover Awesome MCP Servers

kavi-research-assistant-mcp

Enables AI to save, organize, search, and synthesize research materials using a local vector database with support for both OpenAI and Ollama backends.

Laravel Forge MCP Server

A minimalist MCP server that integrates with Laravel Forge, allowing users to manage their Laravel Forge servers, sites, and deployments through AI assistants like Claude Desktop, Windsurf, or Cursor.

facebook-mcp-server

facebook-mcp-server

Remote MCP Server with Bearer Auth

A Cloudflare Workers-based MCP server implementation that supports OAuth/bearer token authentication, enabling secure remote interaction with Model Context Protocol tools.

Google Tasks MCP Server

A Model Context Protocol server that enables AI assistants to manage Google Tasks, including creating, updating, deleting, and searching tasks and task lists via OAuth2 authentication.

WhatsApp MCP Server

Triển khai máy chủ MCP (Message Control Protocol) của WhatsApp

aifais-mcp-server

Headless document processing for AI agents. Invoice extraction, contract analysis, and Dutch business verification. Pay-per-use via X402 on Solana. No API keys needed.

Knowledge Graph Builder

Transforms text or web content into structured knowledge graphs using local AI models with MCP integration for persistent storage in Neo4j and Qdrant.

Data Analysis MCP Server

A simple Model Context Protocol (MCP) server that allows LLMs to create and manage user entries in a JSON file system database.

DatahubMCP

Enables Claude to query MySQL databases and access Google Workspace (Sheets, Forms, Drive) for education program management, with built-in templates for data analysis and report generation.

YApi MCP Server

Enables reading and searching API documentation from YApi instances, allowing AI models to access interface definitions, project API lists, and search through API endpoints using YApi URLs or project IDs.

superman-mcp

A Cursor enhancement plugin that provides multi-session MCP functionality, a membership switcher, and usage billing overview, with no activation code required.

MCP Express Server

A TypeScript-based MCP server template using Express.js and Server-Sent Events, providing example tools for echoing messages, performing calculations, and retrieving server time.

Sirr MCP Server

Provides Claude Code direct access to a Sirr secret vault for reading, pushing, listing, and deleting secrets with expiry constraints. It enables natural language secret management while keeping credentials secure through metadata-only listing and controlled value retrieval.

Affinity MCP Server

Enables AI assistants to control the Affinity creative suite on macOS through natural language, allowing for automated design tasks, UI interaction, and file operations. It leverages AppleScript and System Events to bridge AI commands with professional creative software.

APK Security Guard MCP Suite

Provides a one-stop automated solution for Android APK security analysis by integrating tools like JEB, JADX, APKTOOL, FlowDroid, and MobSF into unified MCP standard API interfaces.

Futuristic Risk Intelligence

Geopolitical conflict risk data for AI agents

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.

Google Calendar MCP Server

Máy chủ Giao thức Bối cảnh Mô hình (MCP) tích hợp với API Lịch Google.

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.

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.

pygdbmi-mcp-server

Enables dynamic debugging with GDB via the MCP protocol, allowing LLMs to execute GDB commands, manage breakpoints, control execution, and inspect program state.

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.

PDF Reader MCP Server (@shtse8/pdf-reader-mcp)

Một máy chủ MCP được xây dựng bằng Node.js/TypeScript cho phép các tác nhân AI đọc an toàn các tệp PDF (cục bộ hoặc URL) và trích xuất văn bản, siêu dữ liệu hoặc số trang. Sử dụng pdf-parse.

Sequential Thinking MCP Server

Enables AI assistants to work through complex problems step-by-step with dynamic thought processes, allowing for revision of previous steps, exploration of alternative approaches, and flexible planning as understanding deepens.

Lightning Tools MCP Server

Cho phép tương tác với địa chỉ Lightning và các công cụ Lightning thông thường thông qua LLM của bạn, cung cấp chức năng Mạng Lightning thông qua ngôn ngữ tự nhiên.

Swagger MCP

Một máy chủ MCP (Model-Controller-Persistence) kết nối với một đặc tả Swagger và giúp một AI xây dựng tất cả các model cần thiết để tạo ra một máy chủ MCP cho dịch vụ đó.