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(8554)

Medium Cost

n8n-mcp-server

by sergio2171

Sec9

Manages n8n workflows (list, get, create, update, delete, activate/deactivate) via a Model Context Protocol (MCP) server for Claude Desktop.

Setup Requirements

⚠️Requires Node.js 18+ and npm installed.
⚠️Requires a running n8n instance with a configured API Key.
⚠️Correct configuration of `N8N_API_URL` and `N8N_API_KEY` in a `.env` file is crucial, especially ensuring `N8N_API_URL` ends with `/api/v1/`.
⚠️The `cwd` for the MCP server in Claude Desktop's configuration (`claude_desktop_config.json`) must be an absolute path to the repository.

Verified SafeView Analysis

The server uses environment variables for sensitive API keys (`N8N_API_KEY`), preventing hardcoding. Input data is validated using Zod schemas (`src/validators.js`), which helps prevent common injection vulnerabilities. Error handling logs details without exposing raw stack traces directly in responses. Communication with Claude Desktop occurs over stdio, limiting external network attack surfaces. Axios is used for HTTP requests to the n8n API. Overall, good security practices are followed for its intended function.

Updated: 2025-12-05GitHub→

Medium Cost

AGAI09-MCP-Server

by ramsjenu

Sec8

An AI agent leveraging LangGraph and OpenAI to interact with external tools via the Model Context Protocol (MCP) using JSON-RPC over STDIO.

Setup Requirements

⚠️Requires OpenAI API Key (Paid)
⚠️Requires Serper API Key (Paid, free tier available for testing)
⚠️Requires graphviz system dependency for diagram generation (e.g., `brew install graphviz` on macOS)

Verified SafeView Analysis

The core server (`mcp_server.py`) does not exhibit immediate critical security flaws like `eval` or hardcoded secrets. It correctly loads API keys from environment variables and uses Pydantic for input validation. However, the `README.md` suggests using `eval(input.expression)` when demonstrating how to extend the system with a calculator tool. While this is in the documentation and not the deployed code, implementing such a suggestion without proper sanitization would introduce a severe security vulnerability (arbitrary code execution). External API calls (wttr.in, Serper API) are inherent to its function, with timeouts implemented.

Updated: 2025-11-20GitHub→

Low Cost

downdetector-mcp

by domdomegg

Sec8

Provides real-time service status and outage information by querying Downdetector across various regions for large language models.

Setup Requirements

⚠️Requires Node.js (>=18 for main dependencies, >=16 for compatibility as per manifest).
⚠️Relies on the external `downdetector-api` for data, which can be affected by Downdetector's website changes, rate-limiting (e.g., Cloudflare), or intermittent unavailability.
⚠️Requires a compatible Model Context Protocol (MCP) client environment (e.g., Claude Desktop, Cursor, Cline) for installation and interaction.

Verified SafeView Analysis

The server uses `zod` for robust input validation on `serviceName` and `domain` parameters before passing them to the `downdetector-api` library. There is no direct use of `eval` or user-controlled execution of shell commands found in the core server logic. No hardcoded secrets are present in the provided source code or configuration files. The primary external risk involves the `downdetector-api` npm package (whose source is not provided), and the inherent unreliability of web scraping due to potential Cloudflare blocks or changes in external website structure, which the server notes as a limitation.

Updated: 2026-01-14GitHub→

Low Cost

mcp-weather

by romeritomendes

Sec9

A Model Context Protocol (MCP) server for retrieving weather alerts and forecasts for US locations using the National Weather Service (NWS) API.

Setup Requirements

⚠️Requires Node.js 18+
⚠️Functions only for US locations via NWS API
⚠️Designed to run as an MCP server, typically orchestrated by a client like Cline (requires `cline_mcp_settings.json` configuration)

Verified SafeView Analysis

The server uses Zod for input validation, which effectively mitigates common injection risks for parameters. External API calls are made only to the official National Weather Service (NWS) API. No hardcoded secrets or sensitive API keys are found in the provided code. The server operates via stdio, limiting its direct external attack surface.

Updated: 2025-11-22GitHub→

Low Cost

mcp-fantastical

by aplaceforallmystuff

Sec6

Manages calendar events and schedules through the Fantastical app on macOS, enabling AI to interact with personal or work calendars.

Setup Requirements

⚠️Requires macOS (Fantastical is macOS-only).
⚠️Fantastical application must be installed.
⚠️Requires 'Accessibility permissions' for your terminal application or Claude Desktop to allow AppleScript interaction with other apps.
⚠️Node.js version 18+ is required.

Verified SafeView Analysis

The server uses `child_process.exec` to run `osascript` commands and `open` URL schemes. This interaction with local applications requires granting 'Accessibility permissions' to the terminal or Claude Desktop, which inherently provides the executing process with significant control over other applications. While the current implementation attempts to sanitize user inputs for URL schemes using `encodeURIComponent` and `URLSearchParams`, and uses mostly static AppleScripts for reading calendar data, a vulnerability could arise if untrusted input is improperly handled in future additions or if the server itself is compromised. The explicit requirement for high-level permissions on macOS makes this a higher-risk tool compared to isolated web services.

Updated: 2026-01-14GitHub→

Low Cost

dodaone-mcp-server

by fefogarcia

Sec8

Serve the DodaOne governance framework via an MCP-compatible API for informational queries and action evaluations.

Setup Requirements

⚠️Requires a GQS_API_KEY (API key for the DodaOne Governance Query Service), which may require registration or payment for the external service.

Verified SafeView Analysis

The server securely handles the GQS_API_KEY via environment variables and uses it in standard HTTP headers. Input validation is performed using Zod schemas. Network requests are made to a single, hardcoded external API endpoint. Error handling is present for network failures and non-OK responses from the external service. No 'eval' or other high-risk dynamic code execution patterns were found. The main security consideration is the trust in the external 'Governance Query Service' endpoint itself.

Updated: 2025-11-23GitHub→

Medium Cost

MCPServer_Demo

by matpadley

Sec8

A multi-language demonstration of Model Context Protocol (MCP) servers and clients for Todo management.

Setup Requirements

⚠️Requires a separate MCP server (.NET, TypeScript, or Go implementation) to be running concurrently for client functionality.
⚠️The Go server requires Go 1.21+ and CGO to be enabled for its SQLite driver.
⚠️The default TypeScript server implementation uses stdio transport and requires an HTTP adapter to be directly consumable by the React and ExtJS clients.
⚠️The ExtJS client explicitly uses Python 3's built-in HTTP server for local hosting (e.g., `python3 -m http.server 8080`).

Verified SafeView Analysis

The server implementations (Go, TypeScript) generally employ good practices like prepared statements for SQLite, mitigating SQL injection risks. The Go server explicitly enables permissive CORS (`Access-Control-Allow-Origin: *`), which is suitable for a demo but would require stricter configuration in a production environment to prevent cross-site request forgery (CSRF) or other attacks. The TypeScript server, by default, uses a stdio transport, limiting its direct network exposure. The ExtJS client dynamically generates HTML for button `onclick` attributes; while currently safe due to integer IDs, this pattern can be a cross-site scripting (XSS) risk if data is not properly sanitized. No hardcoded sensitive secrets were found.

Updated: 2026-01-07GitHub→

Low Cost

mcp-playwright

by sandeep-talware

Sec4

Automate browser actions programmatically via an MCP protocol server, primarily for LLM interaction.

Setup Requirements

⚠️Requires Node.js 16.x or higher.
⚠️Requires Playwright browsers to be installed (`npx playwright install chromium`).
⚠️The server must be running before any client can connect.

Review RequiredView Analysis

The server exposes capabilities that allow arbitrary JavaScript execution within the controlled browser context via the `playwright_evaluate` tool, and dynamic network request interception/modification via `playwright_route_request`. If exposed to untrusted clients or integrated with an LLM that might generate malicious code, this poses significant risks, including Cross-Site Scripting (XSS), data exfiltration, or browser exploitation. The included `Validator` primarily checks input structure and types, not the safety of the content. The `README` acknowledges these risks and warns against public exposure without authentication.

Updated: 2025-12-08GitHub→

Medium Cost

obsidian-mcp-server

by franklinchristuraj

Sec3

Enables AI assistants to programmatically interact with an Obsidian knowledge vault through the Model Context Protocol (MCP) via HTTPS, offering full read and write access.

Setup Requirements

⚠️Requires Obsidian Desktop application installed locally or remotely accessible.
⚠️Requires the Obsidian 'Local REST API' community plugin installed and configured (API key, port, vault path).
⚠️Requires careful configuration of multiple environment variables (`MCP_API_KEY`, `OBSIDIAN_API_URL`, `OBSIDIAN_API_KEY`, `OBSIDIAN_VAULT_PATH`).
⚠️The local Obsidian REST API connection uses `httpx.AsyncClient(verify=False)`, disabling SSL verification, which is a security risk if connecting over untrusted networks or public IPs. This should be addressed for production environments.

Review RequiredView Analysis

Critical security risks identified: 1. `httpx.AsyncClient(verify=False)` disables SSL certificate verification when connecting to the Obsidian REST API, making local connections vulnerable to Man-in-the-Middle attacks if not carefully controlled. 2. A publicly accessible API key (`798f67623306a6e2092542b9bdcf9775b44f5d4ae3193b1a2820b369e194047e`) for the remote production server is hardcoded in `test_remote_connection.py` and `EXTERNAL_CONNECTION_INFO.md`, a severe breach of security best practices as it exposes production credentials. 3. The simplified OAuth implementation for Claude.ai connectors uses the `MCP_API_KEY` as the `OAuth Client Secret` and returns it as an `access_token`, which significantly weakens OAuth security by using the main API key directly as an OAuth token. 4. The `execute_command` tool allows execution of arbitrary Obsidian commands, potentially leading to risks depending on the underlying Obsidian REST API plugin's safeguards. 5. The server can be configured to listen on `0.0.0.0` and authentication can be optionally disabled (`MCP_REQUIRE_AUTH=false`), posing risks if misconfigured without a robust reverse proxy and firewall protections.

Updated: 2025-11-21GitHub→

Medium Cost

MCP-server

by jaisoni138

Sec8

Provides a modular AI application backend using FastMCP for custom data retrieval, integrated with Ollama and Open WebUI for a conversational interface.

Setup Requirements

⚠️Docker and Docker Compose are required to run the full stack.
⚠️Ollama service is a core dependency and needs to be running.
⚠️A local 'data/data.txt' file is expected by the 'mcp-custom-server'.

Verified SafeView Analysis

No 'eval' or direct obfuscation found. Network risks are typical for containerized services. No hardcoded secrets in the provided code. Potential risks depend on the implementation of `client_ollama.py` (not provided) and the content/management of `data/data.txt`.

Updated: 2026-01-18GitHub→

Medium Cost

langextract

by haritha8503

Sec9

This Rust program uses Tree-sitter to parse source code files across multiple languages (e.g., TypeScript, Python, Rust, JavaScript, HTML, CSS, JSON, Markdown) and extract string literals, providing their value, line, and column.

Setup Requirements

⚠️Requires Rust toolchain (Rustup recommended).
⚠️Requires C/C++ build tools (e.g., `gcc` or `clang`) for compiling tree-sitter grammars.

Verified SafeView Analysis

The project is a local command-line interface (CLI) tool for source code analysis using the tree-sitter library. It processes local files based on user-provided paths and extracts string literals. No 'eval' or similar dangerous dynamic code execution patterns were found. There are no obvious network risks, hardcoded secrets, or malicious patterns. The 'unsafe' blocks are used for Foreign Function Interface (FFI) to load tree-sitter language grammars, which is standard practice for this library and considered justified for its intended use. Direct security risks are minimal for a standalone tool, as it primarily operates on local files provided by the user.

Updated: 2026-01-19GitHub→

High Cost

document-parser-mcp

by kgand

Sec9

Intelligent document parsing and conversion to clean Markdown for AI processing and RAG pipelines.

Setup Requirements

⚠️Requires Python 3.10 or higher.
⚠️8GB+ RAM recommended for optimal performance, especially with VLM/ASR pipelines.
⚠️Requires installation of the `docling` library and optional OCR engines (e.g., `easyocr`, `tesseract`) or MLX acceleration (`docling[mlx]`) based on desired features.

Verified SafeView Analysis

The server uses `httpx` for downloading remote files and incorporates measures like URL scheme validation (`allowed_schemes`), maximum file size limits (`max_file_size_mb`), and filename sanitization (`sanitize_filename`) to mitigate risks like SSRF or path traversal when handling external content. Communication with MCP clients occurs over standard I/O (stdio_server), which generally limits direct network attack surface. Reliance on external libraries like `docling` (and optional `easyocr`, `mlx`) introduces dependency-related security considerations that would require auditing of those upstream projects. No 'eval' or obvious hardcoded secrets were found.

Updated: 2025-12-11GitHub→

PreviousPage 693 of 713Next