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)

31
1
Medium Cost
stefanstranger icon

avm-mcp-server

by stefanstranger

Sec9

This server acts as an MCP gateway for AI agents and tools to discover, search, and retrieve detailed documentation for Azure Verified Modules (AVM) from the Bicep Public Registry.

Setup Requirements

  • ⚠️Requires Python 3.11 or higher.
  • ⚠️Requires the UV package manager to be installed (specifically `uvx` for the recommended run command).
  • ⚠️Requires internet connectivity to access Microsoft Container Registry and GitHub.
Verified SafeView Analysis
Fetches markdown content from `raw.githubusercontent.com` for AVM module documentation. Input `url` for `scrape_avm_module_details` is validated via a specific regex to ensure it targets legitimate `github.com` URLs, mitigating arbitrary URL injection risks. The server does not execute or interpret the fetched markdown; clients rendering this content should perform their own sanitization to prevent potential XSS from compromised external markdown. No `eval` or hardcoded secrets found.
Updated: 2025-11-29GitHub→
31
6
Medium Cost
MCPRUNNER icon

mssqlMCP

by MCPRUNNER

Sec9

The SQL Server MCP (Model Context Protocol) Server enables AI assistants like GitHub Copilot within Visual Studio Code to interact with SQL Server databases, allowing for SQL query execution, detailed database metadata retrieval, and management of connections and security.

Setup Requirements

  • ⚠️Requires .NET 8.0 SDK or later.
  • ⚠️Mandatory environment variables (MSSQL_MCP_KEY and MSSQL_MCP_API_KEY) must be securely configured; scripts are provided for generation but values must be saved externally.
  • ⚠️Access to an SQL Server instance is required for database operations.
Verified SafeView Analysis
The project implements robust security features, including AES-256 encryption for connection strings, multi-tier API key authentication with role-based access control and connection-level restrictions, and comprehensive input validation to prevent SQL injection and dangerous commands. Encryption keys and API keys are managed via environment variables and scripts to avoid hardcoding. While the server defaults to HTTP, the documentation explicitly recommends HTTPS for production environments, which would require an external reverse proxy. Regular key rotation and monitoring are also advised for optimal security.
Updated: 2025-11-20GitHub→
31
1
Medium Cost
accuknox icon

mcp_server

by accuknox

Sec2

The AccuKnox MCP server provides a multi-cloud asset management and security posture solution, allowing AI agents to search cloud assets, retrieve AI/ML model vulnerabilities, and manage findings through a unified interface.

Setup Requirements

  • ⚠️Requires an AccuKnox API Token, obtained from the AccuKnox CSPM dashboard, which implies a reliance on a commercial AccuKnox platform.
  • ⚠️Requires Python 3.10 or higher for execution.
  • ⚠️Configuration files for clients (e.g., `.vscode/mcp.json`) mandate the use of absolute paths for server command and arguments, which can be brittle if the project directory moves.
  • ⚠️The `USER_GUIDE.md` advises strict reliance on a `.env` file for `ACCUKNOX_BASE_URL` and `ACCUKNOX_API_TOKEN` for the stdio server, potentially conflicting with `mcp.json` `env` configurations or HTTP client header/query parameters.
Review RequiredView Analysis
The primary critical security risk is the widespread use of `httpx.AsyncClient(verify=False)` across multiple files (`shared/api.py`, `shared/utils/api_utils.py`, `shared/utils/auth_validator.py`). This disables SSL/TLS certificate verification for all API calls to the AccuKnox backend and JWKS endpoints. This vulnerability makes the server highly susceptible to Man-in-the-Middle (MITM) attacks, allowing an attacker to intercept, read, or tamper with sensitive data (e.g., cloud asset details, vulnerability reports, API tokens) in transit. Additionally, the `_get_auth_context` function in `fastmcp_server.py` allows API tokens and base URLs to be passed via URL query parameters, which is less secure than HTTP headers and could lead to their exposure in server logs or browser history.
Updated: 2025-12-05GitHub→
31
1
Medium Cost
edujuan icon
Sec9

A comprehensive MCP server that helps AI coding agents understand and implement the Universal Tool Calling Protocol (UTCP) by providing documentation search, validation, generation, and an LLM-powered expert agent.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid service) for the 'ask_utcp_expert' tool and 'semantic_search_docs' tool.
  • ⚠️Requires Node.js 20.x or higher and npm 9.x or higher.
  • ⚠️The 'DOCS_PATH' environment variable should correctly point to the UTCP documentation directory, defaulting to the current directory.
Verified SafeView Analysis
The server leverages environment variables for sensitive API keys (e.g., OpenAI). It interacts with external APIs (OpenAI) for the expert agent, with retry mechanisms and timeouts implemented for robustness. Documentation loading from a configurable path could pose a minimal risk if an attacker controls the path, but content is used for LLM context, not direct execution. Input validation is performed for UTCP manuals and OpenAPI specs.
Updated: 2025-11-22GitHub→
31
1
Low Cost
WebLegions icon

mcp-agg

by WebLegions

Sec9

Aggregates Model Context Protocol (MCP) servers (stdio, SSE, HTTP) and exposes their tools via a high-performance Fastify HTTP API.

Setup Requirements

  • ⚠️Requires Bun runtime (>= 1.3.0) to be installed.
  • ⚠️Requires external Model Context Protocol (MCP) servers (Stdio, SSE, or HTTP) to be configured for full functionality beyond the 'builtin' tools.
Verified SafeView Analysis
The project demonstrates strong security practices including explicit prototype pollution prevention, custom optimized input validation, and use of security middleware (Helmet, CORS, rate limiting). It leverages environment variables for sensitive configurations and mentions vulnerability scanning in CI/CD. The primary potential risk is the configuration of external MCP servers (via `.mcp.json`), which, if compromised, could direct the aggregator to untrusted endpoints. This is an operational security concern rather than a code vulnerability within the server itself.
Updated: 2025-12-01GitHub→
31
1
Medium Cost
luutuankiet icon

fs-mcp

by luutuankiet

Sec9

This server provides a 'Human-in-the-Loop' filesystem interface for LLM agents, enabling interactive code editing and review with developer oversight.

Setup Requirements

  • ⚠️Requires `uvx` for quick installation and execution (or `uv` for package management and direct Python invocation).
  • ⚠️VS Code CLI (`code` command) must be installed and available in the system's PATH for the `propose_and_review` tool to automatically launch diff windows.
  • ⚠️Requires Python 3.10 or newer.
  • ⚠️The `google-genai` library is needed for Streamlit UI's Gemini schema conversion feature; ensure it's installed (e.g., `uv add google-genai`).
Verified SafeView Analysis
The `validate_path` function is robust, ensuring all file operations are strictly confined to explicitly allowed directories and the system's temporary directory. Access to the temporary directory is further restricted to specific patterns (e.g., `mcp_review_` directories and `current_`/`future_` files within them), preventing arbitrary file creation or access in `/tmp`. The use of `subprocess.Popen(..., shell=True)` for launching VS Code is generally a risk, but in this implementation, the command's arguments are carefully constructed from validated path components, minimizing shell injection risks.
Updated: 2026-01-16GitHub→
31
1
High Cost

material-web-mcp

by shantoislamdev

Sec8

Provides an MCP server for AI agents to programmatically access Material Web documentation, generate templates, and validate HTML code.

Setup Requirements

  • ⚠️Requires Node.js >= 18.17
Verified SafeView Analysis
The project runs a local server for AI agents, exposing programmatic access to documentation and HTML generation/validation tools. While the tools themselves appear limited to documentation and templating, running any local server inherently carries a minimal risk of potential exploitation if not properly secured, though the README does not indicate broader system access or explicit vulnerabilities. No 'eval' or obfuscation is apparent.
Updated: 2025-11-17GitHub→
31
1
Low Cost
switchbm icon

claude-redline

by switchbm

Sec7

Provides a human-in-the-loop review interface, allowing AI agents to pause for interactive user feedback on markdown documents and code during development workflows.

Setup Requirements

  • ⚠️Requires `uv` (Python's fast package manager) to be installed as a prerequisite.
  • ⚠️Requires Python 3.12+.
  • ⚠️The local HTTP server has no authentication, making it theoretically vulnerable to other malicious processes running on the same local machine.
  • ⚠️MCP configuration requires a sufficiently long timeout (e.g., 24 hours) to prevent review sessions from timing out while waiting for human input.
Verified SafeView Analysis
The server runs a local HTTP server on `127.0.0.1` (localhost only) without authentication. This means any other process on the user's local machine could potentially interact with its API endpoints. However, path traversal attacks are mitigated for file access via the `/api/file` endpoint by resolving paths and checking against a base directory. It is designed for single-user, local use.
Updated: 2025-12-12GitHub→
31
1
Low Cost
yujiterada icon

mcp-server-verkada

by yujiterada

Sec3

This server connects AI agents, assistants, and chatbots to the Verkada Command platform by providing a Model Context Protocol (MCP) interface to Verkada APIs for security-related functions like access control, camera management, guest interactions, and sensor data.

Setup Requirements

  • ⚠️Requires Node.js >= 18.0.0.
  • ⚠️Requires a Verkada API Key, which must be obtained and configured as an environment variable.
  • ⚠️Requires manual configuration in `claude_desktop_config.json` with an absolute path to the built server entry point.
Review RequiredView Analysis
The most critical security risk identified is the potential for Local File Inclusion (LFI) via the `updateProfilePhoto` tool. The input schema for this tool's body parameter `file` is `z.string().optional()` with a description stating "Profile photo file path (formatted @/<image-path>)". This format strongly suggests the server will attempt to read a file from the local filesystem based on user-provided input, which could allow an attacker to read arbitrary files if not robustly sanitized and validated. While Zod is used for validation, the specific handling of this `@/<image-path>` pattern in `callVerkadaAPI` is not fully visible, but the pattern itself is inherently risky. Standard Node.js `npm install` practices also present supply chain risks if dependencies are compromised. The server relies on environment variables for API keys (`VERKADA_API_KEY`), which is a good practice to avoid hardcoding secrets in source code.
Updated: 2026-01-19GitHub→
31
1
Medium Cost
matebenyovszky icon

agentplaybooks

by matebenyovszky

Sec9

Provides a Model Context Protocol (MCP) server for AI agents, offering platform-independent memory, skill management, and persona definitions.

Setup Requirements

  • ⚠️Requires a Supabase account setup (URL, anonymous key, and service role key).
  • ⚠️Requires configuration of OAuth providers (Google, GitHub, LinkedIn OIDC) for user authentication, likely within Supabase.
  • ⚠️Requires Docker for the most straightforward self-hosting deployment.
Verified SafeView Analysis
The project demonstrates strong security practices, including robust authentication and authorization via Supabase, API key validation with granular permissions (`memory:read`, `playbooks:write`), and strict ownership checks for resources. Input validation is present for API routes, and file attachment uploads are well-sanitized to prevent path traversal and binary content. No 'eval' or direct code execution from user input is observed. Sensitive keys are expected from environment variables.
Updated: 2026-01-16GitHub→
31
1
Medium Cost
XuYunlei icon
Sec9

An agentic voice-to-voice product discovery assistant performing RAG and web searches over an Amazon product dataset to provide grounded answers.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid service for GPT-4o-mini, Whisper, and TTS).
  • ⚠️Requires a Brave Search API Key (potentially paid or free-tier limited). Note: The `mcp_server/tools/web_tool.py` expects `SEARCH_API_KEY` environment variable, but `configs/env.example` defines `BRAVE_API_KEY`. Users must either rename the variable in their `.env` to `SEARCH_API_KEY` or modify `web_tool.py` to use `BRAVE_API_KEY` for web search functionality to work.
  • ⚠️Requires `ffmpeg` installed on the system for Whisper ASR, which is not part of the `requirements.txt`.
Verified SafeView Analysis
The server uses environment variables for API keys (e.g., OpenAI, Brave), preventing hardcoding of secrets. Input validation is provided by Pydantic models for FastAPI endpoints. External API calls (Brave, OpenAI TTS) use `httpx` with timeouts and error handling. The `critic` node includes basic safety checks. The MCP server is designed to run locally (127.0.0.1:8000), reducing direct external exposure risks. No 'eval' or malicious patterns were found. A minor potential improvement is to explicitly implement domain allowlisting for web search results as mentioned in `SAFETY.md`.
Updated: 2025-11-21GitHub→
31
1
Medium Cost
mcp-fortress icon

mcp-fortress

by mcp-fortress

Sec9

Provides automated security scanning, runtime protection, and vulnerability detection for Model Context Protocol (MCP) servers and AI agent tools within developer environments.

Setup Requirements

  • ⚠️Requires one-time authentication with Smithery for marketplace installation.
  • ⚠️Manual local installation requires `npm install -g mcp-fortress` and modifying `claude_desktop_config.json`.
  • ⚠️Requires Node.js runtime for local installation.
Verified SafeView Analysis
The project's primary purpose is security scanning and threat detection, demonstrating a strong security-first approach in its architecture and documented findings (e.g., `postmark-mcp` analysis). The provided client-side script (`docs/script.js`) is benign. However, the core server-side 'Scanner Engine' and 'API Server' implementations are explicitly stated as 'closed source' in `CONTRIBUTING.md`. This prevents a full code audit of these critical components, meaning the analysis relies on the detailed documentation of its functionality and security principles rather than direct code inspection for its core logic. The tool itself is designed to detect dangerous patterns like 'eval' and 'child_process' in *other* packages.
Updated: 2025-11-30GitHub→
PreviousPage 199 of 760Next