Discover Awesome MCP Servers

claude-usage-guard

An MCP server that exposes Claude Code's real-time rate limit usage so that an orchestrator can check remaining capacity before launching subtasks.

Hardware Manual RAG MCP Server

Enables querying hardware manuals (PDF/HTML) using local RAG with ChromaDB and embeddings, allowing Claude Code to look up pinouts, registers, and specifications.

CoderSwap MCP Server

Enables AI agents to autonomously create and manage topic-specific vector knowledge bases with end-to-end functionality including project creation, content ingestion from URLs, semantic search, and progress tracking. Provides a complete research workflow without exposing low-level APIs.

MCP Recipes Server

Um servidor que expõe ferramentas para consultar receitas usando o Protocolo de Contexto do Modelo (MCP).

Emotional De-escalation MCP Server

Provides strategic dialogue management and emotional de-escalation for customer support bots, detecting problem patterns and recommending actions like escalation to a human operator.

LogicMonitor MCP Server

MCP server enabling AI assistants to interact with your LogicMonitor, providing 125 tools for comprehensive monitoring and management operations.

paperless-mcp

Connects Claude to a self-hosted Paperless-ngx document archive, enabling natural language search, retrieval, and taxonomy browsing of documents.

vSphere-MCP-Pro

Enables secure management of VMware vCenter 8.0+ environments through controlled operations including VM lifecycle management, snapshots, and resource discovery with built-in RBAC authorization, audit logging, and rate limiting.

TimeMCP

Servidor MCP em Golang para substituir o servidor MCP modelcontextprotocol/time

Ad Library MCP

Searches and analyzes competitor ads and content across Meta, Google, Instagram, TikTok, and YouTube with AI-powered creative analysis and cross-platform brand discovery.

mfp-mcp

Connect MyFitnessPal to Claude or any MCP client. Log meals, search food database with macros, track trends, and export nutrition history against your real MyFitnessPal diary.

Merge MCP Server

Provides integration between Merge API and LLM providers supporting the MCP protocol, allowing natural language interaction with Merge data across HRIS, ATS, and other categories.

MySSL MCP Server

O Servidor MCP MySSL

MonetizeAgent

AI agent monetization directory with 75+ entries. Search, filter, and discover ways for AI agents to earn revenue across platforms and protocols.

lucid-mcp-server

MCP server for Lucid App integration that enables AI-powered analysis and management of Lucid diagrams.

FastAPI SSE MCP Random

A FastAPI server implementing the Model Context Protocol (MCP) for structured tool use, providing utility tools including random number generation, image generation via Azure OpenAI DALL-E, and AI podcast generation.

known-path

A lightweight MCP server that activates only trusted catalog assets for a data job, performs trust checks, and generates SQL artifacts.

MCP Leave Management

Simulates a leave management workflow for employees and managers, including leave application, balance checks, and approval processes.

mcp-zeroentropy

MCP Server for ZeroEntropy collections, top documents and rerankers

spaceship-mcp

A community-built MCP server for the Spaceship API, enabling management of domains, DNS records, contacts, and marketplace listings through natural language.

Futuur API MCP Integration

Futuur API MCP Integration é um servidor poderoso baseado em TypeScript que implementa o Protocolo de Contexto de Modelo (MCP) para uma integração perfeita com a API Futuur. Este projeto fornece uma interface robusta para lidar com dados de mercado, categorias, informações de usuário e operações de apostas.

Run Command MCP Server

Provides tools for executing shell commands both synchronously and asynchronously with real-time output streaming and process management capabilities. It enables users to start background tasks, monitor progress, and manage long-running processes via Stdio or HTTP transports.

Outlook MCP Server

Enables AI-powered email management for Microsoft Outlook, allowing users to search, compose, organize, and batch forward emails using natural language commands with 100% local processing.

MCP Server Demo

A WebSocket-based Model Control Protocol (MCP) server that processes model requests and provides responses. Supports chat and text completion actions with a standardized JSON protocol for AI model communication.

BatchIt

A simple aggregator server that allows batching multiple MCP tool calls into a single request, reducing token usage and network overhead for AI agents.

crypto-mcp-server

Enables EVM blockchain operations through Alchemy RPC, including balance queries, contract interactions, transaction sending, and message signing, with multi-chain support across mainnets and testnets.

mcp-pandoc-ts: A Document Conversion MCP Server (TypeScript/Host Service Version)

Here's a breakdown of how to create an MCP (Message Control Protocol) server that allows a Docker container to control a Pandoc installation on the host machine, along with code snippets and explanations: **Concept** The core idea is to have a simple server running on the host machine that listens for commands from the Docker container. These commands will be Pandoc commands. The server then executes Pandoc locally and returns the output (or errors) back to the Docker container. MCP is a lightweight protocol that can be used for this purpose. **Components** 1. **Host Service (Pandoc Controller):** A Python script (or similar) running on the host machine. This script: * Listens on a specific port for incoming MCP messages. * Parses the MCP message to extract the Pandoc command. * Executes the Pandoc command using `subprocess`. * Captures the output (stdout and stderr) of the Pandoc command. * Formats the output into an MCP response and sends it back to the Docker container. 2. **Docker Container:** Your application running inside the Docker container. This application: * Constructs an MCP message containing the Pandoc command. * Sends the MCP message to the host service (using the host's IP address and the port the service is listening on). * Receives the MCP response from the host service. * Parses the MCP response to extract the Pandoc output (or error). 3. **MCP Protocol:** A simple protocol for communication. For example: * **Request:** `COMMAND:pandoc -s input.md -o output.pdf` * **Response (Success):** `STATUS:OK\nOUTPUT: [PDF data as base64 or a path to a file]` * **Response (Error):** `STATUS:ERROR\nOUTPUT: [Error message]` **Python Host Service (pandoc_controller.py)** ```python import socket import subprocess import base64 import os HOST = '0.0.0.0' # Listen on all interfaces PORT = 65432 # Port to listen on def execute_pandoc(command): """Executes the Pandoc command and returns the output.""" try: process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = process.communicate() return_code = process.returncode if return_code == 0: return "OK", stdout.decode('utf-8') # Decode to string else: return "ERROR", stderr.decode('utf-8') # Decode to string except Exception as e: return "ERROR", str(e) def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") with conn: while True: data = conn.recv(1024) if not data: break message = data.decode('utf-8').strip() print(f"Received: {message}") if message.startswith("COMMAND:"): pandoc_command = message[len("COMMAND:"):].strip() status, output = execute_pandoc(pandoc_command) response = f"STATUS:{status}\nOUTPUT:{output}" conn.sendall(response.encode('utf-8')) else: response = "STATUS:ERROR\nOUTPUT:Invalid command format" conn.sendall(response.encode('utf-8')) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) ``` **Explanation of `pandoc_controller.py`:** * **Imports:** Imports necessary modules: `socket` for network communication, `subprocess` for running Pandoc, `base64` for encoding binary data (if needed), and `os` for file operations. * **`HOST` and `PORT`:** Defines the host address and port the server will listen on. `0.0.0.0` means listen on all available network interfaces. * **`execute_pandoc(command)`:** * Takes the Pandoc command as a string. * Uses `subprocess.Popen` to execute the command. `shell=True` is used for simplicity, but be aware of the security implications if the command comes from an untrusted source. Consider using `shell=False` and passing the command as a list of arguments if possible. * Captures the standard output (`stdout`) and standard error (`stderr`) of the command. * Returns the status ("OK" or "ERROR") and the output (or error message). * **`handle_client(conn, addr)`:** * Handles a single client connection. * Receives data from the client. * Parses the message to extract the Pandoc command (if the message starts with "COMMAND:"). * Calls `execute_pandoc` to run the command. * Constructs an MCP response with the status and output. * Sends the response back to the client. * **Main Loop:** * Creates a socket. * Binds the socket to the specified host and port. * Listens for incoming connections. * Accepts a connection and calls `handle_client` to handle it. **Docker Container Code (Example in Python)** ```python import socket HOST = '172.17.0.1' # Replace with the actual IP address of your host machine PORT = 65432 def send_pandoc_command(command): """Sends a Pandoc command to the host service and returns the output.""" try: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) message = f"COMMAND:{command}" s.sendall(message.encode('utf-8')) data = s.recv(4096) # Adjust buffer size as needed response = data.decode('utf-8') status = None output = None for line in response.splitlines(): if line.startswith("STATUS:"): status = line[len("STATUS:"):] elif line.startswith("OUTPUT:"): output = line[len("OUTPUT:"):] if status == "OK": return output else: raise Exception(f"Pandoc error: {output}") except Exception as e: print(f"Error communicating with host service: {e}") return None if __name__ == "__main__": pandoc_command = "pandoc -s input.md -o output.pdf" # Example command try: result = send_pandoc_command(pandoc_command) print("Pandoc Output:", result) except Exception as e: print(f"Error: {e}") ``` **Explanation of Docker Container Code:** * **`HOST` and `PORT`:** The IP address of the *host machine* (not the container's IP). You'll need to determine the host's IP address. A common way to find this is to use the gateway IP address of the Docker network. On Linux, you can often find this with `ip route show default`. The IP address after `via` is usually the host's IP. `172.17.0.1` is a common default, but it might be different on your system. The port should match the port the host service is listening on. * **`send_pandoc_command(command)`:** * Creates a socket and connects to the host service. * Constructs the MCP message: `COMMAND:pandoc ...`. * Sends the message to the host service. * Receives the response from the host service. * Parses the response to extract the status and output. * Returns the output if the status is "OK", otherwise raises an exception. * **Main Block:** * Defines the Pandoc command to execute. * Calls `send_pandoc_command` to send the command to the host service. * Prints the output or any error messages. **Steps to Run:** 1. **Save the code:** Save the host service code as `pandoc_controller.py` and the Docker container code as `app.py` (or similar). 2. **Install Pandoc on the Host:** Make sure Pandoc is installed and accessible in the host's `PATH`. 3. **Run the Host Service:** On the host machine, run the Python script: ```bash python3 pandoc_controller.py ``` 4. **Create a Dockerfile:** Create a `Dockerfile` for your Docker container: ```dockerfile FROM python:3.9-slim-buster WORKDIR /app COPY app.py . #COPY input.md . # If you have an input file # Install any dependencies your Docker container needs #RUN pip install ... CMD ["python", "app.py"] ``` 5. **Build the Docker Image:** Build the Docker image: ```bash docker build -t my-pandoc-app . ``` 6. **Run the Docker Container:** Run the Docker container, making sure to map the port and set the correct host IP: ```bash docker run --rm my-pandoc-app ``` **Important Considerations:** * **Security:** This setup has security implications. The Docker container can execute arbitrary Pandoc commands on the host machine. If the Docker container is compromised, the attacker could potentially use this to execute malicious commands on the host. Consider these mitigations: * **Input Validation:** Carefully validate the Pandoc commands received by the host service to prevent command injection attacks. Whitelist allowed options and arguments. * **User Permissions:** Run the host service under a user account with limited privileges. Don't run it as root. * **Firewall:** Use a firewall to restrict access to the host service's port. Only allow connections from the Docker container's IP address. * **Alternatives:** Consider using a more secure approach, such as a dedicated API with authentication and authorization, or running Pandoc in a separate, isolated container. * **Error Handling:** Implement robust error handling in both the host service and the Docker container. Log errors to help with debugging. * **File Access:** If the Pandoc commands need to access files on the host machine, you'll need to handle file paths carefully. Consider using absolute paths or mounting a volume from the host into the Docker container. * **Binary Data:** If Pandoc outputs binary data (like a PDF), you'll need to encode it (e.g., using base64) before sending it over the network. The example code includes `base64` import, but you'll need to add the encoding/decoding logic. Alternatively, you could have Pandoc write the output to a file on a shared volume and then have the Docker container read the file. * **Host IP Address:** The host IP address can change. You might need to use a more dynamic way to determine the host's IP address from within the Docker container. Environment variables or a discovery service could be used. * **MCP Complexity:** For more complex interactions, consider using a more robust messaging protocol like gRPC or REST. However, for simple command execution, MCP is often sufficient. **Example with Base64 Encoding (for Binary Output)** **Host Service (pandoc_controller.py - Modified)** ```python import socket import subprocess import base64 import os HOST = '0.0.0.0' # Listen on all interfaces PORT = 65432 # Port to listen on def execute_pandoc(command): """Executes the Pandoc command and returns the output.""" try: process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = process.communicate() return_code = process.returncode if return_code == 0: # Check if the output is binary (e.g., PDF) try: stdout.decode('utf-8') # Try decoding as UTF-8 is_binary = False except UnicodeDecodeError: is_binary = True if is_binary: output = base64.b64encode(stdout).decode('utf-8') # Encode as base64 else: output = stdout.decode('utf-8') # Decode to string return "OK", output else: return "ERROR", stderr.decode('utf-8') # Decode to string except Exception as e: return "ERROR", str(e) def handle_client(conn, addr): """Handles a single client connection.""" print(f"Connected by {addr}") with conn: while True: data = conn.recv(1024) if not data: break message = data.decode('utf-8').strip() print(f"Received: {message}") if message.startswith("COMMAND:"): pandoc_command = message[len("COMMAND:"):].strip() status, output = execute_pandoc(pandoc_command) response = f"STATUS:{status}\nOUTPUT:{output}" conn.sendall(response.encode('utf-8')) else: response = "STATUS:ERROR\nOUTPUT:Invalid command format" conn.sendall(response.encode('utf-8')) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) ``` **Docker Container Code (app.py - Modified)** ```python import socket import base64 HOST = '172.17.0.1' # Replace with the actual IP address of your host machine PORT = 65432 def send_pandoc_command(command): """Sends a Pandoc command to the host service and returns the output.""" try: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) message = f"COMMAND:{command}" s.sendall(message.encode('utf-8')) data = s.recv(4096) # Adjust buffer size as needed response = data.decode('utf-8') status = None output = None for line in response.splitlines(): if line.startswith("STATUS:"): status = line[len("STATUS:"):] elif line.startswith("OUTPUT:"): output = line[len("OUTPUT:"):] if status == "OK": return output else: raise Exception(f"Pandoc error: {output}") except Exception as e: print(f"Error communicating with host service: {e}") return None if __name__ == "__main__": pandoc_command = "pandoc -s input.md -o output.pdf" # Example command try: result = send_pandoc_command(pandoc_command) if result: # Decode the base64 encoded PDF data pdf_data = base64.b64decode(result) # Save the PDF to a file with open("output_from_docker.pdf", "wb") as f: f.write(pdf_data) print("PDF saved to output_from_docker.pdf") else: print("No output received from Pandoc.") except Exception as e: print(f"Error: {e}") ``` Key changes in the Base64 example: * **Host Service:** The `execute_pandoc` function now checks if the output is binary. If it is, it encodes the output using base64 before sending it back. It attempts to decode the output as UTF-8; if that fails, it assumes it's binary. * **Docker Container:** The `app.py` script now decodes the base64 encoded data and saves it to a file. This revised example handles binary output (like PDFs) correctly. Remember to adjust the buffer size (`s.recv(4096)`) as needed to accommodate the size of the output. This comprehensive explanation and code should give you a solid foundation for building your MCP-based Pandoc controller. Remember to prioritize security and error handling in your implementation.

CapCutAPI-Complete MCP Server

Enables video editing operations such as trimming, merging, adding audio/text/effects, and exporting via MCP protocol, leveraging CapCut core functionalities.

Lunar Calendar MCP Server

Provides Chinese traditional calendar functions including BaZi calculation, solar-lunar calendar conversion, Huangli almanac queries, daily fortune readings, 24 solar terms, and Wu Xing (Five Elements) analysis.

Reservation System MCP Server

An MCP server that allows AI models to securely access and manage WeChat Cloud-based reservation data. It provides tools for querying records, updating appointment statuses, and deleting entries through the WeChat Cloud Development API.