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
Low Cost
Traia-IO icon

test-mcp-server

by Traia-IO

Sec7

This MCP server provides a standardized interface for AI agents and LLMs to interact with the CoinMarketCap API, leveraging the Model Context Protocol (MCP) for tool exposure and D402 for payment processing.

Setup Requirements

  • ⚠️SERVER_ADDRESS, MCP_OPERATOR_PRIVATE_KEY, and D402_FACILITATOR_URL (unless D402_TESTING_MODE is true) are mandatory environment variables that must be configured for the D402 payment protocol to function correctly. The local run script attempts to generate some of these, but they need careful handling in production.
  • ⚠️Requires Python 3.12+ as specified in `pyproject.toml`.
  • ⚠️The build process for local development (using `run_local_docker.sh`) involves temporary modification of `pyproject.toml` and copying a local `IATP` repository, adding complexity to the environment setup. Ensuring the `IATP` repository is correctly located or accessible (`LOCAL_IATP_PATH` environment variable) is crucial.
  • ⚠️The `docker-compose.yml` file configures the container to expose port 8080, while the `server.py` and `run_local_docker.sh` scripts default to running the server on port 8000. If using `docker-compose up` directly, this port mismatch could lead to connectivity issues unless adjusted in the `.env` file or `docker-compose.yml`.
Verified SafeView Analysis
1. The server uses a very permissive CORS configuration (`allow_origins=["*"]`, `allow_methods=["*"]`, `allow_headers=["*"]`). While this might be acceptable for some public-facing APIs or development, in general, it is recommended to restrict origins to known client domains to prevent potential cross-site request forgery (CSRF) or other browser-based attacks. 2. The `run_local_docker.sh` script automatically generates `SERVER_ADDRESS` and `MCP_OPERATOR_PRIVATE_KEY` for local testing if they are not already set in the `.env` file. While convenient for local development, this approach is *critically insecure* for production environments. In production, these sensitive keys must be securely provisioned via a secrets management system, not generated or hardcoded. 3. The `MCP_OPERATOR_PRIVATE_KEY` is a highly sensitive credential used for signing settlement attestations in the D402 payment protocol. Its compromise would directly impact the integrity of payment processing for the server. 4. The tool implementations in `server.py` call the CoinMarketCap API using `requests.get`. However, the provided code for these tool functions *does not send any authentication headers* (e.g., `X-CMC_PRO_API_KEY`) to the CoinMarketCap API. This, combined with `deployment_params.json` stating `"requires_api_key": false` for the MCP server, implies these tools will likely fail to retrieve data from CoinMarketCap's *Pro* API, which typically requires an API key for most endpoints. This is a functional flaw, not a direct security vulnerability of the MCP server, but it impacts the server's utility.
Updated: 2026-01-05GitHub→
0
0
Low Cost
Koneisto icon

no-as-a-service

by Koneisto

Sec9

Provides a REST API and an MCP (Model Context Protocol) server for AI assistants to retrieve over 1,000 creative rejection responses across various categories.

Setup Requirements

  • ⚠️Integrating with AI assistants like Claude Desktop or Cursor requires a local installation of the MCP server as a Node.js proxy, due to their stdio transport requirements.
  • ⚠️Cloudflare Workers deployment necessitates manually creating KV (Key-Value) namespaces (REASONS_KV, RATE_LIMIT_KV) and updating 'wrangler.toml' with their generated IDs.
  • ⚠️The core functionality relies on a 'reasons.json' file; ensuring this file is correctly loaded (either from the filesystem for Node.js/Express or uploaded to KV for Workers) is critical.
Verified SafeView Analysis
The server implements strong security practices including Helmet.js for security headers, configurable CORS, and IP-based rate limiting. It uses environment variables for configuration and provides clear documentation on secure deployment. Input validation is performed using Zod in the MCP server. Docker deployments run as a non-root user. No obvious 'eval' or direct shell execution of untrusted input was found. Proper handling for JSON parsing errors is present.
Updated: 2025-12-08GitHub→
0
0
High Cost
token-druid609op icon
Sec9

Provides real-time web search and AI-powered content recommendations from various data sources for AI agents.

Setup Requirements

  • ⚠️Requires a Dappier API Key, which needs to be obtained by signing up on their platform.
  • ⚠️Requires 'uv' to be installed for running via 'uvx'.
  • ⚠️The full path to 'uvx' might be needed in client configurations depending on the system's PATH.
Verified SafeView Analysis
The server correctly uses environment variables for the API key. No direct use of 'eval' or other highly dangerous functions detected. It acts as a wrapper for an external API (Dappier), so external network interaction is central to its function. The security of the underlying Dappier API is external to this code review.
Updated: 2025-12-06GitHub→
0
0
Medium Cost
livhg icon
Sec8

Provides a tutorial project for building AI Agent tools using the Model Context Protocol (MCP) and FastMCP framework, demonstrating currency conversion, RAG, and AI sampling functionalities.

Setup Requirements

  • ⚠️Requires 'txtai' Python package for RAG functionality.
  • ⚠️Requires Node.js and 'npx' to run '@modelcontextprotocol/inspector' for testing and interaction.
  • ⚠️The 'sampling' functionality implicitly relies on the calling AI Agent client to have an active connection to an LLM and configured API keys.
Verified SafeView Analysis
The server runs on localhost by default, limiting external exposure. No explicit hardcoded secrets or 'eval' statements are present. The 'sampling' feature sends prompts to an external AI via the calling client, which could present prompt injection risks if inputs to the server are untrusted and then passed directly to the LLM.
Updated: 2025-12-19GitHub→
0
0
High Cost
jbandu icon
Sec9

Provides a standardized, real-time interface for comprehensive airline fleet data management, scraping, and analytics for operational applications.

Setup Requirements

  • ⚠️Requires local Ollama to be running for development-time LLM inference (e.g., `ollama serve` and `ollama pull llama3.2`).
  • ⚠️Requires a PostgreSQL database to be configured and accessible via `POSTGRES_URL`.
  • ⚠️Requires Playwright's browser dependencies to be installed (`npx playwright install --with-deps`) or running within a Docker environment.
Verified SafeView Analysis
The server implements a robust security middleware stack including Helmet, Zod-based input validation with SQL injection/XSS detection, API key authentication (with bcrypt hashing and RBAC), token bucket rate limiting, and comprehensive audit logging with sensitive data redaction. While strong, production deployment requires careful management of API keys, enabling PostgreSQL SSL with certificate validation (currently `rejectUnauthorized: false`), and implementing a dedicated secret management solution. There are no obvious `eval` or malicious patterns found.
Updated: 2025-11-30GitHub→
0
0
High Cost
Porkbutts icon

wyze-mcp-server

by Porkbutts

Sec8

An MCP (Model Context Protocol) server for controlling Wyze smart home devices, allowing AI assistants to list, monitor, and control various devices.

Setup Requirements

  • ⚠️Requires Node.js 18 or higher.
  • ⚠️Requires a Wyze account with devices and API credentials (email, password, API key, key ID) obtained from developer-api-console.wyze.com, set as environment variables.
  • ⚠️MFA (Multi-Factor Authentication) is not currently supported for Wyze accounts; it must be disabled or an account without MFA used.
Verified SafeView Analysis
The server correctly loads user-specific Wyze credentials (email, password, API key, key ID) from environment variables. Input validation is performed using Zod schemas for all tool parameters, which is a good practice. No 'eval' or direct arbitrary command execution is observed. Password hashing uses triple MD5, which is generally considered weak for new password storage, but in this context, it's likely a requirement to match the expected format of the reverse-engineered Wyze API for login. Several API keys (AUTH_API_KEY, FORD_APP_KEY, FORD_APP_SECRET, OLIVE_SIGNING_SECRET, OLIVE_APP_ID) are hardcoded in `src/constants.ts`. These appear to be client identifiers for the Wyze platform's internal APIs, reverse-engineered from the official Wyze app, rather than user-specific secrets. While hardcoding client identifiers is not ideal, it's less critical than hardcoding user credentials. The disclaimer notes that the implementation is based on reverse-engineered APIs, which introduces inherent fragility and a potential for unexpected behavior or vulnerabilities if Wyze's internal APIs change.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
TransitionMatrix icon

godot-dap-mcp-server

by TransitionMatrix

Sec9

An MCP (Model Context Protocol) server that enables AI agents to perform interactive runtime debugging of Godot games via the Debug Adapter Protocol (DAP).

Setup Requirements

  • ⚠️Requires Godot editor (4.3+) to be running with its DAP server enabled on a specified port (default 6006).
  • ⚠️For automated testing and scenario running, the 'GODOT_BIN' environment variable must be set to the absolute path of the Godot executable.
Verified SafeView Analysis
The server's architecture is designed to bridge a client (like an AI agent) to Godot's Debug Adapter Protocol (DAP) server. Communication with the MCP client is via stdio, and with Godot's DAP server via TCP on localhost (default port 6006). This local-only network interaction inherently limits remote attack surface. No hardcoded secrets were found. The Go codebase emphasizes robust error handling and timeout protection. Bash scripts are straightforward and use safe practices (`set -euo pipefail`). The core functionality of processing debug information does not involve direct execution of untrusted code in a way that would expose severe vulnerabilities within the server itself. Overall, it appears safe for its intended local bridge purpose.
Updated: 2025-12-05GitHub→
0
0
Low Cost
VSC-NeuroPilot icon

neuro-mcp-relay-registry

by VSC-NeuroPilot

Sec6

A permissions-based, controllable MCP Relay & Registry server for NeuroPilot and NeuroMCP.

Setup Requirements

  • ⚠️Requires pnpm package manager.
  • ⚠️Requires Node.js 20 or higher.
  • ⚠️Uses a 'nitro-nightly' build, which may be unstable.
Verified SafeView Analysis
The core "permissions-based" and "controllable" aspects of the MCP Relay & Registry functionality are explicitly stated as "not yet implemented" in the `server/server.ts` file and listed as "MVP" items in `TODO.md`. This means crucial security features like authorization and robust input validation for a relay/registry are currently missing from the implementation. Reliance on a `nitro-nightly` build for a server framework can introduce instability or undiscovered vulnerabilities. Future features listed in `TODO.md` (e.g., importing other MCP config sources, searching other registries, server chaining) introduce significant security risks if not implemented with stringent validation, authentication, and isolation. The provided code does not expose sensitive internal information or hardcoded secrets.
Updated: 2025-12-24GitHub→
0
0
Low Cost
DimbongCHOI icon

mcp_poke_server

by DimbongCHOI

Sec8

This server provides a Pokémon information API and acts as a tool for an AI chatbot via the Model Context Protocol (MCP), supporting both direct API calls and MCP-orchestrated interactions.

Setup Requirements

  • ⚠️Requires Node.js runtime
  • ⚠️Relies on external PokeAPI (pokeapi.co) for data
  • ⚠️Designed to interact with the Model Context Protocol (MCP) ecosystem
Verified SafeView Analysis
CORS configuration in `src/web-server.js` allows requests with no origin (`if (!origin) { return callback(null, true); }`), which is noted as a 'development convenience' but could expose the server to broader access than intended in a production environment. Otherwise, standard practices like input validation (JSONRPCMessageSchema) and body size limits are in place. No obvious hardcoded secrets or malicious patterns were found.
Updated: 2025-11-19GitHub→
0
0
Low Cost
BhagyeshPatil2004 icon

MCP-Server-Projects

by BhagyeshPatil2004

Sec9

This server integrates with Google Calendar to manage events (list, add, delete) directly through Claude, enabling personal productivity and scheduling assistance.

Setup Requirements

  • ⚠️Requires a Google Cloud Project with the Google Calendar API enabled and an OAuth 2.0 Client ID (downloaded as `credentials.json`).
  • ⚠️The first run requires manual browser interaction for Google account authorization and consent.
  • ⚠️Requires Python 3.10 or higher.
Verified SafeView Analysis
The server uses the standard Google OAuth 2.0 flow for desktop applications, requiring the user to obtain and manage `credentials.json` and `token.json` files locally. No hardcoded secrets or 'eval' usage are present. Input validation for `start_time` and `end_time` in `add_event` is basic but sufficient as Google Calendar API handles robust date parsing.
Updated: 2025-12-11GitHub→
0
0
Medium Cost
zademy icon
Sec8

Provides current and daily weather forecasts for specified locations or geographic coordinates using the Open-Meteo API.

Setup Requirements

  • ⚠️Requires Java Development Kit (JDK) to build and run the application.
  • ⚠️The project needs to be built (e.g., using Maven or Gradle) to produce the executable JAR file (`target/weather-0.0.1-SNAPSHOT.jar`) before it can be run.
  • ⚠️The `mcp.json` file specifies an absolute JAR path (`/Users/sadot/...`), which will need to be updated to a relative path like `target/weather-0.0.1-SNAPSHOT.jar` or an appropriate absolute path for your environment.
Verified SafeView Analysis
The server uses standard Spring Boot and RestClient for external API calls to a public, free weather API (Open-Meteo). No hardcoded secrets, 'eval' functions, obfuscation, or obvious malicious patterns were found in the provided source code. URL construction for API calls appears robust for its purpose. The manual JSON string construction in `formatWeatherResponse` and custom `escapeJson` method are functional for the current data but generally less robust than using an `ObjectMapper` for full object serialization, though this isn't a direct security vulnerability in this context.
Updated: 2026-01-19GitHub→
0
0
Low Cost
toms74209200 icon

mcp-gitmoji

by toms74209200

Sec7

Provides gitmoji emoji listings and search functionality in a paginated format as a Model Context Protocol (MCP) server.

Setup Requirements

  • ⚠️Requires Deno 2.0.0 or later to be installed.
  • ⚠️Intended for use with a Model Context Protocol client (e.g., within Visual Studio Code with an `mcp.json` configuration).
Verified SafeView Analysis
The server's main executable (`main.ts`) is configured to run with `--allow-all` Deno permissions, which grants extensive access (network, file system, environment, subprocesses, etc.). While the current implementation of the tools (`list_gitmoji`, `search_gitmoji`) appears benign, performing only in-memory operations on static data and communicating via stdio, granting such broad permissions is a significant security concern and bad practice. Input validation for tool arguments is present using Zod, which is a positive, but the overall permissive execution environment is suboptimal.
Updated: 2026-01-14GitHub→
PreviousPage 414 of 713Next