Discover Awesome MCP Servers

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.

MCP Terminal Tool Server

An MCP server that enables users to execute arbitrary shell commands on their local machine and receive the output. It provides a terminal tool for running system commands through MCP-compatible clients using the Python SDK.

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.

Internal Data MCP Server

Exposes internal employee directories and project management systems to AI models through standardized tools and resources. It enables AI assistants to search for team members, query project statuses, and explore organizational hierarchies with secure role-based access control.

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.

Rembg MCP Server

Enables AI-powered background removal from images using multiple specialized models including u2net, birefnet, and isnet. Supports both single image processing and batch folder operations with advanced options like alpha matting and mask-only output.

MCP Boilerplate

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

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.

crypto-pegmon-mcp

crypto-pegmon-mcp

Riyadh Districts MCP Server

Provides tools for querying 192 Riyadh districts with Arabic/English name support, calculating distances between districts using the Haversine formula, and searching district information with coordinates.

IGDB MCP Server

Provides access to the Internet Game Database (IGDB) API, enabling users to search for video games, retrieve detailed game information including ratings and platforms, and discover trending and anticipated titles.

MCP Math Calculator Server

Enables basic mathematical operations through MCP protocol with add and multiply tools. Built with fastmcp 2.0 and optimized for serverless deployment on Vercel.

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.

Wave Accounting MCP Server

Integrates Claude with Wave Accounting to automate expense tracking and income transaction creation from receipts and payment data.

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.

mcpproxy-go

Local-first MCP proxy with BM25 tool discovery, quarantine security, Docker isolation, OAuth support, activity logging, and web UI. Routes multiple upstream MCP servers through a single endpoint.

Facebook Ads Library MCP Server

This MCP server lets you search Facebook's Ad Library, retrieve brand ads, and analyze ad images/videos using AI - all with intelligent caching and batch processing for efficiency.

Access MCP Server by CData

Access MCP Server by CData

VeyraX MCP

Provides unified access to all tools integrated with the VeyraX platform through a single authentication. Eliminates the need for multiple logins by connecting once to access all your tools across any MCP-compatible environment.

PipeCD Docs MCP Server

Enables searching and retrieving official PipeCD documentation through full-text search and document retrieval. Clones PipeCD docs from GitHub and indexes Markdown files for quick access to titles and content.