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

mcp-servers

by rishit2264

Sec8

This project demonstrates setting up and interacting with multiple MCP servers (Multi-Compute Protocol) using a client and a ReAct agent powered by an LLM for tool orchestration.

Setup Requirements

  • ⚠️Python 3.12+ required
  • ⚠️GROQ_API_KEY environment variable is required (paid service)
  • ⚠️Requires separate 'mathserver.py' (not provided) and 'weather.py' processes to be running concurrently for the client to function as intended.
Verified SafeView Analysis
The code loads API keys from environment variables, which is a good practice. Servers run locally by default (127.0.0.1) using HTTP, which is generally safe for local execution. No 'eval', obfuscation, or hardcoded secrets were found. The primary security considerations would stem from how the underlying 'mcp' library handles tool execution and if the HTTP server is exposed to external networks without proper security.
Updated: 2025-11-19GitHub→
0
0
Medium Cost
techmad220 icon

code-quality-mcp

by techmad220

Sec9

A Rust-based MCP server for comprehensive code quality analysis, designed to work alongside harness enforcement gates for proactive self-correction in code generation.

Setup Requirements

  • ⚠️Requires Rust toolchain installed for building (`cargo build`).
  • ⚠️Full functionality of `dependency_audit` requires specific language ecosystem auditors (e.g., `cargo-audit`, `npm`, `pip-audit`, `go` with `govulncheck`) to be installed and accessible in the system PATH.
  • ⚠️The `pattern_history` tool requires a separate 'cognitive-memory' MCP server running, defaulting to `http://localhost:8050`.
Verified SafeView Analysis
The server's own codebase appears robust, using safe Rust practices like `std::process::Command` for external tool execution, which prevents shell injection within the server itself. It actively scans for common security vulnerabilities (SQLi, XSS, CMDi, hardcoded secrets, etc.) in user code, demonstrating good security awareness. It makes HTTP calls to a configurable 'cognitive-memory' server, which is a known external dependency and not an inherent vulnerability in this server's code. No 'eval', code obfuscation, or hardcoded secrets were found within the provided source code of the MCP server.
Updated: 2025-12-14GitHub→
0
0
Low Cost
rjmarin icon
Sec5

This project likely provides a server-side utility or modification for the Minecraft Protocol, focused on editing or manipulating text-based content within the game or its related server environment.

Review RequiredView Analysis
No source code was provided for analysis. Cannot perform a security audit for 'eval', obfuscation, network risks, hardcoded secrets, or malicious patterns. The score is a placeholder, as safety cannot be guaranteed without code.
Updated: 2025-12-02GitHub→
0
0
Low Cost
bioanywhere icon
Sec9

Provides Docker deployment configuration and CI/CD setup for a generic 'MCP server' application.

Setup Requirements

  • ⚠️Docker required
  • ⚠️GCP Service Account (with appropriate permissions) and Project ID required for CI/CD pushing to Google Artifact Registry
  • ⚠️Port 3000 must be available on the host system
Verified SafeView Analysis
Standard Docker deployment configuration. No hardcoded secrets or malicious patterns observed in the provided deployment scripts. Secrets like GCP_CREDENTIALS and GCP_PROJECT_ID are externalized as repository secrets for CI/CD, which is a good practice. The server exposes port 3000, which is typical for a web service.
Updated: 2025-12-02GitHub→
0
0
Medium Cost
GUESTVALENCIA icon

mcp-enterprise-server

by GUESTVALENCIA

Sec1

A multimodal AI platform integrating Qwen3 models for enterprise-level system interaction, real-time multimedia generation, and communication capabilities.

Setup Requirements

  • ⚠️Requires multiple paid API keys for external services (Groq, Cartesia, Deepgram, Twilio, Render).
  • ⚠️Node.js version >=18.0.0 is required for execution.
  • ⚠️Image and video generation features are currently placeholders or simulated, requiring further integration for full functionality.
  • ⚠️Requires manual `.env` file configuration with all necessary API keys.
Review RequiredView Analysis
CRITICAL: The server is highly vulnerable to command injection and path traversal. The `child_process.exec` function is used directly with unsanitized user input (`req.body.command`) in the `/mcp/command/execute` endpoint and within the `execute_command` Qwen tool. Similarly, `fs.readFile` directly uses unsanitized user input (`req.body.path`, `req.body.uri`) in `/mcp/resources/read` and the `read_file` Qwen tool. These vulnerabilities allow remote code execution and arbitrary file access on the host system. Furthermore, the `RENDER_API_KEY` is hardcoded as a fallback in the Render API client services, and a 'mcp-secret' authentication header ('sandra_enterprise_2025') is hardcoded in test files and used for authentication, making it publicly exposed and trivial to bypass.
Updated: 2025-12-14GitHub→
0
0
Medium Cost
binahm icon
Sec9

Manages a private registry of Model Context Protocol (MCP) servers by combining selections from public registries and organization-specific private server definitions, to control what developers can install for tools like GitHub Copilot.

Setup Requirements

  • ⚠️Requires Python 3.12+
  • ⚠️Relies on an external proxy service (not part of this repo) to serve the GitHub-hosted registry in the MCP format.
  • ⚠️Client applications (e.g., GitHub Copilot) require specific administrative configuration to use this private registry.
Verified SafeView Analysis
The code primarily involves fetching JSON data from configured public registries and loading local JSON files. It explicitly states that secrets never go into the repository, mitigating hardcoded credential risks. Schema validation is used for configuration and server definitions. While fetching remote data always carries inherent risks (e.g., a compromised public registry serving malformed data), the codebase itself does not appear to execute arbitrary remote code on the host running the registry scripts. The actual execution of MCP servers (especially package-based ones) is intended to happen client-side, making client configuration critical for end-to-end security. The use of URL encoding for server names in network requests is a good practice.
Updated: 2026-01-19GitHub→
0
0
Low Cost
WaltXin icon
Sec8

Provides credit card fetching and analysis tools, along with educational guides, for integration with AI agents using the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Local testing with OpenAI Agent Builder requires exposing the local server via a public tunnel like Ngrok.
  • ⚠️The production deployment targets Cloudflare Workers and utilizes Cloudflare-specific services like Durable Objects ('MCP_OBJECT') and KV storage ('OAUTH_KV'), making it tightly coupled to the Cloudflare ecosystem.
  • ⚠️When deployed to Cloudflare, a custom domain is required for compatibility with OpenAI Agent Builder (generic '.workers.dev' domains are blocked).
Verified SafeView Analysis
The server exposes two tools, 'get-cards' and 'get-guides', both of which fetch data from a hardcoded external AWS API endpoint (https://fqrqqph16l.execute-api.us-west-2.amazonaws.com). While the parameters for 'get-cards' are validated using Zod, the system relies entirely on the security and data integrity of this external API. The server uses permissive CORS headers ('Access-Control-Allow-Origin: *'), which is standard for public APIs but means no origin-based access control is enforced at this layer. No 'eval' or obvious hardcoded secrets beyond public API endpoints were found.
Updated: 2025-12-25GitHub→
0
0
Medium Cost
officialpraise icon

mongodb-mcp-server-forked

by officialpraise

Sec8

A Model Context Protocol server for enabling AI assistants to interact with MongoDB databases and MongoDB Atlas resources through natural language.

Setup Requirements

  • ⚠️Requires Node.js v20.10.0 or later.
  • ⚠️The server will not start unless a MongoDB connection string or Atlas API credentials are configured.
  • ⚠️Atlas API credentials require careful management of permissions; only grant the minimum necessary roles to service accounts.
Verified SafeView Analysis
The server uses `mongodb-redact` to hide sensitive data in logs, generates secure, expiring passwords for Atlas database users, and guides users on assigning minimal API key permissions. It features an 'indexCheck' to enforce query optimization and 'readOnly' mode for restricted access. However, like any database-interacting system, its overall security is highly dependent on how MongoDB connection strings and Atlas API credentials (client ID/secret) are configured and managed externally.
Updated: 2025-12-22GitHub→
0
0
Medium Cost
PerfLab-io icon

v0-mcp

by PerfLab-io

Sec6

An MCP (Model Context Protocol) server that exposes v0.dev APIs for AI-powered development tools with real-time streaming support, enabling client applications to interact with v0.dev services.

Setup Requirements

  • ⚠️Requires `V0_API_KEY` for v0.dev API access (which may incur costs depending on usage).
  • ⚠️Requires an Upstash Redis (or compatible KV store) with `KV_URL`, `KV_REST_API_URL`, `KV_REST_API_TOKEN`, `KV_REST_API_READ_ONLY_TOKEN` configured.
  • ⚠️Requires a `DATABASE_URL` for a database (e.g., Supabase) connection.
  • ⚠️The OAuth PKCE validation contains a temporary bypass (`lib/oauth-provider.ts`) that, if not removed, creates a critical security vulnerability.
  • ⚠️Uses `pnpm` as the preferred package manager; users should install dependencies with `pnpm install`.
Review RequiredView Analysis
The server implements robust cryptographic practices for API key encryption using AES-256-GCM and SHA256 derivation. It also includes sensitive data redaction in logging and rate limiting for log messages. However, there is a **critical temporary bypass** in `lib/oauth-provider.ts` for PKCE validation (`PKCE validation failed - this might be a client issue // TEMPORARY: Allowing invalid PKCE for testing`). If this bypass is active in production, it poses a significant security vulnerability, allowing an attacker to exchange stolen authorization codes without a valid `code_verifier`. This is a severe weakness that must be addressed immediately for a production environment.
Updated: 2025-12-13GitHub→
0
0
Low Cost
PaddyNoonan icon

-fenergo-mcp-server

by PaddyNoonan

Sec2

Provides an AI-powered connector for Claude Desktop and ChatGPT to query Fenergo Nebula document management and customer journey data via a shared AWS AppRunner backend.

Setup Requirements

  • ⚠️Requires manual registration of OIDC client (`mcp-client`) with Fenergo's identity provider, including a specific redirect URI (`https://tc8srxrkcp.eu-west-1.awsapprunner.com/signin-oidc`).
  • ⚠️Contains hardcoded default client secrets (`d67105c0-52ca-164e-d0ea-b107cbbfdbc3` and `secret`) in source files (`oidc-auth.js`, `oauth-auth.js`) that override environment variables if not properly configured, posing a critical security risk.
  • ⚠️Uses an in-memory session store for SSO state and tokens, which means sessions are not persistent across server restarts and is not scalable for multiple instances (explicitly noted as 'development only').
  • ⚠️Requires deployment to AWS AppRunner for the backend service, implying AWS account setup and configuration.
Review RequiredView Analysis
The codebase contains hardcoded default sensitive values for `clientSecret` in `oidc-auth.js` and `oauth-auth.js`, which is a severe security vulnerability. Additionally, the `apprunner-backend.js` explicitly logs the full value of `FENERGO_OIDC_CLIENT_SECRET` (if set) during startup and diagnostics, which exposes credentials in application logs. The in-memory session store is not suitable for production and could lead to session loss or vulnerability if not properly managed in a distributed environment. While HTTPS and secure protocol settings are used, these critical issues significantly compromise the security posture.
Updated: 2025-12-12GitHub→
0
0
Low Cost
freeshineit icon

mcp-server-rust

by freeshineit

Sec7

The server implements a simple protocol for exposing tools and resources, primarily for an agent to interact with various functionalities.

Setup Requirements

  • ⚠️Requires Rust toolchain (Cargo) for local development and execution.
  • ⚠️The provided `mcp-config.toml` is currently ignored; tools and resources are hardcoded in the server logic.
  • ⚠️Docker and Docker Compose are required for containerized deployment.
Verified SafeView Analysis
The server implements a custom JSON-RPC-like protocol over TCP. While the current implementation of 'search_files' and 'read_resource' methods *simulates* file system interactions and returns hardcoded responses, the interface for accepting user-provided paths and patterns (e.g., 'pattern', 'directory', 'uri') carries a high potential for path traversal and arbitrary file access vulnerabilities if these operations were to be fully implemented with actual file system I/O without robust input sanitization and access control. No hardcoded secrets or 'eval'-like patterns are present. The 'mcp-config.toml' file is provided but currently ignored by the server's hardcoded tool and resource definitions.
Updated: 2026-01-19GitHub→
0
0
Low Cost
nlupitaviza icon

mcp-server

by nlupitaviza

Sec5

A Node.js Express server designed to stream real-time data, specifically initial model loading and periodic updates (pings), to client applications using Server-Sent Events (SSE).

Setup Requirements

  • ⚠️Requires Node.js to be installed on the host system.
  • ⚠️The default CORS policy allows all origins (`*`), which is generally not recommended for production. Configure specific allowed origins or use a proxy to restrict access.
  • ⚠️No authentication or authorization is implemented for the data streaming endpoint, making the data publicly accessible to any client that connects.
Verified SafeView Analysis
The server uses `cors()` without specific origin configuration, allowing requests from any domain, which is a significant security risk for production environments if sensitive data were to be exposed. There is no authentication or authorization implemented for the `/mcp` SSE endpoint, meaning any client can connect and receive data. No apparent malicious patterns, hardcoded secrets, or usage of `eval` were found.
Updated: 2026-01-18GitHub→
PreviousPage 655 of 760Next