Discover Awesome MCP Servers

mcp-weather

A Model Context Protocol (MCP) server that enables AI assistants and LLMs to access real-time weather data and forecasts by connecting to the OpenWeatherMap API.

Joomla MCP Server

Joomla MCP Server

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.

Remote MCP Server

A Cloudflare Workers implementation of Model Context Protocol server that enables Claude AI to access external tools through OAuth authentication.

A2A Client MCP Server

An MCP server that enables LLMs to interact with Agent-to-Agent (A2A) protocol compatible agents, allowing for sending messages, tracking tasks, and receiving streaming responses.

Go Process Inspector

Inspetor de goroutines não invasivo

Mcp Server Kakao Map

kakao map mcp server

MCP-Censys

Um servidor de Protocolo de Contexto de Modelo que permite consultas em linguagem natural da API de Busca Censys para reconhecimento de domínio, IP e FQDN, fornecendo informações sobre hosts, DNS, certificados e serviços em tempo real.

SeekChat

O SeekChat suporta a execução de ferramentas MCP, permitindo que a IA controle diretamente seu computador e execute diversas tarefas. Automatize facilmente o gerenciamento de arquivos, análise de dados, desenvolvimento de código e muito mais, transformando a IA em um assistente verdadeiramente inteligente.

MariaDB / MySQL Database Access MCP Server

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

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.

jcrawl4ai-mcp-server

jcrawl4ai-mcp-server

MySQL Database Server

Permite que LLMs interajam com bancos de dados MySQL, inspecionando esquemas e executando consultas seguras e somente leitura dentro de transações.

mcp-painter

Ferramenta de Desenho para Assistentes de IA

Tushare MCP Server

Um servidor baseado no Protocolo de Contexto de Modelo (Model Context Protocol) que permite que assistentes de IA consultem e pesquisem informações sobre ações usando a API Tushare.

MCP Server

Um proxy de serviço de IA moderno que permite a interação com múltiplos provedores de IA (Anthropic Claude, OpenAI) através de uma API unificada, implantado globalmente usando Cloudflare Workers.

mcp-qdrant-docs MCP Server

Um servidor MCP que extrai dados de websites, indexa o conteúdo no Qdrant e fornece uma ferramenta de consulta.

MCP Car Database

Um sistema cliente-servidor que utiliza o Protocolo de Contexto de Modelo (Model Context Protocol) que permite aos usuários consultar um banco de dados SQLite com dados fictícios de carros.

readme-updater-mcp

Here's a translation of "MCP server to update README.md using Ollama for conflict analysis" into Portuguese, along with some considerations for different contexts: **Option 1 (Most Direct Translation):** * **Servidor MCP para atualizar o README.md usando o Ollama para análise de conflitos.** **Option 2 (More Explanatory):** * **Servidor MCP para atualizar o arquivo README.md, utilizando o Ollama para analisar e resolver conflitos.** **Option 3 (Focusing on the Purpose):** * **Servidor MCP para atualização do README.md com análise de conflitos realizada pelo Ollama.** **Explanation of Choices and Considerations:** * **MCP Server:** "MCP server" is likely a technical term. I've kept it as "Servidor MCP" as it's likely understood within the specific context. If you have more information about what "MCP" stands for, you might be able to translate it more accurately. * **README.md:** "README.md" is a standard filename and is often left untranslated in technical contexts. I've kept it as "README.md" in the first option. The second and third options use "arquivo README.md" for clarity. * **Ollama:** "Ollama" is likely a proper noun (a software name), so it's best to leave it as "Ollama." * **Conflict Analysis:** "Conflict analysis" translates directly to "análise de conflitos." * **"Utilizando" vs. "Usando":** Both "utilizando" and "usando" mean "using." "Utilizando" is slightly more formal. I've used "usando" in the first option and "utilizando" in the second for a bit of variety. * **"Para":** The word "para" is used to indicate purpose or intention. **Which option is best?** The best option depends on your audience and the level of formality you want to convey. * **Option 1** is the most direct and concise. It's suitable if your audience is familiar with the technical terms. * **Option 2** is slightly more explanatory, making it a good choice if you want to ensure clarity. * **Option 3** focuses on the overall purpose, which might be useful in a summary or overview. I recommend choosing the option that best suits your specific needs and target audience. If you can provide more context about the MCP server and its purpose, I can refine the translation further.

esa MCP Server

Uma interface que permite que a IA Claude interaja com a API da esa para pesquisar, criar e atualizar documentos através do Protocolo de Contexto do Modelo.

MCP Server NestJS

A robust server-side application that implements Model Context Protocol (MCP) for file operations, providing authentication and modular REST APIs for managing files, users, and posts.

Master Control Program (MCP) Backend

Provides API endpoints for a hotel management frontend and integrates with SmartThings API to control devices based on user preferences and room assignments.