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
Medium Cost
infanputra icon

nettune

by infanputra

Sec5

Nettune provides a client-side wrapper that downloads and runs a Go-based server in MCP stdio mode, enabling AI-assisted network diagnostics and TCP optimization for improved connection speeds and stability.

Setup Requirements

  • ⚠️The `nettune server` component requires root privileges (`sudo`) to operate, as it makes system-level modifications.
  • ⚠️An API key is required for client-server authentication. It is passed via command-line arguments, and users are warned to secure their shell history.
  • ⚠️The core server functionality for network optimization (sysctl, qdisc, systemd management) is Linux-specific, even though the client wrapper supports macOS/Windows.
Review RequiredView Analysis
The server component (`nettune server`) requires root privileges to modify system-level network configurations (sysctl, qdisc, systemd), which is a significant security consideration. The client-server communication uses HTTP with Bearer token authentication, but the README explicitly warns that TLS termination (e.g., via a reverse proxy) is recommended for production, implying non-encrypted communication by default. API keys are passed via command-line arguments, posing a risk if shell history or process lists are compromised. The Go adapters execute external commands (`tc`, `sysctl`, `systemctl`, `ip`), raising potential concerns for command injection if user-supplied profile parameters are not rigorously sanitized (though validation is present). The JavaScript wrapper downloads binaries from GitHub releases, and while it performs SHA256 checksum verification, the trust chain relies on GitHub's integrity. Running this server on an internet-exposed host without proper firewalling and TLS is highly risky.
Updated: 2026-01-19GitHub→
0
0
Low Cost
imvickykumar999 icon

MCP-Server-Client

by imvickykumar999

Sec9

Demonstrates a basic FastMCP server and client for exchanging model context, including tools, resources, and prompts, primarily for AI integration.

Setup Requirements

  • ⚠️Requires Python 3.8+.
  • ⚠️Requires `fastmcp` and `requests` Python libraries (install with `pip install fastmcp requests`).
  • ⚠️The FastMCP server must be running before the client can connect.
Verified SafeView Analysis
The server binds to `127.0.0.1` by default, limiting external exposure. No explicit use of `eval` or `exec` functions, hardcoded secrets, or obvious malicious patterns were found in the provided source code. It's a simple demonstration, making it relatively safe to run.
Updated: 2025-12-06GitHub→
0
0
Low Cost

movie-ticketing-mcp-server

by cloudz-modern-platform-demo

Sec8

A Python-based MCP server that acts as a bridge, providing movie ticketing information from a backend API to AI assistants.

Setup Requirements

  • ⚠️Requires Python 3.12+
  • ⚠️Requires `uv` (Python package installer) to be installed.
  • ⚠️Requires a separate backend API server running (defaulting to `http://localhost:9000`) for full functionality.
Verified SafeView Analysis
The server acts as an API bridge, so its overall security profile depends heavily on the backend API it integrates with and the security of that API. It defaults to listening on `0.0.0.0`, which should be restricted to specific interfaces for production environments. No obvious code injection (`eval`) or obfuscation methods are present in the provided information.
Updated: 2025-11-18GitHub→
0
0
Low Cost
Sec4

An API bridge enabling AI clients (MCPs) to execute terminal commands on a Kali Linux server for AI-assisted penetration testing and CTF solving.

Setup Requirements

  • ⚠️Requires a Kali Linux (or similar Debian-based offensive security distro) environment for full functionality due to reliance on tools like nmap, nxc, gobuster.
  • ⚠️Critical network security considerations: Default is 127.0.0.1 (localhost), but exposing the API via --ip 0.0.0.0 is explicitly warned as 'very dangerous' and 'highly discouraged' and requires careful network segmentation/SSH tunneling.
  • ⚠️Relies on external MCP clients (e.g., Claude Desktop, 5ire) for AI interaction, which need specific configuration to connect to this server.
Review RequiredView Analysis
The project's explicit purpose is to allow AI to execute terminal commands, which is an inherently high-risk operation. While the README explicitly warns against unsafe network configurations (e.g., binding to `0.0.0.0` without caution) and encourages SSH tunneling, the capability itself requires extreme trust in the client, careful deployment, and robust security practices to prevent remote code execution vulnerabilities or misuse. No obvious 'eval' or obfuscation is mentioned in the provided text, but the underlying command execution mechanism (likely subprocess calls) is the primary attack surface.
Updated: 2025-11-17GitHub→
0
0
Medium Cost
stilllovee icon

memory-mcp-server

by stilllovee

Sec7

Provides a Model Context Protocol (MCP) server for AI Agents to save and retrieve conversational summaries, enhancing cross-session context.

Setup Requirements

  • ⚠️Requires a Node.js runtime environment (version >=18 recommended due to SDK dependencies).
  • ⚠️The SQLite database file ('summaries.db') is created in the current working directory where the server is launched, which might require managing persistence if the server's working directory changes.
  • ⚠️The HTTP server endpoint lacks user authentication/authorization, making it unsuitable for secure multi-user or public-facing deployments without an external security layer.
Verified SafeView Analysis
No obvious malicious code, 'eval' usage, or hardcoded secrets were found. The server utilizes standard and well-maintained libraries. The HTTP transport exposes `save_summary` and `get_summaries` endpoints without built-in authentication or authorization, meaning any client with network access to the server can interact with the global summary database. This design implies a single-user or trusted local environment; using it in a multi-user or untrusted shared environment would pose a privacy and data integrity risk.
Updated: 2025-11-29GitHub→
0
0
High Cost
hkhkkh icon
Sec4

Provides Model Context Protocol (MCP) servers for real-time weather data retrieval and Stable Diffusion-based AI image generation and management.

Setup Requirements

  • ⚠️Requires local Stable Diffusion WebUI installed and running, accessible via API.
  • ⚠️Requires manual configuration of SD WebUI API URL and launcher path in `sd_mcp_server.py`.
  • ⚠️SD WebUI must be launched with the `--api` command-line argument.
Review RequiredView Analysis
The `sd_mcp_server.py` uses `subprocess.Popen` with `shell=True`, which is a security risk if the `SD_LAUNCHER_PATH` variable (though hardcoded/developer-configured) could be manipulated. More critically, the `img2img` and `interrogate_image` functions accept an `image_path` argument from user input and directly attempt to read local files (`os.path.exists` check is insufficient). This allows for arbitrary local file disclosure if a malicious actor can provide a path to an existing file on the server's machine, posing a significant information leakage risk.
Updated: 2025-11-27GitHub→
0
0
Low Cost
phuhduong icon

jigsaw-mcp

by phuhduong

Sec8

Provides a barebones Model Context Protocol server for Dedalus deployments, featuring a single greeting tool.

Setup Requirements

  • ⚠️Requires Node.js (v18+ recommended based on `package-lock.json` engine requirements).
  • ⚠️Requires `npm install` and `npm run build` to compile TypeScript source code before running.
Verified SafeView Analysis
The server uses the `@modelcontextprotocol/sdk` and does not appear to implement any inherently dangerous operations directly (like `eval`, arbitrary shell execution, or sensitive file system access beyond what the SDK might abstractly require). Input validation for the 'hello' tool is present but basic. No hardcoded secrets were found. The primary security considerations would be potential vulnerabilities within the `@modelcontextprotocol/sdk` itself or how clients utilize the exposed tools.
Updated: 2025-11-20GitHub→
0
0
Low Cost
hyperion14 icon

docx-mcp-service

by hyperion14

Sec7

Generates BHK-formatted Word documents from Markdown text, optimized for integration with Mistral Chat via the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Docker and Docker Compose are essential prerequisites for running this service.
  • ⚠️Nginx is required for production deployment to handle reverse proxying, SSL/TLS termination, and correct routing for SSE transport and file downloads.
  • ⚠️The `DOCKER_API_KEY` and `PUBLIC_URL` environment variables must be configured in the `.env` file; a default API key will be used if `DOCKER_API_KEY` is not set, posing a security risk.
  • ⚠️The `templates/bhk-base.docx` file must be present in the `templates/` directory for BHK formatting to function correctly.
Verified SafeView Analysis
The project uses API key authentication for critical endpoints, which is a good practice. File handling for uploads and downloads appears robust against common path traversal attacks. However, the default API key 'YOUR_API_KEY' in `app.py` is a significant security risk if not changed in a production environment. Additionally, the Nginx configuration for CORS (`Access-Control-Allow-Origin '*'`) is wide open and should be restricted to `https://chat.mistral.ai` in production as noted in `NGINX_SETUP.md`. No obvious malicious patterns or usage of `eval` were found.
Updated: 2025-12-27GitHub→
0
0
Medium Cost

brewsource-mcp

by CharlRitter

Sec9

Provides a Model Context Protocol (MCP) server that grants AI assistants access to comprehensive brewing knowledge and tools, including beer styles, breweries, and commercial beer data.

Setup Requirements

  • ⚠️Requires Kind (Kubernetes in Docker) for local Kubernetes cluster setup.
  • ⚠️Requires Tilt for live-reload development and service orchestration.
  • ⚠️Nix is the recommended setup option for managing prerequisites.
Verified SafeView Analysis
The project is a server exposing an HTTP API (port 8080) for MCP client interaction, as expected. It's built with Go, which generally implies good memory safety. Local development utilizes Kind and Tilt for a containerized Kubernetes environment, isolating immediate external risks. The project includes dedicated documentation for secure production deployment using K3s, Traefik, and Cert-Manager, indicating security awareness. No 'eval' or obfuscation is apparent.
Updated: 2025-11-17GitHub→
0
0
High Cost
AndreChuabio icon

mcp-yfinance-server

by AndreChuabio

Sec3

A comprehensive financial analysis suite providing real-time sentiment analysis, stock data, and paper trading functionality, designed for integration with Model Context Protocol (MCP) clients like Claude Desktop.

Setup Requirements

  • ⚠️Requires multiple API keys from various external services (Google Gemini, Alpha Vantage, NewsAPI, Reddit, Financial Modeling Prep, Paper Invest), many of which have strict free-tier rate limits.
  • ⚠️Requires a running MongoDB instance and its connection URI configured, adding a significant infrastructure prerequisite.
  • ⚠️The sentiment analysis component uses Google Gemini AI, which can incur significant token costs, especially with batch processing or frequent queries.
  • ⚠️Dual server architecture: Node.js for sentiment analysis (npm start) and Python for MCP tools/Paper Trading (python mcp_yfinance_server.py), requiring setup for both environments.
Review RequiredView Analysis
The provided `claude_desktop_config.json` file, listed as part of the source code for analysis, contains hardcoded Paper Invest API credentials (`paper_API_KEY`, `paper_account_ID`, `paper_portfolio_ID`). While the server code itself loads these from environment variables (a better practice), the inclusion of actual credentials in a configuration file within a repository is a severe security risk. Sharing or committing such a file would expose sensitive API keys, making it unsafe. Reliance on multiple external APIs (Google Gemini, Alpha Vantage, NewsAPI, Reddit, Paper Invest, yfinance, MongoDB) increases the overall attack surface, though API key management via `.env` helps mitigate this if secrets are not hardcoded elsewhere.
Updated: 2026-01-08GitHub→
0
0
High Cost
sethdf icon

codebootstrap

by sethdf

Sec5

A container-first development environment providing AI coding tools (Claude, Codex, Gemini) and pre-configured Model Context Protocol (MCP) servers for AI-assisted development, ensuring a consistent environment across local machines and cloud services like GitHub Codespaces.

Setup Requirements

  • ⚠️Docker (or Docker Desktop for macOS/Windows/WSL) is a mandatory prerequisite on the host machine.
  • ⚠️Requires separate API accounts/authentication for Claude (Anthropic), Codex (OpenAI), and Gemini (Google) for AI tool functionality.
  • ⚠️AI tools are explicitly configured to bypass permissions/sandbox prompts ('YOLO' mode), meaning they can execute potentially destructive commands without user confirmation.
  • ⚠️Initial setup via `curl -fsSL ... | bash` executes remote code directly, presenting a supply chain security risk.
Review RequiredView Analysis
AI tools (`claude`, `codex`, `gemini`) are configured to run in 'YOLO mode' (`--dangerously-skip-permissions`, `--dangerously-bypass-approvals-and-sandbox`, `--yolo`) by default. This grants them significant autonomy without explicit user approval for actions such as file system modifications, Git operations, and API calls. While guidelines are provided to the AI within project context files (`context-append.md`) to prevent destructive operations, the bypass of explicit human confirmation poses a significant risk for unintended or malicious actions if the AI hallucinates or is prompted incorrectly. The `host-setup.sh` script is designed for `curl | bash` execution, which introduces a supply chain security risk by running unreviewed remote code. The `filesystem`, `git`, and `github` MCP servers grant broad access to the workspace filesystem and GitHub API. `GITHUB_TOKEN` is exposed to the `github` MCP server for API access.
Updated: 2025-12-02GitHub→
0
0
Medium Cost
VideoAmp icon

cli

by VideoAmp

Sec8

Enable AI assistants, agents, and chatbots to interact with VideoAmp's public API functionalities through the Model Context Protocol (MCP) or a command-line interface.

Setup Requirements

  • ⚠️Requires a paid Claude license (Pro, Max, Team, or Enterprise) for remote server usage with Claude products.
  • ⚠️Admin privileges may be needed to add the VideoAmp MCP server as a Custom Connector in Claude.
  • ⚠️Local CLI installation involves downloading and manually moving a binary to a system path (potentially requiring 'sudo').
Verified SafeView Analysis
The provided source code consists only of documentation (README.md, AGENTS.md), so direct analysis of executable code for malicious patterns like 'eval' or hardcoded secrets is not possible. The documentation itself appears benign. Local CLI installation involves downloading pre-compiled binaries from releases and moving them to a system path, often requiring 'sudo' on Linux/macOS. This is a common practice but introduces a supply chain risk if the binaries are compromised. Connectivity to the remote MCP server at `https://api.videoamp.dev/v1/mcp` relies on the security of that external endpoint.
Updated: 2026-01-16GitHub→
PreviousPage 337 of 760Next