Discover Awesome MCP Servers

Perplexity MCP Server

Una implementación personalizada del Protocolo de Contexto de Modelo que integra Perplexity AI con Claude Desktop, permitiendo a los usuarios acceder a los modelos de IA de Perplexity tanto para preguntas individuales como para conversaciones de múltiples turnos.

mcp-ppt

design ppt

GitHub Code Review MCP Server

A Model Context Protocol server that provides read-only access to GitHub repositories, enabling AI assistants to perform code reviews without write permissions.

readme-updater-mcp

Okay, I understand. You want me to translate the following instruction into Spanish: "MCP server to update README.md using Ollama for conflict analysis." Here's the translation: **"Servidor MCP para actualizar README.md usando Ollama para el análisis de conflictos."** Here are a few alternative translations, depending on the nuance you want to convey: * **More literal:** "Servidor MCP para actualizar el archivo README.md, utilizando Ollama para el análisis de conflictos." (This is slightly more formal and emphasizes the file.) * **Focus on the action:** "Servidor MCP que actualiza README.md, empleando Ollama para analizar conflictos." (This emphasizes the updating action.) The first translation, "Servidor MCP para actualizar README.md usando Ollama para el análisis de conflictos," is likely the best and most natural-sounding option.

esa MCP Server

Una interfaz que permite a Claude AI interactuar con la API de esa para buscar, crear y actualizar documentos a través del Protocolo de Contexto del 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.

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.

Browserbase MCP Server

Enables cloud browser automation through Browserbase and Stagehand, allowing LLMs to interact with web pages, take screenshots, extract data, and perform automated actions with support for proxies, stealth mode, and parallel sessions.

MCP Config

Una herramienta CLI para gestionar las configuraciones de servidores MCP.

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

Okay, here's a breakdown of how you could achieve an MCP (Microservice Control Protocol) server setup to control Pandoc on your host machine from a Docker environment, along with considerations and potential code snippets (in Python, as it's commonly used for microservices). **Concept:** The core idea is to create a small server (the MCP server) running on your host machine. This server will: 1. **Receive requests:** Listen for requests from your Docker container. These requests will specify the Pandoc conversion to perform (input file, output file, options, etc.). 2. **Execute Pandoc:** Run the Pandoc command on the host machine using the provided parameters. 3. **Return results:** Send the output (success/failure, any error messages) back to the Docker container. **Components:** * **Pandoc Host Service (MCP Server):** This is the Python server running on your host. It uses a framework like Flask or FastAPI to handle HTTP requests. * **Docker Container:** Your application running inside Docker. It will make HTTP requests to the Pandoc Host Service. * **Pandoc:** Must be installed on the *host* machine, not necessarily inside the Docker container. **Steps:** 1. **Pandoc Host Service (Python - Flask Example):** ```python from flask import Flask, request, jsonify import subprocess import os app = Flask(__name__) @app.route('/pandoc', methods=['POST']) def pandoc_convert(): data = request.get_json() input_file = data.get('input_file') output_file = data.get('output_file') options = data.get('options', []) # Default to empty list if no options if not input_file or not output_file: return jsonify({'error': 'Missing input_file or output_file'}), 400 # Construct the Pandoc command command = ['pandoc', input_file, '-o', output_file] + options try: result = subprocess.run(command, capture_output=True, text=True, check=True) return jsonify({'status': 'success', 'output': result.stdout}) except subprocess.CalledProcessError as e: return jsonify({'status': 'error', 'error': e.stderr, 'returncode': e.returncode}), 500 except FileNotFoundError: return jsonify({'status': 'error', 'error': 'Pandoc not found. Ensure it is installed on the host.'}), 500 except Exception as e: return jsonify({'status': 'error', 'error': str(e)}), 500 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) # Listen on all interfaces ``` * **Explanation:** * Uses Flask to create a simple web server. * `/pandoc` endpoint accepts POST requests. * Expects JSON data with `input_file`, `output_file`, and optional `options`. * Constructs the Pandoc command using `subprocess.run`. `check=True` raises an exception if Pandoc returns a non-zero exit code (error). * Captures the standard output and standard error from Pandoc. * Returns a JSON response indicating success or failure, along with any output or error messages. * Error handling is included for common issues (missing files, Pandoc not found, etc.). * `host='0.0.0.0'` makes the server accessible from outside the host machine (important for Docker). * `port=5000` You can choose a different port if needed. 2. **Docker Container (Python Example):** ```python import requests import json def convert_with_pandoc(input_file, output_file, options=None): url = 'http://<host_ip>:5000/pandoc' # Replace <host_ip> with your host's IP address headers = {'Content-type': 'application/json'} data = { 'input_file': input_file, 'output_file': output_file, 'options': options or [] } try: response = requests.post(url, data=json.dumps(data), headers=headers) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) result = response.json() if result['status'] == 'success': print("Pandoc conversion successful!") print("Output:", result['output']) return True else: print("Pandoc conversion failed:") print("Error:", result['error']) return False except requests.exceptions.RequestException as e: print(f"Error connecting to Pandoc service: {e}") return False if __name__ == '__main__': # Example usage: input_file = 'my_input.md' # Replace with your input file (must be accessible to the host) output_file = 'my_output.pdf' # Replace with your desired output file pandoc_options = ['--pdf-engine=xelatex', '--toc'] # Example Pandoc options # Create a dummy input file for testing with open(input_file, 'w') as f: f.write("# Hello, Pandoc from Docker!") success = convert_with_pandoc(input_file, output_file, pandoc_options) if success: print(f"Successfully converted {input_file} to {output_file}") else: print(f"Conversion failed.") ``` * **Explanation:** * Uses the `requests` library to make HTTP POST requests. * `url`: **Crucially, replace `<host_ip>` with the actual IP address of your host machine.** This is how the Docker container finds the Pandoc Host Service. If you are running Docker Desktop, this is often the IP address of your network interface. You can find it using `ipconfig` (Windows) or `ifconfig` (Linux/macOS) on your host. Alternatively, on some systems, `host.docker.internal` might work, but it's not universally reliable. * `data`: Constructs the JSON payload to send to the server. * Error handling: Catches `requests.exceptions.RequestException` for network errors. * `response.raise_for_status()`: Checks for HTTP errors (4xx, 5xx) and raises an exception if one occurs. 3. **Docker Setup (Dockerfile):** ```dockerfile FROM python:3.9-slim-buster WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . CMD ["python", "your_script.py"] # Replace your_script.py with the name of your Python file ``` * **Explanation:** * Uses a Python base image. * Sets the working directory to `/app`. * Copies `requirements.txt` (see below) and installs the dependencies. * Copies the rest of your application code. * Specifies the command to run when the container starts. 4. **`requirements.txt`:** ``` Flask requests ``` * Lists the Python packages your Docker container needs. **Important Considerations and Troubleshooting:** * **Host IP Address:** This is the most common point of failure. Make sure the IP address in the Docker container's `url` is correct and that the host machine is accessible from the container. Using `host.docker.internal` *might* work on some Docker setups, but it's not guaranteed. The most reliable approach is to find the actual IP address of your host's network interface. * **Firewall:** Ensure that your host machine's firewall is not blocking connections to the port you're using (e.g., port 5000). You may need to create a firewall rule to allow incoming connections on that port. * **File Paths:** The `input_file` and `output_file` paths in the JSON data are *relative to the host machine's file system*. The Docker container doesn't have direct access to files inside the container unless you use volume mounts (see below). Therefore, the files you want to convert must be accessible on the host machine's file system. * **Volume Mounts (Alternative to Shared File System):** If you want to work with files *inside* the Docker container, you can use Docker volume mounts. This allows you to share a directory between the host and the container. For example: ```bash docker run -v /path/on/host:/path/in/container ... ``` Then, in your Python code, you would use the paths *inside the container* (e.g., `/path/in/container/my_input.md`). However, you'd still need to ensure that the host service can access the files. A common pattern is to mount the same directory on both the host and the container. * **Security:** This setup is *not* inherently secure. Anyone who can access the Pandoc Host Service can potentially execute arbitrary Pandoc commands on your host machine. Consider adding authentication and authorization to the service if security is a concern. For example, you could use API keys or JWT tokens. * **Error Handling:** The example code includes basic error handling, but you should add more robust error handling for production environments. Log errors, handle different types of exceptions, and provide informative error messages to the user. * **Pandoc Installation:** Make absolutely sure Pandoc is installed and accessible on the host machine. The `PATH` environment variable must be configured correctly so that the `pandoc` command can be found. * **Asynchronous Processing (Optional):** For long-running Pandoc conversions, consider using asynchronous processing (e.g., with Celery or Redis Queue) to avoid blocking the Flask server. This will improve the responsiveness of your application. * **Alternative Frameworks:** While Flask is a good starting point, FastAPI is another excellent choice for building APIs in Python. It's known for its performance and automatic data validation. **Example Workflow:** 1. **Host Machine:** * Install Pandoc. * Create the Python script for the Pandoc Host Service (e.g., `pandoc_server.py`). * Run the Pandoc Host Service: `python pandoc_server.py` 2. **Docker Container:** * Create the Python script that makes requests to the Pandoc Host Service (e.g., `pandoc_client.py`). * Create the `Dockerfile` and `requirements.txt`. * Build the Docker image: `docker build -t my-pandoc-app .` * Run the Docker container: `docker run my-pandoc-app` (Remember to set up volume mounts if needed and ensure the host IP is correct in your client script). **Spanish Translation of Key Concepts:** * **MCP (Microservice Control Protocol):** Protocolo de Control de Microservicios * **Host Machine:** Máquina Anfitrión / Servidor Anfitrión * **Docker Container:** Contenedor Docker * **Pandoc Host Service:** Servicio Anfitrión de Pandoc / Servidor Anfitrión de Pandoc * **Endpoint:** Punto de Acceso / Punto Final * **Payload:** Carga Útil * **Volume Mount:** Montaje de Volumen * **Firewall:** Cortafuegos * **Asynchronous Processing:** Procesamiento Asíncrono This comprehensive explanation should give you a solid foundation for building your MCP-based Pandoc control system. Remember to adapt the code and configuration to your specific needs and environment. Good luck!

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.

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

Here are a few options for translating "Non-Invasive goroutine inspector" into Spanish, with slightly different nuances: * **Inspector de gorutinas no invasivo:** This is a direct and common translation. It emphasizes the "non-invasive" aspect clearly. * **Inspector de gorutinas no intrusivo:** This is very similar to the first option, using "no intrusivo" instead of "no invasivo." Both are good choices, with "no intrusivo" perhaps sounding slightly more technical. * **Herramienta de inspección de gorutinas no invasiva:** This translates to "Non-invasive goroutine inspection tool." It's a bit more descriptive. * **Analizador de gorutinas no invasivo:** This translates to "Non-invasive goroutine analyzer." "Analizador" might be preferred if the tool performs more in-depth analysis than just inspection. The best choice depends on the specific context and the intended audience. If you want a simple and clear translation, the first two options are excellent. If you want to emphasize that it's a tool, use the third. If you want to emphasize analysis, use the fourth.

PR Reviewer

Una herramienta que se integra con GitHub y Notion para analizar y revisar pull requests, permitiendo revisiones de código automatizadas y documentación en Notion.

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.

Futuur API MCP Integration

Futuur API MCP Integration es un potente servidor basado en TypeScript que implementa el Protocolo de Contexto de Modelo (MCP) para una integración perfecta con la API de Futuur. Este proyecto proporciona una interfaz robusta para el manejo de datos de mercado, categorías, información de usuario y operaciones de apuestas.

MCP Recipes Server

Un servidor que expone herramientas para consultar recetas utilizando el Protocolo de Contexto del Modelo (MCP).

Azure Table MCP Server by CData

Azure Table MCP Server by CData

Apache Hbase MCP Server by CData

Apache Hbase MCP Server by CData

OpenSumi

Un marco de trabajo te ayuda a construir rápidamente productos IDE nativos de IA. El cliente MCP es compatible con las herramientas del Protocolo de Contexto del Modelo (MCP) a través del servidor MCP.

Fastly

Fastly

Slack MCP Server

A comprehensive Slack integration server that enables sending messages, managing channels, uploading files, and running Pomodoro timers through FastMCP v2.

KMB Bus MCP Server

Un servidor de Protocolo de Contexto de Modelo que proporciona acceso en tiempo real a la información de rutas y horarios de llegada de los autobuses KMB y Long Win de Hong Kong, permitiendo a los Modelos de Lenguaje responder a las preguntas de los usuarios sobre rutas de autobús, paradas y horas estimadas de llegada (ETA).

Reddit MCP Server

Enables interaction with Reddit through OAuth 2.1 authentication, providing tools for searching content, managing notifications, analyzing posts and comments, and demonstrating advanced MCP features like sampling and real-time notifications.

Amazon DynamoDB MCP Server by CData

Amazon DynamoDB MCP Server by CData