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)

31
1
Low Cost
DocHatty icon
Sec9

This server enables LLMs to engage in non-linear, associative thinking for enhanced creativity and problem-solving by providing tools to explore conceptual space, detect cognitive stagnation, and foster unexpected connections.

Verified SafeView Analysis
The server's core logic in `lib.ts` focuses on string processing, stemming, and distance calculations, which are low-risk computational operations. It uses standard TypeScript and Node.js practices with no apparent use of `eval()` or direct execution of arbitrary user-provided code. Communication is primarily via standard I/O (stdio) as an MCP server, limiting direct network exposure from this application's code. Dependencies like `zod` and `@modelcontextprotocol/sdk` are standard; the SDK is responsible for handling the protocol, but this server does not add significant new attack vectors on its own.
Updated: 2025-12-09GitHub→
31
2
Low Cost
hmain icon

cainban

by hmain

Sec9

A command-line kanban board and an MCP server designed for natural language task management and AI agent integration, enabling AI to decompose tasks and manage project backlogs.

Setup Requirements

  • ⚠️Requires Go 1.21+ to build from source.
  • ⚠️Requires SQLite3 (usually pre-installed or included with Go).
  • ⚠️AI integration requires an MCP client (e.g., Amazon Q CLI, Claude Desktop) and specific `mcp.json` configuration.
Verified SafeView Analysis
The server appears secure for its intended use. It does not use 'eval' or similar dynamic code execution. Network risks are minimal as the MCP server uses standard I/O (stdio) for communication rather than opening network ports directly. No hardcoded secrets like API keys or credentials were found. Database paths are stored in the user's home directory (`~/.cainban`). Input validation is implemented in the task system (e.g., `ValidateTitle`, `IsValidStatus`), and MCP tool arguments are strongly typed, which mitigates injection risks. SQL queries utilize parameterized statements, preventing SQL injection.
Updated: 2025-11-22GitHub→
31
1
Medium Cost
winccoa-tools-pack icon

vscode-winccoa-mcp-server

by winccoa-tools-pack

Sec8

Enables AI assistants to interact with WinCC OA projects using the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires 'WinCC OA Project Admin Extension' (RichardJanisch.winccoa-project-admin) for automatic project detection and setup.
  • ⚠️Requires WinCC OA version 3.21+ (officially supported) for compatibility.
  • ⚠️Requires Node.js 14+ for the MCP Server runtime (the external Node.js application installed by the extension).
  • ⚠️After installing the MCP server manager, a full WinCC OA project restart (closing and reopening WinCC OA completely) may be necessary for the manager to appear in PMON, even if only a project restart is initially prompted.
Verified SafeView Analysis
The extension orchestrates the installation of an external Node.js-based MCP server into a WinCC OA project. It generates a strong random token for API authentication (Bearer token) and stores it in a `.env` file. Communication with the MCP server uses standard HTTP/SSE. The setup process uses 'child_process.spawn' with 'shell: true' for 'npm install' and 'git clone' commands; while generally a security consideration, it's used with controlled commands. The default configuration of the deployed MCP server sets 'MCP_CORS_ORIGINS=*', which allows cross-origin requests from any domain. This setting should be reviewed and restricted in production deployments of the MCP server itself.
Updated: 2026-01-19GitHub→
31
1
Medium Cost
Talljack icon
Sec8

Aggregates trending content and data from a multitude of online platforms (e.g., GitHub, Hacker News, Product Hunt, AI tools, academic papers, job boards) for AI assistants and indie developers.

Setup Requirements

  • ⚠️Requires Python 3.10+.
  • ⚠️Optional API keys (REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET, OPENROUTER_API_KEY, HUGGINGFACE_TOKEN, SEMANTICSCHOLAR_API_KEY) are needed for full functionality or to bypass rate limits on some platforms. OpenRouter tools explicitly check for an API key.
  • ⚠️Some fetchers (e.g., TrustMRR, RemoteOK fallback) utilize Playwright for web scraping, which requires browser binaries to be installed (`playwright install`).
Verified SafeView Analysis
The server uses environment variables for sensitive API keys (Reddit, OpenRouter, HuggingFace, Semantic Scholar), which is good practice. It fetches data from numerous third-party APIs and performs web scraping on several sites (e.g., Betalist, Replicate, TrustMRR, Gumroad, Twitter via Nitter). Web scraping introduces inherent fragility and potential for breakage if target site structures change. The `TrustMRRFetcher` and fallback for `RemoteOKFetcher` utilize Playwright, which launches a headless browser, adding a dependency and another process to manage. However, there are no obvious hardcoded secrets or malicious code patterns detected in the provided snippets. Input sanitization is implicitly handled by the Pydantic models for output, but direct HTML/JSON parsing should be robust to malformed data.
Updated: 2025-12-04GitHub→
31
3
High Cost
2dogsandanerd icon

DAUT

by 2dogsandanerd

Sec6

AI-powered tool to automatically generate and maintain documentation for codebases using LLMs and RAG.

Setup Requirements

  • ⚠️Python 3.9+ required
  • ⚠️Local Ollama instance running with `llama3` and `nomic-embed-text` models required for AI generation/embeddings
  • ⚠️Local ChromaDB server required for semantic search and vector storage
  • ⚠️MCP_API_KEY environment variable MUST be set to a strong, unique value for secure MCP server operation (default is insecure)
Verified SafeView Analysis
The MCP server uses an API key for authentication. However, the `start_mcp.sh` script and `daut-mcp.service` file default to a weak `MCP_API_KEY="secret-token-123"`. This default MUST be changed by the user to a strong, unique key for secure operation, as explicitly warned in the README.
Updated: 2026-01-06GitHub→
31
1
Low Cost
zhiyibaby icon
Sec8

Provides Huawei Cloud API access for AI assistants to query resources, prices, and guide workflows.

Setup Requirements

  • ⚠️Huawei Cloud API Keys: The `README.md` suggests setting `HUAWEI_CLOUD_ACCESS_KEY` and `HUAWEI_CLOUD_SECRET_KEY`. However, the source code (`src/huawei_cloud_ops_mcp_server/config/hw.py`) expects account-specific environment variables (e.g., `XIAOHEI2018_CLOUD_ACCESS_KEY`, `KRSK2021_CLOUD_ACCESS_KEY`) depending on the `account` parameter in tool calls. Users must ensure the correct account-specific variables are set, otherwise authentication will fail.
  • ⚠️Python Version: Requires Python >= 3.11.
  • ⚠️API Method Restrictions: The `huawei_api_request` tool currently only supports `GET` requests for most services. `POST` requests are only supported for `LTS` log content queries. Other `POST`, `PUT`, `DELETE` operations are not supported.
Verified SafeView Analysis
The server retrieves Huawei Cloud API keys from environment variables, which is good practice. API requests are signed using standard cryptographic methods (HMAC-SHA256/SM3). It explicitly restricts `huawei_api_request` to 'GET' methods (with a specific exception for 'POST' on LTS log queries), preventing arbitrary write/delete operations. Error handling, specifically `strict_error_handler`, captures all exceptions and returns full tracebacks in its output, which could expose internal system details if not handled securely by the consuming AI client. The server itself does not perform LLM calls, so 'avg_tokens_per_call' is not applicable to its internal operations.
Updated: 2025-12-04GitHub→
31
1
Low Cost
juliooidella icon

my-server-mcp

by juliooidella

Sec9

Integrates Jira Cloud and Discord with GitHub Copilot via an MCP server to automate development tasks and provide context to AI agents.

Setup Requirements

  • ⚠️Requires an Atlassian Jira Cloud account and a generated API token.
  • ⚠️Requires GitHub Copilot enabled and VS Code (v1.102+) for client integration.
  • ⚠️The `MCP_PROD_TOKEN` environment variable is mandatory for server authentication.
Verified SafeView Analysis
The server uses environment variables for all sensitive credentials (Jira username, API token, MCP token, Discord webhook URL), preventing hardcoding. It implements token-based authentication (`MCP_PROD_TOKEN`) for client-server communication using `StaticTokenVerifier`. No 'eval' or malicious patterns were found. While Jira custom field IDs are hardcoded, this is typical for Jira integrations and not a security vulnerability. Error handling for API calls is present, but comprehensive input sanitization for all tool parameters against potential injection attacks, if exposed to untrusted inputs, could be further enhanced. Given its intended use as an internal tool for a Copilot agent, current measures are strong.
Updated: 2025-12-05GitHub→
31
1
Low Cost
adrianmdevs icon

mcp_server_ts

by adrianmdevs

Sec8

Provides a Model Context Protocol (MCP) server that exposes defined tools (e.g., "create-user") for client applications.

Setup Requirements

  • ⚠️Requires Node.js (version >=18 as per `package-lock.json` for several dependencies) and npm installed.
  • ⚠️For development, running `node src/server.ts` directly on a TypeScript file typically requires `ts-node` (a dev dependency) or a prior TypeScript compilation step (`tsc`) to produce JavaScript output. The `server:dev` script implicitly relies on this setup.
  • ⚠️The Model Context Protocol SDK is a core dependency, and understanding its architecture is necessary for effective development and interaction.
Verified SafeView Analysis
The provided `src/server.ts` defines a 'create-user' tool, but its implementation is an empty `try...catch` block. This means no actual data persistence or external interaction occurs within the tool's logic as provided, minimizing immediate security risks. However, if real database or external API calls were to be added to this empty block, they would require robust input validation and sanitization to prevent common vulnerabilities (e.g., SQL injection, XSS). The server uses `StdioServerTransport` for local communication, which limits direct network attack surface, unless the commented `StreamableHTTPServerTransport` is enabled without proper security configurations. The `DANGEROUSLY_OMIT_AUTH=true` flag in a `package.json` script (`server:inspect`) is a development-time risk associated with the inspector, not the server's core runtime logic, but highlights a potential for misconfiguration.
Updated: 2025-12-13GitHub→
31
1
Medium Cost
dilettacal icon

bug-buster-ai

by dilettacal

Sec4

A cybersecurity AI agent that analyzes Python code for vulnerabilities using OpenAI's LLMs and Semgrep, deployable on Azure and GCP.

Setup Requirements

  • ⚠️Requires Docker for recommended local setup, or Node.js and `uv` for local development.
  • ⚠️Requires OpenAI API Key (paid service) and Semgrep App Token for core functionality.
  • ⚠️Requires significant Azure CLI and Terraform setup for cloud deployment, including manual Key Vault secret population and Container App secret linking post-Terraform apply.
  • ⚠️The presence of `eval(expr)` in `backend/airline.py` is a critical security risk; ensure `airline.py` is not used in a production or user-facing context, or remove it entirely.
Review RequiredView Analysis
The `backend/airline.py` file, which is part of the provided source code, contains a `calculate` function that uses `eval(expr)`. If this function were exposed to untrusted user input, it would be a severe remote code execution vulnerability. While `backend/server.py` (the core API) does not appear to directly use this `airline.py` file, its presence in the repository's backend makes it a significant security risk if the architecture were ever changed or if `airline.py` were invoked in an insecure context. Other aspects, like handling API keys via Key Vault and OIDC for deployment, are good practices. Diagnostic endpoints `/network-test` and `/semgrep-test` provide system information, which could be a minor information disclosure risk, but are common for health checks.
Updated: 2025-11-23GitHub→
31
1
Low Cost
murigugitonga icon

mcp_server_client

by murigugitonga

Sec7

A Node.js server that exposes a "create-user" tool, designed to be integrated with LLMs via the Model Context Protocol SDK.

Setup Requirements

  • ⚠️Requires Node.js (version >=18 recommended as per package-lock.json and peer dependencies)
  • ⚠️Requires `npm install` to setup dependencies
  • ⚠️Requires TypeScript environment to build (`tsc`) or run directly with `ts-node` (as in `server:dev` script)
Verified SafeView Analysis
The `src/server.ts` file itself does not contain obvious security vulnerabilities, hardcoded secrets, or direct network exposure (it uses `StdioServerTransport` for local communication). It leverages Zod for input validation, which is a good practice. However, the `package.json` contains a `server:inspect` script that explicitly sets `DANGEROUSLY_OMIT_AUTH=true` when running with `@modelcontextprotocol/inspector`. While intended for local development and inspection, this flag bypasses authentication and represents a significant security risk if this server (or any server using the inspector) were ever exposed on a network in a non-development context. Additionally, the `create-user` tool's implementation is an empty `try...catch` block, meaning the actual data handling and its security cannot be assessed from the provided snippet.
Updated: 2025-12-13GitHub→
31
1
Medium Cost
abneetwats24 icon

hr-policy-mcp

by abneetwats24

Sec6

Provides HR policy documents and basic math tools as authenticated Model Context Protocol (MCP) resources for consumption by AI agents.

Setup Requirements

  • ⚠️Requires an external Keycloak server running and accessible (e.g., at http://192.168.10.7:5555/realms/openspace) with a configured realm and client.
  • ⚠️Critical environment variables for OAuth2 client credentials (OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET) and the Keycloak issuer URL must be set via a .env file.
  • ⚠️Requires Python 3.13 or newer.
Review RequiredView Analysis
The server uses `httpx.AsyncClient(verify=False)` when performing OAuth2 token introspection, which disables SSL/TLS certificate validation. This is a critical security vulnerability for production environments, making it susceptible to Man-in-the-Middle (MITM) attacks. Additionally, the `CORSMiddleware` is configured with `allow_origins=["*"]`, which is overly permissive and insecure for production. While basic SSRF protection is implemented for the introspection endpoint, it relies on a hardcoded whitelist of local IP ranges, which may not be comprehensive. No hardcoded secrets were found, as client credentials are expected via environment variables.
Updated: 2025-12-12GitHub→
31
1
Low Cost
midasol icon

sap-mcp-server

by midasol

Sec8

Enables AI agents and applications to interact with SAP Gateway systems through a modular architecture for OData operations.

Setup Requirements

  • ⚠️Requires Python 3.11 or higher.
  • ⚠️Requires SAP Gateway access credentials configured in a '.env.server' file at the project root.
  • ⚠️Integration with external tools like Gemini CLI requires careful manual configuration of absolute paths and 'cwd' (current working directory) parameter in the client's settings file, which is noted as 'ABSOLUTELY CRITICAL' and a common troubleshooting point.
  • ⚠️For AI-powered examples, Google Gemini API Key is required.
Verified SafeView Analysis
The server emphasizes secure SAP integration with enterprise-grade authentication and SSL/TLS support. Credentials are managed via '.env.server' file, explicitly instructed not to be committed to version control, and proper file permissions are recommended. Input validation for OData queries is implemented to prevent injection attacks. However, the server's stdio transport directly exposes raw exception messages (str(e)) in case of tool call failures, which is an information leak and could be a moderate risk. The 'SAP_VERIFY_SSL=false' option, while intended for development, poses a risk if mistakenly used in production.
Updated: 2025-12-14GitHub→
PreviousPage 203 of 760Next