Qwen3-8B-SysMLv2

Qwen3-8B-SysMLv2 is a domain-adapted large language model fine-tuned from Qwen 3 (8B parameters) to understand, generate, and reason about SysML v2 textual models.
It bridges the gap between natural language system requirements and formal SysML v2 model syntax, enabling semi-automated model-based systems engineering (MBSE) workflows.

🚀 Overview

🎯 Purpose

Qwen3-8B-SysMLv2 is built to translate high-level system requirements into structured SysML v2 text, facilitating model generation, validation, and reasoning.
It’s especially suited for use in automated MBSE pipelines or AI-assisted engineering tools.

🧠 Capabilities

• ✅ Text → SysML v2 Generation
  Converts natural language system specifications into valid SysML v2 textual models.

• 🔁 Multi-Option Model Synthesis
  Produces multiple design alternatives (usually 2–3 structure options) per requirement prompt.

• 🧩 Error-Resilient Workflow
  Supports generation in JSON → SysML v2 format to minimize syntax errors.

• 🔍 SysML Reasoning
  Understands structure, behavior, and requirements interrelations within SysML models.

• 🧱 Toolchain Integration
  Designed to integrate with:

  • LangGraph for model flow orchestration
    
  • MCP (Model Composition Pipeline) for SysML diagram rendering
    
  • vLLM / Ollama for low-latency inference
    

🧩 Example Usage

🔹 Text-to-SysML Generation

Input:

Create a SysML v2 model of a warehouse system

The warehouse system must include a sensor array to monitor temperature and humidity, and an alert system that triggers when thresholds are exceeded.

Output

package WarehouseSystem {

    // Sensor Array Component
    part def SensorArray {
        attribute temperature : Real;        // in Celsius
        attribute humidity : Real;           // in percentage
        attribute location : String;
        
        // Data transmission mock method
        method transmitData {
            attribute dest: String;
            attribute data: String = format("Temp=%.2fC, Humidity=%.2f%%", temperature, humidity);
            // Mock transmission
            output transmittedData: String = data;
            return transmittedData;
        }
    }

    // Alert System Component
    part def AlertSystem {
        attribute temperatureThreshold : Real;  // in Celsius
        attribute humidityThreshold : Real;     // in percentage
        
        // Threshold check mock method
        method checkThreshold {
            attribute sensorData : SensorReading;
            return isWithinLimits: Boolean = 
                (Abs(sensorData.temperature - temperatureThreshold) <= 1) && 
                (Abs(sensorData.humidity - humidityThreshold) <= 5);
        }
        
        // Alert activation mock method
        method triggerAlert {
            attribute message : String;
            // Mock alert generation
            output alertGenerated : String = message;
            return alertGenerated;
        }
    }

    // Sensor Reading Data Type
    data def SensorReading {
        temperature : Real;        // in Celsius
        humidity : Real;           // in percentage
    }

    // Central Monitoring Server Component
    part def CentralMonitoringServer {
        port sensorPort {
            out sensorData : SensorReading;
        }
        port alertPort {
            out alertMessage : String;
        }

        // Process sensor data and send alerts
        method processData {
            in sensorData : SensorReading;
            out alertMessage : String;
            
            // Mock logic
            attribute tempDiff = Abs(sensorData.temperature - 20);  // Example threshold
            attribute humDiff = Abs(sensorData.humidity - 50);
            
            alertMessage :=
                if tempDiff > 3 {"High temperature alert!"} else {
                if humDiff > 10 {"High humidity alert!"} else {"All normal"}
            }
        }
        
        // Pipe data flow
        sensorPort.sensorData -> processData.sensorData;
        processData.alertMessage -> alertPort.alertMessage;
    }

    // Warehouse Dashboard Component
    part def WarehouseDashboard {
        // Simulated display of sensor data
        attribute displaySensorData : SensorReading;
        
        method updateDashboard {
            in newData : SensorReading;
            // Mock update logic
            displaySensorData := newData;
        }
    }

    // Stakeholder Notification Component
    part def StakeholderNotification {
        // Mock SMS/email sending
        method sendNotification {
            in message : String;
            return sentMessage : String = message;
        }
    }

    // Integration of System Parts
    part warehouseSystem {
        part sensorArray : SensorArray {
            location = "Cold Storage Zone";
            temperature = 12.5;
            humidity = 62;
        }
        
        part centralMonitoringServer : CentralMonitoringServer {
            processData = > return "High temperature alert!";
        }
        
        part warehouseDashboard : WarehouseDashboard {
            updateDashboard = > return sensorArray.transmitData();
        }
        
        part alertSystem : AlertSystem {
            temperatureThreshold = 10;
            humidityThreshold = 50;
        }
        
        part stakeholderNotification : StakeholderNotification {
            sendNotification = > return alertSystem.triggerAlert("Temperature exceeded safe limits!");
        }
        
        // Connections between components
        interface sensorInterface {
            end sensorEnd {
                out sensorData : SensorReading = sensorArray.transmitData();
            }
            end serverEnd {
                in sensorData : SensorReading;
            }
        }
        
        connect sensorInterface to centralMonitoringServer;
        
        interface alertInterface {
            end dashboardEnd {
                out alertMessage : String = warehouseDashboard.updateDashboard(sensorInterface.sensorEnd.sensorData);
            }
            end notificationEnd {
                in alertMessage : String;
            }
        }
        
        connect alertInterface to stakeholderNotification;
    }
}