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
Medium Cost
limaCoder icon
Sec9

The server provides a Model Context Protocol (MCP) interface to query and retrieve information from the Star Wars API (SWAPI), offering tools for searching characters, planets, films, and fetching detailed character data, as well as a resource to list all films.

Setup Requirements

  • ⚠️Requires a Node.js environment (v18 or higher recommended by dependencies) to install and run.
  • ⚠️Requires TypeScript to be installed and the project to be built (`npm run build`) before it can be executed.
  • ⚠️As an MCP server, it is designed to be interacted with via a compatible Model Context Protocol client or framework.
Verified SafeView Analysis
The code does not use `eval` or similar dangerous functions. There is no obfuscation. Network requests are made to a public, well-known API (SWAPI) via `axios`. No hardcoded secrets (API keys, sensitive URLs, credentials) are found; the SWAPI base URL is public. Input schemas for tools are validated using `zod`. Error handling appears robust, returning text content and marking errors without exposing raw stack traces directly, reducing information leakage. Overall, it follows good security practices for its stated purpose.
Updated: 2025-11-27GitHub→
0
0
Low Cost

PhiSHRI_MCP

by Stryk91

Sec4

Provides persistent context 'doors' (JSON bundles) to AI models, allowing them to resume work across sessions, maintain state, and access a structured knowledge base without re-explaining everything.

Setup Requirements

  • ⚠️The `PHISHRI_PATH` environment variable must be correctly set to the root directory of the knowledge base. If not found, the server will attempt to prompt the user via stderr, which can cause the server to hang or behave unpredictably in non-interactive (e.g., automated MCP) environments.
  • ⚠️The recommended installation method explicitly uses `Invoke-Expression` (iex) in PowerShell, which carries a severe security risk and should be approached with extreme caution, ideally by manually inspecting the script or avoiding this installation method entirely.
  • ⚠️The server is written in Rust, requiring the Rust toolchain if building from source, though pre-compiled binaries are available via the installer.
Review RequiredView Analysis
The Rust server code itself (`phishri-mcp`) appears to be a robust stdio-based application with no direct network listening, dynamic code execution (like `eval`), or hardcoded secrets. It primarily handles file I/O for its knowledge base and session data. However, the project's recommended 'Quick Install' command in the `README.md` uses PowerShell's `Invoke-Expression` (`iex`) on an external script (`install.ps1`). Executing `iex` on a remote script is a critical security vulnerability, allowing arbitrary code execution on the user's machine. This significantly lowers the overall safety rating for users following the recommended setup instructions.
Updated: 2025-11-25GitHub→
0
0
Medium Cost
Stig-Johnny icon
Sec9

Allows an AI agent to monitor Xcode Cloud build statuses and interact with Slack channels programmatically.

Setup Requirements

  • ⚠️Requires manual creation and configuration of a Slack App, including setting specific bot token scopes (e.g., `channels:history`, `chat:write`, `search:read`).
  • ⚠️The `SLACK_BOT_TOKEN` and `SLACK_BUILD_CHANNEL_ID` environment variables are mandatory for full functionality and must be obtained manually from Slack.
  • ⚠️The Slack bot needs to be explicitly invited to any private channels it intends to access or monitor messages from.
Verified SafeView Analysis
The server requires sensitive credentials (SLACK_BOT_TOKEN) to be provided via environment variables, which is good practice. It utilizes the official `@slack/web-api` library, reducing custom API interaction risks. Input validation for tool arguments is handled by Zod schemas through the MCP SDK. There is no evidence of `eval` or direct arbitrary command execution from user input. Error handling for missing Slack scopes is explicit, promoting secure configuration. Output message truncation (e.g., to 500 characters for text) helps prevent excessively large responses and implicitly limits potential data exposure, though this could be a minor data loss point for very long messages.
Updated: 2025-12-06GitHub→
0
0
High Cost
chieftecho icon

budgie

by chieftecho

Sec8

A Go-based MCP server that exposes specialized Kiro agents as sub-tools for complex task orchestration within the Kiro CLI ecosystem, with robust session management and Docker-based sandboxing.

Setup Requirements

  • ⚠️Docker is required for 'sandbox mode', which is highly recommended for security.
  • ⚠️The 'budgie-sandbox' Docker image must be pre-built: `docker build -t budgie-sandbox:latest .`
  • ⚠️Every sub-agent call (by the orchestrator) MUST include a 'directory' parameter, otherwise the call will fail.
  • ⚠️Every sub-agent JSON configuration MUST include 'fs_read' and 'fs_write' in its 'allowedTools' list for response file decoupling, which might seem counter-intuitive for agents that conceptually don't need file system access.
Verified SafeView Analysis
The server prioritizes security through its robust sandbox mode, running each sub-agent in an isolated Docker container. This provides filesystem isolation (only mounted working directory is RW), credential protection (host credentials like ~/.aws/ and ~/.ssh/ are explicitly not mounted, only kiro-cli auth is RO-mounted), and controlled execution. Each session uses a unique Docker volume for isolation and clean cleanup. The 'Mandatory directory parameter' forces explicit working directory control. However, the 'TODO' section explicitly notes the lack of a 'Prompt Sanitizer' to prevent prompt injection attacks, which is a significant acknowledged risk for a system orchestrating AI agents that can use powerful tools like 'execute_bash', 'fs_read', and 'web_fetch'. While the sandbox heavily mitigates the blast radius of such attacks, the prompt injection itself is not yet prevented at the input stage.
Updated: 2026-01-07GitHub→
0
0
Medium Cost
Yogeshknaik icon

jira-mcp-server

by Yogeshknaik

Sec8

Provides tools to interact with Jira, enabling programmatic execution of JQL queries, creation/editing/deletion of tickets, and management of Jira projects and statuses.

Setup Requirements

  • ⚠️Requires Jira URL, API email, and API key configured as environment variables (JIRA_URL, JIRA_API_MAIL, JIRA_API_KEY).
  • ⚠️Requires 'npm install' to install dependencies and 'npm run build' to compile the TypeScript code.
  • ⚠️Specifically designed for use with Claude Desktop, requiring configuration in 'claude_desktop_config.json'.
Verified SafeView Analysis
Uses environment variables for sensitive Jira credentials (URL, email, API key), which is a good practice. API calls are made via the 'axios' library. No 'eval' or direct command injection patterns are present. Input parameters are used directly in API calls or JQL queries; while the server itself doesn't introduce vulnerabilities, the client (LLM) must ensure JQL and other string inputs are safe to prevent potential JQL injection. Error responses may include raw API error data, potentially exposing internal details. Attachment uploads use 'X-Atlassian-Token: no-check', a Jira-specific header.
Updated: 2025-11-23GitHub→
0
0
Low Cost
Harsha-1705 icon

my-mcp-server

by Harsha-1705

Sec8

A multi-tool agent designed for web quality assurance, capable of scraping web pages, optimizing images, and creating Jira tickets for identified issues.

Setup Requirements

  • ⚠️Requires Playwright browser binaries to be installed (e.g., via 'playwright install' after pip installation).
  • ⚠️Real Jira ticket creation requires setting 'JIRA_URL', 'JIRA_EMAIL', and 'JIRA_TOKEN' environment variables.
  • ⚠️The 'create_jira_ticket' tool uses a hardcoded Jira project key ('WEB') which needs to be customized for your specific Jira instance.
Verified SafeView Analysis
The 'scrape_webpage' tool utilizes 'playwright' which launches a headless browser, interacting with potentially untrusted external web content. While 'playwright' offers sandboxing, this inherently introduces a larger attack surface compared to simple HTTP requests. However, this is necessary for its intended web scraping functionality. Sensitive Jira credentials ('JIRA_URL', 'JIRA_EMAIL', 'JIRA_TOKEN') are correctly sourced from environment variables, preventing hardcoding. No 'eval' or obvious malicious patterns are present.
Updated: 2026-01-19GitHub→
0
0
High Cost
sk3tch icon

glkvm-mcp

by sk3tch

Sec6

Control KVM devices (mouse, keyboard, screenshot, OCR) directly over HTTPS with mTLS for agent-driven GUI automation on remote computers.

Setup Requirements

  • ⚠️Requires Tesseract OCR (`tesseract-ocr`) and FFmpeg (`ffmpeg`) to be installed locally on the machine running the MCP server.
  • ⚠️The target KVM device must be running Linux with USB HID gadget support and `ustreamer` for video capture, which may require specific hardware and kernel configuration.
  • ⚠️Requires a multi-step, manual process for generating and managing mutual TLS (mTLS) certificates (CA, client, and per-KVM server certs), which is complex and prone to misconfiguration.
Verified SafeView Analysis
The KVM-side HID server, which facilitates direct control of the physical device, is designed to run with root privileges to access HID gadget devices (`/dev/hidg0`, `/dev/hidg1`). A compromise of this server would grant full root access to the controlled machine, representing a critical risk. While mutual TLS (mTLS) is implemented for secure communication and authentication, the setup involves manual certificate management across multiple machines, which is prone to human error. External dependencies like `ffmpeg` and `tesseract` introduce additional attack surfaces if those binaries contain vulnerabilities or if their invocation arguments could be manipulated (though current usage appears safe). The README itself highlights the 'terrifying' ease of building such a powerful tool.
Updated: 2025-12-05GitHub→
0
0
Medium Cost
zhangchark icon

jadx-mcp-server

by zhangchark

Sec8

This server acts as an MCP (Microservice Communication Protocol) proxy to a local JADX-AI-MCP Plugin, enabling programmatic interaction for Android reverse engineering tasks.

Setup Requirements

  • ⚠️Requires a JADX-AI-MCP Plugin instance running locally on a specified port (default 8650).
  • ⚠️Requires Python 3.10 or newer.
  • ⚠️Requires `fastmcp` and `httpx` Python packages to be installed.
Verified SafeView Analysis
The server connects to a JADX-AI-MCP Plugin instance that is hardcoded to run on `127.0.0.1` (localhost). This design significantly limits the direct network attack surface of the sensitive reverse engineering data it exposes. The code itself does not contain obvious malicious patterns, 'eval' usage, or hardcoded secrets. Error handling for network requests is present. The primary security risk would arise if the MCP server itself is exposed publicly without robust authentication or access controls, which is not the intended or default deployment.
Updated: 2025-11-24GitHub→
0
0
Low Cost
hawkymisc icon
Sec7

Integrate Stable Diffusion image generation models with LLMs (like Claude) via the Model Context Protocol, enabling natural language control for image generation.

Setup Requirements

  • ⚠️Requires Python 3.10 or higher.
  • ⚠️Requires a CUDA-enabled GPU (NVIDIA), Apple Silicon (MPS), or falls back to CPU (performance significantly impacted).
  • ⚠️Large Stable Diffusion models (e.g., SD3.5-large-turbo) require substantial RAM/VRAM (32GB+ RAM, 48GB+ recommended for WSL with large models).
  • ⚠️Dependencies include fastmcp, diffusers, transformers, torch, pillow, accelerate, and psutil.
Verified SafeView Analysis
The server can operate in SSE (HTTP) mode, which exposes it to the network. While FastMCP provides a framework for secure interactions, the server itself does not implement explicit authentication or authorization mechanisms, relying on the client (LLM Host) for access control. Careful deployment in a controlled network environment (e.g., localhost, behind a firewall, or with a secure proxy) is recommended if using SSE. Input validation for image sizes and other parameters is in place, and file path handling appears robust, mitigating common injection and path traversal risks. No 'eval' or hardcoded secrets were found.
Updated: 2025-12-13GitHub→
0
0
Low Cost
dontpanicw icon

go-devops-mcp

by dontpanicw

Sec10

A Micro-Capability Platform (MCP) server designed to optimize routine DevOps tasks for backend developers and other users through a standardized tool interface.

Setup Requirements

  • ⚠️Requires Go runtime and dependencies (`github.com/mark3labs/mcp-go`).
  • ⚠️Designed to communicate via standard I/O (stdin/stdout), typically requiring integration with a parent process or system.
Verified SafeView Analysis
The provided source code does not contain any obvious security vulnerabilities such as hardcoded credentials, 'eval' equivalent, or direct arbitrary command execution. The server communicates via standard I/O (ServeStdio), which limits direct network exposure. Tools are added with defined parameters, suggesting a controlled execution environment. Further security would depend on the `mcp-go` library itself and any additional tools implemented in the `internal/tools` directory not provided.
Updated: 2025-11-24GitHub→
0
0
Low Cost

game-analytics-mcp-server

by jussikolehmainen

Sec7

A server for collecting and processing analytics data from a game, likely a multiplayer or Minecraft-related application.

Setup Requirements

  • ⚠️Requires Node.js runtime and a package manager (npm or yarn).
  • ⚠️Database configuration required for data persistence (type unspecified).
Verified SafeView Analysis
Cannot fully assess without code content. As a server application, it inherently exposes network endpoints. Security depends on proper input validation, authentication, and authorization mechanisms, which are unknown. No obvious 'eval' or obfuscation detected from file names.
Updated: 2025-11-18GitHub→
0
0
Low Cost
mordang7 icon

ContextKeep

by mordang7

Sec4

Provides a standalone, persistent, and searchable long-term memory server for AI agents and tools, compatible with the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires Python 3.10 or higher.
  • ⚠️Manual copying of the generated `mcp_config.json` content into the AI client's configuration is necessary.
  • ⚠️The WebUI runs with Flask `debug=True` by default when started manually, which is a significant security risk for a network-accessible server.
Review RequiredView Analysis
The `webui.py` Flask application is configured with `debug=True` when run directly (e.g., `python webui.py`). Running a Flask application in debug mode in a production or network-accessible environment is a critical security vulnerability, as it can expose sensitive information and allow arbitrary code execution. Both the MCP server and WebUI bind to `0.0.0.0` by default, making them accessible from any network interface without explicit authentication. Data is stored locally in plain JSON files.
Updated: 2025-12-12GitHub→
PreviousPage 347 of 760Next