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)

30
1
High Cost
yanqinghao icon

mcp-crypto-server

by yanqinghao

Sec8

A high-performance platform for real-time cryptocurrency and stock market data, technical analysis, LLM-powered insights, and news aggregation, primarily for generating trading signals and reports for AI applications.

Setup Requirements

  • ⚠️Requires paid API keys for cryptocurrency exchanges (e.g., Binance), potentially AKShare/yfinance for stock data, and a paid LLM service (e.g., OpenAI API Key).
  • ⚠️Docker and Docker Compose are essential for running the TimescaleDB database and the multi-service architecture.
  • ⚠️Telegram Bot Token and Chat ID are necessary for receiving alerts and signals.
  • ⚠️Requires Python 3.9+ and the 'uv' package manager for local development and dependency management.
Verified SafeView Analysis
Sensitive credentials such as API keys for exchanges and Telegram tokens are correctly loaded from environment variables. There are no direct 'eval' calls or obvious obfuscation. Network access is essential for its functionality (exchanges, Telegram API). The Docker setup exposes standard ports. Overall, good security practices are followed for credential handling.
Updated: 2025-11-24GitHub→
30
1
Low Cost
hyperpolymath icon

poly-k8s-mcp

by hyperpolymath

Sec4

Provides a Model Context Protocol (MCP) server for AI assistants to programmatically manage Kubernetes clusters using kubectl, Helm, and Kustomize CLIs.

Setup Requirements

  • ⚠️Requires Deno runtime (v2.0+).
  • ⚠️Requires `kubectl`, `helm` (optional), and `kustomize` (optional) CLIs to be installed and accessible in the system's PATH.
  • ⚠️Requires a valid Kubernetes kubeconfig (`~/.kube/config` or `KUBECONFIG` environment variable) with appropriate cluster access.
  • ⚠️Must be run with Deno's `--allow-run`, `--allow-read`, `--allow-write`, `--allow-env`, and potentially `--allow-net` permissions, granting broad system access.
Review RequiredView Analysis
The server explicitly requires and uses Deno's `--allow-run` permission to execute `kubectl`, `helm`, and `kustomize` CLI tools directly. This means the security boundary is the user's local Kubernetes configuration (`~/.kube/config`) and credentials. An MCP client (e.g., AI assistant) could perform any action the user's configured `kubectl` can. There are no additional authentication or authorization layers provided by the server itself beyond the underlying CLI tools. The `kubectl_apply` tool writes manifest content to `/tmp/kubectl-manifest.yaml` before applying it, which is a common pattern but could pose risks if the server runs in a compromised environment or with over-privileged access. The `kustomize_create` tool writes `kustomization.yaml` files based on input, allowing arbitrary Kustomize configuration to be created. The project's `PROVEN-INTEGRATION.md` indicates future plans for formal verification of resource lifecycles, RBAC, and manifest validation (`SafeSchema`), but these are not currently implemented, meaning input validation against Kubernetes schemas is not enforced by the server itself.
Updated: 2026-01-17GitHub→
30
1
Medium Cost
GalacticQuasar icon

nova-llm

by GalacticQuasar

Sec8

A full-stack LLM agent workflow with custom tool calling capabilities and configuration with Model Context Protocol (MCP) servers, supporting multiple Gemini models.

Setup Requirements

  • ⚠️Requires a Google Gemini API Key (paid service) for LLM access.
  • ⚠️Requires Node.js 18+ and npm for both client and server setup.
  • ⚠️Automatically downloads and runs an external MCP server package via `npx` during initialization, requiring internet access and relying on the security of that third-party package.
Verified SafeView Analysis
The server uses environment variables for API keys (GEMINI_API_KEY) and client origin, which is good practice. A rate limit is applied to the streaming endpoint, enhancing protection against abuse. The custom tool calls (`getTime`, `getRandomNumber`) use safe native JavaScript functions, mitigating direct injection risks through their arguments. However, the server automatically executes `npx @modelcontextprotocol/server-sequential-thinking` to connect to an MCP server; while intended, this introduces a dependency on the security of that external package and the `npm` ecosystem during execution.
Updated: 2026-01-17GitHub→
30
1
Medium Cost
postmanlabs icon

postman-code-examples

by postmanlabs

Sec9

A CLI tool for searching, navigating, and reading content from a Notion workspace, designed for AI agents.

Setup Requirements

  • ⚠️Requires Node.js version 18 or higher.
  • ⚠️Requires creation of a Notion Integration with 'Read content' capabilities via notion.so/my-integrations.
  • ⚠️Notion pages and databases must be explicitly shared with the created integration for the CLI to access them.
  • ⚠️Requires the NOTION_API_KEY environment variable to be set with the integration's secret token.
Verified SafeView Analysis
The CLI securely handles API keys by requiring them to be loaded from environment variables (NOTION_API_KEY), preventing hardcoding. It interacts with the official Notion API endpoints. No 'eval' or obfuscation is present. Standard API interaction patterns are followed, and the code appears straightforward. Minor deduction for not including explicit network request timeouts in the generated fetch clients, which is a common practice for robustness but less critical for a simple demo.
Updated: 2026-01-16GitHub→
30
1
High Cost
shawnmcrowley icon

n8n_workflows

by shawnmcrowley

Sec3

This N8N server serves as a collection of production-ready automation workflows, exposing them as tools for AI agents (MCP clients) to enable dynamic, AI-driven automation across various platforms and data sources.

Setup Requirements

  • ⚠️Requires Docker and Docker Compose installed.
  • ⚠️Requires PostgreSQL with pgvector extension installed and configured.
  • ⚠️Requires N8N account or self-hosted instance (Docker setup handles this).
  • ⚠️Requires API keys for multiple external services (OpenAI, FireCrawl, EODHD, Ahrefs, SEMrush, BuzzSumo, AnswerThePublic, Reddit, Perplexity, OpenWeather, Alpha Vantage) which may be paid services.
  • ⚠️Requires a local Ollama instance running for local LLMs.
  • ⚠️Requires Redis for the dynamic workflow management feature (`build-your-own-n8n-workflows-mcp-server-.json`).
  • ⚠️For RAG chatbot, requires a Google Cloud Project with Vertex AI API enabled and Google AI API Key, and Pinecone account/index named 'company-files'.
  • ⚠️For Microsoft Excel integration, requires Microsoft Azure credentials with Microsoft Graph permissions.
  • ⚠️Many workflows require specific Google Cloud APIs enabled (Drive, Sheets, Gmail).
  • ⚠️Some workflows implicitly require a functional n8n API key (`N8N_API_KEY`) to retrieve workflow definitions.
Review RequiredView Analysis
Critical security risks identified: 1. **Hardcoded Secrets**: Multiple workflow files contain hardcoded API keys (e.g., NYT Article Search, FireCrawl, EODHD, Brave Search). These sensitive credentials are exposed in the source code, posing a significant vulnerability. 2. **Potential XSS in HTML Generation**: Workflows that generate HTML content (e.g., for emails) from dynamic data (e.g., `postgres_api_workflow_with_email-postgres.json`, `url-parsing-and-email-generation-.json`, `firecrawl_webscraping-.json`, `html-newsletter-with-real-time-data-.json`) do not appear to sanitize inputs before embedding them. If malicious content is injected into data sources, it could lead to Cross-Site Scripting (XSS) in email clients or rendered HTML outputs. 3. **Dynamic Workflow Execution**: The `build-your-own-n8n-workflows-mcp-server-.json` workflow allows AI agents to execute other N8N workflows by ID. While attempts are made to manage an 'available' list, this introduces a complex trust boundary. A compromised or maliciously prompted AI agent could potentially execute unintended or harmful workflows, bypassing their `availableInMCP: false` settings. The reliance on `workflowInputs` without strict validation could allow arbitrary parameter injection. 4. **Exposed Admin Interface**: PgAdmin is exposed on `localhost:5050` by default. While not publicly exposed in a standard Docker setup, if the host machine has public access, this becomes a direct attack vector to the PostgreSQL database. 5. **Sensitive Information in Logs**: Depending on the workflow execution and error handling, sensitive data or API responses might be inadvertently logged.
Updated: 2026-01-18GitHub→
30
1
Low Cost
tariksagbas1 icon

ai-agent-mcp-server

by tariksagbas1

Sec2

This project implements an MCP (Model Context Protocol) server and client using AMQP (RabbitMQ) for communication, enabling an LLM-powered agent to interact with internal tools and data resources.

Setup Requirements

  • ⚠️Requires a running RabbitMQ server instance, possibly via Docker, with pre-defined queues, exchanges, and services.
  • ⚠️Requires a `.idep` JSON configuration file (e.g., `configs/${DEPLOYMENT_CODE}.idep`) to define services, tools, and RabbitMQ topology.
  • ⚠️Requires an OpenAI API Key for the LLM component, incurring paid usage costs.
  • ⚠️The `docker-compose.yml` references a private Azure Container Registry (`deploymentagent.azurecr.io/icron-llm`) for the LLM service image, which may require specific authentication or access.
Review RequiredView Analysis
Critical security vulnerabilities found: 1. Hardcoded Google API credentials (CLIENT_ID, CLIENT_SECRET, REFRESH_TOKEN) are present in `backup.ts`. This is a severe risk as these secrets would be exposed if the code is publicly accessible. 2. Hardcoded RabbitMQ credentials (username: 'platform', password: 'platform', vhost: 'tarik.sagbas') are used in `service_core/rpc_client.py` for `rpc_call_mcp`, making client-to-server communication dependent on static, non-environment-variable-driven secrets. 3. The FastAPI client (`mcp_amqp/lg_agent.py`) enables CORS with `allow_origins=["*"]`, which is overly permissive and can expose the service to cross-site scripting (XSS) attacks or unauthorized access from any domain. 4. The use of `exec` in `mcp_amqp/app.py` for dynamic function generation, while seemingly controlled by predefined schemas, still presents a potential attack vector if the schema generation or input is compromised.
Updated: 2025-11-26GitHub→
30
1
Medium Cost
akkytech0617 icon

letta-cloud-mcp

by akkytech0617

Sec9

Provides a Model Context Protocol (MCP) server to connect AI agents like Factory Droid, Claude Code, and Cursor to Letta Cloud's stateful memory system for persistent memory, agent interaction, and archival storage.

Setup Requirements

  • ⚠️Requires a Letta Cloud API key (LETTA_API_KEY) which may involve a paid subscription on Letta Cloud's pay-as-you-go model.
  • ⚠️Requires Node.js version 18.0.0 or higher.
  • ⚠️Only supports Letta Cloud; not compatible with self-hosted Letta instances.
Verified SafeView Analysis
The server uses `process.env` for API keys, preventing hardcoding. Input validation is rigorously handled by Zod schemas for all tool arguments. Communication with Letta Cloud uses an official SDK, presumably over HTTPS. The server primarily communicates via standard I/O (stdio) as an MCP server, not exposing network ports directly. While `@modelcontextprotocol/sdk` (a dependency) can involve `cross-spawn` for running external processes, this specific server acts as the *target* for such commands from an MCP client, not an initiator of arbitrary commands based on user input. The main security considerations would be the secure handling of `LETTA_API_KEY` and the integrity of the MCP client connecting to it.
Updated: 2026-01-18GitHub→
30
1
Medium Cost
surrealwolf icon

high-command-mcp

by surrealwolf

Sec9

Provides an MCP server to access real-time Helldivers 2 game data via the High-Command API, exposing game status, planets, statistics, and more as callable tools.

Setup Requirements

  • ⚠️Requires Python 3.9+
  • ⚠️MCP client does NOT implement automatic retries for rate limits (applications must implement exponential backoff)
  • ⚠️Production deployments (ENVIRONMENT=production) must use HTTPS for HIGH_COMMAND_API_BASE_URL
  • ⚠️Helldivers 2 API might have Cloudflare bot protection requiring X-Super-Client and X-Super-Contact headers for reliable access
Verified SafeView Analysis
The project demonstrates robust security practices, including explicit HTTPS enforcement for production environments, non-root user execution, read-only root filesystem, and dropped capabilities in Kubernetes deployments. Environment variables are used for configuration, avoiding hardcoded secrets. Error messages are designed not to leak sensitive information. While the default development URL is HTTP, this is strictly validated against HTTPS for production.
Updated: 2026-01-12GitHub→
30
1
High Cost
ggmenu icon
Sec7

Extracts text from various document formats (PDF, DOCX, XLSX, CSV, TXT, JSON, Markdown) and converts them to Markdown.

Setup Requirements

  • ⚠️Requires Python 3.10+.
  • ⚠️Requires local installation of several document parsing libraries (e.g., pdfminer.six, openpyxl, python-docx). Full functionality (e.g., for `convert_to_markdown` and robust PDF image extraction) depends on `markitdown` and `PyMuPDF` (fitz), which are not explicitly listed in `setup.py`'s `install_requires` and may need to be installed separately, with PyMuPDF potentially requiring system dependencies.
  • ⚠️Windows PowerShell users may need to adjust the execution policy (`Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser`) to run automated setup scripts.
Verified SafeView Analysis
The server explicitly states it is designed for local, trusted environments and has no built-in authentication. It processes local files using `os.path.expanduser`, which could lead to reading arbitrary files within the process's permissions if an untrusted client sends malicious paths. Document parsing libraries (pdfminer.six, openpyxl, python-docx, markitdown, PyMuPDF) are used, which inherently carry risks if malformed or malicious documents are processed (no internal sandboxing for these libraries). However, the project provides comprehensive security documentation (`SECURITY.md`), enforces a 100MB file size limit, implements rate limiting, and truncates output for AI context protection. The `convert_to_markdown` tool converts the *entire* document to a file, bypassing the output truncation for the AI's preview, which could consume significant local resources.
Updated: 2026-01-19GitHub→
30
1
Medium Cost
ry-ops icon
Sec8

The server integrates with the Cloudflare API to enable AI agents to manage zones, DNS records, Workers KV storage, cache, and analytics.

Setup Requirements

  • ⚠️Requires a Cloudflare API Token with appropriate permissions (e.g., Zone - DNS - Edit, Account - Workers KV Storage - Edit).
  • ⚠️Requires a Cloudflare Account ID for all Workers KV operations.
  • ⚠️Manual configuration in Claude Desktop's `claude_desktop_config.json` is needed, including an absolute path to the server directory.
Verified SafeView Analysis
The server uses `httpx` for making API requests and retrieves sensitive API tokens from environment variables, which is a good practice. There is no usage of `eval` or other obvious code execution vulnerabilities. Input arguments are passed directly to the Cloudflare API, relying on Cloudflare's own API for input validation and sanitization. The primary security consideration is ensuring the Cloudflare API token has only the minimum necessary permissions to prevent privilege escalation.
Updated: 2026-01-18GitHub→
30
1
Medium Cost
deeprave icon

mcp-server-guide

by deeprave

Sec9

An MCP server that centralizes AI agent instructions, documentation, and guidelines to support an iterative and phased software development cycle, ensuring structured, collaborative, and high-quality outcomes.

Setup Requirements

  • ⚠️Requires `uv` (Ruff's package manager and installer) for Python dependency management.
  • ⚠️Requires Python 3.13+.
  • ⚠️For Kiro CLI integration, `kiro-cli` must be separately installed and available in your system's PATH.
  • ⚠️Initial setup may involve interactive prompts for template installation and configuration file creation if not using Docker/auto-init.
Verified SafeView Analysis
The project demonstrates a high level of security awareness. It employs robust URL validation to prevent SSRF attacks, path validation and sanitization to prevent path traversal and unsafe filenames, and enforces explicit actions for critical file system operations. The Kiro CLI integration scripts include shell-level allowlisting for paths and commands, combined with consent mechanisms, creating strong guardrails for agent interactions. Content size validation is also present. There are no obvious `eval()` or obfuscation patterns, nor hardcoded secrets.
Updated: 2025-11-27GitHub→
30
1
High Cost
trysoma icon

soma

by trysoma

Sec7

A platform for building and managing AI agents and functions using the Model Context Protocol (MCP). It provides SDKs for Python and TypeScript to define agents and functions, and an API server to manage them, including identity, encryption, and bridging capabilities to integrate with external AI models and services. The insurance claim bot serves as a comprehensive example application.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid) or a compatible LLM API key for AI agent functionality.
  • ⚠️Requires a running Restate server instance.
  • ⚠️Development and deployment require both Python (>=3.8) and Node.js (>=18) environments with pnpm for dependency management.
  • ⚠️The Protobuf compiler (`protoc`) is needed for certain Rust build targets.
Verified SafeView Analysis
The system incorporates robust encryption and secret management features, supporting KMS integration. However, the use of `exec` within Python code generation (even if on trusted templates) presents a potential, albeit mitigated, risk. Hardcoded bootstrap/test API keys and default encryption aliases (e.g., 'default' DEK alias) require careful handling and rotation in production environments. Network interactions with external AI models and the Restate runtime also necessitate proper input validation, sanitization, and secure configuration.
Updated: 2026-01-16GitHub→
PreviousPage 213 of 760Next