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
bioanywhere icon

mcp-gitlab-mcp-server

by bioanywhere

Sec9

Integrate an AI assistant with GitLab to manage merge requests, CI/CD pipelines, code reviews, and discussions.

Setup Requirements

  • ⚠️Requires a GitLab Private Access Token with appropriate permissions.
  • ⚠️Requires a specific GitLab Project ID to be configured.
  • ⚠️Requires Python 3.10+ and all dependencies listed in pyproject.toml to be installed within a virtual environment.
Verified SafeView Analysis
The server securely handles GitLab access tokens by requiring them as environment variables, preventing hardcoding. It uses `aiohttp` for asynchronous HTTP requests to the GitLab API, which is a standard and secure practice. There is no usage of 'eval' or other directly dangerous functions. Input validation is handled at the tool schema level, and basic error handling is present. Further hardening could involve more granular access control if the server is exposed to untrusted clients, but for its intended use case, it is well-implemented.
Updated: 2025-12-10GitHub→
0
0
High Cost
IrfanThomson icon

claude-code-settings

by IrfanThomson

Sec3

Manages and synchronizes global configuration settings for Claude Code, including multi-agent setup and secure secrets management across different machines.

Setup Requirements

  • ⚠️Requires `claude-code` CLI tool to be installed globally (via npm).
  • ⚠️Requires `python3` and `openssl` for secrets management scripts.
  • ⚠️Grants broad `sudo` and `docker` permissions to the Claude Code agent, posing a significant security risk that must be carefully reviewed and potentially restricted.
  • ⚠️Requires separate installations for MCP servers like Obsidian MCP (e.g., `uvx obsidian-mcp`) and Docker for Atlassian MCP.
  • ⚠️Requires API keys for Jules (Google) and potentially Jira/Confluence credentials (paid services).
Review RequiredView Analysis
CRITICAL RISK: The `settings.local.json` file grants very broad `Bash` permissions to the Claude Code agent, including `Bash(sudo systemctl start:*)`, `Bash(sudo usermod:*)`, and `Bash(sudo -S docker:*)`. Granting `sudo` permissions to an AI agent is a severe security vulnerability, as a compromised agent or successful prompt injection could lead to arbitrary command execution with root privileges on the host system. This poses an extreme risk of system compromise. A minor concern is the hardcoded `OBSIDIAN_REST_API_KEY` and `OBSIDIAN_URL` in `obsidian-mcp-config.json`, which is committed publicly, though it appears to be for local access and potentially a placeholder. The secrets management system itself (encryption/decryption scripts) is well-designed using OpenSSL and explicitly avoids committing plaintext secrets.
Updated: 2025-12-13GitHub→
0
0
Low Cost
robotmcp icon
Sec8

Control a Tugbot mobile robot in a simulated warehouse environment using natural language via an AI LLM and the ROS-MCP server.

Setup Requirements

  • ⚠️Requires Ubuntu 22.04 LTS and ROS 2 Humble due to Gazebo compatibility and ROS distribution.
  • ⚠️Specific ROS 2 packages (`ros-humble-ros-gz`, `ros-humble-rosapi`, `ros-humble-rosbridge-server`) must be installed via `apt`.
  • ⚠️Uses `uv` for Python environment management, and ROS system bindings must be installed into the virtual environment.
Verified SafeView Analysis
The system uses `ExecuteProcess` to launch Gazebo, which is standard but could be a vector for injection if inputs were user-controlled (not the case here with fixed commands). The `rosbridge_websocket` node opens a network port (default 9090) without explicit authentication in this configuration, which is expected for its function but represents a network ingress point. In a non-isolated environment, this could pose a risk if not properly secured via firewalls or network segmentation. No hardcoded secrets or obvious malicious patterns were found in the provided code.
Updated: 2025-12-08GitHub→
0
0
Low Cost
sauronx2 icon
Sec8

Orchestrates multiple AI agents in parallel using the Model Context Protocol (MCP) for Claude Code environments.

Setup Requirements

  • ⚠️Requires Docker and Docker Compose for setup and execution.
  • ⚠️Requires Claude Code to connect and utilize its features.
Verified SafeView Analysis
The provided source code (docker-compose.yml and README.md) does not contain obvious security vulnerabilities like hardcoded secrets, 'eval' usage, or obfuscation. The server exposes port 8080 via SSE, which is a common communication method. Data persistence is handled via Docker volumes, which is good practice for containerized applications. However, the internal implementation of `claude-flow@alpha` and `mcp-proxy` Node.js packages, which are critical components, is not available for review. The security assessment is limited to the provided configuration and documentation.
Updated: 2025-12-10GitHub→
0
0
Low Cost
relyky icon

mcp-demo

by relyky

Sec10

This project is a demonstration of an MCP (Model Context Protocol) server built using the FastMCP framework, providing tools and resources for AI models to interact with.

Setup Requirements

  • ⚠️Requires Python 3.12+
  • ⚠️Requires the 'uv' package manager for recommended setup and execution
Verified SafeView Analysis
The provided source code is simple and demonstrates basic arithmetic and string manipulation. No dangerous functions like 'eval' or 'exec' are used. There are no hardcoded secrets or network vulnerabilities present in the given snippets. The f-string usage in 'get_greeting' is safe within the server's context and does not introduce direct server-side vulnerabilities.
Updated: 2025-11-19GitHub→
0
0
Medium Cost
HJeon139 icon
Sec9

An MCP server designed to manage and store contextual information (markdown files with metadata) for AI agents, supporting CRUD operations and text search.

Setup Requirements

  • ⚠️Python 3.11 or higher is required.
  • ⚠️Requires manual migration or configuration update if currently using the old `.out_of_context` storage path (default changed to `out_of_context`). Automatic migration only works if no custom `OUT_OF_CONTEXT_STORAGE_PATH` is set.
  • ⚠️Future semantic search features will require additional dependencies like `sentence-transformers` and `torch`, resulting in a ~500MB download on first use.
Verified SafeView Analysis
The system is designed to be self-contained and uses STDIO for communication, significantly limiting network attack vectors. Input validation for context names (`_validate_name` in `mdc_storage.py`) prevents basic path traversal vulnerabilities. No `eval()` or hardcoded secrets were found in the provided source code. Configuration is handled via environment variables or a configuration file, not directly in code. The core functionality involves direct file system manipulation by the server process, implying the agent environment is trusted.
Updated: 2025-12-18GitHub→
0
0
Low Cost
NAITIVEAI icon
Sec6

Deploys a remote Model Context Protocol (MCP) server on Cloudflare Workers, exposing basic calculator tools without requiring authentication, intended for demonstration and integration with MCP clients like Cloudflare AI Playground or Claude Desktop.

Setup Requirements

  • ⚠️Requires a Cloudflare Workers account for deployment.
  • ⚠️No authentication is implemented, making it publicly accessible to anyone with the URL.
  • ⚠️Requires `npm` and `wrangler` CLI to set up and deploy.
Verified SafeView Analysis
The server is explicitly designed to be 'authless' for demonstration purposes. While the arithmetic tools themselves use Zod for input validation (mitigating input injection for numeric inputs), the absence of any authentication mechanism means anyone with the URL can access and invoke the calculator functions. This is a critical security vulnerability for any non-public facing or sensitive application. No hardcoded secrets were found in the provided code snippets. Use with caution and only for its intended demo purpose.
Updated: 2025-11-25GitHub→
0
0
Medium Cost
NickFlach icon

PFORK_MCP

by NickFlach

Sec8

Unified API gateway for the Pitchforks ecosystem, enabling AI agents and other clients to interact with decentralized tools for peaceful resistance on Neo X.

Setup Requirements

  • ⚠️Mandatory Environment Variables: Requires `SESSION_SECRET` for MCP server API key authentication, and `DEVELOPER_PRIVATE_KEY` and `DEVELOPER_ADDRESS` for wallet-based authentication, which are critical for write operations. Several API URLs (`PROTOCOL_API_URL`, `DEX_API_URL`, `FERRY_API_URL`, `ANALYST_API_URL`, `APP_API_URL`) and blockchain RPC endpoints (`NEO_X_RPC_URL`, `ETHEREUM_RPC_URL`) are also needed for full functionality.
  • ⚠️Placeholder API Integration: Most high-level tools (`analyst-get-overview`, `dex-get-info`, `protocol-get-info`, etc.) currently return static placeholder data. Full, live functionality requires active connections to the respective Pitchforks ecosystem APIs and backend development on those sites as outlined in `PITCHFORKS_MCP_RECOMMENDATIONS.md`.
  • ⚠️Monorepo Dependencies: The top-level `package.json` references several `@pitchfork` packages using `file:../@pitchfork/shared/packages/...`. This indicates it's part of a larger monorepo. Running this server standalone may require manually setting up or publishing these shared packages.
Verified SafeView Analysis
The server implements robust multi-layer authentication (wallet signatures and API keys), includes input validation using Joi, uses nonce management to prevent replay attacks, and configures rate limiting and standard security headers (Helmet, CORS). TypeScript strict mode enhances code quality and reduces common vulnerabilities. However, the `AuthMiddleware`'s reliance on `DEVELOPER_PRIVATE_KEY` directly from environment variables for server-side signing is a significant risk; in a production environment, this should be replaced with a secure key management system (e.g., KMS). Additionally, the initial `xmcp` tools return placeholder data, meaning the security of actual integrations with live Pitchforks APIs (when implemented) will require further review.
Updated: 2025-11-26GitHub→
0
0
Medium Cost
isakskogstad icon

blocket-tradera-mcp

by isakskogstad

Sec7

MCP server for Swedish marketplaces Blocket and Tradera, enabling AI assistants to search listings, compare prices, and browse items.

Setup Requirements

  • ⚠️Requires personal Tradera API credentials (TRADERA_APP_ID, TRADERA_APP_KEY) for full functionality; otherwise, only Blocket searches will work.
  • ⚠️Requires Node.js version 18 or higher.
Verified SafeView Analysis
The TRADERA_APP_ID and TRADERA_APP_KEY environment variables have default values hardcoded in src/clients/tradera-client.ts. While likely intended for development, this poses a security risk if not overridden by user-provided credentials, as it could lead to shared rate limits or potential credential compromise if these defaults are widely used or become public knowledge. The README explicitly advises users to obtain their own API credentials.
Updated: 2025-12-26GitHub→
0
0
High Cost

mcp_server

by jsv-datascientist

Sec5

This server provides a flexible framework for building, running, and managing multi-turn, agentic AI conversations with custom tools, likely exposed via an API.

Setup Requirements

  • ⚠️Requires an API Key for a Large Language Model (e.g., OpenAI, Anthropic), which incurs usage costs.
  • ⚠️Requires Python 3.x and installation of dependencies listed in `requirements.txt`.
  • ⚠️Docker must be installed to use the provided Docker setup.
Verified SafeView Analysis
Cannot perform a detailed security audit without access to code content. The presence of 'agent_chains.py' and 'custom_tools.py' suggests potential for dynamic code execution or plugin-like behavior which, if not carefully implemented, could introduce injection vulnerabilities or arbitrary code execution risks. Network risks cannot be assessed without knowing API endpoints, authentication mechanisms, or data handling practices. User discretion is advised.
Updated: 2025-11-18GitHub→
0
0
Medium Cost
yo-mi2027 icon

mcp_server

by yo-mi2027

Sec9

Enables LLMs (specifically Claude) to interact with and retrieve information from structured local manuals via a hierarchical reasoning RAG workflow.

Setup Requirements

  • ⚠️Requires Docker Desktop (or compatible engine) for the FastAPI backend.
  • ⚠️Requires Node.js 18+ and npm (or compatible tool) for the MCP client.
  • ⚠️Users must manually create and populate the 'manuals/' directory with structured content (e.g., '00_目次.json' and text files).
Verified SafeView Analysis
The system is designed for local operation with the FastAPI backend bound to `127.0.0.1`. CORS is configured for local access. Regex search functionality includes a fallback mechanism for invalid patterns, preventing potential injection issues. No hardcoded secrets were found, and there's no use of `eval` or similar dangerous dynamic code execution. Overall, it's very safe for its intended local-only use, but like any local server, its security is tied to the host machine's integrity.
Updated: 2026-01-06GitHub→
0
0
Low Cost
KlenLucas icon

ai-test-generator

by KlenLucas

Sec8

Automatically generate Playwright test code from user stories using Claude AI.

Setup Requirements

  • ⚠️Requires Anthropic API Key (Paid)
  • ⚠️Requires Playwright browsers to be installed (`playwright install`)
Verified SafeView Analysis
The application properly uses environment variables for API keys, avoiding hardcoded secrets. It includes a validation step for generated code, which helps mitigate risks associated with AI hallucinations or unexpected code. The primary security consideration is ensuring the generated Playwright test code, if run in an unisolated environment, does not perform unintended actions. However, the system's design with a QA engineer persona prompt and validators aims to produce safe, functional tests.
Updated: 2026-01-19GitHub→
PreviousPage 384 of 760Next