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

mcp-dnac

by robertbergman2

Sec2

A simple Express.js backend server designed for basic user authentication and API status monitoring.

Review RequiredView Analysis
The server contains critically hardcoded administrator credentials (`admin`/`password123`) in `routes/auth.js`, making it highly vulnerable to unauthorized access. It also uses a hardcoded fallback for `API_KEY` in `config.js`, which is poor practice for production environments.
Updated: 2025-11-18GitHub→
0
0
Low Cost
Clivern icon

Moose

by Clivern

Sec8

Provides a Model Context Protocol (MCP) server boilerplate in Go for integration with Cursor AI IDE, supporting STDIO and Server-Sent Events modes.

Setup Requirements

  • ⚠️Requires Go language installed to build and run from source.
  • ⚠️The 'moose' executable must be in the system's PATH for Cursor AI IDE to find it in STDIO mode.
  • ⚠️When using SSE mode, the 'moose' server must be started manually and running before Cursor AI IDE attempts to connect.
Verified SafeView Analysis
The provided source code is a boilerplate and does not contain obvious critical vulnerabilities like 'eval' or hardcoded secrets. The 'hello_world' tool handler uses safe string formatting. Running in SSE mode exposes an HTTP endpoint; while the boilerplate itself doesn't include authentication/authorization, this would be a consideration for production deployments if exposed externally.
Updated: 2026-01-16GitHub→
0
0
Low Cost
Originate-Group icon

common-mcp-submodule

by Originate-Group

Sec9

Provides a production-ready framework for building HTTP Model Context Protocol (MCP) servers with FastAPI, supporting OAuth 2.1 and Personal Access Token authentication.

Setup Requirements

  • ⚠️Docker is the recommended deployment method, though local Python installation is an alternative.
  • ⚠️OAuth 2.1 authentication requires prior setup with an OIDC provider (e.g., Keycloak) and specific environment variables.
  • ⚠️Requires Python 3.10 or newer.
Verified SafeView Analysis
The server employs robust authentication mechanisms, including OAuth 2.1 token validation via JWKS and configurable PAT verification using a user-provided asynchronous function, promoting secure handling of credentials. External network requests (e.g., to Keycloak) utilize `httpx` with explicit timeouts. Configuration relies on environment variables, preventing hardcoded secrets. The `Access-Control-Allow-Origin: *` header is used for specific OAuth discovery and proxy endpoints, which is common for public OAuth providers and custom connectors, but could be restricted further if all client origins are known.
Updated: 2025-12-12GitHub→
0
0
Medium Cost
jeremyhahn icon

go-keychain

by jeremyhahn

Sec9

Provides a secure JSON-RPC interface (Model Context Protocol) for cryptographic key and certificate management, including threshold signatures, designed for integration with AI assistants and other clients across on-prem, hybrid, and cloud environments.

Setup Requirements

  • ⚠️Requires specific Go build tags to enable non-PKCS#8 cryptographic backends (e.g., TPM2, PKCS#11, Cloud KMS) beyond the default software backend.
  • ⚠️Initial server setup requires an administrator account linked to a FIDO2-compatible security key (hardware requirement).
  • ⚠️Integration with various hardware (TPM2, PKCS#11, YubiKey, CanoKey) or cloud KMS (AWS, GCP, Azure, HashiCorp Vault) backends requires corresponding hardware, emulators, or cloud credentials and proper configuration.
Verified SafeView Analysis
The project demonstrates a strong awareness of security best practices, including robust error handling, panic recovery, authentication and authorization via WebAuthn/FIDO2 and RBAC, and explicit guidance on secure key handling (e.g., keys never leave HSMs, encryption during transport). Build tags are used to minimize attack surface. Extensive testing (92.5% coverage) further supports code quality. Default weak passwords/PINs for some backends, though documented as defaults, are a minor initial vulnerability if not changed.
Updated: 2026-01-17GitHub→
0
0
Low Cost
alex-gecraft icon

mcp-server

by alex-gecraft

Sec1

Unable to identify the specific use case as no source code was provided for analysis. The repository name 'mcp-server' suggests a server implementation, possibly related to Minecraft Protocol.

Setup Requirements

  • ⚠️CRITICAL: No source code was provided for analysis. Cannot identify any specific requirements or friction points.
  • ⚠️Without source code, installation and operation steps are unknown.
Review RequiredView Analysis
CRITICAL: No source code was provided for analysis. It is impossible to perform a security audit, check for 'eval', obfuscation, network risks, hardcoded secrets, or malicious patterns without the code. Therefore, the security score is the lowest possible, and it is considered unsafe to run due to unknown risks.
Updated: 2025-11-24GitHub→
0
0
Medium Cost
oddradioada icon

secop-mcp-project

by oddradioada

Sec9

AI-powered intelligent access to Colombian public procurement data (SECOP II) for searching processes, retrieving details, and aggregating statistics.

Setup Requirements

  • ⚠️Requires Socrata API Key, API Secret, and App Token for full functionality and to avoid strict rate limits. These must be obtained from datos.gov.co.
  • ⚠️Requires Node.js v18 or higher to run, with a specific `start.sh` script provided for WSL users to manage Node environments.
  • ⚠️For Claude Desktop users on Windows running from WSL, a specific configuration using `wsl.exe` is needed to correctly invoke the server script.
Verified SafeView Analysis
The server uses environment variables for API keys/secrets and explicitly includes `.env` in `.gitignore`, which is good practice. Input validation is rigorously implemented using Zod schemas for all tool parameters, significantly reducing the risk of invalid or malicious data. SQL injection is mitigated with a custom `escape` function in the SoQL query builder. The server operates over STDIO, which is inherently more secure than network-exposed services as it avoids typical network vulnerabilities. If a future HTTP/SSE transport is implemented, additional security measures like OAuth2 and TLS will be required as noted in the project's plan.
Updated: 2025-12-13GitHub→
0
0
Medium Cost
wimwenigerkind icon

clockify-mcp

by wimwenigerkind

Sec9

This MCP Server acts as an adapter for the Clockify time tracking API, providing tools to interact with time entries, workspaces, users, clients, and projects.

Setup Requirements

  • ⚠️Requires CLOCKIFY_API_KEY environment variable to be set.
  • ⚠️Requires Node.js runtime (version >=18.18.0).
  • ⚠️Communicates via standard I/O, requiring an MCP-compatible client or host environment for interaction.
Verified SafeView Analysis
The server retrieves the Clockify API key from environment variables, which is a best practice. It explicitly checks for the API key's presence and exits if not configured, preventing unauthenticated operation. Input schemas are validated using Zod, mitigating common injection risks. No 'eval' or obvious obfuscation was found. Error handling for API calls is present. The server uses a StdioServerTransport, which is generally a secure way to operate as it doesn't directly expose network ports but communicates via standard I/O.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
pilgrim-AIEngineer icon

E-RaktkoshMCP

by pilgrim-AIEngineer

Sec8

Provides an agentic interface for querying real-time blood stock availability from the eRaktKosh portal using natural language.

Setup Requirements

  • ⚠️Requires Python 3.10+
  • ⚠️Requires a Google API Key (for Gemini models, potentially paid usage)
  • ⚠️Requires Playwright browser installation (`uv run playwright install`)
Verified SafeView Analysis
The code uses a permissive CORS policy (`allow_origins=["*"]`), which is generally not recommended for publicly exposed APIs due to potential security risks (e.g., XSS if sensitive cookies/headers were involved). However, for an agentic tool possibly used in a controlled environment, this might be acceptable. Secrets (`GOOGLE_API_KEY`) are correctly handled via environment variables, and there's no evident use of dangerous functions like `eval` or hardcoded sensitive data. Web scraping itself carries inherent risks of interacting with external sites but is core to the application's function.
Updated: 2025-12-13GitHub→
0
0
Medium Cost
gjoeckel icon

cursor-global

by gjoeckel

Sec6

Provides a global, portable Cursor IDE configuration for AI-assisted development, including robust workflow automation, MCP server management, and smart Git operations.

Setup Requirements

  • ⚠️Requires Node.js, npm, Git, and 'jq' to be installed on the system.
  • ⚠️A GitHub Personal Access Token (GITHUB_TOKEN) with appropriate scopes is required for GitHub integration.
  • ⚠️MCP server management scripts (`start-mcp-servers.sh`, `restart-mcp-servers.sh`) hardcode 'PROJECT_ROOT' to '${HOME}/Projects/accessilist', which limits the 'fully portable' claim for MCP server startup if custom MCP servers are not cloned/built at that specific path.
Verified SafeView Analysis
The system configures Cursor IDE for 'full AI autonomy' with 'autoApprove: true' and 'confirmationLevel: none', which means the AI can execute commands and modify files without human confirmation. This is an intended feature for maximum autonomy but presents a high risk if the AI agent is compromised. Additionally, custom MCP servers are fetched and run via 'npx -y git+https://github.com/gjoeckel/my-mcp-servers.git', introducing a supply chain risk as external code is executed. A GitHub push gate is implemented, requiring a specific token, which is a positive security measure.
Updated: 2025-11-25GitHub→
0
0
Medium Cost
Lazareprotrusible421 icon

startmcp

by Lazareprotrusible421

Sec8

A unified gateway server for connecting multiple AI assistants to various backend data sources and tools, standardizing integration through the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires Python 3.12 or higher.
  • ⚠️Node.js v18+ and `npx` are required for the Atlassian provider (which uses `mcp-remote`).
  • ⚠️API keys/OAuth access are needed for each integrated backend service (e.g., GitHub, Jira, FireCrawl).
Verified SafeView Analysis
The project emphasizes security best practices like using PKCE for OAuth, `.env` for credentials, and TLS 1.2+ for network communication. Subprocess execution (`stdio` transport) is done via `asyncio.create_subprocess_exec` with a list of arguments, which is safer than shell commands, reducing command injection risks. However, the Atlassian provider's reliance on `npx -y mcp-remote` introduces a supply chain risk, as `npx -y` automatically installs packages, meaning trust is placed on the external `mcp-remote` package and its dependencies. Overall, the architectural principles for security are strong.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
fahadazizz icon

Figma-MCP-Designer

by fahadazizz

Sec9

Extracts, parses, and normalizes Figma design information into a structured JSON schema via a Model Context Protocol (MCP) server.

Setup Requirements

  • ⚠️Requires Figma Personal Access Token (from Figma settings)
  • ⚠️Python 3.10+ is required
Verified SafeView Analysis
The server securely loads the Figma API token from environment variables. It interacts with the Figma API over HTTPS, which is standard for web services. There are no indications of 'eval', code injection, or other immediately dangerous patterns. The client launches the server using `sys.executable` and `main.py`, which is a controlled and generally safe method for running local Python processes.
Updated: 2025-11-30GitHub→
0
0
High Cost
MohamedElashri icon

root-mcp

by MohamedElashri

Sec7

Empowers Large Language Models (LLMs) to natively understand and analyze CERN ROOT files for High Energy Physics (HEP) analysis.

Setup Requirements

  • ⚠️Requires `scipy` and `matplotlib` for 'extended' mode functionality (though it gracefully falls back to 'core' mode if missing).
  • ⚠️Requires a `config.yaml` file to define `security.allowed_roots` and `resources` for any file access. Without proper configuration, tools will fail with security or resource not found errors.
  • ⚠️Requires Python 3.10 or newer.
Verified SafeView Analysis
The server includes robust `PathValidator` for file access, enforcing `allowed_roots`, preventing path traversal, and validating write operations. Remote file access is disabled by default. However, the `core.operations.basic_stats` module uses Python's `eval()` function for processing user-defined expressions (`selection`, `defines`). While `eval()` is restricted to a limited `numpy` namespace and an empty `__builtins__` dictionary to mitigate arbitrary code execution, it remains a less secure approach compared to the `ast`-based `SafeExprEvaluator` used in the `extended` mode's `analysis.operations` module. Users should configure `allowed_roots` carefully to prevent unintended file access.
Updated: 2026-01-17GitHub→
PreviousPage 469 of 760Next