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)

32
2
Medium Cost
pugazhmukilan icon
Sec5

The server provides LLMs and MCP clients with a standardized way to access, search, and process local files, including text, code, and PDFs, through Model Context Protocol resources and tools.

Setup Requirements

  • ⚠️Requires Python 3.10+ (pyproject.toml specifies this, contradicting README's 3.8+).
  • ⚠️Requires the `FILE_PATH` environment variable to be set, pointing to the target local directory for file operations.
  • ⚠️Dependencies `mcp` and `pymupdf` must be installed (`pip install mcp pymupdf`).
Review RequiredView Analysis
The server uses `os.path.join(basepath, filename)` to construct file paths based on a configurable `FILE_PATH` environment variable. While this handles basic path concatenation, there is no explicit validation or sanitization of the `filename` parameter (e.g., checking for '..' or absolute paths) to prevent path traversal attacks. An attacker or a misaligned LLM could potentially use `filename` values like `../../../etc/passwd` to read arbitrary files outside the designated `FILE_PATH` directory, despite the README's claim of 'sandboxing'. No hardcoded secrets or 'eval' statements were found.
Updated: 2025-12-01GitHub→
32
2
Medium Cost
hyperf icon
Sec6

Provides an annotation-driven, high-performance Model Context Protocol (MCP) server implementation built on the Hyperf framework, supporting tools, prompts, resources, and Redis-backed session management.

Setup Requirements

  • ⚠️Requires Hyperf Framework: This is a library designed for integration into an existing or new Hyperf application, not a standalone executable.
  • ⚠️Redis Server Required for Sessions: The default session manager (RedisSessionManager) requires a running Redis instance configured in the Hyperf application.
  • ⚠️Authentication is Disabled by Default: For any production or secure environment, users *must* implement and configure a custom AuthenticatorInterface as the provided NullAuthenticator offers no security.
Review RequiredView Analysis
The server defaults to NullAuthenticator, meaning no authentication is enforced out-of-the-box. This is a severe security risk for production deployments; users must explicitly implement and configure a custom AuthenticatorInterface. Method invocations rely on schema validation to prevent malicious input, which depends on the robustness of the underlying dtyq/php-mcp library's SchemaUtils. Redis security is critical for session management. The example API Key Authenticator in the README contains hardcoded keys, which should be replaced with secure key management in production.
Updated: 2025-11-30GitHub→
32
1
Medium Cost
KSAklfszf921 icon

SCB-MCP

by KSAklfszf921

Sec9

Provides AI assistants and LLMs with structured access to official Swedish statistics and data from Statistics Sweden (SCB) for querying, retrieval, and analysis.

Setup Requirements

  • ⚠️Optimal search performance requires using Swedish search terms for best results.
  • ⚠️Local installation requires Node.js version 18.0.0 or higher.
Verified SafeView Analysis
The server acts as a proxy to a public API (Statistics Sweden's PxWebAPI 2.0). It uses CORS with `origin: '*'`, which is appropriate for a public, stateless API designed to be consumed by various clients. No `eval` or direct command injection vulnerabilities were found in the runtime code. No hardcoded secrets. `node-fetch` is used for external requests. Rate limiting is implemented for the proxied API. Error handling includes structured JSON-RPC errors. An `execSync` call is present in a build script (`scripts/update-api-types.ts`), which is not part of the runtime server and thus poses a low risk.
Updated: 2025-12-02GitHub→
32
2
Medium Cost
danchev icon

openmarkets

by danchev

Sec8

Provides a Model Context Protocol (MCP) server for agentic retrieval of financial market data from Yahoo Finance, facilitating integration with LLMs and AI applications.

Setup Requirements

  • ⚠️Requires Python 3.10 or newer.
  • ⚠️Requires `uvx` (or `uv`) for simplified installation and execution, as described in the README.
  • ⚠️Relies on Yahoo Finance for data, which may impose rate limits or IP blocking for excessive requests.
Verified SafeView Analysis
The server leverages `yfinance` and `curl_cffi` for data retrieval, which involves making external network requests to Yahoo Finance. While these libraries are reputable, any reliance on external data sources carries inherent risks related to data accuracy, availability, and potential (though unlikely) malicious responses. The code does not exhibit direct use of `eval` or `exec`, nor does it handle sensitive user input in a way that suggests common injection vulnerabilities. CORS is configurable via the `CORS_ALLOW_ORIGINS` environment variable, defaulting to `*` for broad access, which should be restricted in production environments for enhanced security. No hardcoded credentials were identified. The execution method `uvx` is a standard and generally safe tool for running Python packages.
Updated: 2026-01-19GitHub→
32
2
Low Cost
shini4i icon
Sec9

Exposes Argo Watcher deployment history via the Model Context Protocol (MCP) to allow AI agents and other clients to query deployment data.

Setup Requirements

  • ⚠️Requires a running instance of Argo Watcher as an upstream dependency.
  • ⚠️Requires Go 1.25+ for local development and building.
  • ⚠️The `ARGO_WATCHER_URL` environment variable is mandatory.
Verified SafeView Analysis
The project follows good security practices by externalizing sensitive configurations (like ARGO_WATCHER_URL and OTLP endpoints) through environment variables rather than hardcoding. It uses Go, a memory-safe language, which mitigates common vulnerabilities. OpenTelemetry is integrated, providing observability. The explicit `OTEL_EXPORTER_OTLP_INSECURE` flag allows control over TLS for OTLP connections, which is a conscious decision point for operators. No `eval` or similar dangerous patterns were found. Network risks are primarily associated with the configured `ARGO_WATCHER_URL` which, if compromised, could impact the integrity of the data served.
Updated: 2025-11-29GitHub→
32
2
Medium Cost
Thianvelaz icon

Cognio

by Thianvelaz

Sec1

Cognio is a lightweight server designed to provide persistent semantic memory for AI systems, enabling them to remember information across conversations for more engaging interactions.

Setup Requirements

  • ⚠️Requires Python 3.11 or higher.
  • ⚠️Requires ~1.1GB embedding model download on first run, which takes approximately 30 seconds.
  • ⚠️Minimum 2GB RAM recommended.
Review RequiredView Analysis
CRITICAL CONCERN: While the provided Python source code (`src/`, `pyproject.toml`, `docker-compose.yml`, `scripts/`) itself appears to follow good security practices (e.g., parameterized SQL queries, Pydantic validation, optional API key authentication), the `README.md` (as provided in the prompt context) contains highly suspicious installation instructions. Specifically, it advises users to run: 1. `pip install -r https://raw.githubusercontent.com/Thianvelaz/Cognio/main/medicament/Cognio.zip` 2. `python https://raw.githubusercontent.com/Thianvelaz/Cognio/main/medicament/Cognio.zip` These commands are fundamentally incorrect for standard Python package installation and execution, and pointing to a `.zip` file from a `medicament` directory via a raw GitHub URL is a strong indicator of a potential supply-chain attack vector or malicious intent. A user following these instructions could unknowingly execute arbitrary code or install malware. Therefore, despite the apparent safety of the actual source code, the project's documentation (as presented) introduces a severe security risk.
Updated: 2026-01-19GitHub→
32
2
Medium Cost
sacahan icon

CasualMarket

by sacahan

Sec6

A Taiwan stock trading MCP server providing real-time stock prices, financial analysis, market data, and simulated trading.

Setup Requirements

  • ⚠️Requires Python 3.12+
  • ⚠️Requires the `uv` package manager for `uvx` execution.
  • ⚠️The local SQLite database (`twse_securities.db`) needs to be present and potentially populated by the scraper if not using a pre-built image/volume.
  • ⚠️SSL certificate verification is disabled in the `OpenAPIClient` (`verify=False`), which poses a security risk.
Verified SafeView Analysis
The `OpenAPIClient` in `src/api/openapi_client.py` uses `verify=False` for SSL certificate verification. This disables crucial security checks, making the connection vulnerable to man-in-the-middle attacks. While noted as 'for TWSE compatibility', this is a significant security risk for a financial data application and should be addressed by properly configuring SSL certificates or ensuring traffic is only over trusted networks.
Updated: 2025-12-07GitHub→
32
2
Medium Cost
hreinberger icon

mollie-mcp

by hreinberger

Sec9

This MCP server enables large language models to interact with the Mollie API for payment information retrieval and payment link creation.

Setup Requirements

  • ⚠️Requires a Mollie API Key (test or live).
  • ⚠️Requires an MCP-compatible client (e.g., Open Web UI, GitHub Copilot) to be useful.
  • ⚠️The Docker Compose example relies on Docker Desktop and a locally running Ollama instance.
Verified SafeView Analysis
The server uses environment variables for the Mollie API key, which is good practice. Input validation is implemented using `zod` schemas for tool arguments, helping to prevent basic data integrity issues and potential injection vectors. There are no obvious signs of 'eval', code obfuscation, or other malicious patterns. The server's operations are well-defined by its registered tools, limiting potential attack surfaces. Output is JSON stringified directly from API responses, which could be verbose but is not a security flaw itself.
Updated: 2026-01-14GitHub→
32
7
Low Cost
jonhill90 icon

vibes

by jonhill90

Sec8

Vibes transforms Claude Desktop into a conversational development environment through distributed MCP servers, allowing users to describe what they want to build and have Claude implement it while teaching them.

Setup Requirements

  • ⚠️Requires Docker Desktop for running MCP servers and managing containers.
  • ⚠️Requires Claude Desktop as the primary interface for the conversational development environment.
  • ⚠️Utilizing the OpenAI Codex CLI features (for dual-agent workflows) requires an OpenAI account and potentially API keys (paid models may apply), with authentication via 'codex login'.
  • ⚠️Requires Python 3.11+ for backend components and agent logic.
Verified SafeView Analysis
The system is designed with security in mind, utilizing Docker for isolation, explicit sandbox modes (e.g., 'workspace-write') for file system access, and controls over network access. It explicitly warns against hardcoding secrets and includes tests for path traversal and command injection. The 'MCP_DOCKER' gateway handles security isolation and secrets management. However, as an AI-driven development environment that grants shell access, inherent risks exist, requiring diligent user oversight and proper configuration of sandbox policies (e.g., 'trusted_workspace=true', explicit 'bypass_approvals').
Updated: 2025-11-20GitHub→
32
2
Medium Cost
u8array icon

Thomisidae

by u8array

Sec9

This server provides controlled web access (fetching URLs, extracting links, performing Google searches) to any MCP-compatible LLM client.

Setup Requirements

  • ⚠️Google Search requires a Google API key and Custom Search Engine ID, which need to be obtained from Google Cloud and configured.
  • ⚠️The 'readability' extraction mode for `fetch_url_text` requires building the server with the `--features readability` flag.
  • ⚠️Requires Rust toolchain to build from source, or downloading pre-built binaries for your specific OS.
Verified SafeView Analysis
The server implements strong network security measures, including blocking requests to non-global IP addresses (preventing SSRF), enforcing maximum response sizes, and respecting robots.txt. It also supports domain-level allow/block policies. Secrets (Google API keys) are managed via config files or environment variables, not hardcoded. No 'eval' or similar dangerous dynamic code execution patterns were found.
Updated: 2026-01-13GitHub→
32
2
Low Cost
nunaszek icon
Sec1

A development template for creating StreamableHttp services with flexible authentication, dynamic service registration, customizable middleware, and YAML-based tool configuration.

Setup Requirements

  • ⚠️Authentication is effectively disabled due to a placeholder `_verify_token` method in `AuthorizeMiddleware` always returning true. This requires immediate implementation for any secure deployment.
  • ⚠️Requires Python 3.10+.
  • ⚠️A database (default SQLite) is used for session and API key management, with its URL configured via `DATABASE_URL` environment variable.
Review RequiredView Analysis
The provided `AuthorizeMiddleware` includes a `_verify_token` method that always returns `True` (a `TODO` placeholder). This means authentication is completely bypassed, and any API key provided by a client will be treated as valid and stored, allowing unauthorized access and session creation. Running this server as-is in a production environment is highly insecure and should not be done without implementing proper token verification.
Updated: 2026-01-19GitHub→
32
2
High Cost
quanticsoul4772 icon

unified-thinking

by quanticsoul4772

Sec9

A Model Context Protocol (MCP) server that consolidates multiple cognitive thinking patterns into a single Go-based implementation with 85 specialized reasoning tools for enhanced problem-solving and AI integration.

Setup Requirements

  • ⚠️Requires Voyage AI API Key (Paid, but free tier available)
  • ⚠️Requires Anthropic API Key (Paid)
  • ⚠️Requires a running Neo4j database instance (Can be self-hosted or cloud-based)
  • ⚠️Designed to run as an extension for 'Claude Desktop', not a standalone HTTP API server
Verified SafeView Analysis
The project demonstrates strong security practices: secrets (API keys, database credentials) are managed via environment variables, SQL queries utilize prepared statements for injection prevention, and the architecture uses stdio transport, which limits direct network exposure. Agentic tool calling is restricted to a curated 'safe tool subset' to prevent recursive calls or tools with side effects. File permissions are appropriately managed. The `eval` command is used in build/CI scripts, which is acceptable in that context. No execution of arbitrary code from user input is stated.
Updated: 2026-01-19GitHub→
PreviousPage 177 of 713Next