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
Pintaro icon

mem0

by Pintaro

Sec4

OpenMemory is a personal AI memory management server with a web dashboard, allowing users to store, retrieve, and manage facts and preferences for AI agents and applications. It provides a centralized knowledge base for various client applications.

Setup Requirements

  • ⚠️Requires API keys for chosen LLM and Embedder providers (e.g., OPENAI_API_KEY) configured via environment variables or the UI.
  • ⚠️Python 3.x environment needed for the API server, and Node.js for the Next.js UI. Docker/Docker Compose is the recommended setup.
  • ⚠️Defaults to SQLite, but can be configured to use various vector databases (Qdrant, Chroma, Redis, Elasticsearch, etc.), each with its own setup requirements.
Review RequiredView Analysis
The underlying `mem0` library, used by this server, appears to use `eval()` for parsing tool call arguments in some contexts (observed in `mem0-ts/src/oss/src/llms/langchain.ts` and `mem0/proxy/main.py`). This is a critical security vulnerability if attacker-controlled input can reach these `eval` calls, potentially leading to arbitrary code execution. While the immediate server code might sanitize inputs, the dependency introduces a high risk. Other aspects, such as using environment variables for API keys and local API communication, are generally good practices.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
firo icon
Sec8

Provides technical and fundamental analysis, and portfolio management tools for financial assets via an MCP server.

Setup Requirements

  • ⚠️Requires Python dependencies (`yfinance`, `pandas`, `numpy`, `pandas_ta`, `mcp`, `FastAPI`, `uvicorn`, `sse_starlette`).
  • ⚠️Requires internet access to fetch financial data from Yahoo Finance.
  • ⚠️Manual configuration of Claude Desktop JSON file for local integration.
Verified SafeView Analysis
The server primarily relies on the `yfinance` library for fetching market data. While `yfinance` is a widely used library, the server does not perform extensive sanitization of ticker symbols beyond what `yfinance` implicitly handles. No direct `eval` or `exec` calls with user input were found. The core logic involves data processing and calculations, not direct system interaction or arbitrary code execution based on external input. The application exposes port 8000, which requires appropriate network security if exposed publicly.
Updated: 2026-01-18GitHub→
0
0
Medium Cost
MCDxAI icon
Sec3

Integrates Model Context Protocol (MCP) servers and Google Gemini AI with Meteor Client for tool execution and AI interaction within Minecraft.

Setup Requirements

  • ⚠️Requires Meteor Client (Minecraft mod) to function.
  • ⚠️External MCP servers (e.g., Node.js, Python) must be installed and configured separately by the user.
  • ⚠️Optional: Google Gemini API key (paid service) is required for AI integration.
Review RequiredView Analysis
The addon allows users to configure and run arbitrary local commands as MCP servers via `StdioClientTransport`. This means any configured MCP server can execute arbitrary code on the user's system, controlled by the `command`, `args`, `workingDirectory`, and `env` parameters in `MCPServerConfig`. This poses a significant security risk if untrusted MCP servers are added or if the addon is compromised to add malicious servers. Gemini API keys are lightly obfuscated (XOR with a hardcoded salt) before NBT storage, not strongly encrypted.
Updated: 2026-01-07GitHub→
0
0
Medium Cost
cyril-goud-foodsmart icon

redshift-mcp-server

by cyril-goud-foodsmart

Sec7

This server acts as a Model Context Protocol (MCP) agent for AWS Redshift, enabling programmatic access to Redshift schemas, table metadata, and allowing execution of read-only SQL queries.

Setup Requirements

  • ⚠️Requires an AWS Redshift instance and corresponding credentials (host, database, user, password).
  • ⚠️Explicitly sets Redshift SSL `rejectUnauthorized: false`, which might require awareness of its security implications or specific network configurations.
  • ⚠️Requires Node.js (>=18) and npm/yarn to build and run the TypeScript project.
Verified SafeView Analysis
The server connects to AWS Redshift, leveraging environment variables for credentials. The `execute_query` tool is restricted to `SELECT`, `WITH`, and `EXPLAIN` statements, significantly mitigating SQL injection risks for write/destructive operations. However, the Redshift connection explicitly sets `ssl: { rejectUnauthorized: false }`, which weakens SSL security by not verifying the server's certificate. While sometimes necessary in specific enterprise configurations (e.g., custom CAs), it introduces a potential man-in-the-middle vulnerability if not properly understood and managed.
Updated: 2025-12-14GitHub→
0
0
Medium Cost
kekzl icon
Sec8

Manages on-demand Model Context Protocol (MCP) servers using Docker Compose to provide AI coding assistants with task-specific tools and reduce token context overhead.

Setup Requirements

  • ⚠️Docker and Docker Compose must be installed.
  • ⚠️Requires obtaining and configuring various API tokens (GitHub, Database, Slack, Jira, Brave Search) in a `.env` file.
Verified SafeView Analysis
The project uses official MCP server Docker images and emphasizes secure practices like `.env` for secrets, least privilege, and sandboxed filesystem access. The Puppeteer server, however, requires `SYS_ADMIN` capability and `seccomp=unconfined`, which significantly relaxes security for that specific service and increases the attack surface if used for untrusted web content. No 'eval' or malicious patterns found in the shell script, which primarily wraps Docker commands.
Updated: 2025-12-06GitHub→
0
0
High Cost
Sec7

An AI-powered platform for building interactive conversational forms that leverage large language models.

Setup Requirements

  • ⚠️Requires an API key for a Large Language Model (e.g., OpenAI, Anthropic, Google Gemini), which may incur costs.
  • ⚠️Requires Node.js and a package manager (npm or yarn) installed for dependency management and running the development server.
Verified SafeView Analysis
The project is a front-end web application interacting with external AI APIs. This introduces potential network risks related to API key exposure (if not properly proxied or secured via a backend), data handling with third-party LLM providers, and potential for prompt injection if the agent design is not robust. Client-side heavy applications require careful management of sensitive credentials.
Updated: 2025-11-17GitHub→
0
0
Low Cost
Kuxha icon
Sec9

This server demonstrates autonomous workforce orchestration for post-acute care by automating scheduling, detecting conflicts, and enforcing compliance for a synthetic home-care workforce using an AI agent.

Setup Requirements

  • ⚠️Requires Python 3.12+
Verified SafeView Analysis
The server operates primarily with an in-memory data store, significantly reducing risks associated with database injections. Communication for the MCP server is via standard I/O ('stdio') using 'mcp dev', which limits direct network exposure. The code does not contain 'eval', 'exec', or other obvious dynamic code execution vulnerabilities. There are no hardcoded secrets or external API keys visible in the provided source. The system processes synthetic data, further reducing real-world impact of potential exploits. Overall, the architecture and implementation appear secure for its intended demonstration purpose.
Updated: 2026-01-15GitHub→
0
0
Medium Cost

mcp_server_test

by plaire48

Sec4

A backend server application, potentially related to game development or modding (e.g., Minecraft Coder Pack), which might include functionalities integrating with AI/LLM for data processing or interactive elements.

Setup Requirements

  • ⚠️Requires a Python environment and installation of dependencies listed in `requirements.txt` (exact dependencies unknown).
  • ⚠️May require configuration of network ports and firewall rules for server accessibility.
  • ⚠️If AI/LLM functionality is present (as suggested by schema), it will require an LLM provider API key or a local LLM setup, potentially incurring costs.
Review RequiredView Analysis
A thorough security audit is impossible without the content of `Activity` and `requirements.txt`. Based solely on the 'Server' designation, common risks include unauthenticated endpoints, insecure deserialization, potential vulnerabilities in unpatched dependencies, and improper input validation. No specific 'eval' or obfuscation could be identified due to missing code.
Updated: 2025-11-17GitHub→
0
0
High Cost
guojun21 icon
Sec5

Orchestrates long-running, agent-based LLM tasks, generating content and continuously or periodically re-executing prompts based on initial goals and input materials.

Setup Requirements

  • ⚠️Requires `agent` CLI to be installed and logged in.
  • ⚠️The `agent` CLI needs access to the fixed model: `gpt-5.2-codex-xhigh-fast`.
  • ⚠️The output directory must be writable by the server and the `agent`.
Review RequiredView Analysis
The server delegates task execution to an external `agent` CLI, which is invoked using `child_process.spawn`. User-controlled arguments like `agent_bin`, `workspace_dir`, `output_dir`, and `input_materials` are passed directly to `spawn` and file system operations (`fs` module). This introduces risks of arbitrary command execution if `agent_bin` is manipulated to point to a malicious binary, or path traversal if directory paths are not sufficiently sanitized. The `agent` is also run with `--force-allow-all-commands` (`-f`), giving it broad permissions within its workspace. Requires trust in the `agent` CLI and careful handling of user inputs to prevent exploitation.
Updated: 2026-01-18GitHub→
0
0
Low Cost

mcp_server

by Joshua-Abok

Sec5

A server component designed to provide weather-related data or services.

Setup Requirements

  • ⚠️Likely requires an external Weather API key (e.g., OpenWeatherMap, AccuWeather), which may involve registration or payment for commercial use.
  • ⚠️Python dependencies (e.g., Flask, requests, etc.) are not specified and need to be identified from the `server.py` code.
  • ⚠️No details on database requirements for caching, user data, or historical weather data.
Review RequiredView Analysis
Cannot perform a comprehensive security audit without the content of `server.py`. Assumed to be a standard network server, which inherently carries risks if not properly secured (e.g., authentication, input validation, authorization, rate limiting). Without code, checks for 'eval', obfuscation, or specific network vulnerabilities are impossible. Further code inspection is required.
Updated: 2025-11-17GitHub→
0
0
Low Cost
brzozowskijuanpablo icon

MCP_Server

by brzozowskijuanpablo

Sec5

A C# .NET 8.0 server application designed to manage or orchestrate other processes (referred to as 'mcpServers'), such as a 'sql-query-server' that interacts with a SQL API.

Setup Requirements

  • ⚠️.NET 8.0 SDK Required
  • ⚠️External SQL API Dependency (Implicit for child processes)
Review RequiredView Analysis
The provided source code is limited to project configuration files and a custom configuration file (mcp-config.json). No actual C# application logic is available for a comprehensive security audit. The mcp-config.json demonstrates the server's ability to execute arbitrary commands (`dotnet run`) and set environment variables for child processes. If this configuration file can be dynamically loaded from an untrusted source or manipulated without proper authorization, it would represent a critical remote code execution vulnerability. The `SQL_API_URL` specified is `http://localhost:7000`, which is not a hardcoded secret itself, and points to a local endpoint, minimizing external network exposure from this specific configuration.
Updated: 2025-11-28GitHub→
0
0
Low Cost
thiennga52004 icon

OpenAPI-to-MCP-Server-FE

by thiennga52004

Sec4

A frontend web application for managing and converting OpenAPI specifications into Model Context Protocol (MCP) servers, enabling AI assistant interaction.

Setup Requirements

  • ⚠️Requires a separate backend API server (not provided in this repository) to handle user authentication, spec management, and executable building.
  • ⚠️The `REACT_APP_API_DOMAIN` environment variable should be explicitly set to point to a secure (HTTPS) backend API to avoid using the hardcoded insecure HTTP endpoint.
  • ⚠️The signup process is simulated on the frontend (`Auth.js`), implying the backend doesn't yet support this route or it's a placeholder.
Verified SafeView Analysis
The application hardcodes a backend API domain `http://57.158.26.182:8081` in `Auth.js` if `REACT_APP_API_DOMAIN` is not set. Using an HTTP (non-HTTPS) endpoint is a critical security risk as it exposes sensitive data like login credentials and JWT tokens to eavesdropping. Storing JWT tokens in `localStorage` (`localStorage.setItem('JWTtoken', data.data.JWTtoken)`) is susceptible to Cross-Site Scripting (XSS) attacks. No client-side input validation is visible for uploaded files, which should be strictly handled by the backend. The core frontend code itself does not contain obvious malicious patterns like `eval` or obfuscation, but its reliance on a potentially insecure backend connection is a major concern.
Updated: 2025-12-14GitHub→
PreviousPage 657 of 760Next