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

obsidian-vault-mcp

by MarkOnFire

Sec9

Provides a Model Context Protocol (MCP) server for Claude (Desktop/Code) to read, search, list, and modify notes and attachments in an Obsidian vault, with awareness of PARA methodology and task management features.

Setup Requirements

  • ⚠️Requires Python 3.10+
  • ⚠️Requires `OBSIDIAN_VAULT_PATH` environment variable set to an existing Obsidian vault (iCloud-synced vaults must be downloaded locally and fully synced)
  • ⚠️Requires an MCP-compatible client (e.g., Claude for Desktop/Code) to function as a tool, as it runs via stdio and not as a standalone web server
Verified SafeView Analysis
The server runs locally via standard I/O (stdio_server), meaning it does not expose any network ports, significantly reducing external attack surface. It employs atomic file write operations (temp file then rename) and includes checks for path traversal ('..') and filename sanitization for new notes and attachments. File types and sizes for attachments are validated against configuration. While it supports write operations, these are features of the tool designed for AI agent control, not vulnerabilities. The potential for risk is primarily contained within the local Obsidian vault and relies on the user's trust in the AI agent's actions.
Updated: 2026-01-18GitHub→
30
1
Medium Cost
1sustgmboab icon

nexonco-mcp

by 1sustgmboab

Sec9

An advanced server for accessing and analyzing clinical evidence data to support precision medicine and oncology research, with flexible search options.

Setup Requirements

  • ⚠️Requires 'uv' package manager for Python environment management.
  • ⚠️Python 3.11 or higher is required.
  • ⚠️Docker is recommended for NANDA server setup (Method 1).
  • ⚠️Different transport options ('stdio' for Claude, 'sse' for NANDA) need to be considered when running.
Verified SafeView Analysis
The server uses standard Python libraries (requests, pandas, uvicorn, starlette) and the FastMCP framework. It interacts with the public CIViCdb GraphQL API. No instances of 'eval', obfuscation, or hardcoded sensitive secrets were found in the provided source code. Input parameters for the 'search_clinical_evidence' tool are validated using Pydantic. The overall architecture appears robust and designed with common security practices in mind for its intended functionality. The primary external dependency is CIViCdb, a reputable public database.
Updated: 2026-01-19GitHub→
30
1
Medium Cost
noemys-tech icon

Open-MCP

by noemys-tech

Sec3

Provides a Model Context Protocol (MCP) interface for interacting with S3-compatible object storage services like AWS S3 or MinIO, enabling LLMs to list buckets, list objects, download objects, and retrieve object metadata.

Setup Requirements

  • ⚠️Requires Java 21 or higher and Maven.
  • ⚠️Requires access to an S3-compatible object storage server (e.g., MinIO, AWS S3) with valid credentials for tool operations.
  • ⚠️**Critical Security Misalignment**: The server's code (v1.0.1) explicitly lacks OAuth 2.1 authentication and allows anonymous sessions, contradicting its own README, rendering it insecure for production without an external authentication layer.
Review RequiredView Analysis
The `s3-mcp` server, specifically version 1.0.1 (as per its source code and changelog), explicitly *removed OAuth 2.1 authentication*. It automatically creates 'anonymous' sessions for any incoming request if no valid session ID is provided or if no `Authorization` header is present. This is a critical security risk, making the server unsuitable for untrusted environments or direct internet exposure without an external authentication proxy. S3 access keys (`token`) and secret keys (`userToken`) are passed as plaintext arguments within JSON-RPC requests; without an HTTPS proxy, these credentials are vulnerable to interception. The `s3-mcp` README and Docker instructions are outdated, still mentioning OAuth and `JWT_SECRET` configuration, which creates significant confusion and can mislead users into believing authentication is enforced when it is not in this specific `s3-mcp` version.
Updated: 2025-12-02GitHub→
30
1
High Cost
ianyimi icon
Sec3

Develop a multi-agent personal knowledge management system within Obsidian, offering semantic search, voice interface, and distributed computing across local devices.

Setup Requirements

  • ⚠️Requires Ollama for local LLM inference and embeddings (e.g., Llama 3.1 70B, nomic-embed-text) necessitating significant RAM/VRAM (e.g., 40GB+ RAM for 70B model).
  • ⚠️Requires a running Qdrant Vector Database instance (locally or on Unraid NAS) for semantic search functionality.
  • ⚠️The full distributed architecture relies on Tailscale VPN for secure inter-device communication and mobile access, which needs to be configured by the user.
Review RequiredView Analysis
The plugin dynamically loads and executes user-provided JavaScript files from the 'mcp-tools' folder using blob URLs and dynamic imports. These dynamically loaded scripts have full access to the Obsidian application (app, vault, workspace) via global window objects, effectively giving arbitrary user-controlled code complete control over the vault and plugin behavior. While a refactoring proposal mentions future sandboxing with `vm2` or `isolated-vm`, the current `main.ts` code does not implement this. This creates a high security risk if untrusted code is placed in the tools folder. Additionally, the planned Python `owui_filesystem_tools.py` with `bash` command execution, if improperly exposed or integrated, represents a severe risk (though it's not directly part of the plugin's `main.ts` dynamic loading). Network exposure is mitigated by default `localhost` binding and planned Tailscale VPN, but misconfiguration could lead to unauthorized access.
Updated: 2025-11-22GitHub→
30
1
Low Cost
seanivore icon

claud-grants

by seanivore

Sec7

Facilitates grant application management and development roadmap tracking for a decentralized AI developer knowledge sharing protocol, while outlining its technical implementation.

Setup Requirements

  • ⚠️Requires Solana development environment (Rust, Solana CLI)
  • ⚠️Requires Web3 client-side libraries for interaction
Verified SafeView Analysis
This repository primarily contains documentation and high-level code snippets for a grant application, not the full executable MCP server code. Therefore, it poses no direct security risks from running server-side code from this specific repository. However, the described $CLAUD protocol involves smart contracts, tokenomics, and decentralized systems, which are inherently complex and prone to vulnerabilities. The documentation mentions plans for external security audits and robust measures for the actual protocol implementation (claud-coin), but these cannot be fully validated from the provided truncated source code.
Updated: 2025-11-29GitHub→
30
1
Medium Cost
Gitmy3 icon
Sec3

Integrates Wazuh SIEM data with AI assistants (like Claude) using the Model Context Protocol (MCP) for natural language security queries and analysis.

Setup Requirements

  • ⚠️Requires a running Wazuh server (v4.12 recommended) with its API and Indexer (OpenSearch/Elasticsearch) accessible.
  • ⚠️Requires an OpenAI API Key for LLM query functionality, which is a paid service.
  • ⚠️Disables SSL certificate verification (`WAZUH_VERIFY_SSL=false`) by default for Wazuh connections, posing a significant security risk for production environments.
Review RequiredView Analysis
CRITICAL: The server explicitly disables SSL certificate verification for Wazuh API and Indexer connections (`verify=False` and `WAZUH_VERIFY_SSL=false` in various configurations). This makes the connection vulnerable to Man-in-the-Middle (MITM) attacks. Additionally, sensitive credentials for Wazuh API and Indexer are hardcoded in `app/config.py`, making them prone to exposure if the code is committed without proper `.env` override or secure credential management. These are severe security flaws for a system handling security information.
Updated: 2025-12-11GitHub→
30
1
High Cost
maximilien icon

weave-mcp

by maximilien

Sec2

Provide a Model Context Protocol (MCP) server for managing and interacting with various vector databases, offering AI-powered tools for schema and chunking suggestions.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid) for AI features (suggest_schema, suggest_chunking).
  • ⚠️Docker is required for local Weaviate setup and E2E tests.
  • ⚠️The `weave` CLI binary must be installed and in PATH for AI-powered suggestion tools to function.
  • ⚠️Node.js 22.7.5+ and npm are required for the optional MCP Inspector debugging tool.
Review RequiredView Analysis
The `executeCommand` function in `src/pkg/mcp/handlers.go` directly executes shell commands (`sh -c`) constructed with user-provided input (e.g., `source_path`, `requirements`). This poses a significant shell injection vulnerability if input is not rigorously sanitized. Additionally, the Weaviate client (`src/pkg/weaviate/weave_client.go`) constructs GraphQL queries using string formatting with user-provided filters (e.g., `valueString: "*filename\": \"%s\"*"`), which could lead to GraphQL injection if the input is not adequately escaped. Default CORS configuration allowing `*` is flexible but can be a security risk if not properly restricted in production environments.
Updated: 2026-01-16GitHub→
30
1
Medium Cost

Cernji-Agents

by TerraCo89

Sec8

Centralized error analysis and automated issue creation by processing alerts from observability systems (like Kibana/Elasticsearch) and triggering workflows (e.g., in N8N or Linear). It acts as a Model Context Protocol (MCP) server exposing tools for these operations.

Setup Requirements

  • ⚠️Requires `uv` (Python package manager) to run.
  • ⚠️Requires an active ELK (Elasticsearch, Kibana) stack for log aggregation and alerting.
  • ⚠️Requires Docker for running the ELK stack and potentially N8N.
  • ⚠️Requires N8N for workflow orchestration if `trigger_n8n_workflow` tool is used.
  • ⚠️Requires `FASTMCP_API_TOKEN` environment variable for MCP server authentication.
  • ⚠️Requires `LINEAR_API_KEY` and `LINEAR_ORG_ID` environment variables for Linear API integration.
  • ⚠️Requires `ELASTICSEARCH_URL` environment variable to connect to Elasticsearch.
  • ⚠️Requires `ANTHROPIC_API_KEY` (or `OPENAI_API_KEY`) and `MODEL_NAME` environment variables for LLM-driven analysis in the associated `trigger_error_analysis.py` script.
Verified SafeView Analysis
The server uses environment variables for API keys and authentication tokens, which is a good practice. It implements an authentication middleware using `FASTMCP_API_TOKEN` for incoming requests. External HTTP requests are made using `httpx` with JSON payloads. No direct `eval()` or unsanitized shell command execution is observed. Potential risks include LLM prompt injection (if LLMs are used via `trigger_error_analysis.py`) and misconfiguration of sensitive environment variables.
Updated: 2025-11-27GitHub→
30
1
Low Cost
PivotLLM icon

MCPLaunchPad

by PivotLLM

Sec9

An MCP server demonstrating Google OAuth2 authentication using the device flow for securing access to tools and resources.

Setup Requirements

  • ⚠️Requires Google Cloud Project setup for OAuth2 credentials and consent screen configuration.
  • ⚠️Requires `GOOGLE_CLIENT_ID` and `GOOGLE_CLIENT_SECRET` environment variables to be set for authentication (will fatal if missing unless `--skip-auth` is used).
  • ⚠️OAuth2 access tokens are not persisted and expire after approximately 1 hour, requiring re-authentication for prolonged use (acknowledged as a limitation of the example, not production-ready behavior).
Verified SafeView Analysis
The server correctly leverages environment variables for Google OAuth2 client ID and secret, avoiding hardcoded credentials in the example. It uses a robust OAuth2 device flow for authentication and integrates bearer token validation at the HTTP layer. The default binding to 'localhost' limits direct network exposure. The README explicitly highlights critical production considerations such as requiring HTTPS, proper token storage, and refresh token handling. While the example's tool handlers currently return placeholder user information due to the handler signature not yet supporting context passing, the authentication mechanism itself functions correctly at the HTTP middleware level.
Updated: 2026-01-18GitHub→
30
1
Low Cost
ayaanjan76 icon

awesome-mcp-servers

by ayaanjan76

Sec1

This repository serves as a curated list and directory for Model Context Protocol (MCP) servers, categorizing various implementations and frameworks to extend AI capabilities with external resources.

Setup Requirements

  • ⚠️The primary 'README.md' in the repository (as provided in the source code block) directs users to download and run an unverified executable '.zip' file, posing a severe security risk.
  • ⚠️There is a discrepancy in the definition of 'MCP' (Microsoft Cognitive Services vs. Model Context Protocol) across different README files in the repository.
  • ⚠️The repository itself is an 'awesome list' and not an executable server; individual MCP servers listed within must be set up separately according to their own documentation.
Review RequiredView Analysis
The 'README.md' file within the provided 'SOURCE CODE (Truncated)' block (distinct from the main README in the prompt's introductory text) contains direct download links to an unverified '.zip' executable file (e.g., 'https://raw.githubusercontent.com/ayaanjan76/awesome-mcp-servers/main/chromophoric/awesome-mcp-servers.zip') and instructs users to 'Run the application' from it. This is a severe security risk as the contents are unknown and could contain malicious code. Additionally, there's a discrepancy in the definition of 'MCP' (Microsoft Cognitive Services vs. Model Context Protocol) across different READMEs in the provided source, which is confusing and potentially misleading.
Updated: 2026-01-19GitHub→
30
1
Low Cost
ozipi icon
Sec9

Enables AI agents to interact with the Brainloop personalized learning platform by providing structured access to course management, content creation, and progress tracking, using an MCP (Model Context Protocol) interface.

Setup Requirements

  • ⚠️Docker is required to run the server for end-to-end tests and recommended for deployment.
  • ⚠️Requires a Google Cloud Project to obtain `GOOGLE_CLIENT_ID` and `GOOGLE_CLIENT_SECRET` for OAuth 2.0 client credentials, including setting up an authorized redirect URI (e.g., `http://localhost:3000/oauth/google/callback`).
  • ⚠️Requires access to a running Brainloop API instance (`BRAINLOOP_API_URL`) and a Brainloop database (`BRAINLOOP_DATABASE_URL`) for its core functionality.
  • ⚠️A valid MCP JWT token, obtained via the Google OAuth flow, is required for authentication and for running tests.
Verified SafeView Analysis
The server demonstrates robust security practices including OAuth 2.1 with PKCE, JWT tokens for session management, Zod for input validation, CORS configuration, rate limiting, request size limits, and explicit handling of sensitive environment variables. Session data is managed with timeouts and cleanup. No direct 'eval' or obvious code injection vulnerabilities were found. A polyfill for `globalThis.crypto` is used for the `jose` library, which relies on Node's native crypto module, not a direct security risk.
Updated: 2025-12-03GitHub→
30
1
Medium Cost
neverinfamous icon

postgresql-mcp

by neverinfamous

Sec9

Enabling AI agents to programmatically interact with PostgreSQL databases through a rich set of specialized tools and a sandboxed code execution environment.

Setup Requirements

  • ⚠️Many advanced tools require specific PostgreSQL extensions (e.g., pgvector, PostGIS, pg_cron, pgcrypto, citext, ltree, pg_stat_kcache, HypoPG, pg_partman) to be installed and enabled in the database.
  • ⚠️Certain administrative tools (e.g., `VACUUM FULL`, `CREATE EXTENSION`, `pg_terminate_backend`) require superuser database privileges.
  • ⚠️If OAuth 2.1 authentication is enabled, a compatible external authorization server (with configured issuer, JWKS URI, and audience) is required.
Verified SafeView Analysis
The `codemode` module implements robust sandboxing using Node.js `vm` or `worker_threads`, explicitly blocking access to dangerous Node.js globals (like `require`, `process`, `eval`, filesystem, and networking modules). It uses regex patterns to detect and prevent common malicious code injection attempts. The `HttpTransport` also enforces strong network security measures including rate limiting, maximum request body size, HTTP Strict Transport Security (HSTS), Content Security Policy (CSP), and other security headers. OAuth 2.1 is supported for external authentication and authorization. While these layers provide strong protection, inherent theoretical limitations exist for any in-process sandbox compared to full containerization.
Updated: 2026-01-19GitHub→
PreviousPage 232 of 760Next