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
takeshy icon

mcp-gatekeeper

by takeshy

Sec9

MCP server enabling AI assistants to securely execute shell commands with granular access control and sandboxing.

Setup Requirements

  • ⚠️Requires '--root-dir' option to be explicitly set and point to an existing directory, otherwise the server will not start.
  • ⚠️The 'bubblewrap' sandbox mode requires the 'bwrap' utility to be installed on the system for full process isolation. If not found, it falls back to 'none' mode, which offers less security.
  • ⚠️For 'wasm' sandbox mode, pre-compiled WebAssembly binaries (e.g., ruby.wasm, python.wasm) must be available and configured via 'wasm_binary' and potentially '--wasm-dir'.
Verified SafeView Analysis
The server's primary function is shell command execution, which is inherently high-risk. However, mcp-gatekeeper implements robust, multi-layered security controls to mitigate these risks. Key measures include: - **Mandatory directory sandboxing (`--root-dir`)**: All operations are restricted to a specified root directory, with symlink resolution to prevent escapes. - **Glob-based argument restrictions**: Fine-grained control over allowed command arguments, crucial for preventing command injection. - **Multiple sandbox modes (bubblewrap, WASM, none)**: - `bubblewrap` provides strong namespace isolation, making it highly secure for native binaries. - `wasm` mode uses wazero runtime for maximum isolation, preventing system calls and network access. - The `none` mode is acknowledged as less secure, offering only path validation. - **API Key-based Access Control**: API keys are generated with strong randomness, stored as bcrypt hashes, and displayed only once at creation. - **Environment Variable Filtering**: Allowed environment variables are configurable per API key, preventing sensitive information leakage. - **Network Access Restriction**: Both `bubblewrap` and `wasm` sandboxes explicitly block network access for executed commands. - **Audit Logging**: All command requests and their execution results are logged for review, regardless of policy decisions. - **Rate Limiting**: Configurable rate limiting for the HTTP API adds another layer of protection against abuse. No 'eval' or malicious patterns were identified in the provided source code. The implementation uses standard and secure Go practices for command execution (`os/exec`) and cryptographic hashing (`bcrypt`).
Updated: 2026-01-19GitHub→
0
0
Medium Cost
Ev3lynx727 icon
Sec6

A containerized suite of Model Context Protocol (MCP) servers providing various development utilities like code analysis, browser automation, and Docker management.

Setup Requirements

  • ⚠️Requires Docker and docker-compose to be installed.
  • ⚠️Requires API keys for remote services like Context7 (`CONTEXT7_API_KEY`) and potentially GitHub (`GITHUB_TOKEN`).
  • ⚠️Requires updating local MCP client configuration to connect to the container's exposed ports.
Verified SafeView Analysis
The `start_mcp_servers.sh` script utilizes `eval` for command execution, which is generally a security risk, though in this context, the commands are hardcoded within the script itself rather than derived from untrusted input. The Docker socket (`/var/run/docker.sock`) is mounted read-only, which, while safer than read-write, still grants significant access to the host's Docker daemon. The VS Code server data mount (`~/.vscodeserver`) could expose sensitive VS Code configurations or extensions if the container is compromised. Ports 3000-3005 are exposed on the host, increasing the network attack surface if the host is publicly accessible.
Updated: 2025-12-15GitHub→
0
0
Low Cost
kfbyldy icon

mcp-server

by kfbyldy

Sec7

An MCP server designed to ingest data into a big data platform and provide weather information.

Setup Requirements

  • ⚠️Requires Python 3.13 or higher.
  • ⚠️Access to an internal network (specifically 'uds-index-platform.test.fnwintranet.com') is required for the big data upload functionality.
  • ⚠️The 'uv' tool for running the server might need prior installation (e.g., 'pip install uv' or 'pipx install uv').
Verified SafeView Analysis
The 'mcp_logger.py' script uses 'subprocess.Popen' to execute arbitrary commands, which is powerful but used for its intended purpose of command wrapping and logging. No 'eval' or explicit obfuscation is present. The 'USER="test"' is hardcoded in 'mcp_server.py', which is not a secret but a fixed configuration that might be problematic if 'test' user has elevated privileges or if it's not intended for a production environment. The target API base URL 'http://uds-index-platform.test.fnwintranet.com' is an internal test URL, implying an internal network dependency.
Updated: 2025-12-26GitHub→
0
0
Medium Cost

telegram-mcp

by PavelAntipov39

Sec8

Provides an MCP server for AI agents (like Claude/Cursor) to programmatically interact with a user's Telegram account, enabling extensive messaging, chat, and contact management capabilities.

Setup Requirements

  • ⚠️Requires Telegram API ID and API Hash (obtained from my.telegram.org/apps).
  • ⚠️Requires generation of a Telegram session string via `session_string_generator.py` for authentication.
  • ⚠️Requires a specific MCP-compatible client (e.g., Claude Desktop, Cursor) and manual configuration of its `mcpServers` settings with the full path to the project.
  • ⚠️Python 3.10+ and the `uv` package manager are required for dependency management, or Docker must be used.
Verified SafeView Analysis
The server requires sensitive Telegram API credentials (ID, Hash, Session String) which must be securely stored in a .env file. While it runs locally via an MCP client, the powerful tools exposed could be misused by an unconstrained AI agent or an attacker with access to the client, potentially leading to unintended or destructive actions on the user's Telegram account. The removal of file-based operations is a positive security measure.
Updated: 2025-11-17GitHub→
0
0
Medium Cost
adwonnacott icon

docs-scraper-mcp

by adwonnacott

Sec9

Scrapes documentation from websites using Firecrawl, stores it locally, backs it up to GitHub, and provides tools for retrieval, search, and management.

Setup Requirements

  • ⚠️Requires a Firecrawl API key (paid service after free tier).
  • ⚠️Requires a GitHub Personal Access Token with repository access.
  • ⚠️Requires a pre-initialized GitHub repository (with at least one commit) for backups.
Verified SafeView Analysis
The server correctly handles API keys and tokens via environment variables. File system operations are strictly confined to a dedicated 'scraped-docs' directory within the user's home. Input validation is performed using Zod schemas for tool arguments. There is no usage of 'eval' or apparent code obfuscation. Path construction for local files mitigates directory traversal risks. Interaction with external APIs (Firecrawl, GitHub) is well-structured with retry logic. The primary residual risk would be from the content scraped itself if it were crafted to exploit a downstream consumer, but this server does not introduce new vulnerabilities in that regard.
Updated: 2025-11-27GitHub→
0
0
High Cost
hmmroger icon

simply-feed-mcp

by hmmroger

Sec8

A Model Context Protocol (MCP) server that enables AI assistants to fetch, search, and retrieve real-time information from RSS/news feeds, including summarization and topic extraction using an LLM.

Setup Requirements

  • ⚠️Requires Node.js 20+.
  • ⚠️Requires an OpenAI-compatible LLM API Key (paid service) for summarization and search capabilities.
  • ⚠️A separate worker process (e.g., `npx simply-feed-mcp --worker`) must be running to continuously fetch and process feed items, otherwise the MCP server will not have any data.
Verified SafeView Analysis
The server uses environment variables for sensitive configurations like LLM API keys and Azure Storage connection strings, which is good practice. Feed URLs for fetching content are loaded from a configuration file or Azure Blob, requiring trust in the source of these configurations to prevent Server-Side Request Forgery (SSRF). LLM responses are parsed as JSON and validated using Zod schemas, mitigating risks associated with untrusted LLM output. No direct 'eval' calls or obfuscation found.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
Pevansh icon
Sec4

A personalized AI Learning Coach MCP server that tracks learning progress, fetches relevant content, and generates daily learning insights using RAG.

Setup Requirements

  • ⚠️Requires a Supabase database instance with pgvector extension and a specific SQL schema to be set up manually.
  • ⚠️Requires a Groq API Key, which is a paid service for LLM inference.
  • ⚠️Requires `sentence-transformers` to download and run a local embedding model (e.g., `all-MiniLM-L6-v2`), which consumes local CPU/RAM.
Review RequiredView Analysis
The `src/ingestion/content_fetcher.py` file explicitly bypasses SSL certificate verification for network requests (`ssl._create_default_https_context = ssl._create_unverified_context`). This is a critical security vulnerability that makes the server susceptible to Man-in-the-Middle (MiTM) attacks when fetching content from RSS feeds or blogs, potentially allowing attackers to inject malicious content. While other parts of the code (Supabase client usage, Groq API key handling via environment variables) appear to follow good practices, this SSL bypass is a severe flaw for any system interacting with external content sources. No 'eval' or obvious hardcoded secrets were found.
Updated: 2025-12-10GitHub→
0
0
Medium Cost
jayasimhag1reddy icon

Context-Persistance

by jayasimhag1reddy

Sec8

Enables cross-window context sharing for AI conversations in VS Code by persistently storing and linking discussions across different repositories.

Setup Requirements

  • ⚠️Requires manual configuration in VS Code's `mcpServers.json` settings file with the absolute path to the compiled server.
  • ⚠️Requires Node.js and `npm` to build and run (`npm install`, `npm run build`).
Verified SafeView Analysis
The server uses `better-sqlite3` with prepared statements for database operations, which effectively prevents common SQL injection vulnerabilities. Communication occurs via standard I/O (`StdioServerTransport`), meaning no network ports are directly exposed by this server instance. Entity extraction and search queries rely on regex and FTS5 `MATCH` clauses, treating user input as literal search terms rather than executable code. The database is stored locally in the user's home directory. While FTS5 queries with very complex syntax could potentially be used for local resource exhaustion, the overall design for a local-only server interacting with Copilot appears robust against common remote attack vectors and data manipulation.
Updated: 2025-12-13GitHub→
0
0
Low Cost
mlopezgez icon

mcp-server-repomix

by mlopezgez

Sec10

Serves model context via the Model Context Protocol, integrated as an extension within the Zed editor for the 'Repomix' project.

Setup Requirements

  • ⚠️Requires the Rust toolchain (compiler and Cargo) to build the extension.
  • ⚠️Not a standalone executable; it must be compiled as a dynamic library and loaded by the Zed editor as an extension.
  • ⚠️The provided `main` function is a placeholder and does not initiate the actual Model Context Protocol server functionality.
Verified SafeView Analysis
The provided source code is extremely minimal, consisting of a 'Hello, world!' main function, and common, well-regarded Rust dependencies. It's intended to be compiled as a C-compatible dynamic library (cdylib) for an editor extension. No network activity, file system operations, user input processing, hardcoded secrets, 'eval' patterns, or obfuscation are present in the provided snippet. The actual server logic is not visible.
Updated: 2025-12-02GitHub→
0
0
Low Cost
furbyhaxx icon
Sec8

A starter template for building Model Context Protocol (MCP) servers in Rust, enabling AI assistant integrations.

Setup Requirements

  • ⚠️Requires Rust 1.85+ (Rust 2024 edition).
  • ⚠️The `rmcp` library has specific API patterns (e.g., `#[tool]` macros) that users need to follow.
  • ⚠️No built-in authentication, authorization, or TLS for HTTP transport; users must implement these for secure production deployments.
Verified SafeView Analysis
The server explicitly provides guidance on security considerations, such as using environment variables for sensitive values, binding to localhost (127.0.0.1) in production, and sanitizing inputs. It utilizes `figment` for robust configuration management (TOML, environment variables, CLI) which helps prevent hardcoded secrets. Structured logging with `tracing` mitigates log injection. However, the template explicitly states that it does *not* provide built-in authentication, authorization, or TLS, advising users to add these as needed for production deployments. The default HTTP host bind `0.0.0.0` is configurable, but also requires users to be aware of network exposure.
Updated: 2025-11-25GitHub→
0
0
Medium Cost
johnohhh1 icon
Sec8

Integrates Exploit-DB with AI assistants (e.g., Open-WebUI) to assist with penetration testing workflows by searching for and retrieving exploit information.

Setup Requirements

  • ⚠️Requires manual extraction of the `exploitdb-main.zip` database to a specified path (defaults to home directory).
  • ⚠️Optional but recommended: `searchsploit` must be installed separately for faster searches; otherwise, CSV parsing is used, which can be slower.
  • ⚠️Requires manual configuration within Open-WebUI (Admin Panel or `mcp.json` modification). Docker Open-WebUI users require volume mounts and Python installed within the container.
Verified SafeView Analysis
The server executes external commands via `subprocess.run` (specifically `searchsploit`) with user-provided `keyword` and `edb_id`. While `searchsploit` is a legitimate and common tool for this purpose, direct passing of unsanitized user input to external commands can be a vector for command injection if not handled carefully, or if `searchsploit` itself has vulnerabilities. However, `searchsploit` is designed to process arbitrary search terms. The `README.md` explicitly warns against exposing the server to the internet and emphasizes use for authorized testing only, which mitigates the primary risks. No `eval` or hardcoded secrets were found.
Updated: 2025-12-14GitHub→
0
0
Low Cost
suissa icon
Sec4

A web dashboard for Magalu Marketplace sellers to manage their products, orders, customer service tickets, customer questions, and chat conversations.

Setup Requirements

  • ⚠️Requires a valid Magalu API Key (obtained from the Magalu Developer Portal)
  • ⚠️Requires a valid Magalu Seller ID
Verified SafeView Analysis
The application stores the Magalu API Key and Seller ID directly in the browser's localStorage in plaintext. This is a critical security vulnerability, as these credentials can be easily exfiltrated via Cross-Site Scripting (XSS) attacks. Any successful XSS exploit would grant an attacker full access to the seller's Magalu account via the exposed API key and seller ID.
Updated: 2025-11-22GitHub→
PreviousPage 543 of 760Next