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)

High Cost

nexus-mcp

by rcdelacruz

Sec9

Provides a local Model Context Protocol (MCP) server for AI agents, enabling hybrid web search and intelligent, token-efficient content retrieval from articles and documentation.

Setup Requirements

⚠️Requires Python 3.10+
⚠️If using uvx for installation, 'uv' must be pre-installed separately.
⚠️Local development setup for Claude Desktop/Cursor requires providing absolute paths to the Python interpreter and server script in the JSON configuration.

Verified SafeView Analysis

The server's core functionality involves making external network requests to arbitrary URLs provided by the user/LLM via DuckDuckGo and httpx. This is inherent to its purpose. Input validation is performed for queries, modes, and URL formats (checking for 'http://' or 'https://' prefixes). Timeouts are implemented for both search and HTTP requests, preventing hanging operations. HTML content is pre-cleaned by removing common junk tags (scripts, styles, navs, footers, iframes) before processing. There are no obvious hardcoded secrets, 'eval' usage, or other directly malicious patterns identified in the provided source code.

Updated: 2025-12-15GitHub→

Medium Cost

Context-Aware-MCP-Framework

by Research-Anonymous-25

Sec8

This repository demonstrates the Context-Aware Model Context Protocol (MCP) for multi-agent coordination, comparing it against traditional stateless MCP for complex planning tasks.

Setup Requirements

⚠️Requires OpenAI API Key (Paid Service)
⚠️Python 3.10+ required
⚠️Requires installation of multiple Python dependencies (e.g., fastmcp, openai, datasets, evaluate, matplotlib)

Verified SafeView Analysis

Interacts with OpenAI API, sending task context and prompts to a third-party LLM service. Standard data privacy considerations for external API usage apply. No obvious malicious code patterns, obfuscation, or arbitrary code execution ('eval') detected within the provided README.

Updated: 2025-11-17GitHub→

Medium Cost

remote_mcp

by AuraFriday

Sec2

Provides infrastructure for external applications to register as AI-controllable tools with an MCP server via reverse connections.

Setup Requirements

⚠️Requires the 'Aura Friday MCP-Link Server' to be running as this project provides client-side implementations and a server-side component, not a standalone server.
⚠️Different language implementations (Go, Java, Kotlin, C++) require specific compilers/SDKs and build steps, increasing setup friction.
⚠️The Perl version specifically requires additional CPAN modules (`JSON`, `LWP::UserAgent`, `HTTP::Request`, `File::HomeDir`, `IO::Socket::SSL`).

Review RequiredView Analysis

CRITICAL: Hardcoded `TEST_TOKEN = "e5076d"` (and similar `29e63eb5` for SQLite unlock) in `remote.py` and across multiple language demos. This token is used to bypass "security checks" for tool usage, making the entire system fundamentally insecure for production use as anyone knowing this token can call registered tools. CRITICAL: Use of `eval(code)` in the JavaScript (`reverse_mcp.js`) `evaluate_js` action. This allows arbitrary code execution via untrusted input, a severe Remote Code Execution (RCE) vulnerability. CRITICAL: SSL/TLS certificate verification is explicitly disabled (`rejectUnauthorized: false`, `InsecureSkipVerify: true`, `context.verify_mode = ssl.CERT_NONE`) in all language implementations for local communication. While intended for self-signed certificates in a local environment, this is a dangerous practice as it makes the system vulnerable to Man-in-the-Middle (MitM) attacks if exposed beyond a trusted local network. MEDIUM: The system allows external tools to `call OTHER MCP tools` (e.g., `sqlite`, `browser`, `user`). A compromised or malicious remote tool could exploit this to perform unauthorized actions via other integrated MCP tools. LOW: The custom JSON parsing in Kotlin (`reverse_mcp.kt`) is flagged as a "simplified parser for the demo" and recommends using a robust library for production, implying potential vulnerabilities if not properly handled.

Updated: 2025-12-02GitHub→

Medium Cost

MCP-servers

by mahdi-islam-pranto

Sec4

Provides an AI-powered expense tracking system with a chatbot interface, allowing users to add, list, and summarize expenses, and access predefined spending categories.

Setup Requirements

⚠️Requires Python 3.13 or newer due to `pyproject.toml` specification.
⚠️Requires proper configuration of API keys (Gemini, RapidAPI) as environment variables; currently hardcoded in `chatbot_backend.py`.
⚠️The user interface is built with Streamlit (`chatbot_frontend.py`), which needs to be run separately from the FastMCP server component.

Review RequiredView Analysis

The `chatbot_backend.py` file contains hardcoded API keys for `ChatGoogleGenerativeAI` and a `RapidAPI` jobs API. This is a critical security vulnerability, as these keys are exposed in the source code and can be easily misused. These should be loaded from environment variables. Database operations use parameterized queries, mitigating SQL injection risks. The remote database uses a temporary directory, which can have permission issues depending on the environment.

Updated: 2025-11-27GitHub→

Medium Cost

xhs-mcp-server

by IChouChiang

Sec6

A full-stack AI Agent system for automating social media tasks, specifically Xiaohongshu (XHS). It provides a Canva-like visual editor and an AI Assistant chat box to design, modify, and publish posts across various platforms.

Setup Requirements

⚠️MCP Bridge Path Configuration (CRITICAL): The path to the `mcp-server-stdio.js` Node.js bridge is hardcoded to a Windows-specific path in `backend/agent_server.py` and `backend/agent_chrome.py`. Users MUST manually update this path to their local installation, which varies by OS (Windows/Mac/Linux) and npm global package location.
⚠️API Keys & Authentication: Requires `auth.json` (cookies for Xiaohongshu login) and `searcher_api.txt` (DeepSeek/OpenAI API key) to be manually created in the `backend/` directory. Exporting cookies from a browser can be a manual and sometimes fiddly process.
⚠️Python Environment Dependencies: Requires specific Python packages (`langchain`, `langgraph`, `mcp`, `fastapi`, `uvicorn`, `requests`) which must be installed in a suitable Python environment (e.g., `conda` or `venv`). The `mcp` library itself might have platform-specific build requirements.

Verified SafeView Analysis

The system heavily relies on browser automation and script injection via the MCP (Model Context Protocol) bridge. This inherently involves high privileges and potential risks if not configured securely. Key concerns include: 1. Hardcoded MCP Bridge Path: The path to `mcp-server-stdio.js` is hardcoded in Python scripts, requiring manual adjustment by the user. An incorrect or malicious path could lead to arbitrary code execution in the controlled browser. 2. Session Injection: `auth.json` (containing browser cookies and localStorage) is injected into the browser. If this file is compromised or contains malicious scripts, it could lead to XSS-like vulnerabilities in the controlled browser. 3. Script Injection Tools: Functions like `inject_session` and `extract_images_from_page` explicitly inject JavaScript into the browser. While these seem controlled internally, any vulnerability in how user inputs are handled by these injection points could be exploited. Overall, the system's power to control a browser requires strict adherence to security best practices during setup and operation. The reliance on local configuration files (`auth.json`, `searcher_api.txt`) that are not committed to source control is a good practice.

Updated: 2025-11-30GitHub→

Medium Cost

laravel-mcp-server

by xentixar

Sec1

A Laravel-based server application, likely for managing or serving data related to a specific domain (e.g., Minecraft).

Setup Requirements

⚠️Requires PHP (version specified in composer.json, typically 8.1+)
⚠️Requires Composer for dependency management
⚠️Requires a database (e.g., MySQL, PostgreSQL, SQLite) and database configuration

Review RequiredView Analysis

Cannot perform a full security audit as source code is not provided. Based on file names, it's a standard Laravel project, but specific vulnerabilities like 'eval' or network risks cannot be checked without code access.

Updated: 2025-11-19GitHub→

Medium Cost

mcp-attack

by ipninichuck

Sec3

Provides a graph-based interface for the MITRE ATT&CK Framework, exposing tools for Large Language Models to search, traverse, and generate Navigator layers.

Setup Requirements

⚠️Requires Python 3.11+
⚠️Requires `uv` for dependency management and execution
⚠️First run downloads large ATT&CK STIX data (can be slow)

Review RequiredView Analysis

The `generate_navigator_layer` tool allows the `filename` to be specified directly by the user/LLM. While `os.path.abspath` is used, it does not restrict the output file to a specific safe directory, potentially allowing an attacker to write files to arbitrary locations on the server's filesystem (e.g., via path traversal like `../../malicious.json`). This is a critical vulnerability if the client is untrusted or if an LLM is exploited to perform such an action.

Updated: 2025-12-02GitHub→

Medium Cost

speakup-mcp

by zachswift615

Sec8

Provides a centralized text-to-speech (TTS) server for multiple Claude Code instances, featuring queue management, emotional tones, streaming playback, and a web UI.

Setup Requirements

⚠️Requires Python 3.10+.
⚠️Requires ~70MB of voice data to be downloaded during installation.
⚠️Primarily tested/optimized for macOS, with Linux support available and Windows support planned.

Verified SafeView Analysis

The background HTTP service runs on `localhost:7849` and uses `Access-Control-Allow-Origin: *` for its API endpoints. While binding to localhost generally limits external attack surface, `*` CORS headers could theoretically allow a malicious webpage to trigger text-to-speech playback in the user's browser (a loopback attack). However, the impact is limited as the API only controls speech output, not data access or arbitrary code execution. `subprocess.Popen` is used for service management, but with controlled, non-user-inputted commands. SQLite queries are parameterized, preventing SQL injection.

Updated: 2026-01-17GitHub→

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→

Medium Cost

lattice

by swmcc

Sec10

A Neovim plugin for integrating Obsidian vaults with Model Context Protocol (MCP) servers to provide AI context.

Setup Requirements

⚠️Project is in research phase; no implementation available yet.
⚠️Requires Neovim to function as a plugin.
⚠️Requires an Obsidian vault for content integration.

Verified SafeView Analysis

The project is explicitly stated to be in the research and planning phase with no implementation yet. Therefore, there is no executable code to audit for 'eval', obfuscation, or direct network risks at this stage. It is inherently safe as described.

Updated: 2025-11-16GitHub→

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→

PreviousPage 738 of 760Next