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
High Cost
alejandro-ao icon

simple-mcp-rag

by alejandro-ao

Sec8

An MCP server for Retrieval Augmented Generation (RAG) that ingests documents into a vector database and retrieves relevant information based on queries.

Setup Requirements

  • ⚠️Requires LLAMA_CLOUD_API_KEY, which is for a paid service (LlamaParse).
  • ⚠️The data directory (`LLAMA_RAG_DATA_DIR`) must be explicitly configured for document ingestion to occur automatically.
  • ⚠️Dependencies (`fastmcp`, `chromadb`, `sentence-transformers`, `llama-index`, `llama-parse`, `python-dotenv`) must be installed.
Verified SafeView Analysis
The server performs extensive file system operations, including reading from a data directory (`SimpleDirectoryReader`) and managing a database directory (`shutil.rmtree` for resets). While these are core to its RAG functionality, a misconfigured `LLAMA_RAG_DATA_DIR` or `LLAMA_RAG_DB_DIR` environment variable could lead to reading sensitive files or deleting unintended directories. There are no obvious `eval` or arbitrary code execution vulnerabilities in the provided code snippets. External API calls are made to `LlamaParse`, which requires `LLAMA_CLOUD_API_KEY` (handled via environment variables). The primary risk is with environment variable configuration and the contents of the data directory if the server is exposed to untrusted inputs or runs in an untrusted environment.
Updated: 2025-11-20GitHub→
0
0
Medium Cost
lascam-UFU icon

lc-mcp-server

by lascam-UFU

Sec8

Provides a Model Context Protocol (MCP) server to programmatically interact with LeetCode problems, contests, and solution submissions.

Setup Requirements

  • ⚠️Requires Chrome/Chromium browser installed for the `auth.go` helper.
  • ⚠️Initial authentication (`auth.go`) requires manual user interaction to log into LeetCode in a browser window.
  • ⚠️Requires `LEETCODE_SESSION` and `LEETCODE_CSRF_TOKEN` environment variables to be set, typically obtained via the `auth.go` helper.
Verified SafeView Analysis
The server primarily uses environment variables for sensitive session and CSRF tokens, a good practice. The `auth.go` helper uses `chromedp` to open a browser for manual login and cookie extraction. While `chromedp.Evaluate` is used to inject JavaScript, this is a standard and necessary pattern for browser automation, and the scripts are hardcoded, not derived from user input, mitigating `eval`-like risks. The extracted tokens are stored in a local file (`~/.leetcode_auth.json`) with restrictive permissions (0600), which is appropriate. Overall, the direct server logic in `main.go` does not show obvious RCE vulnerabilities or unsafe `eval` patterns. The primary security concern lies in the careful management of the `LEETCODE_SESSION` and `CSRF_TOKEN` by the user.
Updated: 2025-11-24GitHub→
0
0
Medium Cost
tkutsch77 icon
Sec8

Provides an enterprise-grade Model Context Protocol (MCP) server for RecallBricks memory management, enhancing AI agent capabilities through robust context, memory, and identity management.

Setup Requirements

  • ⚠️Requires a valid "RECALLBRICKS_API_KEY" for authentication with the external RecallBricks API (likely a paid service).
  • ⚠️Primarily designed for integration with Claude Desktop, often requiring specific configuration in 'claude_desktop_config.json'.
  • ⚠️Requires Node.js and a 'npm run build' compilation step before execution.
Verified SafeView Analysis
The server uses environment variables for sensitive configurations like "RECALLBRICKS_API_KEY" and performs a startup validation to ensure the API key is present and of sufficient length. While a default API key is present in the source code, it is clearly intended as a placeholder, and documentation instructs users to override it. Input validation is applied to all tool parameters to prevent common injection vulnerabilities. No 'eval' or obvious obfuscation detected. Network requests are made securely over HTTPS to the configured API.
Updated: 2025-11-22GitHub→
0
0
Low Cost

pu-mcp-server

by leing2021

Sec9

Serves as an API backend for managing and delivering AI prompt templates and related configurations via an EdgeOne KV store, optimized for eventual consistency.

Setup Requirements

  • ⚠️Requires an EdgeOne KV namespace (e.g., 'MCP_CONFIG') to be created and bound to the project as the environment variable 'MCP_CONFIG'.
  • ⚠️Requires a 'SYNC_TOKEN' environment variable for authentication on the internal sync-kv endpoint.
  • ⚠️Designed for a two-repository workflow, where configuration is managed by 'pu-mcp-config' and synced to this server via GitHub Actions.
Verified SafeView Analysis
The internal sync-kv endpoint is protected by a `SYNC_TOKEN` environment variable. Proper configuration of this token and KV namespace permissions on EdgeOne is critical to maintaining security. KV operations are robustly handled with try-catch blocks and logging. No 'eval' or other directly dangerous functions are used.
Updated: 2025-11-29GitHub→
0
0
Medium Cost
Sec9

Integrates SuperProductivity task management with Claude Code by providing read-only access to local tasks, projects, and tags.

Setup Requirements

  • ⚠️Requires Python 3.13+.
  • ⚠️Requires SuperProductivity application with its '__meta_' sync file available locally (e.g., in Google Drive).
  • ⚠️The SP_META_PATH environment variable must be correctly configured to point to the SuperProductivity '__meta_' file.
Verified SafeView Analysis
The server operates locally, reading a designated SuperProductivity sync file via a path provided by an environment variable. Communication with Claude Code is via standard input/output (stdio), not over a network, significantly reducing the attack surface. There are no explicit uses of dangerous functions like 'eval', no hardcoded secrets, and Pydantic models are used for structured data parsing. The `model_config = {"extra": "allow"}` in Pydantic models is for parsing existing data and does not introduce direct security vulnerabilities in this read-only context. The primary theoretical risk would be if a local attacker could manipulate the `SP_META_PATH` environment variable to point to a maliciously crafted file on the local filesystem, potentially leading to a denial of service through malformed JSON. However, this requires pre-existing local system access.
Updated: 2025-11-24GitHub→
0
0
Medium Cost
obsidianempire icon

sample-mcp-server

by obsidianempire

Sec7

A Model Context Protocol (MCP) server for integrating with Salesforce AgentForce to provide intelligent banking service assistance.

Setup Requirements

  • ⚠️Requires Python 3.8+ and pip.
  • ⚠️Salesforce Developer Edition org is crucial for primary integration use case.
  • ⚠️Mobius service and its API credentials (MOBIUS_SERVER, MOBIUS_PORT, MOBIUS_REPOSITORY_ID) are required for the `/askme` endpoint, along with potential SSL certificate configuration.
  • ⚠️Running in MCP mode (`MCP_SERVER_MODE=mcp`) requires the `fastmcp` package, which is an optional dependency.
Verified SafeView Analysis
The server's HTTP mode defaults to permissive CORS (allow_origins=['*']), which should be restricted in production. While it supports external authentication (e.g., Salesforce Named Credentials, API Keys), the server itself does not enforce authentication by default for most of its REST API endpoints, relying on external gateways or explicit middleware setup. The `/askme` endpoint acts as a proxy, handling Mobius credentials via HTTP Basic Auth. While certificate handling is implemented for Mobius SSL, proxying sensitive data requires careful security considerations for both the proxy and the upstream service. Temporary file handling for SSL certificates is present, requiring explicit cleanup.
Updated: 2025-12-11GitHub→
0
0
Low Cost
SaherElMasry icon

go-mcp-framework

by SaherElMasry

Sec9

Provides a production-ready framework for building Model Context Protocol (MCP) servers in Go, offering real-time streaming via Server-Sent Events (SSE), multiple transports, and built-in observability and security features.

Setup Requirements

  • ⚠️Requires Go development environment (Go 1.18+)
  • ⚠️Default `Access-Control-Allow-Origin: *` in HTTP transport needs to be configured for production security
  • ⚠️Backends (e.g., filesystem, custom APIs) require specific configuration parameters.
Verified SafeView Analysis
The framework includes robust security features, particularly for filesystem operations, such as path traversal prevention, workspace sandboxing, file size limits, and extension filtering. Concurrency is controlled via semaphores to prevent resource exhaustion. Configuration supports environment variable expansion, which is good for secrets management but means sensitivity to the execution environment. The default CORS policy in examples is `"*"` (allow all origins), which is generally unsafe for production and requires explicit configuration.
Updated: 2026-01-17GitHub→
0
0
Medium Cost
kaichiachen icon
Sec8

Connects AI assistants to Home Assistant, enabling AI agents to control and query smart home entities and services.

Setup Requirements

  • ⚠️Requires a running Home Assistant instance.
  • ⚠️A Home Assistant Long-Lived Access Token (HA_TOKEN) is mandatory and must be kept secure.
  • ⚠️Requires Python 3.13+ for local development/running outside Docker. The Docker image handles this automatically.
  • ⚠️Network access to port 8000 on the host running the server is required for MCP clients to connect.
Verified SafeView Analysis
Secrets (HA_TOKEN, HA_URL) are configured via environment variables or Home Assistant add-on options, not hardcoded. The server's functionality relies on a Home Assistant long-lived access token, which grants broad control over the HA instance; its security is paramount. The server uses `json.loads` for parsing input parameters to service calls, which is generally safe for data but could be a vector for vulnerabilities if Home Assistant services themselves are susceptible to specially crafted JSON. Network access to the MCP server on port 8000 should be restricted to trusted clients. No `eval` or `exec` found. The code handles common HTTP errors robustly.
Updated: 2026-01-17GitHub→
0
0
Low Cost
C45h888 icon

888.MCP

by C45h888

Sec9

High-speed Redis-based pub/sub message bus and central nervous system for an agentic trading system, handling market data, sentiment, and trading signals.

Setup Requirements

  • ⚠️Requires a running Redis instance for operation (local or external).
  • ⚠️An `MCP_API_KEY` is mandatory for all authenticated endpoints in production mode (`MCP_DEV=false`); API keys must be managed securely via provided admin endpoints.
  • ⚠️Full functionality for historical data archiving and retrieval (`/tool/retrieve`) depends on S3 configuration (`S3_DATA_BUCKET`, `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`). Without these, retrieval endpoints will return `501 Not Implemented`.
  • ⚠️The optional RAG endpoint (`/tool/search_rag`) requires specific environment variables (`VECTOR_DB_TYPE`, `VECTOR_DB_URL`, `VECTOR_DB_API_KEY`) to connect to an external vector database. It defaults to a mock engine for development.
Verified SafeView Analysis
The MCP Server demonstrates a robust security posture, incorporating multi-key API authentication with granular role-based access control (RBAC), SHA256 hashing for API keys, and triple-tier rate limiting (IP, per-key, and per-endpoint) to mitigate various attack vectors including DoS and brute force. Comprehensive input validation (Pydantic and JSON Schema) prevents data injection, and structured JSON logging with secret sanitization ensures no sensitive information is leaked. HTTPS enforcement (via Render.com), proper security headers, and least-privilege IAM policies for S3 (with encryption and versioning) further harden the system. A clearly defined development mode (`MCP_DEV=true`) bypasses authentication, but its use is explicitly flagged for non-production environments. Administrative endpoints for key management are strictly secured with admin-only permissions. The RAG endpoint (Phase 6) has been specifically remediated to comply with these strong security standards.
Updated: 2025-12-13GitHub→
0
0
Medium Cost
andriyshevchenko icon

Essential-MCP-Servers

by andriyshevchenko

Sec7

Provides a reference configuration and baseline for connecting AI clients to various external tools and services via the Model Context Protocol (MCP).

Setup Requirements

  • ⚠️Requires Node.js and npm/npx installed to run the example servers.
  • ⚠️Requires an EXA_API_KEY for the Exa MCP server, which typically involves a third-party service and potential costs.
Verified SafeView Analysis
The repository itself (README.md) does not contain explicit vulnerabilities like hardcoded secrets or 'eval'. However, it describes and provides example configurations for running external `npx` packages (e.g., `@playwright/mcp`, `exa-mcp-server`), which inherently introduces supply chain risks as trust is placed in those third-party packages. The nature of some described MCP servers (e.g., remote Python code execution, local filesystem and desktop actions) implies significant security implications for the *runtime environment* if not properly sandboxed or managed by the end-user. API keys (e.g., EXA_API_KEY) are explicitly handled as environment variables, which is a good security practice.
Updated: 2026-01-19GitHub→
0
0
High Cost
LibraxisAI icon

rmcp_memex

by LibraxisAI

Sec7

Lightweight Model Context Protocol (MCP) server providing local Retrieval-Augmented Generation (RAG) capabilities with embedded vector store and local/remote embeddings.

Setup Requirements

  • ⚠️Requires Rust toolchain with Cargo (stable)
  • ⚠️Requires protobuf compiler to be installed for build dependencies
  • ⚠️MLX HTTP server is an optional external dependency if not using fastembed fallback
Verified SafeView Analysis
The `rag_index` function accepts a `path` argument, allowing a client to specify arbitrary local file paths for indexing. If the server is exposed to untrusted input or runs with elevated privileges, this could lead to information disclosure by indexing sensitive files. Additionally, LanceDB filter predicates are constructed with manual string sanitization (`replace('\'', "''")`), which, while present, always carries a higher risk compared to parameterized queries for preventing injection vulnerabilities.
Updated: 2026-01-11GitHub→
0
0
Low Cost
Sanjayvk98 icon
Sec9

This server provides a local API for managing and summarizing personal expense entries.

Setup Requirements

  • ⚠️Python 3.12+ required
  • ⚠️Requires 'fastmcp' dependency to be installed
  • ⚠️Requires write access to a temporary directory for the SQLite database
Verified SafeView Analysis
The server uses parameterized SQL queries, effectively preventing SQL injection. No hardcoded secrets or dangerous functions like 'eval' or 'exec' are present. The SQLite database is created in a temporary directory, which ensures write access but could theoretically be accessed by other processes on the same system in a multi-user environment, although this is a minor concern for a typical local expense tracker. The file access for categories is limited to a local JSON file within the application directory.
Updated: 2025-12-14GitHub→
PreviousPage 307 of 760Next