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
Low Cost
timsto-cas icon

mcp_test_repo

by timsto-cas

Sec1

A custom client-server application for network communication and remote execution of Python code.

Setup Requirements

  • ⚠️Requires Python installed.
  • ⚠️Secure key management for the `auth_key` is critical but not provided in the source code.
  • ⚠️Network port must be open and accessible for client-server communication.
Review RequiredView Analysis
CRITICAL: The server and client both use `eval()` on network-received data (`message['data']` and `response['data']`) without any apparent sanitization. This allows arbitrary remote code execution by a connected party, posing an extremely severe security vulnerability.
Updated: 2025-11-24GitHub→
0
0
High Cost
Ryttis icon

mcp-server

by Ryttis

Sec3

A minimalist, stable kernel server providing a bounded execution environment for various tools via JSON-RPC over WebSocket, strictly separating business logic from side effects, primarily intended for AI agent integration.

Setup Requirements

  • ⚠️Requires OpenAI API Key (Paid Service)
  • ⚠️Requires a running MySQL database with connection details via environment variables
  • ⚠️Requires ETNOLENTOS_PATH and FACTURACORE_PATH environment variables to enable project-specific tools
Review RequiredView Analysis
Critical vulnerabilities for Command Injection (`core.runCommand`), Arbitrary File Read/Write (`core.readFile`, `core.writeFile`), and potential SQL Injection (`core.dbQuery`). The `core.runCommand` tool passes user-controlled input directly to `child_process.exec` without sanitization. The `core.readFile` and `core.writeFile` tools allow reading/writing to arbitrary paths on the file system without proper root confinement. The `core.dbQuery` passes unsanitized SQL queries to the database. These tools lack necessary input validation and path confinement, making the server highly exploitable if exposed.
Updated: 2026-01-13GitHub→
0
0
Low Cost
rroldan icon
Sec10

This project contains a minimal Rust 'Hello World' program, serving as a basic boilerplate or placeholder.

Verified SafeView Analysis
The provided source code consists solely of a 'Hello, world!' program. It performs no network operations, file I/O, external dependency calls, uses no 'eval' or similar functions, and contains no hardcoded secrets or malicious patterns. It is extremely safe.
Updated: 2025-12-06GitHub→
0
0
Low Cost
EigenPriyam icon
Sec9

Provides a remote API for tracking and summarizing personal or business expenses.

Setup Requirements

  • ⚠️Requires Python 3.11 or higher.
  • ⚠️The 'categories.json' file must be present in the same directory as 'main.py' for the server to function correctly.
Verified SafeView Analysis
Uses parameterized queries throughout the database operations, effectively preventing SQL injection vulnerabilities. No 'eval' or similar dangerous functions, and no hardcoded secrets were found. The server binds to '0.0.0.0', making it accessible from all network interfaces; users should ensure proper firewalling if exposing it to untrusted networks.
Updated: 2025-12-02GitHub→
0
0
Medium Cost
Saiashrita icon
Sec8

An AI-powered development assistant that integrates GitHub, Jira, Slack, and Documentation tools through the Model Context Protocol (MCP) for intelligent orchestration and manual tool execution.

Setup Requirements

  • ⚠️Requires an LLM API Key (Anthropic, Gemini, or OpenAI), which may incur costs depending on usage.
  • ⚠️Requires a GitHub Personal Access Token with `repo` and `read:user` scopes.
  • ⚠️Requires Node.js 18+ and must be run as two separate processes (backend and frontend).
Verified SafeView Analysis
The project correctly uses environment variables for sensitive API keys (e.g., GITHUB_TOKEN, LLM_API_KEY), preventing hardcoded secrets. Inter-process communication via JSON-RPC is handled by parsing standard JSON, which avoids `eval` risks. The `cors()` middleware in the backend is broadly applied (`app.use(cors())`), which is common for development but would require stricter configuration (e.g., specific origins) in a production deployment to mitigate potential cross-origin attacks.
Updated: 2026-01-16GitHub→
0
0
Low Cost
hoyeoy icon

my-mcp-server

by hoyeoy

Sec7

A backend API server providing 'tools' for key-value storage, email sending via multiple providers, and Google Sheets data retrieval, likely for integration with AI agents or other applications.

Setup Requirements

  • ⚠️Requires RESEND_API_KEY environment variable for Resend email functionality.
  • ⚠️Requires GMAIL_USER and GMAIL_PASS environment variables (Gmail app password) for Nodemailer/Gmail functionality.
  • ⚠️Requires GOOGLE_SERVICE_ACCOUNT_JSON environment variable (a JSON string for a Google Cloud service account key) for Google Sheets access.
  • ⚠️Relies on Vercel KV for key-value storage, suggesting a Vercel deployment environment.
  • ⚠️Project includes both Node.js and Python API functions, necessitating a polyglot serverless deployment environment (e.g., Vercel).
Verified SafeView Analysis
Broad CORS ('Access-Control-Allow-Origin: *') is enabled on all Node.js API endpoints, which allows requests from any origin. While common for public APIs or development, it generally reduces security if not specifically needed. The 'tool_calls' mechanism in 'api/mcp.js' is implemented safely by checking specific tool names, but dynamic function dispatch patterns should always be carefully reviewed. All secrets are correctly handled via environment variables.
Updated: 2025-11-25GitHub→
0
0
Low Cost
ricardofauch icon

pokemon-tcg-pocket-mcp

by ricardofauch

Sec9

Provides access to Pokemon TCG Pocket data through the TCGdex API for Model Context Protocol (MCP) clients.

Setup Requirements

  • ⚠️Requires Node.js 18 or higher
  • ⚠️Requires an MCP-compatible client (e.g., Claude Desktop)
  • ⚠️Manual absolute path configuration for client integration is needed (e.g., in claude_desktop_config.json)
Verified SafeView Analysis
The server primarily acts as a proxy for the TCGdex API. It uses standard Node.js/TypeScript practices and the Model Context Protocol SDK. There are no indications of 'eval' usage, obfuscation, or hardcoded sensitive credentials. The main security consideration is the reliance on an external API (TCGdex), which is a common and generally trustworthy data source for Pokémon TCG data.
Updated: 2026-01-19GitHub→
0
0
Low Cost
cbuntingde icon

supabase-memory-mcp

by cbuntingde

Sec9

Provides AI assistants with a multi-layered memory system (semantic, graph, structured, short-term) using Supabase and pgvector for persistent and fast retrieval, enhancing cognitive capabilities.

Setup Requirements

  • ⚠️Requires an existing Supabase project and associated API key (Anon/Public or Service Role) for database connectivity.
  • ⚠️Initial database schema setup may require manual execution of `schema.sql` within the Supabase SQL Editor if the automated `npx ... setup` command encounters permission issues or existing schema conflicts.
  • ⚠️For compatible AI clients (e.g., Cline, Roo Code, Kilo Code), all tool permissions must be explicitly enabled upon initialization as stated in the prerequisites.
Verified SafeView Analysis
The server uses local embedding models (@xenova/transformers), eliminating the need for external API calls for embeddings and improving data privacy. Configuration is loaded securely from environment variables or a local file with restricted permissions (0o600). Database interactions are handled through the Supabase client library, which helps mitigate direct SQL injection risks. The README emphasizes enabling all tool permissions for client-side extensions, which implies a high degree of trust in the consuming AI agent, a common pattern for such systems.
Updated: 2026-01-17GitHub→
0
0
Medium Cost
Kcao3034 icon
Sec9

The MCP server enables programmatic, structural, and semantic editing of Markdown documents, including file system operations and YAML frontmatter management, primarily for use by AI agents.

Setup Requirements

  • ⚠️Requires Python 3.10 or newer.
  • ⚠️Requires a local Ollama instance running with a compatible model (e.g., qwen3:14b or qwen3:8b) for AI capabilities.
Verified SafeView Analysis
The codebase demonstrates good security practices for file system operations, particularly with the `PathResolver`'s `is_safe_path` function to prevent directory traversal attacks. File writes use an atomic temporary file approach. No 'eval' or obvious malicious patterns were found. Network connections for LLM are outbound and configurable.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
ytwei3 icon
Sec9

Enables AI agents to query Ethereum balances, token prices, and simulate token swaps via the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires Rust 1.70 or higher toolchain to build and run.
  • ⚠️Requires an Ethereum RPC URL configured in a `.env` file or as an environment variable.
  • ⚠️Integration with AI agents like Claude Desktop requires manual modification of a client-side JSON configuration file.
Verified SafeView Analysis
The server's core functionality is simulation-only, meaning no on-chain transactions are executed and no private keys are handled by the server itself. Input parsing uses `serde_json` and `ethers-rs` address parsing, which are generally safe. External dependencies include an Ethereum RPC endpoint and CoinGecko API for price feeds, which introduce standard network risks. The code does not use dangerous functions like `eval` or rely on obfuscation. Logging to stderr prevents interference with the stdio communication channel.
Updated: 2025-11-22GitHub→
0
0
High Cost
godwinraj-ai icon

FastApply-MCP

by godwinraj-ai

Sec8

An AI-powered Multi-tool Code Processing (MCP) server designed for comprehensive code editing, analysis, and refactoring across multiple programming languages, leveraging LLMs and AST-based tools.

Setup Requirements

  • ⚠️Requires a compatible LLM server (e.g., LM Studio with a Fast Apply model) running and configured via FAST_APPLY_URL.
  • ⚠️Requires external CLI tools (`ast-grep`, `ripgrep`, `ruff`, `eslint`) to be installed in the system's PATH for full functionality.
  • ⚠️The Qdrant vector database is required for 'collective consciousness' and enhanced learning features, though it has fallback mechanisms if unavailable.
Verified SafeView Analysis
The server implements robust security measures including path validation (`_secure_resolve`) to prevent directory traversal, file size limits to mitigate resource exhaustion, and atomic writes for file modifications. It also uses temporary files for external tool inputs to reduce command injection risk. However, it relies heavily on executing external CLI tools (`ast-grep`, `ripgrep`, `ruff`, `eslint`) via `subprocess.run` and performs extensive file system operations for code editing. While inputs are processed with security in mind, the broad attack surface of these capabilities necessitates careful management of the `WORKSPACE_ROOT` environment variable and an understanding of the tools' invocation context.
Updated: 2026-01-19GitHub→
0
0
Low Cost
Tommertom icon

pdf_mcp_chromadb

by Tommertom

Sec7

Provides a Model Context Protocol (MCP) server for processing PDF documents, generating local embeddings, and performing semantic search.

Setup Requirements

  • ⚠️Requires 'uv' to be installed for 'uvx' command: 'pip install uv'.
  • ⚠️On first run, the embedding model (~80MB for 'all-MiniLM-L6-v2') will be downloaded, requiring internet connectivity.
  • ⚠️Requires Python 3.10+.
Verified SafeView Analysis
The server downloads PDFs from arbitrary URLs provided by the user, which introduces a potential Server-Side Request Forgery (SSRF) risk and resource consumption vulnerability if exposed to untrusted input without proper network segmentation. While it has file size limits and URL validation, a malicious actor could still attempt to download large files repeatedly or target internal network resources. There are no obvious hardcoded secrets, 'eval' usage, or other direct code execution vulnerabilities. The embedding model runs locally, avoiding external API security concerns.
Updated: 2025-12-14GitHub→
PreviousPage 433 of 760Next