# Skyrxin/sast-mcp-server [Health: Active]

**Category:** 🔒 Security  
**Repository:** https://github.com/Skyrxin/sast-mcp-server  
**GitHub Stars:** 4  
**Views:** 6  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/skyrxin-sast-mcp-server

## Description
SAST/DAST server exposing 11 security scanners (Bandit, Semgrep, Trivy, CodeQL, Checkov, Gitleaks, OSV-Scanner, Grype, OWASP ZAP, and more) with closed-loop remediation (scan→patch→re-scan→verify), SARIF/SBOM/VEX export, compliance reporting, and CI integrations (GitHub Advanced Security, DefectDojo, Slack, Jira).

## Tools
Capabilities this server exposes over MCP:

- **scan_vulnerabilities** — Scan a target directory for security vulnerabilities using a SAST tool.
- **ignore_vulnerability** — Ignore a specific vulnerability finding so it won't appear in future scans.
- **unignore_vulnerability** — Remove a vulnerability from the ignore list so it appears in future scans again.
- **list_scanners** — List all available SAST scanners, their status, and supported languages.

Returns information about each scanner including whether it is installed
and ready to use, what languages it supports, and how to install it.
- **list_ignored_vulnerabilities** — List all currently ignored vulnerability findings for a project.
- **scan_git_history** — Scan the entire git history for leaked secrets and credentials using Gitleaks.

Traditional SAST only scans the current state of files. This tool deeply
analyzes the `.git` directory to find API keys, passwords, and tokens
that were committed in the past but may still be valid.
- **run_active_scan** — Run an active dynamic scan (DAST) using OWASP ZAP.

Unlike SAST which only looks at code, this orchestrates spinning up the
application via Docker Compose, waiting for it to be ready, and then
running a ZAP dynamic baseline scan against the running instance.
- **export_sarif** — Run a SAST scan and export results in SARIF 2.1.0 format for CI/CD integration.

SARIF is the industry standard format consumed by GitHub Code Scanning,
GitLab SAST, Azure DevOps, and other CI/CD platforms.
- **scan_all** — Scan with ALL installed scanners in parallel, returning deduplicated results.

Automatically detects which scanners are installed, runs them concurrently,
and deduplicates findings across scanners using content-based hashing.
This is the recommended tool for comprehensive security scanning.
- **scan_image** — Scan a container image for vulnerabilities and secrets.

Pulls and analyzes a container image reference (e.g. `nginx:1.25`,
`ghcr.io/org/app@sha256:...`) with Trivy or Grype, returning the same
normalized findings as a source scan.
- **save_baseline** — Run a scan and save the results as a named baseline for future comparison.
- **compare_baseline** — Compare current scan results against a saved baseline.

Shows new vulnerabilities, fixed vulnerabilities, and severity trends.
- **evaluate_policy** — Run all scanners and evaluate findings against a CI security policy.

Returns an explicit PASS/FAIL verdict suitable for gating a pipeline. A
threshold of ``-1`` means "no limit" for that severity. When ``fail_on_new``
is set, the result also fails if any finding is new relative to the named
baseline (created with ``save_baseline``).
- **export_sbom** — Run all scanners and export an SBOM / vulnerability report.

Produces the supply-chain artifact enterprises expect. In CycloneDX mode, if
Syft is installed the component inventory is the *full* dependency list
(not just vulnerable packages); otherwise components are derived from
findings. SPDX mode emits an SPDX 2.3 document.
- **generate_report** — Run all scanners and render an executive security report (HTML or PDF).
- **compliance_report** — Map findings to a compliance framework and report the posture.

Buckets all findings against OWASP Top 10, SANS CWE Top 25, PCI DSS, or CIS
using each finding's CWE / OWASP metadata.
- **upload_to_defectdojo** — Upload a SARIF report to a DefectDojo engagement.

Requires the DEFECTDOJO_URL and DEFECTDOJO_API_KEY environment variables.
Generate the SARIF file first with `export_sarif(output_path=...)`.
- **upload_to_github** — Upload a SARIF report to GitHub Code Scanning.

Requires a GITHUB_TOKEN environment variable with `security_events: write`
scope. Generate the SARIF file first with `export_sarif(output_path=...)`.
- **comment_on_pr** — Post a security summary comment on a GitHub PR or GitLab merge request.

Credentials come from environment variables only: GITHUB_TOKEN for GitHub,
or GITLAB_TOKEN (+ optional GITLAB_URL) for GitLab.
- **notify_slack** — Send a notification to the configured Slack incoming webhook.

Requires the SLACK_WEBHOOK_URL environment variable.
- **notify_teams** — Send a notification to the configured Microsoft Teams incoming webhook.

Requires the TEAMS_WEBHOOK_URL environment variable.
- **create_jira_issue** — Open a Jira issue for a security finding.

Requires the JIRA_URL, JIRA_EMAIL, and JIRA_API_TOKEN environment variables.
- **generate_fix_prompt** — Build an LLM-ready prompt to fix a cached finding as a unified diff.

Recovers the finding (by hash) from the scan cache, extracts an expanded
window of the vulnerable source, and returns a prompt engineered to make
an LLM emit a strict unified diff. After generating the patch, apply it
with `apply_patch`.
- **apply_patch** — Apply an agent-generated unified diff to files under target_path.

Uses `git apply`, which refuses paths that escape the target directory.
Run with `check_only=True` first to verify the patch applies cleanly
before writing changes.
- **remediate_and_verify** — Apply a fix and prove it worked: scan → patch → re-scan → confirm gone.

The closed remediation loop. Recovers the finding by hash, dry-runs the
patch, re-scans the affected file before and after applying it, and returns
PASS only if the finding's hash disappears **and** no new finding of equal
or higher severity is introduced. On failure (and when ``auto_rollback``),
the patch is reverted so the working tree is left clean.
- **import_sarif** — Ingest an external SARIF file into the normalized finding pipeline.

Lets results from any SARIF-producing tool (Snyk, Veracode, CodeQL, a CI
job, etc.) join the same dedup / baseline / dashboard flow as native scans.
The findings are re-enriched with AST context and stable hashes on import.
- **triage_finding** — Triage a finding: get an exploitability prompt, or record a VEX decision.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "sast-mcp-server": {
    "command": "uvx",
    "args": ["sast-mcp-server"]
  }
}
```

## Documentation

## What Skyrxin/sast-mcp-server MCP server does

Skyrxin/sast-mcp-server MCP server connects AI agents to a collection of security scanners through the Model Context Protocol. It supports Bandit, njsscan, Bearer, Semgrep, Trivy, CodeQL, Checkov, Gitleaks, OSV-Scanner, Grype, and OWASP ZAP. The available coverage includes application code, dependencies, secrets, infrastructure-as-code, container images, Git history, and dynamic scans of applications running through Docker Compose.

Results are returned in a normalized finding format. The server can filter by severity and confidence, restrict scans to Git-modified files, paginate large result sets, and deduplicate findings when multiple scanners report the same issue. `list_scanners` reports which scanners are installed, their supported languages or scopes, and installation guidance.

## How it works

Install the Python package or run it with `uvx`, then make the scanner executables available in the same environment. The full container image bundles nine scanners; CodeQL is supplied separately because of its size, while OWASP ZAP runs through Docker when an active scan is requested. The server reports the scanners it can find at startup and through its readiness information.

Local deployments use stdio. The project also supports Streamable HTTP for remote deployments, with JWT and API-key authentication described as available server features. Gemini CLI, Claude Desktop, Cursor, Windsurf, and OpenAI Agents usage are documented in the project material.

## Setup and configuration

The minimal installation is `pip install sast-mcp-server`; the `[scanners]` extra adds Bandit, njsscan, Semgrep, and Checkov. The full image is available as `ghcr.io/skyrxin/sast-mcp-server:full`, and Docker Compose can expose an HTTP endpoint on port 8080. Binary tools such as Trivy, Grype, Gitleaks, OSV-Scanner, and Bearer require their own installation paths when they are not supplied by the image.

Optional environment variables configure external destinations rather than basic local scanning. GitHub uploads use `GITHUB_TOKEN`, DefectDojo uses `DEFECTDOJO_URL` and `DEFECTDOJO_API_KEY`, Slack uses `SLACK_WEBHOOK_URL`, Teams uses `TEAMS_WEBHOOK_URL`, and Jira uses `JIRA_URL`, `JIRA_EMAIL`, and `JIRA_API_TOKEN`. GitLab merge-request comments use `GITLAB_TOKEN` and may use `GITLAB_URL`.

## Tools and capabilities

The Skyrxin/sast-mcp-server MCP server provides focused and aggregate scan operations. `scan_vulnerabilities` runs one selected scanner, while `scan_all` runs every installed scanner in parallel and removes duplicate findings. `scan_image` examines container images, and `scan_git_history` uses Gitleaks against committed history. `run_active_scan` starts a Docker Compose application and runs an OWASP ZAP baseline scan.

Results can be exported as SARIF 2.1.0, CycloneDX or SPDX SBOM output, HTML or PDF reports, and compliance views for OWASP Top 10, SANS CWE Top 25, PCI DSS, or CIS. Baselines support comparisons of new and fixed findings, while `evaluate_policy` returns a pipeline-oriented pass or fail result with severity thresholds and optional new-finding checks.

Operational tools include ignore-list management, SARIF import, DefectDojo and GitHub uploads, GitHub or GitLab review comments, Slack and Teams notifications, and Jira issue creation. Remediation uses `generate_fix_prompt`, `apply_patch`, and `remediate_and_verify`; the latter can dry-run and roll back a patch, then confirms that the original finding disappeared without introducing an equal-or-higher severity issue. `triage_finding` supports exploitability prompts and VEX decisions.

## Limitations and notes

Scanner coverage depends on which executables are installed and available to the server. CodeQL is not included in the full image, and OWASP ZAP requires Docker for active scans. Upload and notification tools require the corresponding credentials and destination configuration. Active scanning also requires an application stack that can be started with Docker Compose. Patch application is limited to files under the selected target directory and uses `git apply` validation.

_Full upstream README: https://allmcps.com/mcp/skyrxin-sast-mcp-server/readme_