Discover Awesome MCP Servers

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.

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

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.

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.

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.

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.

protocols-io-mcp-server

A Model Context Protocol (MCP) server that enables MCP clients like Claude Desktop to interact with protocols.io, a popular platform for sharing scientific protocols and methods.

Gmail MCP Agent

Enables automated Gmail lead nurturing campaigns with intelligent follow-ups, response tracking, and 24/7 operation. Supports CSV-based contact management, template personalization, and real-time monitoring for enterprise-scale email outreach.

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-qdrant-docs MCP Server

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

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.

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.

Mcp Autotest

Utilitário para teste automático de servidores MCP

PocketBase MCP Server

Um servidor abrangente que permite operações avançadas de banco de dados com o PocketBase, fornecendo ferramentas para gerenciamento de coleções, operações de registro, gerenciamento de usuários e administração de banco de dados através do Protocolo de Contexto de Modelo.

Riza MCP Server

Um servidor MCP que envolve a API do Interpretador de Código Riza e apresenta os endpoints como ferramentas individuais.

MCP Log Reader

Um servidor MCP especializado que ajuda a analisar e depurar logs do Protocolo de Contexto de Modelo, fornecendo ao Claude acesso direto a arquivos de log em múltiplas plataformas.

MCP Recipes Server

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

Go Process Inspector

Inspetor de goroutines não invasivo

Apache Hbase MCP Server by CData

Apache Hbase MCP Server by CData

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.

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

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.

opgen MCP Server

Uma implementação de servidor MCP para geração de senhas, baseada em 1Password/spg/cmd/opgen.

Yellhorn MCP

Um servidor MCP que conecta o Gemini 2.5 Pro ao Claude Code, permitindo que os usuários gerem planos de implementação detalhados com base em sua base de código e recebam feedback sobre alterações no código.

Azure Table MCP Server by CData

Azure Table MCP Server by CData

Fastly

Fastly

Asana MCP Server

Multi-Agent Conversation Protocol server that enables interaction with Asana's task management API, allowing users to manage projects, tasks, and team collaboration through natural language.