Threat Modeling MCP Server
OfficialA Model Context Protocol server that guides an LLM client through a structured, phased STRIDE threat modeling workflow and exports the results.
Provide step-by-step plans and phase guidance (business context, architecture, threat actors, trust boundaries, asset flows, threats, mitigations, code validation, residual risk, export).
Capture and manage business context, assumptions, business features, and validation of completeness.
Model architecture: components, connections, and data stores (add/update/list/delete, batch supported).
Manage threat actors with capability, motivation, relevance, and priority assessment.
Model trust zones, crossing points, and trust boundaries with attached controls.
Track assets and asset flows with sensitivity/criticality, controls, and risk levels.
Identify STRIDE threats, add mitigations, link mitigations to threats, and track severity, likelihood, and status.
Validate security controls and threat remediation against a codebase and produce remediation reports.
Export the full threat model as Threat Composer JSON, Markdown, and extended snapshots to a
.threatmodeldirectory.Inspect available data model types and enum values used by the schema.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Threat Modeling MCP Server Threat model this project"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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:
Threat modeling phase or state management and prompt controlling.
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.
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
.threatmodeldirectory, 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
Install
uvxfrom Astral or the GitHub READMEuvx 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
autoApprovefor 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.shTo uninstall: ./install-kiro-agent.sh --remove
Local install (project-specific):
cp -r /path/to/threat-modeling-mcp-server/.kiro /path/to/your-project/.kiroUsage:
# 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-modelerWhat the agent includes:
System prompt (
.kiro/prompts/threat-modeler.md): Detailed instructions for the phased STRIDE methodologySkills (
.kiro/skills/): Per-phase reference materials, including optional Phase 7.5Auto-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. Passinclude_extended_data=Falseto 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 |
| Get comprehensive plan | Start here for overview |
| Get focused Phase 1 guidance | Recommended starting point |
| Check progress | Track completion status |
| Define business context and taxonomy profiles |
|
| Document and maintain assumptions | Start with |
| Manage components, data-store nodes, and connections | Start with |
| Assess and analyze threat actors | Use |
| Manage zones, crossings, and boundaries | Use |
| Manage assets and flows | Sections are |
| Manage threats, mitigations, links, and residual-risk decisions | Use |
| Record and report code-validation evidence | Start with |
| 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 |
| Business Context Analysis |
2 |
| Architecture Analysis |
3 |
| Threat Actor Analysis |
4 |
| Trust Boundary Analysis |
5 |
| Asset Flow Analysis |
6 |
| Threat Identification |
7 |
| Mitigation Planning |
7.5 |
| Guided Code Validation (Optional) |
8 |
| Residual Risk Analysis |
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:
Clone the repository
Create a virtual environment with
uv venvActivate it with
source .venv/bin/activate(Windows PowerShell:.venv\Scripts\Activate.ps1)Install the package and test dependencies with
uv pip install -e '.[test]'Run the server locally with
python run_server.pyRun 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 toolsadd_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
link_mitigation_to_threatB
Link a mitigation to a threat.
This tool links a mitigation to a threat in the threat model.
Args: ctx: MCP context for logging and error handling mitigation_id: ID of the mitigation to link threat_id: ID of the threat to link to
Returns: A confirmation message
Inputs: threat_id (required), mitigation_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
unlink_mitigation_from_threatB
Unlink a mitigation from a threat.
This tool unlinks a mitigation from a threat in the threat model.
Args: ctx: MCP context for logging and error handling mitigation_id: ID of the mitigation to unlink threat_id: ID of the threat to unlink from
Returns: A confirmation message
Inputs: threat_id (required), mitigation_id (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
Scored across 107 tools
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.
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.
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.
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
Related MCP Connectors
MCP server for static security analysis of Android source code
MCP server: static security scanner for MCP servers, agent skills & plugins. 17 attack patterns.
MEOK MCP Hardening MCP — automated security red-team for any MCP server. Maps OWASP LLM Top 10
One MCP server for all your MCP servers: code mode, per-tool permissions, approvals and audit.
Related MCP Servers
- AlicenseAqualityDmaintenanceUnified MCP server integrating NIST and OWASP security frameworks with live vulnerability data, enabling security searches, compliance mapping, threat modeling, and checklist generation.4114MIT
- FlicenseNot gradedqualityDmaintenanceMCP server for automated architectural mapping, security vulnerability detection, ML asset tracking, and code metrics in local repositories.-
- AlicenseNot gradedqualityBmaintenanceA lightweight MCP server for security reviews that injects security requirements before code generation, scans dependencies for CVEs, and verifies generated code without disrupting workflow.73MIT
- FlicenseNot gradedqualityDmaintenanceA 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.-