Discover Awesome MCP Servers

File Convert MCP Server

File Convert MCP Server

Moralis MCP Server

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

ClickFunnels MCP Framework

Một máy chủ giao thức ngữ cảnh mô hình (Model Context Protocol server) tích hợp ClickFunnels với Claude Desktop, cho phép người dùng liệt kê và truy xuất các phễu bán hàng (funnels) và danh bạ (contacts) từ tài khoản ClickFunnels của họ thông qua ngôn ngữ tự nhiên.

JMeter MCP Server

Một máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol) cho phép các trợ lý AI thực thi và quản lý các bài kiểm tra hiệu năng JMeter thông qua các lệnh bằng ngôn ngữ tự nhiên.

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.

Spring Boot AI MCP Client

Ứng dụng Spring Boot để tương tác với các máy chủ MCP bằng Spring AI Chat Client và Rest Controller.

Paradex Server

Một triển khai máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) cho phép các trợ lý AI tương tác với nền tảng giao dịch hợp đồng tương lai vĩnh cửu Paradex, cho phép truy xuất dữ liệu thị trường, quản lý tài khoản giao dịch, đặt lệnh và theo dõi vị thế.

Axiom MCP Server

Một triển khai máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol) cho Axiom, cho phép các tác nhân AI truy vấn dữ liệu của bạn bằng Ngôn ngữ Xử lý Axiom (APL).

GitHub MCP Bridge

A Model Context Protocol server that enables AI agents to securely access and interact with GitHub Enterprise data, providing access to enterprise users, organizations, emails, and license information.

MCP

Máy chủ MCP

HubSpot CMS MCP Server

An auto-generated Multi-Agent Conversation Protocol Server for interacting with HubSpot CMS API, allowing AI agents to manage HubSpot content management system through natural language commands.

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.

YARR Media Stack MCP Server

Một máy chủ Giao thức Bối cảnh Mô hình toàn diện, kết nối các LLM (Mô hình Ngôn ngữ Lớn) với các dịch vụ media tự lưu trữ, cho phép điều khiển các chương trình TV, phim, tải xuống và thông báo bằng ngôn ngữ tự nhiên, đồng thời vẫn duy trì quyền truy cập API truyền thống.

bonk-mcp MCP Server

Implements Solana blockchain functionality for the LetsBonk launchpad, enabling users to launch and trade tokens on letsbonk.fun.

Mastercard BIN Table MCP Server

An MCP server that provides access to Mastercard's BIN Table Resource API, allowing users to look up and interact with Bank Identification Number data through natural language queries.

MCP Protocol Validator

Bộ kiểm thử để xác thực các triển khai máy chủ MCP dựa trên đặc tả giao thức MCP mở. Giúp các nhà phát triển đảm bảo tuân thủ giao thức và khả năng tương tác.

SuperiorAPIs MCP Server Tool

Một máy chủ MCP dựa trên Python, tự động lấy các định nghĩa plugin từ SuperiorAPIs và tự động tạo các hàm công cụ dựa trên lược đồ OpenAPI, cho phép tích hợp liền mạch với các dịch vụ API.

YouTube MCP Server

Một máy chủ cho phép tương tác với dữ liệu YouTube thông qua Giao thức Ngữ cảnh Mô hình (Model Context Protocol), cho phép người dùng tìm kiếm video, truy xuất thông tin chi tiết về video/kênh và lấy bình luận.

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

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.

MCP AI Service Platform

A powerful AI service platform that provides complete MCP tool calling capabilities and RAG knowledge base functionality, enabling users to connect to multiple MCP servers and perform intelligent document search.

Remote MCP Server Authless

A deployable MCP server on Cloudflare Workers that provides tools without requiring authentication, allowing users to connect from Cloudflare AI Playground or Claude Desktop.

MCP Agent Platform

Một hệ thống tương tác người-máy đa tác tử cho phép tương tác tự nhiên thông qua các khả năng tích hợp nhận dạng hình ảnh, nhận dạng giọng nói và tổng hợp giọng nói.

LlamaCloud MCP Server

Một máy chủ MCP cục bộ tích hợp với Claude Desktop, cho phép các khả năng RAG để cung cấp cho Claude thông tin riêng tư cập nhật từ các chỉ mục LlamaCloud tùy chỉnh.