Stop Searching. Start Trusting.

The curated directory of MCP servers, vetted for security, efficiency, and quality.

Browse Directory Why 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)

Low Cost

pushover-mcp-rs

by chrstnwhlrt

Sec9

Enables LLMs to send push notifications to user devices via the Pushover API for alerts, task completion, or other attention-getting scenarios.

Setup Requirements

⚠️Requires a Pushover API Token and User Key (from pushover.net) which must be manually added to a configuration file after the first run.
⚠️Requires a Rust development environment (version 1.85+) to build the binary using `cargo build --release`.
⚠️The configuration file path is OS-specific (Linux: `~/.config/pushover-mcp-rs/config.json`, macOS: `~/Library/Application Support/pushover-mcp-rs/config.json`, Windows: `C:\Users\{user}\AppData\Roaming\pushover-mcp-rs\config.json`).

Verified SafeView Analysis

The server correctly handles sensitive credentials (Pushover API token and user key) by loading them from a user-editable configuration file, rather than hardcoding. Input parameters are validated against Pushover API limits (e.g., message length, URL length) to prevent abuse or malformed requests. All network communication to the Pushover API uses HTTPS with `rustls-tls` for secure transport and includes connection/request timeouts. The server operates over stdin/stdout as an MCP server, avoiding direct network exposure itself, which enhances security. No `eval` or similar dangerous patterns are present.

Updated: 2025-11-30GitHub→

Low Cost

mcp-test-repo

by kennes1026

Sec1

This server facilitates programmatic management of GitHub repositories, including file operations and commit automation, primarily for embedded systems development (like Arduino) using AI integration via the Model Context Protocol (MCP).

Setup Requirements

⚠️Requires a GitHub Personal Access Token (PAT) with appropriate repository permissions (e.g., `repo` scope) for managing repositories.
⚠️Relies on a running Model Context Protocol (MCP) client (e.g., Claude Desktop) to issue commands, which in turn may require an Anthropic Claude API key or subscription.
⚠️Requires a Node.js environment to run the `@modelcontextprotocol/server-github` package if deploying locally.

Review RequiredView Analysis

The provided 'source code' is a README file describing the MCP server and its capabilities, not the actual executable code of the server itself. Therefore, a security audit of the server's implementation (e.g., handling of secrets, network interactions, dependencies) cannot be performed. Without access to the server's source code, its security cannot be guaranteed, especially regarding how GitHub tokens or other credentials are handled.

Updated: 2025-11-26GitHub→

Low Cost

agro-mcp-server

by Nos29HiT

Sec6

A backend server for managing or processing data related to an agro-based custom protocol or application, likely operating over a network.

Setup Requirements

⚠️Requires Node.js runtime to be installed.
⚠️Requires running `npm install` to set up project dependencies (assuming 'node_modules' is not committed or needs updating).

Review RequiredView Analysis

Without access to the actual code in 'mcp-server.js' and its dependencies, a thorough security audit is not possible. The score reflects general risks associated with any network-facing server and potential vulnerabilities in third-party 'node_modules'. No specific 'eval' or obfuscation risks can be identified from filenames alone. Users should always review the source code before deploying.

Updated: 2025-11-18GitHub→

Low Cost

mcp.zig

by nobita5609

Sec3

Provides a Model Context Protocol (MCP) library in Zig, enabling AI applications to connect to external systems by exposing tools, resources, and prompts through a standardized protocol.

Setup Requirements

⚠️Requires Zig version 0.15.0 or later to be installed.
⚠️The project needs to be built via `zig build` to produce the executable before it can be run.

Review RequiredView Analysis

The example code for handling resources and tools (`processFileHandler` in `docs/guide/error-handling.md`) directly uses an unsanitized `path` argument from client input with `std.fs.cwd().readFileAlloc`. This is a critical path traversal vulnerability, allowing a malicious client to read arbitrary files outside the intended working directory (e.g., `../../../../etc/passwd`). While there's an `accessAbsolute` check, it's insufficient to prevent this specific `readFileAlloc` vulnerability. This indicates a significant security risk in how tool/resource handlers might be implemented based on the provided guidance, or a lack of built-in sanitization within the library itself for such common operations. No other immediate malicious patterns, hardcoded secrets, or `eval` usage were found.

Updated: 2026-01-19GitHub→

Medium Cost

twitter-mcp-server

by SahilIjaz

Sec7

An AI-powered chat application that connects to a Model Context Protocol (MCP) server to execute external tools, demonstrating integration with Google GenAI and the Twitter API.

Setup Requirements

⚠️Requires a Google Gemini API Key (which may incur costs) set as GEMINI_API_KEY.
⚠️Requires Twitter API v2 credentials (appKey, appSecret, accessToken, accessSecret) set as TWITTER_API_KEY, TWITTER_API_SECRET, TWITTER_ACCESS_TOKEN, and TWITTER_ACCESS_TOKEN_SECRET.
⚠️The server component must be running locally on port 3001 before the client can connect.
⚠️Requires Node.js version 18 or higher.

Verified SafeView Analysis

API keys for Google GenAI and Twitter are correctly managed using environment variables via dotenv. Server-side input validation for tool arguments is implemented with Zod. The primary security risk is the potential for the AI model to generate undesirable or malicious tool calls, especially for actions with external side effects like posting to Twitter. Session management for SSE connections, while likely relying on UUIDs from the SDK, could benefit from explicit authentication mechanisms for production environments.

Updated: 2025-12-03GitHub→

Medium Cost

rag-system

by asami

Sec6

A hybrid semantic-vector retrieval engine that integrates structured knowledge graphs and embedding models for advanced RAG (Retrieval Augmented Generation) capabilities for AI agents.

Setup Requirements

⚠️Requires Docker for external dependencies (Fuseki, embedding server) even in local development mode.
⚠️The Python `sie-embedding` service and `init-chroma.sh` script require Python and specific `pip` packages (chromadb, requests, openai, sentence-transformers).
⚠️Using OpenAI embedding models requires an `OPENAI_API_KEY`, which is a paid service. The system can auto-detect or be configured for OSS models.

Verified SafeView Analysis

The system downloads and initializes external ontology files (`site.jsonld`, `.ttl` files) from `www.simplemodeling.org` during `init-fuseki.sh` execution, which introduces a supply chain risk. The Python `chroma_server.py` loads embedding models based on `EMBEDDING_MODEL` environment variable, also presenting a supply chain risk if models are sourced from untrusted locations. The custom `SimpleHttpClient` in Scala, while functional, might not be as thoroughly vetted as widely used HTTP client libraries, potentially leading to unforeseen HTTP-related vulnerabilities. Input to SPARQL queries is URL-encoded, which mitigates direct injection, but the overall reliance on external content for initialization merits caution.

Updated: 2026-01-05GitHub→

Medium Cost

xPay

by dimitrov-d

Sec8

Monetize existing HTTP endpoints into paid microservices and expose them as AI-native Model Context Protocol (MCP) tools on Solana.

Setup Requirements

⚠️Requires `NEXT_PUBLIC_CDP_PROJECT_ID` from the Coinbase CDP portal for frontend wallet integration.
⚠️Requires `DATABASE_URL` (Postgres) connection string for backend operations.
⚠️Endpoint creators need a non-zero SOL balance in their wallet to register new endpoints.
⚠️Testing paid endpoints requires a non-zero USDC balance in the connected wallet for x402 payments.

Verified SafeView Analysis

The server employs robust practices including Zod for input validation, JWTs for authentication, and Solana signature verification. It integrates Faremeter for x402 payment enforcement and uses `@modelcontextprotocol/sdk` for MCP server functionality with DNS rebinding protection. Dynamic MCP tool schemas infer types from sample data, which is generally safe. Local image storage for AI-generated content (served publicly) introduces a potential risk if `BASE_URL` is misconfigured or if malicious content could be generated and served. Overall, good security hygiene is demonstrated, but thorough configuration and monitoring are essential for production.

Updated: 2025-11-23GitHub→

Low Cost

relay

by srbsingh3

Sec9

Relay is a macOS-only Electron application designed to orchestrate and manage offline-first MCP (Model Context Protocol) servers for AI coding agents like Cursor, Claude Code, and Codex.

Setup Requirements

⚠️Requires macOS to run (macOS-only application).
⚠️Relies on macOS Keychain for secure secret storage.
⚠️Development requires Node.js (>=18.17.0), TypeScript, and npm workspaces.

Verified SafeView Analysis

The project demonstrates a strong commitment to security, explicitly outlining and enforcing best practices. Key Electron security flags (`contextIsolation=true`, `nodeIntegration=false`, `sandbox=true`) are mandated and implemented. A strict Content Security Policy (`default-src 'self'`) is applied to prevent remote code execution. Secrets are securely stored exclusively in the macOS Keychain using `keytar`, with in-memory purging after use. File operations utilize atomic writes with `.tmp` and `.bak` files for data integrity and recovery. Network activity is strictly limited to transparent, read-only update checks, with no telemetry or user data transmitted. No 'eval' or other inherently dangerous patterns without clear justification were found.

Updated: 2026-01-16GitHub→

Medium Cost

agent-orchestrator-mcp

by techmad220

Sec9

Orchestrates multi-AI coordination, task management, and collaboration across configurable local and cloud LLM providers.

Setup Requirements

⚠️Requires Rust toolchain for building the executable (`cargo build --release`).
⚠️Requires a local Ollama instance running on `http://localhost:11434` by default for local-only mode or to use Ollama models.
⚠️Cloud providers (Claude, OpenAI) require API keys, which are typically associated with paid services.

Verified SafeView Analysis

The server uses standard Rust security practices. API keys are managed via configuration files or environment variables, not hardcoded directly into the application logic. Network communication for AI providers uses the `reqwest` crate, a common and reputable HTTP client. There are no direct `eval`-like functions for arbitrary code execution from user input in the provided Rust code. Potential risks are inherent to LLM interactions (e.g., handling of generated code or malicious prompts leading to unwanted LLM behavior) rather than direct server compromise. The `run-mcp.sh` script logs to a user-specific directory and handles environment variables correctly.

Updated: 2025-12-14GitHub→

Medium Cost

MCP_SERVER

by sunny1561

Sec7

An AI-powered agent for searching and booking flight tickets, exposed via a FastAPI web API.

Setup Requirements

⚠️Requires a Google Cloud Project with Generative AI API enabled to obtain `GOOGLE_API_KEY` (paid usage).
⚠️Requires a configured Gmail account and an app-specific password for `EMAIL_SENDER` and `EMAIL_APP_PASSWORD` to enable sending booking confirmation emails.
⚠️CORS is set to allow all origins (`*`) for the FastAPI server, which is not recommended for production deployments due to security implications.

Verified SafeView Analysis

The application uses `os.getenv` for sensitive credentials (API keys, email config), which is good practice. No obvious malicious patterns or `eval` usage. However, `allow_origins=["*"]` for CORS is configured in `api/main.py`, which is acceptable for development but a significant security risk in a production environment as it allows cross-origin requests from any domain. PDF generation and email sending seem to handle data safely.

Updated: 2025-12-01GitHub→

Medium Cost

telegram-mcp

by stevehorn

Sec8

Searches for messages within a specified Telegram group or channel using keywords, date filters, and extended metadata.

Setup Requirements

⚠️Requires Telegram API credentials (API ID, API Hash) obtained from https://my.telegram.org.
⚠️Requires a Telegram phone number for initial authentication to generate a session string.
⚠️Requires running `npm run auth` once to authenticate and persist the session in the `.env` file.
⚠️Requires a specific `TELEGRAM_GROUP_ID` which can be a public group username or a private group invite hash.

Verified SafeView Analysis

The server handles Telegram API credentials and a session string, which are critical secrets. It correctly uses environment variables for these. The core functionality involves calling the Telegram API's search endpoint with user-provided queries. While no direct 'eval' or arbitrary command injection vulnerabilities are immediately apparent from user input within the provided source code, the reliance on third-party libraries (`telegram`, `chrono-node`) introduces external dependencies whose security is paramount. The `includeExtendedMetadata` option triggers additional API calls (e.g., for reply context, sender info per message), potentially increasing the attack surface or leading to rate-limiting issues if abused. Overall, the approach to secrets management and tool invocation appears standard and reasonably secure.

Updated: 2026-01-19GitHub→

Medium Cost

MCP_SERVER

by Saheli-deb

Sec1

Hosts a server for a specific protocol or application.

Review RequiredView Analysis

Insufficient source code provided to perform a meaningful security audit. No 'eval', obfuscation, hardcoded secrets, or malicious patterns could be identified due to the lack of code beyond the README. Without server implementation details, potential network risks, vulnerabilities, or supply chain issues cannot be assessed, making it unsafe to run without further inspection.

Updated: 2025-12-06GitHub→

PreviousPage 327 of 760Next