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
Low Cost
agaro icon

mcp-exercise

by agaro

Sec9

Provides basic arithmetic operations as a Model Context Protocol (MCP) API server over HTTP.

Setup Requirements

  • ⚠️Requires Python 3.11+
Verified SafeView Analysis
The server code is straightforward, implementing simple arithmetic functions. It includes basic input validation for division by zero. No use of dangerous functions like 'eval' or dynamic code execution was found. The setup scripts are standard bash commands for environment and Docker management. Binding to 0.0.0.0 is common for server applications and not a security flaw itself, though network access should be controlled in production.
Updated: 2025-11-20GitHub→
0
0
Low Cost
dgarcoe icon

dx_cluster_mcp

by dgarcoe

Sec9

A server to enable MCP clients like Claude Desktop to interact with Ham Radio DX Clusters for operations such as reading, posting, and analyzing DX spots.

Setup Requirements

  • ⚠️Requires Docker and Docker Compose.
  • ⚠️User MUST generate a secure random API key and set their Ham Radio Callsign in the .env file.
  • ⚠️An external Docker network named 'ea1rfi-network' must be created manually before starting the server.
  • ⚠️Requires Node.js and npm on the client machine for MCP Proxy if connecting remotely from Windows.
Verified SafeView Analysis
The project demonstrates good security awareness, implementing API Key authentication and providing strong warnings in the documentation about changing the default API key to a secure random string. It also recommends using HTTPS with a reverse proxy and firewalling. The server binds to 0.0.0.0 within its Docker container, which is standard but requires host-level firewalling. The use of Telnet for DX Cluster communication is an inherent characteristic of the DX Cluster protocol and not a vulnerability introduced by this server.
Updated: 2026-01-16GitHub→
0
0
Low Cost
splitpierre icon

directus-mcp-server

by splitpierre

Sec8

This server bridges AI agents (e.g., from Windsurf/Antigravity IDE) to a Directus instance using the Model Context Protocol (MCP), allowing AI agents to interact with Directus data.

Setup Requirements

  • ⚠️Requires a running Directus instance with an accessible /mcp endpoint.
  • ⚠️A Directus API token (`DIRECTUS_TOKEN`) with appropriate permissions is mandatory.
  • ⚠️If Directus is on localhost, the `--network=host` flag is often required for Docker usage.
Verified SafeView Analysis
The server acts as a proxy, forwarding JSON-RPC messages. Security relies on the secure handling of the `DIRECTUS_TOKEN` environment variable and the inherent security of the upstream Directus instance's MCP endpoint. The code itself does not introduce obvious vulnerabilities like `eval` from user input or hardcoded secrets (other than the required token in env).
Updated: 2025-12-05GitHub→
0
0
Low Cost
yashdaware icon

remote-mcp-server

by yashdaware

Sec3

Provides a server component for a remote management, control, or data processing system.

Review RequiredView Analysis
No source code was provided for analysis beyond the README.md file. Therefore, a comprehensive security audit could not be performed. The score reflects the high uncertainty and inability to verify the safety of the server's implementation or identify potential vulnerabilities, rather than an assessment of actual code. Specific risks like 'eval', obfuscation, network vulnerabilities, or hardcoded secrets could neither be confirmed nor ruled out.
Updated: 2025-11-30GitHub→
0
0
Low Cost
iwm57 icon

mcp-server

by iwm57

Sec4

An MCP server to expose Actual Budget financial functionality as callable tools, bridging an MCP client to an Actual Budget backend via actual-bridge.

Setup Requirements

  • ⚠️Requires 'actual-bridge' (Node.js application) to be running and accessible via the configured `ACTUAL_BRIDGE_URL`.
  • ⚠️Requires Python 3.9 or newer.
  • ⚠️Configuration is dependent on environment variables loaded from a `.env` file (e.g., `ACTUAL_BRIDGE_URL`).
Verified SafeView Analysis
The `httpx.AsyncClient` is initialized with `verify=False` to skip SSL verification for the actual-bridge communication. While this might be intended for self-signed certificates in a controlled environment, it can lead to Man-in-the-Middle (MITM) vulnerabilities if the `ACTUAL_BRIDGE_URL` points to an untrusted endpoint or if the network is not secure. This significantly reduces the security posture for network communication. Other aspects like `eval` or hardcoded secrets are not present.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
choseongje66 icon
Sec3

Provides a web-based chat client for interacting with public data via an MCP (Multi-Cloud Platform) and LLM.

Setup Requirements

  • ⚠️Requires a MySQL 8.0.44+ server instance with a configured database user and schema. Initial database migration (`npx prisma migrate dev`) is required.
  • ⚠️Requires a running MCP (Multi-Cloud Platform) / LLM server accessible at the configured `MCP_BASE_URL` (defaults to `http://localhost:3000`). This LLM backend is expected to serve a model named `gpt-oss:20b-cloud` as indicated in the chat service.
  • ⚠️The `JWT_SECRET` environment variable must be set to a strong, unique secret to prevent the use of the hardcoded 'devsecret' fallback, which is a critical security risk.
Review RequiredView Analysis
CRITICAL: The backend uses a hardcoded fallback JWT_SECRET 'devsecret' if the `JWT_SECRET` environment variable is not explicitly set. This is a severe vulnerability that makes the authentication easily bypassable. JWT tokens are stored in the browser's localStorage, which is susceptible to Cross-Site Scripting (XSS) attacks if other parts of the frontend are vulnerable. While the frontend uses `ReactMarkdown` with `rehype-highlight` for rendering LLM responses, direct streaming of potentially untrusted LLM output from the MCP to the client could theoretically pose risks if the markdown rendering or sanitization is not robust against all forms of injection, though `ReactMarkdown` typically offers good default protection.
Updated: 2025-11-19GitHub→
0
0
Medium Cost
Sec7

A high-performance MCP server for storing and searching textual 'memories' using GitHub repositories or local filesystems, with features like full-text search, encryption, and project management.

Setup Requirements

  • ⚠️Requires a GitHub Personal Access Token with 'repo' scope for GitHub storage (Paid account not strictly required, but GitHub's free tier has limitations).
  • ⚠️Building requires Rust 1.89.0+ and specific Cargo features (`backend-github, index-tantivy, encryption, mcp-gitmem-storage-github/remote-git`) for a full-featured setup.
  • ⚠️macOS users may encounter a 'Killed: 9' error requiring a specific security fix script (`./scripts/fix-macos-security.sh`).
Verified SafeView Analysis
The server requires a GitHub Personal Access Token (PAT) with a broad 'repo' scope for GitHub storage. Mismanagement or compromise of this token could lead to unauthorized repository access or data exfiltration, especially with 'auto_push' enabled. While it offers optional end-to-end encryption for memories, credentials stored via environment variables are less secure than OS keychain. The local stdio transport is secure, but a WebSocket transport could introduce network risks if not properly secured.
Updated: 2025-11-17GitHub→
0
0
Low Cost

hippocamp

by thinkingidentities

Sec9

Provides persistent, graph-based episodic and semantic memory for AI agents, integrating with LLMs like Claude via the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires a local Neo4j 5.x instance running on bolt://localhost:7688.
  • ⚠️Requires a local Redis instance running on localhost:6379.
  • ⚠️Requires an existing Nessie SQLite database or custom data for initial population, otherwise the memory graph will be empty.
Verified SafeView Analysis
The project is designed for local/internal use, connecting to local Neo4j and Redis instances. Integration with Claude uses 'stdio transport', which is a secure method for local inter-process communication. No 'eval' or obfuscation is indicated. Future 'Memory Commons' vision suggests distributed networks but current implementation is local.
Updated: 2025-11-18GitHub→
0
0
High Cost
shibicr93 icon
Sec9

Generates performance test plans and scripts (Gatling, JMeter) by analyzing OpenAPI specifications using an MCP server and integrating with LLMs.

Setup Requirements

  • ⚠️Requires Java Development Kit (JDK 21+) and Maven 3.9+.
  • ⚠️Requires an MCP client (e.g., `mcp-inspector`) to interact with the server's exposed tools.
  • ⚠️The MCP client must be configured with access to a large language model (LLM), such as Anthropic's Claude (as hinted in `GatlingTestGeneratorHandler`), to utilize the code generation features. This implies associated API costs.
Verified SafeView Analysis
The server primarily acts as a tool provider within the Model Context Protocol (MCP) framework. It does not directly execute generated code or external commands. The `GatlingTestGeneratorHandler` constructs prompts for LLM-based code generation (via the MCP client), which presents an inherent risk of LLM prompt injection if user-provided 'scenarios' data is not properly validated/sanitized by upstream components. However, the generated code is returned to the client, not executed by the server itself. The internal Java logic for scenario generation appears safe. No 'eval', hardcoded secrets, or direct external command execution were found in the provided source code.
Updated: 2026-01-18GitHub→
0
0
High Cost
ivandon15 icon

repocaster

by ivandon15

Sec6

Automatically transforms existing GitHub repositories or local codebases, especially computational biology tools, into AI-accessible Model Context Protocol (MCP) servers.

Setup Requirements

  • ⚠️Requires a paid LLM API key (e.g., OpenAI, DeepSeek, Qwen, configured via environment variables).
  • ⚠️Requires `git` to be installed on the host system for cloning remote repositories.
  • ⚠️Requires the `mcp` Python library to be installed to run the *generated* MCP servers.
Review RequiredView Analysis
The system heavily relies on `subprocess.run` to execute Python scripts from the target repository. While `subprocess.run` is used with a list (mitigating direct shell injection via arguments in `server.py`), the fundamental risk comes from the quality and safety of the target repository's scripts themselves, and the LLM's ability to correctly and safely interpret and expose arguments. Malicious input via the MCP interface could still potentially exploit vulnerabilities in the underlying target scripts if they perform unsafe operations (e.g., `os.system` or `subprocess.run(..., shell=True)` internally with untrusted input). The process inherently involves executing code from a cloned repository, which necessitates user vigilance over the source repository's trustworthiness.
Updated: 2025-12-03GitHub→
0
0
High Cost
wx-b icon
Sec7

A Model Context Protocol (MCP) server that implements Recursive Language Models (RLM) for solving long-context problems by programmatically probing, recursing, and synthesizing over large codebases or documents.

Setup Requirements

  • ⚠️Requires Python 3.12+ and 'uv' (recommended) or 'pip' for dependency management.
  • ⚠️Docker is highly recommended (and default) for safe sandboxed execution of LLM-generated code. Running with 'environment: local' directly on the host carries significant risk.
  • ⚠️Requires API keys (e.g., OPENROUTER_API_KEY, OPENAI_API_KEY) for cloud providers, or a locally running Ollama/vLLM server for local inference. RLM works by making multiple recursive LLM calls, which can lead to significant API costs, especially with large models. Cost monitoring and usage limits are crucial.
Verified SafeView Analysis
The server's core functionality involves executing LLM-generated code (`rlm.core.rlm.RLM`) to probe context. While this inherently carries execution risk, the project is highly transparent about it, strongly recommends and defaults to a Docker sandbox for execution (`environment: docker`), and enforces API key management via environment variables (no hardcoded secrets). File ingestion (`rlm_mcp_server/ingest.py`) also enforces repo boundaries to prevent path traversal. The use of `ast.literal_eval` for parsing LLM output, while safer than `eval`, is a point of note for output processing.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
deepaktewari2000 icon

Finance-MCP-Server

by deepaktewari2000

Sec8

A Python FastAPI server exposing financial data and portfolio calculation tools for LLM integration.

Setup Requirements

  • ⚠️Requires MCP_API_KEY environment variable to be set (defaults to 'secret123' if not).
  • ⚠️Relies on external public APIs (CoinGecko, exchangerate.host, Yahoo Finance via yfinance) which may have rate limits or availability issues.
Verified SafeView Analysis
The server uses a hardcoded default API key 'secret123' if the MCP_API_KEY environment variable is not set, which is acceptable for quickstart but a significant security risk for production. It relies on external public APIs (yfinance, CoinGecko, exchangerate.host) which are generally safe but may have rate limits or availability issues. Input validation is present for required fields, but no comprehensive schema validation is enforced at the invocation layer. No 'eval' or other highly dangerous dynamic code execution patterns were found.
Updated: 2025-11-20GitHub→
PreviousPage 602 of 760Next