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(8554)

10
2
Medium Cost
ndaelman-hu icon

parse-patrol

by ndaelman-hu

Sec9

Provides a dual-mode framework for AI agents and developers to parse computational chemistry files and interact with the NOMAD materials database.

Setup Requirements

  • ⚠️Requires `uv` package manager for setup and execution.
  • ⚠️Requires Python 3.12+.
  • ⚠️Requires network access for NOMAD database tools.
  • ⚠️MCP tool availability depends on optional package installations; use `uv sync --extra all` for full functionality.
Verified SafeView Analysis
The project uses Pydantic for input validation, standard HTTP requests with timeouts for network communication, and trusted third-party libraries (cclib, iodata) for parsing. Dynamic module imports are controlled by hardcoded configurations, mitigating arbitrary code execution risks. File operations are confined to a designated '.data' directory. No obvious hardcoded secrets or malicious patterns were identified. General risks associated with file parsing from untrusted sources or network interactions remain inherent but are handled with reasonable precautions.
Updated: 2025-12-15GitHub→
10
2
Medium Cost
gauravsingh8026 icon

fastmcp-example

by gauravsingh8026

Sec7

Integrate Model Context Protocol (MCP) with LangChain and LangGraph to build AI agent workflows by exposing a variety of custom and pre-defined tools.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid) for LLM functionality.
  • ⚠️Requires Tavily API Key (Paid/Free tier) for web search functionality.
  • ⚠️Requires Calendly API credentials (Client ID, Client Secret) and potentially a paid Calendly plan for `calendly_create_event`.
  • ⚠️The MCP server must be run in a separate terminal (`python server.py`) before client applications can connect via HTTP transport.
Verified SafeView Analysis
The `http_request` tool in `server.py` and the `_make_http_request` function in `config/custom_tools.py` enable making arbitrary HTTP requests. If an LLM's input can be manipulated via prompt injection, this could lead to Server-Side Request Forgery (SSRF) or unauthorized access to internal network resources. This is an inherent risk in tool-using AI agents. OAuth tokens for Calendly are stored locally in `data/calendly_tokens.json`. The code does not use `eval` or `exec` directly, and relies on environment variables for sensitive API keys.
Updated: 2025-12-11GitHub→
10
1
Medium Cost
bobmatnyc icon

mcp-browser

by bobmatnyc

Sec3

Provides browser control (navigation, DOM interaction) and console log capture for AI coding assistants via a local MCP server, with a browser extension and macOS AppleScript as primary control mechanisms.

Setup Requirements

  • ⚠️Requires manual installation and setup of a browser extension (Chrome, Firefox, or Safari) for full functionality (console logs, advanced DOM control, screenshots).
  • ⚠️macOS users leveraging AppleScript fallback will need to grant system automation permissions for their terminal/IDE to control Safari/Chrome, which can be a friction point.
  • ⚠️The AppleScript-based browser control is macOS-only; Windows/Linux users are reliant solely on the browser extension.
  • ⚠️Some MCP CLI features requiring 'py-mcp-installer' will not work if the dependency is not installed.
Review RequiredView Analysis
The server allows execution of arbitrary JavaScript via the browser extension (`eval(code)` in content.js) and arbitrary AppleScript via the AppleScript service (`osascript -e script`). Both 'code' and 'script' inputs originate from the MCP client (likely an LLM). If the LLM or any upstream component is compromised or provides unexpected input, this could lead to arbitrary code execution in the browser's page context (via the extension) or on the local macOS system (via AppleScript). There's no explicit input sanitization or robust sandboxing of these dynamic code injections evident in the provided source for preventing malicious payloads, relying heavily on the trustworthiness of the MCP client's input. The system runs locally on `localhost`, which mitigates remote network exploitation, but local privilege escalation or data exfiltration is a risk.
Updated: 2025-12-19GitHub→
10
1
Medium Cost
KSAklfszf921 icon

OECD-MCP-server

by KSAklfszf921

Sec9

Provides AI assistants with programmatic access to OECD's extensive economic and statistical datasets via the SDMX API.

Setup Requirements

  • ⚠️Requires Node.js runtime version 18.0.0 or higher.
  • ⚠️The publicly hosted Render free-tier instance may experience cold starts (30-60 seconds delay) after periods of inactivity.
Verified SafeView Analysis
The server demonstrates strong security practices including robust input validation (Zod schemas, custom filter sanitization in `sdmx-client.ts` to prevent SSRF and injection attacks), and comprehensive error message sanitization (`sanitizeErrorMessage` in `http-server.ts`) to prevent information leakage like file paths, database credentials, or stack traces. The Docker and Kubernetes configurations (`docker-compose.yml`, `k8s-deployment.yaml`) include excellent container security settings such as read-only filesystems, `runAsNonRoot`, `no-new-privileges`, and capabilities drops, significantly hardening the deployment. Internal rate limiting in `sdmx-client.ts` helps protect the upstream OECD API. The `http-server.ts` uses `cors()` without specific origin restrictions, allowing all origins by default. While common for public APIs, in a production environment, this should ideally be configured to whitelist specific allowed origins. However, the Kubernetes Ingress configuration does implement an application-level `nginx.ingress.kubernetes.io/rate-limit: "100"` to mitigate denial-of-service attacks.
Updated: 2025-12-18GitHub→
10
1
Medium Cost
CryptoLabInc icon

envector-mcp-server

by CryptoLabInc

Sec4

Provides a Model Context Protocol (MCP) server that enables AI applications to securely access and search homomorphically encrypted vector data stored in enVector, suitable for private networks and secure data environments.

Setup Requirements

  • ⚠️Requires Python 3.10+ (3.12 recommended).
  • ⚠️Requires a running `enVector` server (address, key ID, and path to key files must be configured).
  • ⚠️If `embedding-mode` is set to 'openai', an `OPENAI_API_KEY` environment variable is required, incurring monetary costs for OpenAI API usage.
Review RequiredView Analysis
The `document_preprocess.py` module's `_load_documents_from_path` function takes a `path` parameter from tool arguments and uses `pathlib.Path(path)` and `root.glob(pattern)` to read files. If this `document_path` is controlled by an untrusted client (e.g., via a malicious AI prompt), it presents a significant path traversal vulnerability, potentially allowing unauthorized reading of files outside the intended directory or denial-of-service. There is no clear input sanitization for `document_path`. While configuration is handled via environment variables/CLI (avoiding hardcoded secrets), and the default HTTP bind host is localhost (improving default security), the path traversal risk is critical. The `_to_json_available` method's fallback to `repr(obj)` could potentially expose sensitive object states in logs/errors, but is a lesser concern.
Updated: 2025-12-19GitHub→
10
1
Medium Cost
ryo-aien icon
Sec9

Provides a Model Context Protocol (MCP) server exposing Google Gemini API's File Search capabilities for Retrieval-Augmented Generation (RAG).

Setup Requirements

  • ⚠️Requires Python 3.10+
  • ⚠️Requires a Google Gemini API Key (usage-based costs apply for File Search storage, ingestion, and model inference)
  • ⚠️Recommended to use 'uv' package manager for setup (alternatives using 'pip' and 'venv' are provided)
Verified SafeView Analysis
No hardcoded secrets or 'eval' usage were found in the provided source code. Authentication via Bearer Token is supported and strongly recommended for production, with a clear warning logged if disabled. File uploads are handled securely using temporary files. Good practices for environment variable usage and token management are outlined in the README. The Cloud Run deployment example, while initially 'allow-unauthenticated', strongly emphasizes setting authentication tokens for production.
Updated: 2025-12-18GitHub→
10
1
Low Cost
gerard-kanters icon

mcp-linux-tools

by gerard-kanters

Sec6

Provides an LLM agent with limited and whitelisted Linux server management capabilities, including file operations, service control, cron management, WordPress interaction, and shell command execution.

Setup Requirements

  • ⚠️Requires Python 3.13 or higher
  • ⚠️Requires root access for installation and operation (due to systemctl and crontab access)
  • ⚠️Requires manual editing of `config.json` after cloning
  • ⚠️Requires a Linux system with systemd
Verified SafeView Analysis
The server runs as root, granting high privileges. While most functions employ strict whitelisting (directories, services, WordPress sites) and input sanitization (`shlex.split`, regex validation), certain tools inherently carry elevated risks. The `cron_add` tool allows direct insertion of a command string into the root crontab, which, if containing shell metacharacters, could lead to shell injection when cron executes the job. The `execute_shell_command` is explicitly designed for arbitrary shell command execution (though `shlex.split` mitigates *unintended* shell injection) and runs as root by default, allowing potentially destructive commands. The `mysql_query` tool blocks major destructive SQL commands but permits `UPDATE` queries, which could lead to data corruption. Strong systemd service hardening (`NoNewPrivileges`, `ProtectSystem`, `ProtectHome`, `PrivateTmp`, `ReadWritePaths`) and Python sandbox restrictions (PATH, no network) provide good host-level and runtime isolation. The documentation clearly flags dangerous tools with explicit warnings for LLMs.
Updated: 2025-12-19GitHub→
10
1
Low Cost
tznthou icon
Sec6

Facilitates AI-powered browser debugging by providing a minimal set of tools to monitor console logs, navigate, and execute JavaScript.

Setup Requirements

  • ⚠️Requires Node.js 18+ to be installed.
  • ⚠️Requires Google Chrome to be installed (puppeteer-core does not bundle Chromium).
  • ⚠️Automatically launched debug Chrome instances conflict with already running regular Chrome instances, requiring the user to close all existing Chrome windows first.
Verified SafeView Analysis
The server includes several critical security hardening measures as noted in the changelog, such as input validation for ports and URLs (preventing shell and protocol injection), race condition protection during cleanup, and the use of an isolated user-data-dir for launched Chrome instances. However, the `execute_js` tool inherently allows the execution of arbitrary JavaScript code within the browser context via `new Function()`. While this is the core intended functionality for AI interaction and includes safety measures like code length limits (10,000 characters) and a 5-second execution timeout, it means that a compromised AI agent or a malicious prompt could potentially execute harmful scripts in the user's browser. Users should be aware of this inherent risk, as arbitrary code execution, even with limits, grants significant control.
Updated: 2025-12-17GitHub→
10
2
High Cost
SamyRai icon

juleson

by SamyRai

Sec8

An AI-powered coding agent and automation toolkit that integrates with Google's Jules AI via CLI and MCP for comprehensive software development workflows.

Setup Requirements

  • ⚠️Requires Go 1.24+.
  • ⚠️Requires Jules API key (potentially restricted Google service access).
  • ⚠️MCP server only supports stdio transport (no HTTP/WebSocket).
Verified SafeView Analysis
The system is designed to execute significant code changes and interact with external APIs (Jules AI, GitHub), which inherently carries risks. However, the project provides a detailed SECURITY.md, emphasizes using environment variables for secrets, and includes agent-level review phases (when fully implemented) and explicit warnings about template execution, suggesting a strong focus on secure operation if user best practices are followed.
Updated: 2025-12-15GitHub→
10
1
Medium Cost
isakskogstad icon

OECD-MCP-server

by isakskogstad

Sec9

Provides AI assistants access to OECD's 5,000+ economic and statistical datasets via SDMX API for search, analysis, and comparison.

Setup Requirements

  • ⚠️Requires Node.js >=18.0.0.
  • ⚠️Hosted version on Render's free tier may experience 'cold starts' after inactivity, causing initial delays of 30-60 seconds.
  • ⚠️The 'query_data' tool has a built-in limit of 100 observations by default, and a strict maximum of 1000 observations, to prevent context window overflow in LLMs. Users needing more data must handle pagination or broader queries.
Verified SafeView Analysis
The server demonstrates strong security practices including explicit input validation (Zod schemas), comprehensive filter sanitization (to prevent SSRF, command injection, XSS), internal rate limiting for external API calls, and request timeouts. Error messages are sanitized to prevent information leakage (e.g., file paths, internal IPs, stack traces). Kubernetes and Docker Compose configurations include robust security measures like running as non-root, read-only filesystems, and dropping capabilities. The main area for potential enhancement is the CORS configuration, which is currently set to allow all origins (`app.use(cors())`). In a production environment handling sensitive data, this should typically be restricted to specific, known client origins.
Updated: 2025-12-18GitHub→
10
1
High Cost
winklermw-mz icon

SammelsuriumMCP

by winklermw-mz

Sec7

A server that aggregates various tools (web search, Wikipedia, PDF reader, calendar, weather) to provide external, up-to-date information to a local LLM via a RAG architecture.

Setup Requirements

  • ⚠️Requires Python 3.12 (not compatible with 3.14+ due to ChromaDB dependency).
  • ⚠️Requires ChromaDB to be running as a separate service, accessible at the configured host and port.
  • ⚠️Requires an OpenAI-compatible LLM endpoint (e.g., LM Studio) for embedding generation.
  • ⚠️Google Calendar tools require manual generation and secure storage of Google OAuth 2.0 token (`auth/token.json`) and client credentials (`auth/credentials.json`).
Verified SafeView Analysis
The application relies on external services (LLM, ChromaDB, Google APIs, DuckDuckGo, Open-Meteo). Google Calendar access requires sensitive OAuth 2.0 credentials (`auth/token.json`, `auth/credentials.json`) which must be securely stored and managed, especially in containerized environments. No 'eval' or obvious malicious patterns found. The server binds to 0.0.0.0, exposing it to all network interfaces, which is typical for Docker but requires careful network isolation.
Updated: 2025-12-19GitHub→
10
1
Medium Cost
tareqmamari icon

cloud-logs-mcp

by tareqmamari

Sec9

An MCP server that enables AI assistants to interact with and manage IBM Cloud Logs instances for observability, security, and performance analysis.

Setup Requirements

  • ⚠️Requires an IBM Cloud account with access to IBM Cloud Logs service (a paid service).
  • ⚠️Requires an existing IBM Cloud Logs instance and API key, configured via environment variables.
  • ⚠️Requires an MCP-compatible AI client (e.g., Claude Desktop, Microsoft 365 Copilot) to function as intended.
Verified SafeView Analysis
The project demonstrates a very strong commitment to security with extensive documentation (`SECURITY.md`), including best practices for API key management (no hardcoding, rotation, least privilege), TLS enforcement, network isolation, data protection, and runtime security (non-root users, container security, resource limits, rate limiting). It integrates multiple SAST tools (Gosec, govulncheck, Trivy, Semgrep) in CI/CD and uses pre-commit hooks for secrets detection and code quality. Session management includes robust user ID hashing and path traversal prevention. A minor point is the `install.sh` script lacking explicit checksum verification for downloaded binaries, though release artifacts are cryptographically signed.
Updated: 2025-12-20GitHub→
PreviousPage 262 of 713Next