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
rncz icon
Sec9

Allows a Large Language Model (LLM) to fetch accurate current time, offset, delay, and stratum from NTP servers for various timezones.

Setup Requirements

  • ⚠️Requires 'uv' for dependency management and running the server, which might be unfamiliar to users accustomed to 'pip'.
  • ⚠️Requires Python 3.10 or higher.
  • ⚠️Requires an LLM software with tool calling capabilities configured to integrate the MCP server.
Verified SafeView Analysis
The server connects to public NTP servers (pool.ntp.org) which is a standard and generally safe operation for time synchronization. No 'eval', 'exec', or other dynamic code execution methods are used. No hardcoded sensitive credentials were found. Input validation for 'server_index' ensures it stays within bounds of the predefined NTP server list. Timezone input is handled by 'pytz.timezone' with error trapping for invalid inputs. Overall, the code appears robust and secure for its intended purpose.
Updated: 2025-12-13GitHub→
0
0
Medium Cost
jasonzhangshuo icon

memory-mcp-server

by jasonzhangshuo

Sec8

A personal memory management system that allows an AI agent to store, search, update, and summarize personal memories, goals, and decisions, with robust integration and synchronization capabilities with the Feishu (Lark) platform for data visualization and backup.

Setup Requirements

  • ⚠️Requires extensive Feishu API configuration, including setting up an application, obtaining an App ID, App Secret, App Token (for Base/Bitable), Table ID, and specific Feishu app permissions (e.g., `bitable:app`, `drive:drive`, `im:message`, `wiki:wiki.readonly`).
  • ⚠️Python dependencies, including the potentially heavy `sklearn` for similarity calculations, must be installed (`pip install -r requirements.txt`).
  • ⚠️For user-specific Feishu access (e.g., listing personal cloud documents), an OAuth 2.0 flow is required, involving manual browser interaction to get an authorization `code` and then exchanging it for `user_access_token` and `refresh_token`.
  • ⚠️Specific operating system-level configurations are necessary, such as configuring the MCP Server within an IDE like Cursor (editing `cline_mcp_settings.json`) or setting up a macOS LaunchAgent/crontab for automatic Feishu synchronization.
Verified SafeView Analysis
The server uses parameterized queries (`aiosqlite`) to prevent SQL injection. Sensitive credentials are read from environment variables, avoiding hardcoding. Pydantic models are used for input validation, mitigating common injection risks. The Feishu event webhook has basic token validation, and explicitly notes that encryption is not implemented, meaning it won't attempt to process encrypted payloads without the `ENCRYPT_KEY` being set, which is a safe default. File system operations are primarily on internally managed paths (`entries/`). External API calls are handled by `httpx`, a standard and secure library. No obvious `eval` or `exec` vulnerabilities in user-controlled paths were found. The primary risk would stem from misconfiguration of Feishu API permissions or the webhook exposing itself publicly without robust access controls.
Updated: 2026-01-19GitHub→
0
0
Low Cost
ThoreKoritzius icon

graphql-mcp-server

by ThoreKoritzius

Sec7

A Python MCP server for LLMs that indexes a GraphQL schema, stores embeddings for type-field signatures, and enables fast semantic lookup and query execution against a GraphQL endpoint.

Setup Requirements

  • ⚠️Requires an OpenAI API Key (or compatible embedding service) for generating embeddings, which typically involves paid usage.
  • ⚠️Requires either a local GraphQL Schema Definition Language (SDL) file (default: src/schema.graphql) or access to a live GraphQL endpoint with introspection enabled.
  • ⚠️Requires a Python 3 environment and package installation via pip.
Verified SafeView Analysis
The server makes network requests to user-configured embedding endpoints (via `GRAPHQL_EMBEDDINGS_URL`) and GraphQL API endpoints (via `GRAPHQL_ENDPOINT_URL`). While essential for its function, configuring with untrusted URLs could expose internal networks to Server-Side Request Forgery (SSRF) vulnerabilities if the server is publicly exposed. No 'eval' or obvious malicious code patterns were found. API keys and sensitive configuration are loaded from environment variables, promoting secure practice. `json.loads` is used for parsing environment variables like `GRAPHQL_EMBED_HEADERS` and `GRAPHQL_ENDPOINT_HEADERS`, which are configuration and not arbitrary runtime user input.
Updated: 2026-01-19GitHub→
0
0
Low Cost

mcp-generic-prompts

by arvato-systems-romania

Sec8

This repository provides a collection of generic prompts and associated development tools for managing, testing, and integrating them into applications, likely for AI or LLM systems.

Setup Requirements

  • ⚠️Node.js and npm are required to set up and run the project.
  • ⚠️Full functionality, especially for testing prompts against LLMs (if included in examples/tests), may require an external LLM API key (e.g., OpenAI, Anthropic).
  • ⚠️The utility of the stored prompts relies on integration with a separate, external LLM system, not provided by this repository itself.
Verified SafeView Analysis
No code inspection was possible due to a missing README. This is a standard JavaScript/TypeScript project with potential dependency risks. The presence of `vite.config.ts` indicates a local development server, which typically has minimal external network exposure. No obvious signs of 'eval' or obfuscation from file names.
Updated: 2025-11-18GitHub→
0
0
Low Cost
Cloudscockpit icon

actionboard-mcp

by Cloudscockpit

Sec5

Provides a custom server for integration with Actionboard.ai services.

Review RequiredView Analysis
Insufficient source code provided for a comprehensive security audit. No 'eval', obfuscation, hardcoded secrets, or malicious patterns could be identified as only the README was available. A full code review is required.
Updated: 2025-11-27GitHub→
0
0
Low Cost
HananiahKao icon

bible-MCP-server

by HananiahKao

Sec9

Provides access to Bible verses and footnotes from a SQLite database via Model Context Protocol.

Setup Requirements

  • ⚠️Requires the 'Bible20240820.sqlite' database file, which is not included in the repository and must be acquired separately.
  • ⚠️The path to the SQLite database is hardcoded as '/Users/hananiah/Developer/bible-MCP-server/Bible20240820.sqlite' in 'src/index.ts' and will require manual modification or recreating the exact directory structure for the server to function correctly outside of the original developer's environment.
  • ⚠️The 'sqlite3' dependency is a native Node.js module and may require appropriate build tools (e.g., Python, C/C++ compiler) on the host system during 'npm install' if pre-built binaries are not available for your specific platform.
Verified SafeView Analysis
The server uses parameterized SQL queries to prevent injection and opens the SQLite database in read-only mode, significantly enhancing security. No 'eval' or external network calls detected. The main deployment friction is a hardcoded database path, not a direct security vulnerability.
Updated: 2025-11-29GitHub→
0
0
Medium Cost
2900xt icon
Sec9

Provides an MCP-compatible interface for Claude Code clients to search for similar research papers using the Reef AI embedding-based search API.

Setup Requirements

  • ⚠️Requires a Reef AI user ID (API key) and an active Reef AI account, as each search costs 1 credit.
  • ⚠️Requires Node.js (version 18 or higher, as indicated by package-lock.json and tsconfig.json target ES2022).
  • ⚠️Must be configured as an MCP tool with an MCP-compatible client like Claude Code to be usable.
Verified SafeView Analysis
The server acts as a proxy, wrapping the Reef AI external API. It uses environment variables for sensitive data (REEF_USER_ID, REEF_API_URL), which is a good security practice. There is no direct use of 'eval' or child_process, nor any obfuscation. API calls are made via standard fetch to a configurable URL. Error handling provides descriptive messages without exposing raw stack traces. Input parameters are defined with Zod, providing basic type validation before being passed to the external API. The main security considerations would be the security of the upstream Reef AI API itself, which is outside the scope of this server's code.
Updated: 2026-01-18GitHub→
0
0
High Cost
TillMatthis icon

KOmcp

by TillMatthis

Sec9

Provides a secure, OAuth2-authenticated Model Context Protocol (MCP) server that enables LLM applications like Claude to manage (create, search, retrieve, delete) Kura notes via API calls.

Setup Requirements

  • ⚠️Requires a separate KOauth OAuth2 server instance to be running and properly configured for token issuance and dynamic client registration.
  • ⚠️Requires a separate Kura notes application instance (with API enabled) to be running and accessible.
  • ⚠️The project's environment validation (`src/config/env.ts`) requires `KURA_DATABASE_URL` (a PostgreSQL connection string), but the internal `KuraClient` for API interaction actually uses `KURA_URL` (a HTTP API base URL). Both must be provided, with `KURA_URL` pointing to the Kura HTTP API.
  • ⚠️The `src/services/embeddings.ts` file is a placeholder that would need to be correctly implemented (e.g., with an OpenAI API key) if KOmcp were to generate embeddings locally. However, the current `KuraClient` implementation directly calls Kura's API for semantic search, implying Kura itself handles embedding generation.
Verified SafeView Analysis
The server demonstrates robust security practices: Fastify with Helmet, CORS (configurable origins), and Rate Limiting. OAuth2 token validation is thorough, using JWKS for signature verification and checking issuer, audience, and expiration. Role-based access control is enforced via `requireScopes` middleware. Logging (Pino) is structured and redacts sensitive data like Authorization headers. Docker deployment uses a non-root user. Critically, KOmcp interacts with Kura via its HTTP API (`KuraClient` uses `fetch`), shifting direct database access and potential SQL injection risks to the Kura application itself. A minor inconsistency is that `src/config/env.ts` validates for `KURA_DATABASE_URL` while `src/services/kura-client.ts` uses `KURA_URL` to connect to Kura's API, which might lead to unnecessary environment variable requirements, but does not pose a direct security vulnerability.
Updated: 2025-12-05GitHub→
0
0
Low Cost
ramu537 icon

todo-mcp-server

by ramu537

Sec8

This server provides a RESTful API for managing a TODO list, exposing standard CRUD operations and specific status filters, and also registers these functionalities as tools for potential integration with a Spring AI client.

Setup Requirements

  • ⚠️Requires Java Development Kit (JDK 17+ likely, for Spring Boot 3+)
  • ⚠️Requires Maven or Gradle to build and run the application
  • ⚠️Requires a relational database (defaults to in-memory H2 if not explicitly configured, but a persistent database is needed for production use)
Verified SafeView Analysis
No 'eval', obfuscation, or hardcoded secrets were found in the provided source code. Input validation is present via `@Valid` annotations and handled by a global exception handler. The `@CrossOrigin(origins = "*")` annotation on the `TodoController` allows all domains to make requests, which could be overly permissive for production environments and should be restricted to specific trusted origins. No explicit authentication/authorization mechanisms are implemented, making the API openly accessible to anyone who can reach the server.
Updated: 2025-12-14GitHub→
0
0
Medium Cost
esx2ve icon
Sec9

SimpleMem-Lite provides a cloud backend API for AI agents (specifically Claude Code) to store and retrieve long-term memory, perform vector search, and execute graph-based reasoning across development sessions.

Setup Requirements

  • ⚠️Requires API keys for LLM services (e.g., LiteLLM, VoyageAI), which are paid services.
  • ⚠️Docker is required for running FalkorDB if chosen as the graph backend. KuzuDB is the default embedded option.
  • ⚠️Assumes Claude Code is installed and configured for full integration (trace processing, local hooks).
  • ⚠️Heavy reliance on `uv` for dependency management.
Verified SafeView Analysis
The system implements a strong security posture with explicit DEV/PROD modes, API key authentication, and strict validation of Cypher queries in PROD mode (only whitelisted templates allowed). Destructive admin endpoints (`/wipe`) are restricted to DEV mode only and require explicit confirmation. Input decompression includes size limits to prevent 'zip bomb' attacks. While some internal database interactions involve dynamic string formatting for KuzuDB, this is carefully controlled and not equivalent to arbitrary code execution or direct SQL/Cypher injection from user input. Network exposure is typically localhost for local development, with explicit API key authentication for cloud deployments.
Updated: 2026-01-19GitHub→
0
0
Low Cost
JamesChampion icon

mcp-server-rust

by JamesChampion

Sec9

Provides a Rust library for building servers that expose custom tools to AI assistants like Claude using the Model Context Protocol (MCP) and JSON-RPC 2.0 over stdio.

Setup Requirements

  • ⚠️Requires Rust toolchain (stable or nightly) for compilation and execution.
  • ⚠️Its primary utility is realized when integrated with an MCP client (e.g., Claude Desktop, VS Code extension) which provides the AI assistant context.
Verified SafeView Analysis
The server framework itself is robust, utilizing stdio transport and `serde_json` for protocol handling, which mitigates network-based and parsing-based risks. No 'eval'-like functions, obfuscation, or hardcoded secrets were found in the provided source. The primary security consideration for users of this library lies in the implementation of custom `Tool`s, specifically how they validate and process `serde_json::Value` arguments in their `call` method. Improper validation could lead to vulnerabilities like command injection if tools execute external commands based on untrusted input.
Updated: 2025-12-15GitHub→
0
0
High Cost
ArvidSU icon

agent-forum

by ArvidSU

Sec5

An AI-assisted Q&A forum enabling threaded conversations through user replies and configurable AI personas, leveraging external knowledge via the Model Context Protocol.

Setup Requirements

  • ⚠️Requires Node.js 18+.
  • ⚠️Requires AI provider API keys (e.g., OpenAI, Anthropic) which may incur cost.
  • ⚠️Ollama providers require a locally running Ollama server for local model inference.
Verified SafeView Analysis
API keys for AI providers (OpenAI, Anthropic) and for the internal MCP server are stored unencrypted in `backend/data/store.json`. This is a significant risk if the data file is compromised. The forum's MCP server can be configured for `public` access, which exposes forum content without authentication, though it warns against this. Request logging sanitizes sensitive data (e.g., API keys) before logging. Rate limiting is implemented for MCP server access to prevent abuse.
Updated: 2025-11-29GitHub→
PreviousPage 714 of 760Next