The large-scale adoption of large language models for the integration of generative artificial intelligence capabilities is occurring across several domains. This also applies to the domain of conceptual modeling, where a number of approaches are currently being investigated for the creation and interpretation of models utilizing this technology. However, a significant number of these approaches are currently limited to a specific modeling language. Accordingly, the current paper proposes an architecture on the level of metamodeling platforms to facilitate the integration of large language models into modeling editors for triggering actions on arbitrary types of models. We describe the underlying concept and report on a first prototypical implementation of the approach for the web-based MM-AR metamodeling platform.
convey the practical aspects of implementation. In contrast to other approaches, the LLM does not need to know the context of the entire metamodel, but only some predefined functions to call. A user’s textual input is then mapped to these predefined functions that can be executed by the metamodeling platform. This reduces the complexity of the task for the LLM and restricts the possible output to a controllable set of functions, making the approach flexible and extendable.
The remainder of the paper is structured as follows. First, we discuss related work in Section 2, followed by a description of the concept of the approach in Section 3 and the prototypical implementation of the proposed methodology in Section 4. In Section 5 we illustrate the approach on two metamodels.
Several approaches have been explored for the application of large language models to conceptual modeling and metamodeling. These will be briefly characterized in the following.
In initial experiments, large language models were used to create and interpret entity
relationship diagrams (ERD), business process models, UML class diagrams, and Heraklit models [
Baumann et al. [
Subsequently, experiments were conducted in which an LLM was provided with a
metametamodel, several metamodels, and instance models in JSON format created by a metamodeling
platform and accompanied by natural language descriptions [
Although previous approaches showed very well the utilization of large language models for the creation and interpretation of conceptual models, only few investigations have so far been made that can be applied to any modeling language and are integrated in a model editor.
The idea of our approach is to build the final model incrementally in small steps. Each step involves running a few lines of code in the form of a function. When these functions are triggered they perform a UI action on the existing instance of the model, such as creating an instance, naming an instance, moving an instance, deleting a relation, etc. Our approach relies on these functions as the interface to the large language model - see the architecture depicted in Figure 1. The LLM is provided with all the available functions and input from the modeler. The function names, descriptions, parameter names, parameter descriptions, and dynamically
The meta-modelling specifications are used for the creation/modification of
instances of models
Global Datastructure The meta meta-modelling specifications are used for creation/modification of
metamodels Stores and retrieves the instances of models via internal APIs
Node Server 1 Node Server 2
Client (Aurelia, ThreeJS) RightNav UiFunctions prompt createInstance() reply reply deleteInstance() onSend() prompt callOpenAI()
API-Server (Express)
Stores & retrieves the
meta-model and instances of the model DB-Server
Database (PostgreSQL) { "model": "gpt-3.5-turbo-0125", "m{es"sraoglee"s:"":u[ser", ]",to{}ol}"""sftc"yuo""":pnpndn[ecaaet"tersmi:anoc"emtnr"f"i"up:e::ntt""ie{cCocrtrnrsieeo""aan::tt""{ee.,C_..are}nenatEtitexysc"l,iunssitvaen-cGeatoefwthaey caltaxs=s1",and y=2" TfuJhnSevcOiptaiNoronnpfomsord'orpemdcteeapatslataosctinloiksngagLagwLreeMithisnfeothnret } ]",to}o,.l._.choice": "auto" OpenAI
GPT-3.5 Turbo { "id": "chatcmpl-9lFq9TPv5UgsRbjc6cUTxpT3XuRHA", "object": "chat.completion", "created": 1721049333, "model": "gpt-3.5-turbo-0125", "ch{o"icinedse":x[": 0, "message": { "role": "assistant", "content": null, "to{ol"""_itfcdyu"a"pnnl:eclas""tm"ic:o:a"en[lf"l"u_::nY"{ccetrxieoDanCt"e3,_SecvteJnat6"P,9UZaDvSuXAY", Tchpaeallrefaudmnaceltotieonrngstwaorietbhe } "arguments": "{\"className\":\"Exclusive-Gateway\",\"x\":1,\"y\":2}" received in JSON
format from LLM
}, ] }
"logprobs": null,
], } "finish_reason": "tool_calls"
"usage": {
"prompt_tokens": 235,
"completion_tokens": 24,
}, "total_tokens": 259
} "system_fingerprint": null
obtained sample values of the parameters are provided to the LLM as context information.
There is no need for the LLM to know specific information about the meta-metamodel or the
underlying metamodels of the platform. Based on the user’s input and context information
provided, the LLM returns the function name to call, including the function parameters to pass
to the function. For example, if the user specifies keywords like create, build, or instantiate in
the prompt and there is a function called "create" in the list of functions provided to the LLM
whose description mentions that it creates an entity, then the LLM chooses this function over
other functions. This chosen function is subsequently executed by the metamodeling platform
for modifying the model instance in the same way as a user would use a mouse and keyboard.
In the next section, we discuss the prototypical implementation of these concepts as integration
into the MM-AR metamodeling platform [
As basis for the first prototypical implementation, we used the MM-AR metamodeling
platform [
As shown in Figure 1, the platform is implemented as Node.js2 web server running Aurelia23 and the JavaScript WebGL visualization framework THREE.js4. Furthermore, the platform relies on a database server with PostgreSQL5, which is accessed via an API Server running as Node.js application and express6.
As an extension to traditional UI interaction methods, the platform has been enhanced with a prompt field that allows descriptive input. Upon the click of a button, the descriptive input of the desired modeling task, along with the possible set of UI functions, their parameters and corresponding descriptions, is sent to the OpenAI API using GPT 3.5 Turbo as the language model. From the user’s point of view, only descriptive input is considered. The API then returns, on the basis of the input of the user the most probable function name, as well as the required parameters in a JSON format. This function is then called, and the according modeling actions are executed on the model instance. The right side of Figure 1 shows exemplary prompt data sent to the LLM (top) and received by the LLM (bottom).
To illustrate the generic application of the new approach, two use case scenarios for (1) creating instances of model elements and (2) renaming existing model elements in the BPMN and the e3value modeling languages are presented below. Even though these two metamodels are simplified, the underlying structure is already quite complex 7.
Figure 2 shows the state of the model after sending a request with the prompt: “Create a start event” for a BPMN diagram. Figure 3 shows that attributes of instances in a model can be changed by textual input. In this example, a Boundary Element of an e3-value model is created and named by stating: “Create a Boundary Element and name it as point”.
As we can see, the LLM correctly identified which function to invoke in both the cases and has correctly extracted the parameter value out of the given prompt. This way compound prompts can also be processed for executing multiple tasks sequentially. Thus, we can also build and modify large and complex models using multiple simple prompts. We can observe that this approach works on arbitrary metamodels and is in indeed platform independent. The only requirement is that UI actions must be accessible via functions, where each function performs a dedicated UI action and vice versa.
In this paper, we introduced a light-weight approach for integrating LLMs directly into metamodeling platforms, which overcomes the dificulties of LLMs in understanding complex model data by not relying on specific model information, but using UI interaction features as a proxy. In a 2https://github.com/nodejs/node 3https://github.com/aurelia/aurelia 4https://github.com/mrdoob/three.js 5https://www.postgresql.org/docs/ 6https://github.com/expressjs/express 7An illustration of the two metamodels can be found on: https://doi.org/10.5281/zenodo.12920616 ifrst prototypical implementation, we were able to show that the approach works for basic model actions, e.g., creating instances and renaming instances for two metamodels but is extensible to all other UI actions as well. Also, it is metamodel-agnostic and platform-independent.
Nevertheless, this approach is not without some limitations. The prototypical implementation is reliant upon the names instead of platform’s Universally Unique Identifiers (UUIDs) to distinguish the diferent concepts. Consequently, it cannot be guaranteed that the correct metamodel concept is being employed when names are used. We recommend future developers and researchers to invest suficient time in giving adequate contextual information to the LLM through descriptions.