Discover Awesome MCP Servers

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.

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.

RFC MCP Server

An MCP server that enables programmatic access to IETF RFC documents, allowing users to fetch, search, and extract specific sections from RFCs.

MCP Hello World

A minimal reference implementation of an MCP server that responds with "Hello, World" via Streamable HTTP. Serves as a baseline for integration testing and MCP client development with production-ready features including health checks, metrics, and containerized deployment.

mcptesting

Repositório de teste criado via servidor MCP

PrivateGPT MCP Server

Facilita a integração do PrivateGPT com aplicações compatíveis com MCP, permitindo funcionalidades de chat e gestão segura de fontes de conhecimento e acesso de usuários.

ATTENTION: LLM-GENERATED CODE

Servidor MCP do LimeSurvey

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.

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.

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.

Tiddly MCP

Connects AI agents to TiddlyWiki through the Model Context Protocol, enabling listing, searching, filtering, creating, updating, and deleting tiddlers. Defaults to read-only mode with optional write permissions.

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

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

Wealth Management MCP

Provides specialized tools for portfolio health analysis, rebalance simulations, and trade execution via a single interface powered by MongoDB. It enables AI agents to manage investment portfolios while adhering to organizational governing rules, clearance guards, and rate limits.

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

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.

korean-agriculture-mcp

MCP server for Korean agricultural wholesale market real-time auction data from 32+ markets with 63K+ daily records via data.go.kr public API.

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.

むらっけ MPC Server

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

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.

Freepik FastMCP Toolkit

A Model Context Protocol (MCP) server that connects AI assistants directly with Freepik's APIs, allowing users to search, generate, and manage visual content without leaving their AI workflow.

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.

IDA-MCP

Enables interaction with multiple IDA Pro instances through MCP, allowing users to list functions, search instances, and manage reverse engineering analysis across different binary files. Supports multi-instance coordination with automatic discovery and tool forwarding between IDA Pro sessions.

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.

Access MCP Server by CData

Access MCP Server by CData