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
Emeenent14 icon

relay

by Emeenent14

Sec5

Relay is a desktop application for managing Model Context Protocol (MCP) servers, enabling users to configure, enable/disable, and export these servers for AI applications like Claude Desktop.

Setup Requirements

  • ⚠️Requires Node.js v18+ to run the frontend build and development server.
  • ⚠️Requires Rust toolchain (rustc, cargo) for the backend compilation.
  • ⚠️Requires platform-specific build tools (e.g., Visual Studio C++ Build Tools on Windows, Xcode Command Line Tools on macOS, `libwebkit2gtk-4.0-dev build-essential` on Linux) due to its Tauri framework.
Verified SafeView Analysis
The primary security consideration is that Relay's core functionality involves allowing users to define and execute arbitrary commands and arguments for the MCP servers it manages. While essential for its purpose, this grants a high degree of control over the user's system, meaning users must exercise extreme caution when adding or configuring servers, as malicious or improperly configured commands could lead to unintended system access or data manipulation. Additionally, the current implementation (based on `src-tauri/src/models/server.rs` and `src-tauri/src/commands/servers.rs`) stores environment variables (`env`) as plain JSON strings within the local SQLite database. If these `env` strings contain sensitive credentials (e.g., API keys, tokens), they would be stored unencrypted, posing a risk if the local database file is compromised. Although `docs/03-API-SPECIFICATION.md` mentions `env_credentials` and a `KeychainService` for more secure storage, these are not fully implemented in the provided Rust backend code for server CRUD operations, indicating a potential vulnerability for sensitive data.
Updated: 2026-01-17GitHub→
0
0
Medium Cost
prepmonk icon

iwx-mcp-server

by prepmonk

Sec5

Provides a Microservice Communication Protocol (MCP) server to expose Infoworks data management tools via a unified API.

Setup Requirements

  • ⚠️Requires `IWX_REFRESH_TOKEN` environment variable
  • ⚠️Requires `IWX_BASE_URL` environment variable pointing to an Infoworks API instance
  • ⚠️Disables SSL certificate verification (`verify=False`) for upstream Infoworks API calls, which is a critical security vulnerability and should be addressed before production use.
Review RequiredView Analysis
Disables SSL certificate verification (`verify=False`) when making upstream API calls to the Infoworks system, making it vulnerable to Man-in-the-Middle attacks. It relies on environment variables (`IWX_REFRESH_TOKEN`, `IWX_BASE_URL`) for sensitive credentials, which is good practice if those variables are securely managed. Error responses from the upstream API could potentially expose sensitive information through logged full response texts.
Updated: 2025-12-01GitHub→
0
0
Medium Cost
ry-ops icon
Sec8

Provides a Model Context Protocol (MCP) server for AI assistants to manage CheckMK monitoring systems, including hosts, folders, services, and configurations.

Setup Requirements

  • ⚠️Requires Python 3.10 or higher.
  • ⚠️Requires `uv` package manager, which the `setup.sh` attempts to install via `curl | sh`, a method that might be restricted or undesirable in some environments. Manual installation may be needed.
  • ⚠️Requires access to an existing CheckMK instance (version 2.0+) and an automation user with appropriate permissions configured on that instance.
Verified SafeView Analysis
The server uses `os.getenv` for sensitive credentials (CheckMK URL, username, password, site), which is a good practice. No direct `eval` or `exec` commands are observed in the core `server.py` logic. The `httpx` library is used for API communication. The setup script uses `curl | sh` for `uv` installation, which is a common pattern but carries inherent risk if the source is compromised. The server itself is designed for local stdio transport, limiting external network attack surface.
Updated: 2025-12-03GitHub→
0
0
High Cost
RoyRushreeta icon
Sec2

Orchestrates a multi-agent loop to answer user queries by leveraging Google Gemini models, MCP tool servers, and a retrieval pipeline.

Setup Requirements

  • ⚠️Requires `GEMINI_API_KEY` environment variable for Google Gemini API access (a paid service).
  • ⚠️Requires a local Ollama server running with specific models installed (`nomic-embed-text`, `gemma3:12b`, `phi4:latest`, `qwen2.5:32b-instruct-q4_0`) for RAG and semantic chunking.
  • ⚠️The `cwd` paths in `config/mcp_server_config.yaml` are hardcoded to absolute Windows paths (e.g., `C:/Users/Rushreeta Roy/...`) and MUST be updated to reflect the user's local environment.
  • ⚠️Requires Python >= 3.11.
Review RequiredView Analysis
The `action/executor.py` module, which is responsible for running user-generated Python code in a sandbox, includes `__import__` in its `__builtins__` for `exec`. This allows arbitrary modules (e.g., `os`, `subprocess`) to be imported and executed by user-provided code, effectively bypassing any intended sandboxing and leading to full system compromise. Hardcoded absolute Windows paths in `config/mcp_server_config.yaml` also pose a slight risk if not correctly managed in a multi-user environment, but the `__import__` vulnerability is critical.
Updated: 2025-11-27GitHub→
0
0
Medium Cost
Traia-IO icon
Sec8

Provides an MCP (Model Context Protocol) server to enable AI agents and LLMs to interact with the asddsaadsadssad API.

Setup Requirements

  • ⚠️Requires Docker for recommended setup, utilizing `run_local_docker.sh` to build and run the container.
  • ⚠️Requires configuration of D402 payment protocol environment variables (e.g., SERVER_ADDRESS, MCP_OPERATOR_PRIVATE_KEY, D402_FACILITATOR_URL), which may involve blockchain wallet setup and management.
  • ⚠️Python 3.12 or newer is specified as a requirement in `pyproject.toml`.
  • ⚠️The `run_local_docker.sh` script modifies `pyproject.toml` and attempts to locate a local `traia-iatp` project, which might cause friction if the path is not correctly configured or if `rsync` is unavailable.
Verified SafeView Analysis
The server uses environment variables for sensitive data like `MCP_OPERATOR_PRIVATE_KEY` and `D402_FACILITATOR_API_KEY`. The `run_local_docker.sh` script generates placeholder private keys for local development, which is convenient but highlights the need for secure secret management in production. The D402 payment protocol relies on blockchain transactions (involving `TokenAmount` and `TokenAsset`), requiring proper configuration of addresses and private keys. There are no obvious 'eval' or obfuscation risks. Network exposure is controlled to standard HTTP ports.
Updated: 2025-12-03GitHub→
0
0
Low Cost
Ericwyn icon

mcp-partner

by Ericwyn

Sec8

A Postman-like client for testing and interacting with Model Context Protocol (MCP) servers via Server-Sent Events (SSE) or Streamable HTTP.

Setup Requirements

  • ⚠️Requires an existing Model Context Protocol (MCP) server to connect to.
  • ⚠️Web browser CORS (Cross-Origin Resource Sharing) policies can prevent direct connection to local or different-domain MCP servers; users may need to enable the built-in proxy (if on Vercel), use a public proxy, or run a local proxy (like Pancors).
  • ⚠️The built-in '/cors' proxy functionality is only available when deployed on Vercel; GitHub Pages deployments will need an external proxy.
Verified SafeView Analysis
The application is primarily a client-side React application. The included 'api/cors.ts' file implements a generic CORS proxy (Edge Function). While the proxy code includes measures to filter potentially unsafe headers and validates the target URL, it is an open proxy without authentication, authorization, or rate-limiting. If deployed publicly, this proxy could be abused. However, the application's main purpose is to debug CORS issues, and it explicitly provides this proxy functionality or suggests using public/local alternatives. There are no 'eval' statements, obfuscation, hardcoded secrets, or immediate malicious patterns identified within the provided source code snippets.
Updated: 2025-12-09GitHub→
0
0
Medium Cost

withings-mcp

by akutishevsky

Sec9

An MCP server that integrates Withings health data with Claude, enabling natural language queries and AI-powered analysis of personal health metrics like sleep, body measurements, and workouts.

Setup Requirements

  • ⚠️Requires a Withings Developer Account and application setup to obtain Client ID and Client Secret.
  • ⚠️A publicly accessible URL is required for the OAuth redirect URI, even for local development (necessitating a tunneling service or staging deployment).
  • ⚠️An `ENCRYPTION_SECRET` (32+ characters) must be securely generated and configured in environment variables for token encryption.
Verified SafeView Analysis
The project emphasizes privacy with explicit notes on no malicious logging, automatic redaction of sensitive data, and AES-256-GCM encryption for tokens at rest. It uses industry-standard OAuth 2.0. The code is public for transparency. There are no obvious signs of 'eval' or obfuscation. The main potential risks would be standard web server vulnerabilities if not deployed securely, but the project's features mitigate many common issues.
Updated: 2025-11-17GitHub→
0
0
Low Cost
turmex icon
Sec4

The AI Assistant provides a local-first conversational interface, enabling users to chat with LLMs directly in their browser via WebLLM (WebGPU) or locally using an Ollama server. It features intelligent model management, hardware-aware recommendations, and token optimization for efficient conversation.

Setup Requirements

  • ⚠️Requires Ollama to be installed and running locally for server-based models (`ollama serve`).
  • ⚠️Requires Chrome 113+ or Edge 113+ with WebGPU support for browser-based (WebLLM) inference.
  • ⚠️Requires Python 3.8+.
Verified SafeView Analysis
API keys are stored in browser localStorage with base64 obfuscation, which is explicitly noted as 'not encryption' and easily discoverable. CORS is configured permissively for MVP and requires restriction in production. The `launch.sh` script uses `kill -9` to free ports, which could be risky if misused, though it's contextualized for local cleanup.
Updated: 2025-11-20GitHub→
0
0
Medium Cost
mendesrobson icon
Sec1

A server designed for managing or facilitating review processes related to GitHub repositories.

Review RequiredView Analysis
No source code was provided for analysis. Therefore, a comprehensive security audit is not possible, and potential risks such as 'eval' usage, code obfuscation, network vulnerabilities, hardcoded secrets, or malicious patterns cannot be identified. The lowest possible score is assigned due to the inability to verify the safety and security of the application.
Updated: 2025-11-19GitHub→
0
0
Medium Cost
donbr icon
Sec6

Provides AI agents with persistent, temporally-aware knowledge graph memory through episodic ingestion, entity extraction, and semantic search.

Setup Requirements

  • ⚠️Requires Docker and Docker Compose for the recommended default setup (or a running Neo4j/FalkorDB instance).
  • ⚠️Requires API keys for LLM (e.g., OPENAI_API_KEY) and Embedder (e.g., OpenAI).
  • ⚠️Requires Python 3.10+ and the `uv` package manager.
  • ⚠️Tuning `SEMAPHORE_LIMIT` is critical to avoid LLM rate limits (429 errors) and manage API costs, as episode ingestion involves multiple LLM calls.
  • ⚠️Database connection issues (e.g., 'Connection refused') are common setup friction points.
  • ⚠️The default Neo4j password 'demodemo' in config files should be changed for production.
Verified SafeView Analysis
The server exposes powerful graph CRUD operations (e.g., `clear_graph`) as MCP tools, which can delete all data if not properly managed or confirmed. The multi-agent migration system, defined by JSON manifests, explicitly grants `Read`, `Write`, and `Bash` permissions to file systems and allows interaction with multiple MCP servers, significantly increasing the attack surface in unconstrained agentic environments. The default `NEO4J_PASSWORD` in `config/schema.py` is 'demodemo', which is a weak default but can be overridden. Critical safety rules are mentioned in agent prompts to mitigate risks, indicating an awareness of potential issues.
Updated: 2025-12-13GitHub→
0
0
Low Cost
abhishekkhasgiwala icon

mcp

by abhishekkhasgiwala

Sec3

An MCP server that exposes Activiti BPM case and transaction data as AI-consumable tools for IDE-integrated, natural language case analysis.

Setup Requirements

  • ⚠️Requires Docker to run the PostgreSQL database (`activiti-bpm-docker/docker-compose.yml`).
  • ⚠️Requires Java 17 runtime environment.
  • ⚠️Hardcoded database credentials make it unsafe for production environments without modification.
Review RequiredView Analysis
CRITICAL: Database credentials (username 'activiti', password 'activiti') are hardcoded in `application.yaml`. This is a severe security risk and should be replaced with environment variables or a secrets management solution in any non-development environment. While `JdbcTemplate` uses prepared statements for the `get_case_summary` tool, mitigating SQL injection for that specific query, the general `McpTool` interface does not inherently enforce this, meaning future tools could introduce SQL injection vulnerabilities if not carefully implemented.
Updated: 2026-01-17GitHub→
0
0
Low Cost
maybleeess-collab icon
Sec9

Interacting with the Ethereum blockchain for balance queries, token price fetching, and Uniswap V3 swap simulations.

Setup Requirements

  • ⚠️Requires an Ethereum RPC URL (e.g., from Alchemy or Infura), which may be a paid service or have rate limits.
  • ⚠️Requires a private key for signing transactions/simulations, which must be kept secure.
  • ⚠️Communication is via Stdio, not a typical HTTP API, which may require specific integration patterns.
Verified SafeView Analysis
The server uses environment variables for sensitive data like `ETHEREUM_RPC_URL` and `PRIVATE_KEY`, which is a good practice. It explicitly performs swap *simulations* (read-only `eth_call`) and returns calldata for agents to sign and broadcast, preventing the server from directly executing trades. The use of `rust_decimal` prevents floating-point inaccuracies for financial calculations. There are no obvious malicious patterns or dynamic code execution (like `eval`) found. The server communicates via Stdio, reducing its direct network attack surface, but the underlying RPC interactions still rely on secure communication with the Ethereum node.
Updated: 2025-11-30GitHub→
PreviousPage 562 of 760Next