Discover Awesome MCP Servers

MCP Server for OpenHAB

Server that connects MCP (Multi-Capability Platform) with OpenHAB REST API, allowing MCP to interact with OpenHAB items through operations like getItemState and sendCommand.

XMCP Application

A server that leverages the XMCP framework to discover and execute tools from the src/tools directory, supporting both SSE and STDIO transport methods for interaction.

Weather MCP Server

An MCP server that provides weather information and alerts for US locations using the National Weather Service API, enabling retrieval of weather forecasts and active weather alerts.

BaseQL MCP Server

Enables agents to query Base blockchain data using natural language by providing contract addresses, SQL templates, and direct access to Coinbase's SQL API for realtime on-chain analytics including DeFi, NFTs, and wallet activity.

MCP Media Server

Enables browsing and playing media files from a local Movies directory through natural language commands. Supports listing all movies and launching playback using the system's default media player.

Cisco Catalyst Center (DNAC) MCP Server

Enables AI assistants to query and monitor wireless clients in Cisco Catalyst Center infrastructure, providing intelligent client searches, health monitoring, and network diagnostics through natural language.

Seedream 4.0 MCP

Enables AI image generation through Volcano Engine's Seedream 4.0 API, supporting text-to-image, image-to-image, multi-image fusion, and sequential generation with automatic local saving and Markdown support.

whistle-mcp

O Whistle MCP Server é uma ferramenta de gerenciamento de proxy Whistle baseada no protocolo Model Context Protocol (MCP), que permite que assistentes de IA operem e controlem diretamente servidores proxy Whistle locais. Através desta ferramenta, a IA pode ajudar os usuários a gerenciar regras, grupos, valores, monitorar requisições de rede e reproduzir...

Poiesis MCP Server

Enables AI assistants to create, monitor, and manage computational tasks through GA4GH Task Execution Service (TES) functionality. Provides seamless access to TES-compliant services for executing bioinformatics and scientific computing workflows.

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

LinkedIn Profile Analyzer MCP

Enables users to fetch, analyze, and manage LinkedIn posts data through tools that retrieve profiles, search posts by keywords, filter by date, and identify top-performing content based on engagement metrics.

Power BI MCP Server

Enables AI assistants to interact with Power BI datasets through natural language, allowing users to query data, generate DAX, and get insights without leaving their AI assistant.

MCP Middleware Adapter for Express Servers

Okay, here's a breakdown of how to 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 code snippets. **Core Concepts** 1. **Minecraft Protocol (MCP) Libraries:** You'll need a NodeJS library that handles the Minecraft protocol. Popular choices include: * `minecraft-protocol`: A widely used, low-level library. It gives you fine-grained control but requires more code to manage. * `mineflayer`: A higher-level library built on top of `minecraft-protocol`. It provides a bot-like API, making common tasks (chatting, moving, interacting with blocks) easier. If you need bot-like functionality, `mineflayer` is often preferred. 2. **Express Server:** Your Express server will act as the central point for managing and interacting with your MCP clients. It will expose endpoints (routes) that allow you to control the clients. 3. **Client Management:** You'll need a way to keep track of your MCP clients. A simple array or object can work, but consider using a more robust data structure if you need to manage a large number of clients or track more complex client state. 4. **Concurrency:** NodeJS is single-threaded, but it uses an event loop to handle asynchronous operations. MCP interactions are inherently asynchronous (sending packets, receiving responses). Make sure your code is non-blocking to avoid freezing your server. `async/await` is your friend here. 5. **Unique Client Identifiers:** Each MCP client needs a unique identifier. This could be a simple index in an array, a username, or a UUID. Use this identifier to target specific clients when sending commands or retrieving data. 6. **Error Handling:** MCP connections can be unreliable. Handle errors gracefully (e.g., connection refused, authentication failures, packet parsing errors). Implement retry logic if appropriate. **Example Code (using `mineflayer`)** This example demonstrates the basic structure. You'll need to adapt it to your specific needs. ```javascript const express = require('express'); const mineflayer = require('mineflayer'); const app = express(); const port = 3000; // Middleware to parse JSON request bodies app.use(express.json()); // Store clients in an object, keyed by a unique ID const clients = {}; let nextClientId = 1; // Simple auto-incrementing ID // Function to create a new Minecraft client async function createClient(username, password, host, port) { try { const bot = mineflayer.createBot({ host: host, port: port, username: username, password: password, }); // Event listeners (example) bot.on('login', () => { console.log(`Client ${bot.username} logged in`); }); bot.on('kicked', (reason, loggedIn) => { console.log(`Client ${bot.username} was kicked: ${reason}`); delete clients[bot.id]; // Remove from the client list }); bot.on('error', (err) => { console.error(`Client ${bot.username} error:`, err); delete clients[bot.id]; // Remove from the client list }); bot.on('end', () => { console.log(`Client ${bot.username} disconnected`); delete clients[bot.id]; // Remove from the client list }); // Assign a unique ID to the bot bot.id = nextClientId++; clients[bot.id] = bot; return bot.id; // Return the client ID } catch (error) { console.error("Error creating client:", error); throw error; // Re-throw to be caught by the route handler } } // Route to create a new client app.post('/clients', async (req, res) => { const { username, password, host, port } = req.body; if (!username || !host) { return res.status(400).json({ error: 'Username and host are required' }); } try { const clientId = await createClient(username, password, host, port); res.status(201).json({ message: 'Client created', clientId: clientId }); } catch (error) { res.status(500).json({ error: 'Failed to create client' }); } }); // Route to send a chat message to a specific client app.post('/clients/:clientId/chat', (req, res) => { const clientId = parseInt(req.params.clientId); const { message } = req.body; if (!message) { return res.status(400).json({ error: 'Message is required' }); } const bot = clients[clientId]; if (!bot) { return res.status(404).json({ error: 'Client not found' }); } bot.chat(message); res.json({ message: 'Message sent' }); }); // Route to get the list of connected clients app.get('/clients', (req, res) => { const clientList = Object.keys(clients).map(key => ({ id: clients[key].id, username: clients[key].username, host: clients[key].host, port: clients[key].port })); res.json(clientList); }); // Start the server app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` **Explanation:** 1. **Dependencies:** Requires `express` and `mineflayer`. Install them: `npm install express mineflayer` 2. **`clients` Object:** Stores the `mineflayer` bot instances, keyed by a unique ID. 3. **`createClient` Function:** * Creates a new `mineflayer` bot instance using the provided credentials. * Attaches event listeners for `login`, `kicked`, `error`, and `end`. These are crucial for handling connection events and errors. The `kicked`, `error`, and `end` listeners *remove* the client from the `clients` object to prevent memory leaks and ensure the server doesn't try to interact with a disconnected client. * Assigns a unique ID (`bot.id`) to the bot. * Stores the bot in the `clients` object. * Returns the client ID. * Includes error handling with `try...catch`. 4. **`/clients` (POST) Route:** * Handles requests to create new clients. * Extracts the username, password, host, and port from the request body. * Calls the `createClient` function to create the bot. * Sends a success response with the client ID or an error response if creation fails. 5. **`/clients/:clientId/chat` (POST) Route:** * Handles requests to send a chat message to a specific client. * Extracts the `clientId` from the URL parameters and the `message` from the request body. * Retrieves the bot instance from the `clients` object using the `clientId`. * Sends the chat message using `bot.chat(message)`. * Sends a success or error response. 6. **`/clients` (GET) Route:** * Returns a list of connected clients with their IDs, usernames, hosts, and ports. 7. **Error Handling:** The code includes basic error handling for client creation and message sending. You should expand this to handle other potential errors. **How to Run:** 1. Save the code as `app.js`. 2. Run `npm install express mineflayer`. 3. Run `node app.js`. 4. Use a tool like `curl` or Postman to send HTTP requests to the server. **Example `curl` commands:** * **Create a client:** ```bash curl -X POST -H "Content-Type: application/json" -d '{"username": "your_username", "password": "your_password", "host": "your_server_ip", "port": 25565}' http://localhost:3000/clients ``` * **Send a chat message:** (Replace `1` with the actual client ID) ```bash curl -X POST -H "Content-Type: application/json" -d '{"message": "Hello, world!"}' http://localhost:3000/clients/1/chat ``` * **Get the list of clients:** ```bash curl http://localhost:3000/clients ``` **Important Considerations and Improvements:** * **Authentication:** The example uses a simple username/password. For production, use a more secure authentication mechanism (e.g., API keys, JWTs). * **Configuration:** Store server addresses, usernames, and passwords in a configuration file (e.g., using `dotenv`) instead of hardcoding them. * **Rate Limiting:** Implement rate limiting to prevent abuse. * **Logging:** Use a proper logging library (e.g., `winston`, `morgan`) for more detailed logging. * **Client State Management:** If you need to track more complex client state (e.g., location, inventory), store that information in the `clients` object or in a separate database. * **Reconnect Logic:** Implement automatic reconnect logic if a client disconnects unexpectedly. * **Command Handling:** Instead of just sending chat messages, you can implement a more sophisticated command handling system. Parse commands from the chat and execute corresponding actions. * **WebSockets:** For real-time updates from the Minecraft clients to the browser, consider using WebSockets instead of polling the server. Libraries like `socket.io` can simplify this. * **Process Management:** For production deployments, use a process manager like `pm2` to ensure your server restarts automatically if it crashes. * **Security:** Be extremely careful about exposing sensitive information (e.g., passwords) in your code or logs. Use environment variables and secure storage mechanisms. Sanitize all input to prevent command injection vulnerabilities. * **Scalability:** If you need to handle a very large number of clients, consider using a message queue (e.g., RabbitMQ, Kafka) to distribute tasks across multiple server instances. **Choosing Between `minecraft-protocol` and `mineflayer`:** * **`minecraft-protocol`:** * **Pros:** More control, lower-level, potentially more efficient if you only need specific features. * **Cons:** Requires more code to implement common tasks, steeper learning curve. * **`mineflayer`:** * **Pros:** Easier to use, higher-level API, provides bot-like functionality. * **Cons:** Less control, potentially less efficient if you don't need all the features, adds a layer of abstraction. Start with `mineflayer` if you need bot-like features or want a quicker development process. If you need fine-grained control or are concerned about performance, consider `minecraft-protocol`. **Portuguese Translation of Key Phrases:** * "Run multiple MCP clients on a NodeJS Express server (adapter/middleware)": "Executar múltiplos clientes MCP em um servidor NodeJS Express (adaptador/middleware)" * "Minecraft Protocol": "Protocolo Minecraft" * "Client created": "Cliente criado" * "Client not found": "Cliente não encontrado" * "Message sent": "Mensagem enviada" * "Server listening at": "Servidor ouvindo em" * "Username and host are required": "Nome de usuário e host são obrigatórios" * "Failed to create client": "Falha ao criar o cliente" * "Message is required": "A mensagem é obrigatória" * "Error creating client": "Erro ao criar o cliente" * "Client logged in": "Cliente conectado" * "Client was kicked": "Cliente foi expulso" * "Client error": "Erro do cliente" * "Client disconnected": "Cliente desconectado" * "List of connected clients": "Lista de clientes conectados" * "Unique client identifiers": "Identificadores únicos de cliente" * "Error Handling": "Tratamento de erros" * "Concurrency": "Concorrência" * "Authentication": "Autenticação" * "Configuration": "Configuração" * "Rate Limiting": "Limitação de taxa" * "Logging": "Registro" * "Client State Management": "Gerenciamento do estado do cliente" * "Reconnect Logic": "Lógica de reconexão" * "Command Handling": "Tratamento de comandos" * "WebSockets": "WebSockets" * "Process Management": "Gerenciamento de processos" * "Security": "Segurança" * "Scalability": "Escalabilidade" This comprehensive guide should give you a solid foundation for building your MCP client adapter. Remember to adapt the code to your specific requirements and prioritize security and error handling. Good luck!

Salesforce DX MCP Server

Enables secure interaction with Salesforce orgs through LLMs, providing tools for managing orgs, querying data, deploying metadata, running tests, and performing code analysis with granular access control and encrypted authentication.

MetaMCP MCP Server

Espelho de

ClickUp MCP Server

Enables interaction with ClickUp project management platform through the Model Context Protocol, providing tools for task management, team collaboration, and workspace operations with flexible authentication support.

MCP Boilerplate

A minimal, production-ready MCP server with a simple addition calculator tool that demonstrates integration with the Model Context Protocol.

Mcp Todo App

Uma combinação de servidor e cliente MCP que adiciona um toque de IA a um aplicativo de tarefas simples.

Strava MCP

Um servidor Claude MCP que permite aos usuários consultar e analisar seus dados de atividade do Strava, conectando-se à API do Strava.

Authenticator App MCP Server

A secure server that enables AI agents to access 2FA codes and passwords from the Authenticator App, allowing them to assist with automated login processes while maintaining security.

MCP Workitem Server

A server that provides access to Alibaba Cloud workitem descriptions through MCP protocol, allowing agents to retrieve structured workitem data including text, images, and HTML content by ID.

Calendar MCP

MCP server for accessing macOS Calendar events

Deepwiki MCP Server

An MCP server that fetches and converts Deepwiki documentation into Markdown, allowing users to crawl pages from deepwiki.com repositories and access them in different output formats.

GitHub Repository Analyzer

Permite que modelos de linguagem grandes analisem repositórios do GitHub em tempo real, fornecendo ferramentas para recuperar informações do repositório, analisar problemas, acessar documentação e visualizar a atividade.

むらっけ MPC Server

Um servidor MPC que reproduz de forma simplificada a habilidade "Errático" de Pokémon.

Smart EHR MCP Server

Um servidor de Protocolo de Contexto de Modelo que conecta ferramentas de IA a Registros Eletrônicos de Saúde usando SMART on FHIR, permitindo a busca, consulta e análise seguras de dados de pacientes de EHRs compatíveis.

PubChem Chemical Safety MCP Server

Enables users to retrieve chemical safety information including compound properties, GHS safety classifications, and toxicity data from PubChem database using compound names or CIDs. Supports batch queries with caching for efficient chemical safety research and analysis.

KVM MCP Server

A JSON-RPC server that simplifies managing KVM virtual machines by providing a centralized interface for VM lifecycle, networking, storage, and display management tasks.