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)

Medium Cost

dev-kit-gh-mcp-server

by DanielAvdar

Sec2

A GitHub Model Context Protocol (MCP) server designed for automation, bots, and AI agents to perform focused repository operations.

Setup Requirements

⚠️Requires `GITHUB_TOKEN` environment variable for GitHub API authentication (GitHub account required).
⚠️Requires `uv` for development setup (`pipx install uv`).
⚠️Server requires a GitHub repository context, either as a URL or a local Git repository path.

Review RequiredView Analysis

The server uses `dev-kit-mcp-server` which, as indicated in `pyproject.toml`'s `[tool.dkmcp.factory.include]` section, registers tools for local filesystem operations (`create_dir`, `move_dir`, `remove_file`, `rename_file`) and command execution (`exec_make_target`, `predefined_commands`). This means that any client or AI agent interacting with this MCP server could potentially execute arbitrary commands or manipulate the host's filesystem. While GitHub API interactions are authenticated via `GITHUB_TOKEN` (which is sourced from environment variables, not hardcoded), the exposure of host-level command execution and file system manipulation via the MCP interface is a critical security risk if not run in a highly sandboxed and authenticated environment. There is no clear justification for `eval` or obfuscation, and network risks are inherent to any server exposing such capabilities.

Updated: 2026-01-16GitHub→

Low Cost

Rule-MCP-Server

by AkitoSakurabaCreator

Sec8

A Model Context Protocol (MCP) server that enables AI agents (Cursor, Claude Code, Cline) to retrieve and apply common coding rules across projects.

Setup Requirements

⚠️Requires Docker and Docker Compose for easy deployment and development environment setup.
⚠️Requires Go 1.21+ and Node.js 18+ (with pnpm) for local development without Docker.
⚠️Requires a PostgreSQL database for persistent storage.
⚠️Production setup requires careful configuration of environment variables such as a strong `JWT_SECRET` and `ALLOWED_ORIGINS`.

Verified SafeView Analysis

The project demonstrates a strong commitment to security with features like RBAC (Public, User, Admin roles), API key authentication with bcrypt hashing and expiration, password policies (min length, complex characters), rate limiting, and audit logging. It enforces HTTPS for API key usage in production. It also implements CORS configuration. While `docker-compose.dev.yml` contains default database credentials for development, the documentation clearly states that strong, random `JWT_SECRET` and `ALLOWED_ORIGINS` are required for production, and database credentials should be configured via environment variables. Frontend stores authentication tokens in localStorage, which is a common practice but has XSS attack implications. No explicit 'eval' or obvious malicious patterns were found in the provided code.

Updated: 2026-01-14GitHub→

High Cost

ATP-Rankings-API

by Jupiterian

Sec6

Provides an MCP server to allow AI assistants to query historical ATP tennis rankings data.

Setup Requirements

⚠️Requires `rankings.db` to be present; if not, you must run `python scripts/generate.py` (takes ~1 hour to build the entire database) or `python scripts/filler.py` (updates to latest data, faster) before running the server.
⚠️Requires Python 3.12 or newer, as specified in `runtime.txt` and `Dockerfile`.
⚠️Initial database population (via `generate.py` or `filler.py`) requires active internet connection to scrape data from `atptour.com`.

Verified SafeView Analysis

The server uses f-strings for SQLite table names in several database queries (e.g., `src/services.py`, `scripts/generate.py`, `scripts/filler.py`). While values are generally derived internally or validated against `sqlite_master`, this pattern is less robust against potential SQL injection than strictly parameterized queries for all components. Additionally, `src/main.py` uses `CORSMiddleware` with `allow_origins=["*"]`, which is a significant security risk for production deployments as it enables any domain to make cross-origin requests, requiring careful configuration for public access.

Updated: 2025-11-23GitHub→

High Cost

SCB-MCP

by isakskogstad

Sec9

Provides LLMs and AI chatbots access to official statistical data from Statistics Sweden (SCB) via the Model Context Protocol (MCP).

Setup Requirements

⚠️Requires Node.js 18+ to run locally.
⚠️Relies on the external Statistics Sweden (SCB) PxWebAPI 2.0.
⚠️Optimal search results for tables and variables are achieved by using Swedish search terms, which may require specific prompting or translation from the LLM.

Verified SafeView Analysis

The server demonstrates good security practices with robust input validation using Zod, explicit rate limiting for the upstream API, and local lookups to minimize external calls. It uses a wildcard CORS origin, which is acceptable for a public API tool. There are no clear indications of 'eval' or command injection vulnerabilities from user input. Error handling from the upstream SCB API is generally abstracted, reducing exposure of raw internal messages. The build script uses `execSync` but is not part of the runtime server, making it safe.

Updated: 2025-12-02GitHub→

High Cost

akshare_mcp

by wukan1986

Sec8

Provides an MCP server exposing selected AKShare financial data interfaces for client applications like LLMs.

Setup Requirements

⚠️Requires manual configuration (editing `config.py` or providing a custom one via `--config`) to whitelist/blacklist AKShare interfaces; otherwise, it exposes over 1000 functions which may overwhelm clients or consume too many LLM tokens.
⚠️Requires Python >=3.10.
⚠️Potential permission issues when attempting to modify the default `config.py` located in `site-packages`.

Verified SafeView Analysis

The server allows loading a configuration file from a user-specified local path using `importlib.util.spec_from_file_location`, which effectively executes Python code from that file. This is intended for local configuration and not a remote vulnerability, but users should ensure the specified configuration file is trusted.

Updated: 2025-11-20GitHub→

Medium Cost

nu-mcp

by ck3mp3r

Sec8

Serves as a Model Context Protocol (MCP) server, exposing Nushell capabilities and custom CLI tools (e.g., Kubernetes, Git, Tmux) to AI agents with a focus on security and path validation.

Setup Requirements

⚠️Requires Nushell (nu) to be installed and available in PATH.
⚠️Many extension tools require specific CLI binaries (e.g., `argocd`, `kubectl`, `gh`, `tmux`) to be installed and configured in PATH for their functionality.
⚠️Kubernetes-related tools (k8s, argocd) necessitate access to a Kubernetes cluster with a valid `kubeconfig`.

Verified SafeView Analysis

The server's core functionality involves executing arbitrary Nushell commands, either directly via `run_nushell` or through extension tools. This is a powerful capability that inherently requires strong security controls. The project implements a robust security sandbox, primarily through path validation (`src/security/mod.rs`), which aims to prevent path traversal attacks and restrict filesystem access to explicitly allowed directories (current working directory plus any `--add-path` arguments). It uses canonicalization to resolve symlinks and `..` components. A critical component is the `safe_command_patterns.txt` allowlist. Commands matching these regex patterns (e.g., `gh api`, `kubectl get /apis/`) bypass full path validation, as they are presumed to use non-filesystem path arguments. The documentation (`src/security/README.md`) explicitly warns against adding commands that access the filesystem to this list. Misconfigurations or outdated patterns in this allowlist could introduce vulnerabilities. Non-existent path-like strings outside the sandbox (e.g., API endpoints) are cached (`PathCache`) for performance, but the system explicitly ensures that *existing* files outside the sandbox are never cached and are always blocked. Network communication is handled by the executed Nushell commands/tools (e.g., `curl`), not the Rust server itself, which operates over standard I/O (stdio). Destructive operations in extension tools (e.g., `delete_application` in ArgoCD, `kill_pane` in Tmux) are designed to require explicit `force: true` parameters and/or operate within safety modes (`MCP_K8S_MODE`, `MCP_GITHUB_MODE`). No hardcoded secrets were identified in the Rust codebase; environment variables are used for configuration. Overall, the project demonstrates a strong commitment to security, but the inherent power of executing arbitrary commands necessitates careful management of the allowlist and understanding of the sandbox's boundaries.

Updated: 2026-01-19GitHub→

High Cost

evergreen-mcp-server

by evergreen-ci

Sec8

Enables AI assistants to interact with the Evergreen CI/CD platform for build analysis, project management, and debugging.

Setup Requirements

⚠️Requires authentication with Evergreen via `evergreen login` CLI tool to set up OIDC credentials.
⚠️Docker is the recommended and most straightforward deployment method, requiring Docker to be installed and running.
⚠️Evergreen CLI must be installed locally to perform the initial authentication.

Verified SafeView Analysis

The server loads authentication credentials (OIDC tokens or API keys) from local files (`~/.evergreen.yml`, `~/.kanopy/token-oidclogin.json`) or environment variables, which relies on the host system's security. It uses `pyjwt.decode` with `verify_signature=False` for extracting user ID from access tokens; however, this is explicitly commented as being for display/query purposes only, with actual authentication verification handled by the OIDC provider during token exchange. This is a justified, but notable, design decision.

Updated: 2026-01-15GitHub→

Medium Cost

claude-team-mcp

by guru111244

Sec8

A multi-agent MCP server designed for AI development teams to facilitate collaboration between various AI models (like GPT, Claude, Gemini) on complex coding and development tasks.

Setup Requirements

⚠️Requires API keys for at least one large language model provider (e.g., OpenAI, Anthropic, Gemini, or a custom proxy service), which typically involve usage costs.
⚠️Requires Node.js version 18 or higher to run the server.
⚠️Designed for integration with specific IDEs (Claude Code, Windsurf, Cursor) via Model Context Protocol (MCP) configuration, necessitating initial setup in the IDE's configuration file.

Verified SafeView Analysis

The server is designed to interact with external AI APIs (requiring API keys) and has capabilities to interact with the local filesystem (e.g., reading project files, analyzing structure, and generating code files). API keys are handled via environment variables or a configuration file, which is good practice. Network communication with AI providers is expected to use HTTPS. The primary security considerations involve securely managing API keys and carefully reviewing AI-generated code before execution, given the server's access to local project files. No 'eval', code obfuscation, or obvious malicious patterns were found in the provided source code.

Updated: 2026-01-19GitHub→

Low Cost

thebrain-mcp-server

by jqlts1

Sec3

Integrates TheBrain knowledge graph with AI assistants by providing a Model Context Protocol (MCP) server, a RESTful API, and a Spaced Repetition System (SRS) for efficient knowledge recall.

Setup Requirements

⚠️Requires 'THEBRAIN_API_KEY' and 'THEBRAIN_BRAIN_ID' from a paid TheBrain account.
⚠️Python 3.10 is specified for local development setup (via Conda).
⚠️Default weak password '123456' is active for API access if 'WEB_PASSWORD' environment variable is not explicitly configured, making it unsafe by default.

Review RequiredView Analysis

The server includes a hardcoded default password ('123456') for API authentication if the 'WEB_PASSWORD' environment variable is not explicitly set. This is a critical security vulnerability that could lead to unauthorized access. Additionally, the FastAPI CORS is configured to 'allow_origins=['*']', which permits cross-origin requests from any domain, posing a risk in production environments if not restricted. While API keys are read from environment variables, the default password significantly lowers the security posture.

Updated: 2026-01-19GitHub→

Medium Cost

vite-mcp

by broisnischal

Sec7

Provides a Model Context Protocol (MCP) server within a Vite development environment, enabling AI agents and other MCP clients to interact with and observe the browser's state and APIs in real-time.

Setup Requirements

⚠️Requires Vite dev server to be running (operates only in 'development' mode).
⚠️Requires a browser page to be open at the Vite dev server URL for the browser bridge and adapters to function.
⚠️For dynamically generated HTML (e.g., React Router, Remix), `import "virtual:mcp";` must be manually added at the very top of the app's entry file, along with `tsconfig.json` updates for TypeScript support.
⚠️The `zod` library is a mandatory peer dependency.

Verified SafeView Analysis

The plugin is designed for development environments, which influences its security posture. The MCP server endpoint `/__mcp` has `Access-Control-Allow-Origin: *`, which is typical for development servers but could be a risk if the server is accidentally exposed publicly without proper network restrictions or authentication. Adapters execute code within the browser context, which is the intended functionality. Input/output validation is enforced using Zod schemas, which is a strong positive. The serialization of adapter `handler` functions using `toString()` and subsequent (re)evaluation in the browser bridge, while used internally and for developer-provided functions, could be brittle or a vector for injection if not handled carefully, though no direct exploitable flaw is immediately apparent given the typical use case where the developer controls the plugin configuration.

Updated: 2026-01-07GitHub→

Medium Cost

memory-mcp-server

by Sinhan88

Sec3

Provides long-term memory and context storage/retrieval for Large Language Models (LLMs) via an API, adhering to the Model Context Protocol (MCP).

Setup Requirements

⚠️Requires Python and pip installed

Review RequiredView Analysis

The actual Python source code (e.g., `app.py`, `requirements.txt`) for the server logic was not provided for analysis. Therefore, a comprehensive security audit for vulnerabilities like `eval` usage, obfuscation, insecure network practices, lack of input validation, or hardcoded secrets could not be performed. The score reflects the unknown security posture due to lack of code visibility rather than identified flaws.

Updated: 2025-12-15GitHub→

Medium Cost

mcp-evernote

by verygoodplugins

Sec9

Seamless integration with Evernote for note management, organization, and knowledge capture via Model Context Protocol.

Setup Requirements

⚠️Requires Evernote API Consumer Key and Consumer Secret, which must be obtained from Evernote Developers (dev.evernote.com).
⚠️For Claude Desktop users, a local server is run on port 3000 (default) for the OAuth callback, which must be available.
⚠️Requires Node.js version 18.0.0 or higher.

Verified SafeView Analysis

The server securely handles Evernote OAuth tokens, storing them locally or using environment variables, with explicit warnings against committing secrets. The `auth-standalone.ts` script runs a local Express server on `localhost` for the OAuth callback, which is a standard and safe practice for local authentication flows. The server supports user-configured webhooks for change notifications (`EVERNOTE_WEBHOOK_URL`). While this involves making outbound network requests to a user-defined URL, the functionality is documented and the responsibility for ensuring the webhook endpoint's trustworthiness lies with the user. The data sent to webhooks is specific Evernote change data (GUIDs, titles, timestamps), not broader sensitive system information. No `eval` or code obfuscation was found, and the codebase appears clean.

Updated: 2026-01-19GitHub→

PreviousPage 186 of 760Next