Skip to main content
Glama
Threat Modeling MCP Server

Threat Modeling MCP Server

Official
by awslabs

Threat Modeling MCP Server

A Model Context Protocol (MCP) server for comprehensive threat modeling with guided code validation.

Table of Contents

Related MCP server: Code-Oracle

Overview

This server provides tools for threat modeling, including business context analysis, architecture analysis, threat actor analysis, trust boundary analysis, asset flow analysis, code security validation and comprehensive report generation.

Architecture and Approach

This MCP Server calls the existing agent's LLM instead of making an external API or network call to a different service. It relies on existing client's LLM which could be Amazon-Q, Kiro or Cline.

This Threat Modeling MCP Server has three main functionalities:

  1. Threat modeling phase or state management and prompt controlling.

  2. Prompts steering, which controls the agent to go through a methodic approach to threat modeling using built in definitions of business risks, exposures, threat actors and use STRIDE in sequential order.

  3. Structured input validation and phase-completion checks that support an actionable threat model report.

It also has tools to generate a final report in both Markdown and JSON exportable formats.

Key Advantages of this approach

  • This threat model follows the standard STRIDE approach to threat modeling in phases rather than quick conclusion of assets, boundaries and threats which can lead to hallucination or low quality output.

  • There is an effort by LLM to understand the business context of the project and make valid assumptions which can be controlled by the user.

  • This local server relies on the MCP client's configured LLM (Cline, Amazon Q, Kiro) rather than calling a separate model API. Data exposure depends on the client and any other MCP servers the client invokes.

  • The server keeps the working threat model in memory for the current process. Export tools can write JSON and Markdown snapshots to a .threatmodel directory, but those snapshots are not automatically loaded in a later session.

  • The code-validation tool records evidence supplied by the client after it inspects the implementation, applies status transitions atomically, and fails the phase closed until every current threat and mitigation is covered.

Quick Start Prompts and Examples on how to threat model with this MCP server

Note: Before using these prompts, you must first complete the Installation process to set up the MCP server.

Start a threat model

"Threat model this project using the threat modeling MCP Server"

Being specific in the prompt to use the threat modeling MCP Server will make sure the client (Cline/Kiro/etc) will follow the exact phases and methodology rather than taking short cut path and introduce hallucination in results.

Threat model a subproject or reduce the scope to a sub folder

"Threat model this subfolder using the threat modeling MCP Server"

Running it on a subfolder limits the intended analysis scope. To save exports there, request an output path inside that subfolder; the export location is not inferred automatically from the analysis scope.

Save the result of threat model

"Save the threat model report"

Validate the completeness of the threat modeling process

"Please complete all the phases in the threat model plan and then generate the final report."

Feed an architecture diagram image as input

"Threat model this project using the threat model MCP server and consider this architecture_image.png attached for this review"

Attempt remediating the threats

"Can you see if you can implement mitigation controls in the code based on the threats reported in the threat model"

Regenerate threat model based on code fixes

"Can you updated the threat model based on the code fixes which mitigated the reported threats"

More examples

# Set up context
"Set business context for an e-commerce payment system"

# Add architecture
"Add a web server component using AWS EC2"
"Add a database component using AWS RDS"

# Identify threats
"Add a threat where an attacker with network access performs SQL injection"

# Add mitigations
"Add a mitigation for input validation"

# Export results
"Export the threat model to my_model.tc.json"

Key Features

  • Comprehensive Threat Modeling: Structured approach to identifying, evaluating, and addressing security risks

  • Evidence-Based Code Validation: Records implementation evidence, updates statuses, and produces a deterministic report

  • Business Context Analysis: Understand the business value and criticality of the system

  • Architecture Analysis: Document the system's technical architecture and data flows

  • Threat Actor Analysis: Identify potential adversaries and assess their capabilities

  • Trust Boundary Analysis: Identify trust zones and validate security controls at boundaries

  • Asset Flow Analysis: Track critical assets through the system

  • Threat Identification: Systematically identify potential threats using STRIDE methodology

  • Mitigation Planning: Develop strategies to address identified threats

  • Compact Domain Managers: Action-based tools for assumptions, architecture, actors, boundaries, assets, threats, and mitigations

  • Threat Model Guide: Step-by-step guidance through the threat modeling process

  • Data Model Inspection: One tool for listing enum models and inspecting accepted values

Prerequisites

Before installing the Threat Modeling MCP Server, ensure you have the following requirements:

Installation Requirements

  1. Install uvx from Astral or the GitHub README

    • uvx is part of the uv package manager

    • Verify installation: uvx --version

Installation

Once you have uvx installed and verified to be working, add the below configuation to your mcp.json config file. Depending on the what type of client your are using (kiro/cline/amazon-q) the location of this mcp.json will be different. Once you add the config and restart your IDE, the Threat Modeling MCP Server will be automatically be installed directly from this GitHub repository using uvx.

Note: The tools used by this mcp server for threat modeling are already added to the autoApprove for ease of user experience which enables seamless operation without manual approval prompts for each tool call. All tools are internal to the server and do not make external API calls. If you want to review each of the tools and approve it per invocation, then you need to replace the autoApprove array with this: "autoApprove": []

Configuration

Add the following to your MCP client configuration:

For Amazon Q (~/.aws/amazonq/mcp.json):

{
  "mcpServers": {
    "threat-modeling-mcp-server": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/awslabs/threat-modeling-mcp-server.git",
        "threat-modeling-mcp-server"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": ["manage_workflow","export_threat_model","manage_system_context","manage_assumptions","manage_architecture","manage_threat_actors","manage_trust_boundaries","manage_asset_flows","manage_threats","inspect_data_models","manage_code_validation"]
    }
  }
}

For VSCode Cline:

{
  "mcpServers": {
    "threat-modeling-mcp-server": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/awslabs/threat-modeling-mcp-server.git",
        "threat-modeling-mcp-server"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": ["manage_workflow","export_threat_model","manage_system_context","manage_assumptions","manage_architecture","manage_threat_actors","manage_trust_boundaries","manage_asset_flows","manage_threats","inspect_data_models","manage_code_validation"],
      "timeout": 60,
      "type": "stdio"
    }
  }
}

For Kiro (~/.kiro/settings/mcp.json):

{
  "mcpServers": {
    "threat-modeling-mcp-server": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/awslabs/threat-modeling-mcp-server.git",
        "threat-modeling-mcp-server"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "disabled": false,
      "autoApprove": ["manage_workflow","export_threat_model","manage_system_context","manage_assumptions","manage_architecture","manage_threat_actors","manage_trust_boundaries","manage_asset_flows","manage_threats","inspect_data_models","manage_code_validation"]
    }
  }
}

Running with Kiro CLI

To run the MCP server via kiro-cli with all tools auto-approved:

kiro-cli chat --trust-tools="@threat-modeling-mcp-server/*"

This trusts all tools from the threat-modeling-mcp-server MCP server, so you won't be prompted to approve each tool call individually.

Running with the Custom Kiro CLI Agent

This repository includes a pre-configured Kiro CLI agent that covers nine numbered phases plus the optional Phase 7.5 code-validation step. The agent configuration is in .kiro/agents/threat-modeler.json.

Global install (available from any directory):

./install-kiro-agent.sh

To uninstall: ./install-kiro-agent.sh --remove

Local install (project-specific):

cp -r /path/to/threat-modeling-mcp-server/.kiro /path/to/your-project/.kiro

Usage:

# Non-interactive: run full threat model and exit
kiro-cli chat --agent threat-modeler --no-interactive "Threat model this project"

# Interactive: start a session with the agent
kiro-cli chat --agent threat-modeler

What the agent includes:

  • System prompt (.kiro/prompts/threat-modeler.md): Detailed instructions for the phased STRIDE methodology

  • Skills (.kiro/skills/): Per-phase reference materials, including optional Phase 7.5

  • Auto-approved MCP tools: All threat modeling tools run without manual approval prompts

Output File Management

Before exporting, select the directory being threat modeled with manage_workflow(action="set_project", directory=...). The export tool always creates <selected-project>/.threatmodel/ and writes these artifacts there:

  • <base>.tc.json: strict AWS Threat Composer JSON. This is the only file to import into Threat Composer. It holds only the standard schema keys, uses deterministic UUID ids, and applies Threat Composer's field length limits.

  • <base>.md: the human-readable Markdown report with full text.

  • <base>.extended.json: a separate server-state snapshot (architecture, taxonomy profiles, residual risk, phase progress) with internal ids and full text. It is not importable into Threat Composer. Pass include_extended_data=False to skip it.

The stored model keeps full text. When a field exceeds a Threat Composer limit, only the .tc.json copy is shortened, and the tool response lists each shortened field (by entity, field, and length) under "Export Warnings".

Omitting output_path uses a timestamped base filename. Supplying output_path selects only the base filename; absolute paths, parent traversal, and other directory components cannot redirect any artifact outside the selected project's .threatmodel directory.

Validation and analysis tools generally return text through MCP rather than writing report files. The exported files are snapshots; the server does not automatically reload them when a new process starts.

Quick Reference

Essential Tools for Getting Started

Tool

Purpose

Example

manage_workflow(action="plan")

Get comprehensive plan

Start here for overview

manage_workflow(action="guidance", phase="1")

Get focused Phase 1 guidance

Recommended starting point

manage_workflow(action="status")

Check progress

Track completion status

manage_system_context(action, section, ...)

Define business context and taxonomy profiles

action="set", section="all"

manage_assumptions(action, ...)

Document and maintain assumptions

Start with action="describe"

manage_architecture(action, section, ...)

Manage components, data-store nodes, and connections

Start with action="describe"

manage_threat_actors(action, ...)

Assess and analyze threat actors

Use action="update" for relevance and priority

manage_trust_boundaries(action, section, ...)

Manage zones, crossings, and boundaries

Use action="detection_plan" for guidance

manage_asset_flows(action, section, ...)

Manage assets and flows

Sections are assets and flows

manage_threats(action, section, ...)

Manage threats, mitigations, links, and residual-risk decisions

Use action="assess" in Phase 8

manage_code_validation(action, values)

Record and report code-validation evidence

Start with action="describe"

export_threat_model()

Execute Phase 9 export

Generates JSON and Markdown snapshots

🚀 Step-by-Step Guidance

Recommended Approach: Use the consolidated guidance tool for one phase at a time:

Phase

Tool

Purpose

1

manage_workflow(action="guidance", phase="1")

Business Context Analysis

2

manage_workflow(action="guidance", phase="2")

Architecture Analysis

3

manage_workflow(action="guidance", phase="3")

Threat Actor Analysis

4

manage_workflow(action="guidance", phase="4")

Trust Boundary Analysis

5

manage_workflow(action="guidance", phase="5")

Asset Flow Analysis

6

manage_workflow(action="guidance", phase="6")

Threat Identification

7

manage_workflow(action="guidance", phase="7")

Mitigation Planning

7.5

manage_workflow(action="guidance", phase="7.5")

Guided Code Validation (Optional)

8

manage_workflow(action="guidance", phase="8")

Residual Risk Analysis

9

manage_workflow(action="guidance", phase="9")

Output Generation and Documentation

Tools Overview

The Threat Modeling MCP Server provides 11 tools organized into the following categories:

Category

Tools

Description

Workflow

2 tools

Plan and guide the workflow, track or advance phases, and export the result

System Context

1 tool

Manage business context plus software, data, user, and NFR taxonomy profiles

Domain Managers

6 tools

Manage assumptions, architecture, actors, boundaries, asset flows, threats, and mitigations

Data Model Types

1 tool

Explore available enum models and accepted values

Code Validation

1 tool

Record evidence, apply statuses, validate coverage, and render reports

Threat Modeling Methodology

STRIDE Framework

The server uses the STRIDE methodology for systematic threat identification:

Category

Description

Example Threats

Spoofing

Impersonating someone or something else

Authentication bypass, identity theft

Tampering

Modifying data or code

Data corruption, code injection

Repudiation

Claiming to have not performed an action

Log tampering, non-repudiation failures

Information Disclosure

Exposing information to unauthorized users

Data leaks, privacy breaches

Denial of Service

Denying or degrading service

Resource exhaustion, availability attacks

Elevation of Privilege

Gaining capabilities without authorization

Privilege escalation, unauthorized access

Threat Modeling Process

The comprehensive threat modeling process includes these phases:

  • Phase 1 - Business Context Analysis: Understanding the business value and criticality of the system

  • Phase 2 - Architecture Analysis: Connecting every component and data-store node

  • Phase 3 - Threat Actor Analysis: Identifying potential adversaries and their capabilities

  • Phase 4 - Trust Boundary Analysis: Assigning every node to a zone and mapping inter-zone connections

  • Phase 5 - Asset Flow Analysis: Tracking every critical asset through at least one flow

  • Phase 6 - Threat Identification: Systematically identifying potential threats using STRIDE

  • Phase 7 - Mitigation Planning: Linking at least one mitigation to every threat

  • Phase 7.5 - Code Validation Analysis (optional): Recording implementation evidence for every threat and mitigation

  • Phase 8 - Residual Risk Analysis: Recording a current decision, residual ratings, and rationale for every threat

  • Phase 9 - Output Generation and Documentation: Exporting current JSON and Markdown snapshots

Each phase includes specific objectives, activities, and outputs to guide the threat modeling process.

Threat Severity Levels

  • Critical: Immediate action required, system compromise likely

  • High: Significant risk, should be addressed quickly

  • Medium: Moderate risk, address in normal development cycle

  • Low: Minor risk, address when convenient

Threat Likelihood Levels

  • Very Likely: Expected to occur

  • Likely: More likely than not

  • Possible: Plausible given the right conditions

  • Unlikely: Would require unusual circumstances

Mitigation Types

  • Preventive: Controls that prevent threats from occurring

  • Detective: Controls that detect when threats occur

  • Corrective: Controls that respond to and correct threats

  • Deterrent: Controls that discourage an attacker from attempting the threat

Assumptions in Threat Modeling

Assumptions are statements that we accept as true without requiring further validation. They help scope the threat model by establishing boundaries and constraints. Common examples include:

  • "All network connections in the VPC are encrypted in transit"

  • "AWS KMS keys cannot be discovered by brute force"

  • "Nation-state threat actors are not a concern for this system"

By documenting assumptions, we can:

  • Prevent generating pointless threats

  • Avoid recommending unnecessary mitigations

  • Focus on relevant security concerns

  • Clearly document the scope and limitations of the threat model

Development

Contributing

To contribute to this project:

  1. Clone the repository

  2. Create a virtual environment with uv venv

  3. Activate it with source .venv/bin/activate (Windows PowerShell: .venv\Scripts\Activate.ps1)

  4. Install the package and test dependencies with uv pip install -e '.[test]'

  5. Run the server locally with python run_server.py

  6. Run tests with python -m pytest

Security

See CONTRIBUTING for more information.

License

This project is licensed under the Apache-2.0 License. See the LICENSE file for details.

Available Tools

107 tools
add_assetA

Add a new asset to the system. Supports batch operations via the 'items' parameter.

This tool adds one or more assets to the system. For single item: provide name, type, classification, and optional fields directly. For batch: provide a list of asset dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling name: Name of the asset (required for single item mode) type: Type of the asset (e.g., 'Data', 'Credential', 'Process') (required for single item mode) classification: Classification of the asset (e.g., 'Public', 'Confidential') (required for single item mode) lifecycle_state: Current lifecycle state of the asset description: Description of the asset owner: Owner of the asset sensitivity: Sensitivity level of the asset (1-5) criticality: Criticality level of the asset (1-5) metadata: Additional metadata for the asset items: Optional list of asset dicts for batch operation

Returns: A confirmation message with the asset ID(s)

Inputs: name, type, items, owner, +6 more. Returns: result

add_assumptionA

Add a new assumption to the threat model. Supports batch operations via the 'items' parameter.

Assumptions are statements that we accept as true without requiring further validation. They help scope the threat model by establishing boundaries and constraints. For single item: provide description, category, impact, rationale directly. For batch: provide a list of assumption dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling description: Description of the assumption (required for single item mode) category: Category of the assumption (required for single item mode) impact: Impact of the assumption on the threat model (required for single item mode) rationale: Rationale for making this assumption (required for single item mode) items: Optional list of assumption dicts for batch operation

Returns: A confirmation message with the assumption ID(s)

Inputs: items, impact, category, rationale, +1 more. Returns: result

add_componentA

Add a new component to the architecture. Supports batch operations via the 'items' parameter.

This tool adds one or more components to the system architecture. For single item: provide name, type, and optional fields directly. For batch: provide a list of component dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling name: Name of the component (required for single item mode) type: Type of the component (required for single item mode) service_provider: Provider of the service (e.g., 'AWS', 'Azure', 'GCP') specific_service: Specific service name (e.g., 'EC2', 'S3', 'Lambda') version: Version of the component description: Description of the component configuration: Configuration details of the component items: Optional list of component dicts for batch operation

Returns: A confirmation message with the component ID(s)

Inputs: name, type, items, version, +4 more. Returns: result

add_component_to_zoneA

Add a component to a trust zone. Supports batch operations via the 'items' parameter.

This tool adds one or more components to trust zones in the system architecture. For single item: provide zone_id and component_id directly. For batch: provide a list of dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling zone_id: ID of the trust zone (required for single item mode) component_id: ID of the component to add (required for single item mode) items: Optional list of zone-component pair dicts for batch operation

Returns: A confirmation message

Inputs: items, zone_id, component_id. Returns: result

add_connectionA

Add a new connection to the architecture. Supports batch operations via the 'items' parameter.

This tool adds one or more connections between components in the system architecture. For single item: provide source_id, destination_id, and optional fields directly. For batch: provide a list of connection dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling source_id: ID of the source component (required for single item mode) destination_id: ID of the destination component (required for single item mode) protocol: Protocol used for the connection (e.g., 'HTTP', 'HTTPS', 'TCP') port: Port used for the connection encryption: Whether the connection is encrypted description: Description of the connection items: Optional list of connection dicts for batch operation

Returns: A confirmation message with the connection ID(s)

Inputs: port, items, protocol, source_id, +3 more. Returns: result

add_conn_to_crossingA

Add a connection to a crossing point. Supports batch operations via the 'items' parameter.

This tool adds one or more connections to crossing points in the system architecture. For single item: provide crossing_point_id and connection_id directly. For batch: provide a list of dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling crossing_point_id: ID of the crossing point (required for single item mode) connection_id: ID of the connection to add (required for single item mode) items: Optional list of crossing-point-connection pair dicts for batch operation

Returns: A confirmation message

Inputs: items, connection_id, crossing_point_id. Returns: result

add_crossing_pointA

Add a new crossing point. Supports batch operations via the 'items' parameter.

This tool adds one or more crossing points between trust zones in the system architecture. For single item: provide source_zone_id, destination_zone_id, and optional fields directly. For batch: provide a list of crossing point dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling source_zone_id: ID of the source trust zone (required for single item mode) destination_zone_id: ID of the destination trust zone (required for single item mode) authentication_method: Authentication method used at the crossing point authorization_method: Authorization method used at the crossing point description: Description of the crossing point items: Optional list of crossing point dicts for batch operation

Returns: A confirmation message with the crossing point ID(s)

Inputs: items, description, source_zone_id, destination_zone_id, +2 more. Returns: result

add_data_storeA

Add a new data store to the architecture. Supports batch operations via the 'items' parameter.

This tool adds one or more data stores to the system architecture. For single item: provide name, type, classification, and optional fields directly. For batch: provide a list of data store dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling name: Name of the data store (required for single item mode) type: Type of the data store (required for single item mode) classification: Classification of the data (required for single item mode) encryption_at_rest: Whether the data is encrypted at rest backup_frequency: Frequency of backups (e.g., 'Hourly', 'Daily', 'Weekly') description: Description of the data store items: Optional list of data store dicts for batch operation

Returns: A confirmation message with the data store ID(s)

Inputs: name, type, items, description, +3 more. Returns: result

add_flowA

Add a new asset flow to the system. Supports batch operations via the 'items' parameter.

This tool adds one or more asset flows to the system. For single item: provide asset_id, source_id, destination_id, and optional fields directly. For batch: provide a list of flow dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling asset_id: ID of the asset being transferred (required for single item mode) source_id: ID of the source component or trust zone (required for single item mode) destination_id: ID of the destination component or trust zone (required for single item mode) transformation_type: Type of transformation applied to the asset controls: List of security controls applied to the flow description: Description of the flow protocol: Protocol used for the flow encryption: Whether the flow is encrypted authenticated: Whether the flow is authenticated authorized: Whether the flow is authorized validated: Whether the flow is validated risk_level: Risk level of the flow (1-5) items: Optional list of flow dicts for batch operation

Returns: A confirmation message with the flow ID(s)

Inputs: items, asset_id, controls, protocol, +9 more. Returns: result

add_mitigationA

Add a new mitigation to the model. Supports batch operations via the 'items' parameter.

This tool adds one or more mitigations to the threat model. For single item: provide content and optional fields directly. For batch: provide a list of mitigation dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling content: Content of the mitigation (required for single item mode) type: Type of the mitigation status: Status of the mitigation implementation_details: Implementation details of the mitigation cost: Cost of the mitigation effectiveness: Effectiveness of the mitigation metadata: Metadata for the mitigation items: Optional list of mitigation dicts for batch operation

Returns: A confirmation message with the mitigation ID(s)

Inputs: cost, type, items, status, +4 more. Returns: result

add_threatA

Add a new threat to the model. Supports batch operations via the 'items' parameter.

This tool adds one or more threats to the threat model. IMPORTANT: Each text field must be 200 characters or fewer to comply with the Threat Composer schema. For single item: provide threat_source, prerequisites, threat_action, threat_impact directly. For batch: provide a list of threat dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling threat_source: Source of the threat, max 200 chars (required for single item mode) prerequisites: Prerequisites for the threat, max 200 chars (required for single item mode) threat_action: Action performed by the threat, max 200 chars (required for single item mode) threat_impact: Impact of the threat, max 200 chars (required for single item mode) category: STRIDE category of the threat severity: Severity of the threat likelihood: Likelihood of the threat affected_components: List of component IDs affected by the threat affected_assets: List of asset IDs affected by the threat tags: List of tags for the threat items: Optional list of threat dicts for batch operation

Returns: A confirmation message with the threat ID(s)

Inputs: tags, items, category, severity, +7 more. Returns: result

add_threat_actorA

Add a new threat actor. Supports batch operations via the 'items' parameter.

This tool adds one or more threat actors to the threat model. For single item: provide name, type, capability_level, motivations, resources directly. For batch: provide a list of threat actor dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling name: Name of the threat actor (required for single item mode) type: Type of the threat actor (required for single item mode) capability_level: Capability level of the threat actor (required for single item mode) motivations: Motivations of the threat actor (required for single item mode) resources: Resources available to the threat actor (required for single item mode) description: Description of the threat actor priority: Priority of the threat actor (1-10, 0 means not ranked) relevance_score: Relevance score of the threat actor (0.0-1.0) is_relevant: Whether the threat actor is relevant to the system items: Optional list of threat actor dicts for batch operation

Returns: A confirmation message with the threat actor ID(s)

Inputs: name, type, items, priority, +6 more. Returns: result

add_trust_boundaryA

Add a new trust boundary. Supports batch operations via the 'items' parameter.

This tool adds one or more trust boundaries to the system architecture. For single item: provide name, type, and optional fields directly. For batch: provide a list of trust boundary dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling name: Name of the trust boundary (required for single item mode) type: Type of the trust boundary (required for single item mode) crossing_point_ids: IDs of crossing points that cross this boundary controls: Security controls implemented at this boundary description: Description of the trust boundary items: Optional list of trust boundary dicts for batch operation

Returns: A confirmation message with the trust boundary ID(s)

Inputs: name, type, items, controls, +2 more. Returns: result

add_trust_zoneA

Add a new trust zone. Supports batch operations via the 'items' parameter.

This tool adds one or more trust zones to the system architecture. For single item: provide name, trust_level, and optional fields directly. For batch: provide a list of trust zone dicts in the 'items' parameter.

Args: ctx: MCP context for logging and error handling name: Name of the trust zone (required for single item mode) trust_level: Trust level of the zone (required for single item mode) description: Description of the trust zone items: Optional list of trust zone dicts for batch operation

Returns: A confirmation message with the trust zone ID(s)

Inputs: name, items, description, trust_level. Returns: result

advance_phaseB

Advance to the next phase of the threat modeling process.

This tool advances to the next phase of the threat modeling process.

Args: ctx: MCP context for logging and error handling

Returns: A confirmation message and guidance for the new phase

Inputs: no named parameters. Returns: result

analyze_threat_actorsA

Analyze the threat actors.

This tool analyzes the threat actors in the threat model and provides recommendations.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted analysis of the threat actors

Inputs: no named parameters. Returns: result

clear_architectureA

Clear the architecture.

This tool clears all components, connections, and data stores from the architecture.

Args: ctx: MCP context for logging and error handling

Returns: A confirmation message

Inputs: no named parameters. Returns: result

clear_asset_flowsC

Clear all assets and flows from the system.

This tool clears all assets and flows from the system.

Args: ctx: MCP context for logging and error handling

Returns: A confirmation message

Inputs: no named parameters. Returns: result

clear_business_contextA

Clear the business context.

This tool clears the business context, description, and clarification questions.

Args: ctx: MCP context for logging and error handling

Returns: A confirmation message

Inputs: no named parameters. Returns: result

clear_threat_actorsB

Clear all threat actors.

This tool clears all threat actors from the threat model.

Args: ctx: MCP context for logging and error handling

Returns: A confirmation message

Inputs: no named parameters. Returns: result

clear_trust_boundariesA

Clear all trust boundaries.

This tool clears all trust boundaries, crossing points, and trust zones from the system architecture.

Args: ctx: MCP context for logging and error handling

Returns: A confirmation message

Inputs: no named parameters. Returns: result

delete_assetA

Delete an asset from the system. Supports batch operations via the 'ids' parameter.

This tool deletes one or more assets from the system. Assets cannot be deleted if used in any flows. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the asset to delete (required for single item mode) ids: Optional list of asset IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_assumptionB

Delete an assumption from the threat model. Supports batch operations via the 'ids' parameter.

For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the assumption to delete (required for single item mode) ids: Optional list of assumption IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_componentA

Delete a component from the architecture. Supports batch operations via the 'ids' parameter.

This tool deletes one or more components from the system architecture. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the component to delete (required for single item mode) ids: Optional list of component IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_connectionA

Delete a connection from the architecture. Supports batch operations via the 'ids' parameter.

This tool deletes one or more connections from the system architecture. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the connection to delete (required for single item mode) ids: Optional list of connection IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_crossing_pointB

Delete a crossing point. Supports batch operations via the 'ids' parameter.

This tool deletes one or more crossing points from the system architecture. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the crossing point to delete (required for single item mode) ids: Optional list of crossing point IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_data_storeA

Delete a data store from the architecture. Supports batch operations via the 'ids' parameter.

This tool deletes one or more data stores from the system architecture. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the data store to delete (required for single item mode) ids: Optional list of data store IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_flowA

Delete an asset flow from the system. Supports batch operations via the 'ids' parameter.

This tool deletes one or more asset flows from the system. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the flow to delete (required for single item mode) ids: Optional list of flow IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_mitigationA

Delete a mitigation from the model. Supports batch operations via the 'ids' parameter.

This tool deletes one or more mitigations from the threat model. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the mitigation to delete (required for single item mode) ids: Optional list of mitigation IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_threatA

Delete a threat from the model. Supports batch operations via the 'ids' parameter.

This tool deletes one or more threats from the threat model. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the threat to delete (required for single item mode) ids: Optional list of threat IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_threat_actorA

Delete a threat actor. Supports batch operations via the 'ids' parameter.

This tool deletes one or more threat actors from the threat model. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the threat actor to delete (required for single item mode) ids: Optional list of threat actor IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_trust_boundaryA

Delete a trust boundary. Supports batch operations via the 'ids' parameter.

This tool deletes one or more trust boundaries from the system architecture. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the trust boundary to delete (required for single item mode) ids: Optional list of trust boundary IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

delete_trust_zoneA

Delete a trust zone. Supports batch operations via the 'ids' parameter.

This tool deletes one or more trust zones from the system architecture. For single item: provide the id directly. For batch: provide a list of IDs in the 'ids' parameter.

Args: ctx: MCP context for logging and error handling id: ID of the trust zone to delete (required for single item mode) ids: Optional list of trust zone IDs for batch deletion

Returns: A confirmation message

Inputs: id, ids. Returns: result

execute_code_validation_stepA

Execute the complete code validation step (Phase 7.5) automatically.

This tool automates the code validation step, analyzing the codebase to determine which security controls are already implemented and which threats are mitigated.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted report of the code validation results

Inputs: no named parameters. Returns: result

execute_final_export_stepB

Execute the complete final export step (Phase 9) automatically.

This tool automates the final export step, generating all required documentation and outputs from the threat modeling process.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted report of the export results

Inputs: no named parameters. Returns: result

export_comprehensive_threat_modelA

Export comprehensive threat model with all global variables to Threat Composer JSON format.

This tool exports the complete threat model including all global variables from all phases of the threat modeling process. It collects business context, assumptions, architecture, threat actors, trust boundaries, asset flows, threats, mitigations, and phase progress.

Args: ctx: MCP context for logging and error handling output_path: Path to save the exported threat model (will be saved in .threatmodel directory) include_extended_data: Whether to include extended data beyond standard Threat Composer format

Returns: A comprehensive export summary with details about what was exported

Inputs: output_path (required), include_extended_data. Returns: result

export_threat_model_with_remediation_statusA

Export the threat model with remediation status.

This tool exports the threat model with information about which threats are already remediated by existing security controls.

Args: ctx: MCP context for logging and error handling output_path: Path to save the exported threat model

Returns: A confirmation message

Inputs: output_path (required). Returns: result

follow_threat_modeling_planB

Follow the threat modeling plan.

This tool guides the user through the threat modeling process step by step, following the plan generated by the get_threat_modeling_plan tool.

Args: ctx: MCP context for logging and error handling phase: Optional phase to get guidance for (if not provided, will use current phase)

Returns: A markdown-formatted guide for the current or specified phase

Inputs: phase. Returns: result

generate_remediation_reportA

Generate a prompt for LLM to create a comprehensive remediation report.

This tool generates a prompt for LLM to create a report showing which threats are remediated by existing security controls in the code, which are partially remediated, and which require implementation.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted prompt for LLM to generate a remediation report

Inputs: no named parameters. Returns: result

get_architecture_analysis_planC

Get a comprehensive architecture analysis plan.

This tool returns a detailed plan for analyzing system architecture for security concerns using AI-powered analysis with AWS documentation validation.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted architecture analysis plan with prompts for LLM analysis

Inputs: no named parameters. Returns: result

get_assetA

Get details about a specific asset.

This tool retrieves details about a specific asset in the system.

Args: ctx: MCP context for logging and error handling id: ID of the asset to retrieve

Returns: A markdown-formatted description of the asset

Inputs: id (required). Returns: result

get_asset_flow_analysis_planA

Get a comprehensive asset flow analysis plan.

This tool returns a detailed plan for analyzing asset flows for security concerns using AI-powered analysis with AWS documentation validation.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted asset flow analysis plan with prompts for LLM analysis

Inputs: no named parameters. Returns: result

get_assumptionA

Get details about a specific assumption.

Args: ctx: MCP context for logging and error handling id: ID of the assumption to retrieve

Returns: A markdown-formatted description of the assumption

Inputs: id (required). Returns: result

get_business_contextA

Get the business context.

This tool returns the business context created from the answers to the clarification questions.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted business context

Inputs: no named parameters. Returns: result

get_business_context_analysis_planB

Get a comprehensive business context analysis plan.

This tool returns a detailed plan for analyzing business context descriptions using AI-powered analysis to categorize business features.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted business context analysis plan with prompts for LLM analysis

Inputs: no named parameters. Returns: result

get_business_context_featuresB

Get all business context features with descriptions.

This tool returns all available features of the business context with descriptions of what each feature represents.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted list of business context features with descriptions

Inputs: no named parameters. Returns: result

get_crossing_pointC

Get details about a specific crossing point.

This tool retrieves details about a specific crossing point in the system architecture.

Args: ctx: MCP context for logging and error handling id: ID of the crossing point to retrieve

Returns: A markdown-formatted description of the crossing point

Inputs: id (required). Returns: result

get_current_phase_statusB

Get the current phase status and completion progress.

This tool provides information about the current phase of the threat modeling process and the completion progress of each phase.

Args: ctx: MCP context for logging and error handling

Returns: A dictionary with current phase information and completion percentages

Inputs: no named parameters. Returns: result

get_data_model_typesB

Get available types for a data model.

This tool returns the available types for a specified data model.

Args: ctx: MCP context for logging and error handling model_name: Name of the data model to get types for

Returns: A markdown-formatted list of available types

Inputs: model_name (required). Returns: result

get_flowB

Get details about a specific asset flow.

This tool retrieves details about a specific asset flow in the system.

Args: ctx: MCP context for logging and error handling id: ID of the flow to retrieve

Returns: A markdown-formatted description of the flow

Inputs: id (required). Returns: result

get_mitigationA

Get details about a specific mitigation.

This tool retrieves details about a specific mitigation in the threat model.

Args: ctx: MCP context for logging and error handling id: ID of the mitigation to retrieve

Returns: A markdown-formatted description of the mitigation

Inputs: id (required). Returns: result

get_phase_1_guidanceA

Get detailed guidance for Phase 1: Business Context Analysis.

This tool provides step-by-step guidance for conducting business context analysis, including objectives, steps, tools to use, and expected outputs.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted guide for Phase 1

Inputs: no named parameters. Returns: result

get_phase_2_guidanceA

Get detailed guidance for Phase 2: Architecture Analysis.

This tool provides step-by-step guidance for conducting architecture analysis, including objectives, steps, tools to use, and expected outputs.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted guide for Phase 2

Inputs: no named parameters. Returns: result

get_phase_3_guidanceA

Get detailed guidance for Phase 3: Threat Actor Analysis.

This tool provides step-by-step guidance for conducting threat actor analysis, including objectives, steps, tools to use, and expected outputs.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted guide for Phase 3

Inputs: no named parameters. Returns: result

get_phase_4_guidanceA

Get detailed guidance for Phase 4: Trust Boundary Analysis.

This tool provides step-by-step guidance for conducting trust boundary analysis, including objectives, steps, tools to use, and expected outputs.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted guide for Phase 4

Inputs: no named parameters. Returns: result

get_phase_5_guidanceA

Get detailed guidance for Phase 5: Asset Flow Analysis.

This tool provides step-by-step guidance for conducting asset flow analysis, including objectives, steps, tools to use, and expected outputs.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted guide for Phase 5

Inputs: no named parameters. Returns: result

get_phase_6_guidanceA

Get detailed guidance for Phase 6: Threat Identification.

This tool provides step-by-step guidance for conducting threat identification, including objectives, steps, tools to use, and expected outputs.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted guide for Phase 6

Inputs: no named parameters. Returns: result

get_phase_7_5_guidanceA

Get detailed guidance for Phase 7.5: Code Validation Analysis.

This tool provides step-by-step guidance for conducting code validation analysis, including objectives, steps, tools to use, and expected outputs.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted guide for Phase 7.5

Inputs: no named parameters. Returns: result

get_phase_7_guidanceA

Get detailed guidance for Phase 7: Mitigation Planning.

This tool provides step-by-step guidance for conducting mitigation planning, including objectives, steps, tools to use, and expected outputs. The next steps are conditional based on whether code is detected in the project.

Args: ctx: MCP context for logging and error handling directory: Directory to check for code files (default: current directory)

Returns: A markdown-formatted guide for Phase 7 with conditional next steps

Inputs: directory. Returns: result

get_phase_8_guidanceA

Get detailed guidance for Phase 8: Residual Risk Analysis.

This tool provides step-by-step guidance for conducting residual risk analysis, including objectives, steps, tools to use, and expected outputs.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted guide for Phase 8

Inputs: no named parameters. Returns: result

get_phase_9_guidanceA

Get detailed guidance for Phase 9: Output Generation and Documentation.

This tool provides step-by-step guidance for generating outputs and documentation, including objectives, steps, tools to use, and expected outputs.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted guide for Phase 9

Inputs: no named parameters. Returns: result

get_threatA

Get details about a specific threat.

This tool retrieves details about a specific threat in the threat model.

Args: ctx: MCP context for logging and error handling id: ID of the threat to retrieve

Returns: A markdown-formatted description of the threat

Inputs: id (required). Returns: result

get_threat_actorA

Get details about a specific threat actor.

This tool retrieves details about a specific threat actor in the threat model.

Args: ctx: MCP context for logging and error handling id: ID of the threat actor to retrieve

Returns: A markdown-formatted description of the threat actor

Inputs: id (required). Returns: result

get_threat_modeling_planA

Get a comprehensive threat modeling plan.

This tool returns a detailed threat modeling plan in markdown format, covering all phases of the threat modeling process. If code is detected in the specified directory, it will automatically run the threat model validation against the code.

Args: ctx: MCP context for logging and error handling directory: Directory to check for code files (default: current directory) auto_validate_code: Whether to automatically validate against code if detected (default: True)

Returns: A markdown-formatted threat modeling plan

Inputs: directory, auto_validate_code. Returns: result

get_threat_model_progressB

Get the current progress of the threat modeling process.

This tool returns the current progress of the threat modeling process, including completed phases and the current phase.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted progress report

Inputs: no named parameters. Returns: result

get_trust_boundaryA

Get details about a specific trust boundary.

This tool retrieves details about a specific trust boundary in the system architecture.

Args: ctx: MCP context for logging and error handling id: ID of the trust boundary to retrieve

Returns: A markdown-formatted description of the trust boundary

Inputs: id (required). Returns: result

get_trust_boundary_analysis_planA

Get a comprehensive trust boundary analysis plan.

This tool returns a detailed plan for analyzing trust boundaries for security concerns using AI-powered analysis with AWS documentation validation.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted trust boundary analysis plan with prompts for LLM analysis

Inputs: no named parameters. Returns: result

get_trust_boundary_detection_planA

Get a comprehensive trust boundary detection plan.

This tool returns a detailed plan for detecting trust boundaries from architecture components using AI-powered analysis with step-by-step prompts and guidance.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted plan with prompts for LLM-powered trust boundary detection

Inputs: no named parameters. Returns: result

get_trust_zoneB

Get details about a specific trust zone.

This tool retrieves details about a specific trust zone in the system architecture.

Args: ctx: MCP context for logging and error handling id: ID of the trust zone to retrieve

Returns: A markdown-formatted description of the trust zone

Inputs: id (required). Returns: result

list_assetsA

List all assets in the system.

This tool lists all assets in the system, optionally filtered by type or classification.

Args: ctx: MCP context for logging and error handling type: Optional type to filter assets classification: Optional classification to filter assets

Returns: A markdown-formatted list of assets

Inputs: type, classification. Returns: result

list_assumptionsA

List all current assumptions in the threat model.

Args: ctx: MCP context for logging and error handling category: Optional category to filter assumptions

Returns: A markdown-formatted list of assumptions

Inputs: category. Returns: result

list_componentsA

List all components in the architecture.

This tool lists all components in the system architecture.

Args: ctx: MCP context for logging and error handling type: Optional type to filter components

Returns: A markdown-formatted list of components

Inputs: type. Returns: result

list_connectionsA

List all connections in the architecture.

This tool lists all connections in the system architecture.

Args: ctx: MCP context for logging and error handling component_id: Optional component ID to filter connections

Returns: A markdown-formatted list of connections

Inputs: component_id. Returns: result

list_crossing_pointsA

List all crossing points.

This tool lists all crossing points in the system architecture.

Args: ctx: MCP context for logging and error handling zone_id: Optional trust zone ID to filter crossing points

Returns: A markdown-formatted list of crossing points

Inputs: zone_id. Returns: result

list_data_modelsA

List all available data models.

This tool lists all available data models that can be used with get_data_model_types.

Args: ctx: MCP context for logging and error handling

Returns: A markdown-formatted list of available data models

Inputs: no named parameters. Returns: result

list_data_storesA

List all data stores in the architecture.

This tool lists all data stores in the system architecture.

Args: ctx: MCP context for logging and error handling type: Optional type to filter data stores

Returns: A markdown-formatted list of data stores

Inputs: type. Returns: result

list_flowsA

List all asset flows in the system.

This tool lists all asset flows in the system, optionally filtered by asset ID or component ID.

Args: ctx: MCP context for logging and error handling asset_id: Optional asset ID to filter flows component_id: Optional component ID to filter flows

Returns: A markdown-formatted list of flows

Inputs: asset_id, component_id. Returns: result

list_mitigationsA

List all mitigations in the model.

This tool lists all mitigations in the threat model, optionally filtered by type or status.

Args: ctx: MCP context for logging and error handling type: Optional type to filter mitigations status: Optional status to filter mitigations

Returns: A markdown-formatted list of mitigations

Inputs: type, status. Returns: result

list_threat_actorsB

List all threat actors.

This tool lists all threat actors in the threat model.

Args: ctx: MCP context for logging and error handling type: Optional type to filter threat actors relevant_only: Whether to only show relevant threat actors

Returns: A markdown-formatted list of threat actors

Inputs: type, relevant_only. Returns: result

list_threatsA

List all threats in the model.

This tool lists all threats in the threat model, optionally filtered by category, severity, or status.

Args: ctx: MCP context for logging and error handling category: Optional category to filter threats severity: Optional severity to filter threats status: Optional status to filter threats

Returns: A markdown-formatted list of threats

Inputs: status, category, severity. Returns: result

list_trust_boundariesB

List all trust boundaries.

This tool lists all trust boundaries in the system architecture.

Args: ctx: MCP context for logging and error handling type: Optional type to filter trust boundaries

Returns: A markdown-formatted list of trust boundaries

Inputs: type. Returns: result

list_trust_zonesA

List all trust zones.

This tool lists all trust zones in the system architecture.

Args: ctx: MCP context for logging and error handling trust_level: Optional trust level to filter zones

Returns: A markdown-formatted list of trust zones

Inputs: trust_level. Returns: result

remove_component_from_zoneC

Remove a component from a trust zone.

This tool removes a component from a trust zone in the system architecture.

Args: ctx: MCP context for logging and error handling zone_id: ID of the trust zone component_id: ID of the component to remove

Returns: A confirmation message

Inputs: zone_id (required), component_id (required). Returns: result

remove_conn_from_crossingB

Remove a connection from a crossing point.

This tool removes a connection from a crossing point in the system architecture.

Args: ctx: MCP context for logging and error handling crossing_point_id: ID of the crossing point connection_id: ID of the connection to remove

Returns: A confirmation message

Inputs: connection_id (required), crossing_point_id (required). Returns: result

reset_asset_flowsC

Reset assets and flows to the default set.

This tool resets assets and flows to the default set.

Args: ctx: MCP context for logging and error handling

Returns: A confirmation message

Inputs: no named parameters. Returns: result

reset_threat_actorsB

Reset the threat actors to the default set.

This tool resets the threat actors to the default set.

Args: ctx: MCP context for logging and error handling

Returns: A confirmation message

Inputs: no named parameters. Returns: result

set_business_contextA

Set the business context with description and all features in one call.

This streamlined tool sets the business context description and all business features in a single call, eliminating the need for the clarification questions workflow.

Args: ctx: MCP context for logging and error handling description: Business context description industry_sector: Industry sector (optional) data_sensitivity: Data sensitivity level (optional) user_base_size: User base size (optional) geographic_scope: Geographic scope (optional) regulatory_requirements: Regulatory requirements, comma-separated (optional) system_criticality: System criticality (optional) financial_impact: Financial impact of breach (optional) authentication_requirement: Authentication requirement (optional) deployment_environment: Deployment environment (optional) integration_complexity: Integration complexity (optional)

Returns: A confirmation message with the number of features configured

Inputs: description (required), user_base_size, industry_sector, data_sensitivity, +7 more. Returns: result

set_threat_actor_priorityC

Set the priority of a threat actor.

This tool sets the priority of a threat actor in the threat model.

Args: ctx: MCP context for logging and error handling id: ID of the threat actor priority: Priority of the threat actor (1-10)

Returns: A confirmation message

Inputs: id (required), priority (required). Returns: result

set_threat_actor_relevanceC

Set the relevance of a threat actor.

This tool sets whether a threat actor is relevant to the system.

Args: ctx: MCP context for logging and error handling id: ID of the threat actor is_relevant: Whether the threat actor is relevant to the system

Returns: A confirmation message

Inputs: id (required), is_relevant (required). Returns: result

update_assetA

Update an existing asset. Supports batch operations via the 'items' parameter.

This tool updates one or more existing assets in the system. For single item: provide id and fields to update directly. For batch: provide a list of asset dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the asset to update (required for single item mode) name: New name of the asset type: New type of the asset classification: New classification of the asset lifecycle_state: New lifecycle state of the asset description: New description of the asset owner: New owner of the asset sensitivity: New sensitivity level of the asset criticality: New criticality level of the asset metadata: New metadata for the asset items: Optional list of asset dicts for batch update

Returns: A confirmation message

Inputs: id, name, type, items, +7 more. Returns: result

update_assumptionA

Update an existing assumption. Supports batch operations via the 'items' parameter.

For single item: provide id and fields to update directly. For batch: provide a list of assumption dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the assumption to update (required for single item mode) description: New description of the assumption category: New category of the assumption impact: New impact of the assumption rationale: New rationale for the assumption items: Optional list of assumption dicts for batch update

Returns: A confirmation message

Inputs: id, items, impact, category, +2 more. Returns: result

update_componentA

Update an existing component in the architecture. Supports batch operations via the 'items' parameter.

This tool updates one or more existing components in the system architecture. For single item: provide id and fields to update directly. For batch: provide a list of component dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the component to update (required for single item mode) name: New name of the component type: New type of the component service_provider: New provider of the service specific_service: New specific service name version: New version of the component description: New description of the component configuration: New configuration details of the component items: Optional list of component dicts for batch update

Returns: A confirmation message

Inputs: id, name, type, items, +5 more. Returns: result

update_connectionA

Update an existing connection in the architecture. Supports batch operations via the 'items' parameter.

This tool updates one or more existing connections in the system architecture. For single item: provide id and fields to update directly. For batch: provide a list of connection dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the connection to update (required for single item mode) source_id: New ID of the source component destination_id: New ID of the destination component protocol: New protocol used for the connection port: New port used for the connection encryption: New encryption status description: New description of the connection items: Optional list of connection dicts for batch update

Returns: A confirmation message

Inputs: id, port, items, protocol, +4 more. Returns: result

update_crossing_pointA

Update an existing crossing point. Supports batch operations via the 'items' parameter.

This tool updates one or more existing crossing points in the system architecture. For single item: provide id and fields to update directly. For batch: provide a list of crossing point dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the crossing point to update (required for single item mode) source_zone_id: New ID of the source trust zone destination_zone_id: New ID of the destination trust zone authentication_method: New authentication method authorization_method: New authorization method description: New description of the crossing point items: Optional list of crossing point dicts for batch update

Returns: A confirmation message

Inputs: id, items, description, source_zone_id, +3 more. Returns: result

update_data_storeA

Update an existing data store in the architecture. Supports batch operations via the 'items' parameter.

This tool updates one or more existing data stores in the system architecture. For single item: provide id and fields to update directly. For batch: provide a list of data store dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the data store to update (required for single item mode) name: New name of the data store type: New type of the data store classification: New classification of the data encryption_at_rest: New encryption status backup_frequency: New frequency of backups description: New description of the data store items: Optional list of data store dicts for batch update

Returns: A confirmation message

Inputs: id, name, type, items, +4 more. Returns: result

update_flowA

Update an existing asset flow. Supports batch operations via the 'items' parameter.

This tool updates one or more existing asset flows in the system. For single item: provide id and fields to update directly. For batch: provide a list of flow dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the flow to update (required for single item mode) asset_id: New ID of the asset being transferred source_id: New ID of the source component or trust zone destination_id: New ID of the destination component or trust zone transformation_type: New type of transformation applied to the asset controls: New list of security controls applied to the flow description: New description of the flow protocol: New protocol used for the flow encryption: New encryption status authenticated: New authentication status authorized: New authorization status validated: New validation status risk_level: New risk level of the flow (1-5) items: Optional list of flow dicts for batch update

Returns: A confirmation message

Inputs: id, items, asset_id, controls, +10 more. Returns: result

update_mitigationA

Update an existing mitigation. Supports batch operations via the 'items' parameter.

This tool updates one or more existing mitigations in the threat model. For single item: provide id and fields to update directly. For batch: provide a list of mitigation dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the mitigation to update (required for single item mode) content: New content of the mitigation type: New type of the mitigation status: New status of the mitigation implementation_details: New implementation details of the mitigation cost: New cost of the mitigation effectiveness: New effectiveness of the mitigation metadata: New metadata for the mitigation items: Optional list of mitigation dicts for batch update

Returns: A confirmation message

Inputs: id, cost, type, items, +5 more. Returns: result

update_threatA

Update an existing threat. Supports batch operations via the 'items' parameter.

This tool updates one or more existing threats in the threat model. IMPORTANT: Each text field must be 200 characters or fewer to comply with the Threat Composer schema. For single item: provide id and fields to update directly. For batch: provide a list of threat dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the threat to update (required for single item mode) threat_source: New source of the threat, max 200 chars prerequisites: New prerequisites for the threat, max 200 chars threat_action: New action performed by the threat, max 200 chars threat_impact: New impact of the threat, max 200 chars category: New STRIDE category of the threat severity: New severity of the threat likelihood: New likelihood of the threat status: New status of the threat affected_components: New list of component IDs affected by the threat affected_assets: New list of asset IDs affected by the threat tags: New list of tags for the threat items: Optional list of threat dicts for batch update

Returns: A confirmation message

Inputs: id, tags, items, status, +9 more. Returns: result

update_threat_actorA

Update an existing threat actor. Supports batch operations via the 'items' parameter.

This tool updates one or more existing threat actors in the threat model. For single item: provide id and fields to update directly. For batch: provide a list of threat actor dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the threat actor to update (required for single item mode) name: New name of the threat actor type: New type of the threat actor capability_level: New capability level of the threat actor motivations: New motivations of the threat actor resources: New resources available to the threat actor description: New description of the threat actor priority: New priority of the threat actor (1-10) relevance_score: New relevance score of the threat actor (0.0-1.0) is_relevant: New relevance status of the threat actor items: Optional list of threat actor dicts for batch update

Returns: A confirmation message

Inputs: id, name, type, items, +7 more. Returns: result

update_trust_boundaryA

Update an existing trust boundary. Supports batch operations via the 'items' parameter.

This tool updates one or more existing trust boundaries in the system architecture. For single item: provide id and fields to update directly. For batch: provide a list of trust boundary dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the trust boundary to update (required for single item mode) name: New name of the trust boundary type: New type of the trust boundary crossing_point_ids: New IDs of crossing points controls: New security controls description: New description of the trust boundary items: Optional list of trust boundary dicts for batch update

Returns: A confirmation message

Inputs: id, name, type, items, +3 more. Returns: result

update_trust_zoneA

Update an existing trust zone. Supports batch operations via the 'items' parameter.

This tool updates one or more existing trust zones in the system architecture. For single item: provide id and fields to update directly. For batch: provide a list of trust zone dicts in the 'items' parameter (each must include 'id').

Args: ctx: MCP context for logging and error handling id: ID of the trust zone to update (required for single item mode) name: New name of the trust zone trust_level: New trust level of the zone description: New description of the trust zone items: Optional list of trust zone dicts for batch update

Returns: A confirmation message

Inputs: id, name, items, description, +1 more. Returns: result

validate_business_context_completenessA

Validate that all business context features are set before proceeding to next phase.

This tool validates that all required business context features have been set and returns a clear message indicating whether the business context is complete or what features are still missing.

Args: ctx: MCP context for logging and error handling

Returns: A validation message indicating if business context is complete

Inputs: no named parameters. Returns: result

validate_security_controlsA

Check what security controls are implemented in code and update threat model.

Given the current threats and mitigations in the threat model, analyze the codebase to determine what's actually implemented and update the threat model accordingly. The agent should autonomously decide how to analyze the code.

Args: ctx: MCP context for logging and error handling code_directory: Directory containing code to analyze file_patterns: Optional list of file patterns to include (e.g., [".py", ".js"])

Returns: Simple instruction for autonomous analysis

Inputs: code_directory (required), file_patterns. Returns: result

validate_threat_model_against_codeA

Validate the threat model against the actual codebase.

This tool analyzes the codebase to determine which threats are already mitigated by existing security controls, and generates a comprehensive report.

Args: ctx: MCP context for logging and error handling code_directory: Directory containing code to analyze file_patterns: Optional list of file patterns to include (e.g., [".py", ".js"])

Returns: A markdown-formatted validation report

Inputs: code_directory (required), file_patterns. Returns: result

validate_threat_remediationA

Check if specific threats are remediated in code and update threat model.

Given specific threat IDs, analyze the codebase to determine if these threats are mitigated by existing code and update the threat model accordingly.

Args: ctx: MCP context for logging and error handling code_directory: Directory containing code to analyze threat_ids: List of threat IDs to validate

Returns: Simple instruction for autonomous threat-specific analysis

Inputs: threat_ids (required), code_directory (required). Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 107 tools

    Disambiguation4/5

    Most tools are cleanly separated by resource type (components, connections, data stores, threats, etc.) with clear CRUD patterns. However, several code-validation tools (validate_security_controls, validate_threat_remediation, validate_threat_model_against_code, execute_code_validation_step) have overlapping purposes and could confuse an agent.

    Naming Consistency4/5

    The naming generally follows a verb_noun pattern (e.g., add_component, list_threats, delete_flow), and batch modifiers are consistent. Deviations exist: some entity types lack a get_* counterpart (components, connections, data stores), and a mix of validate_*, execute_*, and get_* plan/guidance tools introduces minor inconsistency.

    Tool Count1/5

    With 107 tools, this server far exceeds the 50+ threshold for an extreme mismatch. While the domain is broad, the sheer number is overwhelming and suggests the tool surface should be consolidated or broken into smaller servers.

    Completeness4/5

    The server covers the full threat modeling lifecycle: business context, architecture elements, trust boundaries, threat actors, assets, flows, threats, mitigations, code validation, and exports. Minor gaps exist (e.g., no get_component, get_connection, or get_data_store), but they are workable.

    Maintenance

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Unified MCP server integrating NIST and OWASP security frameworks with live vulnerability data, enabling security searches, compliance mapping, threat modeling, and checklist generation.
      41
      14
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      A lightweight MCP server for security reviews that injects security requirements before code generation, scans dependencies for CVEs, and verifies generated code without disrupting workflow.
      73
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol server for automated security vulnerability assessment, combining OWASP Dependency-Check dependency scanning with custom code vulnerability detection, and generating detailed HTML and JSON reports.
      -