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
High Cost
openpharma-org icon

financials-mcp

by openpharma-org

Sec8

A comprehensive Model Context Protocol (MCP) server that provides professional-grade access to financial and economic data through Yahoo Finance and Federal Reserve Economic Data (FRED).

Setup Requirements

  • ⚠️Requires a free FRED API Key (set as FRED_API_KEY environment variable) for most FRED data retrieval methods.
  • ⚠️Relies on unofficial Yahoo Finance web scraping, which may be prone to breakage due to website changes or bot detection.
  • ⚠️Requires Node.js version 18 or higher.
Verified SafeView Analysis
The server primarily performs web scraping from Yahoo Finance and uses the FRED API. It correctly retrieves the FRED_API_KEY from environment variables, preventing hardcoding. The Yahoo Finance scraping uses a mobile User-Agent and includes built-in throttling and bot detection handling, indicating an awareness of scraping challenges, but it's an unofficial method. No 'eval' or other directly exploitable malicious patterns were found. Network requests are to legitimate financial data sources.
Updated: 2025-12-22GitHub→
0
0
Medium Cost
timothywarner-org icon

stoic-mcp

by timothywarner-org

Sec8

An MCP server for Claude Desktop that provides access to a curated collection of wisdom quotes from Stoic philosophers and modern personal development authors, offering quote management, discovery, and AI-powered explanations and generation.

Setup Requirements

  • ⚠️Requires Claude Desktop for MCP integration.
  • ⚠️Requires a DeepSeek API key (paid service) for AI-powered features (explanations and quote generation).
  • ⚠️The full path to `dist/index.js` must be manually configured in Claude Desktop's `claude_desktop_config.json`, which can be platform-specific and error-prone.
Verified SafeView Analysis
The server uses `StdioServerTransport` for communication, which is safer than direct network exposure. AI API key (`DEEPSEEK_API_KEY`) is retrieved from environment variables, which is good practice. Tool arguments are type-cast and processed in a controlled switch statement, reducing direct code execution risks. The `import-quotes.ts` utility takes a filename from process arguments, but uses `path.join` with a fixed base directory (`quotes-source/`), which mitigates simple path traversal attacks to write arbitrary files outside the intended directory. AI prompts are constructed with user content, which is sent to an external API but not executed locally, presenting a minor prompt injection vector at the DeepSeek API level.
Updated: 2025-11-19GitHub→
0
0
Low Cost
aaronjnichols icon

mcp_server_example01

by aaronjnichols

Sec10

Performs addition of two numbers and generates a text summary, a PNG bar chart visualization, and a CSV file of the result. Designed to be consumed by a client (e.g., an AI agent).

Setup Requirements

  • ⚠️Requires `matplotlib` for plotting, which might need system-level dependencies depending on the environment (though pre-built wheels are common).
  • ⚠️Requires the `FastMCP` library to be installed.
Verified SafeView Analysis
The source code in `src/mcp_test.py` does not contain any obvious security vulnerabilities such as direct use of `eval()` or `exec()` with untrusted input, arbitrary file system writes, or hardcoded secrets. It relies on standard and generally secure Python libraries for its functionality (matplotlib, csv, base64). Network communication and server handling are delegated to the `FastMCP` framework, which is built on `uvicorn`, a robust ASGI server.
Updated: 2025-11-22GitHub→
0
0
Medium Cost
victormasson21 icon

foundation-project-mcp

by victormasson21

Sec8

An MCP server enabling AI assistants to securely read unread emails, draft replies in Gmail, and access email writing style guides from Notion.

Setup Requirements

  • ⚠️Requires Google Cloud Console setup for Gmail API Client ID and Secret.
  • ⚠️Manual OAuth authentication process involving opening a URL in a browser and approving access.
  • ⚠️Optional Notion integration requires creating a Notion integration, a style guide page, and granting access.
  • ⚠️The `.env.local` file must be manually created and populated, and never committed to version control.
Verified SafeView Analysis
The server uses OAuth 2.0 for Gmail access with `gmail.readonly` and `gmail.compose` scopes, which are sensitive. It explicitly warns against committing `.env.local` containing credentials and saves tokens securely. Email headers are sanitized to prevent injection attacks. OAuth token generation involves a temporary local web server, which is a standard secure practice. Overall, good security practices are implemented for its intended functionality.
Updated: 2025-12-07GitHub→
0
0
Low Cost
aporthq icon
Sec9

Provides policy enforcement for AI agent tool calls using the APort platform for authorization and audit trails.

Setup Requirements

  • ⚠️Requires an APort Agent Passport, which needs to be registered via the APort API (aport.io) using a curl command.
  • ⚠️Depends on the external APort service (api.aport.io) for real-time policy verification.
  • ⚠️Requires Node.js and npm to run the server, with client examples also available in Python.
Verified SafeView Analysis
The server is built using the Model Context Protocol (MCP) SDK and APort SDK for policy enforcement. It does not contain 'eval' or other directly exploitable patterns. Configuration values are sourced from environment variables, preventing hardcoded secrets. The 'Simple Mode' explicitly noted in the README implies a lesser security posture than an upcoming 'Secure Mode', but this is transparent. Calls to the external APort service are central to its function and introduce a dependency on that service's security.
Updated: 2026-01-15GitHub→
0
0
Medium Cost
johngrimes icon

mcp-js-debugger

by johngrimes

Sec2

Enables AI assistants to debug JavaScript and TypeScript applications by exposing Chrome DevTools Protocol capabilities.

Setup Requirements

  • ⚠️Requires Node.js 18.0.0 or later.
  • ⚠️Requires a CDP-compatible debug target (e.g., Node.js with --inspect, Chrome, Edge) to be running and exposed via WebSocket URL.
Review RequiredView Analysis
The server allows connecting to arbitrary WebSocket URLs via `connect_debugger` and fetching source maps from arbitrary URLs. This presents a severe Server-Side Request Forgery (SSRF) vulnerability, allowing an AI to potentially probe or interact with internal network resources from the host running the MCP server. While the evaluation of expressions is an inherent function of a debugger, the uncontrolled network access for connection and resource fetching is a critical flaw. The design document mentions mitigation strategies (URL validation, allowlists), but these are not implemented in the provided source code.
Updated: 2025-11-24GitHub→
0
0
High Cost
NeverGET icon
Sec8

Delegates token-heavy development operations from Claude Code to Gemini CLI, enabling scalable AI-powered development workflows without exceeding Claude's context window.

Setup Requirements

  • ⚠️Requires Node.js 18+ to run the wrapper.
  • ⚠️Requires Gemini CLI to be installed and authenticated on the system where this wrapper runs (`npm install -g @google/gemini-cli && gemini auth`).
  • ⚠️Optional: Redis server required if `REDIS_URL` environment variable is set for session persistence.
  • ⚠️Requires the SuperClaude Spec Workflow framework root to be discoverable or set via `SCW_FRAMEWORK_PATH` for local development setup.
Verified SafeView Analysis
The Gemini MCP Wrapper primarily acts as a secure proxy, executing the `gemini` CLI with prompts and file paths derived from incoming MCP requests. It does not introduce new direct execution capabilities like `eval` or obfuscation. The main security considerations are inherited from the `gemini` CLI itself (e.g., its tool access, sandboxing configuration) and the broader SuperClaude Spec Workflow's validation process, where Claude is explicitly mandated to validate ALL Gemini outputs *after* execution. Session data is stored locally in `.claude/sessions` or optionally in Redis; this is generally safe within a controlled project environment. No hardcoded secrets are present; environment variables are used for configuration.
Updated: 2025-11-29GitHub→
0
0
Low Cost
BeCrafter icon

mcp-router

by BeCrafter

Sec3

A powerful Model Context Protocol (MCP) routing and management tool that supports aggregating multiple MCP servers, providing a unified management interface and API.

Setup Requirements

  • ⚠️Requires Node.js >= 20.0.0
  • ⚠️Uses pnpm as package manager
  • ⚠️Electron desktop application requires a desktop environment
  • ⚠️Native module `better-sqlite3` requires `electron-rebuild` (handled by postinstall script)
Review RequiredView Analysis
The application explicitly uses Node.js `vm` module's `runInContext` for executing user-defined Hook code, which is noted in the source as 'lower security' and suggests upgrading to `vm2` or `isolated-vm`. Token validation for the HTTP API is marked as 'TODO' in `MCPHttpServer`, indicating an incomplete authentication mechanism. The `StdioClientTransport` executes arbitrary commands based on server configuration, posing a risk if input to these configurations is not properly sanitized or controlled.
Updated: 2025-11-27GitHub→
0
0
Low Cost
aduboseh icon

iter

by aduboseh

Sec9

Iter is a governed Model Context Protocol (MCP) server that provides deterministic, auditable decisions, enforces policy and economic constraints, and emits replay-sufficient DecisionPackets for AI systems.

Setup Requirements

  • ⚠️The default build (`public_stub`) provides a deterministic stub implementation for protocol validation but does not include the full proprietary execution substrate. Expecting full functionality with the public repo will lead to disappointment.
  • ⚠️The server primarily communicates via standard input/output (STDIO) in its current public form, not over HTTP/HTTPS. It is designed to be run as a child process and interacted with programmatically, e.g., via the provided Rust/TypeScript SDKs.
  • ⚠️When run as a child process (e.g., by the SDKs or examples), the server binary (`iter-server`) is expected to be discoverable in the system's PATH, or its path explicitly provided by the client application.
Verified SafeView Analysis
The codebase demonstrates a strong focus on security, particularly around strict input validation (e.g., NaN/Infinity, bounds for floats, hash formats), a fail-closed design for invalid inputs (e.g., unknown enum values), and explicit information redaction in outputs to prevent leakage of internal state. The primary communication mechanism for the public stub is STDIO, which inherently limits direct network attack surface. There are no obvious hardcoded secrets or malicious patterns in the provided public source code. The `caller_context` module is a placeholder, deferring authentication/authorization implementation to future phases, meaning this specific component isn't yet secured.
Updated: 2026-01-14GitHub→
0
0
Medium Cost
kittu532518 icon

stock_techfun_analyst

by kittu532518

Sec3

Aggregates analysis from multiple MCP servers to provide comprehensive stock insights.

Review RequiredView Analysis
The provided source code is limited to only the README.md file. Without the actual server logic or other code files, a comprehensive security audit is impossible. The score reflects the inability to verify safety due to lack of code, rather than identified vulnerabilities.
Updated: 2025-11-25GitHub→
0
0
Low Cost
mosteligible icon

mcp-starter

by mosteligible

Sec2

A starter template for building Model Context Protocol (MCP) servers with FastMCP and FastAPI, providing configurable tools and resources.

Setup Requirements

  • ⚠️Requires Python >= 3.10
  • ⚠️Authentication is not enabled by default and requires custom implementation in AuthMiddleware for secure deployment.
Verified SafeView Analysis
The default AuthMiddleware is a pass-through implementation with a 'TODO' for adding actual authentication logic. While an AUTH_TOKEN environment variable exists, it is not utilized in the provided default middleware. This means that, by default, the server does NOT enforce authentication, making it critically insecure for any sensitive use case without custom implementation of the AuthMiddleware.
Updated: 2025-12-21GitHub→
0
0
Medium Cost
AuraFriday icon

local_mcp

by AuraFriday

Sec4

Bridges STDIO-based Model Context Protocol (MCP) tools to an SSE server with progressive discovery, enabling AI to access a vast toolbox without context explosion.

Setup Requirements

  • ⚠️Requires manual configuration of external MCP server commands and arguments in `settings[0].local_mcpServers` within `nativemessaging.json`.
  • ⚠️External MCP servers are not included; users must find and install them (e.g., via npm) and ensure they are compatible with the MCP protocol.
  • ⚠️External MCP servers run with the user's local permissions, necessitating strict trust in any configured server to prevent system compromise.
  • ⚠️Requires Python 3.8+.
Verified SafeView Analysis
The server's core function is to execute arbitrary external commands (MCP servers) configured by the user via `command` and `args` in `nativemessaging.json`. This means a malicious external server, if configured, could run arbitrary code with the user's permissions, including accessing local files or making network requests. While the code itself does not contain 'eval' or direct malicious patterns, it acts as an execution environment for user-defined binaries/scripts without sandboxing. The README explicitly warns about this risk, stating 'Does not provide sandboxing: External servers run with your user's permissions. Malicious servers could access your files. Only enable trusted servers.' The use of an HMAC-based `tool_unlock_token` helps ensure the AI has read documentation before executing, but doesn't prevent malicious server behavior itself. The `env` field for subprocesses is used to pass sensitive information like API keys, which is a standard practice but relies on the security of the configuration file and the external server itself.
Updated: 2025-12-02GitHub→
PreviousPage 492 of 760Next