Generative artificial intelligence for server generation

A generative AI model automates the creation and testing of software servers, addressing the complexity and error-proneness of manual OData server development by generating and refining declarative data models.

JP2024163841APending Publication Date: 2024-11-22エスアーペーエスエー
View PDF 0 Cites 1 Cited by

Patent Information

Application Number
JP2023207860
Authority / Receiving Office
JP · JP
Patent Type
Applications
Current Assignee / Owner
Priority Date
2023-05-12
Filing Date
2023-12-08
Publication Date
2024-11-22

AI Technical Summary

Technical Problem

Creating software servers, particularly OData servers, is technically difficult and error-prone, with manual data model creation and detection of errors being challenging.

Method used

Employing a generative artificial intelligence (GAI) model to automatically generate software servers, including declarative data models, which can be tested and refined, using frameworks like SAP Cloud Application Platform (CAP) and models such as generative pre-trained transformers (GPT) or bidirectional encoders to create server files and data.

Benefits of technology

Automates the creation of accurate and efficient software servers, reducing human error and streamlining the process of generating and testing declarative data models.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 2024163841000001_ABST
    Figure 2024163841000001_ABST
Patent Text Reader

Abstract

To provide generative artificial intelligence for server generation.SOLUTION: In an example, Generative Artificial Intelligence (GAI) is utilized to automatically generate software servers. More particularly, a GAI model may be used to create a declarative-based data model and accompanying data for a software server, such as a web server. Furthermore, the created declarative-based data model can be automatically tested and resubmitted to the GAI model to refine the software server file upon failure of the testing.SELECTED DRAWING: Figure 1
Need to check novelty before this filing date? Find Prior Art

Description

[Technical field]

[0001] This document relates generally to computer systems. More particularly, this document relates to the use of generative artificial intelligence for server generation. [Background technology]

[0002] In computer systems, software servers are often used to manage applications that interact with one or more software clients over a computer network such as the Internet. An OData server is a type of web server that implements the Open Data Protocol (OData) that allows the creation and consumption of RESTful application program interfaces (APIs) for data sources. OData is a protocol for creating and consuming data APIs that are based on RESTful principles and expose data as resources that can be accessed using standard Hypertext Transfer Protocol (HTTP) methods such as GET, POST, PUT, and DELETE.

[0003] OData servers allow developers to expose data from various sources, such as databases, file systems, or web services, as OData feeds that can be consumed by client applications. OData servers map HTTP requests to corresponding data operations and return the data in a standardized format, typically JavaScript Object Notation (JSON) or Extensible Markup Language (XML). OData servers are used in a variety of contexts, including enterprise data integration, business intelligence, and mobile application development. OData servers enable the creation of scalable and flexible APIs that can be consumed by a wide range of clients, including web and mobile applications, desktop software, and other back-end systems.

[0004] The present disclosure is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings in which like reference numerals indicate similar elements and in which: Summary of the Invention [Means for solving the problem]

[0005] The system is Generative artificial intelligence (GAI) models and A server repository; Framework Server and The framework server comprises: receiving a text-based prompt from a framework client describing one or more services; creating a server-generated request including the text-based prompt and a first pre-designed system message; providing the server generation request to the GAI model to generate one or more server files defining model definitions for services executable within the framework server; storing the one or more server files in the server repository; The device is configured to perform operations including: [Brief description of the drawings]

[0006] [Figure 1] FIG. 1 is a block diagram illustrating a system for automatically generating a software server according to an exemplary embodiment. [Diagram 2] FIG. 1 is a flow diagram illustrating a method for automatically generating a software server according to an example embodiment. [Diagram 3] FIG. 2 is a block diagram illustrating a software architecture that may be installed on any one or more of the devices described above. [Figure 4]FIG. 1 is a schematic diagram of a machine in the form of a computer system, in which a set of instructions can be executed to cause the machine to perform any one or more of the methods discussed herein, according to an exemplary embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0007] In the following description, exemplary systems, methods, techniques, instruction sequences, and computing machine program products are discussed. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide an understanding of various exemplary embodiments of the present subject matter. However, it will be apparent to one skilled in the art that various exemplary embodiments of the present subject matter may be practiced without these specific details.

[0008] Some of the example embodiments described herein provide methods and systems for automatically generating software servers, such as web servers, that are implemented using the Open Data Protocol (OData).

[0009] "OData" may refer specifically herein to the Open Data Protocol, an open web protocol for querying and communicating data using Representational State Transfer (REST) ​​web services, but may also apply to other types of web services. OData enables the creation and use of HTTP-based data services, where resources identified using Uniform Resource Identifiers (URIs) and defined in terms of abstract data models can be exposed and edited by web clients using simple HTTP messages. OData typically uses commonly deployed web technologies such as Transmission Control Protocol (TCP), HTTP, Atom Publishing Protocol, XML, and JSON to exchange data between systems. The results (payload) of an OData query are typically structured in an easily parsable format, such as Atom, JSON, or XML, and the results can be parsed by any number of client libraries provided by platforms such as .NET, Silverlight, Java, AJAX, PHP, and mobile development platforms. OData, as used herein, may refer to any standardized or non-standardized version of the OData protocol or similar web protocols (e.g., Google Data Protocol (GData)) that communicate using REST-based web services communication techniques.

[0010] "Server" is used herein to generally refer to a software server, although in some embodiments the software may be embodied in hardware, although in most contexts a software server runs on some type of hardware.

[0011] A "service," as used herein, generally refers to a software system designed to enable different machines or applications to communicate with each other over the Internet. In other words, a service is a collection of exposed functionality, such as entities, actions, and functions. A service can provide a standard way of communication between different software applications, regardless of their platform or programming language.

[0012] Creating a software server, especially an OData server, can be technically difficult: data models and data must be created manually, and errors that occur during the creation process are difficult to detect and correct.

[0013] In one example, generative artificial intelligence (GAI) is utilized to automatically generate software servers. More specifically, a GAI model can be used to create a declarative-based data model and associated data for a software server, such as a web server. Furthermore, the created declarative-based data model can be automatically tested and, if the test fails, sent back to the GAI model for refinement of the software server files.

[0014] Cloud computing can be described as Internet-based computing that provides shared computer processing resources and data to computers and other devices on demand. Users can establish respective sessions during which processing resources and bandwidth are utilized. During a session, for example, a user is provided on-demand access to a shared pool of configurable computing resources (e.g., computer networks, servers, storage space, applications, and services). Computing resources can be provisioned and released (e.g., scaled) to meet the user's demands. An example of a cloud platform is the SAP Cloud Application Platform (CAP) from SAP SE of Walldorf, Germany. The cloud platform can run a data model infrastructure in which data models can be created and run.

[0015] One example of such a data model infrastructure is Core Data Services (CDS) from SAP SE, Walldorf, Germany. CDS allows service definitions and data models to be captured declaratively in the form of a plain object notation. CDS models are typically written in the CDS language and, once compiled, are typically stored in Javascript Object Notation (JSON) files and conform to a standard notation such as core schema notation (CSN). These models are compiled and run on a server, which can then handle incoming requests for the applications defined by the models.

[0016] A common architecture in cloud platforms includes services (also called microservices), which have become popular in service-oriented architectures (SOA). In such SOAs, applications consist of multiple independent services. These services are deployed and managed within the cloud platform and run on top of the cloud infrastructure. In some examples, service-based applications can be created and / or extended using application programming frameworks. In an exemplary embodiment, created software servers implement the services.

[0017] In one exemplary embodiment, the GAI model is implemented as a generative pre-trained transformer (GPT) model, or bidirectional encoder. A GPT model is a type of machine learning model that uses a transformer architecture, a type of deep neural network that excels at processing sequence data such as natural language.

[0018] A bidirectional encoder is a type of neural network architecture in which an input sequence is processed in two directions: forward and backward. In the forward direction, the encoder starts from the beginning of the sequence and processes the input one token at a time, while in the backward direction, the encoder starts from the end of the sequence and processes the input in reverse order.

[0019] By processing the input sequence in both directions, a bidirectional encoder can capture more context information and dependencies between words, resulting in better performance.

[0020] A bidirectional encoder can be implemented as a Bidirectional Long Short-Term Memory (BiLSTM) model or a Bidirectional Encoder Representations from Transformers (BERT) model.

[0021] Each direction has its own hidden state, and the final output is a combination of these two hidden states.

[0022] Long short-term memory (LSTM) is a type of recurrent neural network (RNN) designed to overcome the vanishing gradient problem in traditional RNNs, which can make it difficult to learn long-term dependencies in sequence data.

[0023] LSTMs contain a cell state, which acts as a memory that stores information over time. The cell state is controlled by three gates: an input gate, a forget gate, and an output gate. The input gate determines how much new information is added to the cell state, while the forget gate determines how much old information is discarded. The output gate determines how much of the cell state is used to compute the output. Each gate is controlled by a sigmoid activation function, which outputs a value between 0 and 1 that determines how much information passes through the gate.

[0024] In BiLSTM, there are separate forward and backward LSTMs. At each time step, the forward LSTM cell and the backward LSTM cell receive the current input token and the hidden state from the previous time step. The forward LSTM processes the input token from left to right, while the backward LSTM processes the input token from right to left.

[0025] The output of each LSTM cell at each time step is a combination of the input token and the previous hidden state, allowing the model to capture both short-term and long-term dependencies between the input tokens.

[0026] BERT applies bidirectional training of models known as transformers to language modeling, in contrast to prior art solutions that examine text sequences left-to-right or a combination of left-to-right and right-to-left. Bidirectionally trained language models have greater awareness of the context and flow of language than unidirectional language models.

[0027] More specifically, the transformer encoder reads an entire sequence of information at once and is therefore considered bidirectional (although it could actually be said to be non-directional). This feature allows the model to learn the context of a piece of information based on all of its surroundings.

[0028] In another exemplary embodiment, a GAN embodiment can be used. A GAN is a supervised machine learning model with two sub-models: a generator model trained to generate new examples, and a discriminator model that tries to classify examples as either real or artificial. The two models are trained together in an adversarial fashion (using a zero-sum game from game theory) until the discriminator model is fooled approximately half the time, which means that the generator model is generating plausible examples.

[0029] The generator model takes as input a fixed-length random vector and generates samples in the domain of interest. This vector is drawn randomly from a Gaussian distribution and is used to seed the generation process. After training, the points in this multidimensional vector space correspond to points in the problem domain, forming a compressed representation of the data distribution. This vector space is called the latent space, or the vector space of latent variables. Latent variables, or hidden variables, are variables that are important to a domain but cannot be directly observed.

[0030] The classifier model takes as input examples from this domain (real or artifact) and predicts a binary class label: real or fake (artificial).

[0031] While generative modeling, as we discussed in the previous section, is an unsupervised learning problem, a neat property of GAN architectures is that training a generative model is framed as a supervised learning problem.

[0032] Two models, a generator and a classifier, are trained together: the generator produces batches of examples, and these, along with real examples from the domain, are fed to the classifier, which classifies them as real or fake.

[0033] The classifier is then updated to become better at distinguishing between real and fake samples in the next round, and importantly, the generator is updated based on how well the generated samples managed to fool the classifier, or failed to do so.

[0034] In another exemplary embodiment, the GAI model is a variational autoencoder (VAE) model. A VAE comprises an encoder network that compresses input data into a lower-dimensional representation called a latent code, and a decoder network that generates new data from the latent code. In either case, the GAI model includes a generative classifier, which can be implemented, for example, as a naive Bayes classifier.

[0035] CAP-based server files are in a declarative format, where the intent / end result of a program is declared, rather than how that intent / end result should be reached. Declarative code typically consists of statements that invoke higher-level functions or abstractions with clear, human-readable intent. In contrast, imperative code consists of statements that explicitly affect the state of the program without reference to any higher-level goal.

[0036] In other words, declarative format files define the structure and elements of a computer program using the logic of a computation without describing its control flow. Within declarative programming, there are several sub-paradigms that can be used, including constraint programming (where relationships between variables are expressed in the form of constraints that specify properties of the target solution), domain-specific languages ​​(languages ​​defined for a particular application domain), functional programming (where expressions are evaluated via function application), and hybrid languages ​​(which mix declarative and imperative programming).

[0037] Thus, in some exemplary embodiments, the GAI model generates declarative files, which yield better / accurate results than if the GAI model were asked to generate imperative files.

[0038] FIG. 1 is a block diagram illustrating a system 100 for automatically generating software servers, according to an exemplary embodiment, where a CAP server 102 provides a server that enables one or more CAP clients, such as a CAP client 104, to create and manage software servers, such as an OData server for web services. The CAP server 102 provides a server that implements a software framework for creating and managing applications, and thus may be generally referred to as a framework server. Similarly, the CAP client 104 interfaces with the CAP server 102 in a client-server relationship, and thus may be generally referred to as a framework client. The CAP client 104 may generate model information that includes user interface annotations. The user interface annotations may then be used to generate on the fly a graphical user interface in which a user may issue requests to the CAP server 102. In this case, the user enters or otherwise selects a natural language text prompt that generally describes the service for which the user wants a software service generated. For example, a user might enter something like, "Help desk ticketing system: This application manages customer inquiries and support requests, including creating, assigning, and resolving tickets. Entities include tickets, customers, support agents, and knowledge base articles. Relationships include ticket-customer, ticket-support agent, and ticket-knowledge base article."

[0039] The prompts are received by a system message manager 106 in the CAP server 102. The system message manager 106 serves to manage server-generated and server-data-generated requests to the GAI model 108. More specifically, the system message manager 106 adds a system message to the prompt. The system message essentially serves as an instruction to the GAI model 108 that provides further details on what the GAI model 108 should generate. This system message may be general in nature in that it may apply to many or even all of the server-generated requests issued by the system message manager 106. However, in some exemplary embodiments, the system message may be more personalized, allowing for different system messages for different organizations, locations, server types, etc.

[0040] The system messages and prompts are then sent as a server creation request to the GAI model 108. The GAI model 108 then uses the server creation request as input to create a server. The server is then returned to the system message manager 106. The GAI model 108 can be, for example, a large language model (LLM).

[0041] In one exemplary embodiment, generating the server involves generating OData services, including their schemas and services, based on prompts and system messages.

[0042] After the server is created, the system message manager 106 can move on to generating server data. The system message manager 106 creates a data folder and a file (such as a comma separated values ​​(CSV) file) that does not yet contain data, but only headers (such as a header row with column names). This creation is based on one or more of the generated server files. One or more of the generated server files are then used to create one or more statements. In an exemplary embodiment, the statements are Structured Query Language (SQL) table creation statements. These statements include the exact shape of the database tables, including the associations between the tables. These statements, as well as the empty files in the created data folder, can be added to a separate system message to create a data generation request. This separate system message again essentially serves as an instruction to the GAI model 108 providing further details on what the GAI model 108 should generate. This system message can be general in nature in that it can apply to many or even all of the server generation requests issued by the system message manager 106. However, in some exemplary embodiments, system messages may be more personalized, allowing for different system messages for different organizations, locations, server types, and the like.

[0043] The data generation request is then sent to the GAI model 108, which then generates and returns the server data.

[0044] The system message manager 106 then utilizes a server validator to validate the generated server. Validation may include running one or more tests on the generated server to ensure that the generated server complies with established standards. One such test may be an attempt to compile the generated server. Other tests may test the accuracy, efficiency, or some metric of the server by testing the server using the generated server data. If the generated server fails one or more of the validation tests, the system message manager 106 may retry the server generation request by resubmitting the exact same server generation request that it sent last time, or by modifying the system message in some way to further affect the change. This modification may include, for example, adding back into the server generation request whatever validation errors were returned during the first failed validation test. The system message manager 106 then receives the regenerated server again, which may again be tested by the server validator 110. After the server validator 110 successfully validates the server, the server can be written into the server repository 112 and the server data can be written into the data repository 114 .

[0045] The server execution component 116 can then, at some later point in time, run the defined server by executing the server file in the server repository 112 .

[0046] 2 is a flow diagram illustrating a method 200 for automatically generating a software server according to an exemplary embodiment, where a text-based prompt describing one or more services is received from a framework client at operation 202. At operation 204, a server generation request is created using the text-based prompt and a first pre-designed system message. In an exemplary embodiment, the prompt is appended to the first pre-designed system message to create the server generation request.

[0047] In operation 206, the server generation request is provided to the GAI model to generate one or more server files that define model definitions for services executable within the framework server. In an exemplary embodiment, the one or more server files are in a declarative format and may include schema files and service files. The schema files and service files may, for example, define OData services.

[0048] At operation 208, the one or more server files are validated, which may include attempting to compile the one or more server files. At operation 210, it is determined whether the validation of the one or more server files is successful. If not successful, the method returns to operation 206, where a server generation request is resent to the GAI model to regenerate the one or more server files.

[0049] After the one or more server files are successfully verified, in operation 212, a data generation request is created using the text-based prompt and the second pre-designed system message. In an exemplary embodiment, this is performed by appending the text-based prompt to the second pre-designed system message. Then, in operation 214, the data generation request is fed to the GAI model to generate one or more server data files. In operation 216, the one or more server files are tested using the one or more server data files. In operation 218, it is determined whether the one or more server files pass the test. If not, the method 200 returns to operation 212. If so, in operation 220, the generated one or more server files are stored in the server repository and the generated one or more server data files are stored in the data repository.

[0050] What follows is an example of a user provided prompt and the corresponding generated system message, and finally, sample servers and server data, according to one illustrative embodiment.

[0051] The user can now enter the following prompt for the desired application: "App to manage inventory in Tile Warehouse." The system message manager can receive this prompt and add the following system message to the prompt to create a server generated request: [Table 1A] [Table 1B]

[0052] In response, the GAI model can generate the following schema files: ### db / schema.cds ```cds namespace tile.warehouse; using { UUID, Composition} from '@sap / cds / common'; entity Warehouse { key ID: UUID; name: String @assert.present; location: String @assert.present; tiles: Composition of many TileStorage on tiles.warehouse = $self; } entity TileType { key ID: UUID; name: String @assert.present; size: String @assert.present; color: String @assert.present; description: String; inventory: Composition of many TileStorage on inventory.tileType = $self; } entity TileStorage { key ID: UUID; warehouse: Association to Warehouse; tileType: Association to TileType; quantity: Integer; } ```

[0053] The GAI model can also generate the following service files: ### srv / service.cds ```cds using { tile.warehouse} from '.. / db / schema.cds'; service TileWarehouseService { entity Warehouses as projection on warehouse.Warehouse; entity TileTypes as projection on warehouse.TileType; entity TileStorage as projection on warehouse.TileStorage; } ```

[0054] Taken together, the schema files and the service files configure the software server, which can then be validated. As previously mentioned, this validation can include an attempt to compile. Here, the first attempt to compile fails, thereby returning the following error: [ERROR] db / schema.cds:3:9-13: Artifact "UUID" has not been found (in using: "UUID") [ERROR] db / schema.cds:3:15-26: Artifact "Composition" has not been found (in using: "Composition") Command failed: cds compile '*' [ERROR] db / schema.cds:3:9-13: Artifact "UUID" has not been found (in using: "UUID") [ERROR] db / schema.cds:3:15-26: Artifact "Composition" has not been found (in using: "Composition")

[0055] Therefore, the system message manager will try again to send the server generation request back to the GAI model. If the server file compilation is successful, the system message manager can move on to arranging for sample server data to be generated. As mentioned above, one or more statements are created along with one or more files that lack data. These statements and files are then added to a separate system message for the prompt to create a data generation request such as the following: [Table 2A] [Table 2B]

[0056] In this example, the GAI model then returns the following server data: ###warehouse-Warehouse.csv ```csv ID, name, location f71df848-a1d5-41b5-b0ae-5cd5b44bb5d1,Warehouse A,New York 8d24de97-764e-40bd-9c9b-c23a73124325,Warehouse B,Los Angeles 74e3d60c-981d-4470-9e32-9f1f2da4d4fe,Warehouse C,Houston a932d88f-521e-4a68-80db-9ac93d0b4991,Warehouse D,Miami 149761b7-cd93-413c-9f56-775175c9eaf8,Warehouse E,Chicago ``` ###warehouse-Tiles.csv ```csv ID,name,color,design,quantity,warehouse_ID 00e09604-7bc8-4075-89c5-54663e6295e5,Tile 1,Red,Regular,100,f71df848-a1d5-41b5-b0ae-5cd5b44bb5d1 6529e84d-e571-4e7e-b127-91d3cbd71205,Tile 2,Blue,Regular,80,8d24de97-764e-40bd-9c9b-c23a73124325 973c6f27-c6fa-4a9b-81f2-1ff2228acc24,Tile 3,White,Textured,150,74e3d60c-981d-4470-9e32-9f1f2da4d4fe 02f98609-c5ca-4345-ad5d-e62d939f7c81,Tile 4,Black,Patterned,70,a932d88f-521e-4a68-80db-9ac93d0b4991 43bef353-1ebe-4282-9465-f0d5cd5a862d,Tile 5,Green,Textured,200,149761b7-cd93-413c-9f56-775175c9eaf8 ```

[0057] The generated server can then be tested using the generated server data to validate the generated server. If anything fails, the server or the server data (or both) can be regenerated. Note that this regeneration can be performed automatically, but it is also possible for a user to trigger the regeneration to address a specific need. For example, a user may look at the generated server data and realize that there are not enough properties in the data about warehouses to describe the owner and location. Thus, the user may add the following prompt: "Add 10 more realistic properties to warehouses to describe their owners and locations"

[0058] In response, the GAI model can regenerate the server data as follows: ###warehouse-Tiles.csv ```csv ID;name;color;design;quantity;warehouse_ID 00e09604-7bc8-4075-89c5-54663e6295e5;Tile 1;Red;Regular;100;f71df848-a1d5-41b5-b0ae-5cd5b44bb5d1 6529e84d-e571-4e7e-b127-91d3cbd71205;Tile 2;Blue;Regular;80;8d24de97-764e-40bd-9c9b-c23a73124325 973c6f27-c6fa-4a9b-81f2-1ff2228acc24;Tile 3;White;Textured;150;74e3d60c-981d-4470-9e32-9f1f2da4d4fe 02f98609-c5ca-4345-ad5d-e62d939f7c81;Tile 4;Black;Patterned;70;a932d88f-521e-4a68-80db-9ac93d0b4991 43bef353-1ebe-4282-9465-f0d5cd5a862d;Tile 5;Green;Textured;200;149761b7-cd93-413c-9f56-775175c9eaf8 ``` ###warehouse-Warehouse.csv ```csv ID;name;location;ownerName;ownerEmail;ownerPhone;addressLine1;addressLine2;city;state;country;postalCode;latitude;longitude f71df848-a1d5-41b5-b0ae-5cd5b44bb5d1;Warehouse A;New York;John Doe;john.doe@example.com;+1-555-123456;123 Main St;Apt 4B;New York;New York;USA;10001;40.7128;-74.0060 8d24de97-764e-40bd-9c9b-c23a73124325;Warehouse B;Los Angeles;Jane Smith;jane.smith@example.com;+1-555-234567;456 Sunset Blvd;;;Los Angeles;California;USA;90028;34.0522;-118.2437 74e3d60c-981d-4470-9e32-9f1f2da4d4fe;Warehouse C;Houston;Jim Brown;jim.brown@example.com;+1-555-345678;789Houston St;;;Houston;Texas;USA;77007;29.7604;-95.3698 a932d88f-521e-4a68-80db-9ac93d0b4991;Warehouse D;Miami;Julia Green;julia.green@example.com;+1-555-456789;1012 Ocean Dr;;;Miami;Florida;USA;33139;25.7617;-80.1918 149761b7-cd93-413c-9f56-775175c9eaf8;Warehouse E;Chicago;Carl White;carl.white@example.com;+1-555-567890;1313 Lakeshore Dr;;;Chicago;Illinois;USA;60601;41.8781;-87.6298

[0059] In light of the above disclosure, various examples are described below. It should be noted that one or more features of the examples taken separately or in combination should be considered within the disclosure of the present application.

[0060] Example 1. Generative artificial intelligence (GAI) models and A server repository; Framework Server and The framework server comprises: receiving a text-based prompt from a framework client describing one or more services; creating a server generation request including one or more statements generated from one or more server files and a first predesigned system message; providing a server generation request to the GAI model to generate one or more server files that define model definitions for services executable within the framework server; Storing one or more server files in a server repository 23. A system configured to perform operations including:

[0061] Example 2. The system of Example 1, where one or more server files are in a declarative format.

[0062] Example 3. The system of Examples 1 or 2, where one or more server files include a schema file and a service file.

[0063] Example 4. The system from Example 3, with a schema file and a service file defining an Open Data Protocol (OData) service.

[0064] Example 5. Operation is creating a data generation request including a text-based prompt and a second pre-designed system message; providing a data generation request to the GAI model to generate one or more server data files; storing one or more server data files in a data repository; The system of any of Examples 1-4, further comprising:

[0065] Example 6. Operation is validating one or more server files; In response to determining that one or more server files fail validation, retrying to provide the server generated request to the GAI model. The system of example 5, further comprising:

[0066] Example 7. The system of example 6, wherein validating includes attempting to compile one or more server files.

[0067] Example 8. The system of example 6, wherein validating includes running one or more tests on the one or more server files using the one or more server data files.

[0068] Example 9. receiving a text-based prompt from a framework client describing one or more services; creating a server generation request including one or more statements generated from one or more server files and a first predesigned system message; providing a server generation request to the GAI model to generate one or more server files that define model definitions for services executable within the framework server; Storing one or more server files in a server repository The method includes:

[0069] Example 10. The method of Example 9, where one or more server files are in declarative format.

[0070] Example 11. The method of Examples 9 or 10, wherein the one or more server files include a schema file and a service file.

[0071] Example 12. The method of Example 11, where a schema file and a service file define an Open Data Protocol (OData) service.

[0072] Example 13. creating a data generation request that includes a text-based prompt and a second pre-designed system message; providing a data generation request to the GAI model to generate one or more server data files; storing one or more server data files in a data repository; The method of any of Examples 9-12, further comprising:

[0073] Example 14. validating one or more server files; In response to determining that one or more server files fail validation, retrying to provide the server generated request to the GAI model. The method of Example 13, further comprising:

[0074] Example 15. The method of example 14, wherein validating includes attempting to compile the one or more server files.

[0075] Example 16. The method of example 14, wherein validating includes running one or more tests on the one or more server files using the one or more server data files.

[0076] Example 17. A non-transitory machine-readable medium storing instructions, the instructions, when executed by one or more processors, causing the one or more processors to: receiving a text-based prompt from a framework client describing one or more services; creating a server-generated request including a text-based prompt and a first pre-designed system message; providing a server generation request to the GAI model to generate one or more server files that define model definitions for services executable within the framework server; Storing one or more server files in a server repository A non-transitory machine-readable medium for causing operations to be performed, including:

[0077] Example 18. The non-transitory machine-readable medium of example 17, wherein the one or more server files are in a declarative format.

[0078] Example 19. The non-transitory machine-readable medium of any of Examples 17-18, wherein the one or more server files include a schema file and a service file.

[0079] Example 20. The non-transitory machine-readable medium of example 19, wherein the schema file and the service file define an Open Data Protocol (OData) service.

[0080] FIG. 3 is a block diagram 300 illustrating a software architecture 302 that may be installed on any one or more of the devices described above. It will be appreciated that FIG. 3 is merely a non-limiting example of a software architecture and that many other architectures may be implemented to enable the functionality described herein. In various embodiments, the software architecture 302 is implemented by hardware, such as machine 400 of FIG. 4, which includes a processor 410, memory 430, and input / output (I / O) components 450. In this exemplary architecture, the software architecture 302 may be conceptualized as a stack of layers, where each layer may provide a particular function. For example, the software architecture 302 includes layers such as an operating system 304, a library 306, a framework 308, and an application 310. In operation, the application 310 invokes an API call 312 through this software stack and receives a message 314 in response to the API call 312, consistent with some embodiments.

[0081] In various implementations, the operating system 304 manages hardware resources and provides common services. The operating system 304 includes, for example, a kernel 320, services 322, and drivers 324. The kernel 320 serves as an abstraction layer between the hardware and other software layers, consistent with some embodiments. For example, the kernel 320 performs memory management, processor management (e.g., scheduling), component management, networking, and security configuration, among other functions. The services 322 may provide other common services for other software layers. The drivers 324 are responsible for controlling or interfacing with the underlying hardware, according to some embodiments. By way of example, the drivers 324 may include a display driver, a camera driver, a BLUETOOTH® or BLUETOOTH® Low-Energy driver, a flash memory driver, a serial communication driver (e.g., a Universal Serial Bus (USB) driver), a Wi-Fi® driver, an audio driver, a power management driver, and the like.

[0082] In some embodiments, the libraries 306 provide a low-level common infrastructure utilized by the applications 310. The libraries 306 can include system libraries 330 (e.g., C standard libraries) that can provide functions such as memory allocation functions, string manipulation functions, mathematical functions, etc. Additionally, the libraries 306 can include API libraries 332 such as a media library (e.g., a library for supporting the presentation and manipulation of various media formats such as Moving Picture Experts Group-4 (MPEG4), Advanced Video Coding (H.264 or AVC), Moving Picture Experts Group Layer-3 (MP3), Advanced Audio Coding (AAC), Adaptive Multi-Rate (AMR) audio codec, Joint Photographic Experts Group (JPEG or JPG), or Portable Network Graphics (PNG)), a graphics library (e.g., an OpenGL framework used for rendering in two dimensions (2D) and three dimensions (3D) in a graphical context on a display), a database library (e.g., SQLite for providing various relational database functions), a web library (e.g., WebKit for providing web browsing capabilities), etc. The libraries 306 may also include a wide variety of other libraries 334 for providing many other APIs to the applications 310 .

[0083] The framework 308 provides a high-level, common infrastructure that can be utilized by the applications 310, according to some embodiments. For example, the framework 308 provides various GUI functions, high-level resource management, high-level location services, etc. The framework 308 can provide a wide range of other APIs that can be utilized by the applications 310, some of which may be specific to a particular operating system 304 or platform.

[0084] In an exemplary embodiment, the applications 310 include a wide variety of other applications, such as a home application 350, a contacts application 352, a browser application 354, a book reader application 356, a location application 358, a media application 360, a messaging application 362, a game application 364, and a third party application 366. According to some embodiments, the applications 310 are programs that perform functions defined within the program. One or more of the applications 310 may be structured in a variety of ways using a variety of programming languages, such as object-oriented programming languages ​​(e.g., Objective-C, Java, or C++) or procedural programming languages ​​(e.g., C or assembly language). In one specific example, the third party application 366 (e.g., an application developed using the ANDROID® or IOS™ Software Development Kit (SDK) by an entity other than the vendor of a particular platform) may be mobile software that runs on a mobile operating system, such as IOS™, ANDROID®, WINDOWS® Phone, or another mobile operating system. In this example, the third party application 366 can invoke API calls 312 provided by the operating system 304 to enable the functionality described herein to be implemented.

[0085] FIG. 4 illustrates a schematic diagram of a machine 400 in the form of a computer system in which a set of instructions may be executed to cause the machine 400 to perform any one or more of the methods discussed herein, according to an exemplary embodiment. In particular, FIG. 4 illustrates a schematic diagram of a machine 400 in the form of an exemplary computer system in which instructions 416 (e.g., software, programs, applications, applets, apps, or other executable code) may be executed to cause the machine 400 to perform any one or more of the methods discussed herein. For example, the instructions 416 may cause the machine 400 to perform the method 200 of FIG. 2. Additionally or alternatively, the instructions 416 may also implement FIGS. 1-2, etc. The instructions 416 transform a general unprogrammed machine 400 into a specific machine 400 programmed to perform the functions described and illustrated in the described manner. In alternative embodiments, the machine 400 operates as a standalone device, or the machine 400 may be coupled (e.g., networked) to other machines. In a networked deployment, the machine 400 may operate in the capacity of a server or a client machine in server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment.The machine 400 may comprise, without limitation, a server computer, a client computer, a personal computer (PC), a tablet computer, a laptop computer, a netbook, a set-top box (STB), a personal digital assistant (PDA), an entertainment media system, a cellular telephone, a smartphone, a mobile device, a wearable device (e.g., a smart watch), a smart home device (e.g., a smart appliance), other smart devices, a web appliance, a network router, a network switch, a network bridge, or any machine capable of executing instructions 416, sequentially or otherwise, that specify actions to be taken by the machine 400. Additionally, although only a single machine 400 is illustrated, the term "machine" shall be taken to include a collection of machines 400 that individually or jointly execute instructions 416 to perform any one or more of the methodologies discussed herein.

[0086] Machine 400 may include a processor 410, memory 430, and I / O components 450, which may be configured to communicate with each other, such as via a bus 402. In an exemplary embodiment, processor 410 (e.g., a central processing unit (CPU), a reduced instruction set computing (RISC) processor, a complex instruction set computing (CISC) processor, a graphics processing unit (GPU), a digital signal processor (DSP), an application specific integrated circuit (ASIC), a radio frequency integrated circuit (RFIC), another processor, or any suitable combination thereof) may include, for example, a processor 412 and a processor 414 that may execute instructions 416. The term "processor" is intended to include a multi-core processor that may include two or more independent processors (sometimes referred to as "cores") that can execute instructions 416 simultaneously. Although FIG. 4 shows multiple processors 410, the machine 400 may include a single processor with a single core 412, a single processor with multiple cores 412 (e.g., a multi-core processor 412), multiple processors with single cores 412, 414, multiple processors with multiple cores 412, 414, or any combination thereof.

[0087] Memory 430 may include a main memory 432, a static memory 434, and a storage unit 436, each accessible to processor 410, such as via bus 402. Main memory 432, static memory 434, and storage unit 436 store instructions 416 embodying any one or more of the methods or functions described herein. Instructions 416 may reside, in whole or in part, in main memory 432, in static memory 434, in storage unit 436, within at least one of processors 410 (e.g., within a processor's cache memory), or any suitable combination thereof, during their execution by machine 400.

[0088] The I / O components 450 can include a wide variety of components for receiving input, providing output, generating output, transmitting information, exchanging information, capturing measurements, and the like. The particular I / O components 450 included within a particular machine will vary depending on the type of machine. For example, a portable machine such as a mobile phone may include a touch input device or other such input mechanism, while a headless server machine may not include such a touch input device. It will be appreciated that the I / O components 450 may include many other components not shown in FIG. 4. The I / O components 450 are grouped according to function merely to simplify the following discussion, and such grouping is in no way limiting. In various exemplary embodiments, the I / O components 450 can include an output component 452 and an input component 454. Output components 452 can include visual components (e.g., a display such as a plasma display panel (PDP), a light emitting diode (LED) display, a liquid crystal display (LCD), a projector, or a cathode ray tube (CRT)), acoustic components (e.g., a speaker), haptic components (e.g., vibration motors, resistive mechanisms), other signal generators, etc. Input components 454 can include alphanumeric input components (e.g., a keyboard, a touch screen configured to receive alphanumeric input, a photo-optical keyboard, or other alphanumeric input component), point-based input components (e.g., a mouse, a touchpad, a trackball, a joystick, a motion sensor, or another pointing device), tactile input components (e.g., a physical button, a touch screen that indicates the location and / or force of a touch or touch gesture, or other tactile input component), audio input components (e.g., a microphone), etc.

[0089] In further exemplary embodiments, the I / O component 450 can include a biometric component 456, a motion component 458, an environmental component 460, or a position component 462, among many other components. For example, the biometric component 456 can include components for detecting expressions (e.g., hand expressions, facial expressions, vocal expressions, body gestures, or eye tracking), measuring biosignals (e.g., blood pressure, heart rate, body temperature, sweat, or brain waves), identifying a person (e.g., voice identification, retina identification, face identification, fingerprint identification, or electroencephalogram-based identification), etc. The motion component 458 can include an acceleration sensor component (e.g., an accelerometer), a gravity sensor component, a rotation sensor component (e.g., a gyroscope), etc. The environmental components 460 may include, for example, a light sensor component (e.g., a photometer), a temperature sensor component (e.g., one or more thermometers to detect ambient temperature), a humidity sensor component, a pressure sensor component (e.g., a barometer), an acoustic sensor component (e.g., one or more microphones to detect background noise), a proximity sensor component (e.g., an infrared sensor to detect nearby objects), a gas sensor (e.g., a gas detection sensor to detect concentrations of harmful gases for safety or to measure pollutants in the air), or other components capable of providing indications, measurements, or signals corresponding to the surrounding physical environment. The position components 462 may include a location sensor component (e.g., a global positioning system (GPS) receiver component), an altitude sensor component (e.g., an altimeter, or a barometer to detect air pressure from which altitude can be derived), an orientation sensor component (e.g., a magnetometer), etc.

[0090] Communication can be implemented using a wide variety of technologies. I / O component 450 can include a communication component 464 operable to couple machine 400 to network 480 or device 470 via coupling 482 and coupling 472, respectively. For example, communication component 464 can include a network interface component or another device suitable for interfacing with network 480. In further examples, communication component 464 can include a wired communication component, a wireless communication component, a cellular communication component, a near field communication (NFC) component, a Bluetooth component (e.g., Bluetooth Low Energy), a Wi-Fi component, and other communication components for communicating via other modalities. Device 470 can be another machine or any of a wide variety of peripheral devices (e.g., coupled via USB).

[0091] Further, the communication component 464 may detect the identifier or may include a component operable to detect the identifier. For example, the communication component 464 may include a radio frequency identification (RFID) tag reader component, an NFC smart tag detection component, an optical reader component (e.g., an optical sensor for detecting one-dimensional barcodes such as Universal Product Code (UPC) barcodes, multi-dimensional barcodes such as QR Code, Aztec Code, Data Matrix, Dataglyph, MaxiCode, PDF417, Ultra Code, UCC RSS-2D barcodes, and other optical codes), or an acoustic detection component (e.g., a microphone for identifying tagged audio signals). In addition, a variety of information may be obtained via the communication component 464, such as location via Internet Protocol (IP) geolocation, location via triangulation with Wi-Fi signals, location via detection of NFC beacon signals that may indicate a particular location.

[0092] The various memories (e.g., 430, 432, 434, and / or memory of processor 410) and / or storage unit 436 may store one or more sets of instructions 416 and data structures (e.g., software) that embody or are utilized by any one or more of the methods or functions described herein. These instructions (e.g., instructions 416), when executed by processor 410, cause various operations to be performed for implementing the disclosed embodiments.

[0093] As used herein, the terms "machine storage medium," "device storage medium," and "computer storage medium" mean the same thing and may be used interchangeably. These terms refer to a single or multiple storage devices and / or storage media (e.g., a centralized or distributed database, and / or associated caches and servers) that store executable instructions and / or data. Thus, these terms are to be interpreted to include, but are not limited to, solid-state memory and optical and magnetic media, including memory that is internal or external to the processor. Specific examples of machine storage media, computer storage media, and / or device storage media include, by way of example, semiconductor memory devices, such as erasable programmable read-only memories (EPROMs), electrically erasable programmable read-only memories (EEPROMs), field programmable gate arrays (FPGAs), and non-volatile memories including flash memory devices, magnetic disks such as internal hard disks and removable disks, magneto-optical disks, and CD-ROM and DVD-ROM disks. The terms "machine storage media," "computer storage media," and "device storage media" specifically exclude carrier waves, modulated data signals, and other such media, at least some of which are covered by the term "signal media" discussed below.

[0094] In various exemplary embodiments, one or more portions of network 480 may be an ad-hoc network, an intranet, an extranet, a virtual private network (VPN), a local area network (LAN), a wireless LAN (WLAN), a wide area network (WAN), a wireless WAN (WWAN), a metropolitan area network (MAN), the Internet, a portion of the Internet, a portion of the public switched telephone network (PSTN), a plain old telephone service (POTS) network, a cellular telephone network, a wireless network, a Wi-Fi network, another type of network, or a combination of two or more such networks. For example, network 480 or a portion of network 480 may include a wireless or cellular network, and coupling 482 may be a code division multiple access (CDMA) connection, a global system for mobile communications (GSM) connection, or another type of cellular or wireless coupling. In this example, coupling 482 may implement any of a variety of types of data transfer technologies, such as single-carrier radio transmission technology (1xRTT), Evolution-Data Optimized (EVDO) technology, General Packet Radio Service (GPRS) technology, Enhanced Data Rates for GSM Evolution (EDGE) technology, 3G networks, Third Generation Partnership Project (3GPP®) including Fourth Generation Wireless (4G) networks, Universal Mobile Telecommunications System (UMTS), High Speed ​​Packet Access (HSPA), Worldwide Interoperability for Microwave Access (WiMAX), Long Term Evolution (LTE) standards, others defined by various standards bodies, other long-range protocols, or other data transfer technologies.

[0095] The instructions 416 may be transmitted or received over the network 480 using a transmission medium via a network interface device (e.g., a network interface component included in the communications component 464) and utilizing any one of several well-known transfer protocols (e.g., HTTP). Similarly, the instructions 416 may be transmitted or received using a transmission medium to the device 470 via a coupling 472 (e.g., a peer-to-peer coupling). The terms "transmission medium" and "signal medium" mean the same thing and may be used interchangeably in this disclosure. The terms "transmission medium" and "signal medium" shall be interpreted to include any intangible medium capable of storing, encoding, or carrying the instructions 416 so that they may be executed by the machine 400, as well as to include digital or analog communications signals, or other intangible media for facilitating the communication of such software. Thus, the terms "transmission medium" and "signal medium" shall be interpreted to include any form of modulated data signal, carrier wave, or the like. The term "modulated data signal" means a signal having one or more of its characteristics set or changed to encode information within the signal.

[0096] The terms "machine-readable medium," "computer-readable medium," and "device-readable medium" mean the same thing and may be used interchangeably in this disclosure. These terms are defined to include both machine storage media and transmission media. Thus, these terms include both storage devices / storage media and carrier waves / modulated data signals. [Explanation of symbols]

[0097] 100 Systems 102 CAP Server 104 CAP Clients 106 System Message Manager 108 GAI Model 110 Server Validator 112 Server Repository 114 Data Repositories 116 Server Execution Components 200 ways 300 Block Diagram 302 Software Architecture 304 Operating Systems 306 Library 308 Framework 310 Applications 312 API Calls 314 Messages 320 Kernel 322 Service 324 Driver 330 System Library 332 API Library 334 Other Libraries 350 Home Applications 352 Contact Application 354 Browser Applications 356 Book Reader Application 358 Location Application 360 Media Applications 362 Messaging Applications 364 Game Application 366 Third Party Applications 400 Machines 402 Bus 410 Processor 412 processor, multi-core processor 414 processor 416 Command 430 Memory 432 Main memory 434 Static Memory 436 Storage Unit 450 Input / Output (I / O) Components 452 Output Component 454 Input Component 456 Biometric Components 458 Movement Components 460 Environmental Components 462 Position Component 464 Communication Components 470 devices 472 Combine 480 Network 482 Combine

Claims

1. 1. A system comprising: Generative artificial intelligence (GAI) models and A server repository; Framework Server and The framework server comprises: receiving a text-based prompt from a framework client describing one or more services; creating a server-generated request including the text-based prompt and a first pre-designed system message; providing the server generation request to the GAI model to generate one or more server files defining model definitions for services executable within the framework server; storing the one or more server files in the server repository; 23. A system configured to perform operations including:

2. The system of claim 1 , wherein the one or more server files are in a declarative format.

3. The system of claim 1 , wherein the one or more server files include a schema file and a service file.

4. The system of claim 3 , wherein the schema file and the service file define an Open Data Protocol (OData) service.

5. The operation, creating a data generation request including one or more statements generated from the one or more server files and a second pre-designed system message; providing the data generation request to the GAI model to generate one or more server data files; storing said one or more server data files in a data repository; The system of claim 1 further comprising:

6. The operation, validating the one or more server files; in response to determining that the one or more server files fail the validation, retrying the providing of the server generated request to the GAI model. The system of claim 5 , further comprising:

7. The system of claim 6 , wherein the verifying comprises attempting to compile the one or more server files.

8. The system of claim 6 , wherein the validating comprises running one or more tests on the one or more server files using the one or more server data files.

9. 1. A method comprising: receiving a text-based prompt from a framework client describing one or more services; creating a server-generated request that includes the text-based prompt and a first pre-designed system message; providing the server generation request to a GAI model to generate one or more server files defining model definitions for services executable within a framework server; storing the one or more server files in a server repository; The method includes:

10. The method of claim 9 , wherein the one or more server files are in a declarative format.

11. The method of claim 9 , wherein the one or more server files include a schema file and a service file.

12. The method of claim 11 , wherein the schema file and the service file define an Open Data Protocol (OData) service.

13. creating a data generation request including one or more statements generated from the one or more server files and a second pre-designed system message; providing the data generation request to the GAI model to generate one or more server data files; storing the one or more server data files in a data repository; 10. The method of claim 9, further comprising:

14. validating the one or more server files; in response to determining that the one or more server files fail the validation, retrying the providing of the server generated request to the GAI model; 14. The method of claim 13, further comprising:

15. 15. The method of claim 14, wherein the step of validating comprises the step of attempting to compile the one or more server files.

16. 15. The method of claim 14, wherein the verifying step comprises running one or more tests on the one or more server files using the one or more server data files.

17. A non-transitory machine-readable medium storing instructions that, when executed by one or more processors, cause the one or more processors to: receiving a text-based prompt from a framework client describing one or more services; creating a server-generated request including the text-based prompt and a first pre-designed system message; providing the server generation request to a GAI model to generate one or more server files defining a model definition for a service executable within a framework server; storing said one or more server files in a server repository; 4. A non-transitory machine-readable medium for causing operations to be performed, including:

18. 20. The non-transitory machine-readable medium of claim 17, wherein the one or more server files are in a declarative format.

19. 20. The non-transitory machine-readable medium of claim 17, wherein the one or more server files include a schema file and a service file.

20. 20. The non-transitory machine-readable medium of claim 19, wherein the schema file and the service file define an Open Data Protocol (OData) service.

Citation Information

Cited By

  • Program and information collection system

    JP7809308B1