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
High Cost
guilhermetechmakers icon
Sec6

Builds AI-powered conversational forms (agents) to collect structured data through natural language interactions.

Setup Requirements

  • ⚠️Requires Supabase project (VITE_SUPABASE_URL, VITE_SUPABASE_ANON_KEY)
  • ⚠️Requires a separate backend API (VITE_API_URL)
  • ⚠️LLM API keys (e.g., OpenAI, Anthropic, Google) are needed for AI functionality and may incur costs.
Review RequiredView Analysis
The application interacts with `/admin` endpoints, which implies a strong backend authentication/authorization layer is critical but not visible in this client-side code. The `webhook-utils.ts` allows forwarding data to arbitrary URLs, which is a high-risk feature requiring strict backend validation to prevent SSRF or data exfiltration. The `profile.ts` file explicitly comments that `two_factor_secret` 'Should be encrypted in production', indicating a potential vulnerability if not handled rigorously on the backend. Client-side 2FA secret generation is less secure than server-side. No obvious malicious patterns or 'eval' usage observed.
Updated: 2025-11-23GitHub→
0
0
High Cost
bhaskar9298 icon
Sec9

Manages personal and group expenses, including shared expense tracking and splitting, through an AI-orchestrated tool server.

Setup Requirements

  • ⚠️Requires MONGODB_URI environment variable for database connection.
  • ⚠️Requires Python 3.12 or newer.
  • ⚠️Requires an OpenAI API key for the example client to function as demonstrated, interacting with 'gpt-5'.
Verified SafeView Analysis
The server uses environment variables (`MONGODB_URI`) for sensitive connection strings, indicating good practice against hardcoded secrets. MongoDB connections are configured with TLS and certificate verification (`tls=True`, `tlsCAFile=certifi.where()`). Authentication and authorization logic (`is_user_in_group`, `is_user_group_admin`, etc.) are heavily integrated into the tools, requiring `user_id` for most operations. Input validation is present for critical parameters like group names, amounts, and email formats. There are no obvious `eval` or other dangerous dynamic code execution patterns. The MongoDB schema `additionalProperties: True` allows for flexible document structure but could be made stricter for enhanced data integrity if desired, though this is not a direct security vulnerability.
Updated: 2025-12-19GitHub→
0
0
Medium Cost

netflow_mcp

by elastickent

Sec7

Provides a natural language interface for analyzing NetFlow data stored in Elasticsearch, offering features like traffic analysis, bottleneck detection, anomaly detection, host investigation, and intelligent recommendations.

Setup Requirements

  • ⚠️Requires an existing Elasticsearch cluster with NetFlow data indexed under 'logs-netflow*'.
  • ⚠️Requires an MCP-compatible client (e.g., Claude Desktop) to interact with the server; it is not a standalone application.
  • ⚠️Specific configuration required within the Claude Desktop client's configuration file (`claude_desktop_config.json`), including correct Python paths.
Verified SafeView Analysis
The server connects to an Elasticsearch cluster using provided credentials, implying access to sensitive network traffic data. While running locally via a desktop client (Claude Desktop) reduces external exposure, the security relies heavily on the underlying Python code (not provided) and proper Elasticsearch security. No 'eval' or obfuscation is apparent from the README.
Updated: 2025-11-17GitHub→
0
0
Medium Cost
080bct12alex icon

MCP

by 080bct12alex

Sec3

Building and deploying an MCP server for expense tracking that integrates with AI chatbots and custom clients, demonstrating core MCP concepts and multi-server client interaction.

Setup Requirements

  • ⚠️Requires `uv` package manager and `fastmcp` library for both server and client setup.
  • ⚠️Client configurations for local servers contain hardcoded absolute paths (e.g., to Python executables and server scripts), which must be manually adjusted for different environments.
  • ⚠️Requires an `OPENAI_API_KEY` to interact with the specified `ChatOpenAI` LLM via the client.
Review RequiredView Analysis
The remote expense tracker server lacks user authentication and authorization mechanisms. All operations (add_expense, list_expenses, summarize) apply to a single, shared database (expenses.db) without distinguishing between users. This poses a critical data privacy and integrity risk for a multi-user deployment, as any client can access or modify all financial data. SQL injection is mitigated by parameterized queries, and temporary directory usage for the database is a minor improvement.
Updated: 2025-11-28GitHub→
0
0
Low Cost
alexisleboulanger icon

mcp-server-miro

by alexisleboulanger

Sec8

An MCP server enabling AI agents to programmatically interact with and manipulate Miro boards via its API.

Setup Requirements

  • ⚠️Requires a Miro API token configured in a .env file.
  • ⚠️Many tools require a Miro Board ID, either set as a default in .env or provided per-call.
  • ⚠️Requires Node.js to be installed for local development/execution without Docker.
Verified SafeView Analysis
The server uses Zod for input validation, and sensitive API tokens are correctly loaded from environment variables. There are no obvious 'eval' or command injection vulnerabilities. The `passthrough()` option in some Zod schemas allows unknown fields to pass through validation, which is then forwarded to the Miro API, potentially leading to unexpected behavior or API errors if the Miro API doesn't handle them gracefully, though this is not a direct server vulnerability. Error responses from the Miro API are directly formatted and returned, which could, in rare cases, expose verbose upstream error details if the Miro API itself were to leak sensitive system information (unlikely for a public API).
Updated: 2025-12-03GitHub→
0
0
Medium Cost
yes0ng icon
Sec9

Assisting with information security tasks by providing product end-of-life dates, CVE lookups, and threat intelligence checks for IPs, domains, and URLs.

Setup Requirements

  • ⚠️Requires Python 3.8 or higher.
  • ⚠️Dependencies must be installed via `pip install -r requirements.txt`.
  • ⚠️Full functionality (VirusTotal, AbuseIPDB) requires API keys, which may be for paid services.
Verified SafeView Analysis
The servers utilize standard Python libraries (httpx, asyncio, os, json, hashlib, datetime) and interact with legitimate, well-known public security APIs (NVD, endoflife.date, VirusTotal, AbuseIPDB, URLhaus). API keys for premium services are correctly loaded from environment variables, preventing hardcoding of secrets. A simple file-based cache for reputation results is implemented in a 'tmp' directory, which is a common and generally safe practice for local caching of JSON data. No 'eval' or other dynamic code execution functions are observed, and the code appears straightforward and robust.
Updated: 2025-11-21GitHub→
0
0
Low Cost
jvolden icon

mcp-sdl

by jvolden

Sec9

Provides SDL3 API documentation, code examples, and migration guides to AI assistants for code generation and reference.

Setup Requirements

  • ⚠️Requires Python 3.10 or higher.
  • ⚠️Requires 'uv' package manager for installation and running.
  • ⚠️Installation uses 'uvx' directly from the GitHub repository URL.
Verified SafeView Analysis
The server primarily serves pre-defined static data (API docs, examples, migration guides) stored as Python data structures. Dynamic imports are restricted to internal modules, and there are no direct calls to 'eval' or external arbitrary code execution. The provided code does not show hardcoded secrets or direct external network requests initiated by the tools themselves. The risk of malicious patterns or arbitrary code execution appears low based on the provided source.
Updated: 2026-01-18GitHub→
0
0
Low Cost
Sec8

Executes shell commands on a server with security controls, and reads/searches/extracts information from PDF files.

Setup Requirements

  • ⚠️Requires the 'mcp' Python package to be installed.
  • ⚠️Requires the 'pymupdf' Python package for the PDF server.
  • ⚠️Configuration in Claude Desktop requires absolute paths to the server scripts.
Verified SafeView Analysis
The terminal server implements security features like command whitelisting, timeout limits, and shell operator restrictions. The PDF server uses a trusted library (pymupdf) and handles file paths carefully. Both servers avoid 'eval' and similar dangerous functions. Potential risks are mitigated by the security features implemented.
Updated: 2025-11-22GitHub→
0
0
Low Cost
Ramakrishna-Gedala icon

mcp_emi_server_deployment

by Ramakrishna-Gedala

Sec9

Provides a lightweight FastMCP server to expose loan EMI calculation, amortization schedule, loan comparison, and prepayment calculation tools to MCP clients.

Setup Requirements

  • ⚠️Requires Python 3.13+
  • ⚠️Requires 'uv' for environment management and running (pip-compatible alternative)
  • ⚠️An external EMI calculation backend API must be running and accessible at the configured `EMI_API_BASE_URL`
Verified SafeView Analysis
The server acts as a proxy to a configurable REST backend via the `EMI_API_BASE_URL` environment variable. The `requests` library is used with a 10-second timeout. Payloads are constructed internally, minimizing client-side injection risks. The primary security consideration is ensuring `EMI_API_BASE_URL` points to a trusted and secure backend, as compromise of this variable could direct traffic to malicious endpoints.
Updated: 2025-11-27GitHub→
0
0
Medium Cost
zq940222 icon

mcp-server-demo

by zq940222

Sec8

A custom Spring AI MCP (Multi-Modal Chat Protocol) server designed for runtime dynamic toolset discovery and routing, bypassing Spring AI's default startup-time tool scanning.

Setup Requirements

  • ⚠️Requires Java (likely 17+) and a compatible Spring Boot environment.
  • ⚠️Requires an MCP-compatible client (e.g., Spring AI client) to interact with the server's custom endpoints.
  • ⚠️Configuration properties like `mcp.toolset.allowed` (for whitelisting toolsets) and cache settings are critical for proper security and performance, though not strictly 'required' for startup.
Verified SafeView Analysis
The application uses reflection (`Class.forName`, `getDeclaredConstructor().newInstance`, `Method.invoke`) for dynamic tool loading and execution. While this inherently adds complexity, the `DynamicToolsetRegistry` restricts class scanning to specific internal packages (`ai.crewplus.mcpserver.tool`) which mitigates the risk of arbitrary code execution from external sources. The `RUNTIME_TOOLSET_ROUTING.md` document also mentions a `mcp.toolset.allowed` whitelist configuration, which is a good security practice to prevent unauthorized toolset loading. No obvious hardcoded secrets or 'eval'-like direct command execution are found. Input arguments for tool calls are typed and converted, reducing direct injection risks, but robust input validation in actual tool implementations remains crucial.
Updated: 2025-11-26GitHub→
0
0
Medium Cost
jbandu icon
Sec8

Provides comprehensive maintenance intelligence for airline operations, including predictive maintenance, parts optimization, and compliance tracking.

Setup Requirements

  • ⚠️Requires a PostgreSQL database to be manually set up and migrated with schema (`npm run db:migrate`) and optionally seeded (`npm run db:seed`).
  • ⚠️Neo4j database is optional but recommended for 'get-component-history' and requires separate installation and configuration (`ENABLE_NEO4J=true`).
  • ⚠️Machine Learning (ML) functionalities (e.g., predict-component-failures) can optionally depend on an external Python ML service if `PYTHON_ML_SERVICE_URL` is configured.
  • ⚠️Language Model (LLM) integration can require a local Ollama instance (`LLM_MODE=ollama`) or a Claude API Key (`LLM_MODE=claude`) for full functionality.
Verified SafeView Analysis
The server utilizes environment variables for all sensitive configurations (PostgreSQL, Neo4j, Claude API keys), which is a good security practice. Input validation is performed using Zod schemas for all tool arguments, helping to prevent common injection vulnerabilities. No 'eval' or explicit obfuscation is present. While integrations with external ML/LLM services introduce inherent network risks, these are managed through standard practices (e.g., API keys, URLs). Many tool handlers are currently marked with 'TODO', indicating that the full implementation and thus complete security posture of those features are not yet defined in the provided source.
Updated: 2025-11-28GitHub→
0
0
High Cost
morikazu1119 icon

Medical-MCP-Server

by morikazu1119

Sec8

Provides a reproducible Python development environment template with Docker and Docker Compose, optimized for GPU-accelerated workloads.

Setup Requirements

  • ⚠️Requires Docker and Docker Compose installed on the host machine.
  • ⚠️Requires a host machine with NVIDIA GPUs and appropriate drivers for GPU acceleration.
  • ⚠️If using `docker-run.sh`, the hardcoded `HOST_DATA_PATH="/mnt/c/mnt/data"` must be adjusted for non-Windows hosts or different data locations.
  • ⚠️The default SSH port (2222) on the host must be available or configured otherwise.
Verified SafeView Analysis
No 'eval' or obvious obfuscation detected. Hardcoded defaults for build arguments and `HOST_DATA_PATH` exist but are intended for user configuration or override, not secrets. Exposes SSH port (22) to the host; users must ensure proper host firewall rules. Grants full GPU access to the container, a common but privileged setting for ML development.
Updated: 2025-11-30GitHub→
PreviousPage 529 of 760Next