Discover Awesome MCP Servers

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.

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!

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

genesys-memory

Causal graph memory engine for AI agents. Scores memories using relevance × connectivity × reactivation, connects them in a causal graph, and actively forgets irrelevant ones. 11 MCP tools including store, recall, search, traverse, and explain.

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.

Robot Navigation MCP Server

Enables robot navigation control and monitoring through natural language. Provides tools for robot positioning, navigation to coordinates, device status monitoring, task management, and emergency controls.

kr-pc-deals-mcp

Enables AI assistants to search and compare Korean PC parts prices from Danawa and Compuzone, build assembly estimates with automatic compatibility checks, and track price history.

Optical Context MCP

Compress OCR-heavy PDFs into dense packed images so agents can work with long visual documents.

Picsart MCP Server

Enables AI agents and terminals to generate images, video, and audio using 141 models from 28 providers via the Picsart gen-ai API.

ssyubix-agentlink

Cross-device communication between AI agents over the public internet

at-eli-mcp

Enables searching and retrieving Austrian federal legislation and case law from the official legal information system RIS, with verifiable ELI and ECLI identifiers.

Palo Alto Networks MCP Server

Enables MCP clients to interact with Palo Alto Networks firewalls and Panorama, providing tools to retrieve address objects, security zones, policies, and system information.

MoluAbi MCP Server

Enables complete AI agent lifecycle management through MoluAbi's platform, allowing users to create, manage, and interact with AI assistants. Provides comprehensive tools for agent operations with secure authentication, usage tracking, and payment integration.

Daemon-MCP

Daem0n-MCP provides AI agents with persistent, semantically indexed memory to track decisions, rules, and outcomes across sessions. It actively prevents repetitive mistakes by enforcing context checks and prioritizing information about past failures during recall. Best for Claude Code.

Production MCP Template

A production-grade, extensible Python template for building Model Context Protocol servers with support for Streamable HTTP and stdio transports. It provides a structured framework for implementing tools, resources, and prompts with built-in authentication, observability, and background task management.

TestPilot MCP

Enables AI models (Claude, ChatGPT, GitHub Copilot) to run and analyze local tests, rerun failures, and orchestrate QA workflows using existing UI and API test frameworks.

Anki MCP Server

A Model Context Protocol server that bridges Claude AI with Anki flashcard app, allowing users to create and manage flashcards using natural language commands.

AI Workspace MCP Server

Provides a secure workspace for AI-driven file management and Python script execution designed to run on Vercel. It enables tools for full file operations and code execution within a sandboxed environment.

MCP File Operations Server

Enables secure file management operations within a documents folder, including reading, writing, listing, deleting files and creating directories. Supports all file types with path validation to prevent access outside the designated documents directory.

WinCC V8 MCP Server

MCP server providing access to Siemens WinCC V8 SCADA systems via REST API, enabling tag management, alarm logging, and archive operations.

GitKraken MCP

The GitKraken MCP Server turns your AI assistant into a context-aware development partner by connecting it to git history, branches, issues, pull requests, and multi-repo workflows through GitKraken. It works with all the providers you would expect from the GitKraken software suite such as GitHub, GitLab, Azure DevOps, Bitbucket, Jira, and more.

BeamScope MCP

BeamScope gives AI coding agents access to your running BEAM application through a resilient TCP architecture that survives app restarts.

MCP Echo Env

Echoes environment variables (PWD and WORKSPACE_SLUG) to verify that MCP clients properly propagate workspace context to server processes.