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)

32
1
Medium Cost
ondata icon
Sec8

Enables AI agents to interact with CKAN-based open data portals for searching, exploring, and querying datasets, organizations, and tabular data.

Setup Requirements

  • ⚠️Requires Node.js v18.0.0 or higher.
  • ⚠️Requires an MCP-compatible client (e.g., Claude Desktop, HTTP client) to interact with it.
  • ⚠️To run as an HTTP server, the `TRANSPORT=http` environment variable must be set (default is `stdio`).
  • ⚠️Deploying to Cloudflare Workers requires the `wrangler` CLI and a Cloudflare account.
Verified SafeView Analysis
The server is designed for read-only access to public CKAN APIs. It makes HTTP GET requests to user-provided `server_url`s, which could potentially be abused for Server-Side Request Forgery (SSRF) if the runtime environment allows access to internal networks. However, interaction is restricted to known CKAN API v3 endpoints, and robust input validation with Zod schemas is used. No direct remote code execution (RCE) vectors or hardcoded secrets are evident. Dependency `@modelcontextprotocol/sdk` has been updated to fix a critical ReDoS vulnerability.
Updated: 2026-01-19GitHub→
32
1
Low Cost
lukaszzychal icon

mcp-doc-generator

by lukaszzychal

Sec9

Generates technical documentation and various diagrams (architecture, UML, sequence, flowchart, Gantt, dependency, cloud) from code or natural language prompts, supporting Polish, and exports to PDF/DOCX. Includes optional AI image generation.

Setup Requirements

  • ⚠️Requires Docker and Docker Compose for full functionality (recommended setup).
  • ⚠️OpenAI API Key (OPENAI_API_KEY environment variable) is required for AI image generation tools (generate_image_openai, generate_icon_openai, generate_illustration_openai). These tools incur a cost (e.g., $0.04 per standard 1024x1024 image) and are not token-based.
  • ⚠️External network access is used by default for Mermaid (via mermaid.ink API) and OpenAI tools. Local Mermaid CLI execution is a fallback option.
Verified SafeView Analysis
The server uses subprocess execution for Graphviz, Pandoc, and Mermaid CLI, but input content is generally written to temporary files and output paths are carefully constructed with absolute paths within a dedicated output volume, mitigating direct command injection risks. OpenAI and Mermaid.ink API calls are made via `aiohttp`, reducing direct shell interaction. Environment variables are used for API keys. Designed to run in Docker, providing isolation. The `_enhance_prompt_for_no_text` function handles user prompts before passing to DALL-E, but the parsing in `mcp_client.py` (client-side) could lead to unexpected arguments if not handled carefully, though server-side tools have input validation.
Updated: 2025-12-03GitHub→
32
2
Low Cost
scalekit-inc icon

scalekit-mcp-server

by scalekit-inc

Sec8

This server enables AI agents to interact with Scalekit's identity platform through the Model Context Protocol (MCP) for natural language identity management.

Setup Requirements

  • ⚠️Requires a Scalekit account and configured API credentials (SK_CLIENT_ID, SK_CLIENT_SECRET, etc.) to interact with the Scalekit platform.
  • ⚠️Requires Node.js version 18 or greater, as indicated by various dependency `engines` fields in `package-lock.json` and ES module usage.
Verified SafeView Analysis
The server uses environment variables for sensitive credentials (API keys, secrets), which is good practice. Input validation is performed using Zod schemas and custom functions for email/URL formats. Authentication is handled by `@scalekit-sdk/node` for token validation, including scope checks for tool calls. Error handling is present with appropriate logging and responses. CORS is configured to allow all origins, which is broad but might be necessary for diverse MCP client environments. The server relies on external Scalekit APIs, so its security is also dependent on the robustness of those services. No 'eval' or obvious malicious patterns were detected.
Updated: 2026-01-19GitHub→
32
5
High Cost
jgardner04 icon

Ghost-MCP-Server

by jgardner04

Sec9

Manages a Ghost CMS instance programmatically by exposing its Admin API as an MCP Server, allowing AI agents or other systems to create, update, delete, and retrieve content (posts, pages, tags, members, newsletters, tiers) and upload images.

Setup Requirements

  • ⚠️Requires `GHOST_ADMIN_API_URL` and `GHOST_ADMIN_API_KEY` environment variables.
  • ⚠️The image upload tool (`ghost_upload_image`) can only download images from a whitelist of domains (imgur.com, github.com, unsplash.com, cloudinary.com, amazonaws.com) for security reasons. Other image sources will be blocked.
  • ⚠️Large list operations (e.g., `get_posts` with `limit=100`) can generate very large JSON outputs, potentially incurring high token costs for AI models.
Verified SafeView Analysis
The server implements robust security measures including comprehensive input validation (Zod schemas), NQL injection prevention, HTML sanitization (XSS prevention) for content and notes, and a tightly controlled URL validator (SSRF protection) for image downloads. API keys are loaded from environment variables and handled securely. Rate limiting and graceful shutdown are also implemented. The image URL validator whitelist is very restrictive (only a few popular image hosting domains), which is a strong security choice but could be a functional 'gotcha' for users.
Updated: 2026-01-07GitHub→
32
1
Low Cost
ryar001 icon

finance_mcp

by ryar001

Sec8

Provides structured financial statements (Income Statement, Balance Sheet, Cash Flow) from public companies for consumption by LLMs via an MCP server.

Setup Requirements

  • ⚠️Relies on `yfinance` for data, which scrapes Yahoo Finance; respect Yahoo Finance's terms of service to avoid potential IP bans or service interruptions.
  • ⚠️Requires `uv` package manager (or `uvx`) for the recommended quick installation and execution method.
  • ⚠️While documentation mentions `GEMINI_API_KEY`, the current implementation directly uses `yfinance` and does not incur LLM token costs for data retrieval, but this might change in future iterations based on project history.
Verified SafeView Analysis
The server primarily uses the `yfinance` library to scrape data from Yahoo Finance, which carries a note in the README about respecting Yahoo Finance's terms of service. There are no explicit `eval` or direct code injection vulnerabilities observed. The logging configuration includes async handlers which is good. Firestore integration is present but not actively used for core data retrieval by the MCP tools. While `GEMINI_API_KEY` is referenced in documentation, the current implementation bypasses LLM for data fetching, thus reducing direct exposure to potential LLM-related prompt injection risks from this component. The server runs as a local process and communicates via standard I/O for MCP, which generally limits direct network exposure.
Updated: 2025-12-10GitHub→
32
2
High Cost
ardaaltinors icon

MemCP

by ardaaltinors

Sec4

MemCP provides a memory management system for AI assistants, enabling persistent context, knowledge graphs, and user profile synthesis across conversations and various AI platforms.

Setup Requirements

  • ⚠️Requires paid API keys for OpenAI or Google Gemini (for embeddings and LLM inference).
  • ⚠️Requires Docker and Docker Compose for the full infrastructure setup (PostgreSQL, Qdrant, RabbitMQ, Redis).
  • ⚠️Requires Python 3.11+ and the 'uv' package manager for local development setup.
  • ⚠️Multiple external services (PostgreSQL, Qdrant, RabbitMQ, Redis) must be running and accessible.
Review RequiredView Analysis
The application demonstrates several good security practices, including strong password hashing (bcrypt), extensive use of environment variables for secrets, and redaction of sensitive information (like API keys, passwords, tokens) in logs. Database queries appear to be parameterized, mitigating SQL injection risks. However, a **critical XSS vulnerability** exists in `src/middlewares/mcp_oauth_redirect_middleware.py`. The `redirect_url` from user-controlled query parameters is directly embedded into a JavaScript `window.location.href` assignment without proper sanitization. This allows malicious `javascript:` URIs to execute arbitrary code in the user's browser context. Path-based API keys (`/mcp/{api_key}`) are also generally less secure than header-only authentication, though header-based API keys are also supported.
Updated: 2025-11-25GitHub→
32
1
Low Cost
DIMANANDEZ icon

refrag

by DIMANANDEZ

Sec8

A Python library for Retrieval Augmented Generation (RAG) that uses micro-chunking, fast direct embedding, and query-time heuristic compression to reduce context size and improve retrieval efficiency, with optional LLM-based reranking for precision.

Setup Requirements

  • ⚠️Requires OpenAI or Anthropic API Key (Paid, only if using the optional REFRAGReranker component)
  • ⚠️Requires `sentence-transformers` models (downloaded on first use, can be large depending on model)
  • ⚠️The official documentation (README, How-It-Works) describes a system that uses LLMs for generating representations during indexing, but the provided source code explicitly implements 'Fast direct encoding (no LLM during indexing)' and heuristic compression, making the core functionality LLM-free and contradicting the documentation's core innovation description.
Verified SafeView Analysis
The core implementation (embedder, compressor) does not use LLMs, which reduces immediate security risks associated with prompt injection or external API calls for core processing. The `REFRAGReranker` component, however, makes external API calls to OpenAI or Anthropic, which introduces standard risks of data privacy, reliance on external services, and potential cost accumulation. API keys are appropriately sourced from environment variables. The use of regex in `ChunkCompressor` for keyword extraction could, in theory, be susceptible to ReDoS attacks with crafted inputs, though the patterns used are relatively simple. An example in the documentation shows `pickle` usage for index saving/loading; loading pickled data from untrusted sources is a deserialization vulnerability, but this is an example for user implementation rather than a core library function.
Updated: 2026-01-19GitHub→
32
2
Medium Cost
pugazhmukilan icon
Sec5

The server provides LLMs and MCP clients with a standardized way to access, search, and process local files, including text, code, and PDFs, through Model Context Protocol resources and tools.

Setup Requirements

  • ⚠️Requires Python 3.10+ (pyproject.toml specifies this, contradicting README's 3.8+).
  • ⚠️Requires the `FILE_PATH` environment variable to be set, pointing to the target local directory for file operations.
  • ⚠️Dependencies `mcp` and `pymupdf` must be installed (`pip install mcp pymupdf`).
Review RequiredView Analysis
The server uses `os.path.join(basepath, filename)` to construct file paths based on a configurable `FILE_PATH` environment variable. While this handles basic path concatenation, there is no explicit validation or sanitization of the `filename` parameter (e.g., checking for '..' or absolute paths) to prevent path traversal attacks. An attacker or a misaligned LLM could potentially use `filename` values like `../../../etc/passwd` to read arbitrary files outside the designated `FILE_PATH` directory, despite the README's claim of 'sandboxing'. No hardcoded secrets or 'eval' statements were found.
Updated: 2025-12-01GitHub→
32
2
Medium Cost
hyperf icon
Sec6

Provides an annotation-driven, high-performance Model Context Protocol (MCP) server implementation built on the Hyperf framework, supporting tools, prompts, resources, and Redis-backed session management.

Setup Requirements

  • ⚠️Requires Hyperf Framework: This is a library designed for integration into an existing or new Hyperf application, not a standalone executable.
  • ⚠️Redis Server Required for Sessions: The default session manager (RedisSessionManager) requires a running Redis instance configured in the Hyperf application.
  • ⚠️Authentication is Disabled by Default: For any production or secure environment, users *must* implement and configure a custom AuthenticatorInterface as the provided NullAuthenticator offers no security.
Review RequiredView Analysis
The server defaults to NullAuthenticator, meaning no authentication is enforced out-of-the-box. This is a severe security risk for production deployments; users must explicitly implement and configure a custom AuthenticatorInterface. Method invocations rely on schema validation to prevent malicious input, which depends on the robustness of the underlying dtyq/php-mcp library's SchemaUtils. Redis security is critical for session management. The example API Key Authenticator in the README contains hardcoded keys, which should be replaced with secure key management in production.
Updated: 2025-11-30GitHub→
32
1
Medium Cost
KSAklfszf921 icon

SCB-MCP

by KSAklfszf921

Sec9

Provides AI assistants and LLMs with structured access to official Swedish statistics and data from Statistics Sweden (SCB) for querying, retrieval, and analysis.

Setup Requirements

  • ⚠️Optimal search performance requires using Swedish search terms for best results.
  • ⚠️Local installation requires Node.js version 18.0.0 or higher.
Verified SafeView Analysis
The server acts as a proxy to a public API (Statistics Sweden's PxWebAPI 2.0). It uses CORS with `origin: '*'`, which is appropriate for a public, stateless API designed to be consumed by various clients. No `eval` or direct command injection vulnerabilities were found in the runtime code. No hardcoded secrets. `node-fetch` is used for external requests. Rate limiting is implemented for the proxied API. Error handling includes structured JSON-RPC errors. An `execSync` call is present in a build script (`scripts/update-api-types.ts`), which is not part of the runtime server and thus poses a low risk.
Updated: 2025-12-02GitHub→
32
2
Medium Cost
danchev icon

openmarkets

by danchev

Sec8

Provides a Model Context Protocol (MCP) server for agentic retrieval of financial market data from Yahoo Finance, facilitating integration with LLMs and AI applications.

Setup Requirements

  • ⚠️Requires Python 3.10 or newer.
  • ⚠️Requires `uvx` (or `uv`) for simplified installation and execution, as described in the README.
  • ⚠️Relies on Yahoo Finance for data, which may impose rate limits or IP blocking for excessive requests.
Verified SafeView Analysis
The server leverages `yfinance` and `curl_cffi` for data retrieval, which involves making external network requests to Yahoo Finance. While these libraries are reputable, any reliance on external data sources carries inherent risks related to data accuracy, availability, and potential (though unlikely) malicious responses. The code does not exhibit direct use of `eval` or `exec`, nor does it handle sensitive user input in a way that suggests common injection vulnerabilities. CORS is configurable via the `CORS_ALLOW_ORIGINS` environment variable, defaulting to `*` for broad access, which should be restricted in production environments for enhanced security. No hardcoded credentials were identified. The execution method `uvx` is a standard and generally safe tool for running Python packages.
Updated: 2026-01-19GitHub→
32
2
Low Cost
shini4i icon
Sec9

Exposes Argo Watcher deployment history via the Model Context Protocol (MCP) to allow AI agents and other clients to query deployment data.

Setup Requirements

  • ⚠️Requires a running instance of Argo Watcher as an upstream dependency.
  • ⚠️Requires Go 1.25+ for local development and building.
  • ⚠️The `ARGO_WATCHER_URL` environment variable is mandatory.
Verified SafeView Analysis
The project follows good security practices by externalizing sensitive configurations (like ARGO_WATCHER_URL and OTLP endpoints) through environment variables rather than hardcoding. It uses Go, a memory-safe language, which mitigates common vulnerabilities. OpenTelemetry is integrated, providing observability. The explicit `OTEL_EXPORTER_OTLP_INSECURE` flag allows control over TLS for OTLP connections, which is a conscious decision point for operators. No `eval` or similar dangerous patterns were found. Network risks are primarily associated with the configured `ARGO_WATCHER_URL` which, if compromised, could impact the integrity of the data served.
Updated: 2025-11-29GitHub→
PreviousPage 187 of 760Next