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
taihen icon

mcp-ripestat

by taihen

Sec5

A Model Context Protocol (MCP) server that enables Large Language Models (LLMs) to query the RIPEstat Data API for network information, IP addresses, prefixes, and ASNs using natural language.

Setup Requirements

  • ⚠️No built-in authentication/authorization; requires external security measures (e.g., firewall, MCPProxy).
  • ⚠️Requires Go 1.24.4+ and Make for building and running directly.
  • ⚠️Usage might be affected by RIPEstat API quotas, despite internal rate limiting.
Review RequiredView Analysis
The server explicitly states it does not provide authentication or authorization, recommending external firewalling or an MCP proxy for security. While it implements CORS with origin validation and secure client IP extraction, and includes per-instance rate limiting to manage RIPE API quotas, the lack of built-in access control makes direct public exposure a significant security risk. No 'eval' or malicious patterns were found in the provided source code, and development security practices like `govulncheck`, `Trivy`, and `CodeQL` are mentioned.
Updated: 2026-01-19GitHub→
0
0
Low Cost

ocs-mcp-server

by AILLY2025

Sec2

The OCS MCP Server acts as an API gateway for an OCS (Order Management System), providing tools for order review, order querying, and warehouse management to automate business processes.

Setup Requirements

  • ⚠️Requires Python 3.12+.
  • ⚠️Requires 'uv' package manager for dependency management.
  • ⚠️Requires various OCS API credentials (e.g., OCS_BASE_URL, OCS_ACCESS_TOKEN or OCS_USERNAME/OCS_PASSWORD) to be configured via environment variables for proper functionality.
Review RequiredView Analysis
CRITICAL: Hardcoded Docker registry credentials (`DOCKER_USERNAME`, `DOCKER_PWD`) are present in `build.sh`, posing a severe risk if the repository is public. Hardcoded `fallback_access_token`, `application_key`, default `username`/`password`, and cookie values are present in `config.py`. Disabling SSL/TLS certificate verification (`httpx.AsyncClient(verify=False)`, `aiohttp.ClientSession(ssl=False)`) in `services/ocs_service.py` and `services/auth_service.py` makes the application vulnerable to Man-in-the-Middle (MITM) attacks, especially in production environments.
Updated: 2025-11-27GitHub→
0
0
Low Cost
raalrwai icon

MCP

by raalrwai

Sec9

A minimal API server exposing simple tools for potential integration with AI agents or other applications.

Setup Requirements

  • ⚠️Requires the 'mcp' Python library to be installed.
Verified SafeView Analysis
The code itself is simple and does not contain obvious security vulnerabilities like eval, hardcoded secrets, or malicious patterns. The server binds to 0.0.0.0, which means it listens on all available network interfaces; this is standard but should be considered if deploying publicly without proper network segmentation.
Updated: 2025-12-10GitHub→
0
0
Medium Cost
nulone icon
Sec9

Provides AI assistants with persistent, feedback-learning memory to save insights, track feedback, and improve information retrieval.

Setup Requirements

  • ⚠️Requires Node.js 18+ to run.
  • ⚠️Requires Claude CLI or Claude Desktop for integration as an MCP server. Manual configuration of `claude.json` (or `claude_desktop_config.json`) with an absolute path to `dist/index.js` is necessary.
  • ⚠️While general operations (add, list, search) are efficient, retrieving full content for an insight (`get_detail`) or exporting all memory (`export_memory`) can return large amounts of text, potentially leading to higher token consumption by the AI client.
Verified SafeView Analysis
The server operates locally via standard I/O (stdio) and does not expose any network interfaces, significantly reducing external attack surface. It explicitly avoids `console.log` to prevent stdout pollution, which is critical for the MCP protocol. Robust input validation (`src/validation.ts`) prevents oversized or malformed data. Data integrity is prioritized with atomic file writes using a temp-file-and-rename pattern, mutex protection for concurrent access, and automatic recovery with backup generation for corrupted data files. No hardcoded secrets or 'eval' statements were found. The use of XDG Base Directory Specification for data storage is good practice.
Updated: 2026-01-19GitHub→
0
0
Low Cost
hackerdogs-ai icon

mcpservers-and-tools

by hackerdogs-ai

Sec3

A generic, plugin-based MCP server designed to automatically discover and expose reconnaissance tools, supporting both pure Python and command-line application wrappers.

Setup Requirements

  • ⚠️Requires `fastmcp` and `hd-logging` Python packages.
  • ⚠️Relies on system-installed command-line tools (e.g., `ping`, `nslookup`, `nmap` for examples) which must be available in the system's PATH.
  • ⚠️Requires Python 3.
  • ⚠️The `PYTHONPATH` environment variable must be correctly set to include the `mcpservers` directory for plugin discovery to work properly.
Review RequiredView Analysis
The `mcpservers/prowler/prowler_mcp.sh` script, which is part of the provided source, contains a hardcoded `PROWLER_APP_API_KEY`. This is a critical security vulnerability, as it exposes sensitive credentials directly in the source code. The `recon_mcpserver.py` component uses `subprocess.run` for external commands, which is implemented safely by passing arguments as a list. However, its dynamic plugin loading from the `recon/tools` directory means any code placed there will be executed, requiring strict trust and control over plugin sources to prevent arbitrary code execution.
Updated: 2026-01-17GitHub→
0
0
Low Cost
premkalyan icon
Sec1

Provides intelligent context, agent management, SDLC guidance, and tool configurations for AI-powered software development workflows, acting as an AI intelligence layer within the VISHKAR MCP ecosystem.

Setup Requirements

  • ⚠️Requires Node.js >=18.17.0.
  • ⚠️Requires API keys (VISHKAR_API_KEY, REGISTRY_UPDATE_TOKEN) obtained from Project Registry, potentially requiring separate project setup.
  • ⚠️Production deployment on Vercel requires Vercel Blob and KV setup for storage and caching.
  • ⚠️Multiple build troubleshooting steps noted in VERCEL-BUILD-TROUBLESHOOTING.md suggest potential deployment complexities.
Review RequiredView Analysis
CRITICAL: The system has multiple confirmed, severe vulnerabilities. 1. VULN-001 (CVSS 9.8 - Broken Authentication): Any API key is accepted, leading to complete authentication bypass. 2. VULN-002 (CVSS 9.1 - Path Traversal): Vulnerable to reading arbitrary files on the server (e.g., '/etc/passwd'). 3. VULN-003 (CVSS 9.8 - YAML RCE): Uses 'yaml.load()' which is susceptible to remote code execution. 4. Missing Rate Limiting (CVSS 7.5): No protection against Denial of Service (DoS) attacks despite being configured to enable it. These issues must be fixed immediately before any deployment or sensitive use.
Updated: 2025-12-15GitHub→
0
0
Low Cost
Sec8

Deploys a remote Model Context Protocol (MCP) server on Cloudflare Workers, allowing external clients to access custom AI tools without authentication.

Setup Requirements

  • ⚠️Requires a Cloudflare account for deployment.
  • ⚠️Requires Node.js and npm for local development and dependency management.
  • ⚠️The deployed server is explicitly 'authless', meaning it is publicly accessible and any custom tools added will be exposed without authentication.
Verified SafeView Analysis
The project creates an 'authless' MCP server, making it publicly accessible without credentials. While convenient for quick integration, users must be aware that any custom tools or logic added to this server will be exposed to anyone with the URL. As a Cloudflare template, the underlying code is expected to be free of direct 'eval' or malicious obfuscation, running within the sandboxed Workers environment.
Updated: 2025-11-17GitHub→
0
0
Medium Cost
elliemci icon

mcp-adk

by elliemci

Sec1

Develops and connects AI agents to interact with either a local SQLite database or a remote Notion workspace via the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires Python 3 and Google ADK library (`google.adk`).
  • ⚠️Local SQLite database must be created manually via `python3 local_mcp/create_db.py` before running the local agent/server.
  • ⚠️Notion API Key (NOTION_API_KEY) is required for the remote Notion agent setup.
  • ⚠️Running the remote Notion agent requires Node.js and npm/npx to install and run `@notionhq/notion-mcp-server`.
Review RequiredView Analysis
The `local_mcp/server.py` is highly vulnerable to SQL injection. The `get_table_schema`, `query_db_table`, and `delete_data` functions directly interpolate user-provided parameters (`table_name`, `columns`, `condition`) into SQL queries using f-strings without any sanitization or parameterized queries. An attacker could craft malicious input to execute arbitrary SQL commands, access unauthorized data, or delete records. This makes the local server unsafe to run with untrusted input. The `remote_mcp/agent.py` relies on an external `npx @notionhq/notion-mcp-server` command, introducing a dependency on a third-party package whose security is not directly auditable from this source code, though it's assumed to be official.
Updated: 2025-11-22GitHub→
0
0
Low Cost
OpenBankProject icon

OBP-MCP

by OpenBankProject

Sec9

Provides a Model Context Protocol (MCP) server for AI assistants to interact with the Open Bank Project (OBP) API.

Setup Requirements

  • ⚠️Requires Python 3.12+.
  • ⚠️Requires access to an OBP API instance (configured via OBP_BASE_URL and OBP_API_VERSION).
  • ⚠️The `uv` package manager must be installed to run scripts and the server.
  • ⚠️Endpoint and glossary indexes must be generated (`scripts/generate_endpoint_index.py`, `scripts/generate_glossary_index.py`) for full functionality, though `startup_updater.py` attempts to automate this on server start.
Verified SafeView Analysis
The codebase appears well-structured and free from obvious malicious patterns, 'eval' usage, or hardcoded secrets. It correctly uses environment variables for sensitive configurations like API base URLs and authentication details. OAuth is optionally configurable, adding to security. The use of `subprocess.run` to generate indexes is for internal scripts and uses `sys.executable` and `Path` objects, minimizing shell injection risks. Network requests are made to configurable OBP endpoints, assuming those endpoints are trusted. The primary security consideration is ensuring the `OBP_BASE_URL` points to a legitimate and trusted OBP API instance and that API keys/tokens used via headers are managed securely by the AI assistant accessing this MCP server.
Updated: 2026-01-14GitHub→
0
0
Medium Cost
mgerhards icon

mcp_docfetcher

by mgerhards

Sec4

Provides tools to programmatically fetch raw text content from any specified URL and perform site-specific searches on Google.

Setup Requirements

  • ⚠️Requires Python 3
  • ⚠️Requires installation of dependencies from requirements.txt (including 'requests' and 'mcp' libraries)
Review RequiredView Analysis
The 'fetch_docs' tool allows fetching arbitrary URLs, posing a Server-Side Request Forgery (SSRF) risk. This could enable an attacker to access internal network resources or cloud metadata services from the server's host. The 'search_docs' tool's HTML parsing for extracting URLs is brittle and sensitive to changes in Google's search page structure. There are no obvious hardcoded secrets or use of 'eval'.
Updated: 2025-12-03GitHub→
0
0
Medium Cost
haegemonia76 icon

mcp-servers

by haegemonia76

Sec2

A collection of Model Context Protocol (MCP) servers designed to provide controlled access and management capabilities for various infrastructure components like PostgreSQL databases, Redis caches, Docker containers, and Git repositories.

Setup Requirements

  • ⚠️Requires Node.js and pnpm package manager.
  • ⚠️Requires external PostgreSQL, Redis, and Docker daemon instances to be running and accessible for respective managers.
  • ⚠️High privileges: running these services grants significant control over associated infrastructure, posing security risks if not properly secured and monitored.
Review RequiredView Analysis
The 'postgres-manager-mcp' server's 'query' tool directly executes user-provided SQL strings without proper parameterization. The `PG_ALLOW_WRITE` environment variable and the `startsWith("select")` check are insufficient to prevent severe SQL injection vulnerabilities (e.g., `SELECT 1; DROP TABLE users;`). Additionally, the 'docker-manager-mcp' and 'git-manager-mcp' services expose highly privileged operations (container start/stop/restart, Git add/commit/push/pull) which, if used by an untrusted or malfunctioning agent, could lead to significant data loss or system compromise. All sensitive configurations (`DATABASE_URL`, `REDIS_URL`) are correctly sourced from environment variables, preventing hardcoded secrets.
Updated: 2025-12-03GitHub→
0
0
Medium Cost
taddiemason icon
Sec9

Enables AI agents (e.g., OpenWebUI) to access ConnectWise Manage data through natural language commands via a Docker-based Model Context Protocol (MCP) bridge.

Setup Requirements

  • ⚠️Requires Docker and Docker Compose installed.
  • ⚠️Requires ConnectWise Manage API credentials (Company ID, Public Key, Private Key), obtained from your ConnectWise instance.
  • ⚠️Requires OpenWebUI (or another MCP-compatible AI agent) to utilize its functionality, including manual tool configuration in OpenWebUI's admin panel.
Verified SafeView Analysis
The server is designed for read-only access, which inherently reduces the impact of potential security vulnerabilities. Secrets (ConnectWise API credentials) are correctly handled via environment variables loaded from a .env file, a standard best practice. There are no 'eval' or similar dangerous dynamic code execution patterns identified in the provided Node.js or Python code that would execute arbitrary user input. The Node.js bridge uses `child_process.spawn` to execute a Python script, passing JSON via stdin, which is a controlled and generally safe inter-process communication method. The `cors` middleware is enabled, allowing requests from all origins by default, which is acceptable for a local integration but might require stricter configuration in specific enterprise deployments. Overall, it appears well-engineered for its stated purpose with good security practices.
Updated: 2025-11-20GitHub→
PreviousPage 700 of 760Next