Discover Awesome MCP Servers

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.

KIA - Kaizen Intelligent Agent

Transforms Claude into a production-grade pair programmer by orchestrating best-in-class APIs (Morph, Chroma, DSPy) for iterative code evolution to 95%+ quality, semantic codebase search, package discovery across 3,000+ libraries, and pattern learning.

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

Una implementación de servidor MCP que se integra con optivus, proporcionando capacidades de transcripción de video (por ejemplo, YouTube, Facebook, Tiktok, etc.) para LLMs.

Python MCP Server

El proyecto **python-mcp-server** es un servidor web basado en Flask diseñado para interactuar con Minecraft, probablemente como parte de un sistema más grande para administrar servidores de Minecraft, plugins o datos de jugadores.

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.

Dice Roller MCP Server

Provides comprehensive dice rolling, coin flipping, and tabletop RPG mechanics for AI assistants like Claude. It enables real-time tabletop gaming through features such as standard NdM notation, advantage/disadvantage rolls, and D\&D character stat generation.

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.

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 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.

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.

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.

WarpGBM MCP Service

Provides GPU-accelerated gradient boosting model training and inference through a cloud service. Enables AI agents to train models on NVIDIA A10G GPUs and get fast cached predictions with portable model artifacts.

File Rank MCP Server

A tool that helps rank codebase files by importance (1-10 scale), track file dependencies, and provide summaries, all accessible through a simple JSON-based interface.

Local LLM MCP Server

Bridges local LLMs running in LM Studio with MCP clients like Claude Desktop to perform reasoning and analysis tasks while keeping sensitive data private. It features a suite of tools for local code review, privacy scanning, and content transformation using auto-discovered local models.

MCP PDF

Enables creative PDF generation with full design control including colors, shapes, emoji, and Unicode support. Supports everything from simple documents to artistic masterpieces using PDFKit's powerful API.

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.

Comax Payment Link MCP

Allows integration with Comax ERP/payment systems to create payment links, manage orders, and retrieve customer information using the MCP protocol.

mcp-apple-music

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

Engram

A persistent memory server for AI agents that stores structured notes in a local SQLite database with full-text search and graph-based relationships. It features 32 specialized tools for managing long-term context, including version history, automated TTL expiration, and complex filtering.

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.

MCP Storyblok Server

A comprehensive server enabling natural language interaction with Storyblok CMS for managing stories, assets, components, releases, and other content through a modular architecture.

OpenAPI MCP Server

Un servidor que permite a los Modelos de Lenguaje Extensos descubrir e interactuar con APIs REST definidas por especificaciones OpenAPI a través del Protocolo de Contexto del Modelo.

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.

MCP Zoom Recordings

Enables users to list and manage Zoom cloud recordings through the Model Context Protocol. It allows for searching recordings by date and retrieving specific meeting details, including download URLs for video, audio, and transcripts.

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.