Discover Awesome MCP Servers

MySQL MCP Server

Permite a interação segura com bancos de dados MySQL, permitindo que assistentes de IA listem tabelas, leiam dados e executem consultas SQL através de uma interface controlada.

API

Uma coleção de projetos Swift que visam construir um servidor MCP para completar tarefas pessoais.

PokeAPI MCP Server

A Model Context Protocol server that interfaces with PokeAPI to provide Pokémon information to LLM applications through JSON-RPC over stdio.

SAP Business One MCP Server by CData

SAP Business One MCP Server by CData

Bybit Server

Interact seamlessly with the Bybit API to fetch market data, manage your account, and execute trades. Leverage powerful tools to enhance your trading experience and automate your strategies effortlessly. If you wish to use an API key restricted to your personal IP address, you must configure the MCP

Ogury MCP Server

An MCP server that gives Claude access to Ogury's campaign reporting API, enabling retrieval of campaign performance metrics and reports through natural language queries.

Pharmaceutical Benefits Scheme API Server

Um servidor independente do Protocolo de Contexto de Modelo que permite que modelos de IA acessem os dados da API do Australian Pharmaceutical Benefits Scheme (PBS), incluindo listagens de medicamentos, preços e informações de disponibilidade.

Medium MCP Server

A protocol server that enables programmatic interaction with Medium's content ecosystem, allowing for intelligent content retrieval and context-aware analysis.

MariaDB / MySQL Database Access MCP Server

Um servidor MCP que fornece acesso a bancos de dados MariaDB ou MySQL.

MCP Boilerplate

A modern, lightning-fast starter template for building Model Context Protocol applications with Bun, enabling developers to create MCP servers with TypeScript support, validation, and environment configuration.

Browser Monitoring MCP Server

Abre um navegador para monitorar e recuperar logs do console e requisições de rede, fornecendo dados estruturados sobre o comportamento de páginas web para LLMs.

Bluesky Context Server

Um servidor MCP simples que permite que clientes MCP consultem instâncias Bluesky.

fhir-mcp-server-medagentbench

Uma implementação de servidor do Protocolo de Contexto do Modelo para uso com o MedAgentBench (geração de requisições FHIR).

Wikidata MCP Server

Uma implementação de servidor para interagir com a API do Wikidata usando o Protocolo de Contexto de Modelo, fornecendo ferramentas para pesquisar identificadores, extrair metadados e executar consultas SPARQL.

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.

JIRA MCP Server

Provides tools for AI assistants to interact with JIRA APIs, enabling them to read, create, update, and manage JIRA issues through standardized MCP tools.

Mermaid Chart MCP

Enables AI assistants to generate and render Mermaid diagrams (flowcharts, sequence diagrams, etc.) as PNG/SVG images with local file saving and HTTP access URLs. Supports batch processing and intelligent caching for efficient diagram creation.

jcrawl4ai-mcp-server

jcrawl4ai-mcp-server

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.

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.

MCP Config

Uma ferramenta CLI para gerenciar configurações de servidores MCP.

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.

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 Manager

An enterprise-level MCP gateway and proxy that sits between an organization's MCP servers and clients. MCP Manager mitigates security threats, enables fine-grained permissions, enforces policies and guardrails, and generates comprehensive, end-to-end logs.

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.