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)

36
5
Low Cost
Alexander-Panov icon

finam-mcp

by Alexander-Panov

Sec8

Integrate Finam Trade API with AI assistants for natural language trading operations via Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires Python 3.12+.
  • ⚠️Requires 'uv' (or 'uvx') for dependency management and execution.
  • ⚠️Requires Finam Trade API Key and Account ID (FINAM_API_KEY, FINAM_ACCOUNT_ID) configured via environment variables or HTTP headers.
  • ⚠️Requires an MCP client (e.g., Claude Desktop, Cursor, VS Code) to interact with the server.
Verified SafeView Analysis
The server securely handles API keys by requiring them via environment variables or HTTP headers, avoiding hardcoded secrets. It utilizes standard Python libraries (`httpx`) for robust network requests and pydantic for data validation. Sensitive trading operations (`place_order`, `cancel_order`) are explicitly marked with `meta={'sensitive': True}` for client awareness. No use of dangerous functions like `eval` or `exec` was found. Security depends on the user's careful handling of Finam API keys and the inherent robustness of the Finam Trade API itself.
Updated: 2026-01-19GitHub→
36
1
Medium Cost
omri3193 icon
Sec8

Orchestrates multiple AI agents for complex reasoning and real-time information retrieval, integrating large language models with web search capabilities.

Setup Requirements

  • ⚠️Requires `GROQ_API_KEY` environment variable.
  • ⚠️Requires `TAVILY_API_KEY` environment variable.
  • ⚠️The `Screenshot 2025-12-29 095100.png` image file must be present in the project root for the frontend UI to display correctly without errors.
Verified SafeView Analysis
The code uses `subprocess.run` for internal service orchestration with hardcoded commands, which is safe. API keys are loaded from environment variables. There are no obvious code-level vulnerabilities like `eval()` with user input or hardcoded secrets. Standard LLM application risks such as prompt injection exist but are not code-specific vulnerabilities here. The `requests.post` to localhost is an internal communication.
Updated: 2026-01-19GitHub→
36
6
Medium Cost
kweinmeister icon

fast-diff-mcp

by kweinmeister

Sec9

Provides a high-performance text diffing service for LLMs, enabling them to compare text blocks and receive differences in unified diff format via the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires Rust Toolchain to compile the Python extension.
  • ⚠️Requires `uv` for Python environment and package management, instead of standard `pip`.
Verified SafeView Analysis
The server binds to '0.0.0.0' by default, meaning it listens on all network interfaces. While common for containerized or local servers, it requires proper network segmentation or firewalling if exposed publicly without additional authentication. No 'eval', hardcoded secrets, or obvious malicious patterns were found in the source code. The core functionality is safe string diffing.
Updated: 2026-01-11GitHub→
36
4
Medium Cost
mcpland icon

mock-mcp

by mcpland

Sec7

Facilitates AI-generated mock data for testing web applications by bridging test runners with Model Context Protocol (MCP) clients.

Setup Requirements

  • ⚠️Requires an MCP (Model Context Protocol) client (e.g., Cursor, Claude Desktop) to be configured and running separately to generate mock data.
  • ⚠️The test runner must set the `MOCK_MCP=1` environment variable to enable mock generation.
  • ⚠️Tests need to use an HTTP interception library (e.g., `fetchMock`, Playwright's `page.route`) to route requests to `mock-mcp`.
Verified SafeView Analysis
The server primarily acts as a conduit between a test process and an external AI client. While the server's code itself appears robust without direct `eval` or obvious vulnerabilities, a critical security consideration lies in the trust placed in the AI-generated data. The server forwards mock data supplied by the AI client without deep validation against the original OpenAPI schema (only structural validation is performed on the mock data arguments, not content). This means if the external AI client is compromised or manipulated (e.g., via prompt injection), it could generate malicious data (e.g., XSS payloads, SQL injection strings) that is then injected into the test environment. While the server doesn't execute this malicious data, it acts as the delivery mechanism.
Updated: 2025-11-22GitHub→
36
6
Medium Cost
wxkingstar icon

doc-hub-mcp

by wxkingstar

Sec8

Provides offline, local Markdown document retrieval and resource reading capabilities for IDEs, Agents, or debugging tools, primarily focused on WeChat Work and Feishu developer documentation.

Setup Requirements

  • ⚠️Node.js version 20.18 or higher is strictly required due to dependency requirements.
  • ⚠️Requires manual configuration of the `DOC_ROOT` environment variable if Markdown documents are not located in the default 'docs/', 'wecom/', or 'feishu/' directories.
  • ⚠️The initial setup and first launch using `npx` may involve downloading over 100MB of data and can take several minutes to complete.
Verified SafeView Analysis
The server's file access is strictly confined to configured document root directories (e.g., 'docs/', 'wecom/', 'feishu/' or a custom path via `DOC_ROOT`). The internal path handling mechanism (`path.relative`, `path.join`, `encodeResourcePath`, `decodeResourcePath`) is designed to prevent path traversal vulnerabilities from client-provided resource URIs. However, if the `DOC_ROOT` environment variable (an administrator-level configuration) is intentionally or inadvertently set to an untrusted or overly broad path (e.g., `/`), it could expose sensitive files readable by the Node.js process to any client with MCP access.
Updated: 2026-01-19GitHub→
36
9
Medium Cost
schemacrawler icon

SchemaCrawler-AI

by schemacrawler

Sec6

Provides an AI-powered interface for natural language database schema exploration, analysis, visualization, and SQL assistance.

Setup Requirements

  • ⚠️Requires JDBC connection details to a database (e.g., URL, user, password), provided via environment variables.
  • ⚠️Requires a Java Runtime Environment or Docker to run.
  • ⚠️The MCP Server transport type (`SCHCRWLR_MCP_SERVER_TRANSPORT`) must be explicitly configured as 'http' or 'stdio', otherwise it defaults to 'stdio' and might not be accessible over the network as expected.
  • ⚠️Relies on Spring AI framework for its core functionality.
Verified SafeView Analysis
The HTTP transport profile in `application.yaml` explicitly allows all origins (`allowed-origin: '*'`), which is a Cross-Origin Resource Sharing (CORS) vulnerability for public APIs, though potentially intended for flexible AI agent integration. User-provided regular expressions for filtering database objects are directly used in `InclusionRule`s, posing a potential Regular Expression Denial of Service (ReDoS) risk if not adequately validated or sandboxed by the underlying SchemaCrawler library. Stack traces are logged to the client on exceptions (`logExceptionToClient`), which can lead to information disclosure. No hardcoded secrets or obvious command injection vulnerabilities were found. Database credentials are handled via environment variables.
Updated: 2026-01-19GitHub→
36
25
High Cost
Eth3rnit3 icon

FerrumMCP

by Eth3rnit3

Sec7

A browser automation server for AI assistants, enabling interaction with web pages through the Model Context Protocol.

Setup Requirements

  • ⚠️Requires Ruby 3.2+.
  • ⚠️Docker deployments require `--security-opt seccomp=unconfined` for Chromium to function.
  • ⚠️BotBrowser profiles, used for anti-detection, require separate licensing or purchase.
  • ⚠️The `solve_captcha` tool requires `whisper-cli` to be installed and available on the system.
Verified SafeView Analysis
The server is designed for trusted environments and should not be publicly exposed without additional security layers. It implements XSS/XPath injection prevention, API key authentication, and rate limiting (when enabled). It features non-root Docker execution and session isolation. Inherent risks like arbitrary JavaScript execution and file system access (for screenshots) are present but managed with explicit caveats. Logging of full backtraces is a potential concern if logs are not secured.
Updated: 2025-12-29GitHub→
36
7
Low Cost
cafferychen777 icon

ChatSpatial

by cafferychen777

Sec8

Natural language-driven spatial transcriptomics analysis via Model Context Protocol, integrating 60+ scientific methods.

Setup Requirements

  • ⚠️Requires Python 3.10+ (3.11-3.12 recommended).
  • ⚠️Many advanced methods require R and specific R packages (e.g., sctransform, spacexr), necessitating a separate R installation and `rpy2`.
  • ⚠️Certain features (STAGATE_pyG, STalign) require manual installation directly from GitHub due to PyPI unavailability.
  • ⚠️Specific methods (SingleR, PETSc acceleration for CellRank) are not available on Windows due to C++ compilation issues.
  • ⚠️A full installation (with all features) can consume 5-10 GB of disk space.
Verified SafeView Analysis
The server is designed to run locally by default (stdio, localhost for SSE/HTTP), minimizing network exposure. Input parameters are extensively validated using Pydantic models. The `SECURITY.md` outlines a clear vulnerability reporting policy. However, the use of `rpy2` for R package integration and `subprocess.run` for specific tasks (like database downloads) introduces potential, albeit controlled, external code execution. While the R scripts are from trusted sources or bundled, this class of operation inherently carries a slightly elevated risk compared to purely sandboxed environments. No hardcoded secrets were identified; API keys for `mllmcelltype` are passed as parameters.
Updated: 2026-01-18GitHub→
36
8
Low Cost
jamesward icon
Sec9

This server provides a set of tools for AI agents to query employee skills and retrieve employees based on specific skills from an in-memory dataset.

Setup Requirements

  • ⚠️Requires Java Development Kit (JDK) installed.
  • ⚠️Requires Gradle (though the 'gradlew' wrapper typically handles this automatically).
Verified SafeView Analysis
The provided source code is minimal and focuses on in-memory data operations. It does not use 'eval', access external resources (databases, APIs, files) beyond standard Spring Boot mechanisms, or handle sensitive user input in a way that suggests immediate vulnerabilities. Input parameters for tool functions are used safely in filtering operations. No hardcoded secrets are present. The inherent security of the application depends on proper deployment and network configuration, which is outside the scope of the provided code.
Updated: 2025-12-05GitHub→
36
4
High Cost

cymbiont

by Brandtweary

Sec8

Augments AI assistants with a self-organizing knowledge graph for persistent memory and enhanced context retrieval across various domains.

Setup Requirements

  • ⚠️Requires an OpenAI API Key (Paid) for entity extraction and semantic search.
  • ⚠️Requires local installation and setup of the Neo4j graph database.
  • ⚠️The Python backend requires ~4GB of dependencies, including PyTorch with CUDA libraries, which can be resource-intensive.
Verified SafeView Analysis
Connects to a local Neo4j database and an external OpenAI API (requiring an API key). Integrates deeply with the Claude Code assistant, processing user input and output. Involves syncing local files from a corpus directory and running git post-commit hooks, which requires trust in the application's handling of local data and script execution.
Updated: 2025-11-18GitHub→
36
7
Medium Cost
VEEPAYONX icon

VEEPAY

by VEEPAYONX

Sec3

The system facilitates the creation, deployment, and management of self-evolving AI agents on the Solana blockchain for various Web3 automation and decision-making tasks, fostering a community-driven, decentralized ecosystem.

Setup Requirements

  • ⚠️Requires a complex multi-language development environment including Python, Rust (for Solana/Anchor), Go (for backend), and Node.js (for frontend/scripts), each with its own toolchains and package managers.
  • ⚠️Requires a Solana client (CLI) and a funded wallet to interact with the blockchain, incurring transaction fees (SOL) for deployment and agent operations.
  • ⚠️AI model training, especially for advanced models, may require access to high-performance computing resources like Google TPUs (as indicated by `ai/hardware_acceleration/tpu_training.py`) or powerful GPUs, adding significant infrastructure costs and setup complexity.
Review RequiredView Analysis
Multiple critical security risks were identified, primarily revolving around hardcoded secrets and overly permissive network configurations. Several Go backend files (`backend/api/middleware/auth.go`, `backend/api/handlers/user.go`, `backend/api/models/user.go`) contain hardcoded JWT secret keys (`your-secure-secret-key-here`, `your_secret_key`) that are used for authentication token generation and validation. The WebSocket server (`backend/websocket/server.go`) uses a hardcoded token (`valid-token`) for authentication and allows all origins (`CheckOrigin: func(r *http.Request) bool { return true }`), which is highly insecure for production. Similarly, the main Go API server (`backend/api/main.go`) has broad CORS enabled (`corsConfig.AllowAllOrigins = true`). The Python AI server (`ai/api/server.py`) also includes a hardcoded default JWT secret key if `SECRET_KEY` environment variable is not set. These issues make the system unsafe for deployment in a public or production environment without extensive remediation.
Updated: 2026-01-16GitHub→
36
6
High Cost
ralfbecher icon
Sec6

Analyzes relational database schemas, generates semantic ontologies (RDF/OWL, R2RML), and provides tools for Text-to-SQL convenience, secure query execution, and data visualization.

Setup Requirements

  • ⚠️Requires Python 3.13+.
  • ⚠️Requires external database connection details (PostgreSQL, Snowflake, or Dremio credentials in .env file or passed as parameters).
  • ⚠️The Dremio connection through the `connect_database` MCP tool (as defined in `src/main.py`) is misconfigured, attempting to use PostgreSQL wire protocol instead of the Dremio REST API client, which may prevent successful connection for Dremio users. Ensure the correct `connect_dremio` tool from `src/tools/connection.py` is registered if Dremio REST API functionality is desired.
Review RequiredView Analysis
Positive: Implements robust SQL injection and identifier validation, explicitly blocking DML/DDL operations. Utilizes SecureCredentialManager with Fernet encryption and secure salt management. Critical Risk: The DatabaseManager stores database connection passwords in plaintext within `self._last_connection_params` for reconnection purposes. Although a SecureCredentialManager is initialized, its encryption capabilities are not used to protect these stored credentials. This exposes sensitive information in memory, posing a significant risk if the server process memory is accessed or dumped.
Updated: 2026-01-11GitHub→
PreviousPage 124 of 760Next