Discover Awesome MCP Servers

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.

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.

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.

agloop-mcp

An MCP server providing 14 introspection tools for AgLoop, a custom agent framework for VS Code Copilot. It enables users to monitor and manage agent states, tasks, execution logs, and plans through a set of specialized read and write tools.

LogicMonitor MCP Server

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

capus

Persona-driven LLM agent testing for macOS and web apps through a local MCP daemon, enabling autonomous GUI testing with human-like behavior.

Go Process Inspector

Inspetor de goroutines não invasivo

fastmail-mcp

An MCP server for Fastmail that provides access to email, contacts, and calendars via the JMAP protocol. It enables users to search, send, and bulk-manage emails while also interacting with calendar events and address books through natural language.

Apache Hbase MCP Server by CData

Apache Hbase MCP Server by CData

Agent Handoff Certified MCP

Verifiable agent-to-agent task handoff with signed provenance chain.

OpenSumi

Um framework ajuda você a construir rapidamente produtos IDE nativos de IA. O MCP Client oferece suporte a ferramentas do Protocolo de Contexto de Modelo (MCP) por meio do servidor MCP.

MCP Vault

Enables AI assistants to interact with Obsidian vaults through file operations like moving/renaming files and analyzing markdown heading structures. Bridges AI assistants with Obsidian using the Local REST API plugin for seamless vault management.

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.

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.

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.

jcrawl4ai-mcp-server

jcrawl4ai-mcp-server

dobbe

Automates DevOps workflows like vulnerability resolution, code review, test generation, and DORA metrics through Claude Code slash commands, using a state machine for reliable execution.

x402-discovery

Discovers and queries x402-payable APIs at runtime — enables autonomous agents to find, evaluate, and pay for services via USDC micropayments on Base without API keys or subscriptions.

google-workspace-mcp-with-script

MCP server for Claude Code CLI that integrates with Google Workspace, enabling management of Docs, Sheets, Drive, Gmail, Calendar, and Apps Script.

GoScry

GoScry é uma aplicação de servidor escrita em Go que atua como uma ponte entre um sistema de controle (como um LLM ou script) e um navegador web.

Sponge MCP Server

Provides a Model Context Protocol interface to the Sponge wallet API for managing digital assets and transaction histories. It enables users to securely check balances, retrieve addresses, and perform transfers using DAuth-style credential exchange.

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.