Discover Awesome MCP Servers

mcp-sanctions-check

MCP server for OFAC SDN sanctions screening. Check names against US Treasury sanctions lists with automatic cache refresh. No API key needed for the check itself.

MCP API Requester

An MCP server that enables LLMs to make arbitrary HTTP requests (GET, POST, PUT, DELETE, etc.) with custom headers, bodies, and cookies, supporting JSON and error handling.

XHS MCP

Enables interaction with Xiaohongshu (Little Red Book) platform through automated browser operations. Supports authentication, content publishing, search, discovery, and commenting using Puppeteer-based automation.

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.

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.

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.

openqa-mcp

Enables interaction with openQA instances through the REST API, offering read tools for jobs, machines, and test suites, as well as mutating tools like restart and cancel with optional authentication.

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 app (acting as the host) connecting to a Node.js MCP (Microcontroller Platform) server. This example focuses on the core communication and assumes you have a basic understanding of TypeScript, web development, and Node.js. **Conceptual Overview** 1. **Web App (Host - TypeScript/HTML/JavaScript):** * Uses WebSockets to establish a persistent connection with the MCP server. * Sends commands/data to the MCP server. * Receives data/responses from the MCP server. * Updates the UI based on the received data. 2. **MCP Server (Node.js):** * Listens for WebSocket connections from the web app. * Receives commands/data. * Processes the commands (e.g., interacts with hardware, performs calculations). * Sends responses back to the web app. **Example Code** **1. MCP Server (Node.js - `mcp-server.js` or `mcp-server.ts`)** ```typescript // mcp-server.ts import { WebSocketServer, WebSocket } from 'ws'; const wss = new WebSocketServer({ port: 8080 }); // Choose your port wss.on('connection', ws => { console.log('Client connected'); ws.on('message', message => { try { const data = JSON.parse(message.toString()); // Parse JSON data console.log('Received:', data); // **Process the received data/command here** // Example: if (data.command === 'getSensorData') { // Simulate sensor data const sensorValue = Math.random() * 100; const response = { type: 'sensorData', value: sensorValue }; ws.send(JSON.stringify(response)); } else if (data.command === 'setLed') { // Simulate setting an LED const ledState = data.state; console.log(`Setting LED to: ${ledState}`); const response = { type: 'ledStatus', state: ledState }; ws.send(JSON.stringify(response)); } else { ws.send(JSON.stringify({ type: 'error', message: 'Unknown command' })); } } catch (error) { console.error('Error parsing 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); }); }); console.log('MCP Server started on port 8080'); ``` **To run the server:** 1. **Install `ws`:** `npm install ws` 2. **If using TypeScript:** * Compile: `tsc mcp-server.ts` * Run: `node mcp-server.js` (or `node mcp-server.ts` if you're using `ts-node`) 3. **If using JavaScript (after compiling from TypeScript):** * Run: `node mcp-server.js` **2. Web App (Host - TypeScript/HTML/JavaScript)** * **HTML (`index.html`):** ```html <!DOCTYPE html> <html> <head> <title>MCP Host</title> </head> <body> <h1>MCP Host</h1> <button id="getSensorData">Get Sensor Data</button> <p>Sensor Value: <span id="sensorValue"></span></p> <button id="ledOn">LED On</button> <button id="ledOff">LED Off</button> <p>LED Status: <span id="ledStatus"></span></p> <script src="app.js"></script> </body> </html> ``` * **TypeScript (`app.ts`):** ```typescript // app.ts const socket = new WebSocket('ws://localhost:8080'); // Replace with your server address socket.addEventListener('open', () => { console.log('Connected to MCP Server'); }); socket.addEventListener('message', event => { try { const data = JSON.parse(event.data); console.log('Received:', data); if (data.type === 'sensorData') { const sensorValueElement = document.getElementById('sensorValue'); if (sensorValueElement) { sensorValueElement.textContent = data.value.toFixed(2); } } else if (data.type === 'ledStatus') { const ledStatusElement = document.getElementById('ledStatus'); if (ledStatusElement) { ledStatusElement.textContent = data.state ? 'On' : 'Off'; } } else if (data.type === 'error') { console.error('Error from server:', data.message); alert(`Error: ${data.message}`); // Or display in a more user-friendly way } } catch (error) { console.error('Error parsing message:', error); } }); socket.addEventListener('close', () => { console.log('Disconnected from MCP Server'); }); socket.addEventListener('error', error => { console.error('WebSocket error:', error); }); // Button event listeners document.getElementById('getSensorData')?.addEventListener('click', () => { socket.send(JSON.stringify({ command: 'getSensorData' })); }); document.getElementById('ledOn')?.addEventListener('click', () => { socket.send(JSON.stringify({ command: 'setLed', state: true })); }); document.getElementById('ledOff')?.addEventListener('click', () => { socket.send(JSON.stringify({ command: 'setLed', state: false })); }); ``` * **Compile TypeScript:** `tsc app.ts` * **JavaScript (`app.js` - the compiled output):** (This will be generated by the TypeScript compiler) **How to Run the Web App:** 1. **Serve the HTML:** You'll need a web server to serve the `index.html` file. You can use a simple one like `http-server` (install with `npm install -g http-server` and then run `http-server .` in the directory containing `index.html`). Alternatively, use any web server you prefer (e.g., a more complex Node.js server, Python's `http.server`, etc.). 2. **Open in Browser:** Open `http://localhost:8080` (or the address your web server is using) in your web browser. **Explanation and Key Points** * **WebSockets:** WebSockets provide a persistent, full-duplex communication channel between the web app and the MCP server. This is ideal for real-time data exchange. * **JSON:** JSON (JavaScript Object Notation) is used to serialize and deserialize data being sent over the WebSocket connection. This makes it easy to work with data in both the web app and the Node.js server. * **Error Handling:** The code includes basic error handling to catch potential issues like invalid JSON or WebSocket errors. Robust error handling is crucial in real-world applications. * **Command Structure:** The example uses a simple command structure where the web app sends JSON objects with a `command` property to indicate the desired action. The server then processes the command and sends back a response. * **TypeScript:** TypeScript adds static typing to JavaScript, which helps catch errors early in the development process and improves code maintainability. * **Event Listeners:** The web app uses event listeners to handle WebSocket events like `open`, `message`, `close`, and `error`. * **DOM Manipulation:** The web app updates the HTML elements (e.g., `sensorValue`, `ledStatus`) to display the data received from the MCP server. * **Server-Side Logic:** The MCP server's `message` handler is where you would implement the core logic for interacting with your microcontroller or other hardware. The example provides placeholders for simulating sensor data and LED control. **Important Considerations for Real-World Applications** * **Security:** If you're dealing with sensitive data, use secure WebSockets (WSS) with TLS/SSL encryption. Implement authentication and authorization mechanisms to protect your MCP server from unauthorized access. * **Scalability:** For high-traffic applications, consider using a more scalable WebSocket server implementation (e.g., using a load balancer and multiple server instances). * **Data Validation:** Validate the data received from the web app and the MCP server to prevent unexpected errors or security vulnerabilities. * **Error Handling:** Implement comprehensive error handling and logging to diagnose and resolve issues quickly. * **Reconnect Logic:** Implement automatic reconnect logic in the web app to handle cases where the WebSocket connection is lost. * **State Management:** Consider using a state management library (e.g., Redux, Zustand) in the web app to manage the application's state more effectively, especially as the application grows in complexity. * **Hardware Interaction:** The MCP server will need to use appropriate libraries or APIs to communicate with your specific microcontroller or hardware. This will vary depending on the hardware platform you're using. * **Message Queues:** For more complex systems, consider using a message queue (e.g., RabbitMQ, Kafka) to decouple the web app and the MCP server and improve reliability and scalability. **Chinese Translation of Key Terms** * **Web App:** 网络应用程序 (wǎngluò yìngyòng chéngxù) * **Host:** 主机 (zhǔjī) * **MCP (Microcontroller Platform):** 微控制器平台 (wēi kòngzhìqì píngtái) * **Server:** 服务器 (fúwùqì) * **WebSocket:** WebSocket (pronounced the same) * **Connection:** 连接 (liánjiē) * **Data:** 数据 (shùjù) * **Command:** 命令 (mìnglìng) * **Sensor:** 传感器 (chuángǎnqì) * **LED:** LED (pronounced the same) or 发光二极管 (fāguāng èrjígǔan) * **Error:** 错误 (cuòwù) * **Message:** 消息 (xiāoxi) * **Client:** 客户端 (kèhùduān) * **JSON:** JSON (pronounced the same) * **Port:** 端口 (duānkǒu) This comprehensive example should give you a solid foundation for building a web app that communicates with a Node.js MCP server using WebSockets and TypeScript. Remember to adapt the code to your specific hardware and application 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

Recruitee MCP Server

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

Enhanced Cognee

Enterprise-grade AI memory infrastructure with multi-agent support, providing 122 MCP tools for memory management, agent coordination, and cross-language SDKs.

LangGraph FastAPI MCP Server

Enables LLM-powered agents to securely communicate with and orchestrate downstream microservices via FastAPI endpoints exposed as MCP tools.

mcp-apple-music

Full Apple Music integration for Claude: search the catalog, browse your personal library, manage playlists, and get personalised recommendations.

custom-mcp-server

Exposes custom Python functions as tools and integrates with Ollama for tool calling.

Tripo AI MCP Server

Enables AI assistants to interact with the Tripo3D AI API to generate 3D models from text, images, or multiview inputs. It supports advanced features like model animation, stylization, and real-time task status tracking.

OpenAPI MCP Server

一个服务器，它使大型语言模型能够通过模型上下文协议发现和交互由 OpenAPI 规范定义的 REST API。

mcp-desktop

macOS desktop automation enabling AI agents to screenshot, switch apps and tabs, click, type, and scroll. Offers two trust levels: read-only screenshot and full UI control.

Zoho Books MCP Server

Enables AI assistants to manage Zoho Books accounting tasks such as invoices, contacts, expenses, and sales orders through natural language.

Godot Scene Analyzer

Analyzes Godot game projects to enforce ECS architecture patterns, automatically detecting when scene scripts contain game logic that should be in the ECS layer and validating separation between presentation and logic code.

CovAiLent

An MCP server for chemistry-focused tools, enabling LLM agents to perform molecule parsing, format conversion, property lookup, and other chemistry operations with explainable responses.

mcp-llm-behave

Exposes llm-behave's behavioral regression testing as MCP tools, allowing offline semantic similarity checks on LLM outputs without any API calls.

Discourse MCP

Enables AI agents to interact with Discourse forums through search, reading topics/posts, managing categories and tags, chat channels, and optionally creating content with safeguarded write operations.

Netlify Express MCP Server

A basic serverless MCP implementation using Netlify Functions and Express. Demonstrates how to deploy and run Model Context Protocol servers in a serverless environment with proper routing configuration.