Frame Mcp

io.github.lambdasecPublished by GitHub account lambdasecv0.2.0Updated Nov 7, 2026

MCP server for the Frame security scanner: scan, verify, fix, exploit, packs and separation logic.

VerifiedSTDIODesktop onlyDeveloper ToolsSecurity & Monitoring

Overview

AI-generated overview

Wraps the Frame security scanner so an assistant can scan code for vulnerabilities, verify and fix findings, and run authorized exploit checks.

What you can do
  • Scan files or directories for data-flow vulnerabilities and return findings as JSON, optionally with an LLM detection and triage layer
  • Record scan results as a baseline file and re-scan earlier findings to report whether each is fixed, removed, present or suppressed
  • Generate verified fixes for findings as a unified diff, or write patches into source files
  • Drive an LLM agent against a live target to attempt exploitation
  • List and validate framework packs that teach Frame a framework's sources, sinks and sanitizers
  • Check whether a separation logic entailment is valid, with an optional countermodel
When to use it
Useful when a coding agent should audit a codebase for injection and traversal style vulnerabilities, track whether reported issues were actually fixed, or propose verified patches. Also fits teams that want an agent-assisted exploit check against their own authorized test targets.
Requirements
Runs locally over stdio, typically launched with uvx from the frame-mcp PyPI package, and needs the frame command line program available. The AI scan layer, fix and exploit tools need an OpenAI-compatible endpoint configured through FRAME_LLM_BASE_URL, FRAME_LLM_MODEL and, when required, FRAME_LLM_API_KEY. Plain scanning needs none of these.
Before you install
The exploit tool sends live traffic to a target and is meant only for systems you own or are explicitly authorized to test; unauthorized testing may be illegal. write_baseline creates or overwrites a baseline file, and fix with in_place writes patches into source files. LLM-backed features send code and findings to the configured endpoint, which may be a third-party API.

Installation

In SourceWeft

  1. Open Frame Mcp in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

frame-mcp

mcp-name: io.github.lambdasec/frame-mcp

An MCP server that exposes the Frame security scanner to any MCP client, so a coding agent can scan code, verify fixes, and reason about vulnerabilities over stdio.

Frame combines taint analysis with separation logic verification to find data-flow vulnerabilities (SQL injection, command injection, path traversal, and more), and checks each reported path with a solver. This package wraps the frame command line program as MCP tools. It launches frame as a subprocess with an explicit argument list, never a shell, and prefers the frame executable installed next to the running Python interpreter.

Install

Run directly with uvx (no separate install step):

bash
uvx frame-mcp

Claude Code

bash
claude mcp add frame -- uvx frame-mcp

Codex

Add this stanza to ~/.codex/config.toml:

toml
[mcp_servers.frame]command = "uvx"args = ["frame-mcp"]

Cursor

Create .cursor/mcp.json:

json
{  "mcpServers": {    "frame": {      "command": "uvx",      "args": ["frame-mcp"]    }  }}

VS Code

Create .vscode/mcp.json:

json
{  "servers": {    "frame": {      "type": "stdio",      "command": "uvx",      "args": ["frame-mcp"]    }  }}

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json under the mcpServers key:

json
{  "mcpServers": {    "frame": {      "command": "uvx",      "args": ["frame-mcp"]    }  }}

Gemini CLI

Add to ~/.gemini/settings.json under the mcpServers key:

json
{  "mcpServers": {    "frame": {      "command": "uvx",      "args": ["frame-mcp"]    }  }}

Zed

Add to Zed settings.json under context_servers:

json
{  "context_servers": {    "frame": {      "command": {        "path": "uvx",        "args": ["frame-mcp"]      }    }  }}

Tools

ToolPurposeRead only
scanScan a file or directory for vulnerabilities and return findings as JSON; ai adds LLM detection and triage, hunt_authz the agentic authorization hunt.yes
write_baselineScan a path and record the findings as a baseline file.no
verifyRe-scan the files behind earlier findings and report whether each is fixed.yes
fixGenerate and verify fixes for findings. Returns a diff by default.no
exploitDrive an agent to exploit a live, authorized target.no
packs_listList the framework packs a scan would load.yes
packs_checkValidate framework pack files.yes
solveCheck a separation logic entailment P |- Q.yes

A security-review prompt chains scan (with the AI layer), verify, and an offer to fix.

AI features and environment variables

The scan tool with ai=true, along with fix and exploit, call an LLM through an OpenAI-compatible endpoint. Configure it with these environment variables in the MCP client that launches the server:

VariablePurpose
FRAME_LLM_BASE_URLBase URL of the LLM endpoint, for example a local server or a hosted API.
FRAME_LLM_API_KEYAPI key for the endpoint, when it requires one.
FRAME_LLM_MODELModel name to request.

These are inherited from the server process environment and forwarded to each frame subprocess. Every other setting (streaming, timeouts, agent budgets, the hunt's budgets) is a key of the [llm] / [hunt] tables in the project's .frame.toml, which each frame command reads. The plain scan (taint analysis plus verification) needs none of them.

Exploit authorization

The exploit tool drives an autonomous agent that sends live traffic to a target. Run it only against systems you own or are explicitly authorized to test. Unauthorized testing of systems you do not control may be illegal.

License

Apache-2.0. See LICENSE.

Source: README.md at commit 7cb15e2

Tools

8

scan

Scan source for vulnerabilities

Scan a file or directory for security vulnerabilities with Frame. Runs taint analysis plus separation logic verification and returns the findings as JSON. Set ``ai=True`` to add the LLM detection and triage layer (needs the FRAME_LLM_* environment variables). ``changed_ref`` scans only files that differ from a git ref; ``files`` restricts the scan to a list of files; ``baseline`` reports only findings absent from a baseline file; ``packs`` loads extra framework packs. ``hunt_authz=True`` adds the agentic authorization hunt (IDOR, missing authorization, privilege escalation; needs a model): every handler gets a verdict, and the result's ``hunt`` section lists how it ended and what it left unresolved. A hunt runs one agent per group of handlers and can take hours on a large application; it is bounded by its step budgets, not by a timeout. This tool does not modify any files.

Parametersaipathrequiredrootfilespacksfail_onbaselinelanguagehunt_authzchanged_refmin_severityno_cross_file

write_baseline

Write a scan baseline file

Scan ``path`` and record the findings as a baseline file. Writes ``baseline_file`` to disk (creating or overwriting it) and uses ``--fail-on none`` so the current state is accepted. Later scans can pass this file as ``baseline`` to report only new findings.

Parameterspathrequiredbaseline_filerequired

verify

Verify earlier findings are fixed

Re-scan the files behind earlier findings and report their status. ``findings_json`` is the JSON produced by ``scan`` (a JSON string or the parsed object). Each finding comes back as fixed, file_removed, present, suppressed, uncertain or unverifiable. Pass ``ids`` (finding fingerprints) to check only specific findings. This tool does not modify any files.

Parametersidsfindings_jsonrequired

fix

Generate verified security fixes

Generate and verify fixes for scan findings. By default this returns a unified diff and does not touch any files. Set ``in_place=True`` to write the patches to the source files. Each patch is verified by re-scanning the patched code. This tool needs the FRAME_LLM_* environment variables (FRAME_LLM_BASE_URL, FRAME_LLM_MODEL, and an API key when the endpoint requires one).

Parameterspathrequiredin_placefindings_jsonrequired

exploit

Drive an exploitation agent against a target

Drive an LLM agent to exploit a live target. Authorized use only. Run this only against systems you own or are explicitly authorized to test. ``target`` is a URL such as http://app:8080. Optionally prime the agent with ``findings_json`` from ``scan``, a plain-language ``goal``, a ``success_check`` shell command (exit 0 means solved), and ``max_steps``. Needs the FRAME_LLM_* environment variables.

Parametersgoaltargetrequiredmax_stepsfindings_jsonsuccess_check

packs_list

List loadable framework packs

List the framework packs a scan would load. Packs teach Frame a framework's sources, sinks, sanitizers and entry points. Pass ``path`` to include a project directory's .frame/packs.

Parameterspath

packs_check

Validate framework pack files

Validate one or more framework pack .toml files or directories.

Parametersfilesrequired

solve

Check a separation logic entailment

Check whether a separation logic entailment ``P |- Q`` is valid. Example entailment: ``x |-> 5 |- x |-> 5``. Set ``model=True`` to return a countermodel when the entailment is invalid.

Parametersmodelentailmentrequired

Version history

2
  1. v0.2.0LatestNov 6, 2026
  2. v0.1.0Oct 29, 2026

Score

90% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts
  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts