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(8554)

0
0
High Cost
krishnab0841 icon

Multi_MCP_AI_Agent

by krishnab0841

Sec3

The Multi-MCP Intelligent Assistant enables natural language interaction with GitHub, Perplexity, Calendar, and Gmail by integrating multiple Model Context Protocol (MCP) servers.

Setup Requirements

  • ⚠️Requires API keys/credentials for integrated services (GitHub, Perplexity, Calendar, Gmail).
  • ⚠️Requires an API key for the underlying Large Language Model (LLM) (e.g., OpenAI, Anthropic, or other MCP-compatible LLMs), which may incur costs.
Review RequiredView Analysis
No source code for the server was provided for analysis, only the README.md file. Therefore, a comprehensive security audit of the server's implementation (e.g., checking for 'eval', hardcoded secrets, network risks, or malicious patterns) could not be performed. The score reflects the inability to assess the server's safety based on the provided information.
Updated: 2025-11-25GitHub→
0
0
Low Cost
betterhyq icon

honeycomb

by betterhyq

Sec8

A service configuration management platform based on Model Context Protocol (MCP), providing visual MCP service configuration and management.

Setup Requirements

  • ⚠️Requires Node.js >= 24.11.1 (or specific version from .nvmrc).
  • ⚠️Requires pnpm >= 10.25.0 (or specific version from package.json).
  • ⚠️Mandatory database initialization step: 'pnpm init-db' before first run.
  • ⚠️The Docker setup uses an internal JD.com pnpm registry (`http://registry.m.jd.com/`), which might not be accessible externally. Users might need to configure pnpm to use a public registry.
Verified SafeView Analysis
The project uses `dotenv` for environment variable management and has a specific CORS origin configured, which are good security practices. The `ToolModel` and database schema include a `callback` field of type `string` intended to store JavaScript code. However, in the provided server-side `mcp.ts` file, the actual MCP server `registerTool` method uses a fixed anonymous function, and the `tool.callback` string from the database is currently unused for execution. This means there is no immediate Remote Code Execution (RCE) vulnerability from `eval`ing user-controlled code in the provided snippets. This is a critical distinction from an earlier assessment. Future implementations that activate this `callback` string for dynamic execution would introduce a severe RCE risk without robust sandboxing. Standard web application vulnerabilities (e.g., XSS, CSRF, insecure dependencies) may still apply but cannot be fully assessed from truncated code.
Updated: 2026-01-19GitHub→
0
0
Low Cost
arvindand icon

mcp-scaffold

by arvindand

Sec9

A Maven plugin that generates Spring AI Model Context Protocol (MCP) tools from Spring Data JPA repositories and Spring services, enabling AI assistants to interact with the application's data layer.

Setup Requirements

  • ⚠️Requires Java 21+ for compilation and runtime.
  • ⚠️Maven 3.9+ is required, Gradle projects are not currently supported.
  • ⚠️The target application must be a Spring Data JPA application.
  • ⚠️Requires adding `mcp-annotations` and `spring-ai-starter-mcp-server-webmvc` dependencies to the project's `pom.xml`.
Verified SafeView Analysis
The MCP Scaffold Maven plugin itself is safe, focusing on build-time code generation using JavaParser and JavaPoet. It does not involve runtime 'eval' or obfuscation. The generated MCP tools, by design, provide direct access to the application's data layer. The documentation explicitly highlights this, advising users to implement authentication, restrict write operations using `filter.exclude-methods` (a feature the `suggest` goal aids in), and limit exposure to read-only functionality for AI clients. The `ReadOnlyDetector` and `suggest` goal actively contribute to identifying and preventing exposure of dangerous write operations.
Updated: 2026-01-17GitHub→
0
0
Low Cost
fancier21 icon
Sec8

Deploys a remote Model Context Protocol (MCP) server on Cloudflare Workers to expose simple calculator and random number generation tools without requiring authentication.

Setup Requirements

  • ⚠️Requires Node.js and npm to install dependencies and the Cloudflare Wrangler CLI for deployment and local development.
  • ⚠️Connecting to local MCP clients (e.g., Claude Desktop) requires an additional 'mcp-remote' proxy.
  • ⚠️The 'authless' nature means that if sensitive tools were added, external authentication/authorization would need to be implemented separately.
Verified SafeView Analysis
The server is explicitly 'authless', meaning it exposes its tools publicly without authentication, which is stated as its intended design. For the provided simple calculator and random number tools, this is low risk. Input validation for tool arguments is performed using Zod schemas, which helps mitigate common injection vulnerabilities. External network requests are made to drand.cloudflare.com, a trusted randomness beacon. No hardcoded secrets or obvious malicious patterns were found.
Updated: 2025-11-19GitHub→
0
0
Medium Cost
dvy246 icon

Mcp-server

by dvy246

Sec8

A Streamlit and CLI-based chat interface leveraging the Model Context Protocol (MCP) to connect Google's Gemini LLM with various tools and servers for tool-augmented conversational AI.

Setup Requirements

  • ⚠️Requires Google Gemini API Key (Paid)
  • ⚠️Python 3.10+ required
  • ⚠️Requires `uv` to run the default local math server configuration
Verified SafeView Analysis
The core application code appears secure, utilizing `yaml.safe_load` for configuration and loading API keys from environment variables. There are no obvious 'eval' or malicious patterns. However, the Model Context Protocol (MCP) design inherently involves executing external processes (local or remote) as 'tools' configured by the user (e.g., `MATH_SERVER_PATH`, `MANIM_SERVER_PATH`, or the remote `expense` server). While this is the intended functionality, it means the overall security depends heavily on the trustworthiness and proper securing of these external tools/servers that the application interacts with. Users must ensure that the configured server paths point to safe executables/scripts.
Updated: 2025-11-20GitHub→
0
0
Medium Cost
infanputra icon

nettune

by infanputra

Sec5

Nettune provides a client-side wrapper that downloads and runs a Go-based server in MCP stdio mode, enabling AI-assisted network diagnostics and TCP optimization for improved connection speeds and stability.

Setup Requirements

  • ⚠️The `nettune server` component requires root privileges (`sudo`) to operate, as it makes system-level modifications.
  • ⚠️An API key is required for client-server authentication. It is passed via command-line arguments, and users are warned to secure their shell history.
  • ⚠️The core server functionality for network optimization (sysctl, qdisc, systemd management) is Linux-specific, even though the client wrapper supports macOS/Windows.
Review RequiredView Analysis
The server component (`nettune server`) requires root privileges to modify system-level network configurations (sysctl, qdisc, systemd), which is a significant security consideration. The client-server communication uses HTTP with Bearer token authentication, but the README explicitly warns that TLS termination (e.g., via a reverse proxy) is recommended for production, implying non-encrypted communication by default. API keys are passed via command-line arguments, posing a risk if shell history or process lists are compromised. The Go adapters execute external commands (`tc`, `sysctl`, `systemctl`, `ip`), raising potential concerns for command injection if user-supplied profile parameters are not rigorously sanitized (though validation is present). The JavaScript wrapper downloads binaries from GitHub releases, and while it performs SHA256 checksum verification, the trust chain relies on GitHub's integrity. Running this server on an internet-exposed host without proper firewalling and TLS is highly risky.
Updated: 2026-01-19GitHub→
0
0
Low Cost
imvickykumar999 icon

MCP-Server-Client

by imvickykumar999

Sec9

Demonstrates a basic FastMCP server and client for exchanging model context, including tools, resources, and prompts, primarily for AI integration.

Setup Requirements

  • ⚠️Requires Python 3.8+.
  • ⚠️Requires `fastmcp` and `requests` Python libraries (install with `pip install fastmcp requests`).
  • ⚠️The FastMCP server must be running before the client can connect.
Verified SafeView Analysis
The server binds to `127.0.0.1` by default, limiting external exposure. No explicit use of `eval` or `exec` functions, hardcoded secrets, or obvious malicious patterns were found in the provided source code. It's a simple demonstration, making it relatively safe to run.
Updated: 2025-12-06GitHub→
0
0
Medium Cost
stilllovee icon

memory-mcp-server

by stilllovee

Sec7

Provides a Model Context Protocol (MCP) server for AI Agents to save and retrieve conversational summaries, enhancing cross-session context.

Setup Requirements

  • ⚠️Requires a Node.js runtime environment (version >=18 recommended due to SDK dependencies).
  • ⚠️The SQLite database file ('summaries.db') is created in the current working directory where the server is launched, which might require managing persistence if the server's working directory changes.
  • ⚠️The HTTP server endpoint lacks user authentication/authorization, making it unsuitable for secure multi-user or public-facing deployments without an external security layer.
Verified SafeView Analysis
No obvious malicious code, 'eval' usage, or hardcoded secrets were found. The server utilizes standard and well-maintained libraries. The HTTP transport exposes `save_summary` and `get_summaries` endpoints without built-in authentication or authorization, meaning any client with network access to the server can interact with the global summary database. This design implies a single-user or trusted local environment; using it in a multi-user or untrusted shared environment would pose a privacy and data integrity risk.
Updated: 2025-11-29GitHub→
0
0
High Cost
hkhkkh icon
Sec4

Provides Model Context Protocol (MCP) servers for real-time weather data retrieval and Stable Diffusion-based AI image generation and management.

Setup Requirements

  • ⚠️Requires local Stable Diffusion WebUI installed and running, accessible via API.
  • ⚠️Requires manual configuration of SD WebUI API URL and launcher path in `sd_mcp_server.py`.
  • ⚠️SD WebUI must be launched with the `--api` command-line argument.
Review RequiredView Analysis
The `sd_mcp_server.py` uses `subprocess.Popen` with `shell=True`, which is a security risk if the `SD_LAUNCHER_PATH` variable (though hardcoded/developer-configured) could be manipulated. More critically, the `img2img` and `interrogate_image` functions accept an `image_path` argument from user input and directly attempt to read local files (`os.path.exists` check is insufficient). This allows for arbitrary local file disclosure if a malicious actor can provide a path to an existing file on the server's machine, posing a significant information leakage risk.
Updated: 2025-11-27GitHub→
0
0
Low Cost
phuhduong icon

jigsaw-mcp

by phuhduong

Sec8

Provides a barebones Model Context Protocol server for Dedalus deployments, featuring a single greeting tool.

Setup Requirements

  • ⚠️Requires Node.js (v18+ recommended based on `package-lock.json` engine requirements).
  • ⚠️Requires `npm install` and `npm run build` to compile TypeScript source code before running.
Verified SafeView Analysis
The server uses the `@modelcontextprotocol/sdk` and does not appear to implement any inherently dangerous operations directly (like `eval`, arbitrary shell execution, or sensitive file system access beyond what the SDK might abstractly require). Input validation for the 'hello' tool is present but basic. No hardcoded secrets were found. The primary security considerations would be potential vulnerabilities within the `@modelcontextprotocol/sdk` itself or how clients utilize the exposed tools.
Updated: 2025-11-20GitHub→
0
0
Low Cost
hyperion14 icon

docx-mcp-service

by hyperion14

Sec7

Generates BHK-formatted Word documents from Markdown text, optimized for integration with Mistral Chat via the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Docker and Docker Compose are essential prerequisites for running this service.
  • ⚠️Nginx is required for production deployment to handle reverse proxying, SSL/TLS termination, and correct routing for SSE transport and file downloads.
  • ⚠️The `DOCKER_API_KEY` and `PUBLIC_URL` environment variables must be configured in the `.env` file; a default API key will be used if `DOCKER_API_KEY` is not set, posing a security risk.
  • ⚠️The `templates/bhk-base.docx` file must be present in the `templates/` directory for BHK formatting to function correctly.
Verified SafeView Analysis
The project uses API key authentication for critical endpoints, which is a good practice. File handling for uploads and downloads appears robust against common path traversal attacks. However, the default API key 'YOUR_API_KEY' in `app.py` is a significant security risk if not changed in a production environment. Additionally, the Nginx configuration for CORS (`Access-Control-Allow-Origin '*'`) is wide open and should be restricted to `https://chat.mistral.ai` in production as noted in `NGINX_SETUP.md`. No obvious malicious patterns or usage of `eval` were found.
Updated: 2025-12-27GitHub→
0
0
High Cost
AndreChuabio icon

mcp-yfinance-server

by AndreChuabio

Sec3

A comprehensive financial analysis suite providing real-time sentiment analysis, stock data, and paper trading functionality, designed for integration with Model Context Protocol (MCP) clients like Claude Desktop.

Setup Requirements

  • ⚠️Requires multiple API keys from various external services (Google Gemini, Alpha Vantage, NewsAPI, Reddit, Financial Modeling Prep, Paper Invest), many of which have strict free-tier rate limits.
  • ⚠️Requires a running MongoDB instance and its connection URI configured, adding a significant infrastructure prerequisite.
  • ⚠️The sentiment analysis component uses Google Gemini AI, which can incur significant token costs, especially with batch processing or frequent queries.
  • ⚠️Dual server architecture: Node.js for sentiment analysis (npm start) and Python for MCP tools/Paper Trading (python mcp_yfinance_server.py), requiring setup for both environments.
Review RequiredView Analysis
The provided `claude_desktop_config.json` file, listed as part of the source code for analysis, contains hardcoded Paper Invest API credentials (`paper_API_KEY`, `paper_account_ID`, `paper_portfolio_ID`). While the server code itself loads these from environment variables (a better practice), the inclusion of actual credentials in a configuration file within a repository is a severe security risk. Sharing or committing such a file would expose sensitive API keys, making it unsafe. Reliance on multiple external APIs (Google Gemini, Alpha Vantage, NewsAPI, Reddit, Paper Invest, yfinance, MongoDB) increases the overall attack surface, though API key management via `.env` helps mitigate this if secrets are not hardcoded elsewhere.
Updated: 2026-01-08GitHub→
PreviousPage 318 of 713Next