Discover Awesome MCP Servers

chuk-mcp-celestial

Provides authoritative astronomical data including moon phases, solar eclipses, and sun/moon rise and set times using the US Navy API or offline Skyfield calculations. It enables users to query Earth's seasons and celestial events for any location and date.

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.

Things MCP Server

A Model Context Protocol server that enables AI assistants to interact with the Mac application 'Things' for task management operations through its URL scheme.

Laminar MCP Server

Integrates Laminar workspaces with AI editors to manage workflows, steps, and configuration stores. It allows users to execute, monitor, and debug workflow executions through natural language commands.

Personal Context MCP Server

Enables managing personal information with dynamic topic-based organization (tasks, meetings, contacts, etc.), supporting optional OTP authentication and AES-256 encryption for sensitive data with automatic backups.

Mcp Todo App

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

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

SQL Server Express MCP Server

Facilita a interação com o Microsoft SQL Server Express, oferecendo suporte a operações de banco de dados como consultas, gerenciamento de tabelas e inspeção de esquema por meio de comandos MCP em linguagem natural.

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.

VLC MCP Server

Um servidor MCP (Protocolo de Contexto de Modelo) para reproduzir e controlar filmes usando o VLC.

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!

MCP Server Boilerplate

A basic TypeScript starter template for building Model Context Protocol (MCP) servers with example function implementation and development tooling.

zk-mcp

Servidor MCP para zk

Oura Ring MCP Server

Enables access to Oura Ring health data including sleep patterns, activity metrics, readiness scores, heart rate, workouts, and stress measurements with AI-powered analysis and personalized recommendations.

MCP Boilerplate

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

Yahoo Finance MCP Server

Provides access to real-time stock prices, financial statements, news, and options data via the Model Context Protocol. It enables AI assistants to retrieve comprehensive market data, including historical prices and analyst recommendations, through a standardized interface.

redshift-utils-mcp

redshift-utils-mcp

Next.js MCP Server

A sample MCP server implementation for Next.js projects that uses the Vercel MCP Adapter to handle protocol requests across different transport methods.

Neon MCP Server

Espelho de

Guokao MCP

Enables intelligent querying and matching of 2025 Chinese civil service examination positions based on personal qualifications, including education, major, political status, work experience, and location preferences.

Bear App MCP Server

A Model Context Protocol server that integrates with Bear App, enabling AI assistants to create, search, modify, and organize notes and tags through X-callback-URL scheme.

CtrlTest MCP Server

Enables control system analysis and testing through PID controller evaluation against second-order plants. Provides regression testing utilities with step response analysis, gust rejection metrics, and settling time calculations for control engineering applications.

SpiderFoot MCP Server

Enables interaction with SpiderFoot's OSINT scanning capabilities through Claude and other MCP-compatible tools. Supports comprehensive scan management, real-time monitoring, result retrieval, and export functionality for reconnaissance and investigation workflows.

Dumpling AI MCP Server

Integrates with Dumpling AI to provide data scraping, content processing, knowledge management, and code execution capabilities through tools for web interactions, document handling, and AI services.

MCP HTTP Fetcher Server

Fetches web pages from HTTP/HTTPS URLs and converts them to Markdown format. Supports both SSE and Stdio protocols for web deployments, Kubernetes environments, and desktop clients.

IMAP MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que assistentes de IA acessem e gerenciem e-mails através de IMAP, suportando a navegação, pesquisa, leitura e organização de e-mails, ao mesmo tempo em que aprende as preferências do usuário ao longo do tempo.

Curl MCP Server

Enables full curl functionality within the Model Context Protocol, allowing users to execute network requests with support for custom headers and host networking. It facilitates interaction with local and external APIs, including those using self-signed certificates, directly through Docker.