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
Medium Cost
suman724 icon

mcp-server-agent

by suman724

Sec8

Demonstrates an intelligent agent utilizing an MCP (Model Context Protocol) server for mathematical operations and showcases Agent-to-Agent (A2A) communication.

Setup Requirements

  • ⚠️Requires Python 3.12+.
  • ⚠️The MCP server must be running (`make server`) for the agent and client to function.
  • ⚠️The Calculator Agent must be running in A2A server mode (`make run-agent-server`) for the A2A invoker.
  • ⚠️An LLM API key (e.g., `API_KEY` for Gemini) or a configured local LLM (e.g., Ollama with LiteLLM) is needed for the agent's intelligent capabilities.
Verified SafeView Analysis
The server binds to `0.0.0.0` and all default communication (MCP, A2A) happens over unencrypted HTTP (e.g., `localhost:8000`, `localhost:8001`). This is acceptable for local development and demonstration purposes but would require HTTPS and proper network configuration for production deployment. API keys are appropriately managed via environment variables. The 'simple_exec' mode in the agent's CLI is not a direct arbitrary code execution vulnerability, as it parses fixed tool names and numeric arguments.
Updated: 2026-01-19GitHub→
0
0
Low Cost
altbee icon
Sec9

A minimal JSON-RPC server for interacting with Ethereum, providing balance queries, Uniswap V2 token price lookups, and swap simulations.

Setup Requirements

  • ⚠️Requires an Ethereum RPC URL (e.g., Infura/Alchemy, which can be a paid service) set in ETH_RPC_URL.
  • ⚠️The 'swap_tokens' simulation requires WALLET_PRIVATE_KEY to be set for the 'from' address to perform gas estimation. Without it, this specific method will fail.
  • ⚠️Only supports Uniswap V2; Uniswap V3 or other DEXes are not supported.
Verified SafeView Analysis
The server primarily focuses on read-only operations and simulations. Crucially, `swap_tokens` explicitly states it's a simulation and does not send transactions on-chain, which significantly mitigates financial risk. Private keys, if provided, are handled via environment variables, adhering to good security practices. The server binds to localhost by default, reducing external attack surface. No 'eval' or malicious patterns were found. The use of 'ethers-rs' and 'rust_decimal' suggests robust cryptographic and numerical handling.
Updated: 2025-12-03GitHub→
0
0
Medium Cost
alephtex icon
Sec9

Integrates Perplexity AI for web search capabilities into a Model Context Protocol (MCP) client.

Setup Requirements

  • ⚠️Requires a Perplexity AI API Key (Paid service)
  • ⚠️Requires Python 3.10+ to run
  • ⚠️Dependencies must be installed via `pip install -r requirements.txt`
Verified SafeView Analysis
The server correctly retrieves the Perplexity API key from an environment variable, preventing hardcoding. It uses `httpx` for making API requests, which is a standard and secure library. Input `query` is passed directly to the Perplexity API, relying on the external service for content handling. There are no 'eval' or similar dangerous patterns, nor direct file system access beyond script execution. Error handling is present for API key absence and network issues. Overall, the code appears safe for its intended purpose.
Updated: 2025-12-13GitHub→
0
0
Low Cost
aadversteeg icon

echo-mcp-server

by aadversteeg

Sec9

A simple echo server implementing the Model Context Protocol (MCP) to demonstrate custom MCP server creation and echo messages.

Setup Requirements

  • ⚠️Requires .NET 10.0 SDK for local development/deployment.
  • ⚠️Requires Docker for container deployment.
Verified SafeView Analysis
The provided source code snippets (configuration files) and README do not reveal any immediate security vulnerabilities like 'eval' usage, hardcoded sensitive credentials, or network misconfigurations. The 'MessageFormat' relies on string templating, which is generally safe in .NET applications and does not imply code execution. A full audit would require inspecting the complete C# application logic, but based on the available information, it appears secure for its stated purpose.
Updated: 2026-01-19GitHub→
0
0
Low Cost
bioanywhere icon

mcp-base-mcp-pibe

by bioanywhere

Sec5

A Model Context Protocol (MCP) server that provides onchain tools for AI applications to interact with the Base Network and Coinbase API, enabling various blockchain and DeFi operations.

Setup Requirements

  • ⚠️Requires multiple API keys (Coinbase Developer Platform, Alchemy, Neynar, OpenRouter) which may involve registration and potentially costs.
  • ⚠️A wallet seed phrase is required for all write operations and sensitive local configuration, necessitating careful handling and security practices.
  • ⚠️The initialization CLI writes sensitive credentials in plain text to client configuration files (e.g., Claude Desktop, Cursor) on the local machine.
Review RequiredView Analysis
The server stores sensitive credentials (Coinbase API keys, wallet seed phrase, other API keys) in plain text JSON configuration files on the user's local filesystem via its initialization CLI, which is a significant local security risk. The `buy_openrouter_credits` tool relies on a third-party API (`openrouter.ai`) to provide transaction intent data (`call_data`) for on-chain transfers; a compromise of this third-party API could lead to malicious fund transfers. Additionally, client configurations use `npx -y base-mcp@latest`, dynamically pulling the latest package version, which could expose users to supply chain attacks if the npm package is compromised. While the core blockchain interaction logic uses robust libraries like AgentKit and Viem, these configuration and third-party dependencies introduce notable vulnerabilities.
Updated: 2025-12-10GitHub→
0
0
Low Cost
BlockRunAI icon
Sec10

This repository serves as a curated 'Awesome List' of Model Context Protocol (MCP) servers relevant to e-commerce, retail, and online stores, providing a directory for developers and AI agents.

Verified SafeView Analysis
The provided 'SOURCE CODE' consists entirely of Markdown documentation files (README.md, CONTRIBUTING.md) for an 'Awesome List' of e-commerce MCP servers. It contains no executable code, scripting, server logic, or dynamic elements. Therefore, there are no inherent security risks such as 'eval', obfuscation, hardcoded secrets, or network vulnerabilities within this repository's content itself. Security risks for actual MCP servers would lie within the external repositories linked in this list, not in this documentation.
Updated: 2026-01-17GitHub→
0
0
Medium Cost
ekkerdthomas icon

pharos-mcp

by ekkerdthomas

Sec9

A Model Context Protocol (MCP) server that enables natural language querying and schema exploration of SYSPRO ERP SQL databases for non-technical users via Claude Desktop.

Setup Requirements

  • ⚠️Requires Python 3.11+.
  • ⚠️Requires access to a SYSPRO SQL Server database.
  • ⚠️Requires Claude Desktop for end-user access and integration configuration.
  • ⚠️Requires manual creation and population of a `.env` file for database credentials.
  • ⚠️Windows users typically need WSL configured for Claude Desktop integration.
Verified SafeView Analysis
The `QueryValidator` module (`src/pharos_mcp/core/security.py`) implements strong, explicit blocking of all data modification/DDL SQL commands (INSERT, UPDATE, DELETE, DROP, etc.), system stored procedures, and common SQL injection patterns like multi-statements and inline comments. It enforces read-only operations for user-executed queries. Database credentials are loaded from environment variables, preventing hardcoding. All tool calls are audit logged with sanitized parameters. `sanitize_identifier` is used to prevent injection in table/column names.
Updated: 2026-01-19GitHub→
0
0
Medium Cost
ptitmonnstree icon

sonarlint-mcp-server

by ptitmonnstree

Sec8

Provides SonarLint-powered code quality analysis, bug detection, and quick fixes as an MCP server for AI clients like Claude Desktop.

Setup Requirements

  • ⚠️Requires Node.js v22.7.5 or higher to run the server.
  • ⚠️Initial setup (via 'npm install' or first 'npx' run) downloads the SonarLint Java backend and plugins (approx. 70MB) via a postinstall script, which can take time and requires internet access.
  • ⚠️Relies on a Java Runtime Environment (JRE 17) for its SLOOP backend, although a JRE is bundled and automatically set up; environmental conflicts or issues with the bundled JRE could cause friction.
Verified SafeView Analysis
The server primarily uses standard I/O for communication via the Model Context Protocol (MCP), minimizing direct network attack surface. It utilizes 'child_process.spawn' to interact with a local Java-based SLOOP backend, which is generally safer than arbitrary command execution. File system operations are inherent to its code analysis function and are performed on user-specified paths. No 'eval' or directly malicious code patterns were found. Hardcoded credentials for testing purposes are isolated to test fixtures, not operational code. The Node.js path for language analyzers is set to 'process.execPath', preventing arbitrary executable injection.
Updated: 2026-01-19GitHub→
0
0
High Cost
Amier-ge icon

NTFS_Parser_MCP

by Amier-ge

Sec8

Provides an MCP server for forensic analysis of NTFS file systems by parsing artifacts like MFT, UsnJrnl, and LogFile from disk images or raw files.

Setup Requirements

  • ⚠️Requires the 'NTFS_Parser' library folder to be located in the parent directory of 'NTFS_Parser_MCP'.
  • ⚠️E01 image support requires installing 'libewf-python' (e.g., `pip install libewf-python`).
  • ⚠️Requires Python 3.10 or newer.
Verified SafeView Analysis
The server's direct implementation appears robust. It primarily handles file inputs/outputs locally and does not expose direct 'eval' or other arbitrary code execution vectors. The main security considerations are the robustness of the underlying `NTFS_Parser` library (which it imports) and its dependencies against potentially malicious or malformed forensic input files, which is an inherent challenge in forensic tooling.
Updated: 2025-12-05GitHub→
0
0
Medium Cost
belayoub icon
Sec7

Enables AI agents to interact with terminal-based applications (TUI/CLI) by providing a structured Terminal State Tree representation.

Setup Requirements

  • ⚠️Requires Rust 1.75+ toolchain to build and run.
  • ⚠️Full PTY support is available on Linux, macOS, and WSL2, with partial support on native Windows.
  • ⚠️The main server functionality (MCP integration) is currently a placeholder ('TODO: Initialize MCP server when rmcp is available') in the main.rs, meaning it will not yet function as a full MCP server.
  • ⚠️Requires a `terminal-mcp.config.yaml` for critical security settings (e.g., command whitelisting) and operational parameters.
Verified SafeView Analysis
The server's core functionality involves spawning arbitrary commands and managing pseudo-terminals (PTY). This is inherently high-risk, as it could allow for command injection or PTY escape if not properly secured. The project explicitly addresses these risks in its documentation, planning for 'Command whitelist + sandbox options' and 'Redact passwords in snapshots'. Configuration of 'allowed_commands' and 'sandbox_mode' is crucial for safe operation. Without a strict whitelist, or with a misconfigured one, running this server could pose significant security vulnerabilities.
Updated: 2025-11-30GitHub→
0
0
High Cost
3D-Tech-Solutions icon

code-scalpel

by 3D-Tech-Solutions

Sec8

Code Scalpel provides a robust, multi-language code analysis and transformation platform for AI agents, integrating deep static analysis, security scanning, refactoring, and project-wide insights to enable AI to understand and modify code effectively.

Setup Requirements

  • ⚠️Extensive Tool Dependencies: Requires Node.js/npm for JavaScript/TypeScript tools (ESLint, Prettier, TypeScript compiler, Babel, etc.), Java/Gradle/Maven for Java/Kotlin tools (Detekt, ktlint, SonarQube, etc.), Ruby/Bundler for Ruby tools (RuboCop, Reek, Brakeman), C++ toolchains (Clang Static Analyzer, Cppcheck), and various Python tools (MyPy, Pylint, Bandit, etc.). Many of these are external CLI tools that need to be installed and accessible.
  • ⚠️Resource Requirements: Can be highly CPU and memory intensive due to deep static analysis, PDG generation, symbolic execution (with Z3), and cross-file dependency resolution, especially for large projects. Deployment without sufficient resources or outside a robust sandbox can lead to performance bottlenecks or instability.
  • ⚠️Licensing Tiers: Many advanced features (e.g., cross-file analysis, extended context, detailed compliance reports, advanced security features) are gated behind 'Pro' and 'Enterprise' tiers, requiring a valid JWT license key and potentially a connection to a remote verification server for full functionality. Defaults to 'Community' tier if no license is provided.
  • ⚠️Configuration Complexity: Involves multiple configuration files for governance (`.code-scalpel/policy.yaml`), tier-specific limits (`.code-scalpel/limits.toml`), and various language-specific linters/analyzers (`.eslintrc`, `tsconfig.json`, `detekt.yml`, etc.), which adds complexity to setup and maintenance.
Verified SafeView Analysis
The server implements extensive internal security controls, including a robust policy engine (OPA-based with Rego rules), cryptographic verification of policies, tamper resistance for critical configurations, strict input validation, and secure path resolution. It proactively analyzes security vulnerabilities *in* the code it processes rather than exposing direct code execution risks. However, processing arbitrary code strings and file paths, even for analysis, carries inherent risks such as potential resource exhaustion (DoS) or exploitation of parser vulnerabilities if not adequately sandboxed and monitored externally.
Updated: 2026-01-19GitHub→
0
0
High Cost
HolyCrusader2004 icon

SysAdminAIAgent

by HolyCrusader2004

Sec3

An AI agent interacts with the operating system securely through a Microservice Communication Protocol (MCP) server, offering controlled filesystem operations.

Setup Requirements

  • ⚠️Requires Docker and Docker Compose for full setup.
  • ⚠️Requires a local Ollama instance with a large language model (e.g., `gpt-oss:20b`) to be running.
  • ⚠️Specific host path (e.g., `D:/ASO/aso-project/playground`) needs to be configured as a Docker volume for `/mnt/playground`.
Review RequiredView Analysis
CRITICAL: Hardcoded secrets for 'OAUTH_CLIENT_SECRET' and 'KEYCLOAK_ADMIN_PASSWORD' are present in `docker-compose.yml` and `mcp-server/config.py`. CRITICAL: SSL/TLS certificate verification is explicitly disabled (`verify=False`) in `mcp-server/token_verifier.py` for HTTP client, posing a severe risk of Man-in-the-Middle attacks. The agent is confined to a `/mnt/playground` directory but has `delete_file` and `delete_folder` capabilities within it, which could lead to data loss if misused or compromised.
Updated: 2025-12-06GitHub→
PreviousPage 388 of 760Next