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)

Low Cost

cli

by mcpize

Sec5

A command-line interface (CLI) tool designed for deploying, managing, and monetizing Model Context Protocol (MCP) servers in the cloud.

Setup Requirements

⚠️Requires Node.js v20.0.0 or higher to run the CLI itself.
⚠️Requires `mcpize login` for authentication to access most cloud features.
⚠️The `mcpize dev` command may require additional local tools like `tsx`, `uvicorn`, `watchdog.watchmedo`, or `php` CLI installed, depending on the project's runtime and chosen tunnel provider (`ngrok`, `cloudflared` need setup or auth tokens).

Verified SafeView Analysis

The CLI handles authentication securely, using browser-based OAuth with CSRF protection and refresh token rotation. Secrets management (mcpize secrets) is robust, supporting secure input methods and environment isolation. However, there are significant security and privacy implications to note: 1. The `mcpize analyze` command sends the entire local project directory (tarball) to a remote API (`/analyze-repository/tarball`) for manifest generation. This means your complete source code is transmitted to a third-party service, which can be a data privacy concern for proprietary or sensitive intellectual property. 2. The `mcpize init` command downloads project templates from `mcpize/templates` on GitHub. These templates can contain and execute `postInit` scripts, introducing a supply-chain risk. If the template repository were compromised, malicious code could be executed on the user's local machine. 3. The CLI frequently executes external commands (e.g., `npm`, `python`, `git`, `uvicorn`, `tsx`, `cloudflared`) based on user project configuration. While this is standard for a development tool and arguments appear to be handled with basic sanitation (e.g., quoting entry paths), users should be aware that the CLI trusts the scripts defined within their local projects. 4. A Supabase anonymous public key is hardcoded in `src/lib/config.ts`. This is typically designed for client-side access to public data and is not a secret in the traditional sense, but its purpose should be clearly understood.

Updated: 2026-01-18GitHub→

Medium Cost

politician-trading-data-assistant

by anguslin

Sec6

A chat application for users to query politician trading data, using an LLM to interpret queries, access data via the Model Context Protocol (MCP), and summarize findings.

Setup Requirements

⚠️Requires a Hugging Face API Key (`HF_API_KEY`), which is needed for LLM inference and may incur usage costs based on model and token consumption.
⚠️The frontend (`ui/app.js`) contains a hardcoded `API_KEY` that *must* be updated to match the backend's API_KEY and secured (e.g., via a proxy or GitHub Secrets) before any production deployment to prevent its public exposure.
⚠️The backend relies on the `@anguslin/mcp-capitol-trades` server being runnable as a Node.js child process within its environment, potentially requiring specific Node.js versions (>=18) and dependencies to be available for the spawned process.

Verified SafeView Analysis

The frontend (`ui/app.js`) hardcodes the `API_KEY` which will be publicly visible if deployed without modification, posing a significant security risk to that specific key. The backend implements several security measures including CORS restriction to allowed domains, API key validation via `x-api-key` header, and rate limiting. The `mcpService` spawns a child `node` process to run the `@anguslin/mcp-capitol-trades` server; while spawning child processes can be a risk, in this case, it's explicitly targeting a known internal dependency.

Updated: 2025-11-30GitHub→

Medium Cost

pilates-mcp-server

by Readify-App

Sec2

Provides Pilates studio information from a WordPress site to Claude Desktop, including search, details, and content management capabilities for multiple post types.

Setup Requirements

⚠️Requires Python 3.10+.
⚠️Requires Claude Desktop to be installed and running.
⚠️WordPress API credentials (username and application password) are hardcoded in `server.py` and need manual modification for custom WordPress instances, or for updating compromised credentials.
⚠️`uv` and `jq` are required for installation and are installed by the setup script, potentially requiring elevated privileges for `jq` on Linux (`sudo apt-get install jq`).

Review RequiredView Analysis

CRITICAL: WordPress API username and application password are hardcoded in plain text within `server.py`. This is a severe security risk, allowing anyone with access to the source code to gain full administrative access to the connected WordPress site. These credentials should be stored securely, ideally as environment variables. The installation process uses `curl | bash` which executes remote scripts directly and carries inherent risks of arbitrary code execution if the source is compromised. The server exposes several write operations (create/update posts, custom fields, taxonomies) using these hardcoded credentials, making it highly vulnerable if deployed insecurely.

Updated: 2025-12-07GitHub→

Low Cost

gothink-web

by rainmana

Sec7

Provides AI assistants with a structured Model Context Protocol (MCP) server offering systematic thinking tools, mental models, and debugging approaches for enhanced decision-making.

Setup Requirements

⚠️Requires Go 1.21+ and Git if building from source.
⚠️Data is stored in-memory and will be lost on server restart by default, as no persistent storage implementation is provided in the current code (despite `enable_persistence` config option).
⚠️Requires an MCP-compatible client (e.g., Claude Desktop) to interact with its services; it does not offer a standalone user interface.

Verified SafeView Analysis

The Go backend uses standard library and well-known third-party libraries for HTTP and MCP. Configuration is managed via environment variables or files, avoiding hardcoded secrets. HTTP server sets read/write timeouts to mitigate certain denial-of-service attacks. CORS is broadly enabled for all origins ('*'), which might be acceptable for an MCP client integration but means the server does not enforce origin-based access control. The `DEPLOYMENT.md` explicitly states there is 'no built-in authentication' for the HTTP endpoints, requiring external security measures (e.g., API keys, firewalls) for production use to secure access to its tool functions. No 'eval' or similar dangerous dynamic code execution patterns are observed.

Updated: 2025-11-26GitHub→

Low Cost

Docs-MCP

by matin-g

Sec7

A Model Context Protocol (MCP) server that provides semantic search over documentation sites.

Setup Requirements

⚠️Requires OpenAI API Key (Paid)
⚠️Python 3.10 or higher required
⚠️Manual configuration of the absolute project path in MCP client settings (e.g., Claude Code, Cursor)

Verified SafeView Analysis

The server makes external network calls to OpenAI for embeddings and to arbitrary URLs for documentation crawling. User-provided documentation URLs could potentially lead to unexpected content being fetched, though the process converts HTML to Markdown, mitigating direct execution risks. Requires careful management of the OpenAI API key.

Updated: 2025-11-17GitHub→

Medium Cost

bookstack-mcp

by lborjigi

Sec8

This server integrates BookStack documentation management with Cursor AI using the Model Context Protocol.

Setup Requirements

⚠️Requires a running BookStack instance with API access enabled.
⚠️Requires manual creation of a BookStack API Token (ID and Secret) with appropriate permissions.
⚠️Requires configuration of the BookStack URL (BS_URL) in the .env file, which may point to an internal IP address.

Verified SafeView Analysis

The server uses environment variables for API credentials, which is a good security practice. HTTP requests are made using the httpx library, and there are no direct command injection vulnerabilities detected in the parsing or execution paths. The `setup_env.sh` script is interactive, reducing the risk of shell injection through user input if not used maliciously. A potential risk is Server-Side Request Forgery (SSRF) if the `BS_URL` is configured to point to an internal network address controlled by an attacker, allowing them to probe internal services. However, this is a configuration-level risk rather than a vulnerability in the code itself, which adheres to standard security practices for Python applications interacting with APIs.

Updated: 2025-11-25GitHub→

High Cost

macbird

by richard-hajek

Sec4

Provides AI assistants with direct access to Thunderbird email accounts for management and interaction.

Setup Requirements

⚠️Requires `bun` runtime to be installed.
⚠️Thunderbird extension must be manually loaded as a 'temporary add-on' via developer tools, meaning it needs to be reloaded after each Thunderbird restart.
⚠️The client configuration requires an absolute path to the `server.ts` file.

Review RequiredView Analysis

The server explicitly warns about giving AI direct access to email, which is an inherent risk. A critical vulnerability exists in the `download_attachment` and `read_email_attachments` tools, where the `downloadPath` parameter is directly used to write files to the local filesystem without sufficient sanitization or validation. A malicious AI could instruct the server to write arbitrary files to sensitive system locations or overwrite user files, leading to remote code execution or data corruption. While the WebSocket server is local-only, this arbitrary file write capability makes it unsafe to use with untrusted AI.

Updated: 2025-11-25GitHub→

Medium Cost

mem0_mcp_private

by parthshr370

Sec7

The Mem0 MCP server provides a Model Context Protocol (MCP) interface for LLM agents to perform long-term memory operations like adding, searching, updating, and deleting memories via the Mem0 API.

Setup Requirements

⚠️Requires a Mem0 API Key (`MEM0_API_KEY`), which is for a paid service.
⚠️Requires Python 3.10 or higher.
⚠️The default server configuration disables DNS rebinding protection, which might be a security concern in certain deployment environments.

Verified SafeView Analysis

The server uses environment variables for API keys, which is a good practice. It also handles exceptions from the Mem0 API gracefully, returning structured error JSON. However, the `create_server` function explicitly disables DNS rebinding protection (`enable_dns_rebinding_protection=False`) for its transport security settings. While potentially justified for specific deployment scenarios (e.g., behind a reverse proxy), this is a deliberate weakening of a security feature that should be considered.

Updated: 2025-12-05GitHub→

Medium Cost

memes-mcp

by oshoura

Sec8

This MCP server enables users to find meme templates via text search and generate new meme images by overlaying custom text onto the templates, leveraging Google Gemini for meme annotation and Pinecone for vector search.

Setup Requirements

⚠️Requires Google Generative AI API Key (Paid) for the 'scraper/batch_annotate.py' script, which is necessary to populate meme metadata.
⚠️Requires Pinecone API Key, index, and namespace to be configured (Paid) for the meme search functionality.
⚠️Requires AWS S3 bucket, region, and credentials (Paid) for storing and serving meme images.
⚠️The scraper component ('scraper/scraper.py') depends on Selenium, meaning a Chrome browser and ChromeDriver (or compatible driver) must be installed and accessible on the machine where the scraper is executed.

Verified SafeView Analysis

API keys for Google Generative AI, Pinecone, and AWS S3 are loaded from environment variables, which is good practice. Input schemas for tool functions are validated using Zod, mitigating some input-related risks. Image processing uses the Jimp library for text overlay, a common and generally safe image manipulation tool. The scraper component, a prerequisite for generating the 'memes.json' data, utilizes Selenium and fetches external content from imgflip.com. While Selenium can introduce a larger attack surface if not properly isolated, it operates as an offline data preparation step and sanitizes filenames. There is a theoretical potential for Server-Side Request Forgery (SSRF) if the 'memes.json' file (which is generated by the trusted scraper) were maliciously altered to contain arbitrary 'image_url' values pointing to internal network resources; however, the server itself loads this file locally.

Updated: 2025-12-16GitHub→

Low Cost

pangea-mcp-server

by pangeacyber

Sec9

Integrates various Pangea security services as tools for AI agents via the Model Context Protocol (MCP).

Setup Requirements

⚠️Requires Node.js v24.11.0 or greater.
⚠️Requires a Pangea account and API tokens configured with access to AI Guard, Domain Intel, Embargo, IP Intel, Redact, Secure Audit Log, URL Intel, and Vault services. The primary token must be stored in Pangea Vault.
⚠️Requires a Pangea Secure Audit Log configuration with a 'Standard Audit Log Config' schema.
⚠️If Pangea AuthN is enabled (--authn flag), additional Pangea AuthN client setup is required in the Pangea console.

Verified SafeView Analysis

The server implements strong security practices by integrating Pangea's AI Guard for both pre-tool input and post-tool output validation and redaction, significantly reducing risks like prompt injection or data leakage. Sensitive Pangea API tokens are securely fetched from Pangea Vault at runtime, rather than being hardcoded or directly exposed as environment variables. OAuth client secrets for authentication are also stored in Vault. No 'eval' or similar dangerous code execution patterns were found. Network risks are managed through explicit HTTP transport with optional Pangea AuthN for access control. The hardcoded Pangea domain is a configuration, not a vulnerability. Overall, a well-secured application.

Updated: 2026-01-18GitHub→

Medium Cost

homelab-mcp

by myraffy

Sec6

Manage and monitor homelab infrastructure including Docker/Podman, Ollama AI, Pi-hole DNS, Unifi networks, Ansible inventory, and UPS systems through an MCP-compatible server.

Setup Requirements

⚠️Requires Ansible Inventory (`ansible_hosts.yml`) to be configured and mounted, OR individual environment variables for each service (Docker/Podman, Ollama, Pi-hole, Unifi, Ping, UPS).
⚠️Requires direct network access from the server to your homelab services (Docker/Podman API, Ollama API, Pi-hole API, Unifi Controller, NUT servers). In Docker, this often means `network_mode: host`.
⚠️API keys/passwords are required for many integrations (e.g., Pi-hole API, Unifi API, NUT authentication) and must be securely configured via environment variables or Ansible Vault.
⚠️Running the Ping MCP server in Docker containers requires granting the `NET_RAW` capability (`--cap-add=NET_RAW`).

Verified SafeView Analysis

The project demonstrates strong security awareness through comprehensive documentation (SECURITY.md, pre_publish_check.py) and a pre-push Git hook to prevent accidental exposure of sensitive data. It explicitly warns about the inherent security risks of some services (e.g., Docker/Podman APIs often using unencrypted HTTP without authentication) and provides mitigation strategies like firewall rules and TLS. However, some key services, such as the Unifi exporter, by default disable SSL verification for HTTPS connections (`verify_ssl=False`, `urllib3.disable_warnings`), which is a significant security vulnerability to Man-in-the-Middle attacks. Other integrations primarily use unencrypted HTTP, relying on network isolation for security. While risks are acknowledged and documented, the default insecure network settings for Unifi are a notable concern.

Updated: 2026-01-19GitHub→

Medium Cost

aria-mcp-server

by meetsandeepan

Sec8

The server acts as a Model Context Protocol (MCP) gateway to the ARIA Access API, enabling comprehensive management of healthcare data including patient demographics, appointments, billing, and radiation therapy.

Setup Requirements

⚠️Requires ARIA Access API credentials (base URL, client ID, client secret, username, password) to be configured via environment variables.
⚠️Requires Node.js version 18 or higher to run.
⚠️Relies on the `@modelcontextprotocol/sdk` for its server framework, implying interaction with an MCP client/orchestrator.

Verified SafeView Analysis

The server handles sensitive healthcare data and authenticates with an external ARIA Access API using credentials from environment variables. There are no obvious signs of 'eval' or malicious code patterns. Authentication tokens are managed with automatic refresh. The primary security consideration is ensuring the `ARIA_BASE_URL` points to a trusted ARIA instance and that all environment variables holding credentials are securely managed.

Updated: 2025-11-28GitHub→

PreviousPage 556 of 760Next