Discover Awesome MCP Servers

Docker MCP Server

Enables AI assistants to manage Docker containers, images, networks, volumes, and Compose services through the Model Context Protocol. It supports system operations, command execution within containers, and integration with Docker Hub and GitHub Container Registry.

DrissionPage MCP Server

A professional browser automation server that enables MCP clients to perform structured web navigation, element interaction, and data extraction using the DrissionPage framework. It features 14 deterministic tools optimized for LLMs to automate web workflows efficiently without relying on vision-based models.

n8n MCP Server

Enables Large Language Models to interact with n8n automation instances through the Model Context Protocol. Supports workflow management, execution, credentials handling, and security audits through natural language commands.

Simple MCP Server

A TypeScript-based MCP server that enables Claude Desktop to perform file operations and retrieve system information, with built-in security features that restrict access to safe directories only.

N Lobby MCP Server

A Model Context Protocol server that provides secure access to N Lobby school portal data including announcements, schedules, and learning resources through browser-based authentication.

Remote MCP Server (Authless)

A template for deploying authentication-free MCP servers on Cloudflare Workers. Enables connecting remote MCP tools to clients like Claude Desktop or the Cloudflare AI Playground via SSE.

Terra Config MCP Server

Enables LLMs to configure the TerraAPI dashboard by managing health and fitness integrations, destinations, and provider credentials. It allows users to programmatically interact with the Terra ecosystem to handle developer settings and data source configurations.

UnknownCheats MCP

Enables programmatic interaction with the UnknownCheats forum by bypassing Cloudflare protection using a headed Chrome browser. Supports searching forums, reading threaded discussions with pagination, extracting code blocks in multiple languages, and maintaining persistent authenticated sessions.

op-mcp

An MCP server that provides secure access to 1Password secrets and item management through the 1Password CLI. It enables MCP clients like Claude and Cursor to read, create, edit, and delete password vault items with biometric authentication handled by the 1Password desktop app.

Search Intent MCP

Một dịch vụ dựa trên MCP (Multi-Channel Platform - Nền tảng Đa kênh) phân tích các từ khóa tìm kiếm của người dùng để xác định ý định của họ, cung cấp phân loại, lý giải, tham khảo và đề xuất tìm kiếm để hỗ trợ phân tích SEO.

Local Filesystem MCP Server

Enables exploration and search of local filesystems using glob pattern matching to find files and grep to search for text patterns within files.

capsule-mcp-server

Capsule MCP server gives your AI agent the ability to safely run untrusted Python and JavaScript code in a secure WebAssembly sandbox.

Local RAG

Privacy-first local document search using semantic search. Runs entirely on your machine with no cloud services, supporting PDF, DOCX, TXT, and Markdown files.

aws-pricing-mcp

aws-pricing-mcp

MCP Chat with Claude

Okay, here's a TypeScript example for a web application (acting as the host) connecting to a Node.js MCP (Microcontroller Platform) server. This example focuses on the core communication setup using WebSockets. I'll break it down into two parts: **1. Node.js MCP Server (Server-Side - `mcp-server.ts`)** ```typescript // mcp-server.ts import WebSocket, { WebSocketServer } from 'ws'; const wss = new WebSocketServer({ port: 8080 }); // Choose your port console.log("MCP Server started on port 8080"); wss.on('connection', ws => { console.log('Client connected'); ws.on('message', message => { console.log(`Received: ${message}`); // Process the message from the client (web app) try { const data = JSON.parse(message.toString()); // Assuming JSON format // Example: Handle different message types if (data.type === 'command') { console.log(`Executing command: ${data.command}`); // Here you would interact with your microcontroller or other hardware // (This is where the "MCP" part comes in) // For example, you might send a serial command, control GPIO pins, etc. // Simulate a response from the microcontroller setTimeout(() => { ws.send(JSON.stringify({ type: 'response', status: 'success', result: `Command ${data.command} executed.` })); }, 500); // Simulate a delay } else if (data.type === 'sensor_request') { // Simulate reading sensor data const sensorValue = Math.random() * 100; // Replace with actual sensor reading ws.send(JSON.stringify({ type: 'sensor_data', value: sensorValue })); } else { console.log("Unknown message type"); ws.send(JSON.stringify({ type: 'error', message: 'Unknown message type' })); } } catch (error) { console.error("Error processing message:", error); ws.send(JSON.stringify({ type: 'error', message: 'Invalid JSON' })); } }); ws.on('close', () => { console.log('Client disconnected'); }); ws.on('error', error => { console.error('WebSocket error:', error); }); // Send a welcome message to the client ws.send(JSON.stringify({ type: 'status', message: 'Connected to MCP Server' })); }); ``` **Explanation (Server):** 1. **Imports:** Uses the `ws` library for WebSocket functionality. Install it: `npm install ws --save` and `@types/ws` for typescript support. 2. **WebSocket Server:** Creates a WebSocket server listening on port 8080 (you can change this). 3. **`connection` Event:** This event fires when a client (your web app) connects to the server. 4. **`message` Event:** This event fires when the server receives a message from a client. * **JSON Parsing:** The example assumes messages are sent as JSON. It parses the incoming message using `JSON.parse()`. Error handling is included in case the JSON is invalid. * **Message Handling:** The code demonstrates how to handle different types of messages (e.g., `command`, `sensor_request`). This is crucial for a real MCP application. You'll need to adapt this section to match the specific commands and data your microcontroller or hardware supports. * **MCP Logic:** The `// Here you would interact with your microcontroller...` comment is the most important part. This is where you'd use libraries like `serialport` (for serial communication), `rpio` (for Raspberry Pi GPIO control), or other libraries to interact with your hardware. *This part is highly dependent on your specific hardware setup.* * **Responses:** The server sends responses back to the client, also in JSON format. This allows the web app to know the status of commands and receive sensor data. 5. **`close` and `error` Events:** These events handle client disconnections and WebSocket errors. 6. **Welcome Message:** The server sends a welcome message to the client when it connects. **2. Web Application (Client-Side - `index.ts` and `index.html`)** * **`index.ts` (TypeScript):** ```typescript // index.ts const socket = new WebSocket('ws://localhost:8080'); // Replace with your server address socket.addEventListener('open', () => { console.log('Connected to MCP Server'); displayMessage('Connected to MCP Server'); }); socket.addEventListener('message', event => { console.log('Received:', event.data); try { const data = JSON.parse(event.data); displayMessage(`Received: ${JSON.stringify(data)}`); if (data.type === 'sensor_data') { updateSensorValue(data.value); } } catch (error) { console.error("Error parsing message:", error); displayMessage(`Error parsing message: ${error}`); } }); socket.addEventListener('close', () => { console.log('Disconnected from MCP Server'); displayMessage('Disconnected from MCP Server'); }); socket.addEventListener('error', error => { console.error('WebSocket error:', error); displayMessage(`WebSocket error: ${error}`); }); function sendCommand(command: string) { const message = JSON.stringify({ type: 'command', command: command }); socket.send(message); displayMessage(`Sent command: ${command}`); } function requestSensorData() { const message = JSON.stringify({ type: 'sensor_request' }); socket.send(message); displayMessage("Requesting sensor data..."); } // Helper functions to update the UI (replace with your actual UI framework) function displayMessage(message: string) { const messageDiv = document.getElementById('messages'); if (messageDiv) { messageDiv.innerHTML += `<p>${message}</p>`; } } function updateSensorValue(value: number) { const sensorValueDiv = document.getElementById('sensorValue'); if (sensorValueDiv) { sensorValueDiv.textContent = `Sensor Value: ${value.toFixed(2)}`; } } // Example button click handlers (connect these to your HTML buttons) (window as any).sendCommand = sendCommand; // Make available in HTML (window as any).requestSensorData = requestSensorData; ``` * **`index.html` (HTML):** ```html <!DOCTYPE html> <html> <head> <title>MCP Web App</title> </head> <body> <h1>MCP Web App</h1> <button onclick="sendCommand('LED_ON')">Turn LED On</button> <button onclick="sendCommand('LED_OFF')">Turn LED Off</button> <button onclick="requestSensorData()">Get Sensor Data</button> <div id="sensorValue">Sensor Value: N/A</div> <div id="messages"></div> <script src="index.js"></script> <!-- Compiled JavaScript --> </body> </html> ``` **Explanation (Client):** 1. **WebSocket Connection:** Creates a WebSocket connection to the MCP server. Make sure the address matches your server's address and port. 2. **Event Listeners:** * `open`: Fires when the connection is established. * `message`: Fires when the client receives a message from the server. It parses the JSON data and updates the UI accordingly. * `close`: Fires when the connection is closed. * `error`: Fires if there's a WebSocket error. 3. **`sendCommand()` Function:** Sends a command to the MCP server. It constructs a JSON message with the `type` set to `"command"` and includes the command string. 4. **`requestSensorData()` Function:** Sends a request to the MCP server to get sensor data. 5. **UI Update Functions:** `displayMessage()` and `updateSensorValue()` are placeholder functions that update the HTML. You'll need to replace these with your actual UI framework (e.g., React, Angular, Vue.js) code. 6. **HTML:** The HTML provides buttons to send commands and request sensor data. It also includes a `<div>` to display messages and sensor values. The `onclick` attributes of the buttons call the `sendCommand()` and `requestSensorData()` functions. **How to Run:** 1. **Install Dependencies:** * **Server:** `npm install ws --save` and `npm install -D typescript @types/ws` * **Client:** You'll need a way to serve the HTML and JavaScript files. You can use a simple HTTP server like `http-server` (install globally: `npm install -g http-server`). You'll also need to install typescript `npm install -D typescript` 2. **Compile TypeScript:** * **Server:** `tsc mcp-server.ts` * **Client:** `tsc index.ts` 3. **Start the Server:** `node mcp-server.js` (or `ts-node mcp-server.ts` if you have `ts-node` installed) 4. **Serve the Web App:** Navigate to the directory containing `index.html` and run `http-server`. Then open your browser to the address provided by `http-server` (usually `http://localhost:8080` or similar). **Important Considerations and Improvements:** * **Error Handling:** The example includes basic error handling, but you should add more robust error handling in a real application. * **Security:** For production environments, you'll need to implement proper security measures, such as authentication and authorization. Consider using WSS (WebSocket Secure) for encrypted communication. * **Data Serialization:** JSON is a common choice, but you could use other serialization formats like Protocol Buffers or MessagePack for better performance. * **UI Framework:** Use a UI framework (React, Angular, Vue.js) to build a more structured and maintainable web application. * **MCP Logic:** The most important part is the MCP logic on the server-side. You'll need to adapt the code to interact with your specific microcontroller or hardware. This will likely involve using libraries like `serialport`, `rpio`, or other hardware-specific libraries. * **Message Queues:** For more complex applications, consider using a message queue (e.g., RabbitMQ, Kafka) to decouple the web application from the MCP server. * **State Management:** If your web application needs to maintain state, consider using a state management library like Redux or Zustand. * **Typescript Configuration:** Create a `tsconfig.json` file to configure the TypeScript compiler. This will allow you to specify compiler options like target JavaScript version, module system, and more. **Example `tsconfig.json` (for both server and client):** ```json { "compilerOptions": { "target": "es6", // Or a more modern version "module": "commonjs", // Or "esnext" for browser modules "moduleResolution": "node", "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "strict": true, "skipLibCheck": true, "outDir": "./dist" // Output directory for compiled JavaScript }, "include": ["*.ts"], // Include all TypeScript files in the current directory "exclude": ["node_modules"] } ``` **Vietnamese Translation of Key Concepts:** * **Web App (Ứng dụng web):** Ứng dụng chạy trên trình duyệt web. * **MCP Server (Máy chủ MCP):** Máy chủ điều khiển và giao tiếp với vi điều khiển (microcontroller). MCP stands for Microcontroller Platform. * **WebSocket:** Giao thức giao tiếp hai chiều, thời gian thực giữa máy chủ và ứng dụng web. * **Client (Máy khách):** Trong trường hợp này, là ứng dụng web. * **Server (Máy chủ):** Máy chủ Node.js chạy MCP server. * **JSON:** Định dạng dữ liệu phổ biến để trao đổi thông tin giữa máy khách và máy chủ. * **Microcontroller (Vi điều khiển):** Một máy tính nhỏ được nhúng trong các thiết bị điện tử để điều khiển các chức năng cụ thể. * **Serial Communication (Giao tiếp nối tiếp):** Một phương pháp truyền dữ liệu tuần tự qua một kênh duy nhất. * **GPIO (General Purpose Input/Output):** Các chân trên vi điều khiển có thể được cấu hình làm đầu vào hoặc đầu ra để tương tác với các thiết bị bên ngoài. * **TypeScript:** Một ngôn ngữ lập trình là superset của JavaScript, thêm kiểu tĩnh. * **Compile (Biên dịch):** Chuyển đổi mã TypeScript thành mã JavaScript mà trình duyệt có thể hiểu được. This comprehensive example should give you a solid foundation for building a web application that communicates with a Node.js MCP server. Remember to adapt the MCP logic to your specific hardware and requirements. Good luck!

Nearest Tailwind Colors

Finds the closest Tailwind CSS palette colors to any given CSS color value. Supports multiple color spaces and customizable result filtering to help match designs to Tailwind's color system.

Sora MCP Server

Integrates with OpenAI's Sora 2 API to generate, remix, and manage AI-generated videos from text prompts. Supports video creation, status monitoring, downloading, and remixing through natural language commands.

Tickory MCP Server

Scheduled scans across all Binance spot and perpetual pairs using CEL rules (RSI, volume, MAs, price action). Runs server-side 24/7, fires webhooks on match, with delivery proof and alert explainability.

Org-roam MCP Server

Enables interaction with org-roam knowledge bases, allowing search, retrieval, creation, and linking of notes while respecting org-roam's file structure and conventions.

FastMCP Document Analyzer

A comprehensive document analysis server that performs sentiment analysis, keyword extraction, readability scoring, and text statistics while providing document management capabilities including storage, search, and organization.

MockMCP

Hosted MCP endpoint that returns realistic fake data for prototyping agents. Paste one URL into Claude Code, Cursor, or Claude Desktop — 12 pre-built tools covering users, products, orders, events, email, and knowledge base search. No signup, no config, no auth. Built for developers who want to prototype agent workflows before wiring up a real backend.

GitLab MCP Server

An MCP server that provides comprehensive access to the GitLab API for project management, repository operations, and issue tracking. It enables users to perform file operations, manage branches, and coordinate organization-wide workflows through project and group-level milestones.

MCP RSS News Agent

A FastMCP-based server that provides tools for discovering RSS feeds, fetching and processing news content, searching articles by keyword, and generating summaries across multiple news sources and categories.

video-transcribe-mcp

Một triển khai máy chủ MCP tích hợp với optivus, cung cấp khả năng phiên âm video (ví dụ: YouTube, Facebook, Tiktok, v.v.) cho LLM.

CSMAR MCP Server

Enables direct access to CSMAR financial databases through Claude Code. Supports 240+ databases including financial statements, stock trading data, and company information with intelligent login management and 11 MCP tools.

MCP Hello World Server

A demonstration Model Context Protocol server that provides a configurable 'Hello World' tool with multi-language support and input validation. It supports both local stdio and remote HTTP deployment via Docker, facilitating testing and integration with platforms like Cursor and Manus.

PyNet Bridge

PyNet Bridge MCP implementation to connect IAs with PyNet Platform.

Python MCP Server

Dự án **python-mcp-server** là một máy chủ web dựa trên Flask, được thiết kế để tương tác với Minecraft, có khả năng là một phần của một hệ thống lớn hơn để quản lý máy chủ Minecraft, plugin hoặc dữ liệu người chơi.

mailsink

MailSink is an MCP server for temporary, TTL-based email inboxes.

OpenAPI MCP Server

Một máy chủ cho phép các Mô hình Ngôn ngữ Lớn khám phá và tương tác với các API REST được định nghĩa bởi các đặc tả OpenAPI thông qua Giao thức Bối cảnh Mô hình.