Discover Awesome MCP Servers

E-phy MCP Server

Provides access to the French e-phy catalog for detailed information on pesticides, fertilizers, and other phytosanitary products. It enables users to search for products, retrieve authorized usage specifications, and check the approval status of active substances.

Proxmox MCP Server

An enterprise-grade management tool that enables Claude Code to securely interact with Proxmox VE for full VM and LXC container management. It provides single-command installation and comprehensive security controls for production-ready deployments.

MCP Fullstack

A comprehensive operations platform providing browser automation, web search/crawling, database operations, deployment tools, secrets management, and analytics capabilities for full-stack software engineering workflows. Features AI-driven automation, real-time monitoring dashboard, and cross-platform service management.

MCP Autostarter

An intelligent MCP server that enables seamless restarting of Claude's MCP handler process without disrupting the UI, allowing for plugin reloading without closing the entire Claude Desktop application.

Advanced MCP Server

Provides real-time weather alerts from the National Weather Service, news search capabilities via NewsAPI, and safe local directory exploration for AI assistants.

Remote MCP Server (Authless)

Deploys a Model Context Protocol server on Cloudflare Workers without authentication requirements, allowing you to create and expose custom AI tools to clients like Claude Desktop or Cloudflare AI Playground.

MCP Server MySQL

Enables LLMs to interact with MySQL databases through standardized protocol, supporting database management, table operations, data queries, and modifications with configurable permission controls.

PulseAgent

An interrupt-aware MCP sidecar for long-running coding agents that detects changes in user guidance, constraints, or plans, enabling agents to pause, replan, and acknowledge updates before continuing.

MCP Server Directory

Descubre y comparte servidores de Protocolo de Contexto de Modelos para aplicaciones, desarrollo e integración de IA.

Gaia-Protocol

Gaia Protocol—a planetary DAO for global resource management using quantum-entangled ledgers and algorithmic governance.

Airtable MCP Server

Enables complete interaction with Airtable databases through 16 CRUD operations including batch processing, schema management, and record manipulation. Designed for AI applications and n8n workflows with HTTP streaming support.

Sanka MCP Server

A Model Context Protocol server that integrates the Sanka TypeScript SDK to provide document search and code execution capabilities. It allows clients to interact with Sanka's public API through a hosted HTTP or SSE interface.

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.

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.

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 demonstrating a web application (acting as the host) connecting to a Node.js MCP (Microcontroller Platform) server. This example focuses on the core communication setup. You'll need to adapt it based on the specific MCP protocol and data you're exchanging. **Conceptual Overview** 1. **Web App (Host - TypeScript/JavaScript):** * Uses WebSockets to establish a persistent connection with the MCP server. * Sends commands/requests 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/requests. * Processes the commands (potentially interacting with hardware). * Sends data/responses back to the web app. **Example Code** **1. MCP Server (Node.js - `mcp-server.ts`)** ```typescript // mcp-server.ts import WebSocket, { WebSocketServer } 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()); // Assuming JSON format console.log('Received:', data); // **Process the received message here based on your MCP protocol** // 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 console.log(`Setting LED to: ${data.state}`); const response = { type: 'ledStatus', state: data.state }; ws.send(JSON.stringify(response)); } else { console.log("Unknown command"); 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); }); // Send a welcome message ws.send(JSON.stringify({ type: 'status', message: 'Connected to MCP Server' })); }); console.log('MCP Server started on port 8080'); ``` **To run the server:** 1. Make sure you have Node.js and npm installed. 2. Create a new directory for your project. 3. Inside the directory, run: `npm init -y` 4. Install the `ws` package: `npm install ws --save` 5. Install `typescript`: `npm install typescript --save-dev` 6. Create a `tsconfig.json` file: `npx tsc --init` (adjust settings as needed) 7. Place the `mcp-server.ts` file in the directory. 8. Compile the TypeScript: `npx tsc` 9. Run the server: `node mcp-server.js` (or `node dist/mcp-server.js` if you configured a `dist` output directory in `tsconfig.json`) **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', event => { console.log('Connected to MCP Server'); }); socket.addEventListener('message', event => { try { const data = JSON.parse(event.data); console.log('Received:', data); if (data.type === 'status') { console.log('Status:', data.message); } else 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:', data.message); alert(`Error from server: ${data.message}`); } } catch (error) { console.error('Error parsing message:', error); } }); socket.addEventListener('close', event => { console.log('Disconnected from MCP Server'); }); socket.addEventListener('error', event => { console.error('WebSocket error:', event); }); // 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 })); }); ``` **To run the web app:** 1. Create a directory for your web app files. 2. Place `index.html` and `app.ts` in the directory. 3. Compile the TypeScript: `npx tsc` 4. This will create an `app.js` file. 5. Open `index.html` in your web browser. You might need to serve it using a simple web server (e.g., using `npx serve` or `python -m http.server`). **Explanation and Key Points** * **WebSockets:** WebSockets provide a full-duplex communication channel over a single TCP connection. This is ideal for real-time data exchange between the web app and the MCP server. * **JSON:** The example uses JSON (JavaScript Object Notation) for message formatting. This is a common and easy-to-parse format for data exchange. You can adapt this to other formats if needed. * **Error Handling:** The code includes basic error handling for WebSocket events and JSON parsing. Robust error handling is crucial in real-world applications. * **MCP Protocol:** The most important part is defining your MCP protocol. This is the set of commands and data formats that the web app and MCP server will use to communicate. The example uses simple `command` and `type` fields to illustrate this. You'll need to design a protocol that meets the needs of your specific application. * **TypeScript Compilation:** The TypeScript code needs to be compiled into JavaScript before it can be run in the browser. The `tsc` command performs this compilation. * **Server Address:** Make sure the WebSocket URL in the web app (`ws://localhost:8080`) matches the address and port where your MCP server is listening. * **Security:** For production environments, consider using secure WebSockets (WSS) with TLS/SSL encryption. * **State Management:** In a more complex application, you'll likely need to manage the state of the connection and the data being exchanged. Consider using a state management library like Redux or Zustand for larger applications. * **UI Updates:** The example updates the HTML elements with the data received from the server. You'll need to adapt this to your specific UI requirements. **How to Adapt This Example** 1. **Define Your MCP Protocol:** This is the most important step. Determine the commands the web app can send to the MCP server and the data formats the server will use to respond. Consider things like: * Sensor data requests * Actuator control commands (e.g., turning LEDs on/off, controlling motors) * Configuration settings * Error reporting 2. **Implement MCP Server Logic:** Modify the MCP server code to handle the commands defined in your protocol. This might involve interacting with hardware (e.g., reading sensor values, controlling actuators). 3. **Implement Web App Logic:** Modify the web app code to send the appropriate commands to the MCP server and to handle the data received from the server. Update the UI accordingly. 4. **Error Handling:** Add more robust error handling to both the web app and the MCP server. 5. **Security:** Use secure WebSockets (WSS) for production environments. This example provides a basic foundation for building a web app that communicates with an MCP server. Remember to adapt it to your specific needs and to design a well-defined MCP protocol.

ssyubix-agentlink

Cross-device communication between AI agents over the public internet

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.

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.

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.

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.

lexq

55 MCP tools for managing business rules. Create policy groups, define rules, run dry-run tests, batch simulations, A/B testing, deployments, and integrations.

nworks

NAVER WORKS CLI + MCP server. 26 tools for messages, calendar, drive, mail, tasks, and boards. AI agents can manage NAVER WORKS directly.

hearthstone-oracle

Hearthstone MCP server with card search, deck analysis, and strategy coaching. Gives LLMs access to every Hearthstone card plus built-in strategy knowledge for deck building and gameplay advice.

Prycd Pricing MCP Server

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

Stochastic Thinking MCP Server

Provides advanced probabilistic decision-making algorithms including MDPs, MCTS, Multi-Armed Bandits, Bayesian Optimization, and Hidden Markov Models to help AI assistants explore alternative solutions and optimize long-term decisions.

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.

Hurl OpenAPI MCP Server

Enables AI models to load and inspect OpenAPI specifications, generate Hurl test scripts, and access API documentation for automated testing and API interaction through natural language.