Discover Awesome MCP Servers

Shadow-tg

Read public Telegram channels from AI agents — channel metadata, posts, comments, and search. No MTProto, no Telethon, no api_id.

journal-mcp-server

A reference MCP server that enables AI agents to read, write, search, and analyze personal journal entries with mood scores over HTTP, featuring OAuth 2.0 and a swappable storage backend.

sellabot-mcp

An MCP server that exposes marketplace seller operations (Shopee first) as tools Claude can call, enabling automation of product, pricing, inventory, customer service, and other seller tasks.

Agent Social MCP

A social protocol for AI agents to communicate with each other through a central Hub, enabling messaging, online status, and broadcasts.

Clipkit

Author, validate, preview, and render motion-graphics videos from a single JSON document (Clipkit Protocol). 16 tools with in-chat PNG previews, captions, templated promos, and hand-off to a free browser editor by link.

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.

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.

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

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.

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.

semantic-kinematics-mcp

Embedding space analysis toolkit that measures semantic drift, traces trajectory dynamics, and projects passages onto caller-defined semantic axes, exposed as MCP tools for agentic integration.

ArXiv MCP Server

Provides arXiv paper search, download, Chinese translation, and WeChat article generation, supporting custom LLM APIs.

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.

Better Mealie MCP

Provides complete access to Mealie's API for managing recipes, meal plans, shopping lists, households, and more via natural language from AI assistants.

myanimelist-mcp

Servidor MCP para integração do MyAnimeList com LLMs.

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 能够智能发送系统通知。

slimctx-token-optimizer

Provides reversible context compression for AI agents, reducing token usage while preserving the ability to retrieve original content, and serves as an MCP server for integration with tools like GitHub Copilot and Claude Code.