A Unified Intelligent Framework for SysML Use Case Diagram Modeling and Verification

Highlights

Please indicate how your work links to systems science via your contributions to systems practice, theory, and/or methodology.

• This work brings together three complementary techniques so to better assist in the development of SysML Use Case Diagrams.
• Such intelligent modeling is enabled through rule-based verification, LLM-assisted natural language extraction, and hybrid Case-Based Reasoning.

What are the main findings and/or the implications of the main findings?

• Initial experiments indicate that the retained approach shows promising performance in detecting modeling violations and retrieving relevant cases.
• Future research and further evaluation of the approach will mainly focus on LLM extraction robustness, scalability and interoperability.

Abstract

The increasing complexity of systems within Model-Based Systems Engineering (MBSE) environments has made structured and reliable use case modeling critically important. Existing approaches to SysML Use Case Diagram modeling and verification remain fragmented, addressing generation, validation, or reuse in isolation. This paper presents UCDForge, a unified intelligent framework combining a rule-based verification engine, an LLM-assisted extraction pipeline, and a hybrid Case-Based Reasoning mechanism integrating pyCBR and myCBR for SysML Use Case Diagram modeling and verification. The verification module enforces structural, spatial, linguistic, and relationship rules against XML diagrams of the open-source toolkit TTool, while the generation module transforms natural language descriptions into standards-compliant diagrams through LLM extraction, hybrid CBR retrieval, and human-in-the-loop refinement. As an exploratory research contribution, the framework shows promising initial results in both violation detection and relevant case retrieval, suggesting its potential as a reliable and adaptive modeling assistant within MBSE environments.

1. Introduction

In the evolving landscape of engineering and complex systems, Model-Based Systems Engineering (MBSE) has emerged as a promising way forward for enhancing engineering design and architecture, where SysML serves as one of the main modeling languages and a backbone for modeling such systems [1].

In the context of designing complex systems, Use Case Diagrams (UCDs) hold significant value, especially during the early stages of modeling. The purpose of UCDs is to provide a high-level operational view of the functions performed by the system, which would be decomposed in later stages [2]. Since the overall quality of the model heavily depends on the structure and quality of the diagrams developed upfront, early-stage SysML models such as UCDs serve as the entry point and could greatly influence the downstream system architecture and design. In many cases, modelers who encounter problems during later stages are required to revisit the UCDs and refine them, resulting in increased cost, time, and development effort.

Since Systems Engineering involves multiple stakeholders and cross-disciplinary teams, there exists a greater margin for ambiguity if not modeled properly. Despite their seemingly simple appearance, UCDs pose challenges in maintaining coherence between different teams. Modelers often struggle with defining correct relationships, misuse of «include» and «extend» constructs, omit essential semantic rules, assign inconsistent names to actors and use cases, and leave dangling or unconnected elements [3,4]. Differences in individual interpretation further lead to misconceptions and inconsistencies [5], reducing the uniformity of the model and complicating collaboration, particularly when the diagram serves as a reference for further functional or architectural design.

The major cause of the problems stated above is the lack of a unified intelligent framework capable of guiding novice and experienced users in modeling UCDs while adhering to standard rules. It is essential that defects are detected and removed before they propagate to subsequent development phases, where their detection and removal become more expensive [6]. The growing complexity of systems, combined with extensive documentation and long requirement specifications, do not adequately account for human cognitive limitations. Expecting individuals to absorb large volumes of information and process it accurately increases the likelihood of errors and inconsistencies.

The goal of this paper is to present some exploratory research that was done with the aim to progress and cover these issues step by step. Similarly to the approach presented in [7], a combination of different techniques was made to address the identified issues. In this case, rule-based reasoning, large language model (LLM)-assisted extraction (e.g., see [8]), and case-based reasoning (CBR) were selected and were combined in an experimental tool, UCDForge, that will be presented in this paper. The overall aim was to support both verification of existing models and the generation of new use case diagrams from natural language descriptions of systems. With this in mind, rule-based reasoning was selected for its possibilities to implement confirmed knowledge in the form of rules. The use of CBR was investigated so as to be able to learn from previous designs (in our case, UCDs). And LLMs were selected so as to build upon their capacities to extract knowledge. Without loss of genericity, in this work, SysML use case diagrams are represented using TTool1, an open-source SysML modeling environment that stores models in an XML-based format and supports model creation. With the arrival of SysML V22, that has a defined textual notation, this opens up possibilities for the future to move from XML to the new SysML V2 notation and make such features available for other tools as well. The novelty in this paper lies therefore in the combination of three complementary techniques to better support the development of use case diagrams.

The paper is organized as follows. Section 2 presents the background and related work, covering use case diagram modeling, case-based reasoning, and existing approaches along with their limitations. The overall system architecture, experimental setup, and knowledge base design are presented in Section 3. The modular architecture of UCDForge, including both the generation and verification workflows, is also detailed in this section. Representative case studies are presented in Section 4, followed by results and a discussion in Section 5. Finally, Section 6 concludes the paper and outlines directions for future work.

2. Related Work

This section aims at laying the foundations for the work presented in this paper, presenting briefly the underlying techniques, and positioning the work with respect to others in the field, seeing how they addressed the identified challenges while highlighting the major takeaways and limitations that remain to be addressed.

This section starts with Use Case Diagrams and their modeling challenges, explaining why intelligent assistance is needed. Case-Based Reasoning is then introduced as a foundational concept, as it underpins a core component of the proposed framework. The subsequent subsections briefly review existing approaches by category: rule-based, NLP-based, pattern-driven, LLM-based, and knowledge-driven, allowing for a better understanding on the limitations of each approach.

2.1. Use Case Diagrams and Challenges in Modelling Use Case Diagrams

Use case diagrams (see Figure 1 for an example) capture the actions a system performs to deliver observable value to its actors, along with interactions between actors and use cases and relationships among use cases themselves [9]. Table 1 presents the symbols used by use case diagrams.

Figure 1. Use Case Diagram.

Table 1. Legend for the Use Case Diagram.

Serial Number	Remarks/Definitions
1	Human Actor (Stickman): Represents a human user interacting with the system. Human actors are depicted using the standard SysML/UML stickman notation.
2	Non-Human Actor (<<Actor>>): Represents an external system, device, or non-human entity interacting with the system. These actors are represented using a rectangular box with the <<Actor>> stereotype.
3	Association (Line): A solid line connecting an actor to a use case, representing participation or interaction with the system functionality.
4	Use Case (Oval): Represents a functional service, capability, or behavior provided by the system to achieve a specific objective for an actor. Use cases are depicted using oval notation.
5	Include (<<include>>): A directed dependency indicating mandatory behavior that is always executed as part of another use case.
6	Extend (<<extend>>): A directed dependency indicating optional or conditional behavior that extends a base use case under specific circumstances.
7	Actor Generalization: Represents inheritance between actors, where a specialized actor inherits the behavior and associations of a more general actor.
8	Use Case Generalization: Represents inheritance between use cases, where a specialized use case inherits the behavior of a generalized use case.
9	System Boundary (Rectangle): Defines the scope of the system and encloses all use cases that belong to the system being modeled.

As one of the most widely used behavioral diagrams in SysML and UML, UCDs provide a high-level functional and operational view of the system, helping stakeholders understand the expected system behavior. Although UCDs appear simple, constructing structurally and semantically correct diagrams remains a challenge. Manual modeling frequently results in missing actors, duplicate use cases, relationship misuse, and inconsistent system boundaries, challenges that become more prominent in large-scale MBSE projects involving multiple stakeholders and evolving requirements, emphasizing the need for intelligent assistance during the modeling process. These challenges can be broadly categorized as follows:

• Structural and semantic correctness, ensuring that all elements are properly connected, positioned, and that relationships such as «include» and «extend» are correctly applied.
• Naming consistency across actors and use cases, especially in multi-stakeholder environments.
• Maintaining model coherence and uniformity across teams and within the same architecture.
• Generating UCDs that adhere to SysML standards while meeting modeler and stakeholder expectations.
• Transforming natural language descriptions and large documents into complete, standards-compliant UCDs efficiently.

2.2. Case-Based Reasoning (CBR)

Case-Based Reasoning is a problem-solving paradigm that solves new problems by retrieving and adapting solutions from previously solved similar problems [10]. Unlike rule-based systems that rely on a fixed set of predefined logic, CBR learns from experience - the more cases it has seen, the wider the knowledge base becomes. This makes it particularly well suited for domains where expert knowledge is difficult to formalize, but historical examples are available. In our case, the idea is to learn from previous designs of UCDs.

As shown in Figure 2, the CBR cycle consists of four stages, commonly referred to as the 4Rs:

Figure 2. CBR Cycle [10].

• Retrieve: Given a new problem, the system searches the case library and retrieves the most similar past cases based on a similarity measure.
• Reuse: The solution from the retrieved case is proposed as a candidate solution for the new problem.
• Revise: The proposed solution is evaluated and refined to better fit the new problem.
• Retain: Once the solution is validated, the new problem solution pair is stored back into the case library, expanding it for future use.

2.3. Rule-Based Verification Techniques

Rule-based reasoning techniques are one of the most interpretable and straightforward approaches for diagram verification. These approaches have predefined rules and constraints that are applied to enforce and validate semantic, syntactic, and structural correctness and integrity.

Aquino et al. [3] propose a methodological assistant that relies on formalized rules for the SysML use case diagram that integrates a priori and a posteriori support. In the a priori phase, the methodological assistant guides the users to identify the UCD elements, supporting the construction of the model where a graph is drawn to visualize the elements and their relationships. In the latter phase, the software helps verify the UCD to ensure that all elements adhere to the enforced rules and guidelines, explicitly identifying errors and inconsistencies. However, this software only provides assistance and is not capable of supporting fully automated generation of UCD within the modeling environment. The authors highlight the need for increased automation and suggest the use of Case-Based Reasoning (CBR).

Similarly, Alanazi [11] introduces a rule-based framework where a set of 15 rules is defined for different UML diagrams, including UCDs as well, to help users build a well-structured diagram. The approach defines well-thought-out rules, but these rules still have to be applied manually, and there are no automated verification means, making it solely dependent on manual enforcement.

An interesting approach undertaken by El-Attar and Miller [12] integrates rule-based consistency and diagram generation through reverse engineering of use case descriptions. The authors introduce SSUCD (Simple Structured Use Case Description) capable of generating UCDs from semi-structured textual descriptions while maintaining consistency between diagrams and their descriptions. To support this, lightweight formal constructs such as INCLUDE, ABSTRACT, and SPECIALIZES are introduced to improve machine readability while remaining natural language friendly. The software also supports reverse generation of description skeletons. Nevertheless, the framework remains heavily dependent on manually authored descriptions and predefined structural keywords, limiting semantic flexibility and adaptability.

2.4. NLP-Based Diagram Generation Approaches

Alksasbeh et al. [13] propose an automated UCD generation approach using Natural Language Processing (NLP) techniques such as POS tagging, tokenization, stemming, and semantic analysis to extract UCD elements from natural language requirements. Although the approach effectively supports use case diagram generation, it relies mainly on predefined heuristic and linguistic rules, making it heavily dependent on sentence structure and correctness. Furthermore, the software lacks verification mechanisms to evaluate the correctness of generated UCDs and primarily focuses on automated generation rather than intelligent validation or adaptive methodological assistance.

Similarly, Dias et al. [14] propose an NLP- and Machine Learning (ML)-based approach for UCD generation, using the strengths of both techniques to generate UML use case diagrams, with the objective of fully automating the process and potentially replacing manual and semi-automated UCD generation approaches. In addition to conventional NLP techniques, the approach integrates mechanisms such as Word Sense Disambiguation and Anaphora Resolution to improve extraction accuracy and reduce ambiguity. Although the work demonstrates improved extraction capabilities and enhanced diagram generation accuracy, it mainly focuses on extraction and automated UCD creation rather than intelligent validation or adaptive methodological guidance. Furthermore, support for advanced use case relationships and deeper semantic verification remains limited.

Addressing the challenges involved in manually generating UML diagrams from textual requirements, Sharma et al. [15] develop an approach to generate activity and sequence diagrams from natural language using lexical and syntactic analysis together with Grammatical Knowledge Patterns (GKP). The framework forms intermediary structured representations known as frames to capture actors, actions, preconditions, and interactions before diagram generation. Although the approach provides flexibility without strict input structures, the correctness and semantic reliability of the generated models remain a concern, and the framework is limited to activity and sequence diagrams.

2.5. Model Quality and Pattern-Driven Approaches

Heuristic and pattern-driven approaches aim to improve the quality of use case diagrams by identifying recurring modeling patterns, structural inconsistencies, ambiguities, and common bad design practices. Instead of relying entirely on strict formal verification methods, these approaches make use of predefined heuristics, quality patterns, and guided inspection techniques to assist analysts in detecting potentially problematic or poorly modeled constructs within use case diagrams.

Miller et al. [16] propose a methodology that uses Object Constraint Language (OCL)-based anti-pattern matching and heuristic inspection techniques to identify potentially defective, ambiguous, inconsistent and poorly designed areas within UCDs, supported by a tool named ARBIUM. The approach is mainly oriented towards identifying bad modeling practices such as duplicated behaviors, relationship misuse, and improper associations to keep the model consistent and understandable. However, the methodology depends on strictly predefined anti-pattern and mainly targets diagrammatic quality rather than the semantic validation.

Bhatnager et al. [17] propose a framework for assessing and evaluating the complexity of multiple SysML models, including UCDs, through metrics such as Use Case Points (UCP), actor/use case weights and cyclomatic complexity to measure model complexity and development effort within MBSE environments. The methodology is further supported through a Java-based automated evaluation tool to compute the complexity of the model. The authors observe a pattern that increasing model complexity negatively impacts the model’s maintainability, understandability, and visualization. The work focuses mainly on assessing the complexity but does not offer any corrective measures or methodological guidance for properly restructuring the model.

2.6. LLM-Based and Intelligent Modeling Assistance Approaches

Within the framework of this research project, intelligent and AI-driven approaches have been investigated so as to further enable automation with as aim to minimize human intervention, making it easier for users to perform modeling activities without worrying extensively about the semantic and structural aspects of the diagrams.

An empirical study on the use of LLMs for generating SysML behavioral models was conducted by Wang et al. [8]. The work evaluates the generation capability of different LLM models in generating SysML Activity, State Machine and Sequence Diagrams while also analyzing hallucinations from syntactic and semantic perspectives. In order to preserve model quality, the authors introduce model-checking rules, Retrieval-Augmented Generation (RAG)-supported prompts and feedback-driven regeneration mechanisms. Although the authors observe promising capabilities of LLMs in generating such diagrams, deeper semantic correctness and consistency still remain a challenge. Furthermore, the work primarily focuses on SysML Activity, Sequence, and State Machine Diagrams and does not extensively address Use Case Diagrams.

In another work presented by Schleifer et al. [18], the authors propose language model-based pipelines for the automatic generation of Use Case Diagrams (UCDs) from natural language requirements with minimal dependency on annotated datasets. The approach combines NLP techniques and Large Language Model (LLM)-based prompting strategies to identify actors, systems and use cases from heterogeneous industrial requirements and generate corresponding diagrams. A notable contribution of the work is the reduction of rigid preprocessing steps and handcrafted transformation rules through intelligent prompting mechanisms. Nevertheless, the framework remains primarily focused on automated generation and exhibits limitations in model verification, since the adherence of the model to rules is not strictly checked by a dedicated module.

García Alarcia et al. report a potential application of LLMs in systems engineering, to obtain sets of requirements for a particular problem [19]. The sources are constituted by textual documents. The adequacy of such approaches is assessed in the paper. Looking at metrics traditionally employed to evaluate the similarity of LLM-generated artifacts, the result does not turn out to perform well for requirements. Other publications suggest similar issues, and alternative approaches are being studied.

2.7. Knowledge-Driven Approaches

Knowledge-driven approaches mainly focus on utilizing previously stored knowledge, reusable design artifacts, ontologies, semantic relationships and reasoning mechanisms to assist modeling activities. These approaches attempt to improve modeling efficiency, consistency, and reuse by retrieving and adapting knowledge from previously developed models and design cases.

Gomes et al. [20] propose a CBR framework for UML design that mainly utilizes the reuse and retrieval phases of the CBR cycle to adapt previously developed diagrams to new problems. The software contains a case library indexed using WordNet ontology and synset-based similarity, enabling semantic retrieval across UML objects and relationships. Verification mechanisms are incorporated to check object names, relations, attributes, and methods, thereby preserving consistency and correctness. While the framework demonstrates the application of CBR for UML design reuse, it does not fully utilize the complete CBR cycle to its full advantage and the scope remains limited to UML class diagrams rather than SysML use case modeling or adaptive intelligent verification potential.

Similarly, myCBR [21] is a symbolic Case-Based Reasoning engine that represents domain knowledge using taxonomies, similarity measures, and weighted attributes to support interpretable retrieval. The framework is widely applicable in model-driven engineering environments where diagram elements possess hierarchical relationships and structured semantics. In this paper, myCBR is integrated through its Java REST API using attributes such as system names, actors, use cases, and domain classifications. The framework relies primarily on lexical and structural similarity through attribute-based and string-level matching, but lacks deeper semantic and contextual reasoning capabilities.

2.8. Limitations of Existing Methods

Despite significant progress in rule-based, NLP-driven, heuristic, LLM-based, and knowledge-driven approaches, most existing works address isolated aspects of SysML use case diagram modeling rather than providing an integrated framework. Rule-based approaches offer structural validation but limited adaptability, while NLP and LLM-based methods improve generation capabilities without robust verification support. Heuristic and metric-driven methods focus mainly on evaluation, while CBR-based approaches support retrieval and reuse, but lack deeper contextual reasoning and integrated verification. Consequently, no existing solution simultaneously supports generation, validation, semantic correctness checking, adaptive guidance, and consistency management for SysML use case diagrams within MBSE environments. In this work, the goal was to see if the use of multiple methods, each for a specific contribution, could bring a solution. In the proposed approach, rule-based verification, LLM-assisted extraction, and hybrid CBR retrieval were brought together into a unified intelligent framework for SysML UCD modeling. It should be noted that it concerns an exploratory research project; its limitations and associated directions for future research have been identified at the end of the paper.

3. Proposed Approach

To address the challenges mentioned in the previous section, this paper introduces UCDForge, a unified intelligent framework for SysML use case diagram generation and verification. The framework consists of two interconnected modules: a generation workflow that transforms system descriptions into structured use case diagrams using LLM-assisted extraction and hybrid Case-Based Reasoning, and a verification workflow that evaluates existing diagrams using structural, semantic, and linguistic validation rules. Together, these modules provide guided support for both model construction and quality assessment within MBSE environments.

3.1. Experimental Setup and Data Collection

UCDForge is implemented in Python version 3.10 with a Streamlit3-based web interface that supports interactive generation and verification workflows for both modules. XML model data is processed using ElementTree4, while natural language processing is supported through spaCy5, NLTK6, and Flair7 for grammatical and structural analysis. A MySQL knowledge base managed through PyMySQL8 supports case storage, retrieval, and reuse within the generation workflow.

To support the Case-Based Reasoning capabilities of UCDForge, a structured knowledge base containing more than 50 validated use case diagrams was developed from academic publications, public modeling examples, and engineering case studies. Each case stores core modeling elements including system names, actors, use cases, relationships, and domain information. For hybrid retrieval, cases are represented in both semantic and symbolic forms using precomputed embeddings and structured attributes, allowing UCDForge to retrieve semantically related and structurally similar diagrams during generation.

UCDForge includes a session persistence mechanism that allows designers to save and restore the workflow state at any stage of the generation process, supporting interrupted and iterative modeling activities without restarting the workflow. Sessions are stored using a dedicated UCDForge XML format that preserves system descriptions, extracted elements, relationships, retrieval outputs, workflow progress, and the previously generated TTool XML file. During restoration, the saved session is parsed and reloaded into the wizard, allowing users to resume partially completed modeling tasks while preserving all intermediate work.

3.2. Modular System Architecture

UCDForge follows a modular architecture designed to separate generation and verification workflows into interconnected system components. This modular structure improves scalability, maintainability, and workflow organization while allowing each component to operate within a unified modeling environment. The overall system combines Natural Language Processing, Large Language Models, Case-Based Reasoning, and rule-based verification techniques to support intelligent use case diagram generation and verification.

3.2.1. Generation Module

The generation module serves as the primary intelligent modeling component of UCDForge. Its objective is to transform unstructured system descriptions into structured use case diagrams through a guided and semi-automated workflow.

User Input

The module accepts multiple forms of input including plain text descriptions, PDF documents, and previously developed UCDForge custom modeling files serialized in XML format. Once the input is received, pre-processing operations are applied to normalize and extract textual content before forwarding the information to the Large Language Model for extracting relevant modeling elements.

LLM Extraction Pipeline

The extraction pipeline is responsible for transforming pre-processed system descriptions into modeling elements required for drafting use case diagrams. During this stage, the Large Language Model analyzes the input text to identify the system name, primary actors, secondary actors, use case, domains, and potential relationships between modeling components. These extracted elements are displayed to the user for review and refinement.

To support different deployment environments and computational constraints, UCDForge integrates two interchangeable Large Language Model execution strategies consisting of cloud-based inference and local offline inference.

The cloud-based mode uses Google’s Gemma 3 27B model9 through the Google Generative Language REST API10, providing strong contextual reasoning and efficient processing of complex engineering descriptions without requiring high-performance local hardware. On the other hand, local inference is supported through LM Studio11 using OpenAI12-compatible endpoints, where models such as Mistral 7B can be executed directly on the user’s machine. This supports offline processing, improved privacy, and secure handling of sensitive engineering data. Together, these deployment options allow UCDForge to operate across research and industrial environments with different privacy, infrastructure, and computational requirements.

The extraction workflow as shown in Figure 3 applies different processing strategies depending on the size of the input document. Smaller textual inputs are processed through direct extraction using a single inference request. For moderately sized engineering documents, the software applies a Recursive Refine strategy in which overlapping document sections are processed iteratively, with partial extraction results forwarded across stages to preserve contextual continuity and progressively refine extracted modeling elements. For very large engineering specifications, a semantic RAG-based condensation stage is applied prior to Recursive Refine processing, where document sections are embedded, ranked by modeling relevance, and filtered before iterative extraction to reduce unnecessary context while preserving modeling-relevant information.

Figure 3. Extraction workflows for different document sizes: (a) Direct extraction for small sized documents, (b) Recursive refine strategy for medium sized documents and (c) Semantic RAG-based condensation for large and very large documents.

The intermediate JSON representation output from LLM is forwarded to the hybrid CBR workflow, where the extracted modeling elements are used to retrieve similar use case diagram artifacts from the knowledge base for generation support.

3.2.2. Hybrid Case-Based Retrieval

After the extraction stage, the identified modeling elements are passed to the hybrid Case-Based Retrieval module. This module improves the quality of generation by finding previously validated use case diagrams that are structurally or semantically similar to the current system description. Instead of depending only on direct language model generation, the software reuses past engineering knowledge stored in the UCDForge knowledge base.

The retrieval workflow combines two complementary reasoning strategies consisting of semantic retrieval (pyCBR) and symbolic retrieval (myCBR). This hybrid approach allows the software to identify both conceptually related cases and structurally similar cases, even when different terminology or naming conventions are used across system descriptions. Both retrieval workflows are executed in parallel, and their outputs are merged to produce a unified ranked list of candidate cases for user selection. By default, the highest ranked case is automatically selected as the primary reference case for the subsequent generation workflow.

The semantic retrieval component is implemented using pre-trained sentence transformer embedding models. Paragraph-level embeddings are generated using BAAI/bge-large-en-v1.513, while shorter embeddings are generated using all-mpnet-base-v214. During extraction, system descriptions, actors, use cases, and domain information are converted into vector embeddings and compared against stored knowledge base cases using cosine similarity. Semantic comparisons are performed across system names, descriptions, actors, use case, and domain representations to identify conceptually relevant use case diagrams.

To improve retrieval robustness, semantic similarity is complemented by lexical similarity and synonym expansion. Jaccard similarity and predefined synonym repositories reduce sensitivity to vocabulary variation and inconsistent naming.

Weighted similarity scoring is applied across multiple modeling attributes, including titles, descriptions, actors, use case, and domains. The weighting configuration was refined through engineering judgment and iterative retrieval evaluation during system development, with primary emphasis placed on use case similarity since it most directly represents system functionality and behavioral intent.

Query and candidate use cases are compared using a symmetric one-to-one matching strategy based on cosine similarity as shown in Figure 4. Each use case is paired with its most similar unmatched counterpart in both directions, and the final similarity score is computed as the average of the forward and backward matching scores. Once matched, use cases are excluded from further assignments, while unmatched elements contribute zero similarity during score aggregation. This approach penalizes unmatched functionality and favors cases with balanced functional similarity.

Figure 4. Symmetric one to one semantic matching process used for forward and backward use case similarity evaluation during hybrid retrieval.

Actor similarity was also assigned significant influence because actor interactions contribute strongly to behavioral interpretation and system usage context during retrieval, and were computed using a similar similarity evaluation process. The similarity of the domain and description was assigned moderate influence to support contextual relevance during retrieval. Lower weights were assigned to system name similarity and lexical similarity since these attributes are more sensitive to naming variation and contribute less to overall modeling correspondence. This weighted scoring strategy improves retrieval accuracy by prioritizing modeling elements with greater functional significance.

The symbolic retrieval component runs in parallel through the myCBR framework as shown in Figure 5. Historical use case diagram cases from the UCDForge knowledge base are exported into a myCBR project structure, where each case is represented as a collection of string, symbol, and numeric attributes covering system names, descriptions, actors, use cases, domains, relationship categories, and structural element counts. System names are compared using trigram similarity, while system descriptions are evaluated using Jaro-Winkler similarity to capture partial lexical similarity.

Figure 5. Overall hybrid Case-Based Retrieval workflow combining semantic retrieval (pyCBR), symbolic retrieval (myCBR) and result integration.

Actor names, use case labels, domain descriptors, and relationship types are stored as symbol attributes. Rather than storing these as separate entries, values belonging to the same attribute category are concatenated into combined textual descriptors.

During retrieval, the myCBR engine compares these descriptors between the query and stored cases using symbolic equality matching, allowing broader structural and lexical comparison rather than fine-grained element-level matching.

Structural features including primary actor count, secondary actor count, use case count, and relationship count are stored as numeric attributes and evaluated using a polynomial difference function. During retrieval, query elements are converted into a flat attribute map and sent to the myCBR REST engine, where local similarity scores are computed and merged into a final relevance score using a weighted amalgamation function. Greater weight is assigned to use case and actor attributes to align with the priorities of the semantic retrieval workflow.

Although semantic retrieval focuses on contextual similarity through embeddings, symbolic retrieval emphasizes structural and lexical correspondence, making it effective for identifying cases with similar modeling patterns. Once both retrieval workflows complete, the pyCBR and myCBR engines independently produce ranked candidate cases that are displayed side by side in the interface. The highest-scoring case is pre-selected by default, while users may review both ranked outputs and select the most suitable case before proceeding to case adaptation.

3.2.3. Case Adaptation and Suggestion Refinement

After a case is selected during retrieval, the software performs case adaptation to refine the extracted modeling elements using information from the selected knowledge base case. The workflow compares user-extracted actors and use cases with their corresponding elements in the retrieved case.

Semantic similarity between labels is computed using sentence embeddings generated with all-mpnet-base-v2. A sentence embedding is a dense numerical vector representation that captures the semantic meaning of a text label, enabling similarity to be measured based on meaning rather than exact lexical matching. If a user-supplied label is sufficiently similar to a knowledge base label, the knowledge base label is suggested as a normalized alternative. Original user labels are never automatically replaced and remain unchanged unless the user explicitly accepts the suggestion.

Following label mapping, relationship definitions are updated using the generated mappings to preserve naming consistency across the adapted diagram. The software then identifies actors, use cases, and relationships from the retrieved case that are not already present in the user session and prepares them as reusable suggestions.

These suggested elements are presented as optional recommendations within the interface. Users may accept individual or all suggestions, or continue using only the originally extracted elements. Existing user elements are not removed or overwritten during this process. This suggestion-based adaptation strategy improves modeling consistency and reuse while preserving user control over the final use case diagram structure.

3.2.4. User Review, Refinement and Relationship Definition

Following case adaptation, the extracted elements are presented to the users for validation or any refinement if needed before proceeding further. Users can make changes as needed and may review, modify, add, or remove actors, use cases, and inferred relationships to improve the correctness and completeness of the model. This stage follows a human-in-the-loop strategy, where the final diagram structure remains under user supervision before proceeding to relationship definition and automatic generation.

After the review stage, users define and validate the relationships between actors and use cases before final diagram synthesis. The workflow supports association, include, extend, actor generalization, and use case generalization relationships, where relationships inferred during the LLM extraction stage are pre-loaded as initial suggestions for user review and refinement. Association relationships define interactions between actors and use cases, include relationships representing mandatory behavior, extend relationships capture optional conditional behavior, and generalization relationships represent inheritance between specialized and generalized modeling elements. Users may further add, modify, or remove relationships to improve structural correctness and modeling completeness before proceeding with generation. Extension relationships also support optional condition descriptions during relationship definition.

Basic structural consistency checks are enforced during the editing process to preserve SysML compliance and prevent invalid relationship configurations. In addition, the evolving model is continuously validated using the UCDForge verification engine, which evaluates the diagram against the implemented SysML use case modeling rules covering structural, spatial, linguistic, and relationship constraints. By detecting and reporting violations before export, the framework helps ensure that the resulting model remains compliant with the enforced SysML use case diagram semantics. Relationships such as include and extend cannot coexist between the same pair of use cases, while invalid self-referencing generalization relationships are automatically rejected.

3.2.5. Diagram Export, Verification and Knowledge Base Retention

After the relationship definition stage, confirmed modeling elements are converted into a TTool-compatible XML representation of the SysML v1 use case diagram. The generated XML additionally contains a reference diagram panel from the selected knowledge base case for direct comparison within TTool. Automatic verification is then performed, covering naming consistency, connectivity, relationship correctness and diagram arrangement, with findings reported as warnings and errors embedded within the XML file.

Beyond TTool XML, the workflow generates SVG representations alongside PlantUML-based SysML v1 and SysML v2 textual notations. The use of both TTool and PlantUML is intentional because they serve different purposes within the workflow. TTool XML provides a complete machine-readable representation that preserves the semantics of the model, structural information, and verification results, enabling subsequent analysis, validation, and model restoration. In contrast, PlantUML offers a lightweight textual notation that facilitates visualization, documentation, version control, and interoperability with external tools and development environments. The use of these two representations does not introduce methodological redundancy or additional modeling effort since both exports are automatically generated from the same internal model. Consequently, TTool supports formal analysis and model preservation, whereas PlantUML supports communication, collaboration, and exchange, providing complementary capabilities within the multi-format export framework. UCDForge additionally supports export through a custom session XML format for later restoration and refinement. Figure 6 presents the multi-format export and verification workflow adopted within UCDForge.

Figure 6. Multi-format diagram export and verification workflow used for generating validated SysML representations within UCDForge.

Users may optionally retain the finalized case within the knowledge base, storing embeddings, modeling elements, relationships, PlantUML notation, and the generated TTool XML for future hybrid retrieval, thereby completing the Case-Based Reasoning cycle.

3.3. Verification Module

In addition to the semi-automated generation workflow, UCDForge provides a dedicated verification module for analysing SysML v1 use case diagrams represented in the TTool XML format. The verification workflow allows users to upload previously created diagrams and evaluate their structural correctness, naming quality, connectivity, spatial arrangement, and relationship consistency through a guided multi-stage verification process.

3.3.1. File Upload and Pre-Verification

The verification workflow begins with the upload of a TTool compatible XML file containing one or more SysML v1 use case diagram panels. The software parses the XML structure to extract the core modeling elements, including the system boundaries, actors, use cases, spatial coordinates, and relationship definitions. During parsing, diagram panels are identified, modeling elements are classified according to their corresponding TTool component types, and connector relationships are resolved into association, include, extend, and generalization categories.

Before detailed verification begins, an initial structural integrity check ensures that each diagram panel contains exactly one system boundary together with at least one actor and one use case. Panels that do not satisfy these minimum structural requirements are excluded from further analysis. After successful extraction, the verification engine executes linguistic, structural, connectivity, and relationship verification operations in a pre-computation stage. The generated findings are then cached within the session to avoid repeated execution in later verification steps. The interface finally presents a summary of the extracted diagrams and identified modeling elements before detailed analysis begins.

After XML extraction and pre-verification, the workflow performs verification across system boundaries, actors, use cases, connectivity, and relationships. Linguistic analysis uses spaCy, WordNet, and NLTK, with context probing applied to improve the parsing reliability for short labels. Verification evaluates naming quality, grammatical correctness, semantic ambiguity, and casing consistency, while semantic similarity is computed using the all-MiniLM-L6-v215 embedding model.

Structural verification detects misplaced boundaries and isolated elements, while relationship verification validates association, include, extend, and generalization links through direction and compatibility checks. A human-in-the-loop review stage allows designers to confirm or correct detected relationships, with findings reported together with corrective guidance. The set of verification rules implemented by UCDForge is detailed in Table 2.

Table 2. Implemented Verification Rules within the UCDForge Verification Engine.

Rule ID	Category	Rule Description
R1	Actor Rules	Each use case must be associated with at least one actor.
R2	Actor Rules	Actor names must be unique, singular, and represent clearly defined noun roles.
R3	Use Case Naming	Use case labels must be meaningful, non-empty, non-duplicated, and follow a Verb + Noun structure.
R4	Relationship—Include	Include relationships must connect valid use cases, where the included use case always executes as part of the base use case.
R5	Relationship—Extend	Extend relationships must connect valid use cases, where the extending use case represents optional behaviour attached to a valid base use case.
R6	Relationship—Generalization	Generalization relationships must occur only between compatible element types.
R7	Directionality	Relationships must follow valid UML directional semantics.
R8	Reversal Suggestion	Semantically reversed relationship directions are identified and corrective reversal suggestions are generated.
R9	Dangling Nodes	Actors or use cases without valid connections are treated as incomplete modeling elements.
R10	Extension Point Text	Extension condition text must be grammatically correct and follow title casing conventions.
R11	Missing Connectors	Actors and use cases without required connectors are flagged during verification.
R12	Invalid Source–Target Pair	Invalid relationship combinations between incompatible element types are rejected.
R13	Unclassified Connectors	All connectors must be classified as Include, Extend, Generalization, or manually reviewed by the user.
R14	Grammar Rules	Use case labels must satisfy grammatical correctness and spelling validation checks.
R15	Plurality Rule	Actor names must remain singular nouns, while use case object nouns may appear in singular or plural form.
R16	Naming Convention	Actor and use case labels must follow Title Case formatting conventions.
R17	Article Formatting Rule	Articles such as “a”, “an”, and “the” must remain lowercase within use case labels.
R18	Actor Naming Rule	Actors must represent generic roles rather than proper nouns or named entities.
R19	Duplicate Association Avoidance	Redundant actor associations with included sub-use cases are discouraged unless independently initiated.
R20	Notation Rules	Human actors use UML stickman notation, while non-human actors use the <<Actor>> stereotype notation.
R21	System Boundary Rule	Use cases must remain inside the system boundary while actors remain outside the boundary region.

3.3.2. Verification Results and Recommendations

Once all verification stages are completed, the findings are aggregated into a unified analysis report that covers all UCD panels in the uploaded TTool SysML v1 XML file. The results are presented through summary and detailed views, grouping findings by severity and modeling category, including system boundaries, actors, use cases, and relationships. Each finding includes the affected element, diagnostic explanation, and severity classification, while semantically similar element pairs are duplicated to reduce redundant reporting.

After reviewing the results, the designer can export a verification-annotated TTool SysML v1 XML file. Verification findings are embedded as grouped activity diagram panels appended to the XML without altering the original diagram structure. Each issue is represented together with diagnostic information and corrective guidance, allowing the exported file to be directly reviewed within TTool alongside the original use case diagram.

4. Case Study

This section presents a walkthrough of the integrated framework through representative case studies for each module. Together, these cases cover the two primary usage scenarios of the framework and demonstrate its effectiveness. The module is demonstrated using a Cab Booking Application UCD.

4.1. System Description, LLM Extraction, and Hybrid CBR Retrieval

The generation workflow was initiated using a plain English description of a Cab Booking Application containing intentional spelling mistakes and ambiguities to simulate realistic user input conditions. After pre-processing, the description was forwarded to the LLM extraction pipeline, which identified the system name, actors, use cases, relationships, and domains without requiring formal modeling constructs from the user.

The hybrid CBR engine queried the knowledge base in parallel using pyCBR and myCBR, displaying both engines’ top matches side by side. The Cab Booking Application was returned as the top pyCBR match with a confidence score of 0.7371. Several cases appeared as common matches across both engines, indicating strong semantic and structural relevance. pyCBR consistently produced more relevant matches through semantic embedding similarity, while myCBR provided complementary symbolic retrieval through string-based matching.

4.2. Element Editing, CBR Suggestions, and Output Generation

Following case selection, CBR-suggested and LLM-extracted elements were merged and presented to the user for review, where actors, use cases, and relationships could be accepted, discarded or modified. This corresponds to the Reuse and Revise phases of the CBR cycle. Upon finalization, the software generated TTool XML, PlantUML, and SysML v2 notation from a unified internal representation, with an SVG preview rendered directly within the interface for visual inspection before export, as shown in Figure 7.

Figure 7. SVG Preview of Generated Cab Booking Application Use Case Diagram.

The generated TTool XML was subsequently evaluated using the verification module before being made available for export. The finalized diagram was then retained within the knowledge base, completing the retain phase of the CBR cycle. The reproduced TTool diagram shown in Figure 8 demonstrates that a plain English system description containing spelling mistakes and ambiguities can be transformed into a standards-compliant SysML Use Case Diagram through the proposed methodological framework.

Figure 8. Reproduced TTool Diagram—Finalized Cab Booking Application UCD.

The verification module was evaluated using a Satellite Operation System Use Case Diagram intentionally injected with structural, spatial, linguistic, and relationship errors to simulate common modeling mistakes.

4.3. XML Parsing and Element Extraction

The uploaded TTool XML file as shown in Figure 9 was automatically parsed, allowing the software to extract the actors, use cases, and connectors along with their associated spatial and structural data. Following extraction, the verification results for all categories were generated in advance, allowing users to navigate between verification stages without reprocessing the diagram.

Figure 9. Actor and Use Case Verification Results—Satellite Operation System.

The following modeling errors were deliberately introduced during evaluation. Actor-related issues included ambiguous naming (“Magesh”), the use of a verb as an actor name (“Repair”), incorrect title case formatting (“project engineer”), placement of an actor inside the system boundary (“Safety Engineer”), and duplicate actor naming (“Payload Operator”). Use case related errors included invalid naming structures such as non-verb beginnings (“Storage Module Recorder”), spelling errors (“Get Payload Status”), incorrect spatial placement outside the system boundary (“Store Power”), and semantic inconsistencies (“Send Stored Command”). Relationship-level errors included the incorrect use of include relationships where generalization relationships were more appropriate. Each actor and use case was evaluated against the enforced rules, with results colour-coded by severity as shown in Figure 10, and all deliberately introduced errors were successfully identified with the corresponding verification feedback.

Figure 10. Use Case Verification Results—Satellite Operation System.

The relationship validation stage analyzed the extracted connectors, identified potential relationship inconsistencies, and presented the results for user confirmation. The observed results are shown in Figure 11. The correction-annotated TTool XML was exported and opened within the TTool environment, where verification findings remained accessible alongside the original diagram, as shown in Figure 12.

Figure 11. Final Verification Results—15 Errors and 9 Warnings Detected.

Figure 12. Corrected UCD After Applying Verification Suggestions.

5. Results and Discussion

5.1. Overview, Performance Summary & Evaluation Metrics

The objective of this section is to present the experimental evaluation of the proposed framework across its two core modules: the UCD Verification Module and the UCD Generation Module, and observe how it fares when put to the test under various input conditions across different cases with different levels of correctness and ambiguity. Each module is evaluated independently through representative test cases, with results reported across the key performance dimensions of accuracy, recall, precision, and retrieval relevance.

The tests were conducted exhaustively across various domains from the database, for prompts of different sizes in an unbiased manner. The following results were observed:

The verification module was evaluated against a set of TTool XML diagrams of varying complexity and correctness. Please refer to Table 3. The number of rules enforced was 21. The CBR module was evaluated on retrieval relevance, suggestion acceptance rate and overall generation performance. Performance metrics are summarized in Table 4.

Table 3. Verification Engine Performance Metrics.

Parameter	Value/Remarks
Total Violations	355
Rule Violations Detected	343
Recall	96.6%
False Positives	5
Precision	98.54%
F1 Score	97.5%
Ambiguity/Warning	13.5%
User Correction Requirement	Low

Table 4. Generation and CBR Performance Metrics.

Parameter	Value
Stability	99%
Top 1 UCD Match Confidence	98.5%
Top 3 UCDs Match Confidence	82%
Elements Mapping Accuracy	92%

To evaluate the performance of the verification module, three standard metrics were used: Precision, Recall, and F1 Score. Precision measures the proportion of flagged violations that were genuinely real, while Recall measures the proportion of actual violations successfully detected. The F1 Score is the harmonic mean of Precision and Recall, ensuring a high score is only achieved when both metrics are strong. In the verification context, high Precision indicates the software avoids incorrectly flagging valid elements, while high Recall indicates successful identification of actual modeling errors.

$$\mathrm{F}1={\displaystyle \frac{2\times \mathrm{Precision}\times \mathrm{Recall}}{\mathrm{Precision}+\mathrm{Recall}}}$$

(1)

5.2. Verification and Generation Module Performance

The verification module achieved an F1 score of 97.5%, with a precision of 98.54% and a recall of 96.6%, indicating strong performance in structural and semantic validation. Actor naming violations, spelling inconsistencies, and relationship misuse were the most frequently identified issues. The 13.5% ambiguity rate suggests that some inconsistencies require contextual interpretation rather than strict binary classification, reducing cognitive burden and keeping the correction process focused.

The generation module showed promising results, as summarized in Table 4. Top-1 UCD match confidence refers to the similarity score of the highest-ranked diagram retrieved from the hybrid CBR engine, while Top-3 refers to the average confidence across the three most relevant retrieved diagrams. The hybrid CBR retrieval engine achieved a Top-1 UCD match confidence of 98.5% and a Top-3 match confidence of 82%, demonstrating consistent retrieval of relevant cases from the knowledge base. The extracted elements achieved a mapping accuracy of 92%, requiring minimal manual correction.

5.3. Some Observations

A consistent observation across all generation test cases is that pyCBR outperformed myCBR as the primary retrieval engine. Semantic retrieval produced more relevant matches than symbolic string matching, particularly when domain vocabulary varied across cases. myCBR’s role is better understood as a complementary signal, while cases retrieved strongly by both engines generally represented the strongest retrieval candidates. The 81.5% suggestion acceptance rate confirms that the knowledge base is well-curated and that the hybrid retrieval is returning genuinely relevant cases.

At the same time, the framework intentionally preserves a human-in-the-loop workflow. Rather than enforcing full automation, LLM extractions and CBR recommendations are presented as guided suggestions, allowing users to refine outputs based on domain knowledge and modeling intent. This positions the framework as an intelligent assistant rather than a replacement for the modeler, while also exposing users to validated modeling patterns that reinforce good modeling practices. The observed 1 % instability is attributed to inherent LLM variability, mitigated by requiring user review before diagram finalization.

The framework operationalizes the entire CBR cycle within every generation workflow. The retrieve phase identifies the most semantically and symbolically relevant past cases from the knowledge base, the reuse phase proposes their constituent elements as candidate actors, use cases and relationships for the new diagram, the revise phase requires direct user involvement to evaluate and refine these suggestions against the specific system being modeled, giving users flexibility, and the retain phase permanently stores the finalized and verified diagram back into the knowledge base for future retrieval.

5.4. Evaluation Dataset and Discussion on the Validation

The evaluation dataset was constructed from use case diagrams sourced from academic textbooks, published modeling examples, and engineering case studies, stored in the UCDForge knowledge base, serving as ground truth references for both module evaluations. Testing was conducted in two phases. In the first phase, violations covering all 21 enforced rule categories were systematically injected to ensure complete rule coverage across structural, linguistic, spatial, and relationship error types. The rule categories were informed by established literature on common UCD modeling errors, including [3,11,12], while additional categories were intentionally introduced to broaden coverage. Collectively, the 21 rules resonate with real-world modeling problems, ensuring that injected violations reflect genuine mistakes rather than arbitrarily constructed test cases. For the generation module, the hybrid CBR retrieval engine was repeatedly run across multiple system description inputs against the full knowledge base, evaluating whether the retrieval engine surfaced the most semantically and structurally relevant case for each input. This further motivated the inclusion of a human-in-the-loop stage before finalization. In the second phase, an informal test was conducted with a small group of fellow students and colleagues from both Systems Engineering and non-Systems Engineering backgrounds, who independently tested both the verification and generation modules by giving user inputs for generation and by introducing violations without prior knowledge of the rule categories, simulating realistic and unpredictable modeling mistakes and reducing author bias. The original diagrams served as ground truth, allowing direct comparison against both module outputs. The 355 violations represent the total across all evaluated diagrams, of which 343 were detected, yielding 338 true positives, 12 false negatives, and 5 false positives, producing the reported precision, recall, and F1 scores. A more rigorous evaluation involving formally recruited annotators and independent domain experts represents a direction for future work.

Furthermore, looking at the validation, it should be noted that confidence scores and correctness are not the same. Within this exploratory research project, the primary objective of this work was to demonstrate the feasibility and potential of integrating rule-based verification, LLM-assisted extraction, and hybrid CBR retrieval into a unified framework. A rigorous formal evaluation involving independent domain experts and expert scoring goes beyond the scope of this initial investigation. Regarding the reported metrics, the Top-1 confidence reflects the similarity score of the single best retrieved case, which naturally tends to be high as the retrieval engine identifies the most semantically and structurally relevant match. The reduction in Top-3 confidence is expected and reflects the increasing specificity and subjectivity of lower-ranked candidates, where matches become progressively less aligned with the input as retrieval extends beyond the single best case. Since the knowledge base spans a wide range of domains, lower-ranked candidates naturally represent increasingly distant systems, and this reduction in confidence is therefore a reflection of domain diversity rather than a limitation of the retrieval engine. This effect would naturally diminish with a larger and more densely populated knowledge base, where more closely related cases would be available across a wider range of domains. The elements mapping accuracy reflects the proportion of LLM-extracted actors and use cases that were successfully mapped to semantically equivalent elements in the retrieved knowledge base case, computed through a symmetric one-to-one semantic matching process where each extracted element is paired with its most similar counterpart in the KB case using sentence embeddings. Elements that do not meet the similarity threshold are retained as originally extracted and presented to the user for review, ensuring that unmatched elements remain under user supervision. Crucially, the subsequent steps of the workflow involve a deliberate human-in-the-loop design, where users review, modify, accept, or reject all extracted and suggested elements before diagram finalization. This design choice was intentional precisely because the retrieval and extraction outputs can be domain-specific or may not completely align with the user’s modeling intent and the human-in-the-loop stage ensures that the final diagram reflects validated user decisions rather than unchecked automated output, providing a practical correctness mechanism embedded within the workflow itself. Furthermore, every generated diagram is automatically passed through the verification module before export, enforcing structural, linguistic, spatial, and relationship rules to ensure that the final output satisfies a formally defined correctness criterion regardless of the retrieval confidence score.

During the development of the case retrieval component, several approaches were investigated for determining the relative importance of the different similarity dimensions. In particular, we experimented with data-driven weighting approaches, including logistic regression and a genetic algorithm for optimizing the retrieval weights. These experiments were conducted to determine whether automatically learned weights could consistently improve the ranking and retrieval of cases according to user preferences. Although these approaches were technically feasible, our experiments showed that they introduced considerable methodological and computational complexity without consistently producing rankings that corresponded to the cases users considered most relevant. In particular, the optimized weights were sensitive to the formulation of the relevance criterion and did not reliably reflect the preferences expressed through the actual case-retrieval task. This was especially problematic because our objective is not simply to classify pairs of cases as similar or dissimilar, but to retrieve and rank cases in a way that is meaningful and useful to the user. Consequently, rather than introducing an optimization procedure whose learned weights could be difficult to interpret and reproduce across datasets, we adopted a heuristic weighting strategy. The heuristic approach provides explicit and transparent retrieval weights, allows the contribution of each similarity dimension to be clearly understood, and proved more appropriate for the practical retrieval setting investigated in this work. We therefore consider the heuristic formulation a deliberate design choice resulting from our comparative experimentation, rather than an omission of alternative weighting methods. The implementation resources of the realised approach can be found here16. The repository contains the datasets used in the experiments, the original XML data, and the parsing scripts required to transform the XML data into the structures used by the retrieval system. The source code for the similarity calculations, retrieval process, and weighting configuration is also provided, allowing researchers to inspect and reproduce the experimental pipeline.

6. Conclusions and Perspectives

This paper presents an exploratory research project aiming to improve use case diagram design by bringing in techniques from artificial intelligence, namely rule-based reasoning, case-based reasoning and large-language models.

The selection of these three techniques was deliberate and motivated by the specific challenges identified in the related work. Rule-based verification was chosen because it provides explicit and non-negotiable enforcement of structural, linguistic, spatial, and relationship correctness constraints, ensuring that defined modeling rules are consistently applied regardless of how the diagram was generated. LLM-assisted extraction was selected because it handles natural language ambiguity, spelling variations, and informal phrasing that traditional NLP approaches do not always capture, allowing users to describe their systems freely in plain language without requiring formal modeling constructs or rigid input structures. Case-Based Reasoning (CBR) was chosen because it resolves new problems by retrieving and adapting solutions from previously solved similar problems, making it particularly well suited to domains where expert knowledge is difficult to formalise but historical examples are available. This makes CBR a natural fit for UCD modeling, where validated past diagrams can serve as reusable references for new modeling tasks.

Together, these three techniques address complementary aspects of the UCD modeling lifecycle: LLM-assisted extraction handles unstructured input, CBR retrieval grounds the output in validated knowledge, and rule-based verification ensures that the final diagram satisfies formally defined correctness criteria. As such, the novelty lies in the integration of these three complementary techniques, with each contributing a distinct capability that works in tandem with the others to better support the development of use case diagrams.

The first implementation has demonstrated potential to reduce modeling complexity and improves flexibility and adaptability. First assessment of the verification module and the generation module demonstrate strong performance, and some interoperability is enabled through the three-format export capabilities supporting TTool XML, PlantUML, and SysML v2.

With the encouraging results presented in this paper, come a set of important next research objectives, briefly highlighted below.

• First of all, it is planned to include in future research expert scoring, element-level precision/recall, relation extraction accuracy, and diagram correctness score. In addition, the plan is to do detailed comparisons with LLM-only, rule-base-based, CBR-only and RAG-only baselines.
• Secondly, LLM extraction may be affected by hallucinations, prompt sensitivity and changes in domain terms. This part has in the current research not yet been addressed, and in a next step the robustness of different LLMs, different prompts, different document lengths and different domain requirements will be done. The impact of LLM model choice on the extraction quality needs to be assessed. The goal will be to improve reproducibility through disclosure of prompts, extraction templates, and representative examples of successful and unsuccessful generations.
• Thirdly, it would be interesting to go more in detail on deep semantic correctness, requirement coverage completeness, and cross-graph consistency for the verification module.
• Also, in the current implementation, XML was used. This choice is due to the TTool native notation but does not allow for interoperability with other tools. Again, it concerns an exploratory research project, and interoperability was not a main driver in this first step. However, with the arrival of SysML V2, that has a defined textual notation, this issue will disappear. Also, we aim to turn to SysML V2 in future research, so that the approach links to other tools as well.
• In the current state, the framework has a repository of approximately fifty validated use case diagrams. Although this is a good starting point, one needs to extend this repository and assess the impact on the operation of the framework (precision, knowledge-base growth, retrieval time, repeatability, scalability, domain transferability, retrieval degradation, etc.). In future research, we aim to address these issues and assess the effectiveness of the approach when confronted with large and heterogeneous industrial repositories.
• Once these issues will have been addressed, research may turn to how generated and verified use case diagrams integrate into larger MBSE workflows involving architecture models, safety analyses, requirement models, verification plans, and digital thread concepts. These topics are very important, and deserve specific attention.