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

lsmcp

by depoll

Sec9

Provides AI models with semantic code understanding and refactoring capabilities via Language Server Protocol (LSP) integration.

Setup Requirements

⚠️Docker is highly recommended, and often required for smooth cross-platform operation, especially for native LSP server installations.
⚠️Requires specific language servers (e.g., `typescript-language-server`, `python-lsp-server`) to be installed in the environment where `lsmcp` runs. Auto-installation might fail or isn't supported for all languages in native (non-Docker) environments.
⚠️Node.js version >= 20.0.0 is required.

Verified SafeView Analysis

The project emphasizes a 'container-first architecture' with Docker, providing good isolation. It uses `child_process.spawn` with `shell: false` and includes input sanitization functions (`escapeRegExp`, `escapeShell`, `validateFilePath`, `sanitizeFileURI`) to prevent command injection and path traversal. Filesystem modifications are performed through `src/utils/file-operations.ts` which relies on URIs being safe. The `executeCommand` tool allows executing LSP server commands, which could be a vector if the underlying LSP server exposes dangerous commands, but this is a function of LSP itself. Overall, good security practices are evident.

Updated: 2025-11-28GitHub→

Medium Cost

mcp-process

by Digital-Defiance

Sec3

Provides a secure and auditable environment for AI agents to manage system processes, monitor resources, and orchestrate long-running services.

Setup Requirements

⚠️Requires Node.js 18.0.0 or higher.
⚠️Requires a configuration file (e.g., `mcp-process-config.json`) with explicitly allowed executables; the default allowlist is empty. Failure to configure this will prevent most operations.
⚠️Running without Docker requires manual `npm install` and `npm run build`.

Review RequiredView Analysis

CRITICAL VULNERABILITY: The `ServiceManager.executeHealthCheck` function directly spawns health check commands (`child_process.spawn`) without performing security validations (e.g., executable allowlist, argument injection checks) via the `SecurityManager`. This means an attacker capable of defining or modifying a `ServiceConfig` (including its `healthCheck.command`) could execute arbitrary commands on the host system, bypassing all intended security layers. This is a severe remote code execution vulnerability. Other security measures like executable allowlisting, argument validation, environment sanitization, and privilege prevention are well-implemented for `process_start` operations, but this specific flow bypasses them. Hardcoded dangerous environment variables are blocked, and the Docker setup promotes non-root execution and capability dropping, which are good practices. No obfuscation or obvious hardcoded secrets were found.

Updated: 2026-01-17GitHub→

Low Cost

header-test-mcp

by matsjfunke

Sec8

An MCP server designed for debugging custom header implementations in MCP hosts/clients by providing a tool to retrieve request headers.

Setup Requirements

⚠️Requires Node.js v18 or above
⚠️Requires PNPM v10 or above

Verified SafeView Analysis

The server enables wildcard CORS ('Access-Control-Allow-Origin: *'), which is a security risk in production but acceptable for its stated debugging purpose. The `currentRequestHeaders` global variable can be overwritten by concurrent requests, potentially leading to stale information for debugging, but does not pose a direct critical security vulnerability like data leakage to unauthorized parties.

Updated: 2025-12-11GitHub→

High Cost

network-mcp-docker-suite

by pamosima

Sec9

Provides comprehensive access to Cisco ThousandEyes v7 API functionality for network monitoring, performance analysis, and troubleshooting with enterprise-grade security.

Setup Requirements

⚠️Requires ThousandEyes API v7 Bearer Token (TE_TOKEN) which must be obtained from a ThousandEyes account.
⚠️Primary deployment uses Docker, requiring Docker Engine and Docker Compose.
⚠️Requires Python 3.12 or newer.

Verified SafeView Analysis

The server explicitly implements multiple security features including read-only operations, environment-only credentials (ThousandEyes API token), secure token handling (masking in logs, not stored on disk), HTTPS communication, Bearer Token authentication, and non-root container execution. No 'eval' or similar dangerous patterns were found in the provided Python source code. Docker Compose configuration includes 'no-new-privileges:true' and resource limits. The README states 'Rate Limit Respect' but its implementation is not directly visible in the provided Python code, which is a minor point.

Updated: 2025-12-29GitHub→

Low Cost

chronos-mcp-server

by aadversteeg

Sec9

A time-related server providing timezone-aware date and time information via the Model Context Protocol (MCP).

Setup Requirements

⚠️.NET 9.0 SDK required for local development/deployment.
⚠️Docker required for container deployment.

Verified SafeView Analysis

The provided source code snippets (appsettings, launchSettings, README) do not contain executable logic that would introduce common security risks like 'eval' or obfuscation. Configuration is handled via standard .NET Core mechanisms (appsettings.json, environment variables). The server's functionality (providing date/time) is inherently low-risk. No hardcoded secrets were visible in the truncated code.

Updated: 2026-01-19GitHub→

High Cost

logseq-mcp-server

by eborden

Sec5

Provides an AI-accessible interface for a LogSeq knowledge graph, enabling LLMs to traverse the graph, track concepts over time, and build comprehensive context through specialized tools.

Setup Requirements

⚠️Requires LogSeq Desktop application to be running.
⚠️Requires LogSeq HTTP server to be enabled via LogSeq's settings (Settings → API → Enable HTTP server).
⚠️Requires a LogSeq authentication token to be generated and configured in `~/.logseq-mcp/config.json`.

Verified SafeView Analysis

The server constructs Datalog queries by directly embedding user-provided input (e.g., page names, topic names) into the query string. While inputs are lowercased, this pattern is generally susceptible to Datalog injection if a malicious actor (e.g., a compromised LLM or a user manipulating tool arguments) can craft specific inputs. However, the server is designed to run locally, accessing a user's local LogSeq instance, which significantly limits the impact of such a vulnerability to the user's own data.

Updated: 2026-01-09GitHub→

Low Cost

MCP-para-todo

by elsantiwg

Sec8

An educational MCP server that connects language models with external tools in real-time, focusing on providing real-world context and extending LLM capabilities.

Setup Requirements

⚠️Requires a WeatherAPI Key for the 'weather' tool functionality (free tier available).
⚠️The README suggests a WebSocket client connection (`ws://localhost:3000`), but the server code implements an HTTP POST endpoint (`http://localhost:3000/mcp`). This discrepancy might confuse users attempting to integrate.
⚠️The server, as coded in `src/mcp/server.ts`, currently only registers and exposes the 'weather' tool, despite the README listing 'word_definition' and 'evaluate_math' as implemented. Users wishing to use these other tools would need to modify `src/mcp/server.ts` to register them.
⚠️The 'mathTool' in `src/tools/math.ts` relies on the 'mathjs' library, but 'mathjs' is not listed in `package.json` dependencies. If the 'mathTool' were to be registered and used, it would lead to a runtime error unless 'mathjs' is manually installed.

Verified SafeView Analysis

The server loads API keys from environment variables, which is good practice. The `mathjs.evaluate` function, if used, is generally considered safe from arbitrary code execution according to its documentation as it does not access the global scope. No hardcoded secrets or 'eval' statements were found. Error messages could expose some internal details but are not critical vulnerabilities for this context. The server uses HTTP POST, not WebSockets, despite README examples.

Updated: 2025-11-27GitHub→

High Cost

Memo-MCP

by milasd

Sec8

Provides a local LLM Model Context Protocol (MCP) server for journaling with Retrieval-Augmented Generation (RAG) to search and retrieve personal memo and journal entries.

Setup Requirements

⚠️Requires Python 3.12+ to run.
⚠️Relies on `uv` package manager and `Task` (Taskfile) for setup and execution.
⚠️Memo data must follow a specific `data/memo/YYYY/MM/DD.md` folder structure, which needs to be manually prepared or generated.

Verified SafeView Analysis

The server is designed for local, personal use, communicating via standard I/O (stdio) with LLM clients. This greatly reduces network attack surface compared to a web-exposed service. Hardcoded secrets are not present; configurations like `qdrant_api_key` are optional environment variables and default to `None`. The use of `pickle.load` for FAISS and simple vector stores, while generally unsafe for untrusted data, is used here for self-generated, local persistence, which is a lower risk within the intended local application context. Privacy warnings are clearly stated for sensitive data when using external models. No 'eval' or obvious malicious patterns found.

Updated: 2025-11-23GitHub→

Medium Cost

teamwork-ai

by rafaeljusto

Sec2

The Assigner acts as a webhook server that listens for Teamwork.com task events, analyzing them using AI to assign tasks to users based on skills, job roles, costs, and workload, and then generates an explanatory comment.

Setup Requirements

⚠️Requires a Teamwork.com account and API token.
⚠️Requires configuration and potentially paid API access for an AI agent (Anthropic, OpenAI) or a running local Ollama server.
⚠️Requires a separate Model Context Protocol (MCP) server to be running and accessible for prompt retrieval (e.g., from github.com/teamwork/mcp).
⚠️Lack of webhook authenticity checks (no token/checksum validation) means anyone can trigger the server's actions.

Review RequiredView Analysis

CRITICAL: The server explicitly states in its documentation that 'there's no token or checksum check implemented in the server' for incoming webhooks. This means any unauthenticated external party can send POST requests to the `/teamwork-ai/webhooks/task` endpoint, potentially triggering unauthorized task assignments, comments, or denial-of-service through resource exhaustion. Sensitive API tokens (Teamwork, Anthropic, OpenAI) are handled via environment variables, which is a good practice. No 'eval' or obvious code obfuscation found. The Ollama DSN may include `username:password` in the URL, but the client implementation does not explicitly add Basic Auth headers, meaning these credentials would be ignored for authentication by the default HTTP client.

Updated: 2026-01-07GitHub→

Medium Cost

efatura-mcp-server

by reyhansunduk

Sec8

Integrate with the Turkish GİB e-Arşiv Fatura system to manage e-invoices via an MCP server.

Setup Requirements

⚠️Requires existing Turkish GİB e-Fatura credentials for real API usage (company registration needed).
⚠️Primarily designed for use with Claude Desktop or any compatible MCP client.
⚠️Python dependencies include `mcp`, `python-dotenv`, `pydantic`, and `pydantic-settings` which must be installed.

Verified SafeView Analysis

The project demonstrates strong security awareness, especially with the detailed `SECURITY.md` and the automatic fallback to a mock API if real GİB credentials are not properly configured or are placeholder values. Credentials are loaded from environment variables (`.env`). Network communication with GİB uses HTTPS for security. A minor concern is the potential logging of sensitive `e.response.text` in `gib_earsiv_client.py` during error handling, which could expose parts of a GİB error message if it contains sensitive data. There's also a discrepancy where `zeep` and `lxml` are listed as dependencies in `pyproject.toml` but are not directly used by the provided `gib_earsiv_client.py`, which instead uses `requests`.

Updated: 2025-12-05GitHub→

Medium Cost

webby-mcp

by cordlesssteve

Sec7

Comprehensive website validation for performance, accessibility, SEO, and security.

Setup Requirements

⚠️Requires API keys for GTmetrix and WAVE, and an email for SSL Labs for full functionality.
⚠️Requires downloading Playwright browser binaries (Chromium, Firefox, WebKit) during installation, which adds significant disk space (~1-2 GB) and network usage.
⚠️Requires outbound internet access to various external APIs (Google, GTmetrix, WAVE, Mozilla, SSL Labs) and target websites for browser automation.

Verified SafeView Analysis

The server performs extensive outbound network requests to various external APIs and utilizes Playwright for browser automation, interacting with arbitrary URLs. This inherently carries risks associated with fetching and processing external web content. While Playwright typically runs headless and in a sandbox, the interaction with potentially untrusted external websites requires careful deployment in a controlled and isolated environment. No specific 'eval' or obfuscation found in the provided documentation, but a full code review would be needed to confirm this.

Updated: 2025-11-17GitHub→

Medium Cost

grafana-mcp

by quanticsoul4772

Sec9

Provides AI-powered integration with Grafana instances via Model Context Protocol (MCP) tools for management and querying.

Setup Requirements

⚠️Requires access to a Grafana instance (v8.0+).
⚠️Requires a Grafana API key or Service Account Token with appropriate permissions (GRAFANA_TOKEN environment variable).
⚠️Requires Node.js 18+ with ES modules support and TypeScript 4.9+ for development/build.

Verified SafeView Analysis

The server demonstrates a strong security-first design, featuring automatic credential sanitization in logs and outputs (`security-utils.ts`), and robust error categorization to prevent sensitive internal details from being exposed to the user. It explicitly loads `GRAFANA_TOKEN` from environment variables, which is a recommended practice. TLS configuration with optional `GRAFANA_TLS_SKIP_VERIFY` provides control over certificate validation, although skipping verification should be used with caution in production. Input validation using Zod schemas adds a layer of protection against malformed requests. No 'eval' or other dynamic code execution from external, untrusted input was found.

Updated: 2025-11-23GitHub→

PreviousPage 237 of 760Next