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
team-earth icon
Sec9

Provides a Model Context Protocol (MCP) interface for LLMs (like Claude Desktop) to query various urban intelligence datasets from the DataGraph API, including NYC building permits, property sales, crime, demographics, subway data, and GOSR framework-based civic programs.

Setup Requirements

  • ⚠️Requires a DATAGRAPH_API_KEY from datagraph.city (a free tier is available, but a key is still needed).
  • ⚠️Specific configuration steps for Claude Desktop (editing claude_desktop_config.json) are required for integration.
  • ⚠️Requires Node.js and npm/npx to be installed.
Verified SafeView Analysis
The server acts as a proxy to the external DataGraph API, requiring a DATAGRAPH_API_KEY which is securely handled via environment variables (not hardcoded). There are no 'eval' calls or obfuscation detected. The server explicitly enforces read-only operations and includes a LIMIT clause validation for user-provided Cypher queries, demonstrating a focus on preventing malicious database operations. The core security depends on the DataGraph API itself, but the server component appears robust.
Updated: 2025-12-30GitHub→
0
0
Low Cost
hackafterdark icon

uplink

by hackafterdark

Sec2

Connects local AI agents to a web browser for interaction, control, and debugging.

Setup Requirements

  • ⚠️Requires Python 3.10+.
  • ⚠️Manual browser extension installation via 'Load Unpacked' (Chrome/Edge/Brave) or 'Load Temporary Add-on' (Firefox).
  • ⚠️Server and extension require matching ports if not using default 8765, necessitating manual update in extension dashboard.
  • ⚠️The `AUTH_TOKEN` is hardcoded in `server.py`, requiring manual modification for stronger security.
Review RequiredView Analysis
CRITICAL RISK: The extension uses `eval()` to execute arbitrary JavaScript received from the WebSocket server within the browser's context (`extension/content.js` and `extension/background.js`). While the WebSocket connection is local and secured by a hardcoded token, this design allows for arbitrary code execution on any visited website if the local AI agent is compromised, misconfigured, or if the `AUTH_TOKEN` is discovered. This is a severe vulnerability that can lead to XSS, data exfiltration, or complete browser takeover within the user's session. The `AUTH_TOKEN` is also hardcoded in `server.py`, which makes it easily discoverable and reduces the effectiveness of token-based authentication.
Updated: 2026-01-19GitHub→
0
0
Low Cost
CrackingShells icon

mcp-servers

by CrackingShells

Sec10

This repository serves as a temporary list for compiling Systems Biology MCP servers.

Verified SafeView Analysis
The provided 'SOURCE CODE' consists solely of a README.md file. There is no executable code (e.g., JavaScript, Python, Dockerfiles) to audit for 'eval', obfuscation, hardcoded secrets, or network risks within this repository itself. The repository is inert; security risks would only arise from visiting the external links listed within the README, which are outside the scope of this repository's code.
Updated: 2025-12-02GitHub→
0
0
Medium Cost
ChaseRichardsonGit icon

wp-mcp-chaserich

by ChaseRichardsonGit

Sec8

Enables AI assistants to interact with a WordPress site for content management, including posts, pages, media, and taxonomies, with specific support for Elementor.

Setup Requirements

  • ⚠️Requires a running WordPress instance with REST API enabled.
  • ⚠️Requires a WordPress Application Password for authentication (generated in WordPress Admin > Users > Your Profile).
  • ⚠️For full Elementor integration and meta field access, the custom `mcp-elementor-support.php` plugin must be installed and activated on the WordPress site.
  • ⚠️Requires Node.js version 18 or higher.
Verified SafeView Analysis
The server uses environment variables for WordPress credentials (WP_URL, WP_USERNAME, WP_APP_PASSWORD) and an optional API_KEY for the MCP server itself, which is good practice against hardcoded secrets. It employs HTTPS communication with WordPress (recommended via WP_URL). Authentication for the MCP server relies on a basic API key (via header or query parameter), which is acceptable for internal/development use but less robust than OAuth 2.1, a standard becoming mandatory for public HTTP MCP transports as per the provided `MCP_CREATION_RULES.md`. The WordPress plugin (`mcp-elementor-support.php`) includes `current_user_can('edit_posts')` for permission callbacks. Safety features like 'draft-first' post creation and default slug protection ('preserve_slug: true') are implemented to prevent accidental data loss or SEO impact. No 'eval' or malicious patterns were identified in the provided source code.
Updated: 2026-01-16GitHub→
0
0
Low Cost
zuhairabbas1 icon

legal-research-mcp

by zuhairabbas1

Sec6

This server exposes a Google Search tool as an MCP endpoint, allowing a client application to perform legal research and leverage an LLM for structured analysis.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid)
  • ⚠️MCP server must be started before the client application
  • ⚠️The Google Search tool provides mock results for educational purposes, not real-time search outcomes.
Verified SafeView Analysis
The Flask server runs with `debug=True`, which is a critical security vulnerability for any production deployment as it can expose the debugger and allow arbitrary code execution. While acceptable for a local, educational project, it's a significant risk if used outside this context. The `perform_google_search` function initiates an external HTTP request to Google but then discards the response in favor of hardcoded mock data, making the actual search functional but irrelevant to the output and potentially fragile. No 'eval' or malicious patterns were found.
Updated: 2025-11-19GitHub→
0
0
High Cost
telagod icon

papermcp

by telagod

Sec9

The PaperMCP server provides a unified interface for searching, downloading, and extracting text from academic papers across 23+ diverse scientific and academic sources through the Model Context Protocol.

Setup Requirements

  • ⚠️Full functionality for several core platforms (e.g., Semantic Scholar, Web of Science, Scopus, CORE, Microsoft Academic) requires setting specific API keys as environment variables.
  • ⚠️Optional plugins (e.g., Sci-Hub, LibGen, Unpaywall, ScienceDirect, SpringerLink, IEEE Xplore) are disabled by default and must be explicitly enabled via `PLUGIN_XYZ=true` environment variables.
  • ⚠️The Unpaywall plugin specifically requires setting the `UNPAYWALL_EMAIL` environment variable to function.
  • ⚠️Requires Node.js version >= 18.18 to run. The `canvas` dependency (used by `pdfjs-dist`) might require system-level build tools on some environments.
Verified SafeView Analysis
The server's core functionality involves making HTTP requests to external academic platforms and handling local file operations for PDF download and text extraction. It uses `process.env` for API keys, preventing hardcoded secrets. HTTP requests are throttled and use random user agents. File paths for downloads are sanitized to prevent directory traversal. The optional plugins (e.g., Sci-Hub, LibGen) are explicitly disabled by default and come with warnings about responsible use, mitigating potential legal or security risks associated with those sources. No `eval` or other obvious malicious patterns are found.
Updated: 2025-11-22GitHub→
0
0
Low Cost
cocolizh icon
Sec1

Analysis is severely limited as no source code was provided. Based on the repository name 'demo-algorithms-repo' and the description 'MCP Server', it likely demonstrates algorithms within a server context, but specifics regarding its exact function are unknown.

Setup Requirements

  • ⚠️Source code not provided for analysis, preventing detailed evaluation of requirements or friction points.
Review RequiredView Analysis
CRITICAL: The source code was not provided for analysis, making a comprehensive security audit impossible. Without code, it's impossible to check for 'eval', obfuscation, network risks, hardcoded secrets, or malicious patterns. Therefore, the server cannot be deemed safe to run.
Updated: 2025-11-24GitHub→
0
0
Medium Cost
RezaJF icon
Sec1

Exposes FinnGen data analysis R package functionalities to AI agents and generates Jupyter notebooks using Google Vertex AI for research and development.

Setup Requirements

  • ⚠️Requires R and the `fganalysis` R package to be installed separately.
  • ⚠️Requires a Google Cloud Vertex AI API Key, Project ID, and Location (a paid service) for notebook generation.
  • ⚠️The `fganalysis-r` repository must be cloned as a sibling directory for default database configuration.
Review RequiredView Analysis
CRITICAL: The `execute_r_code` tool allows arbitrary R code execution. If this server is exposed to untrusted AI agents or clients, it presents a severe remote code execution vulnerability, allowing an attacker to run any R code, which can interact with the underlying operating system. The `subprocess.run` calls, while generally requiring care, are particularly dangerous in conjunction with the `execute_r_code` tool. This server is highly insecure for public exposure.
Updated: 2025-11-30GitHub→
0
0
Medium Cost
wzrazsh icon
Sec9

A unified platform for managing, monitoring, and auditing AI development tools and their task lifecycles, providing both a standardized API and a web administration interface.

Setup Requirements

  • ⚠️Requires Node.js runtime environment for backend development.
  • ⚠️Requires PostgreSQL database for production (SQLite for development).
  • ⚠️Requires Redis for caching and performance optimization.
  • ⚠️Recommends Docker and Kubernetes for containerized deployment and orchestration.
Verified SafeView Analysis
The design documents outline a comprehensive security strategy including JWT for admin authentication, tool_id + token for client authentication, RBAC for authorization, mandatory HTTPS, field-level encryption for sensitive data (e.g., API keys, request payloads), at-rest encryption for storage, strict database permissions, rate limiting, and robust input validation against common vulnerabilities. A strong focus on security auditing is also defined. While actual code implementation would require verification, the documented design principles are robust.
Updated: 2025-11-20GitHub→
0
0
Medium Cost
john-walkoe icon

uspto_ptab_mcp

by john-walkoe

Sec9

Access USPTO Patent Trial and Appeal Board (PTAB) data via Open Data Portal API, enabling progressive disclosure, document processing, and AI-driven analysis.

Setup Requirements

  • ⚠️Requires a valid USPTO API Key (Paid access for some API endpoints, though data is generally free). Can be configured via environment variable (USPTO_API_KEY) or secure storage.
  • ⚠️Mistral API Key (MISTRAL_API_KEY) is optional for OCR functionality; without it, only basic PyPDF2 text extraction is available, which may not work for scanned documents. OCR incurs a cost (~$0.15 per 1M input tokens).
  • ⚠️Secure storage relies on Windows Data Protection API (DPAPI) for Windows, or file permissions (0o600) on Linux/macOS. Setting up these permissions correctly is crucial for non-Windows environments.
Verified SafeView Analysis
The server demonstrates robust security practices. API keys are handled securely via OS-specific (Windows DPAPI) or file permission-based secure storage with `secrets.token_bytes` for entropy. Extensive input validation (`src/ptab_mcp/validation/validators.py`) prevents common injection attacks (e.g., SQLi, XSS). All log messages are automatically sanitized to prevent sensitive data exposure and log injection (`src/ptab_mcp/shared/log_sanitizer.py`). Network communications use `httpx` with SSL verification, and include rate limiting, circuit breakers, and request body size limits. The FastAPI proxy server implements comprehensive security headers (X-Frame-Options, CSP, etc.) and strict CORS policies. File permissions for secure storage and log files are correctly enforced (0o600/0o700).
Updated: 2026-01-19GitHub→
0
0
Medium Cost
ZBcheng icon

eth-trading-mcp

by ZBcheng

Sec8

An Ethereum trading service providing balance queries, token price queries, and token swap simulations via MCP protocol for AI Agents.

Setup Requirements

  • ⚠️Requires Rust 1.70+ environment.
  • ⚠️Access to an Ethereum RPC Node (public options are heavily rate-limited; a private/paid node is recommended for reliable performance).
  • ⚠️Blockchain interaction tests are ignored by default due to RPC rate limiting and require specific flags and delays to run (`cargo test -- --ignored --test-threads=1`).
Verified SafeView Analysis
The server correctly uses environment variables for sensitive data like `WALLET_PRIVATE_KEY`. By default, the server runs in a read-only/simulation-only mode, significantly reducing immediate risks. Even when a private key is provided, the exposed MCP tools (`swap_tokens`) only perform transaction *simulations* (using `eth_call` and `estimate_gas`), not actual on-chain executions. The server binds to `0.0.0.0` by default, which is standard but requires appropriate firewall configuration in production environments. Robust error handling is present for input validation and blockchain interactions. No 'eval' or obfuscation found.
Updated: 2025-11-30GitHub→
0
0
Low Cost
meshula icon

LabMCP

by meshula

Sec9

A minimal, production-ready C++20 template for building an MCP (Model Context Protocol) server that implements a dice rolling tool, designed for integration with clients like Claude Desktop.

Setup Requirements

  • ⚠️Requires a C++20 compliant compiler (e.g., g++ or clang++ supporting C++20).
  • ⚠️Requires `make` to build the project.
  • ⚠️For Claude Desktop integration, manual configuration of the executable path (`/path/to/LabMCP/cpp20-mcp-template/build/cpp20-mcp-template`) is necessary in the client's configuration file.
Verified SafeView Analysis
The server communicates via standard I/O (stdio), limiting direct network exposure to external clients. Input validation is performed for the dice rolling tool to prevent excessive or malicious input (e.g., dice count between 1-100, sides between 1-1000). The project uses RapidJSON for robust JSON parsing and error handling, minimizing common JSON-related vulnerabilities. No dynamic code execution (like 'eval') or hardcoded secrets were identified in the provided source code. The C++20 features promote modern, safer coding practices (e.g., RAII, smart pointers).
Updated: 2026-01-17GitHub→
PreviousPage 365 of 760Next