Discover Awesome MCP Servers

QGISMCP

Một máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) kết nối Claude AI với QGIS, cho phép tương tác trực tiếp với phần mềm GIS để tạo dự án, thao tác lớp, thực thi mã và xử lý các thuật toán thông qua các lệnh bằng ngôn ngữ tự nhiên.

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.

zscaler-mcp-server

Connects AI agents to the Zscaler Zero Trust Exchange platform via the Model Context Protocol, enabling read-only operations by default with optional write capabilities.

imagefeatures-mcp

An MCP server that provides classic computer vision feature extraction tools (color, texture, shape) for image analysis, enabling LLMs to perform precise mathematical image comparisons and quality assessments.

che-blender-mcp

Enables executing Python scripts, rendering scenes, and controlling 3D objects in Blender via Claude, with support for Cycles and EEVEE engines.

Basic MCP Server

A minimal Model Context Protocol server demonstrating basic MCP capabilities with example tools, resources, and prompts. Built as a starting template for developers to create their own MCP servers using the Smithery SDK.

GitMCP

Transforms any GitHub repository into a documentation hub for AI assistants, enabling up-to-date access to documentation and code to eliminate hallucinations.

Expense Tracker MCP Server

Enables personal expense management with SQLite storage, allowing users to add, update, delete, list, and summarize expenses by category through natural language interactions.

Rockfish MCP Server

Enables interaction with the Rockfish AI platform for synthetic data generation, dataset management, and ML workflow orchestration through tools like TabGAN training and Manta analytics.

mcp-scryfall

Provides access to Magic: The Gathering card database, enabling listing of sets and expansions.

Google Maps MCP Server for Cloud Run

Provides Google Maps functionality through Cloud Run, enabling route calculation, traffic analysis, route comparison, and trip cost estimation with rate-limited public access.

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!

Google Chat MCP Server

Enables interaction with Google Chat via MCP using the internal Dynamite API, allowing listing spaces, reading and sending messages, and managing DMs. No Google Cloud Console setup required.

mcp-server

A demonstration MCP server for educational purposes, showcasing how to build and integrate MCP servers with LLM clients like Claude Desktop.

Data Science AI MCP

Data Science AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

Recruitee MCP Server

Enables extraction and analysis of candidate profiles from Recruitee recruitment pipelines, optimized for LLM evaluation with clean, bias-free data.

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.

Agent Data Bridge

An MCP server that provides data bridging from Spring Boot interfaces and a lightweight Python sandbox for script execution. It enables agents to fetch data as Markdown or Parquet files and perform automated data analysis within a controlled environment.

Browser MCP

Automate your browser with AI using an MCP server and Chrome extension, enabling fast, private, and stealthy browser control with your existing sessions.

Apple App Store Revenue MCP Server

Fetches revenue and download data for Apple App Store apps using the Sensor Tower API.

search-console-mcp

Model Context Protocol (MCP) server that provides AI agents with access to Google Search Console data.

obsidian-mcp

Enables Claude to read your Obsidian vault and retrieve outstanding tasks from daily notes by parsing checkboxes.

MCP Server for Up-to-Date Library Documentation

Provides Large Language Models with real-time access to the latest documentation for Python libraries like Langchain, LlamaIndex, and OpenAI, enabling accurate and up-to-date code suggestions.

mcp-capstone

MCP server that provides disassembly and reverse engineering capabilities via the Capstone framework, supporting multiple architectures.

Prycd Pricing MCP Server

Enables access to the Prycd Pricing API for retrieving estimated property values and performing health checks on the API service.

MCP Server Tester

Công cụ kiểm thử tự động cho các máy chủ Model Context Protocol (MCP) - ĐANG TRONG QUÁ TRÌNH PHÁT TRIỂN

pain001-mcp

A Model Context Protocol server that exposes the pain001 ISO 20022 Customer Credit Transfer Initiation library as agent tools, enabling AI assistants to generate and validate standardized payment XML messages.

qtm4j-mcp-server

MCP server for QTM4J (QMetry Test Management for Jira) Open API, enabling test case and cycle management via natural language.

lafe-blog MCP Server

Enables creating and managing text notes with a simple note-taking system. Provides tools to create notes, access them via URIs, and generate summaries of all stored notes.

greybeard

An MCP server that provides AI-powered code review and architecture analysis, simulating the perspective of an experienced staff engineer. It integrates with IDEs to review diffs, design decisions, and tradeoffs through natural language.