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
High Cost
Riti0208 icon

nano-banana-mcp

by Riti0208

Sec8

This server provides a Model Context Protocol (MCP) interface for advanced image generation, editing, analysis, and batch processing using Google's Gemini 2.5 Flash Image Preview and Gemini 3 Pro Image Preview models.

Setup Requirements

  • ⚠️Requires a Google Gemini API Key (paid service).
  • ⚠️Requires Node.js 18.0.0 or higher.
Verified SafeView Analysis
The server uses `@modelcontextprotocol/sdk` with a `StdioServerTransport`, which primarily communicates over standard I/O, limiting direct external network exposure. The Google Gemini API key is correctly managed via environment variables (`GEMINI_API_KEY`) and not hardcoded. File system operations (`fs.readFile`, `fs.writeFile`, `fs.mkdir`) are performed for image input and output. The default output directory is `~/Downloads/nano-banana-images`, but custom `outputDir` and `imagePath` arguments are accepted. While control over these paths could theoretically lead to unintended file access in a highly compromised client environment, this is a common and expected interaction for a local agent-based tool and not an inherent vulnerability in the server logic itself. No 'eval' or other direct code execution vulnerabilities were found.
Updated: 2025-12-09GitHub→
30
1
Medium Cost
vishnu2kmohan icon

mcp-server-langgraph

by vishnu2kmohan

Sec9

A production-ready Model Context Protocol (MCP) server for building and deploying multi-LLM LangGraph agents, complete with fine-grained authorization, comprehensive observability, and a unique visual workflow builder that generates production-ready Python code.

Setup Requirements

  • ⚠️Requires API keys for chosen LLM providers (e.g., ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY) if not using local models.
  • ⚠️Code execution backend typically requires a running Docker daemon and potentially access to `/var/run/docker.sock` or a Kubernetes cluster.
  • ⚠️Full feature set requires external databases: Redis (for session/checkpointing) and PostgreSQL (for GDPR/OpenFGA).
  • ⚠️OpenFGA authorization requires explicit store and model IDs to be configured (`OPENFGA_STORE_ID`, `OPENFGA_MODEL_ID`).
Verified SafeView Analysis
The server implements extensive security measures, especially around code execution and secret handling. Key controls include: a `CodeValidator` to prevent dangerous imports (`os`, `subprocess`), builtins (`eval`, `exec`), and patterns; Docker/Kubernetes sandboxing for isolated code execution (running as non-root, restricted networks by default); `SecretString` for obfuscating secrets in logs/exceptions; and explicit sanitization for logging and HTTP headers. Authentication for builder endpoints is enforced, and path traversal in file operations is rigorously validated. These practices are backed by dedicated unit and integration tests.
Updated: 2026-01-19GitHub→
30
2
Low Cost
cs97jjm3 icon
Sec9

Provides a comprehensive toolkit for Business Analysts to manage agile workflows, including sprint planning, backlog management, requirements formatting, and various calculation tools.

Setup Requirements

  • ⚠️Requires Node.js to be installed on the system.
  • ⚠️The recommended 'one-click bundle install' method requires the `@modelcontextprotocol/cli` tool (mcpd) to build the `.mcpb` file.
  • ⚠️Specifically designed to run as an extension within Claude Desktop.
Verified SafeView Analysis
The server operates locally via `stdio` and does not make external network requests for its core functionality. It reads configuration from environment variables, which are not sensitive secrets. No use of `eval` or similar dangerous functions was found. Dependencies are minimal and standard for an MCP server.
Updated: 2026-01-07GitHub→
30
1
Medium Cost
learn-automated-testing icon

selenium_mcp_server

by learn-automated-testing

Sec7

A Model Context Protocol (MCP) server that provides browser automation capabilities using Selenium WebDriver for AI-powered test planning, generation, and healing.

Setup Requirements

  • ⚠️Requires Python 3.10+ (checked during npm install)
  • ⚠️Requires Node.js 16.0.0+ for the npm wrapper
  • ⚠️Requires Chrome browser to be installed on the system
  • ⚠️Downloads ChromeDriver executable on first run, requiring internet access
Verified SafeView Analysis
The server's core functionality involves executing arbitrary JavaScript within the controlled browser instance (`driver.execute_script`). While this is standard for browser automation, it poses a risk if the AI client or its prompts are compromised, potentially leading to malicious browser actions (e.g., navigating to phishing sites, submitting sensitive data). The `reset_automation_session` tool uses `pkill` and `kill` commands, which are powerful and could have unintended side effects if not carefully scoped, though the implementation attempts to target only automation-related processes. `webdriver_manager` downloads unverified binaries from the internet on first use, which is a common supply chain risk for browser automation tools.
Updated: 2026-01-19GitHub→
30
1
Low Cost
InfinityFlowApp icon

csharp-mcp

by InfinityFlowApp

Sec3

This server provides a Model Context Protocol (MCP) interface for AI assistants to dynamically evaluate and execute C# scripts using Roslyn, either directly or from .csx files.

Setup Requirements

  • ⚠️Requires .NET 9.0 SDK or later for local development/running.
  • ⚠️Requires Docker for containerized deployment or dnx for NuGet-based installation.
  • ⚠️Internet connection is required for NuGet package downloads when `#r "nuget:..."` directives are used in scripts.
Review RequiredView Analysis
The server's core function is to execute arbitrary C# code (`eval` pattern). Scripts run in the same process context as the MCP server, posing a significant risk if untrusted code is executed. While file access can be restricted via `CSX_ALLOWED_PATH` (which is disabled in Docker, relying on Docker's volume mounts), and a timeout exists, there is no mention of robust sandboxing (e.g., AppDomains with limited permissions, separate isolated processes) for untrusted code. Pre-imported namespaces like `System.Net.Http` allow scripts to make network calls. This tool requires extreme caution and should only be used with fully trusted C# scripts or in highly isolated, sandboxed environments.
Updated: 2026-01-19GitHub→
30
1
Low Cost
scopweb icon

mcp-go-mysql

by scopweb

Sec9

Provides a secure MySQL database management interface via the Model Context Protocol (MCP) for AI tools like Claude Desktop, featuring intelligent security and operation blocking.

Setup Requirements

  • ⚠️Requires an existing and accessible MySQL server.
  • ⚠️Strongly recommends creating a dedicated MySQL user with minimal permissions, not root.
  • ⚠️Requires manual configuration in Claude Desktop's `claude_desktop_config.json` file.
  • ⚠️MySQL connection details (host, port, user, password, database) must be provided via environment variables (e.g., a `.env` file).
Verified SafeView Analysis
The project demonstrates a strong focus on security, implementing a multi-layered defense against common database attacks. It features comprehensive SQL injection, path traversal, and command injection prevention (23+ SQLi patterns blocked), explicit blocking of dangerous SQL operations (e.g., DROP DATABASE, DELETE/UPDATE without WHERE), configurable DDL blocking, and a table access whitelist. Credentials are handled via environment variables and masked in logs. Connection pooling, context timeouts, and TLS support are documented. A robust security test suite is included, covering various CVEs, CWEs, and injection types, with recommendations for `govulncheck` and `staticcheck`. A minor concern is the `allowNativePasswords=true` option in the DSN used by `internal/mysql.go::getDB()`. While the primary `internal/client.go::Connect()` method (used for core tools like 'query' and 'execute') does not include this, `internal/mysql.go`'s `getDB()` is used by `internal/analysis.go` (e.g., ExplainQuery) and some simpler list/describe functions. This specific DSN setting could allow unencrypted password transmission for those particular calls if the MySQL server itself is not configured to enforce TLS, potentially downgrading security for these operations.
Updated: 2025-11-30GitHub→
30
1
High Cost
jameslbarnes icon

hermes

by jameslbarnes

Sec7

An MCP server enabling AI agents (Claudes) to share ambient conversation summaries on a public bulletin board, facilitating thought sharing, search, comments, and personalized email digests.

Setup Requirements

  • ⚠️Requires Firebase (Google Cloud project) for persistent storage; configured via `FIREBASE_SERVICE_ACCOUNT_BASE64`, `FIREBASE_SERVICE_ACCOUNT`, or `GOOGLE_APPLICATION_CREDENTIALS`.
  • ⚠️Requires Anthropic API Key (`ANTHROPIC_API_KEY`) for AI summarization and daily digests (paid service).
  • ⚠️Requires Firecrawl API Key (`FIRECRAWL_API_KEY`) for scraping external conversation links (paid service).
  • ⚠️Requires Namecheap API Key (`NAMECHEAP_API_KEY`), Username (`NAMECHEAP_USERNAME`), and Client IP (`NAMECHEAP_CLIENT_IP`) for d-stack ingress DNS management, indicating reliance on external DNS provider.
  • ⚠️Default `JWT_SECRET` must be changed in production for robust security.
  • ⚠️Deployment is primarily designed for Docker and Phala Cloud TEE, which may have specific setup requirements.
Verified SafeView Analysis
The server runs within a Trusted Execution Environment (TEE) providing hardware isolation for secret keys and pending entries in memory, which is a strong security measure. A recovery file persists pending entries to a Docker volume on graceful shutdown; while the README states TEE protection covers pending entries, the explicit disk persistence via a volume should be verified to be TEE-encrypted to fully align with 'memory-only' claims. A significant functional security gap is the absence of a server-side anonymization/sensitivity filter for the `write_journal_entry` content. Although the tool schema *forces* Claude to perform a `sensitivity_check` before writing, the server does not programmatically re-validate or filter the `entry` content itself, relying solely on Claude's adherence to privacy guidelines. The default `JWT_SECRET` value `hermes-default-secret-change-in-production` should be changed for production deployments. Namecheap credentials (`NAMECHEAP_API_KEY`, `NAMECHEAP_USERNAME`, `NAMECHEAP_CLIENT_IP`) are used for DNS management and are passed as environment variables. No obvious 'eval' or malicious code patterns were found.
Updated: 2026-01-17GitHub→
30
1
Low Cost
bercianor icon

mcp-forge-python

by bercianor

Sec9

A production-ready MCP (Model Context Protocol) server template for building AI-powered applications with OAuth 2.0 authentication and JWT validation.

Setup Requirements

  • ⚠️Requires Python 3.11+ and `uv` (dependency manager) to be installed.
  • ⚠️The 'local' JWT validation strategy requires an external OAuth provider (e.g., Keycloak, Auth0) with a JWKS endpoint.
  • ⚠️Requires significant configuration in `config.toml` to replace placeholders for OAuth settings (e.g., `jwks_uri`, `issuer`, `audience`, `client_id`, `client_secret`) and deployment (e.g., Docker image repository in `chart/values.yaml`).
Verified SafeView Analysis
The server employs several strong security measures, including: careful avoidance of `eval` in JWT condition checks, configurable CORS, redaction of sensitive headers in access logs, basic rate limiting for JWT validation, and whitelisting of OAuth/JWKS URIs to prevent SSRF attacks. Secrets (`client_id`, `client_secret`) are expected to be provided via environment variables (`MCP_CLIENT_ID`, `MCP_CLIENT_SECRET`) or Kubernetes secrets, not hardcoded. The `jwt_exposed_claims` configuration allows control over which JWT claims are accessible to tools, mitigating PII leakage. The default host is `127.0.0.1` to prevent accidental exposure, with clear warnings for changing to `0.0.0.0`. Environment variable expansion in configuration (`safe_expandvars`) is also whitelisted. The system encourages an 'external' JWT strategy, offloading validation to an upstream proxy, which is a robust security pattern.
Updated: 2025-11-29GitHub→
30
1
Low Cost

elasticsearch-mcp-server

by gokeep-projects

Sec7

Provides a lightweight Model Context Protocol (MCP) server for Elasticsearch, enabling AI assistants to interact with Elasticsearch data sources with low resource consumption.

Setup Requirements

  • ⚠️Requires a running Elasticsearch 7.x/8.x/9.x instance to connect to (defaults to http://localhost:9200).
  • ⚠️Requires Java 17+ (JDK 21 recommended); GraalVM is required for native image compilation.
  • ⚠️Maven 3.8+ is required for project building.
Verified SafeView Analysis
The application acts as an intermediary, exposing powerful Elasticsearch operations (SQL query, DSL search, index management) via HTTP/S endpoints. While the code itself doesn't appear to have obvious vulnerabilities or obfuscation based on the provided README, the nature of the application means that if the MCP client or AI assistant is compromised, it could be used to perform unauthorized operations on the connected Elasticsearch instance. Proper network security, access controls, and careful management of Elasticsearch connection credentials (host, username, password) are critical for secure deployment.
Updated: 2025-11-17GitHub→
30
1
Medium Cost
Foxhunt icon
Sec9

This server provides tools to interact with a self-hosted GitLab instance to fetch and manage project, issue, and wiki data.

Setup Requirements

  • ⚠️Requires Node.js runtime (v18+ recommended based on package-lock.json for @modelcontextprotocol/sdk)
  • ⚠️Requires a self-hosted GitLab instance URL configured via GITLAB_HOST
  • ⚠️Requires a GitLab API Token with appropriate permissions configured via GITLAB_API_TOKEN
Verified SafeView Analysis
Environment variables (GITLAB_API_TOKEN, GITLAB_HOST) are correctly used for sensitive data. Input validation is handled robustly using Zod schemas for all tool arguments, which significantly mitigates common injection risks. Network communication uses axios to the configured GitLab host, which is a standard and secure way for API interaction. There are no 'eval' or other directly dangerous functions identified. The primary security consideration relies on the user ensuring the GITLAB_HOST is legitimate and the API token has appropriate permissions.
Updated: 2025-12-02GitHub→
30
1
Low Cost
jojoprison icon

mcp-music-forge

by jojoprison

Sec8

Scalable MCP server and HTTP API for downloading, transcoding, and tagging audio from various online sources like SoundCloud and YouTube.

Setup Requirements

  • ⚠️Docker and Docker Compose are required for the recommended setup.
  • ⚠️Python 3.12 or newer is required.
  • ⚠️The `ffmpeg` command-line tool must be available in the environment (or Docker container).
  • ⚠️A Redis server is required for the task queue.
  • ⚠️By default, the SoundCloud provider respects its Terms of Use, only downloading tracks explicitly marked as downloadable by the uploader. This can be overridden.
  • ⚠️A `SOUNDCLOUD_COOKIE_FILE` is necessary for accessing private or region-locked SoundCloud tracks.
Verified SafeView Analysis
The `CORSMiddleware` is configured with `allow_origins=["*"]`, which can be a security risk if the API is exposed publicly. Ensure `SOUNDCLOUD_COOKIE_FILE` is handled with strict permissions. External tools like `yt-dlp` and `ffmpeg` are used via `subprocess.run`; argument construction appears safe, mitigating direct command injection. File system operations generally use `pathlib` and internally managed `job_id`s, reducing path traversal risks. No `eval` or obvious obfuscation found.
Updated: 2025-12-04GitHub→
30
1
High Cost
Pilsertech icon

HelixDB-MCP-Server

by Pilsertech

Sec4

AI Memory Layer MCP Server provides a business and customer intelligence system with semantic search and relationship tracking, built on HelixDB graph database with vector embeddings.

Setup Requirements

  • ⚠️HelixDB server must be running (default: 127.0.0.1:6969).
  • ⚠️Requires Rust 1.70+ to build from source.
  • ⚠️By default, configured to use a local embedding server (e.g., Ollama or a Python embedding server) which must be running at `http://127.0.0.1:8699/embed`. Alternatively, requires an OpenAI/Gemini API key for paid services if configured for cloud embedding, or a separate TCP embedding server.
  • ⚠️The server enables TCP and HTTP listeners by default without authentication, making it unsafe for untrusted network exposure.
Review RequiredView Analysis
The server explicitly states that its TCP transport has 'no authentication required', and no authentication mechanism is apparent for its HTTP transport either. This makes it unsafe to expose to untrusted networks without external authentication/authorization. API keys can be stored directly in `mcpconfig.toml` which is a bad practice for production environments. The `do_query` tool mitigates direct database command injection by whitelisting allowed HelixDB query endpoints.
Updated: 2025-11-25GitHub→
PreviousPage 217 of 760Next