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
Medium Cost
Jammy2005 icon
Sec7

A comprehensive MCP server designed to wrap and expose various Product REST APIs, offering tools for product management, supplier listing, product details, search, inventory updates, order placement, customer feedback, shopping cart management, and file uploads.

Setup Requirements

  • ⚠️Requires an external Product REST API server to be running and accessible, either at the hardcoded default `http://192.168.210.100:6051` or an address specified via the `PRODUCT_API_BASE_URL` environment variable.
  • ⚠️Depends on the `FastMCP` framework (imported as `mcp.server.fastmcp`) being installed and available in the Python environment.
  • ⚠️File paths provided for `upload_product_files` can originate from 'LLM virtual paths' or local absolute paths, implying specific environmental setup or client capabilities for file access.
Verified SafeView Analysis
The server acts as a thin wrapper/proxy for an upstream REST API. While it leverages `httpx` with `raise_for_status()` for robust HTTP error handling and manages temporary files securely for uploads, it lacks explicit input validation for complex JSON payloads (e.g., `product_dict`, `order_items_list`). This delegates input validation entirely to the upstream API. If the upstream API lacks robust validation, this server could become an unwitting conduit for vulnerabilities. The default `PRODUCT_API_BASE_URL` is an internal IP, suggesting an internal deployment where direct exposure to the internet would be a security misconfiguration. The `_safe_json` utility may mask underlying JSON parsing errors from the upstream service.
Updated: 2025-11-26GitHub→
0
0
Medium Cost
rubyimogenjohnson icon

mcp-server-email

by rubyimogenjohnson

Sec8

Automates Freedom of Information (FOI) request handling by integrating with Gmail and Claude, including drafting acknowledgment receipts and facilitating team allocation.

Setup Requirements

  • ⚠️Python 3.10+ is required, though the README suggests 3.14+.
  • ⚠️Requires manual setup of a Google Cloud Project with Gmail API enabled and OAuth 2.0 credentials.
  • ⚠️Requires the Claude Desktop application for integration and operation.
  • ⚠️Requires three specific CSV files (`camden_foi_responses.csv`, `foi_team_mapping.csv`, `foi_team_contacts.csv`) to be placed in the project root/src directory.
Verified SafeView Analysis
The server uses Google OAuth 2.0 for authentication with Gmail API, storing tokens locally. `credentials.json` is explicitly recommended not to be committed to version control. No 'eval' or direct code obfuscation detected. CSV files are loaded as internal knowledge bases, assuming trusted data sources. The primary security consideration for LLM integration is prompt injection, which is an inherent risk when sending user-provided email content to an AI model, though the server itself does not execute AI outputs. Logs may contain sensitive email content.
Updated: 2025-12-12GitHub→
0
0
High Cost
sleekcms icon
Sec3

A chatbot system that integrates with SleekCMS to provide AI-powered insights about website content and manage conversation context using the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires Anthropic API Key (Paid, or free evaluation for `claude-3-haiku-20240307` model).
  • ⚠️Requires a valid SleekCMS Pub Token.
  • ⚠️Frontend is a static HTML file; requires a separate local HTTP server (e.g., Python's `http.server` or `npx http-server`) for optimal functionality rather than simply opening the file in a browser.
Review RequiredView Analysis
The server has a critical Server-Side Request Forgery (SSRF) vulnerability. The `pubToken` input in the `/api/connect` endpoint can accept a full URL (`token.startsWith('http')`). If a URL is provided, the backend will attempt to `fetch` data from that arbitrary URL, making it possible for an attacker to probe internal networks, access cloud metadata services, or initiate requests to other unintended endpoints from the server's perspective. Additionally, the default CORS configuration (`app.use(cors())`) allows all origins, which is acceptable for local development but constitutes a security risk in a production environment without explicit origin restrictions.
Updated: 2025-12-02GitHub→
0
0
Low Cost
frnnk icon
Sec7

An MCP (Model Context Protocol) server template providing OAuth 2.0-protected Google Calendar tools to agentic clients.

Setup Requirements

  • ⚠️Requires Python 3.13
  • ⚠️Requires a Google Cloud Project and OAuth 2.0 Client ID/Secret JSON file (`client_secret.json`)
  • ⚠️Requires `uv` for dependency management and running the server
Verified SafeView Analysis
The server's design for local development uses unencrypted file-based token storage (`GOOGLE_LOCAL_TOKEN_PATH`) and a hardcoded 'localtest' principal_id, meaning all operations share the same authentication context. This is acceptable for single-user local testing as stated in the documentation, but a critical security flaw for multi-user or production deployments. The OAuth callback handler in `google_provider.py` performs an `http` to `https` URI replacement which is a workaround for `oauthlib`'s strictness; production environments should ensure proper HTTPS termination and redirect URIs. No obvious 'eval' or malicious obfuscation found.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
YeiyoNathnael icon

LichessMCP

by YeiyoNathnael

Sec1

A server component designed to interact with the Lichess platform, likely for managing custom clients or bots via a specific protocol.

Review RequiredView Analysis
Source code was not provided for analysis. Therefore, a comprehensive security audit could not be performed. This project may contain unknown vulnerabilities, hardcoded secrets, or malicious patterns. It is highly unsafe to run any code without reviewing its source. The low score reflects the complete lack of visibility into the code's security posture.
Updated: 2026-01-16GitHub→
0
0
Medium Cost
flowgrammer420 icon

otc-mcp-server

by flowgrammer420

Sec9

Manages Open Telekom Cloud (OTC) infrastructure, specifically Elastic Cloud Servers (ECS), via AI agents like Claude Desktop.

Setup Requirements

  • ⚠️Requires an Open Telekom Cloud (OTC) account with AK/SK credentials and a Project ID.
  • ⚠️Node.js version 18 or higher is required.
  • ⚠️Environment variables (OTC_ACCESS_KEY, OTC_SECRET_KEY, OTC_PROJECT_ID, OTC_REGION) must be correctly configured.
  • ⚠️Requires manual configuration in Claude Desktop's `claude_desktop_config.json` for AI integration.
Verified SafeView Analysis
The server uses environment variables for sensitive credentials (access/secret keys), which is a standard and secure practice. No 'eval' or other directly malicious patterns were found. Network requests are made to legitimate OTC API endpoints using Axios. The inherent security risk lies in exposing powerful cloud management tools to an AI, meaning a compromised or misconfigured AI could perform unintended actions on the cloud infrastructure.
Updated: 2025-11-25GitHub→
0
0
Low Cost
maxgerlach1 icon

granola-ai-mcp-server

by maxgerlach1

Sec9

Integrates Granola.ai meeting intelligence into Claude Desktop via the Model Context Protocol (MCP) for local AI processing.

Setup Requirements

  • ⚠️Requires macOS with Granola.ai application installed and actively generating meeting data.
  • ⚠️Requires Python 3.12+ and `uv` package manager for setup.
  • ⚠️The repository must be cloned to the user's home directory (`~`) to avoid macOS permission issues with Claude Desktop.
  • ⚠️Requires manual configuration of Claude Desktop's `claude_desktop_config.json` file with a specific, absolute path to the virtual environment's executable script.
Verified SafeView Analysis
The server operates entirely locally, processing data from Granola.ai's cache file on the user's machine. It explicitly states '100% Local Processing' and 'No External API Calls', minimizing network and data modification risks. Access to the cache is read-only. No dynamic code execution from untrusted input (like `eval`) or hardcoded secrets are apparent in the provided source code.
Updated: 2026-01-17GitHub→
0
0
High Cost
ajay-fitbit icon

MCP

by ajay-fitbit

Sec3

Integrates Microsoft SQL Server databases with AI assistants (OpenAI, Claude Desktop) for natural language querying, automated database operations, and test suite generation.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid)
  • ⚠️Requires Microsoft ODBC Driver 17 for SQL Server (Windows/Linux)
  • ⚠️Requires Python 3.8 or higher
  • ⚠️Requires access to a Microsoft SQL Server database with appropriate permissions
Review RequiredView Analysis
CRITICAL VULNERABILITIES IDENTIFIED: 1. SQL Injection Vulnerabilities: - In `server.py:DatabaseService.execute_query`, parameter *keys* are directly substituted into the SQL query via `query.replace(f"@{key}", "?")`. If a malicious AI prompt or user input controls the `key` name, SQL injection is possible (e.g., `@{key}; DROP TABLE Users; --`). - Similarly, in `server.py:DatabaseService.execute_stored_procedure`, parameter *names* are concatenated into the `EXEC` statement (`@{key} = ?`). A malicious agent controlling `key` names could inject SQL. 2. Local File Inclusion (LFI): In `server.py:DatabaseService.generate_query_from_template`, arbitrary `template_file` names are used to read files from the file system. A malicious actor could specify paths to sensitive files (e.g., `/etc/passwd`, `.env` files, or other configuration) leading to information disclosure. 3. Insecure Communication: `httpx.Client(verify=False)` is explicitly used in `openai_client.py`, `server_client.py`, `direct_no_mcp.py`, `direct_database.py`, and `stored_proc_explorer.py` for OpenAI API communication. While intended as a workaround for corporate SSL environments, this bypasses critical SSL certificate verification, making communication vulnerable to Man-in-the-Middle (MITM) attacks and compromising the confidentiality and integrity of API keys and potentially sensitive query contexts. 4. Subprocess Execution: Multiple launcher scripts use `subprocess.run` to execute other Python scripts. While currently controlled within the repository, this pattern could introduce risks if arguments or script paths become controllable by untrusted input, especially in conjunction with the identified injection vulnerabilities. RECOMMENDATIONS: The identified vulnerabilities are critical. Running this code in a production environment or with untrusted input is NOT recommended without significant security hardening.
Updated: 2025-11-19GitHub→
0
0
High Cost
hecatonheyrus icon

pdf-mcp-server

by hecatonheyrus

Sec3

Extracting textual content and generating summaries from PDF documents using Large Language Models (LLMs).

Setup Requirements

  • ⚠️Requires an OpenAI API Key (paid service) for LLM summarization, as it uses OpenAI LLM.
  • ⚠️Requires a Rust development environment (including Cargo) to build and run the server.
  • ⚠️The server is launched by specifying a single PDF file path as an argument, implying it processes one PDF per server instance.
Review RequiredView Analysis
Security analysis is severely limited as only the `README.md` file was provided, not the actual Rust source code (`.rs` files, `Cargo.toml`). Without access to the complete source code, it is impossible to audit for critical security risks such as potential `unsafe` blocks, malicious patterns, improper network handling, input sanitization vulnerabilities when interacting with LLMs, or hardcoded secrets. The server exposes HTTP/HTTPS endpoints for interaction, which can be a vector for attacks if not properly secured (e.g., authentication, authorization, TLS configuration). A full security audit would require the complete source code.
Updated: 2026-01-18GitHub→
0
0
Low Cost
OthmanAdi icon

CloudMcp

by OthmanAdi

Sec1

Provides a set of simple, executable tools (time, date, calculator, memory storage) via an MCP interface using Server-Sent Events (SSE).

Setup Requirements

  • ⚠️Requires Python and specific dependencies (e.g., uvicorn, starlette, mcp library). These are not explicitly listed in a requirements.txt but must be installed.
Review RequiredView Analysis
CRITICAL: The 'calculator' tool uses `eval()` on user-provided input ('expression'). This is a severe remote code execution vulnerability, allowing an attacker to execute arbitrary Python code on the server by injecting malicious expressions. The server is fundamentally unsafe to run in its current state without remediation.
Updated: 2025-11-21GitHub→
0
0
Medium Cost
iamfresh2 icon

mcp-server

by iamfresh2

Sec9

Manages and tracks personal or small business expenses by providing tools to add, list, and summarize financial entries.

Setup Requirements

  • ⚠️Requires Python 3.10 or higher.
  • ⚠️Requires local filesystem write access for the SQLite database in the system's temporary directory.
  • ⚠️Dependencies `aiosqlite` and `fastmcp` must be installed.
Verified SafeView Analysis
The application uses parameterized SQL queries ('?') which effectively prevents SQL injection vulnerabilities. It handles database initialization and operations asynchronously with `aiosqlite`, and includes error handling for database access issues (e.g., read-only mode). No 'eval' statements, hardcoded secrets, or obvious malicious patterns were found. The server binds to `0.0.0.0:8000`, which makes it accessible on all network interfaces; this is standard for local development but would require careful consideration and network security if exposed publicly.
Updated: 2025-11-19GitHub→
0
0
Medium Cost
consigcody94 icon

design-wand

by consigcody94

Sec8

Automate design workflows in Figma by providing AI-powered tools for file inspection, component management, asset export, style updates, and comment tracking.

Setup Requirements

  • ⚠️Requires generating a Figma Personal Access Token from your Figma account settings.
  • ⚠️Requires Node.js 18 or higher to run.
  • ⚠️Configuration for Claude Desktop requires specifying the absolute path to the server's executable file.
Verified SafeView Analysis
The server communicates with the Figma API using a user-provided personal access token. This token grants access to files the user can view. The server itself does not use 'eval' or obvious obfuscation. Input parameters are passed to the Figma API; potential vulnerabilities would mostly reside within the Figma API's handling of these inputs or how the client handles and stores the Figma token. The server handles and serializes JSON responses, which could reveal verbose error messages from the Figma API, but this is not a code execution risk. The README advises users to never commit tokens and to rotate them regularly.
Updated: 2025-11-25GitHub→
PreviousPage 611 of 713Next