Stop Searching. Start Trusting.

The curated directory of MCP servers, vetted for security, efficiency, and quality.

Browse DirectoryWhy Us?

Tired of the MCP "Marketplace" Chaos?

We built MCPScout.ai to solve the ecosystems biggest pain points.

No Insecure Dumps

We manually analyze every server for basic security flaws.

Easy Setup

Our gotcha notes warn you about complex setups.

Avoid "Token Hogs"

We estimate token costs for cost-effective agents.

Products, Not Demos

We filter out "Hello World" demos.

CATEGORIES:
SORT:

Vetted Servers(9120)

30
1
Medium Cost
lhabacuc icon

MCP-server

by lhabacuc

Sec2

An AI-powered DevOps and PC automation agent that interprets natural language commands to interact with the local filesystem, terminal, Git, and desktop environment via a web interface or command-line.

Setup Requirements

  • ⚠️Requires GROQ_API_KEY (paid service) to be configured as an environment variable.
  • ⚠️Python 3.8 or higher is required.
  • ⚠️PyAutoGUI functionalities (desktop automation, screenshots) require a graphical display environment and potentially additional system dependencies (e.g., `scrot` on Linux) to be fully functional.
Review RequiredView Analysis
CRITICAL RISK: The agent provides tools (e.g., `run_command` with `shell=True`, file manipulation, desktop automation via `pyautogui`) that allow the AI to execute arbitrary shell commands and control the user's PC without explicit human confirmation for each action. This is a severe vulnerability for remote code execution, data manipulation, and privacy breaches if the AI misinterprets instructions, its prompts are manipulated, or the web server is exposed externally without robust authentication.
Updated: 2026-01-17GitHub→
30
1
Low Cost

DROMA_MCP

by DROMA01

Sec8

The DROMA MCP Server provides a natural language interface for AI assistants to perform cancer pharmacogenomics data analysis and querying.

Setup Requirements

  • ⚠️Requires a pre-existing DROMA SQLite database, which must be provided by the user and is not included with the installation.
  • ⚠️Requires R 4.0+ and manual installation of specific R packages (`DROMA.Set`, `DROMA.R`) via `devtools::install_github`.
Verified SafeView Analysis
The project uses the FastMCP framework and mentions a MseeP.ai Security Assessment Badge, indicating security considerations. Potential risks include the `rpy2` integration, which allows Python to execute R code, and running in HTTP mode, which exposes a network port. Ensure the R environment and DROMA packages are trusted, and the HTTP server is secured if exposed externally.
Updated: 2025-11-17GitHub→
30
1
Medium Cost
ChistokhinSV icon

gns3-mcp

by ChistokhinSV

Sec5

A FastAPI service that acts as a Model Context Protocol (MCP) server for GNS3, enabling AI agents to automate network lab creation, configuration, and troubleshooting through SSH, console, TFTP, and HTTP proxy functionalities.

Setup Requirements

  • ⚠️Requires GNS3 server instance to be running and accessible.
  • ⚠️Requires Docker for deploying the SSH proxy service, which is a core component.
  • ⚠️For Windows service installation, requires 'uv/uvx' and 'WinSW', along with administrator privileges to set environment variables and install the service.
  • ⚠️PNG diagram export requires the 'cairosvg' library, which is an optional dependency.
Review RequiredView Analysis
The system utilizes an SSH proxy service that exposes a `/local/execute` endpoint, allowing arbitrary commands to be run via `subprocess.run(shell=True)` without explicit input sanitization. This is a critical remote code execution vulnerability if the proxy is exposed or compromised. Although intended for local execution within a Docker container, this pattern introduces significant risk. API key authentication is implemented for HTTP transport, but if `MCP_API_KEY` is not set, it's auto-generated and logged, which could expose it if logs are accessible. The `verify_ssl=False` option for GNS3 connections, while practical for self-signed certificates in labs, reduces overall security by disabling certificate validation.
Updated: 2025-11-30GitHub→
30
1
Medium Cost
wuye-ai icon
Sec7

Provides a Model Context Protocol (MCP) server that acts as an intelligent AI assistant for the property management industry, offering daily news and a specialized knowledge base.

Setup Requirements

  • ⚠️Requires a CRIC Wuye AI Access Token for functionality (obtained via their website).
  • ⚠️Requires Node.js (v16.0.0+) and npm (v8.0.0+) to run locally.
  • ⚠️Requires an MCP-compatible client (e.g., MCP Inspector, Cline) to interact with the server.
Verified SafeView Analysis
Based on the provided truncated source code (primarily READMEs and configuration files), there are no immediately apparent hardcoded secrets or malicious patterns. The server utilizes environment variables or HTTP headers for Access Token management, which is good practice. However, a full security audit of the `index.js` implementation code is not possible due to its summary status, so potential vulnerabilities within the core logic cannot be assessed.
Updated: 2026-01-19GitHub→
30
1
Medium Cost
grokify icon

aha-mcp-server

by grokify

Sec9

This server enables AI assistants to retrieve and search various Aha! workspace data objects by exposing them as tools via the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires an Aha! workspace with API access.
  • ⚠️Requires a generated Aha! API token.
  • ⚠️Requires Go 1.24.1 or later to build/run from source.
Verified SafeView Analysis
The server uses environment variables for sensitive credentials (AHA_API_TOKEN, AHA_DOMAIN), which is a good security practice. API interactions are conducted over HTTPS. The GraphQL search tool uses parameterized queries to mitigate injection risks. No obvious use of 'eval' or other highly dangerous dynamic code execution patterns were found.
Updated: 2026-01-13GitHub→
30
1
Medium Cost
Ignaceassuring178 icon

ai-local-agents

by Ignaceassuring178

Sec8

Provides various local AI agents for voice interaction, basic chat, web scraping, and PDF document summarization and Q&A using Ollama LLMs and Streamlit UIs.

Setup Requirements

  • ⚠️Requires a local Ollama server running with the desired LLM (e.g., 'phi', 'llama3') downloaded.
  • ⚠️Requires microphone access and potentially additional system packages (e.g., 'espeak' on Linux) for the voice assistant.
Verified SafeView Analysis
The code primarily uses well-established libraries (requests, BeautifulSoup, PyPDF2, LangChain, Streamlit) for parsing and data handling, reducing the risk of direct command injection. There are no explicit uses of 'eval()' or 'exec()', nor hardcoded API keys/secrets for external services. However, several components process arbitrary user-provided URLs (web scraper) or uploaded PDF files (PDF bot) and pass this content to a local LLM. This introduces a potential, albeit mitigated, risk of prompt injection or resource exhaustion if very large or malicious content is fed to the LLM or if the scraping/parsing process encounters malformed inputs. Content limits (e.g., '[:2000]', '[:3000]', '[:5000]') are in place to mitigate large input issues. The 'speech_recognition' library by default uses Google's speech recognition API, which sends audio data externally; users concerned about privacy should configure a local STT engine or be aware of this. Given that LLMs are run locally (Ollama), the direct network exposure is minimized. The primary risks are more at the application logic level (LLM interaction, potentially malformed input handling) rather than critical code execution vulnerabilities.
Updated: 2026-01-19GitHub→
30
1
Medium Cost
Knuckles-Team icon

documentdb-mcp

by Knuckles-Team

Sec5

Provides an LLM-powered agent and tools for managing and querying DocumentDB (MongoDB-compatible) instances, including CRUD operations, collection, and user management.

Setup Requirements

  • ⚠️Requires an external DocumentDB (or MongoDB) instance, or can use the provided `ghcr.io/microsoft/documentdb/documentdb-local:latest` Docker image.
  • ⚠️Requires access to an LLM provider (e.g., OpenAI API Key, Anthropic API Key, or a local Ollama setup). Defaults to OpenAI with `http://localhost:1234/v1` and API key 'llama' for local testing.
  • ⚠️Docker and Docker Compose are the primary intended deployment methods, simplifying the setup of multiple interdependent services.
Review RequiredView Analysis
The `run_command` tool (`documentdb_mcp.py`) allows executing arbitrary commands directly against the DocumentDB instance, posing a significant security risk if an LLM agent is compromised or misbehaves. The `pickle.load` function is used in `utils.py` for model loading, which can lead to remote code execution if untrusted `.pkl` files are processed. Binding services to `0.0.0.0` in Docker Compose is common but requires careful external firewall configuration to prevent unintended network exposure. While authentication mechanisms like JWT/OIDC are supported, they do not mitigate the inherent danger of the `run_command` tool if an authenticated entity uses it maliciously.
Updated: 2026-01-19GitHub→
30
1
High Cost
alexchilton icon
Sec3

Manages a Calibre ebook library and enriches metadata by exposing various tools and capabilities to AI models like Claude Desktop.

Setup Requirements

  • ⚠️Requires Calibre ebook management software installed with CLI tools (`calibredb`, `ebook-meta`) accessible in system PATH (e.g., `/Applications/calibre.app/Contents/MacOS/`).
  • ⚠️Requires `CALIBRE_LIBRARY_PATH` environment variable to be correctly configured for the user's Calibre library (e.g., `/Users/YOUR_USERNAME/Calibre Library`).
  • ⚠️First run will download large machine learning models (~350MB combined for semantic search and genre classification), requiring internet access and disk space. This can cause initial delays.
Review RequiredView Analysis
Extensive use of `subprocess.run` to interact with `calibredb` and `ebook-meta` CLI tools. Several tool parameters (e.g., `search_term`, `query`, `file_path`, `title`, `authors`, `isbn` in `calibre_tools/cli_wrapper.py`) are passed directly from user input without explicit sanitization, posing a risk of command injection, which could lead to arbitrary code execution or data manipulation if the underlying Calibre CLI tools are vulnerable to such input. The `calibre_sql` tool executes arbitrary SQL queries (though in read-only mode), which could lead to information disclosure of database schema or denial-of-service via resource-intensive queries. No obvious hardcoded secrets were found. Consider implementing `shlex.quote` for all user-provided arguments passed to subprocess calls.
Updated: 2025-12-05GitHub→
30
1
Medium Cost
airy10 icon

GedcomMCP

by airy10

Sec5

A robust MCP server for AI agents to create, edit, and query genealogical data from GEDCOM files.

Setup Requirements

  • ⚠️Requires local file system read/write permissions for GEDCOM files, which could pose a security risk if not run in a sandboxed environment.
  • ⚠️Optimal usage assumes interaction via `fastmcp`, `qwen-cli`, or `gemini-cli` tools.
  • ⚠️Requires `fuzzywuzzy` and `python-levenshtein` for fuzzy search functionality; the server will issue a warning if these are not installed, and fuzzy search will be unavailable.
Verified SafeView Analysis
The server allows loading and saving GEDCOM files to arbitrary paths on the local file system specified by the user. While `validate_gedcom_path` checks for a `.ged` extension and file/directory existence, it uses `Path(file_path).resolve()`, which does not sandbox access to a specific safe directory. This means a malicious actor (or an overzealous AI agent) could instruct the server to read or write any `.ged` file accessible by the server process's user permissions, potentially leading to unauthorized data access or modification outside the intended project directory if the server is not run in a strictly contained environment (e.g., a Docker container with restricted volume mounts, or as a low-privilege user). No hardcoded secrets or 'eval' statements were found.
Updated: 2025-11-27GitHub→
30
1
Medium Cost

Freelance-MCP-Server

by N1KH1LT0X1N

Sec5

This is a backend server designed to manage and automate freelancing tasks, potentially leveraging AI capabilities for enhanced functionality.

Setup Requirements

  • ⚠️Docker and Docker Compose required for deployment.
  • ⚠️Requires environment variables for configuration (e.g., database credentials, API keys) as indicated by .env.example.
  • ⚠️Requires API key for an AI service (e.g., OpenAI, Anthropic) due to the presence of 'ai_features.py'.
Review RequiredView Analysis
Server application inherently carries network exposure risks. Without access to code, specific vulnerabilities like 'eval' or API key handling cannot be assessed. Reliance on external AI services (suggested by 'ai_features.py') and APIs (suggested by 'API_RESEARCH.md') introduces potential supply chain and data exposure risks if not securely configured.
Updated: 2025-11-18GitHub→
30
1
Medium Cost
kiransth77 icon

aionmcp

by kiransth77

Sec3

AionMCP serves as a model-independent tool server for AI agents and LLMs, dynamically importing OpenAPI, GraphQL, and AsyncAPI specifications to expose them as executable tools. It includes self-learning capabilities, autonomous documentation, and real-time monitoring.

Setup Requirements

  • ⚠️Requires Go 1.21+ development environment for building and running directly.
  • ⚠️No built-in authentication/authorization for the API by default, making it insecure for public exposure.
  • ⚠️Requires Docker/Docker Compose for containerized setup, or manual Go build and execution.
Review RequiredView Analysis
CRITICAL: The core server's API endpoints (e.g., /api/v1/import-spec, /api/v1/tools/:name/invoke) appear to lack authentication and authorization by default. This allows any client to import specifications and execute tools, posing a significant security risk if exposed to untrusted networks. Future enhancements mention JWT-based agent authentication, but it's not currently implemented. The `import-spec` API also allows specifying local file paths or arbitrary URLs, which could lead to path traversal or Server-Side Request Forgery (SSRF) vulnerabilities if not properly sanitized. Running in a production or untrusted environment without an external API gateway, strong firewall rules, and robust authentication is highly insecure.
Updated: 2025-11-30GitHub→
30
1
Medium Cost
JesusMaster icon

github-see-mcp-server

by JesusMaster

Sec6

Integrate GitHub API functionalities (Issues, Pull Requests, Repositories) into a Model Context Protocol (MCP) server using Server-Sent Events (SSE) for AI agent interaction.

Setup Requirements

  • ⚠️Requires Node.js v16 or higher.
  • ⚠️Requires a GitHub Personal Access Token, which needs to be generated and configured in a `.env` file.
  • ⚠️Default CORS policy (`origin: "*"`) is insecure for production environments and should be explicitly configured via `CORS_ALLOW_ORIGIN` environment variable.
Verified SafeView Analysis
The server uses environment variables for sensitive data like GITHUB_TOKEN and API_KEY, which is good practice. Input sanitization is implemented using DOMPurify for potentially user-generated content, mitigating some injection risks. However, CORS is configured with `origin: "*"` by default (`app.use(cors({ origin: "*" }))`), which poses a significant security risk by allowing any domain to interact with the server. For production, `CORS_ALLOW_ORIGIN` should be explicitly set to restrict access. Additionally, the GitHub Personal Access Token is expected to be passed from the client (`mcp-remote`) in a `GITHUB_TOKEN` header, meaning the server acts as a proxy for the client's token. This design shifts the responsibility of token security and scope management to the client and upstream agent, rather than the MCP server enforcing granular access with a server-side token. While common in some proxy patterns, it implies a higher trust in the client, and `API_KEY`'s role in client authentication is not clearly demonstrated in the provided code snippet.
Updated: 2025-12-02GitHub→
PreviousPage 223 of 760Next