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
Medium Cost
gladysvalerie icon

mcp-server-test

by gladysvalerie

Sec9

Orchestrates an AI assistant to help users with coding problems by decomposing them into subproblems and checking solutions using an MCP server for tool execution.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid service)
  • ⚠️Requires Python 3.11 or higher
Verified SafeView Analysis
The system relies on `json.loads` to parse LLM outputs for tool arguments and structured responses. While `json.loads` itself is generally safe, any downstream processing of potentially crafted JSON could theoretically pose a risk, although no explicit vulnerabilities are apparent. The MCP server uses `stdio` transport, limiting direct network exposure to external connections. No 'eval' or other highly dangerous patterns were found.
Updated: 2025-11-20GitHub→
0
0
Low Cost
TJC2002 icon

mcp-server-demo

by TJC2002

Sec8

This server provides a Microservices Communication Protocol (MCP) endpoint, exposing Python functions as callable tools, dynamic resources, and prompt generators over an HTTP transport.

Setup Requirements

  • ⚠️Requires 'uv' for running as per the documentation comments.
  • ⚠️Requires the 'mcp' Python library to be installed.
  • ⚠️The server binds to port 8000; ensure this port is free.
Verified SafeView Analysis
The provided code does not contain obvious direct security vulnerabilities like 'eval' or malicious patterns. User inputs for greetings are used in f-strings, which is generally safe. However, the server defaults to 'streamable-http' on localhost:8000 without explicit authentication in the code. If exposed externally without proper network security (e.g., firewall, authentication layer), it would be vulnerable to unauthorized access and tool invocation. The example 'mcp-config-example.json' even shows 'auth: "type": "none"', highlighting that some MCP servers might operate without built-in security, relying on external mechanisms.
Updated: 2025-12-04GitHub→
0
0
Low Cost
Poushali-02 icon
Sec9

A comprehensive personal finance management system for tracking income, expenses, and generating financial reports.

Setup Requirements

  • ⚠️Requires Python 3.13+ for local installation.
  • ⚠️Requires 'uv' for dependency management and running the server.
  • ⚠️Requires a PostgreSQL 15+ database instance.
  • ⚠️Requires a `.env` file with `DATABASE_URL`, `SECRET_KEY`, and SMTP email service credentials (`SMTP_HOST`, `SMTP_PORT`, `SMTP_USER`, `SMTP_PASSWORD`).
  • ⚠️Intended for integration with Claude Desktop (or Claude Pro via custom connector).
Verified SafeView Analysis
The server employs strong security practices including bcrypt for password hashing, JWT-based authentication with token expiry, robust password strength validation, and environment variable loading for all sensitive credentials (e.g., SECRET_KEY, SMTP credentials, DATABASE_URL). All database interactions use parameterized queries via asyncpg, preventing SQL injection. User data is strictly isolated by filtering all queries with the authenticated user_id. Email verification is required for critical actions like account deletion and password resets, and there are attempt limits for verification/reset codes. The default SECRET_KEY provided in the code explicitly warns it should be changed in production.
Updated: 2026-01-11GitHub→
0
0
Low Cost
AshishBagdane icon

simple-mcp-server

by AshishBagdane

Sec8

Provides a Micro-Agent Communication Protocol (MCP) server for real-time currency conversion using an external API.

Setup Requirements

  • ⚠️Requires a free or paid API Key from ExchangeRate-API (EXCHANGERATE_API_KEY environmental variable) for currency conversion, which needs to be obtained by the user.
  • ⚠️Requires `mcp`, `requests`, and `python-dotenv` Python libraries to be installed.
  • ⚠️Requires internet connectivity to reach the ExchangeRate-API service.
Verified SafeView Analysis
The server correctly loads the API key from environment variables (EXCHANGERATE_API_KEY), preventing hardcoding. It relies on `requests` for external API calls, which is standard and secure. Input parameters for currency conversion are directly used in the API URL, which is typical for such services and not an immediate vulnerability given the context of currency codes. No `eval` or direct `subprocess` calls are found within the server logic itself. The `test_server.py` uses `subprocess` for testing, but that is not part of the deployed server. Error messages returned to the client are informative but do not expose critical internal system details beyond API error types.
Updated: 2025-12-10GitHub→
0
0
Medium Cost
steadybit icon

mcp

by steadybit

Sec8

The Steadybit MCP Server enables LLM tools to interact with the Steadybit chaos engineering platform for managing experiments, executions, and other Steadybit resources.

Setup Requirements

  • ⚠️Requires a Steadybit account and API token.
  • ⚠️The 'create_experiment_from_template' functionality must be explicitly enabled via environment variable (e.g., CAPABILITIES_ENABLED_0=CREATE_EXPERIMENT_FROM_TEMPLATE).
  • ⚠️Requires a Java Runtime Environment (if running locally from JAR) or Docker (if using the Docker image).
Verified SafeView Analysis
The server acts as a wrapper for the Steadybit API, making authenticated HTTP requests. It uses environment variables for sensitive API tokens, preventing hardcoding. Input validation for API URL and token is present. There are no obvious signs of 'eval' or direct shell command execution from user inputs. The primary risk is inherent to any API wrapper, relying on the security of the upstream Steadybit API and proper management of the API_TOKEN.
Updated: 2026-01-12GitHub→
0
0
Low Cost
gvdlga icon
Sec9

This MCP server provides an API wrapper for AssemblyAI, enabling audio transcription and management functionalities such as transcribing files, checking status, listing, and deleting transcriptions.

Setup Requirements

  • ⚠️Requires an AssemblyAI API Key (Paid service).
  • ⚠️Requires Node.js runtime environment.
  • ⚠️Requires running 'npm install' and 'npm run build' commands to prepare the application.
Verified SafeView Analysis
The server uses environment variables for API keys (`ASSEMBLY_API_KEY`) and relies on the `@geniusagents/mcp` library for potential session-based API key management, which is a good practice. No direct 'eval' or other obviously dangerous patterns were found. The server acts as a proxy, so the primary security consideration would be the secure management of the AssemblyAI API key and the `@geniusagents/mcp` framework's security.
Updated: 2025-11-20GitHub→
0
0
Medium Cost

cnxt-clipx-mcp

by thexdesk

Sec9

Generates highlight reels for sports and TV shows by processing data from sources like ESPN and curated TV registries, rendering them using FFmpeg, and optionally uploading to Google Cloud Storage.

Setup Requirements

  • ⚠️Requires Node.js and npm for setup and execution.
  • ⚠️Requires `ffmpeg` and `ffprobe` binaries to be installed and available in the system's PATH for the FFmpeg server to function.
  • ⚠️Requires `npm run sync:sports` to generate `sports-registry.json` for the sports server.
  • ⚠️Google Cloud credentials must be configured (e.g., via `GOOGLE_APPLICATION_CREDENTIALS` environment variable or Application Default Credentials) for GCS upload functionality in the FFmpeg server.
Verified SafeView Analysis
The server utilizes `child_process.spawn` for executing `ffmpeg` and `ffprobe` commands. Arguments are passed as an array, which is a safer practice against shell injection compared to using `shell: true` or `child_process.exec`. The Google Cloud Storage integration relies on standard authentication methods (`GOOGLE_APPLICATION_CREDENTIALS` or Application Default Credentials), reducing the risk of hardcoded secrets. External data fetching from ESPN is done via `fetch`. No obvious `eval` or malicious patterns were found. Relying on properly configured Google Cloud credentials is key for secure GCS operations.
Updated: 2025-11-27GitHub→
0
0
Medium Cost
parrisma icon

mcpnp

by parrisma

Sec9

Augment LLM math capabilities by exposing common numpy and scipy operations as a Micro-Capability Platform (MCP) server.

Setup Requirements

  • ⚠️Requires Python 3.x with numpy, scipy, fastmcp, and pydantic installed (or use Docker).
  • ⚠️Docker is highly recommended for building and running the server, with provided build scripts.
  • ⚠️The server defaults to binding on 0.0.0.0:9124, ensure this port is available and network access is controlled if exposed publicly.
Verified SafeView Analysis
The server uses FastMCP for tool exposure and Pydantic for robust input validation, significantly mitigating injection risks. It leverages standard and well-audited libraries (numpy, scipy). No 'eval' or 'exec' is used dynamically. Error handling is present to catch exceptions during numerical operations. The test client uses a placeholder bearer token, indicating potential for API authentication. The server binds to 0.0.0.0 by default, which is common for containerized services but exposes it on all interfaces, though this is configurable.
Updated: 2025-12-03GitHub→
0
0
High Cost
v3nom icon

toon-fetch

by v3nom

Sec5

Fetches web content from a given URL, cleans it, converts it to Markdown, and optionally processes it using a local language model to return structured data in TOON format for AI agents.

Setup Requirements

  • ⚠️Requires Chromium/browser dependencies for Puppeteer, which can be large downloads and may have system-specific installation requirements.
  • ⚠️Requires an initial download of the LaMini-Flan-T5-248M LLM model (~248MB) on first use, impacting startup time and disk space.
  • ⚠️Demands significant local compute resources (CPU, RAM) for running headless Chrome and local LLM inference per call, potentially making it unsuitable for low-resource environments or high-throughput usage without careful scaling.
Review RequiredView Analysis
The server uses Puppeteer to fetch content from arbitrary URLs. Running a headless browser to visit untrusted external websites can expose the host system to security risks (e.g., Server-Side Request Forgery if not properly isolated, or potential exploits if the browser itself is compromised). No explicit sandboxing mechanisms for Puppeteer are mentioned in the provided code. Additionally, the local LLM downloads its model weights on first use, requiring external network access and disk space, which could be a vector for supply chain attacks if the model source were compromised.
Updated: 2025-12-13GitHub→
0
0
Low Cost
cmalpass icon

mcp-presidio

by cmalpass

Sec9

Provides PII (Personally Identifiable Information) detection and anonymization capabilities using Microsoft Presidio, enabling LLMs to safely handle sensitive data.

Setup Requirements

  • ⚠️Requires Python 3.10 or higher.
  • ⚠️Requires downloading spaCy language models (e.g., en_core_web_lg) for optimal PII detection accuracy.
  • ⚠️Docker (20.10+) and Docker Compose (optional) are required for containerized deployment.
Verified SafeView Analysis
The server processes all data locally using `stdio` transport, eliminating network PII leakage from the server itself. It clearly warns users about the inherent risk of sending PII to LLM providers *before* the server processes it. No 'eval' or obvious hardcoded secrets are used for core functionality. User-provided regex for custom recognizers could theoretically be a vector for ReDoS if not robustly handled by the underlying Presidio library, but this is a standard pattern for such tools. Docker containers are configured to run as a non-root user.
Updated: 2025-12-10GitHub→
0
0
Medium Cost
thousandmiles icon

lsp-mcp-server

by thousandmiles

Sec8

Provides semantic code analysis capabilities, such as go-to-definition and find-references, by bridging Model Context Protocol (MCP) tool calls to a Language Server Protocol (LSP) server.

Setup Requirements

  • ⚠️Requires Node.js (v20+ due to `typescript-language-server` dependency requirements).
  • ⚠️Requires npm to install dependencies (`npm install`) and build the project (`npm run build`).
  • ⚠️The `typescript-language-server` needs to be successfully installed as a local dependency.
Verified SafeView Analysis
The server spawns a local `typescript-language-server` instance and reads local files via `fs.readFile` based on paths provided as tool arguments. While this is necessary for its functionality, it operates with the permissions of the user running it and can access any file the user has access to within the project root. An agent controlling the `filePath` or `query` arguments could potentially read or process sensitive local files, though no direct code injection or arbitrary command execution vulnerabilities (like `eval`) are present. The primary risk is the scope of file system access granted to the process and the data an agent might request from it.
Updated: 2025-11-22GitHub→
0
0
Medium Cost
duquesnay icon

miro-remote-mcp

by duquesnay

Sec9

Enables Claude AI to programmatically create and manipulate Miro boards for visualization and collaboration through natural language commands.

Setup Requirements

  • ⚠️Requires a Miro OAuth App to be created in Miro settings (Client ID, Client Secret, Redirect URI).
  • ⚠️Requires Node.js 16+.
  • ⚠️Initial OAuth2 tokens must be obtained by running `npm run oauth` and configured in the environment.
  • ⚠️OAuth access tokens expire hourly; the server automatically refreshes them, but if the refresh token also expires, manual reauthentication is required via the `/oauth/authorize` endpoint or `npm run oauth`.
Verified SafeView Analysis
The server explicitly handles sensitive data by reading OAuth credentials and tokens from environment variables or a specified file (`/data/tokens.json`). It uses base64 encoding for environment variables in some deployment contexts. There's a refresh lock to prevent race conditions during token refresh. All configuration files and token storage locations are documented as git-ignored. No 'eval' or direct malicious patterns were identified. The OAuth helper runs a temporary local server only for initial token acquisition. The overall design follows good security practices for a standalone application, but token files could be compromised if the hosting environment is not secure.
Updated: 2026-01-09GitHub→
PreviousPage 723 of 760Next