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(8554)

0
0
Medium Cost
openpharma-org icon

fda-mcp

by openpharma-org

Sec9

Provides pharmaceutical intelligence by integrating real-time FDA data (OpenFDA, Orange Book, Purple Book) to offer insights on drug safety, patents, biosimilars, and regulatory compliance for enhanced decision-making.

Setup Requirements

  • ⚠️Requires an initial download of large FDA Orange Book and Purple Book datasets (~47k drug products, ~21k patents) on first run, which may take time and disk space (approx. 300-500MB). These datasets are automatically updated monthly.
  • ⚠️Requires a Node.js runtime environment to execute.
  • ⚠️Constant internet connectivity is essential for initial data download and all live FDA API calls.
Verified SafeView Analysis
The server demonstrates robust security practices including comprehensive input validation using Zod schemas, parameterized queries for the local SQLite database (mitigating SQL injection risks), and appropriate handling of environment variables for sensitive data like API keys. File system operations are confined to internal data paths, and structured logging includes sanitization of sensitive fields. No direct usage of `eval` or user-controlled `child_process` execution was observed.
Updated: 2025-12-22GitHub→
0
0
Low Cost
fkucukkara icon

mcp-101

by fkucukkara

Sec9

Demonstrates using Model Context Protocol (MCP) with GitHub Copilot to enhance C# .NET development workflows, featuring a simple calculator application.

Setup Requirements

  • ⚠️Requires .NET 10 SDK installed.
  • ⚠️Requires VS Code MCP extension.
  • ⚠️Full functionality for MCP features requires an active GitHub Copilot subscription/access.
Verified SafeView Analysis
The provided source code (global.json, README.md) does not contain any obvious security vulnerabilities like hardcoded secrets, 'eval' statements, or malicious network patterns. The project's core functionality is a simple calculator, and its primary purpose is to demonstrate MCP integration with GitHub Copilot by interacting with 'https://api.githubcopilot.com/mcp', which is an expected external dependency for its stated use case.
Updated: 2026-01-17GitHub→
0
0
Medium Cost
back1ply icon
Sec9

Acts as a Model Context Protocol (MCP) server to dynamically load and manage AI agent skills from the local file system.

Setup Requirements

  • ⚠️Requires Node.js >= 18 to run.
  • ⚠️Requires manual registration in the `.mcp.json` file for agents to discover it.
Verified SafeView Analysis
The server correctly implements critical path validation to prevent directory traversal attacks in the `install_skill` function, ensuring target paths remain within the designated workspace. It uses standard Node.js file system operations with robust error handling, preventing crashes due to inaccessible or malformed skill files. There is no usage of 'eval', obfuscation, or direct arbitrary command execution via `child_process`. Network interactions are limited to the MCP standard I/O transport, not opening arbitrary ports. Custom .env loading is implemented safely to avoid stdout corruption during MCP initialization.
Updated: 2026-01-17GitHub→
0
0
Medium Cost
trite icon
Sec8

Provides a Model Context Protocol (MCP) server for .NET C# code analysis, specifically focused on detecting unreferenced code and analyzing solution structures.

Setup Requirements

  • ⚠️Requires .NET 9.0 or later runtime environment.
  • ⚠️Requires MSBuild to be installed (typically included with Visual Studio or .NET SDK).
  • ⚠️Requires an MCP-compatible client (e.g., Claude Desktop) for integration and proper configuration.
Verified SafeView Analysis
The server's core functionality involves loading and analyzing .NET solutions/projects using Roslyn's MSBuildWorkspace. While this is a standard and legitimate method for code analysis, loading untrusted solution or project files could potentially expose the system to risks associated with MSBuild processing. However, the server itself is designed for local execution via stdio, limiting direct network attack vectors. No specific malicious patterns or vulnerable constructs like 'eval' are indicated in the provided README/License, though a full source code audit would be required for a definitive assessment.
Updated: 2025-11-20GitHub→
0
0
Medium Cost
ScraperHub icon

ai-sales-bot

by ScraperHub

Sec7

An AI-powered sales lead generation bot that uses Crawlbase Web MCP and Claude Desktop to crawl websites, extract business data, and output it as a structured CSV.

Setup Requirements

  • ⚠️Requires a Crawlbase account and API tokens (potentially paid service).
  • ⚠️Requires Claude Desktop to be installed and configured.
  • ⚠️Relies on an external script from 'github.com/crawlbase/crawlbase-mcp' that needs to be manually downloaded and configured.
Verified SafeView Analysis
The provided repository 'ai-sales-bot' itself only contains a README.md file; no executable source code is present for direct security analysis within this specific repository. The described solution involves configuring Claude Desktop with an external script from 'https://github.com/crawlbase/crawlbase-mcp' and inserting Crawlbase API tokens into 'claude_desktop_config.json'. The security risk primarily lies with the trustworthiness of the external Crawlbase script and the secure handling of API tokens. Users should carefully review the external script before integrating it, as it will grant web access to Claude Desktop. The direct content of this repository is safe.
Updated: 2025-12-02GitHub→
0
0
Low Cost
varshavskiyTymur icon

sb-content-creator

by varshavskiyTymur

Sec8

An MCP server for AI interaction with Storyblok CMS, enabling automated content creation without manual intervention.

Setup Requirements

  • ⚠️Requires Storyblok Management API credentials (Space ID and Access Token). These are obtained from your Storyblok account settings and might require a paid Storyblok plan.
  • ⚠️Requires Node.js >= 18.0.0.
  • ⚠️CRITICAL BUG: The server will not start if Storyblok `SPACE_ID` and `ACCESS_TOKEN` are not explicitly set as environment variables (`process.env.SPACE_ID`, `process.env.ACCESS_TOKEN`) *before* running the application. Command-line arguments (e.g., `--space-id`, `--access-token` as shown in the `npx` example) are currently ineffective for initialization due to a bug in how `createStoryblokServer` resolves these credentials.
Verified SafeView Analysis
The server correctly avoids hardcoded secrets by expecting Storyblok `SPACE_ID` and `ACCESS_TOKEN` via environment variables or command-line arguments. It does not use `eval` or exhibit obfuscation. However, there is a critical bug in the `src/server/storyblok-server.ts` file: the `createStoryblokServer` function validates and instantiates the `StoryblokApiClient` using the `spaceId` and `accessToken` parameters *directly passed to it*, before considering environment variables or command-line arguments. This means if `createStoryblokServer` is called with empty strings (as it is when `process.env.SPACE_ID` or `process.env.ACCESS_TOKEN` are unset for the HTTP server, or when no arguments are passed for the STDIO/`npx` server), it will unconditionally throw an error and fail to start. This is a setup/functional flaw, not a vulnerability that exposes data or allows arbitrary code execution once running.
Updated: 2026-01-12GitHub→
0
0
High Cost
mrkingsleyobi icon

synapseflow

by mrkingsleyobi

Sec3

An MCP server that acts as a communication layer for a self-learning AI research assistant, orchestrating 66 specialized agents for cross-domain knowledge discovery and real-time insights.

Setup Requirements

  • ⚠️Requires Node.js 20+ and npm 10+.
  • ⚠️Requires Docker & Docker Compose to run supporting databases (PostgreSQL, Redis, Neo4j).
  • ⚠️Requires a HuggingFace API Key for AI model inference, which may incur costs for substantial usage.
  • ⚠️Requires modification of default database passwords and JWT secret for secure deployment, even for local development if exposed to a network.
Review RequiredView Analysis
Multiple critical security risks exist for deployment: 1. Hardcoded Default Passwords: `NEO4J_AUTH=neo4j/password` and `POSTGRES_PASSWORD=password` are hardcoded in `docker-compose.yml` and `init-databases.sh`. 2. Hardcoded JWT Secret: `JWT_SECRET: 'change-me-in-production'` is a default value in `backend/src/config/index.ts` and must be changed for production. 3. Exposed Database Ports: Database ports (PostgreSQL: 5432, Redis: 6379, Neo4j: 7474, 7687) are directly exposed in `docker-compose.yml`, which is unsafe for production without proper network isolation. 4. Reliance on Backend Security: The MCP server forwards requests to the backend; the overall system's security depends on the backend's robustness against injection or misconfigurations. 5. Dependency Security: Heavy reliance on numerous Ruvnet NPM packages, whose security is critical but outside this review's scope.
Updated: 2025-11-25GitHub→
0
0
Low Cost
annmalavet icon
Sec1

This server provides a RESTful API with tools to manage patient information, including searching, creating, and updating patient records in a PostgreSQL database.

Setup Requirements

  • ⚠️Requires a PostgreSQL database to be provisioned and accessible.
  • ⚠️Requires the `patient_info` table to exist in the database with expected columns for patient data.
  • ⚠️Database connection credentials (DB_USER, DB_PASS, DB_NAME, DB_HOST, DB_PORT) must be set as environment variables.
  • ⚠️The default database SSL configuration (`rejectUnauthorized: false`) is highly insecure and should be addressed for any production deployment.
Review RequiredView Analysis
CRITICAL SECURITY RISKS IDENTIFIED: 1. CORS Misconfiguration: The server uses `cors({ origin: '*' })`, which allows requests from any origin. For a system handling sensitive patient information, this is a severe vulnerability that bypasses same-origin policy, making it susceptible to cross-site request forgery (CSRF) and potential data exfiltration from any malicious website if not protected by other strong authentication mechanisms (which are not present in the provided code). 2. PostgreSQL SSL/TLS Insecurity: The database connection is configured with `ssl: { rejectUnauthorized: false }`. This disables SSL/TLS certificate validation, meaning the server will connect to any PostgreSQL instance without verifying its identity. This makes the database connection vulnerable to man-in-the-middle (MITM) attacks, allowing attackers to intercept or alter sensitive patient data in transit. While the application correctly uses parameterized queries (e.g., `$1`, `$2`) to prevent common SQL injection vulnerabilities in its data access layer, the critical network and database connection security flaws outweigh this positive aspect for a system dealing with sensitive personal information.
Updated: 2026-01-19GitHub→
0
0
Low Cost
mcpize icon

cli

by mcpize

Sec5

A command-line interface (CLI) tool designed for deploying, managing, and monetizing Model Context Protocol (MCP) servers in the cloud.

Setup Requirements

  • ⚠️Requires Node.js v20.0.0 or higher to run the CLI itself.
  • ⚠️Requires `mcpize login` for authentication to access most cloud features.
  • ⚠️The `mcpize dev` command may require additional local tools like `tsx`, `uvicorn`, `watchdog.watchmedo`, or `php` CLI installed, depending on the project's runtime and chosen tunnel provider (`ngrok`, `cloudflared` need setup or auth tokens).
Verified SafeView Analysis
The CLI handles authentication securely, using browser-based OAuth with CSRF protection and refresh token rotation. Secrets management (mcpize secrets) is robust, supporting secure input methods and environment isolation. However, there are significant security and privacy implications to note: 1. The `mcpize analyze` command sends the entire local project directory (tarball) to a remote API (`/analyze-repository/tarball`) for manifest generation. This means your complete source code is transmitted to a third-party service, which can be a data privacy concern for proprietary or sensitive intellectual property. 2. The `mcpize init` command downloads project templates from `mcpize/templates` on GitHub. These templates can contain and execute `postInit` scripts, introducing a supply-chain risk. If the template repository were compromised, malicious code could be executed on the user's local machine. 3. The CLI frequently executes external commands (e.g., `npm`, `python`, `git`, `uvicorn`, `tsx`, `cloudflared`) based on user project configuration. While this is standard for a development tool and arguments appear to be handled with basic sanitation (e.g., quoting entry paths), users should be aware that the CLI trusts the scripts defined within their local projects. 4. A Supabase anonymous public key is hardcoded in `src/lib/config.ts`. This is typically designed for client-side access to public data and is not a secret in the traditional sense, but its purpose should be clearly understood.
Updated: 2026-01-18GitHub→
0
0
Medium Cost
anguslin icon
Sec6

A chat application for users to query politician trading data, using an LLM to interpret queries, access data via the Model Context Protocol (MCP), and summarize findings.

Setup Requirements

  • ⚠️Requires a Hugging Face API Key (`HF_API_KEY`), which is needed for LLM inference and may incur usage costs based on model and token consumption.
  • ⚠️The frontend (`ui/app.js`) contains a hardcoded `API_KEY` that *must* be updated to match the backend's API_KEY and secured (e.g., via a proxy or GitHub Secrets) before any production deployment to prevent its public exposure.
  • ⚠️The backend relies on the `@anguslin/mcp-capitol-trades` server being runnable as a Node.js child process within its environment, potentially requiring specific Node.js versions (>=18) and dependencies to be available for the spawned process.
Verified SafeView Analysis
The frontend (`ui/app.js`) hardcodes the `API_KEY` which will be publicly visible if deployed without modification, posing a significant security risk to that specific key. The backend implements several security measures including CORS restriction to allowed domains, API key validation via `x-api-key` header, and rate limiting. The `mcpService` spawns a child `node` process to run the `@anguslin/mcp-capitol-trades` server; while spawning child processes can be a risk, in this case, it's explicitly targeting a known internal dependency.
Updated: 2025-11-30GitHub→
0
0
Medium Cost
Readify-App icon

pilates-mcp-server

by Readify-App

Sec2

Provides Pilates studio information from a WordPress site to Claude Desktop, including search, details, and content management capabilities for multiple post types.

Setup Requirements

  • ⚠️Requires Python 3.10+.
  • ⚠️Requires Claude Desktop to be installed and running.
  • ⚠️WordPress API credentials (username and application password) are hardcoded in `server.py` and need manual modification for custom WordPress instances, or for updating compromised credentials.
  • ⚠️`uv` and `jq` are required for installation and are installed by the setup script, potentially requiring elevated privileges for `jq` on Linux (`sudo apt-get install jq`).
Review RequiredView Analysis
CRITICAL: WordPress API username and application password are hardcoded in plain text within `server.py`. This is a severe security risk, allowing anyone with access to the source code to gain full administrative access to the connected WordPress site. These credentials should be stored securely, ideally as environment variables. The installation process uses `curl | bash` which executes remote scripts directly and carries inherent risks of arbitrary code execution if the source is compromised. The server exposes several write operations (create/update posts, custom fields, taxonomies) using these hardcoded credentials, making it highly vulnerable if deployed insecurely.
Updated: 2025-12-07GitHub→
0
0
Low Cost
rainmana icon

gothink-web

by rainmana

Sec7

Provides AI assistants with a structured Model Context Protocol (MCP) server offering systematic thinking tools, mental models, and debugging approaches for enhanced decision-making.

Setup Requirements

  • ⚠️Requires Go 1.21+ and Git if building from source.
  • ⚠️Data is stored in-memory and will be lost on server restart by default, as no persistent storage implementation is provided in the current code (despite `enable_persistence` config option).
  • ⚠️Requires an MCP-compatible client (e.g., Claude Desktop) to interact with its services; it does not offer a standalone user interface.
Verified SafeView Analysis
The Go backend uses standard library and well-known third-party libraries for HTTP and MCP. Configuration is managed via environment variables or files, avoiding hardcoded secrets. HTTP server sets read/write timeouts to mitigate certain denial-of-service attacks. CORS is broadly enabled for all origins ('*'), which might be acceptable for an MCP client integration but means the server does not enforce origin-based access control. The `DEPLOYMENT.md` explicitly states there is 'no built-in authentication' for the HTTP endpoints, requiring external security measures (e.g., API keys, firewalls) for production use to secure access to its tool functions. No 'eval' or similar dangerous dynamic code execution patterns are observed.
Updated: 2025-11-26GitHub→
PreviousPage 522 of 713Next