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)

0
0
Low Cost
manju07 icon
Sec3

A minimal Model Context Protocol (MCP) server that provides secure file read and write operations within a sandbox directory for AI agents.

Setup Requirements

  • ⚠️Requires `GOOGLE_API_KEY` environment variable for the optional Gradio web interface (app.py) to connect to Gemini API.
  • ⚠️The MCP Python SDK may need to be installed directly from GitHub (`pip install git+https://github.com/modelcontextprotocol/python-sdk.git`) if not available on PyPI.
  • ⚠️MCP client configurations (e.g., for Cursor) require specifying the absolute path to the `server.py` file.
Review RequiredView Analysis
The `resolve_sandbox_path` function in `server.py` is vulnerable to directory traversal. While it correctly handles absolute paths by taking only the file name relative to the sandbox, it fails to sufficiently normalize or validate relative paths (e.g., `../../../filename`) against the sandbox boundary. This allows an attacker to read or write files outside the intended `sandbox/` directory by crafting malicious relative paths.
Updated: 2025-11-29GitHub→
0
0
Medium Cost
tuongle-learn icon

testlink-mcp-server

by tuongle-learn

Sec8

Manages TestLink QA system entities (test cases, plans, suites) via AI agents (Claude, Cursor) using the Model Context Protocol.

Setup Requirements

  • ⚠️Docker Desktop is required to run the server.
  • ⚠️Mandatory environment variables: TESTLINK_URL and TESTLINK_API_KEY.
  • ⚠️A running TestLink QA management system is required for functionality.
  • ⚠️Users must distinguish between TestLink Internal IDs (for linking/actions) and External IDs (for lookup).
Verified SafeView Analysis
The server correctly uses environment variables for TestLink API credentials. It does not contain direct arbitrary code execution vulnerabilities (e.g., 'eval' on user input). The 'robust_call' mechanism calls predefined TestLink API methods or their raw XML-RPC equivalents, not arbitrary user-supplied method names. The main security considerations are ensuring the TestLink API itself is secured and that the client-side configuration (e.g., Claude Desktop, Cursor) protects the `TESTLINK_API_KEY` from unauthorized access.
Updated: 2025-12-03GitHub→
0
0
Medium Cost
sadym-chromium icon

webdriver-spec-mcp

by sadym-chromium

Sec9

Provides a RAG-powered Model Context Protocol (MCP) server for searching, reading, and asking questions about WebDriver BiDi and Classic specifications using Google's Gemini models.

Setup Requirements

  • ⚠️Requires Node.js v20 or higher.
  • ⚠️Requires a Google Gemini API Key to be configured in a `.env` file or environment variables.
  • ⚠️Initial data ingestion (`npm run ingest`) is mandatory before server usage and involves API calls to Gemini for embeddings.
  • ⚠️MCP Client configuration requires the absolute path to the repository.
Verified SafeView Analysis
The project demonstrates good security practices by loading the API key from environment variables (GEMINI_API_KEY) rather than hardcoding. Input schemas for tools are validated using `zod`. Network interactions for data ingestion (`scripts/ingest-specs.ts`) are directed to hardcoded W3C specification URLs, mitigating SSRF risks from user input. AI model calls are made to Google Gemini APIs, which is expected functionality. LanceDB is used for local storage in a dedicated `.mcp-data` directory within the project's working directory. The `read_spec_section` tool retrieves content only from the locally ingested LanceDB store, not by fetching live URLs based on user input, further enhancing security.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
rncz icon
Sec8

Automate Nextcloud note management using an LLM by providing a set of WebDAV-based tools.

Setup Requirements

  • ⚠️Requires a Nextcloud instance with WebDAV enabled and accessible.
  • ⚠️Requires `uv` (ultra-violet) for Python environment and package management.
  • ⚠️Requires an LLM software (e.g., LM Studio) capable of tool calling and configured to use this MCP server.
Verified SafeView Analysis
The server loads WebDAV credentials from a `.env` file, which is good practice. It interacts with Nextcloud via `webdavclient3`. The operations are restricted to defined WebDAV actions (CRUD on notes/categories) and do not involve direct `eval` or `exec` of user input. The main security considerations are protecting the `.env` file and ensuring the LLM interaction is controlled to prevent misuse of the WebDAV tools.
Updated: 2025-12-13GitHub→
0
0
Medium Cost

MCP-server-Hebrew

by yossimmmm

Sec5

A server application likely related to Minecraft (MCP usually refers to Minecraft Coder Pack or Minecraft Protocol), potentially localized for Hebrew speakers.

Setup Requirements

  • ⚠️Docker required
  • ⚠️Node.js environment
  • ⚠️Potential Minecraft client/server version dependencies
Review RequiredView Analysis
Cannot perform a full security audit without code content. 'node_modules' indicates external dependencies, and 'MCP server' suggests network exposure. 'Dockerfile' can improve isolation but does not guarantee application security. Potential for unknown vulnerabilities in dependencies.
Updated: 2025-11-19GitHub→
0
0
Medium Cost
Sec8

Automates and intelligently manages Tableau Server and Tableau Cloud environments, providing comprehensive control and AI-powered operations with a human-in-the-loop safety system.

Setup Requirements

  • ⚠️Requires Tableau Server or Tableau Cloud instance access (PAT authentication)
  • ⚠️Requires OpenRouter API Key (Paid service for AI-powered features)
  • ⚠️Requires Python 3.11+
  • ⚠️Requires a running Redis server (for HITL queue and caching)
Verified SafeView Analysis
The server uses Pydantic Settings for secure environment variable loading and implements a Human-in-the-Loop (HITL) approval system for all critical operations, significantly enhancing safety. It leverages established libraries like httpx and tableauserverclient. A potential XML injection risk exists in `src/api_clients/prep_client.py` where user-provided or LLM-generated strings are directly formatted into XML request bodies without explicit sanitization within the provided source code. This relies on upstream components (e.g., the LLM Web Agent or Unified Intelligence Interface) to perform robust input sanitization before reaching the tools. If not properly sanitized upstream, this could lead to unexpected API behavior.
Updated: 2025-11-29GitHub→
0
0
Low Cost
pudurvenu icon

AI-NextGen

by pudurvenu

Sec1

Provides user-friendly desktop tools for creators to achieve clean results and enhance creative projects.

Setup Requirements

  • ⚠️The application is distributed as pre-compiled binaries (.exe/.dmg) within a ZIP file, with no visible source code for the actual application logic to inspect.
  • ⚠️Requires manual download and installation of an executable from a direct GitHub raw content link, bypassing typical release pages or package managers that might offer more verification.
Review RequiredView Analysis
The provided 'SOURCE CODE' for analysis is exclusively the README file. No actual executable source code for the application's functionality was supplied, making it impossible to perform a comprehensive security audit for potential risks such as 'eval' usage, obfuscation, network vulnerabilities, hardcoded secrets, or malicious patterns. The project instructs users to download and install a pre-compiled ZIP file containing an .exe or .dmg directly from a GitHub raw content link. Running unverified binaries without access to their source code for inspection poses a significant security risk, as their behavior cannot be audited. Therefore, the security score is critically low due to the inability to inspect the underlying application logic.
Updated: 2026-01-19GitHub→
0
0
Low Cost
bytefrostdev icon

bytefrost-joplin-mcp

by bytefrostdev

Sec6

An MCP server enabling AI assistants to directly access, search, read, create, and edit Joplin notes stored in a self-hosted PostgreSQL database.

Setup Requirements

  • ⚠️Project is under active development and NOT PRODUCTION READY.
  • ⚠️Requires a self-hosted Joplin Server (>= 2.6.0) with PostgreSQL database.
  • ⚠️Joplin's End-to-End Encryption (E2EE) must be DEACTIVATED for the MCP to access note content.
  • ⚠️Requires Docker or Python 3.11+ runtime.
  • ⚠️Installation, configuration, and usage documentation are 'Coming soon'.
Review RequiredView Analysis
The project is explicitly marked 'UNDER DEVELOPMENT - NOT PRODUCTION READY', indicating inherent risks due to incomplete testing and potential API/schema changes. It connects directly to the PostgreSQL database, bypassing Joplin's official APIs, which requires careful implementation to prevent issues like SQL injection (no code available to verify parameterized queries). Secrets (like the database password) are indicated to be externalized via `.env` files, which is a good practice. A critical requirement for functionality is that Joplin's End-to-End Encryption (E2EE) must be DEACTIVATED, meaning note content is stored unencrypted in the database and accessible by the MCP.
Updated: 2025-12-05GitHub→
0
0
Medium Cost
paolodalprato icon
Sec9

Enhances NotebookLM with client-side prompt structuring for source fidelity, enabling professional document analysis, legal research, and fact-checking.

Setup Requirements

  • ⚠️Requires Claude Desktop to be installed and configured to use MCP servers.
  • ⚠️Node.js >= 18.0.0 is required.
  • ⚠️A Google account is required for NotebookLM access, and manual authentication may require closing all Chrome/Chromium instances.
Verified SafeView Analysis
The server uses browser automation (Patchright, a Playwright fork) to interact with NotebookLM and Google authentication services. While browser automation inherently involves interactions with external websites, the server's code does not expose mechanisms for arbitrary code execution or navigation to untrusted sites via tool inputs. Command execution via `child_process.exec` is used for platform-specific Chrome process detection with fixed commands, preventing injection risks. User credentials (`LOGIN_EMAIL`, `LOGIN_PASSWORD`) are not hardcoded and are expected from environment variables. There are no detectable server-side 'eval' calls or obfuscation. The overall design appears secure for its intended purpose.
Updated: 2026-01-01GitHub→
0
0
Low Cost
GaneshGMgr icon
Sec8

A backend server for an expense tracking application, leveraging the FastMCP framework for API functionality.

Setup Requirements

  • ⚠️Python 3.13 or newer required
Verified SafeView Analysis
The provided code snippet is minimal and does not contain obvious security risks such as 'eval', obfuscation, hardcoded secrets, or malicious patterns. A comprehensive security audit would require examining the full application logic, defined API endpoints, and data interactions once implemented, as well as the underlying FastMCP framework itself. Based solely on the provided code, there are no immediate red flags.
Updated: 2025-12-01GitHub→
0
0
Medium Cost

semantic_mcp

by milkymap

Sec9

Provides an intelligent search and management system for Model Context Protocol (MCP) servers using AI-powered analysis and vector embeddings.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid Service)
  • ⚠️Requires Cohere API Key (Paid Service)
  • ⚠️Python 3.12+ (for local development)
  • ⚠️Requires generation of custom API authentication and encryption keys
Verified SafeView Analysis
The system relies on multiple API keys (OpenAI, Cohere, internal API_KEY, ENCRYPTION_KEY). The README provides explicit guidance on securing these keys (e.g., using .env.secret, generating strong keys with openssl) and encrypts sensitive MCP configurations. Network exposure is inherent for an API, but authentication is mandated. No direct signs of 'eval' or obfuscation were observed in the provided README.
Updated: 2025-11-17GitHub→
0
0
Low Cost
augustcaio icon

mcp-servers

by augustcaio

Sec9

Manages Docker containers, stacks, volumes, networks, and images by interacting with the Portainer API.

Setup Requirements

  • ⚠️Requires Python 3.12+.
  • ⚠️Portainer (CE or BE) must be installed and accessible via the provided URL.
  • ⚠️Requires access to the Portainer API, which may involve network configuration and API key/password management.
  • ⚠️Users must manage the JWT token returned by `authenticate_portainer` for all subsequent API calls.
Verified SafeView Analysis
The server's core functionality involves making HTTP requests to a user-specified Portainer instance, including passing credentials for authentication and JWT tokens for subsequent operations. This is standard for API interaction. No hardcoded secrets, 'eval', or obfuscation were found. The security relies heavily on the secure configuration and accessibility of the target Portainer instance itself, which is outside the scope of this server's code. Users must ensure their Portainer instance and network access are secure.
Updated: 2026-01-06GitHub→
PreviousPage 656 of 760Next