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
zq940222 icon
Sec7

Spring Boot Starter for building custom MCP (Micro-Agent Protocol) servers with dynamic, runtime toolset discovery and registration based on request parameters.

Setup Requirements

  • ⚠️Requires Java 21+
  • ⚠️Requires Spring Boot 4.0+ (this version might be a typo, as Spring Boot 3.x is current; compatibility with 3.x is more likely and implied by dependencies)
Verified SafeView Analysis
The server dynamically loads and invokes tool methods based on user-controlled `toolset` and `toolName` parameters. While tool classes are scanned from a controlled classpath, using reflection (`method.invoke()`) with external input always carries a risk of unintended method execution if not coupled with strict input validation, authorization, and method access control beyond what is visible in the provided snippets. The default empty `crewplus.mcp.server.scan-base-package` property could, if not properly overridden or configured, lead to wider classpath scanning than intended.
Updated: 2025-11-26GitHub→
0
0
Low Cost
sabatajoxicraft icon

mcp-server

by sabatajoxicraft

Sec10

This repository appears to be a project backup for a server application, but no specific functionality can be determined from the provided source code.

Review RequiredView Analysis
Only a README.md file was provided in the source code. No executable code was available for analysis of security risks such as 'eval', obfuscation, network vulnerabilities, hardcoded secrets, or malicious patterns. Based solely on the provided text file, no immediate risks are apparent.
Updated: 2025-12-13GitHub→
0
0
Medium Cost
renoblabs icon

coolify-mcp-server

by renoblabs

Sec4

Enables AI clients (e.g., Claude Desktop, Antigravity) to manage and automate Coolify deployments and infrastructure through natural language commands.

Setup Requirements

  • ⚠️Requires Coolify API Token (from your Coolify instance)
  • ⚠️Requires Python 3.8+ and FastMCP library dependencies
  • ⚠️Remote access (SSE mode) requires network accessibility to the server and potentially Cloudflare Tunnel setup
  • ⚠️Hardcoded API tokens in many helper/test scripts pose a significant security risk if run without modification.
Review RequiredView Analysis
The core server.py file attempts to handle secrets securely via environment variables and implements a Bearer token authentication middleware for SSE mode. However, a critical security risk exists due to numerous instances of hardcoded API tokens (Coolify, Cloudflare, MCP) found in various helper scripts, test files, and example configurations (e.g., coolify_for_openhands.py, deploy_mcp_to_coolify.py, deploy_realestate.py, configure_domain.py, verify_realestate.py, audit_coolify.py, audit_health.py, and most test_*.py files). While documentation strongly advises against this, the presence of these active tokens directly in the codebase poses a severe risk of accidental credential exposure if these files are run or shared. The server binds to 0.0.0.0, but it is behind an authentication middleware.
Updated: 2025-12-11GitHub→
0
0
Low Cost
jermeyyy icon

kortex

by jermeyyy

Sec7

An MCP server that provides AI coding assistants with advanced capabilities for working with Kotlin Multiplatform (KMP) and Compose Multiplatform (CMP) projects, including LSP-based code analysis, navigation, editing, and planning.

Setup Requirements

  • ⚠️Requires Python 3.10+
  • ⚠️Requires Kotlin Language Server to be installed and in PATH
  • ⚠️Optionally requires SourceKit-LSP for Swift/iOS support
  • ⚠️Optionally requires clangd for Objective-C/iOS support
Verified SafeView Analysis
The server uses `asyncio.create_subprocess_exec` to run external Language Server Protocol (LSP) binaries (Kotlin, Swift, Objective-C). While necessary for its core functionality and typically discovers trusted executables via `shutil.which` or hardcoded paths, this introduces a dependency on external tools. A compromised LSP executable or path could lead to unexpected behavior. No direct 'eval' or hardcoded secrets were found. JSON-RPC communication is handled, which can be vulnerable to malformed or oversized payloads if not robustly validated, though typical LSP usage is generally trusted.
Updated: 2025-11-29GitHub→
0
0
Medium Cost
agentoauth icon

openapi-to-mcp

by agentoauth

Sec8

Provides a Model Context Protocol (MCP) interface to the National Weather Service (NWS) API, enabling AI assistants to access weather-related data and forecasts.

Setup Requirements

  • ⚠️Requires API_BASE_URL environment variable (configured in wrangler.toml for Cloudflare Workers, but essential for any deployment).
  • ⚠️Requires Node.js 18+ and `npm` for building and deployment.
  • ⚠️Requires outbound network access to the configured `API_BASE_URL` (https://api.weather.gov).
Verified SafeView Analysis
The server acts as an API proxy, forwarding requests to an external weather API. It uses environment variables (`API_BASE_URL`, `USER_AGENT`) for configuration. Path and query parameters are URL-encoded before being used in `fetch` requests, mitigating direct URL injection risks. The code does not use `eval` or other dynamic code execution from user input. Error responses may expose underlying HTTP status and response bodies from the external API, which is standard for proxies but could reveal minor details in specific error scenarios. Assuming the deployment environment (e.g., Cloudflare Workers) securely manages environment variables and network access, the generated server code is robust for its intended purpose. The broader 'openapi-to-mcp' project's 'mcp-hub' component does contain `exec` calls for build/deploy processes, but these are not part of the 'weather-mcp' server's runtime.
Updated: 2025-12-10GitHub→
0
0
Low Cost
cutsome icon

gmail-mcp

by cutsome

Sec8

An MCP server that integrates with the Gmail API to provide programmatic email search, retrieval of messages (individually and in batches), and attachment management.

Setup Requirements

  • ⚠️Requires Google Cloud Console setup to enable Gmail API and create OAuth 2.0 credentials (Desktop app type).
  • ⚠️Requires `client_secret.json` file to be downloaded and placed in the project directory or specified via an environment variable.
  • ⚠️Requires Python 3.13 or newer.
Verified SafeView Analysis
The server follows standard practices for Gmail API integration and OAuth2 authentication, relying on `client_secret.json` and `token.json` files for credentials, whose paths can be customized via environment variables. No 'eval' or apparent malicious patterns were found. Network communication is primarily with Google's APIs. Error handling in utility functions (`decode_base64_text`, `parse_date`, `decode_rfc2047_filename`) uses broad `except Exception` clauses and `errors='ignore'` for decoding, which prioritizes robustness over strict error propagation and could silently mask malformed data issues, though it's not a direct security vulnerability. Sensitive tokens are stored locally in `token.json` after the initial OAuth flow.
Updated: 2025-11-28GitHub→
0
0
High Cost
jerroldneal icon
Sec3

Fetches YouTube video transcripts and metadata using browser automation to bypass API rate limits.

Setup Requirements

  • ⚠️Requires Docker for recommended deployment, as Puppeteer dependencies (Chromium) are complex.
  • ⚠️Resource-intensive: Puppeteer (Headless Chrome) can consume significant CPU and RAM per request, especially for long videos or concurrent calls.
  • ⚠️Requires outbound network access to YouTube.
Review RequiredView Analysis
The server uses Puppeteer with the `--no-sandbox` argument, which significantly compromises the security of the headless Chrome instance. Since the server processes arbitrary, user-provided URLs, a malicious YouTube video or a compromised YouTube page could exploit vulnerabilities in the browser to potentially escape the container's isolation, if not properly configured, or cause resource exhaustion. This is a critical security risk for any service that processes untrusted input in a browser context without a sandbox.
Updated: 2025-12-03GitHub→
0
0
Medium Cost
LLMTooling icon

mdx-mcp-server

by LLMTooling

Sec6

Enables LLMs to process and analyze MDX files within a defined workspace, offering tools for reading, searching, converting, and extracting metadata.

Setup Requirements

  • ⚠️Requires Node.js version 20.19.0 or higher.
  • ⚠️Requires the `WORKSPACE_ROOT` environment variable or CLI argument to be explicitly set, as all file operations are strictly confined to this directory.
  • ⚠️The `convert_mdx_to_md` tool will not overwrite existing files, returning an error if the `outputPath` already exists.
Review RequiredView Analysis
The server implements strong path safety (`PathResolver`) to prevent directory traversal attacks, confining all file operations (`read_mdx`, `search_mdx`, `convert_mdx_to_md`, `get_mdx_frontmatter`) to a designated `WORKSPACE_ROOT`. The `convert_mdx_to_md` tool also prevents overwriting existing files. However, a critical risk exists due to the use of `mdx-bundler` and React's `renderToString` for processing MDX content. If untrusted or malicious MDX files are processed, embedded JavaScript/JSX code within them will be executed in the server's Node.js environment, potentially leading to code execution vulnerabilities.
Updated: 2025-12-09GitHub→
0
0
Medium Cost
Sec9

An MCP server enabling seamless, secure integration with Microsoft 365 services (Teams, Outlook, OneDrive, SharePoint) for conversational AI agents.

Setup Requirements

  • ⚠️Requires Microsoft Azure App Registration: Manual setup in Azure Portal, including specific redirect URI (`http://localhost:8003/callback`) and API permissions (e.g., User.Read, Team.ReadBasic.All, Mail.Read).
  • ⚠️Requires critical environment variables: MICROSOFT_OAUTH_CLIENT_ID and MICROSOFT_OAUTH_CLIENT_SECRET must be correctly set from Azure App Registration.
  • ⚠️Requires Python 3.10+ and 'uv' package manager for local development.
Verified SafeView Analysis
The project explicitly prioritizes security with OAuth 2.1 (PKCE support), multi-tenant session management, and automatic token refresh. The `auth_session_analysis.md` details comprehensive security hardening, including removing trust from unverified JWTs, enforcing session-to-user binding, mandatory session expiration, and not persisting `client_secret`. It uses the `msal` library for robust OAuth flows. `MCP_PERSIST_CREDENTIALS` is off by default, and if enabled, credentials are saved with restricted file permissions (`0o600`). `OAUTHLIB_INSECURE_TRANSPORT` (or `OAUTH2_ALLOW_INSECURE_TRANSPORT` in Docker) is configurable, defaulting to `false`, which is good for production but can be enabled for local HTTP development. The security model, documentation, and explicit mitigation of common OAuth risks indicate a strong security posture. Minor risk from `OAUTHLIB_INSECURE_TRANSPORT` if misconfigured in production.
Updated: 2025-11-27GitHub→
0
0
Medium Cost
firstdollar icon

fd-mcp-server

by firstdollar

Sec8

Exposes First Dollar Partner APIs to AI agents via the Model Context Protocol (MCP) and provides a web UI dashboard with a chat interface for human interaction.

Setup Requirements

  • ⚠️Requires an Anthropic API Key for the web UI chat functionality (paid service).
  • ⚠️Requires First Dollar Partner API credentials (clientId:clientSecret) for API key authentication, implying a partnership or access agreement.
  • ⚠️The MCP server and token exchange endpoints are explicitly noted as not yet available in production environments, limiting live deployment for AI agents.
Verified SafeView Analysis
The server employs API key authentication for the MCP endpoint, exchanging it for Firebase ID tokens via a backend service, which is a sound approach. All API interactions (both MCP and Web UI) are performed using GraphQL queries with arguments passed as variables, mitigating direct SQL injection risks. The system leverages Firebase for user authentication in the Web UI, including MFA. While `MCP_HOST` allows binding to all interfaces (0.0.0.0), this is common in containerized deployments like Cloud Run, where network security is managed at the platform level. The `allowedHosts` check is disabled in Cloud Run environments, relying on the platform's security. Potential security relies heavily on the robustness of the upstream First Dollar GraphQL APIs and the security of the API key exchange endpoint. Prompt injection risks for the Claude agent are managed through a detailed system prompt and fallback mechanisms, but remain an inherent concern with LLM integrations.
Updated: 2025-12-12GitHub→
0
0
Low Cost
aslanpour icon

mcp-switchboard

by aslanpour

Sec5

Intelligent orchestrator for managing and configuring multiple MCP servers for AI agents, automating setup, credential management, and lifecycle.

Setup Requirements

  • ⚠️Requires Python 3.10+.
  • ⚠️Requires AWS CLI for AWS SSO authentication.
  • ⚠️Requires Node.js/npm for running `npx`-based MCP servers defined in the registry.
  • ⚠️The `manage_servers` tool allows running arbitrary commands, which is a significant security risk if used with untrusted input.
  • ⚠️The HTTP transport (`/mcp` endpoint) does not include built-in authentication and must be secured externally if exposed.
Verified SafeView Analysis
The server's core function involves launching external subprocesses via `asyncio.create_subprocess_exec`. The `setup_mcp_servers` tool uses predefined commands from `registry.yaml` (e.g., `npx @modelcontextprotocol/server-xxx`), which are generally controlled. However, the `manage_servers` tool allows arbitrary `command` and `args` to be executed if provided by the AI agent or user, posing a critical remote code execution risk if input is untrusted or the AI agent is compromised. Additionally, the HTTP transport (created by `http_transport.py`) provides an unauthenticated endpoint for MCP tools, which could be exploited if exposed to an untrusted network without external security measures. Credential management uses system keychain or a permissions-restricted local file, which are generally secure practices.
Updated: 2025-12-14GitHub→
0
0
Medium Cost
shilpamadini icon
Sec8

A multi-agent customer support orchestration system that processes tickets end-to-end, integrating knowledge base, account data, and long-term memory.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid)
  • ⚠️Requires Python 3.11
  • ⚠️Requires local SQLite databases to be built via provided Jupyter notebooks (`01_external_db_setup.ipynb`, `02_core_db_setup.ipynb`)
Verified SafeView Analysis
The project loads API keys from environment variables, which is good practice. FastMCP servers are configured to use `stdio` transport, limiting direct external network exposure for the microservices themselves. Database paths are configurable. SQL queries leverage SQLAlchemy ORM which generally prevents injection, though dynamically constructed `LIKE` clauses in search tools might warrant extra scrutiny for highly untrusted inputs in a production environment. No `eval` or obvious malicious patterns were found.
Updated: 2025-12-04GitHub→
PreviousPage 537 of 760Next