Technical Summary: LLM-Driven Approach to Modeling Tool Interoperability in the Automotive Domain

1. Problem Statement

In the automotive domain, particularly within the era of Software-Defined Vehicles (SDVs), Model-Driven Engineering (MDE) relies on a heterogeneous ecosystem of modeling tools and languages. Standards such as SysML (supported by tools like CATIA Magic and IBM Rhapsody) coexist with Ecore-based ecosystems (e.g., Eclipse Modeling Framework). This heterogeneity creates a significant interoperability bottleneck: engineering artifacts must be exchanged between tools based on different metamodels.

Traditional solutions rely on manually developed transformation rules (e.g., ATL, QVT). These approaches are labor-intensive, require deep expertise in both source and target metamodels, and struggle to scale as metamodels evolve or when supporting multiple target environments. Furthermore, rule-based approaches often fail to capture necessary semantic interpretations beyond simple structural mappings. While recent research has explored Large Language Models (LLMs) for semantic alignment and knowledge retrieval, there remains a gap in fully automated, end-to-end instance model interoperability across heterogeneous metamodels that ensures strict structural conformance to target specifications.

2. Methodology

The authors propose an LLM-driven framework that automates two core tasks:

1. Model Instance Transformation: Converting a source model instance to a target metamodel format.
2. Metamodel Merging: Unifying two distinct metamodels into a single target-compliant metamodel.

Workflow Architecture

The system is implemented using n8n as an orchestration engine, integrating conversational interaction, file management, LLM inference, and automated validation into a single pipeline. The workflow operates as follows:

• Input: The user provides a source model instance (or source metamodels for merging) and a target metamodel definition via a chat interface.
• Prompt Engineering: The system dynamically constructs prompts for the LLM.
  • System Prompts: Specialize the LLM as a transformation engine. For SysML v2, prompts include explicit instructions to handle specific syntax (e.g., part redefines, attribute redefines, package declarations) to avoid ambiguity.
  • User Prompts: Embed the full content of the source and target artifacts, instructing the LLM to map elements semantically while adhering to the target structure.
• Inference: The LLM (deployed locally to ensure data privacy and control) generates the target model instance or merged metamodel.
• Validation: A critical step where the generated artifact is automatically validated against the target metamodel.
  • For Ecore, a Python-based validator using the PyEcore framework checks XML well-formedness, metamodel conformance, containment hierarchy, reference resolution, multiplicity, and attribute types.
  • For SysML, the framework supports integration with specific conformance checkers.
• Iterative Refinement: If validation fails, the workflow can feed the validation results back into the LLM via an "update prompt" to regenerate a corrected model.

Implementation Details

• Local Deployment: The authors prioritize locally deployable LLMs (specifically Google Gemma-4-31B-it and Qwen/Qwen3.5-122B-A10B) to address security and information flow concerns in critical automotive domains.
• Hardware: Experiments were conducted on three NVIDIA H200 NVL GPUs.

3. Key Contributions

• End-to-End Automation: A unified pipeline that handles file ingestion, semantic mapping, generation, and formal validation without requiring manual transformation rule definition.
• Dual-Task Capability: The framework addresses both instance migration (cross-tool interoperability) and metamodel integration (merging heterogeneous definitions).
• Validation-Driven Generation: Unlike prior works that focus solely on generation, this approach integrates structural validation as a mandatory step, enabling the detection of inconsistencies and supporting iterative refinement.
• Automotive Case Studies: The methodology is demonstrated through four scenarios: Ecore-to-Ecore, SysML v2-to-SysML v2, Ecore-to-SysML v2, and SysML v2-to-Ecore, using realistic hardware abstraction models (sensors and actuators).

4. Experimental Results

The framework was evaluated on automotive hardware models involving cameras, LiDAR, radar, brakes, and steering components.

Model Instance Mapping Performance

• Semantic Matching: Both Gemma and Qwen achieved 100% semantic mapping accuracy across all four transformation scenarios. They successfully inferred correspondences between heterogeneous metamodels without manual rules.
• Syntax Correctness:
  • Ecore Targets: Both models achieved 100% syntax correctness (passing validation).
  • SysML v2 Targets: Performance varied. Gemma achieved 80% (Ecore→SysML) and 60% (SysML→SysML). Qwen achieved 60% and 40%, respectively.
  • Analysis: The primary failure mode in SysML generation was not semantic loss but strict adherence to textual syntax (e.g., incorrect use of redefines constructs or import statements).
• Execution Time: Gemma averaged 5.1 seconds per run, while Qwen averaged 46.5 seconds, attributed to Gemma's smaller computational footprint.

Metamodel Merging Performance

• Semantic Matching: Both models achieved 100% in merging complementary metamodels (sensors + actuators) into a unified target.
• Syntax Correctness: Similar to instance mapping, Ecore targets saw 100% success, while SysML targets saw 60% (Gemma) and 40% (Qwen).
• Time: Gemma averaged 15.2 seconds; Qwen averaged 58.3 seconds.

5. Significance and Claims

The paper claims that the proposed approach significantly reduces the manual engineering effort required for model interoperability. By leveraging LLMs to infer semantic correspondences directly from artifacts, the need for extensive, manually crafted transformation rules is eliminated.

The authors emphasize that while current LLMs excel at semantic understanding, their adherence to strict formal syntax (particularly in SysML v2) remains a limitation. However, because the generated models preserve complete engineering semantics, syntactic errors can often be resolved through iterative refinement or lightweight post-processing.

The significance of this work lies in its demonstration that generative AI can facilitate the integration of heterogeneous modeling ecosystems in future automotive MDE environments. The modular architecture allows for the support of multiple modeling languages (currently Ecore and SysML) by adapting prompts and validators rather than redesigning core transformation logic. The authors note that future work will address context size limitations for large models using Model Context Protocol (MCP) and Retrieval Augmented Generation (RAG).