Stop Searching. Start Trusting.

The curated directory of MCP servers, vetted for security, efficiency, and quality.

Browse Directory Why 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)

Medium Cost

csharp-lsp-mcp

by HYMMA

Sec9

An MCP server that provides C# and XAML language intelligence by integrating with `csharp-ls` and built-in XAML analysis for AI assistants like Claude.

Setup Requirements

⚠️Requires .NET 8.0 SDK or later to be installed.
⚠️Requires `csharp-ls` (the C# Language Server) to be installed globally via `dotnet tool install --global csharp-ls`.
⚠️Requires explicit configuration in Claude's `mcpServers` settings (e.g., `~/.claude.json` or `claude_desktop_config.json`).
⚠️The `csharp_set_workspace` tool must be called first to initialize the workspace before using other C# tools.

Verified SafeView Analysis

The server primarily operates over standard I/O (stdio) for both MCP and LSP, limiting direct network exposure. It acts as an adapter between the AI assistant and the external `csharp-ls` language server. No 'eval', obfuscation, or hardcoded secrets are apparent in the provided source. Security relies heavily on the trustworthiness of the `csharp-ls` dependency.

Updated: 2026-01-02GitHub→

Low Cost

mcp-explorer

by monok8i

Sec1

A web application for testing and exploring Model Context Protocol (MCP) servers by acting as an API gateway for tool execution.

Setup Requirements

⚠️Requires Docker for easy setup of both frontend and backend services.
⚠️Python 3.13 or newer is required for the backend components.
⚠️The core functionality relies on connecting to external MCP servers, meaning you will need an existing MCP server (like the provided 'test-server' example) to interact with.

Review RequiredView Analysis

CRITICAL SECURITY RISK: The `POST /mcp/stdio/connect` endpoint allows users to specify arbitrary `command`, `args`, and `env` parameters, which are directly used to spawn subprocesses on the backend server. This design choice enables Remote Code Execution (RCE) by anyone who can access the API. There is no authentication or authorization layer to restrict who can initiate these connections. Furthermore, the `CORSMiddleware` is configured with `allow_origins=['*']`, which is a significant security vulnerability in a production environment as it allows cross-origin requests from any source, potentially facilitating CSRF and other attacks. The entire application is unsafe to run if the backend API is exposed to untrusted networks or users. It should only be used in a highly controlled and isolated development environment.

Updated: 2026-01-13GitHub→

Medium Cost

opsorch-mcp

by OpsOrch

Sec9

The opsorch-mcp server acts as a Model Context Protocol (MCP) adapter, exposing read-only OpsOrch Core HTTP APIs as safe tools for Large Language Models (LLMs) and agent runtimes to query operational data.

Setup Requirements

⚠️Requires a separate, running OpsOrch Core instance to fetch data from.
⚠️The `OPSORCH_CORE_TOKEN` environment variable is critical for authentication with OpsOrch Core and should be set to a strong, non-default value in production environments.
⚠️Requires a Node.js runtime environment (version 18 or higher recommended) for local execution, or Docker for containerized deployment.

Verified SafeView Analysis

The server's core functionality is explicitly read-only, which significantly reduces the attack surface for data manipulation. It uses environment variables for sensitive configurations like `OPSORCH_CORE_URL` and `OPSORCH_CORE_TOKEN`, which is a good practice. The HTTP transport includes configurable CORS (`MCP_HTTP_ALLOW_ORIGINS`) and Host header allow-lists (`MCP_HTTP_ALLOW_HOSTS`), enhancing network security for remote clients. Input validation is performed using `zod` schemas before making calls to the OpsOrch Core. There are no direct uses of `eval` or similar dangerous functions. The default `OPSORCH_CORE_TOKEN='demo'` for local development is a minor concern if not changed for production but is clearly documented. Overall, the code appears robust against common web vulnerabilities, relying on the security of the underlying 'OpsOrch Core' for data integrity.

Updated: 2026-01-08GitHub→

Medium Cost

clix-mcp-server

by clix-so

Sec8

Enables AI agents to search Clix documentation and SDKs for code examples and information via the Model Context Protocol.

Setup Requirements

⚠️Node.js 18+ required
⚠️Requires an MCP-compatible client for integration (e.g., VS Code extension, Claude Code CLI, Codex CLI)
⚠️Network access is mandatory for core functionality (fetching external documentation/SDK data)

Verified SafeView Analysis

The server requires network access to external Clix services for its core functionality (fetching documentation and SDK data), which inherently involves external dependencies and network calls. Installation via `npx -y` runs code directly from npm, carrying standard supply chain risks. No explicit 'eval' or obfuscation was found in the provided information.

Updated: 2025-11-17GitHub→

High Cost

snippy

by Azure-Samples

Sec9

An AI-powered code snippet manager that integrates with GitHub Copilot via MCP, provides vector search for code, and uses AI agents for documentation and style guide generation.

Setup Requirements

⚠️Requires an Azure Subscription (paid resources will be deployed).
⚠️Requires a GitHub Account with Copilot subscription for full feature utilization.
⚠️Docker Desktop is required for local development to run the Durable Task Scheduler emulator and Azurite.

Verified SafeView Analysis

The project uses robust security practices including Azure User-Assigned Managed Identity for service-to-service authentication (eliminating hardcoded API keys in production), Azure Function App keys for HTTP endpoints, and Azure AD App Registration for Model Context Protocol (MCP) access. While HTTP endpoints are exposed, the project explicitly recommends further hardening with Private Endpoints and a thorough security review before production deployment. No 'eval' or obvious obfuscation was found in the provided code snippets.

Updated: 2025-12-18GitHub→

Medium Cost

docs-mcp-server

by pankaj28843

Sec8

A Model Context Protocol (MCP) server that provides AI assistants with access to documentation sources through a unified search API.

Setup Requirements

⚠️Requires `uv` (Rust-based Python package manager) for dependency management and execution.
⚠️Requires Python 3.10+.
⚠️Web crawling features leverage Playwright, which requires browser binaries (Chromium, Firefox, or WebKit) to be available in the execution environment, potentially increasing image size or setup complexity.
⚠️Optimal search performance benefits from `ripgrep` (rg) being installed, though it has a fallback to `Path.rglob`.

Verified SafeView Analysis

The server uses `subprocess.run` for external tools like `ripgrep` and `docker`, and for internal scripts like `index_audit`. While these are part of the intended functionality and generally handled carefully (e.g., arguments constructed from `Path` objects to prevent shell injection), they expand the attack surface if dependencies are compromised or user-supplied paths are not adequately sanitized. Network operations for crawling, Git syncing, and optional external article extraction introduce risks related to untrusted content sources and external service dependencies. Secrets (e.g., Git authentication tokens, fallback extractor API keys) are configured to be loaded from environment variables, which is a good practice. SQL queries in `sqlite_storage.py` and `segment_search_index.py` appear to be parameterized, mitigating SQL injection risks. Overall, the project demonstrates an awareness of security best practices, but reliance on external configurable services requires diligent user configuration and trust.

Updated: 2026-01-18GitHub→

Low Cost

pinax-mcp

by pinax-network

Sec9

Connects MCP-compatible clients (e.g., Claude Desktop) to remote MCP servers, specifically The Graph Token API, by acting as a bridge between stdio and HTTP/SSE transports.

Setup Requirements

⚠️Requires a JWT Access Token, which must be obtained by creating an account and generating a key on thegraph.market.
⚠️Requires a `REMOTE_URL` specifying the target MCP server endpoint.
⚠️Intended for use with an existing MCP client (e.g., Claude Desktop, Cline) that supports stdio transport for communication.

Verified SafeView Analysis

The client functions as a transparent bridge, forwarding JSON-RPC requests from stdio to a remote server. There is no indication of local code execution vulnerabilities (e.g., `eval`, `child_process`) from incoming messages. The primary security considerations are the integrity of the remote MCP server and the secure handling of the `ACCESS_TOKEN`, which authenticates requests to the external service. The client uses `z.any()` for request payloads, meaning it relies on the remote server for request parameter validation.

Updated: 2025-11-20GitHub→

Low Cost

llm-tools

by samestrin

Sec9

Provides high-performance filesystem operations (file management, editing, search, archiving) as an MCP server for AI agents like Claude Code, acting as the agent's 'hands' for codebase interaction.

Setup Requirements

⚠️Requires Go 1.21+ if installing from source.
⚠️Requires explicit configuration of `--allowed-dirs` for security and functionality.
⚠️Requires proper `claude_desktop_config.json` setup, ensuring the correct binary path is configured.

Verified SafeView Analysis

The server explicitly validates all paths against configured allowed directories to prevent path traversal attacks. It also resolves and validates symlinks, and detects/handles binary files appropriately. Built in Go, it leverages type safety and avoids dangerous patterns like 'eval'. Relies on secure argument passing to underlying CLI binaries. API keys for LLM integration (in other tools of the suite) are expected via environment variables, not hardcoded.

Updated: 2026-01-18GitHub→

Low Cost

x402-mcp-server

by serenorg

Sec7

Enables AI agents to pay for x402-protected database queries and API calls using USDC on the Base blockchain.

Setup Requirements

⚠️Requires Node.js and npm (or pnpm) to run.
⚠️The default setup relies on the `WALLET_PRIVATE_KEY` environment variable for `PrivateKeyWalletProvider`, which is suitable for development and testing but not recommended for production due to inherent security risks.
⚠️The `WalletConnectProvider` is mentioned but requires additional setup and `WALLETCONNECT_PROJECT_ID`.

Verified SafeView Analysis

The server uses environment variables (`WALLET_PRIVATE_KEY`, `WALLETCONNECT_PROJECT_ID`) for sensitive configurations, which is good practice to avoid hardcoding. However, the default and recommended setup in the `src/index.ts` uses `PrivateKeyWalletProvider`, which explicitly states it's 'NOT recommended for production' due to its reliance on a private key directly in environment variables. While it's suitable for development, this introduces a significant security risk if used carelessly in a production environment. Input validation for `sql` queries is basic (`startsWith('SELECT')`), delegating full SQL injection protection to the upstream x402 gateway. The server's core function involves EIP-712 signing, which relies on the security of the `viem` library and the provided private key/WalletConnect setup.

Updated: 2025-12-11GitHub→

Medium Cost

jolokia-mcp-server

by jolokia

Sec6

Enables an LLM to manage a Java application by providing a bridge to JMX API via Jolokia.

Setup Requirements

⚠️Requires a running Java application with a Jolokia agent attached (for Standalone mode) or configured as a JVM agent itself.
⚠️Requires careful configuration of JMX security (authentication, authorization) on the target Java application/Jolokia agent, as this MCP server does not implement its own security layer for JMX access.
⚠️The JVM Agent distribution opens an HTTP port directly in the target Java application, potentially exposing JMX capabilities if network access is not restricted.

Review RequiredView Analysis

The server's core function is to expose powerful JMX operations (read/write attributes, execute operations) to an LLM. While the server's code itself does not contain 'eval' or malicious patterns, these JMX operations can lead to significant runtime modification or arbitrary code execution in the target Java application if the underlying Jolokia agent and JMX are not rigorously secured with authentication, authorization, and network access controls. The server acts as a direct proxy for these capabilities, and its safety is entirely dependent on the security configuration of the managed Java application, which is external to this server.

Updated: 2026-01-05GitHub→

Low Cost

mwilliams_mcpbridge

by mahawi1992

Sec4

Optimizes AI agent context usage by providing a single, intelligent interface for multiple Model Context Protocol (MCP) servers with lazy schema loading and result compaction.

Setup Requirements

⚠️Requires manual creation and configuration of `mcpbridge.config.json` with potentially sensitive credentials for underlying MCP servers.
⚠️Requires Node.js version 18.0.0 or higher.
⚠️Relies on `npx` to dynamically download and execute underlying MCP server packages, which can be a point of friction or security concern in some environments.

Review RequiredView Analysis

The server's core function involves spawning child processes configured in `mcpbridge.config.json` using arbitrary `command` and `args`. This design, while necessary for its operation, introduces significant security risks: 1. **Arbitrary Command Execution**: If an attacker gains control over `mcpbridge.config.json`, they could configure the bridge to execute arbitrary commands on the host system where it runs. 2. **Supply Chain Risk**: The example configuration uses `npx -y @some/mcp-server@latest`, which automatically downloads and executes packages from npm. This can introduce vulnerabilities if a specified package is compromised or if an untrusted source influences which package is configured. 3. **No New Tool Input Validation**: The bridge acts as a proxy, passing arguments directly to the child MCP server tools. It does not add an additional layer of input validation beyond what the child tools or the MCP SDK provide. Therefore, vulnerabilities in underlying MCP servers (e.g., SQL injection, arbitrary file access) could still be exploited through the bridge. 4. **Sensitive Information in Config**: `mcpbridge.config.json` can contain sensitive API keys and secrets. Improper handling or exposure of this file is a major security concern. The project explicitly warns against committing real credentials. The server itself does not use `eval` or dynamic code execution based on AI input within its own code. The primary risks stem from the powerful capabilities granted by its configuration and the privileges required to run child processes.

Updated: 2025-12-11GitHub→

High Cost

drilling_mcp_server

by ridhadev

Sec7

Analyzes oil and gas drilling data from CSV files, providing tools for Rate of Penetration (ROP), Mechanical Specific Energy (MSE), Non-Productive Time (NPT) calculations, and data visualization via an MCP server.

Setup Requirements

⚠️Requires drilling data CSV files (e.g., `well_name time.csv`, `well_name depth.csv`) to be placed in `data/drilling/` or a custom directory specified by the `DRILLING_DATA_DIR` environment variable.
⚠️Requires an Anthropic API Key (`ANTHROPIC_API_KEY`) for `mcp_chatbot.py` to interact with Claude.
⚠️The `mcp_chatbot.py` client expects the drilling server to run on `stdio` transport, but `drilling_mcp_server.py` currently runs on `sse` (port 10000) when executed directly. For them to communicate, either the server's `mcp.run()` call needs to be changed to `stdio` or the client's connection type needs to be updated.
⚠️The `mcp_chatbot.py` script needs its `SERVER_CONFIG_PATH` variable updated to point to the local `server_config.json` (or a copy like `_server_config_local_.json`), and `command`/`args` paths within that config might need local adjustment to ensure correct script execution paths.

Verified SafeView Analysis

The server allows saving filtered data to a user-specified output file path (`filter_data` tool), which, without explicit path sanitization or restriction, could potentially be exploited for arbitrary file writes (e.g., path traversal) if exposed to untrusted inputs. However, it's described as a mockup MCP server typically run in a local or trusted environment, mitigating the immediate severity. Input custom files are checked for size limits, which is good.

Updated: 2025-11-22GitHub→

PreviousPage 204 of 760Next