Skip to main content
Glama

DEPRECATION NOTICE:

mcp-semclone has been deprecated in favor of Earnie, the platform we launched with SCANOSS. Go to https://earnie.dev to continue.

This repository is archived and receives no further updates.

mcp-semclone - Model Context Protocol Server for SEMCL.ONE

Apache-2.0 Python 3.10+ MCP 1.0+

MCP (Model Context Protocol) server that provides LLMs with comprehensive OSS compliance and vulnerability analysis capabilities through the SEMCL.ONE toolchain.

Overview

mcp-semclone integrates the complete SEMCL.ONE toolchain to provide LLMs with powerful software composition analysis capabilities:

  • License Detection & Compliance: Scan codebases for licenses and validate against policies

  • Binary Analysis: Analyze compiled binaries (APK, EXE, DLL, SO, JAR) for OSS components and licenses

  • Vulnerability Assessment: Query multiple vulnerability databases for security issues

  • Package Discovery: Identify packages from source code and generate PURLs

  • SBOM Generation: Create Software Bill of Materials in CycloneDX format

  • Policy Validation: Check license compatibility and organizational compliance

Related MCP server: code-audit-mcp

Features

Tools

Analysis & Scanning:

  • scan_directory - Comprehensive directory scanning for packages, licenses, and vulnerabilities

  • scan_binary - Analyze compiled binaries (APK, EXE, DLL, SO, JAR) for OSS components

  • check_package - Check specific packages for licenses and vulnerabilities

  • download_and_scan_package - Download package source from registries and perform deep license/copyright scanning

Legal Notices & Documentation:

  • generate_legal_notices - Generate legal notices by scanning source code directly (fast, recommended)

  • generate_legal_notices_from_purls - Generate legal notices from PURL list (downloads from registries)

  • generate_sbom - Generate Software Bill of Materials in CycloneDX format

License & Policy Validation:

  • validate_policy - Validate licenses against organizational policies

  • validate_license_list - Quick license safety validation for distribution types

  • get_license_obligations - Get detailed compliance requirements for licenses

  • check_license_compatibility - Check if two licenses can be mixed

  • get_license_details - Get comprehensive license information including full text

  • analyze_commercial_risk - Assess commercial distribution risks

Complete Workflows:

  • run_compliance_check - Universal one-shot compliance workflow for any project type

Resources

  • license_database - Access license compatibility information

  • policy_templates - Get pre-configured policy templates

Prompts

  • compliance_check - Guided workflow for license compliance checking

  • vulnerability_assessment - Guided workflow for security assessment

Installation

Single Command Installation

pip install mcp-semclone

This automatically installs all required SEMCL.ONE tools:

  • purl2notices - Comprehensive package detection and license extraction

  • osslili - License detection from archives (used by check_package)

  • binarysniffer - Binary analysis for OSS components

  • ospac - Policy validation engine

  • vulnq - Vulnerability database queries

  • upmex - Package metadata extraction (used by check_package)

pipx installs the package in an isolated environment while making the CLI tools globally available. This is ideal for avoiding dependency conflicts with other Python packages on your system.

# Install pipx if you don't have it
pip install pipx
pipx ensurepath

# Install mcp-semclone
pipx install mcp-semclone

# IMPORTANT: Inject all SEMCL.ONE tool dependencies into the same isolated environment
# This ensures all tools are available both as libraries and CLI commands
# Required by some agents that need direct CLI tool access
# Use --include-apps to make CLI commands globally available
pipx inject mcp-semclone purl2notices purl2src osslili binarysniffer ospac vulnq upmex --include-apps

Benefits of pipx:

  • ✅ Isolated environment prevents dependency conflicts

  • ✅ All tools globally accessible in PATH

  • ✅ Easy to update: pipx upgrade mcp-semclone

  • ✅ Clean uninstall: pipx uninstall mcp-semclone

For detailed setup instructions including:

  • IDE-specific configurations (Cursor, Cline, Kiro, VS Code, JetBrains)

  • Auto-approve settings

  • pip vs pipx configurations

  • Configuration templates

  • Troubleshooting

See the IDE Integration Guide

Environment Variables

Optional environment variables for enhanced functionality:

# API Keys (optional, for higher rate limits)
export GITHUB_TOKEN="your_github_token"
export NVD_API_KEY="your_nvd_api_key"

# Tool paths (optional, only if tools are not in PATH)
# Tools are auto-detected by default using shutil.which()
export PURL2NOTICES_PATH="/custom/path/to/purl2notices"
export OSSLILI_PATH="/custom/path/to/osslili"
export BINARYSNIFFER_PATH="/custom/path/to/binarysniffer"
export VULNQ_PATH="/custom/path/to/vulnq"
export OSPAC_PATH="/custom/path/to/ospac"
export UPMEX_PATH="/custom/path/to/upmex"

Note: Tools are automatically detected in your PATH. Environment variables are only needed for custom installation locations.

Usage Examples

With MCP Clients

Once configured, you can ask your LLM:

  • "Scan /path/to/project for license compliance issues"

  • "Analyze this Android APK file for OSS components and licenses"

  • "Check if this project has any critical vulnerabilities"

  • "Generate an SBOM for my project"

  • "What licenses are in this compiled binary?"

  • "Validate these licenses against our commercial distribution policy"

  • "Find all GPL-licensed dependencies in this codebase"

Workflows

License Compliance Check

  1. Scan the project to identify all packages and licenses

  2. Load or create a policy defining allowed/denied licenses

  3. Validate licenses against the policy

  4. Generate compliance report with violations and recommendations

Vulnerability Assessment

  1. Discover packages in the codebase

  2. Query vulnerability databases for each package

  3. Prioritize by severity (CRITICAL > HIGH > MEDIUM > LOW)

  4. Identify available fixes and upgrade paths

  5. Generate security report with remediation steps

SBOM Generation

  1. Scan project structure to identify components

  2. Extract metadata for each component

  3. Detect licenses and copyright information

  4. Format as SBOM (CycloneDX 1.4 JSON)

  5. Validate completeness of the SBOM

Examples

Basic MCP Client Usage

See examples/basic_usage.py for simple examples of calling MCP tools directly.

Strands Agent with Ollama

A complete autonomous agent example demonstrating OSS compliance analysis using local LLM (Ollama) with MCP integration.

Location: examples/strands-agent-ollama/

Features:

  • Autonomous decision-making (plan → execute → interpret → report)

  • Local LLM inference via Ollama (llama3, gemma3, deepseek-r1)

  • Interactive and batch analysis modes

  • Custom policy enforcement

  • Complete privacy (no external API calls)

Quick Start:

cd examples/strands-agent-ollama
./quickstart.sh
python agent.py interactive

Documentation:

Use Cases:

  • Mobile app compliance (APK/IPA analysis)

  • Embedded/IoT firmware scanning

  • CI/CD integration

  • Interactive compliance queries

See the example directory for full details.

Contributing

We welcome contributions! Please see CONTRIBUTING.md for details.

License

mcp-semclone is released under the Apache License 2.0. See LICENSE for details.

Support


Part of the SEMCL.ONE Software Composition Analysis toolchain

Available Tools

14 tools
analyze_commercial_riskC

Analyze commercial licensing risk for a project.

Inputs: path (required), include_data_files. Returns: result

check_license_compatibilityA

Check if two licenses are compatible for use together.

This tool answers: "Can I combine code under these two licenses?"

Args: license1: First SPDX license ID (e.g., "MIT") license2: Second SPDX license ID (e.g., "GPL-3.0") context: Usage context (general, static_linking, dynamic_linking)

Returns: Compatibility assessment including: - compatible: True/False indicating if licenses can be combined - reason: Explanation of why they are/aren't compatible - restrictions: Any special conditions or restrictions - recommendations: Suggested actions if incompatible

Example: Checking MIT vs GPL-3.0 returns: - compatible: False - reason: GPL-3.0 is strongly copyleft and requires derivative works to be GPL-3.0 - recommendations: Use dynamic linking, keep code separate, or relicense

Inputs: license1 (required), license2 (required), context. Returns: result

check_packageA

Check a specific package using intelligent tool selection.

This tool intelligently analyzes package files by:

  1. For archives (.jar, .whl, .rpm, .gem, etc.): Use upmex for metadata extraction

  2. If upmex fails or for non-archives: Fall back to osslili for license detection

  3. For PURLs: Use package registry APIs when available

Args: identifier: Package identifier (PURL like pkg:maven/com.google.gson/gson@2.10.1, file path to archive, or package file) check_vulnerabilities: Whether to check for vulnerabilities (default: False for speed) check_licenses: Whether to extract license information (default: True)

Returns: Dictionary containing package metadata, licenses, and optionally vulnerabilities

Inputs: identifier (required), check_licenses, check_vulnerabilities. Returns: result

download_and_scan_packageA

Download package source from registry and perform comprehensive analysis.

⚠️ IMPORTANT: This tool CAN and WILL download source code from package registries!

Workflow (tries methods in order until sufficient data is collected):

  1. Primary: Use purl2notices to download and analyze (fastest, most comprehensive)

  2. Deep scan: If incomplete, use purl2src to get download URL → download artifact → run osslili for deep license scanning + upmex for metadata

    • Maven-specific: If license still missing for Maven packages, uses upmex with --registry --api clearlydefined to resolve parent POM licenses

  3. Online fallback: If still incomplete, use upmex --api clearlydefined/purldb for online metadata

What this tool does:

  • Downloads the actual package source code from npm/PyPI/Maven/etc registries

  • Performs comprehensive license and copyright analysis

  • Extracts package metadata (name, version, homepage, description)

  • Scans ALL source files for embedded licenses (not just package.json/setup.py/pom.xml)

  • Returns copyright statements found in actual source code

  • Maven packages: Automatically resolves parent POM licenses when not declared in package POM

When to use this tool:

  • Package metadata is incomplete or missing (e.g., "UNKNOWN" license in PyPI)

  • Need to verify what's ACTUALLY in the package files (not just metadata)

  • Want to analyze source code directly (not just manifests)

  • Security auditing - see actual package contents before approval

  • License compliance - find licenses embedded in source files

  • Need to extract copyright statements from source code

Real-world example: User asks: "Can you check if duckdb@0.2.3 has license info in the source code?"

  • PyPI metadata shows "UNKNOWN" license

  • This tool downloads the actual .whl/.tar.gz from PyPI

  • Scans ALL files in the package for license information

  • Finds licenses embedded in source code that aren't in metadata

  • Returns: {"method_used": "purl2notices", "declared_license": "UNKNOWN", "detected_licenses": ["CC0-1.0"], ...}

Performance:

  • Primary (purl2notices): 5-15 seconds (fastest)

  • Deep scan (download + osslili + upmex): 10-30 seconds

  • Online fallback (upmex --api): 2-5 seconds (but less complete)

Security note:

  • Downloads are verified against package checksums when available

  • Files are scanned but NOT executed

  • Temporary files are cleaned up unless keep_download=True

Args: purl: Package URL (e.g., "pkg:pypi/duckdb@0.2.3", "pkg:npm/express@4.21.2") keep_download: If True, keeps downloaded files for manual inspection (default: False)

Returns: Dictionary containing: - purl: The package URL analyzed - method_used: Which method succeeded ("purl2notices", "deep_scan", "online_fallback") - download_path: Where package was downloaded (if keep_download=True) - metadata: Package metadata (name, version, homepage, etc.) - declared_license: License from package metadata - detected_licenses: List of licenses found by scanning source files - copyright_statements: Copyright statements extracted from source - files_scanned: Number of files analyzed - scan_summary: Summary of what was found

Examples: # Check if package has license info in source code download_and_scan_package(purl="pkg:pypi/duckdb@0.2.3")

# Download and keep files for manual inspection
result = download_and_scan_package(
    purl="pkg:npm/suspicious-package@1.0.0",
    keep_download=True
)
print(f"Inspect files at: {result['download_path']}")

Inputs: purl (required), keep_download. Returns: result

generate_sbomA

Generate a Software Bill of Materials (SBOM) in CycloneDX format using purl2notices.

This tool creates comprehensive SBOMs in CycloneDX 1.4 JSON format for software inventory, vulnerability tracking, and compliance documentation.

SBOM includes: name, version, PURL, licenses, homepage (external references). Data is sourced from purl2notices scan mode which provides accurate package metadata.

Use this tool when:

  • You need to generate an SBOM for a project or package list

  • Creating inventory documentation for compliance

  • After analyzing packages and need structured output

  • Preparing documentation for security audits

  • Required by procurement or regulatory requirements

Input modes:

  • Provide purls (list of Package URLs) for packages you've already identified

  • Provide path to scan a directory and generate SBOM from discovered packages

  • At least one of purls or path must be provided

Args: purls: Optional list of Package URLs (PURLs) to include in SBOM path: Optional directory path to scan for packages output_file: Optional path to save the SBOM file (CycloneDX JSON format) include_licenses: If True, include license information (default: True)

Returns: Dictionary containing: - sbom: The generated SBOM structure (CycloneDX 1.4 JSON) - packages_count: Number of packages included - output_file: Path to saved file (if output_file was specified)

Examples: # Generate SBOM from PURLs (after batch analysis) generate_sbom( purls=["pkg:npm/express@4.0.0", "pkg:pypi/django@4.2.0"], output_file="/tmp/sbom.json" )

# Generate SBOM by scanning directory
generate_sbom(path="/path/to/project")

# After batch scan workflow
scan_result = check_package("package.jar")
generate_sbom(purls=[scan_result["purl"]], include_licenses=True)

Inputs: path, purls, output_file, include_licenses. Returns: result

get_license_detailsA

Get comprehensive details about a specific license.

This tool provides complete license information including the full license text for generating NOTICE files and understanding license requirements.

Args: license_id: SPDX license ID (e.g., "Apache-2.0", "MIT", "GPL-3.0") include_full_text: Include full license text (can be long, ~5-20KB)

Returns: License information including: - name: Full license name - type: License category (permissive, copyleft_weak, copyleft_strong, etc.) - properties: Characteristics (OSI approved, FSF free, etc.) - permissions: What you CAN do (commercial use, modify, distribute, etc.) - requirements: What you MUST do (include license, preserve copyright, etc.) - limitations: What is NOT provided (liability, warranty, etc.) - obligations: Specific compliance requirements - full_text: Complete license text (if include_full_text=True, fetched from SPDX API)

Example: For Apache-2.0, returns complete license data including: - Full license text for NOTICE files - Patent grant information - Attribution requirements

Inputs: license_id (required), include_full_text. Returns: result

get_license_obligationsA

Get detailed obligations for specified licenses.

This tool answers the critical question: "What must I do to comply with these licenses?"

Args: licenses: List of SPDX license IDs (e.g., ["MIT", "Apache-2.0", "GPL-3.0"]) output_format: Output format (json, text, checklist, markdown)

Returns: Comprehensive obligations including: - Required actions (attribution, notices, disclosure, etc.) - Permissions (commercial use, modification, distribution, etc.) - Limitations (liability, warranty, trademark use, etc.) - Conditions (source disclosure, license preservation, state changes, etc.) - Key requirements for compliance

Example: For MIT license, returns obligations like: - Include original license text in distributions - Preserve copyright notices - No trademark rights granted

Inputs: licenses (required), output_format. Returns: result

run_compliance_checkA

UNIVERSAL COMPLIANCE WORKFLOW: One-shot compliance check for ANY project type.

This is a convenience tool that runs the complete standard compliance workflow:

  1. Scan for licenses and packages (scan_directory)

  2. Generate legal notices with purl2notices (generate_legal_notices)

  3. Validate against policy using ospac (validate_policy or default policy)

  4. Generate SBOM for documentation (generate_sbom)

  5. Check for vulnerabilities (if enabled)

  6. Return comprehensive summary with APPROVE/REJECT decision

This tool works for ANY distribution type (mobile, desktop, embedded, SaaS, etc.) - no specialized tools needed. Distribution type is used for policy validation context.

WHEN TO USE:

  • You want a complete compliance assessment in one call

  • Starting a new project compliance review

  • Need approve/reject decision with full documentation

  • Don't want to orchestrate multiple tool calls manually

  • Want standardized compliance workflow

WHEN NOT TO USE:

  • You need fine-grained control over each step → call individual tools

  • You only need specific information → use targeted tools (scan_directory, etc.)

  • You want to customize the workflow → use individual tools in your preferred sequence

WORKFLOW EXECUTED:

  1. scan_directory(path, identify_packages=True, check_licenses=True)

  2. generate_legal_notices(purls, output_file=NOTICE.txt)

  3. validate_policy(licenses, policy_file or default_policy)

  4. generate_sbom(purls, output_file=sbom.json)

  5. check vulnerabilities (if check_vulnerabilities=True)

  6. Aggregate results → FINAL DECISION: approved/rejected + risk level

Args: path: Directory or project to analyze distribution_type: Optional - mobile, desktop, saas, embedded, etc. (for policy context) policy_file: Optional - Path to custom ospac policy. Uses default if not specified. check_vulnerabilities: Check for security vulnerabilities (default: True) output_dir: Optional - Directory to save outputs (NOTICE.txt, sbom.json). Uses path if not specified.

Returns: Dictionary containing: - decision: "APPROVED" or "REJECTED" - risk_level: "LOW", "MEDIUM", or "HIGH" - summary: Human-readable summary of findings - licenses: List of detected licenses - packages: List of identified packages (PURLs) - vulnerabilities: List of vulnerabilities (if checked) - policy_violations: List of policy violations (if any) - artifacts_created: List of files generated (NOTICE.txt, sbom.json) - recommendations: Actionable next steps

Example: # Complete compliance check with default settings result = run_compliance_check("/path/to/project")

# Mobile app compliance with custom policy
result = run_compliance_check(
    path="/path/to/mobile/app",
    distribution_type="mobile",
    policy_file="/policies/mobile_policy.json"
)

# Check decision
if result["decision"] == "APPROVED":
    print("✓ Ready to ship!")
else:
    print("✗ Issues found:", result["policy_violations"])

Inputs: path (required), output_dir, policy_file, distribution_type, +1 more. Returns: result

scan_binaryA

Scan binary files for OSS components and licenses using BinarySniffer.

This tool analyzes compiled binaries, executables, libraries, and archives (APK, EXE, DLL, SO, JAR, etc.) to detect open source components, extract license information, and identify security issues.

Use this tool when:

  • Analyzing mobile apps (APK, IPA)

  • Scanning executables (EXE, ELF binaries)

  • Examining shared libraries (DLL, SO, DYLIB)

  • Analyzing Java archives (JAR, WAR, EAR)

  • Scanning firmware or embedded binaries

  • Generating SBOM for binary distributions

Args: path: Path to binary file or directory to analyze analysis_mode: Analysis depth - "fast" (quick scan), "standard" (balanced), or "deep" (thorough analysis, slower) generate_sbom: If True, generate SBOM in CycloneDX format check_licenses: If True, perform detailed license analysis check_compatibility: If True, check license compatibility and show warnings confidence_threshold: Minimum confidence level (0.0-1.0) for component detection output_format: Output format - "json", "table", "csv" (default: json)

Returns: Dictionary containing: - components: List of detected OSS components with licenses - licenses: Summary of all licenses found - compatibility_warnings: License compatibility issues (if check_compatibility=True) - sbom: CycloneDX SBOM (if generate_sbom=True) - metadata: Scan statistics and file information

Examples: # Scan an Android APK scan_binary("app.apk")

# Deep analysis with SBOM generation
scan_binary("firmware.bin", analysis_mode="deep", generate_sbom=True)

# Check license compatibility
scan_binary("library.so", check_compatibility=True)

Inputs: path (required), analysis_mode, generate_sbom, output_format, +3 more. Returns: result

scan_directoryA

FIRST STEP: Scan a directory for compliance issues using purl2notices.

This is typically the FIRST tool you should use when analyzing a project. Use this to discover what's in your project before validation or documentation generation.

PURPOSE:

  • Scan project source code for licenses (using purl2notices)

  • Detect ALL packages including transitive dependencies (scans node_modules/, site-packages/, vendor/)

  • Extract copyright statements from source code

  • Check for vulnerabilities (using vulnq)

  • Validate against policy (using ospac)

WHAT purl2notices DETECTS:

  • Project source licenses (from your own code)

  • Dependency packages (ALL packages in node_modules/, not just package.json)

  • Package licenses (from dependency source code)

  • Copyright holders (extracted from actual source files)

IMPORTANT: This tool scans the ENTIRE dependency tree:

  • For npm projects: All 50+ packages in node_modules/ (not just the 1-2 in package.json)

  • For Python projects: All packages in site-packages/ or virtualenv

  • Includes transitive dependencies automatically

WHEN TO USE:

  • Starting compliance analysis for a new project (FIRST STEP)

  • Need to discover all licenses in source code

  • Want to identify all package dependencies (including transitive)

  • Beginning vulnerability assessment

  • Need comprehensive project analysis with copyright attribution

WHEN NOT TO USE:

  • Already have PURLs and just need legal notices → use generate_legal_notices directly

  • Analyzing compiled binaries → use scan_binary instead

  • Just validating known licenses → use validate_license_list

  • Checking single package → use check_package

WORKFLOW POSITION: FIRST STEP in most compliance workflows. Use this to discover what's in your project before validation/generation.

TYPICAL NEXT STEPS:

  1. For mobile apps: scan_directory(check_vulnerabilities=True) → validate_license_list(distribution="mobile") → generate_legal_notices(purls=scan_result["packages"])

  2. For vulnerability assessment: scan_directory(check_vulnerabilities=True) → analyze_commercial_risk(path=".") → check specific packages with check_package for details

  3. For documentation: scan_directory() → generate_legal_notices(purls=scan_result["packages"]) → generate_sbom(path=".")

IMPORTANT NOTES:

  • identify_packages parameter is deprecated (purl2notices always detects packages)

  • check_vulnerabilities=True: Checks all detected packages for CVEs

  • check_licenses parameter is deprecated (purl2notices always scans licenses)

  • Scans recursively by default (max depth 3 into node_modules/)

Args: path: Directory or file path to scan recursive: Enable recursive scanning (default: True, max depth 3) check_vulnerabilities: Check for vulnerabilities in detected packages check_licenses: (Deprecated - always True) Scan for licenses identify_packages: (Deprecated - always True) Detect packages policy_file: Optional policy file for license compliance validation

Returns: Dictionary containing: - licenses: List of detected licenses from project and dependencies - packages: List of ALL detected packages with PURLs (includes transitive deps) - vulnerabilities: List of vulnerabilities (if check_vulnerabilities=True) - policy_violations: Policy violations (if policy_file provided) - metadata: Summary information including copyright holders and counts

Inputs: path (required), recursive, policy_file, check_licenses, +2 more. Returns: result

validate_license_listA

QUICK answer to: "Can I ship this with these licenses?"

This tool analyzes a list of licenses without requiring a filesystem path, making it ideal for quick validation checks.

WHEN TO USE:

  • You have a list of licenses (from scan results)

  • Need to validate for specific distribution type (mobile, desktop, saas, embedded)

  • Want app store compatibility check (iOS/Android)

  • Fast compliance validation without deep analysis

  • Quick go/no-go decision for shipping

WHEN NOT TO USE:

  • Need to scan codebase first → use scan_directory

  • Need detailed policy evaluation → use validate_policy

  • Need complete legal documentation → use generate_legal_notices after validation

  • Don't have license list yet → use scan_directory first

WORKFLOW POSITION: Use AFTER scan_directory/check_package to validate licenses, BEFORE generate_legal_notices to confirm compliance.

COMMON WORKFLOW: scan_directory(identify_packages=True) → validate_license_list(distribution="mobile") [VALIDATION STEP] → generate_legal_notices(purls=[...]) [IF APPROVED]

RETURNS CLEAR DECISION:

  • safe_for_distribution: true/false

  • app_store_compatible: true/false (if check_app_store_compatibility=True)

  • recommendations: What to do next

  • violations: What's wrong (if any)

Args: licenses: List of SPDX license identifiers (e.g., ["MIT", "Apache-2.0"]) distribution: Target distribution type - "mobile", "desktop", "saas", "embedded", "general" check_app_store_compatibility: Check specific App Store (iOS/Android) compatibility

Returns: Dictionary with: - safe_for_distribution: bool - Overall safety assessment - copyleft_risk: str - "none", "weak", or "strong" - risk_level: str - "LOW", "MEDIUM", or "HIGH" - violations: List of identified issues - recommendations: List of actionable recommendations - app_store_compatible: bool - iOS/Android app store compatibility - license_details: Summary of each license

Inputs: licenses (required), distribution, check_app_store_compatibility. Returns: result

validate_policyA

Validate if licenses are approved or rejected for a specific project/distribution type.

This tool evaluates licenses against organizational policies and returns clear APPROVE or DENY decisions based on the distribution type. This is the primary tool for answering: "Can I use these licenses for my [mobile/commercial/saas/etc] project?"

Key Use Cases:

  • Check if licenses are approved for mobile app distribution

  • Validate licenses for commercial products

  • Ensure SaaS deployment compliance

  • Verify licenses for embedded systems

  • Check licenses for any distribution type

Returns clear approve/deny decisions:

  • action: "approve" (licenses are allowed), "deny" (licenses blocked), or "review" (manual review needed)

  • severity: "info" (approved), "warning" (review), "error" (denied)

  • message: Explanation of the decision

  • requirements: What must be done to comply (if approved)

  • remediation: How to fix the issue (if denied)

Args: licenses: List of SPDX license IDs to validate (e.g., ["MIT", "Apache-2.0", "GPL-3.0"]) policy_file: Optional custom policy directory (uses enterprise defaults if not provided) distribution: Distribution type - determines policy rules: - "mobile": iOS/Android apps (blocks GPL, allows permissive) - "commercial": Commercial products (blocks strong copyleft) - "saas": Software as a Service (blocks AGPL, allows GPL) - "embedded": Embedded systems (blocks copyleft) - "desktop": Desktop applications - "web": Web applications - "open_source": Open source projects (allows most licenses) - "internal": Internal use only (allows all) context: Optional usage context (e.g., "static_linking", "dynamic_linking")

Returns: Dictionary with: - licenses: List of licenses evaluated - distribution: Distribution type used - context: Context evaluated - result.action: "approve", "deny", or "review" - result.severity: "info" (approved), "warning" (review), or "error" (denied) - result.message: Human-readable decision explanation - result.requirements: List of compliance requirements (if approved) - result.remediation: Suggested fix (if denied, e.g., "Replace with MIT alternative") - using_default_policy: Whether default enterprise policy was used

Examples: # Check if licenses are approved for mobile app validate_policy(["MIT", "Apache-2.0"], distribution="mobile") → action: "approve" ✓

# Check GPL for mobile (will be denied)
validate_policy(["GPL-3.0"], distribution="mobile")
→ action: "deny", remediation: "Replace with permissive alternative"

# Check licenses for commercial distribution
validate_policy(["MIT", "LGPL-2.1", "Apache-2.0"], distribution="commercial")
→ action: "approve" or "review" depending on policy

# Check AGPL for SaaS (will be denied)
validate_policy(["AGPL-3.0"], distribution="saas")
→ action: "deny", reason: "Network copyleft requires source disclosure"

Workflow Integration: 1. After scanning: scan_directory() → extract licenses → validate_policy() 2. Quick check: validate_policy(["GPL-3.0"], distribution="mobile") → see if approved 3. Policy enforcement: validate_policy() → if action=="deny" → block deployment

Inputs: licenses (required), context, policy_file, distribution. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 14 tools

    Disambiguation5/5

    Every tool has a clearly distinct purpose. While generate_legal_notices and generate_legal_notices_from_purls are similar, their descriptions explicitly differentiate them by input method and use case, preventing confusion. All other tools target unique aspects of compliance analysis.

    Naming Consistency4/5

    Tool names predominantly follow a verb_noun pattern (e.g., scan_directory, validate_policy), but there is minor inconsistency: some use hyphens (check_license_compatibility) while others use underscores consistently, and verbs vary (analyze, check, generate, scan, validate). Overall, the pattern is predictable and readable.

    Tool Count5/5

    With 14 tools, the server covers a comprehensive compliance workflow—from scanning and package analysis to license validation, legal notice generation, and SBOM creation. Each tool serves a clear role without redundancy, and the count is well-scoped for the domain.

    Completeness5/5

    The tool surface covers the entire lifecycle: scanning (source, binary), package analysis (simple and deep), license checks (details, obligations, compatibility), risk assessment, policy validation, legal notices (source and PURL-based), SBOM generation, and an end-to-end compliance workflow. No significant gaps are apparent.

    Maintenance

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables AI assistants to perform vulnerability scanning on Docker/OCI images, check CVE details, analyze licenses, and compare scan results via ScanRook.
      8
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables automated security code auditing using LLM and MCP, including AST parsing, taint analysis, dataflow tracing, and automated PoC generation for multi-language codebases.
      1
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Enables AI coding agents to audit Python and npm dependency licenses against your distribution context before shipping, returning CLEAN, REVIEW, or BLOCK verdicts with plain-language reasons and supporting notice generation.
      3
      1
      MIT
    • A
      license
      B
      quality
      B
      maintenance
      Enables AI agents to run deterministic, fully local static security and compliance audits of code, configurations, and dependencies through 32 MCP tools covering 24 vulnerability categories. It also detects the project stack, generates risk reports and checklists, suggests stack-aware remediations, and re-validates fixes to confirm vulnerabilities were eliminated.
      32
      1
      MIT