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
banday00 icon
Sec8

A remote, unauthenticated Model Context Protocol (MCP) server deployed on Cloudflare Workers, providing simple calculator tools for integration with AI clients like Cloudflare AI Playground or Claude Desktop.

Setup Requirements

  • ⚠️Requires a Cloudflare account for deployment.
  • ⚠️Requires Node.js and `npm`/`wrangler` CLI for local development and deployment.
  • ⚠️The server is intentionally unauthenticated and publicly accessible by design; users should be aware of this for any modifications.
Verified SafeView Analysis
The server is explicitly designed to be "authless," allowing unrestricted access to its calculator tools. While this is intentional for demonstration purposes, deploying sensitive tools without authentication would be a critical security vulnerability. No direct code injection vulnerabilities or hardcoded secrets were identified within the provided source code.
Updated: 2026-01-16GitHub→
0
0
Medium Cost
akash8190 icon

MCP-Server-project

by akash8190

Sec8

A client-server system for remote execution of math operations and mock weather data retrieval using LangChain/LangGraph and an MCP adapter.

Setup Requirements

  • ⚠️Requires Python 3.13 or higher (as per pyproject.toml, overriding README's 3.8+).
  • ⚠️Requires a GROQ_API_KEY environment variable to be set for LLM interactions.
  • ⚠️The weather server (weather.py) must be running explicitly on http://localhost:8000 for the client to communicate with it via HTTP.
Verified SafeView Analysis
The project avoids obvious hardcoded secrets by using environment variables for the GROQ_API_KEY. Math operations are simple arithmetic, limiting injection risks. The weather server currently returns a hardcoded string, mitigating external API security concerns. Primary risks would stem from potential vulnerabilities in the LangChain/LangGraph or MCP libraries themselves, or if the server components were exposed publicly without proper authentication.
Updated: 2025-11-30GitHub→
0
0
Medium Cost
CaullenOmdahl icon

duffel-mcp-server

by CaullenOmdahl

Sec9

Enables LLMs to search for flights, analyze offers, and create bookings through the Duffel API with intelligent optimization strategies.

Setup Requirements

  • ⚠️Requires a Duffel API Key with specific permissions (air.offer_requests.create, air.offers.read, air.orders.create, air.airlines.read, payments.payment_intents.create).
  • ⚠️Duffel Payments must be enabled on your Duffel account for the self-hosted checkout flow (`duffel_create_checkout` tool).
  • ⚠️For persistent checkout sessions in a hosted environment, a Redis instance is required (falls back to in-memory store otherwise).
  • ⚠️Python 3.10 or higher is required.
Verified SafeView Analysis
The server uses Pydantic for robust input validation, `os.getenv` for API key management, and `httpx` for secure external API calls with error handling. Basic path traversal prevention is implemented for static file serving. It uses a trusted third-party payment component (Duffel Payments JS). No `eval` or obvious obfuscation detected. Session storage can fall back to in-memory if Redis is not configured, which might not be production-ready for session persistence.
Updated: 2026-01-03GitHub→
0
0
Medium Cost
kcofoni icon

pmwiki-mcp

by kcofoni

Sec9

Provides a Model Context Protocol (MCP) server for LLMs to read and search PmWiki content.

Setup Requirements

  • ⚠️Requires Docker to run.
  • ⚠️Requires an existing PmWiki 'wiki.d' directory on the host machine to be mounted as a read-only volume.
  • ⚠️Client (e.g., Claude Desktop) requires the 'mcp-proxy' tool for connection.
Verified SafeView Analysis
The server design is secure by default due to read-only mounting of the PmWiki 'wiki.d' directory, preventing any write operations to the wiki files. There are no 'eval' statements or other direct code injection vulnerabilities. Path traversal within 'read_page' is mitigated by replacing '/' with '.' and 'os.path.join' appending to a controlled directory, making it highly unlikely for an attacker to access files outside the mounted volume.
Updated: 2025-12-23GitHub→
0
0
Medium Cost
rncz icon
Sec6

Allows a Large Language Model (LLM) to perform CRUD operations, run raw SQL, and introspect SQLite databases stored locally.

Setup Requirements

  • ⚠️Requires 'uv' for Python environment management and package installation.
  • ⚠️LLM software must support MCP server integration and tool calling.
  • ⚠️Databases are stored locally in a 'databases/' folder relative to the server installation, requiring careful management of this directory.
Verified SafeView Analysis
The `execute_sql` tool allows the LLM to run arbitrary SQL queries, posing a significant risk if the LLM generates malicious or destructive commands (e.g., `DROP TABLE`). While the CRUD tools use parameterized queries for data values, the `sql` string itself is directly from the LLM, requiring careful LLM prompting. The `describe_table` function uses an f-string for the table name in a `PRAGMA` statement, which could be a minor SQL injection risk if not strictly validated. Additionally, the `get_db_path` function might be susceptible to path traversal if `db_name` is manipulated to include `../` sequences, potentially allowing access to files outside the intended `databases` directory.
Updated: 2025-12-13GitHub→
0
0
Medium Cost
r1chard-lyu icon

tracium

by r1chard-lyu

Sec3

Exposes Linux tracing and debugging capabilities (e.g., eBPF, bpftrace, perf, ftrace, syscall tracing) to LLMs and autonomous agents for observability, profiling, and debugging.

Setup Requirements

  • ⚠️Requires `bpftrace`, `perf`, `strace`, and `trace-cmd` (or equivalent ftrace wrapper) to be installed on the Linux system.
  • ⚠️Requires running `sudo ./setup.sh` to configure passwordless `sudo` for `bpftrace`, which is a significant security risk for production environments and should only be used in development.
  • ⚠️Requires Python dependencies, including `fastmcp`, to be installed via `pip install -r requirements.txt`.
Review RequiredView Analysis
The server requires passwordless sudo for `bpftrace` (configured via `setup.sh`), which is a powerful kernel-level tracing tool. While path traversal is checked for `bpftrace` scripts, running arbitrary `bpftrace` scripts with root privileges carries significant risk for system stability, performance, and information disclosure. The `setup.sh` explicitly warns this is for 'development — do not enable in production.'
Updated: 2025-12-04GitHub→
0
0
Medium Cost
immersiveidea icon

babylon-mcp

by immersiveidea

Sec8

Provides AI agents with semantic search access to Babylon.js documentation, API references, and source code, acting as a canonical information source to reduce AI model token usage and improve accuracy.

Setup Requirements

  • ⚠️Requires initial data indexing (~30-45 minutes, ~2GB disk space) by running `npm run clone:repos` and `npm run index:all`.
  • ⚠️Alpine Linux environments require an additional setup step (`npm run alpine:setup`) after `npm install` for WASM backend compatibility with Transformers.js.
  • ⚠️Claude Code CLI integration currently only works via direct `/mcp <url>` command and not through `~/.claude/config.json`.
  • ⚠️If New Relic monitoring is active (default setup), `NEW_RELIC_LICENSE_KEY` and `NEW_RELIC_APP_NAME` environment variables are required.
Verified SafeView Analysis
The server uses `simple-git` for repository management, which executes shell commands for cloning and updating. Input validation is performed using Zod schemas for tool parameters, and `path.join` is used to mitigate path traversal risks when accessing local files, restricting access to cloned repositories. No 'eval', obvious hardcoded secrets, or direct network risks beyond standard HTTP server exposure were identified. New Relic integration requires environment variables for secure setup.
Updated: 2025-11-24GitHub→
0
0
High Cost
apothegmatic-whiskfern276 icon

autosteer

by apothegmatic-whiskfern276

Sec5

A desktop application for managing local Git worktrees and integrating with Claude AI for code-related tasks, providing an enhanced development environment.

Setup Requirements

  • ⚠️Requires an Anthropic API Key (Paid service for Claude AI access).
  • ⚠️Requires a local Git installation for version control operations.
  • ⚠️May require the Claude CLI (`claude` executable) to be installed and available in the system PATH for some advanced agent commands (e.g., /compact).
Review RequiredView Analysis
The application is built using Electron, employing `contextBridge` for renderer-to-main process IPC isolation, which is a good practice. However, its core functionality involves deep system integration, exposing powerful capabilities such as direct terminal access (`terminal.create`, `terminal.write`), extensive file system operations (`file:listDirectory`, `resources:uploadResources`), spawning child processes for Git operations (`git:diff-stats`, `worktree.create`), and managing external MCP servers. A vulnerability in any of these exposed IPC handlers or the underlying services could lead to arbitrary code execution or data manipulation on the user's system. The application also handles API keys (e.g., ANTHROPIC_API_KEY) and potentially sensitive `.mcp.json` configuration files locally. While typical for developer tools requiring such access, the broad permissions make it inherently higher risk if not properly secured and updated.
Updated: 2026-01-19GitHub→
0
0
Low Cost
MuscleGear5 icon

llama-api

by MuscleGear5

Sec3

A local LLM API server for chat completions, tool calling, vision, embeddings, and audio transcription, integrated with developer tools.

Setup Requirements

  • ⚠️Requires local GGUF models for LLM inference (e.g., Qwen3-1.7B-UD-Q6_K.gguf) to be present in the configured models directory (e.g., /mnt/storage/.llama-cpp/models).
  • ⚠️Optimal performance relies on GPU acceleration for llama.cpp, meaning a compatible NVIDIA GPU and drivers are highly recommended, especially when running via Docker Compose.
  • ⚠️Requires Python 3.11+.
  • ⚠️Docker Compose production setup (docker-compose.prod.yml) expects specific volume mounts for models, sessions, Redis, Prometheus, Grafana, Loki, and Whisper cache, which need to be configured on the host machine.
Review RequiredView Analysis
The project includes a built-in tool, `run_shell_command`, which uses `subprocess.run(command, shell=True)`. This is a critical security vulnerability as it allows for arbitrary shell command execution if an attacker can induce the LLM to call it or directly exploit an API endpoint that invokes tools. While intended for developer use, exposing such a capability, especially with `shell=True`, poses a significant risk for sandbox escapes and system compromise. Additionally, the `test_endpoint` MCP tool can make HTTP requests to arbitrary URLs, which could be abused for SSRF if not properly secured.
Updated: 2025-12-19GitHub→
0
0
Medium Cost
asami icon
Sec7

A hybrid semantic and vector retrieval engine that integrates knowledge graphs and embedding models to provide RAG capabilities via REST and MCP APIs for AI agents.

Setup Requirements

  • ⚠️Requires Docker to run external dependencies (Fuseki, sie-embedding).
  • ⚠️Requires an OpenAI API Key if configured to use OpenAI for embeddings.
  • ⚠️For local development, an `sbt` installation and JVM are required to run SIE outside of Docker.
Verified SafeView Analysis
The server architecture relies on external dependencies like Fuseki and a `sie-embedding` service for embedding and vector database operations. Input validation is present for common parameters (query, concept URI) at the API boundaries. Hardcoded credentials are not apparent, with sensitive keys like OPENAI_API_KEY fetched from environment variables. The internal `FusekiClient.queryFlat` method takes a raw SPARQL string; however, its current usage within SIE constructs these queries internally, mitigating direct user-controlled SPARQL injection. The `chroma_server.py` service, typically internal to the Docker network, exposes endpoints that accept document IDs, texts, and metadata. While not directly exposed to end-users in a typical deployment, these could be points of resource exhaustion if not adequately protected by a proxy or firewall in production. Overall, for its intended use as a demo/development server, the security posture is reasonable, but it lacks advanced features like rate limiting, authentication, or robust input sanitization for untrusted external traffic.
Updated: 2026-01-05GitHub→
0
0
Low Cost
aredigg icon
Sec6

This program dynamically generates Python wrappers and a FastMCP server for macOS applications, enabling LLM interaction with native app functionalities via AppleScript.

Setup Requirements

  • ⚠️Requires macOS
  • ⚠️Python 3.10+
  • ⚠️Requires `fastmcp` Python package (for server usage)
  • ⚠️Requires user permission to control macOS applications via AppleScript
Review RequiredView Analysis
The provided source code is limited to `LICENSE.md` and `README.md`, preventing a full audit of the Python generator (`mcp-osacreate`). However, the `README` explicitly warns that the generated AppleScript wrappers can expose powerful and potentially damaging macOS application functionalities, requiring user due diligence to remove risky tools. The tool itself relies on `osascript` and `sdef`.
Updated: 2025-12-05GitHub→
0
0
Medium Cost
zarqa640 icon

MCP-server

by zarqa640

Sec4

A server application designed to host and manage custom Minecraft game instances, potentially supporting modding and multiplayer interactions.

Setup Requirements

  • ⚠️Requires Java Runtime Environment (JRE) to be installed.
  • ⚠️Requires an open network port (default 25565 for Minecraft) and appropriate firewall rules.
  • ⚠️Requires manual configuration of server properties files.
Review RequiredView Analysis
Source code heavily truncated, making a thorough security audit impossible. No visibility into specific patterns like 'eval', obfuscation, hardcoded secrets, or network handling practices. Running any server without full code review carries inherent risks. A score of 4 reflects this high degree of uncertainty rather than identified vulnerabilities.
Updated: 2025-11-25GitHub→
PreviousPage 294 of 760Next