Discover Awesome MCP Servers

Publee MCP Server

Enables AI tools to publish HTML pages and get shareable URLs instantly, with optional account features for persistence, in-place updates, and visibility control.

MCP Home

A self-hosted MCP control plane and protocol gateway that aggregates and manages multiple MCP servers, exposing them via stable, authenticated MCP endpoints for any client.

WHOOP MCP

A local MCP server that connects Claude to the WHOOP Developer API, allowing natural language queries about recovery, sleep, strain, workouts, and body measurements. All data stays on your machine with read-only access.

Kylas CRM MCP Server

Model Context Protocol server for Kylas CRM lead operations, enabling lead creation, search/filter, and lookup of users, products, and pipelines.

notion-household-finance-mcp

Provides tools for querying and writing finance records in a Notion-backed household finance workspace, enabling management of budgets, expenses, savings, and debt through natural language.

claude-tmux-bridge

An MCP server that connects Claude Desktop to an interactive Claude Code session running in a tmux terminal.

Cursor Talk to Figma MCP

Enables Cursor AI to read and modify Figma designs programmatically via the Model Context Protocol.

blacksmith-usage-mcp

A local MCP server that exposes Blacksmith.sh's usage and cost data, enabling queries for CI spend through agents, alerts, or dashboards.

sap-btp-destination-mcp

A Python MCP server that authenticates with SAP BTP, reads Destination Service configurations, and exposes endpoints and MCP tools to access and call these destinations.

Git-Fabric Gateway

A central tool aggregator that routes and orchestrates multiple fabric apps through a single MCP surface. It enables users to access a combined suite of specialized tools from various registered apps via a unified server connection.

blender-mcp

Connects Blender 3D modeling software with Claude AI, enabling natural language control of 3D modeling and scene manipulation tasks.

MCP Server

This MCP server provides access to resources and prompts from GitHub repositories or the local filesystem, enabling teams to share coding standards, documentation, and reusable prompts with AI tools like Claude.

Indonesia Financial Data MCP

Citation-first MCP server for official Indonesian financial data from IDX, BPS, and KSEI, providing tools to access company profiles, financial reports, statistical tables, and investor demographics.

402-mcp

L402 + x402 client MCP. AI agents discover, pay for, and consume any payment-gated API autonomously. Supports Lightning (NWC), Cashu ecash, stablecoins, and human-in-the-loop payments.

Knock MCP Server

Enables AI assistants to manage notification infrastructure—workflows, channels, templates, users, and more—via Knock's API with OAuth authentication.

Kodama MCP

AST-aware code exploration MCP server for AI agents, optimized for token efficiency.

statelessagent

I gave Claude a mass grave of 200 markdown files and now it remembers my entire project between sessions. No cloud, no API keys, one 10mb Go binary, and private. Stateless Agent Memory Engine is your synapse to the CLI.

Odoo MCP Gateway

Enables managing multiple Odoo instances from a single panel and exposes MCP tools for interacting with them via a unified service.

mcp-server-saxo

Enables interaction with Saxo Bank OpenAPI for trading, portfolio management, market data, and account operations through natural language.

markapatent-mcp

Enables searching Turkish patent, trademark, and industrial design data via the TÜRKPATENT database using the MCP protocol.

MCPedia

MCP server for a content-first knowledge base, enabling AI agents to search (full-text, semantic, hybrid) and retrieve Markdown documents, list content, and find related docs.

Databricks MCP Server

Enables interaction with Databricks for running SQL queries, managing clusters, triggering jobs, running notebooks, exploring Unity Catalog metadata, managing secrets, and interacting with DBFS.

Dropbox MCP Server by CData

This read-only MCP Server allows you to connect to Dropbox data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

chaoslimba-mcp-server

MCP server for ChaosLimba — provides read-only access to the Romanian language learning platform's database via the Model Context Protocol.

MCP Middleware Adapter for Express Servers

Okay, here's a breakdown of how you can run multiple Minecraft Protocol (MCP) clients on a NodeJS Express server, acting as an adapter or middleware. This is a more complex setup, so I'll break it down into key concepts and provide code snippets to illustrate the ideas. **Conceptual Overview** 1. **Minecraft Protocol (MCP) Clients:** You'll need a library that handles the Minecraft protocol. Popular choices include: * `minecraft-protocol`: A low-level, flexible library. Requires more manual handling of packets. * `mineflayer`: A higher-level library built on top of `minecraft-protocol`. Provides a bot-like API for interacting with the server. 2. **NodeJS Express Server:** This will be your central hub. It will: * Receive requests from your front-end or other clients. * Manage the lifecycle of multiple MCP client instances. * Route commands/data to the appropriate MCP client. * Receive data from the MCP clients (e.g., chat messages, player positions) and relay it back to the requesting client. 3. **Client Management:** You'll need a way to keep track of your MCP clients. A simple object or array can work, but consider using a more robust data structure if you need advanced features like searching or filtering. 4. **Routing:** You'll need a mechanism to determine which MCP client a request should be sent to. This could be based on: * A unique ID assigned to each client. * The Minecraft server address the client is connected to. * Some other application-specific logic. 5. **Asynchronous Operations:** MCP communication is inherently asynchronous. You'll need to use `async/await` or Promises to handle the asynchronous nature of the protocol. **Code Example (Illustrative)** This example uses `mineflayer` for simplicity, but the core concepts apply to `minecraft-protocol` as well. ```javascript const express = require('express'); const mineflayer = require('mineflayer'); const app = express(); const port = 3000; app.use(express.json()); // For parsing JSON request bodies // Store MCP clients in an object, keyed by a unique ID const minecraftClients = {}; let nextClientId = 1; // Simple ID generator // Function to create a new Minecraft client async function createMinecraftClient(host, port, username, password) { try { const bot = mineflayer.createBot({ host: host, port: port, username: username, password: password, // Optional version: "1.20.1" // Replace with the correct version }); bot.on('login', () => { console.log(`Bot ${bot.username} logged in to ${host}:${port}`); }); bot.on('kicked', (reason, loggedIn) => { console.log(`Bot ${bot.username} was kicked: ${reason}, loggedIn: ${loggedIn}`); // Handle reconnection or cleanup here }); bot.on('error', (err) => { console.error(`Bot ${bot.username} error: ${err}`); // Handle errors appropriately }); bot.on('chat', (username, message) => { if (username === bot.username) return; // Ignore self-messages console.log(`<${username}> ${message}`); // Broadcast the message to connected clients (e.g., via WebSocket) }); return bot; // Return the bot instance } catch (error) { console.error("Error creating bot:", error); throw error; // Re-throw to be caught by the route handler } } // Route to create a new Minecraft client app.post('/clients', async (req, res) => { const { host, port, username, password } = req.body; try { const bot = await createMinecraftClient(host, port, username, password); const clientId = nextClientId++; minecraftClients[clientId] = bot; res.status(201).json({ message: 'Client created', clientId: clientId }); } catch (error) { console.error("Error in /clients route:", error); res.status(500).json({ error: 'Failed to create client' }); } }); // Route to send a command to a specific Minecraft client app.post('/clients/:clientId/command', (req, res) => { const clientId = parseInt(req.params.clientId); const command = req.body.command; const bot = minecraftClients[clientId]; if (!bot) { return res.status(404).json({ error: 'Client not found' }); } try { bot.chat(command); res.json({ message: 'Command sent' }); } catch (error) { console.error("Error sending command:", error); res.status(500).json({ error: 'Failed to send command' }); } }); // Route to get information about a specific client (example: player list) app.get('/clients/:clientId/players', (req, res) => { const clientId = parseInt(req.params.clientId); const bot = minecraftClients[clientId]; if (!bot) { return res.status(404).json({ error: 'Client not found' }); } const playerList = Object.keys(bot.players).map(username => ({ username: username, // Add other player properties as needed (e.g., position) })); res.json(playerList); }); // Start the server app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` **Explanation:** * **Dependencies:** Install the necessary packages: `npm install express mineflayer` * **`minecraftClients`:** This object stores the `mineflayer` bot instances, keyed by a unique ID. * **`createMinecraftClient`:** This function creates a new `mineflayer` bot, sets up event listeners (login, kicked, error, chat), and returns the bot instance. Crucially, it's `async` because `mineflayer.createBot` can take some time. Error handling is important here. * **`/clients` (POST):** This route handles the creation of new Minecraft clients. It receives the server details (host, port, username, password) from the request body, calls `createMinecraftClient`, stores the bot in the `minecraftClients` object, and returns a success response with the new client's ID. * **`/clients/:clientId/command` (POST):** This route sends a command to a specific Minecraft client. It retrieves the client ID from the URL parameters, finds the corresponding bot in the `minecraftClients` object, and uses `bot.chat()` to send the command. * **`/clients/:clientId/players` (GET):** This route retrieves a list of players on the server the bot is connected to. * **Error Handling:** The code includes basic error handling. You should expand this to handle different types of errors and implement appropriate logging and recovery mechanisms. * **Asynchronous Operations:** The `createMinecraftClient` function and the route handlers use `async/await` to handle the asynchronous nature of the Minecraft protocol. **Key Considerations and Enhancements:** * **Authentication/Authorization:** Implement proper authentication and authorization to protect your API endpoints. You don't want just anyone creating and controlling Minecraft bots. Consider using JWTs or other authentication mechanisms. * **WebSocket Integration:** For real-time updates (e.g., chat messages, player positions), use WebSockets. The Express server can act as a WebSocket server (using libraries like `ws` or `socket.io`). The `chat` event handler in the `createMinecraftClient` function would then broadcast the message to connected WebSocket clients. * **Rate Limiting:** Implement rate limiting to prevent abuse of your API. * **Error Handling and Logging:** Implement robust error handling and logging. Use a logging library like `winston` or `pino`. * **Client Lifecycle Management:** Implement mechanisms to handle client disconnections, reconnections, and cleanup. The `kicked` and `error` events are important here. Consider using a more sophisticated client management system (e.g., a database) if you need to persist client state. * **Configuration:** Externalize configuration settings (e.g., server addresses, usernames, passwords) into environment variables or a configuration file. * **Scalability:** For high-scale deployments, consider using a message queue (e.g., RabbitMQ, Kafka) to decouple the Express server from the MCP clients. The Express server would publish commands to the message queue, and the MCP clients would subscribe to the queue and process the commands. * **Security:** Be extremely careful about storing Minecraft account credentials. Use environment variables and avoid hardcoding them in your code. Consider using a secure vault to store sensitive information. * **Minecraft Version Compatibility:** Ensure that your `mineflayer` or `minecraft-protocol` version is compatible with the Minecraft server version you are connecting to. The example code includes a `version` option in `mineflayer.createBot`. * **Resource Management:** Be mindful of the resources consumed by each Minecraft client. Each client will consume CPU, memory, and network bandwidth. Monitor your server's resources and adjust the number of clients accordingly. * **Command Handling:** Instead of just sending raw chat commands, consider creating a more structured command API. This will make it easier to manage and control the bots. **Example Usage (from a client):** 1. **Create a new client:** ```bash curl -X POST -H "Content-Type: application/json" -d '{"host": "your_server_ip", "port": 25565, "username": "your_bot_username", "password": "your_bot_password"}' http://localhost:3000/clients ``` This will return a JSON response with the `clientId`. 2. **Send a command:** ```bash curl -X POST -H "Content-Type: application/json" -d '{"command": "/say Hello from the bot!"}' http://localhost:3000/clients/1/command # Replace 1 with the actual clientId ``` 3. **Get the player list:** ```bash curl http://localhost:3000/clients/1/players # Replace 1 with the actual clientId ``` **Spanish Translation of Key Concepts:** * **Minecraft Protocol (MCP) Clients:** Clientes del Protocolo de Minecraft (MCP) * **NodeJS Express Server:** Servidor NodeJS Express * **Adapter/Middleware:** Adaptador/Middleware * **Client Management:** Gestión de Clientes * **Routing:** Enrutamiento * **Asynchronous Operations:** Operaciones Asíncronas * **Unique ID:** ID Único * **Server Address:** Dirección del Servidor * **Authentication/Authorization:** Autenticación/Autorización * **WebSocket Integration:** Integración de WebSocket * **Rate Limiting:** Limitación de Tasa * **Error Handling and Logging:** Manejo de Errores y Registro * **Client Lifecycle Management:** Gestión del Ciclo de Vida del Cliente * **Configuration:** Configuración * **Scalability:** Escalabilidad * **Security:** Seguridad * **Resource Management:** Gestión de Recursos * **Command Handling:** Manejo de Comandos This comprehensive guide should give you a solid foundation for building your multi-MCP client adapter. Remember to adapt the code and concepts to your specific needs and requirements. Good luck!

Custom Fetch MCP

Enables Claude Code users with third-party APIs to fetch web pages locally, extracting main content without relying on the official Anthropic API.

mcp-server-notify

一个轻量级的桌面通知工具，支持 MCP 协议集成和命令行直接调用，让 Agent 能够智能发送系统通知。

Notion MCP Server

Enables interaction with Notion workspaces through the Notion API with health monitoring capabilities. Provides tools for managing Notion content and pages through natural language interface.

Azure Dev Server

A remote MCP server that provides full filesystem and shell access to a cloud-hosted environment via HTTPS, enabling Claude Desktop to read, write, edit, search files, and execute commands on a remote Azure machine.

hermes-pen-bridge

A hybrid MCP server that proxies Pencil's native design tools and adds utilities for .pen file management, enabling design token extraction, layer trees, diffs, and batch export.