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)

30
1
High Cost
oldnordic icon

syncore

by oldnordic

Sec6

A Model Context Protocol (MCP) server providing a unified interface to 65+ AI-native development tools, including persistent memory, dual-domain vector search, tree-sitter based code analysis, knowledge graphs (Neo4j), task management, and multi-agent coordination.

Setup Requirements

  • ⚠️Requires Rust toolchain (cargo) for building.
  • ⚠️Requires Ollama running locally for all AI-powered features (IntelliTask, sequential reasoning).
  • ⚠️Requires a Neo4j instance for all graph-related features.
  • ⚠️Downloads approximately 500MB of HuggingFace embedding models on first run, requiring internet access and disk space.
  • ⚠️Initial startup consumes ~500MB RAM due to loaded embedding models.
  • ⚠️Uses various language-specific tools (e.g., `clangd`, `gopls`, `eslint`, `javac`) through plugins, which need to be installed and available in the environment.
  • ⚠️Sensitive configurations like Neo4j credentials (`NEO4J_PASS`) must be set via environment variables for full graph functionality.
Verified SafeView Analysis
The server explicitly states 'No authentication - Designed for local use'. If exposed on a network, the default HTTP streaming server on port 3001, and potential interactions with exposed Ollama/Neo4j endpoints could be vulnerable. It relies on external processes for LSP and language-specific diagnostics, which carries inherent trust and execution environment risks.
Updated: 2025-12-09GitHub→
30
2
Medium Cost
nagual69 icon
Sec9

A production-ready infrastructure discovery and CMDB platform, delivering 53 tools via the Model Context Protocol (MCP) SDK for AI assistants, automation, and enterprise infrastructure management.

Setup Requirements

  • ⚠️Requires Docker & Docker Compose for easy deployment of the full stack (server, RabbitMQ, optional monitoring).
  • ⚠️Requires Node.js version 23 or higher, as specified in `package.json`.
  • ⚠️Specific Nmap scan types (`nmap_tcp_syn_scan`, `nmap_udp_scan`) require elevated privileges (e.g., `CAP_NET_RAW`, `CAP_NET_ADMIN` capabilities or `--privileged` mode) in the Docker container for full functionality.
  • ⚠️Full functionality, including multi-transport and hot-reload broadcasting, relies on a running RabbitMQ (AMQP) instance.
Verified SafeView Analysis
The project demonstrates a very strong focus on security, particularly in plugin management, input sanitization, and credential handling. - **Strong Plugin Security**: Implements manifest validation (JSON Schema), SHA256 integrity checks for plugin distributions, static code analysis for restricted module imports, runtime sandboxing (via `Module._load` override) to enforce permissions and dependency policies (`bundled-only`, `external-allowlist`, `sandbox-required`), and optional digital signature verification for trusted plugins. Untrusted or invalid plugins can be quarantined. - **Input Sanitization**: Crucially, `nmap_tools_sdk.js` and `network_tools_sdk.js` explicitly use `sanitizeHost` and `sanitizeUrl` functions to mitigate command injection risks when executing external binaries (`nmap`, `ping`, `wget`, etc.). - **Secure Credential Management**: Utilizes AES-256-CBC encryption for sensitive data (passwords, API keys, SSH keys, etc.) stored locally, supports encryption key rotation, maintains an audit log, and integrates with AWS Secrets Manager and Azure Key Vault for robust secret management. - **Operational Security Concerns**: Default AMQP credentials (`amqp://mcp:discovery@localhost:5672`) and Zabbix credentials (`Admin/zabbix`) are provided for quick start but **must be overridden** in production deployments. Some Nmap tools (`-sS`, `-sU`) explicitly add `--privileged` arguments or inherently require elevated privileges (e.g., `CAP_NET_RAW`, `CAP_NET_ADMIN` in Docker), which is a significant deployment-time security decision and should be managed carefully.
Updated: 2026-01-08GitHub→
30
25
Low Cost
appsecco icon
Sec10

Provides a comprehensive checklist for security practitioners to pentest Model Context Protocol (MCP) servers and AI agents.

Verified SafeView Analysis
This repository provides a security checklist for pentesting MCP servers; it is not an MCP server itself and contains only documentation (Markdown files and a PDF). The repository source code itself poses no direct security risks, as it contains no executable logic, 'eval' statements, obfuscation, network risks, or hardcoded secrets. It is an informational resource.
Updated: 2025-12-18GitHub→
30
1
Low Cost
jsoncut icon
Sec8

Enables AI agents to programmatically generate and validate image and video configurations via the Model Context Protocol (MCP) for the Jsoncut API.

Setup Requirements

  • ⚠️The repository is explicitly marked as 'OUTDATED' and 'no longer maintained', recommending use of the official public server.
  • ⚠️Requires a Jsoncut API Key, which typically implies a paid service.
  • ⚠️Requires Node.js >= 18 for local execution using npx.
Verified SafeView Analysis
The server correctly uses environment variables or request headers for API keys, avoiding hardcoding. It integrates with an external API via HTTPS. For the HTTP server mode, it uses CORS with `origin: '*'`, which is acceptable for a public API gateway where clients are expected to provide their own authentication, but could be restricted further for private deployments. No 'eval' or malicious patterns were found in the provided code.
Updated: 2025-11-29GitHub→
30
1
Medium Cost
adamkwhite icon

claude-memory-mcp

by adamkwhite

Sec9

Provides searchable local storage for Claude conversation history, enabling context retrieval during current sessions.

Setup Requirements

  • ⚠️Requires Python 3.11+ (tested with 3.11.12).
  • ⚠️Ubuntu/WSL environment is recommended, suggesting potential compatibility/setup challenges on other operating systems.
  • ⚠️The recommended installation command requires manual replacement of the project's absolute path.
Verified SafeView Analysis
The project demonstrates strong security practices with comprehensive input validation (titles, content, queries) to prevent path traversal, null byte injection, and dangerous regex patterns. Path validation ensures operations are confined to safe directories. Logging includes sanitization and path redaction to prevent log injection and information disclosure. Search queries are sanitized for SQLite FTS. No obvious hardcoded secrets or malicious patterns were found. The primary MCP transport is stdio, reducing network exposure.
Updated: 2025-11-30GitHub→
30
1
Medium Cost
agarabhishek icon

iam-lens-mcp

by agarabhishek

Sec9

Provides AWS IAM analysis capabilities through a Model Context Protocol (MCP) server, enabling AI assistants to query and simulate IAM permissions and configurations using natural language.

Setup Requirements

  • ⚠️Requires installation of multiple tools (uv, npm, iam-collect, iam-lens) with different package managers.
  • ⚠️Python 3.13 or higher is a prerequisite, which might be newer than system defaults for some users.
  • ⚠️Requires manual configuration of Claude Desktop's `claude_desktop_config.json` with absolute paths for both the server directory and the `iam-collect.jsonc` file, which can be error-prone.
Verified SafeView Analysis
The server uses `subprocess.create_subprocess_exec` to run the `iam-lens` CLI tool, passing arguments as a list which mitigates shell injection risks. File path operations for direct IAM data analysis use `Path.resolve()` and `startswith` checks to prevent path traversal vulnerabilities. No `eval` or obviously dangerous patterns are present. The primary external risk would come from the `iam-lens` CLI tool itself or the contents of the `iam-collect` data.
Updated: 2025-11-24GitHub→
30
1
Medium Cost
dnlbauer icon

cordra-mcp

by dnlbauer

Sec8

Provides AI assistants with read-only access to explore and understand Cordra digital object repositories, including schema discovery, object retrieval, and content search.

Setup Requirements

  • ⚠️Requires a running and accessible Cordra repository, specified by CORDRA_BASE_URL.
  • ⚠️Authentication (CORDRA_USERNAME, CORDRA_PASSWORD) may be required for accessing private Cordra instances or administrative objects.
  • ⚠️Requires Python 3.11 or newer to run.
Verified SafeView Analysis
The server provides strictly read-only access, which inherently limits the potential impact of vulnerabilities to data exposure or denial of service, not data modification. Search queries (Lucene/Solr syntax) are passed directly to the Cordra backend; therefore, the security against query injection largely relies on the Cordra backend's sanitization. No 'eval' or obvious hardcoded secrets are present in the provided source code. Configuration is handled securely via environment variables.
Updated: 2025-12-04GitHub→
30
1
Medium Cost
deeptendies icon

financial-mcp-servers

by deeptendies

Sec5

A repository for discovering, organizing, and running Model Context Protocol (MCP) servers primarily focused on financial, market, and cryptocurrency data sources.

Setup Requirements

  • ⚠️Requires Node.js v18+.
  • ⚠️Many managed MCP servers require API keys for external financial data services, which may be paid or require registration (e.g., Financial Modeling Prep, Alpha Vantage).
  • ⚠️Relies on `npx` to fetch and execute npm packages, requiring network access to `registry.npmjs.org` and trust in upstream package integrity.
Review RequiredView Analysis
The repository's core function involves executing arbitrary npm packages and connecting to external APIs, which carries inherent supply chain and third-party risks. The automated GitHub Action, by default, directly commits discovered MCP server configurations to the repository without a mandatory review step, posing a significant security vulnerability if untrusted packages are automatically added. API keys are placeholders and not hardcoded, which is good practice. The `autoApprove` feature offers a good control mechanism for allowed actions.
Updated: 2026-01-19GitHub→
30
1
High Cost
prefeitura-rio icon

app-mcp-server

by prefeitura-rio

Sec6

This server acts as a backend for a conversational AI assistant for the Rio de Janeiro municipality, providing a suite of specialized tools and data access, including city information, real-time data, calculations, multi-step workflows, web search, and alert management.

Setup Requirements

  • ⚠️The default `VALID_TOKENS="token"` in the example environment file is insecure and must be replaced with a strong, unique token in production.
  • ⚠️Requires numerous environment variables for external API keys (e.g., Google Maps, Gemini, Dharma, PGM, RMI, Typesense, Surkai, BigQuery credentials). Misconfiguration or missing keys will lead to runtime failures.
  • ⚠️Disables SSL verification (`"verify": False`) for requests to the PGM API. This is a critical security risk for production environments if not justified by a highly secure internal network, and should be reviewed.
  • ⚠️For non-local environments (`IS_LOCAL=False`), the `multi_step_service` defaults to `StateMode.REDIS`, requiring a running Redis instance for state management.
Verified SafeView Analysis
The server implements token-based authentication via `CheckTokenMiddleware` and loads secrets from environment variables, which are good practices. However, the example `.env` provides `VALID_TOKENS="token"`, which is a very weak default and insecure for production. Critically, the `pgm_api` function disables SSL certificate verification (`"verify": False`) for requests to the PGM API, which creates a significant Man-in-the-Middle attack vulnerability if the network path is not fully trusted. While `ast.literal_eval` is used, its application in parsing expected LLM-generated structures mitigates but does not eliminate all risks.
Updated: 2026-01-14GitHub→
30
1
Medium Cost
h1ddenpr0cess20 icon

mcp

by h1ddenpr0cess20

Sec9

Exposing various third-party RapidAPI services (jobs, finance, food, entertainment, social, real estate, news, search) as a collection of FastMCP servers for tool integration.

Setup Requirements

  • ⚠️Requires a RapidAPI key and specific API subscriptions on RapidAPI (some may be paid, as detailed in `docs/domain_providers.md`).
  • ⚠️Requires Python 3.10+.
  • ⚠️The server exposes FastMCP tools, implying interaction with an MCP client for full functionality rather than direct web access.
Verified SafeView Analysis
The RapidAPI MCP server acts as a wrapper for various RapidAPI services. API keys are handled securely via environment variables or `.env` files, which is good practice. The source code does not use `eval` or similar dangerous dynamic code execution functions. Input sanitization for RapidAPI parameters (e.g., converting booleans to strings, removing `None` values) is present. While FastMCP handles basic parameter typing, extensive deep input validation beyond that is not explicitly shown, relying on the underlying RapidAPI endpoints for data validation.
Updated: 2025-11-30GitHub→
30
1
Medium Cost
GuiArSt icon

mcp-dev-journal

by GuiArSt

Sec9

An MCP server for AI agents to create and query developer journal entries from git commits, document project summaries, and integrate with project management tools like Linear.

Setup Requirements

  • ⚠️Requires at least one AI API key (Anthropic, OpenAI, or Google) for journal entry/summary generation, which typically involves paid services.
  • ⚠️For cloud deployments (e.g., Vercel), the SQLite database ('journal.db') must be hosted externally (e.g., AWS S3, remote database), as the default expects a local file path.
  • ⚠️If integrating with the companion web app ('Tartarus') for repository tools and attachment download URLs, 'TARTARUS_URL' and 'MCP_API_KEY' environment variables must be properly configured for secure inter-service communication.
Verified SafeView Analysis
The MCP server internally uses parameterized SQL queries via 'better-sqlite3', which prevents SQL injection vulnerabilities. API keys for AI providers, Linear, and the inter-service MCP_API_KEY are configured via environment variables, reducing the risk of hardcoded credentials. It is CRITICAL to set strong, non-default values for all API keys and secrets in production environments. File system access for database operations and backups is confined to specified paths or the project's designated 'data' directory. The 'eval' usage observed in the 'web' app's AI tool generation API route does not directly impact the MCP server's operations, but is a general caution within the broader workspace context. MCP server-to-web app communication relies on the 'MCP_API_KEY' for authentication; if this is not configured, API calls from the MCP server to Tartarus's repository endpoints will be unauthenticated, potentially exposing data if the Tartarus web app is not otherwise secured.
Updated: 2026-01-15GitHub→
30
1
Medium Cost
jaybird-us icon

azure-devops-mcp

by jaybird-us

Sec7

An MCP server that enables Claude to interact with Azure DevOps work items, projects, sprints, and relationships directly through natural language.

Setup Requirements

  • ⚠️Requires Node.js v18.0.0 or higher to be installed.
  • ⚠️Requires Azure CLI to be installed and configured with `az login`.
  • ⚠️Requires the Azure DevOps extension for Azure CLI (`az extension add --name azure-devops`).
  • ⚠️Requires an Azure DevOps organization to be configured, either via an environment variable (`AZURE_DEVOPS_ORG`) or Azure CLI defaults.
Verified SafeView Analysis
The server heavily relies on spawning child processes to execute Azure CLI commands (`az devops ...`). While inputs are generally sanitized via `encodeURIComponent` for URL parameters and writing request bodies to temporary files, reliance on shell execution inherently carries a risk if not meticulously handled. Credentials are not hardcoded but managed via Azure CLI authentication or environment variables, which is a good practice.
Updated: 2026-01-19GitHub→
PreviousPage 235 of 760Next