Human-computer interaction interface dynamic generation system and method based on large language model agent

Abstract

The application provides a human-computer interaction interface dynamic generation system and method based on a large language model agent, the system comprises a skill management module, and a skill registry, a skill discovery unit, a skill draft storage unit, a skill description file storage unit and an artificial review and promotion unit are arranged in the skill management module; the corresponding human-computer interaction interface can be generated in real time according to the natural language intention of a user, and the problem that a fixed page cannot cover temporary needs is reduced; through the arrangement of the large language model agent scheduling module, the skill description file and the general interface scheduling module can be connected to an external service interface, so that the newly added interface capability is changed from an artificial coding process to a skill description file review process, and the function expansion cycle is shortened.

Description

Technical Field

[0001] This invention relates to the technical field of human-computer interaction, and specifically to a system and method for dynamically generating human-computer interaction interfaces based on large language model proxies. Background Technology

[0002] With the development of large language models and intelligent agent technologies, users are increasingly expressing task requirements through natural language or speech. In traditional software systems, the human-computer interaction interface is usually pre-written by developers during the development phase, or rendered by a low-code platform using pre-configured files. While these methods can meet known business processes, for user-submitted or unmodeled requirements, developers still need to add pages, integrate interfaces, and redeploy the system.

[0003] Existing technologies include solutions that use large language models to assist in generating front-end code. This approach typically involves the large language model generating page source code based on user requirements, which developers then incorporate into the project and execute the compilation, packaging, and deployment process. While this reduces some coding workload, it still falls under the category of page generation during the development phase, rather than runtime, real-time UI generation.

[0004] In summary, the existing human-computer interaction interfaces still have the following defects and shortcomings in practical use: 1) Interface generation relies on preset pages or preset configurations. When user needs exceed the preset range, the system cannot immediately generate the corresponding human-computer interaction interface.

[0005] 2) External service interface integration relies on manual coding. When adding new data sources, it is necessary to write interface adaptation, parameter mapping, and interface binding logic, which takes a long time.

[0006] 3) Generating executable code directly from a large language model carries risks. Directly executing the scripts or page code output by the model may lead to unexpected situations such as code injection, unauthorized calls, or loss of UI control.

[0007] 4) Coupling between UI code and client-side design. Browser, mobile, and desktop interfaces typically require separate development, making it difficult to reuse the same generated result.

[0008] 5) Temporarily generated interfaces are difficult to use continuously. Even if the system can generate an interface once, the model and interface often need to be called again after the page is refreshed, which cannot form a long-term workbench.

[0009] Therefore, there is an urgent need to provide a new solution to address the defects and shortcomings of the existing technologies. Summary of the Invention

[0010] To address the shortcomings and deficiencies in existing technologies, this invention provides a system and method for dynamically generating human-computer interaction interfaces based on large language model proxies.

[0011] The specific solution provided by this invention is as follows: A dynamic generation system for human-computer interaction interfaces based on a large language model agent, the system comprising: The operator terminal module provides a natural language input environment, a voice input environment, and an interface output environment for users to input natural language intentions. The large language model proxy scheduling module is connected to the operator terminal module to receive the natural language intent input by the user, and according to the parsing result of the natural language intent, sends the generated skill call request to the skill management module and the general interface scheduling module, and sends the generated interface description language to the interface description generation and verification module. The large language model is data-connected to the large language model proxy scheduling module to parse the natural language intent input by the user, generate the corresponding skill call request based on the parsing result, and generate and output the corresponding interface description language based on the parsing result of the natural language intent and the structured result returned by the external service interface. The skill management module is data-connected to the large language model proxy scheduling module and the general interface scheduling module, so as to provide the general interface scheduling module with a skill description file for calling external service interfaces according to the skill call request; A general interface scheduling module, one end of which is connected to the large language model proxy scheduling module and the skill management module, and the other end is connected to the external service interface, so as to call the external service interface according to the skill call request and the interface call specification in the skill description file. The interface description generation and verification module is connected to the large language model proxy scheduling module to verify the generated interface description language. A multi-form interface rendering module is connected to the interface description generation and verification module to generate a corresponding human-computer interaction interface based on the verified interface description language. Its features are: The skill management module internally includes a skill registry, a skill discovery unit, a skill draft storage unit, a skill description file storage unit, and a manual review and improvement unit; among which... The skill registry generates a list of skills that can be selected by the large language model based on the skill description file. When the skill discovery unit does not have a skill in the skill list that matches the user's natural language intent, it generates a candidate skill description file and sends it to the skill draft storage unit for storage. The skill draft storage unit internally stores candidate skill description files generated by the skill discovery unit; The skill description file storage unit stores skill description files and candidate skill description files that have been manually reviewed and confirmed by the improvement unit. The manual review and enhancement unit confirms the candidate skill description files generated by the skill discovery unit. Successfully confirmed candidate skill description files are moved to the skill description file storage and the skill registry is reloaded to add the newly added skill description files to the skill list.

[0012] In a further preferred embodiment of the present invention, when the general interface scheduling module calls an external service interface: 1) First, read the interface call specification in the skill description file; 2) Then, fill in the call parameters in the skill call request output by the large language model into the corresponding positions in the corresponding interface address, path parameters or query parameters according to their definitions in the interface call specification; 3) Finally, the data returned by the external service interface is parsed into structured results and returned to the large language model agent scheduling module.

[0013] As a further preferred embodiment of the present invention, in the skill management module, The skill description file shall include at least the skill name, usage description, parameter structure, interface call specification, and manual description text; wherein... The interface call specification includes at least the request method, interface address, path parameters, query parameters, request headers, timeout time, and return result processing method.

[0014] As a further preferred embodiment of the present invention, in the skill management module, The candidate skill description file is stored only in the skill draft storage unit before it is confirmed or after the confirmation fails, and cannot be provided to the large language model for use by the skill registry. The candidate skill description file is stored in the skill description file storage unit only after it is successfully confirmed, and can be provided to the large language model for use by the skill registry.

[0015] As a further preferred embodiment of the present invention, the interface description generation and verification module includes a syntax verification unit, a syntax repair unit, and a node whitelist verification unit; wherein... The syntax verification unit performs standard parsing on the interface description language; when the parsing result conforms to the preset structure specification, the standard parsing is considered successful and the interface description language is sent to the node whitelist verification unit; when the parsing result does not conform to the preset structure specification, the standard parsing is considered to have failed and the interface description language is sent to the syntax repair unit. The syntax repair unit performs repair parsing on the interface description language when standard parsing fails. This repair parsing only corrects recoverable format errors in the interface description language when standard parsing fails. These recoverable format errors include at least missing parentheses or quotation marks, forced type conversion of field values, and correctable spelling errors in field names. If the parsing result conforms to the preset structure specifications, the repair parsing is considered successful, and the repaired interface description language is sent to the node whitelist verification unit. If the parsing result does not conform to the preset structure specifications, the repair parsing is considered a failure, and a corresponding fallback interface description is generated based on the failed interface description language. The node whitelist verification unit verifies whether the node type in the verification interface description language belongs to a preset node set.

[0016] As a further preferred embodiment of the present invention, the preset node set includes at least information card nodes, grid nodes, statistical value nodes, list nodes, form nodes, chart nodes, and partition container nodes; wherein... The chart nodes are selected from one or more combinations of line charts, bar charts, or pie charts; The partition container node can generate multiple independent interface areas based on the natural language intent input by the same user.

[0017] As a further preferred embodiment of the present invention, in the multi-form interface rendering module... The interface description language is a non-executable data structure, and the interface description language includes at least a node type field and a node attribute field; The multi-form interface rendering module selects predefined components according to the node type field and sets the component content according to the node attribute field to generate a human-computer interaction interface that corresponds to the user's natural language intent in real time. The multi-form interface rendering module can be deployed in one or more of the following: browser, mobile embedded browsing component, desktop client, or native application client.

[0018] As a further preferred embodiment of the present invention, the system further includes: The interface state persistence module is data-connected to the multi-form interface rendering module. The interface state persistence module internally stores a snapshot of the interface description language of the generated interface, user input text, and tool call trajectory. Furthermore, the multi-form interface rendering module can restore historical interfaces based on interface description language snapshots.

[0019] As a further preferred embodiment of the present invention, the interface state persistence module is further provided with a fixed workbench unit, which copies the user-selected interface description language snapshot as a fixed workbench entry and prioritizes rendering the fixed workbench entry in the subsequent generation process.

[0020] Furthermore, the present invention also provides a method for dynamically generating human-computer interaction interfaces based on large language model proxies, applied to the aforementioned system for dynamically generating human-computer interaction interfaces based on large language model proxies, characterized in that: the method includes the following steps: S100: The user inputs natural language intent through the operator's terminal module; S200: The large language model agent scheduling module receives the skill list generated from the natural language intent and the skill registry; S300: The large language model parses the natural language intent and determines whether a skill needs to be invoked based on the skill invocation request and skill list generated by the parsing results; S401: When a matching skill exists, the general interface scheduling module calls the external service interface according to the corresponding skill description file and returns the structured result; S402: When no matching skill exists, the skill discovery unit generates a candidate skill description file and sends it to the skill draft storage unit for storage. After manual review and confirmation by the improvement unit, it is moved to the skill description file storage unit for storage and triggers the skill registry to be reloaded to add the newly added skill description file to the skill list. The general interface scheduling module calls the external service interface according to the corresponding newly added skill description file and returns the structured result. S500: The large language model generates an interface description language based on the parsing results of natural language intent and the structured results returned by external service interfaces; S600: The interface description generation and verification module performs standard parsing on the interface description language. If the standard parsing fails, it performs repair parsing and then verifies whether its node type belongs to the preset node set. S700: The multi-form interface rendering module generates the corresponding human-computer interaction interface based on the verified interface description language. S800: The interface state persistence module saves the interface description language snapshot, user input text, and tool call trajectory of the generated interface, and copies the interface description language snapshot selected by the user as a fixed workbench entry, and prioritizes rendering the fixed workbench entry in subsequent generation processes.

[0021] Compared with existing technologies, the technical effects that this invention can achieve include: 1) This invention provides a system and method for dynamically generating human-computer interaction interfaces based on large language model agents, which can generate corresponding human-computer interaction interfaces in real time according to the user's natural language intent, reducing the problem that fixed pages cannot cover temporary needs.

[0022] 2) This invention provides a system and method for dynamically generating human-computer interaction interfaces based on a large language model agent. By setting up a large language model agent scheduling module, it is possible to connect skill description files and general interface scheduling modules to external service interfaces, so that the process of adding new interface capabilities is changed from manual coding process to skill description file review process, thus shortening the function expansion cycle.

[0023] 3) This invention provides a dynamic generation system and method for human-computer interaction interfaces based on large language model proxies. By limiting the interface description language to a non-executable data structure and performing standard parsing before rendering, and performing repair parsing when standard parsing fails, and then verifying whether its node type belongs to a preset node set, the security risk of directly executing the model generation code is reduced.

[0024] 4) This invention provides a dynamic generation system and method for human-computer interaction interfaces based on large language model agents. By setting up a multi-form interface rendering module, the same interface description language can be reused in browsers, mobile embedded browsing components, desktop clients or native application clients.

[0025] 5) This invention provides a system and method for dynamically generating human-computer interaction interfaces based on a large language model agent. By setting up an interface state persistence module, the temporarily generated interface can be restored, fixed and used for a long time, reducing the cost of repeatedly calling the large language model and external service interfaces.

[0026] 6) This invention provides a dynamic generation system and method for human-computer interaction interfaces based on large language model agents. Through a skill discovery unit, skill draft storage, and manual review and improvement unit, the system can generate candidate skills when there are no matching skills. After manual review, the skills are hot-loaded and take effect, thereby forming a controllable capability expansion closed loop. Attached Figure Description

[0027] Figure 1 The diagram shown is a logical structure diagram of the generation system provided by the present invention.

[0028] Figure 2 The diagram shows a process schematic of the generation system provided by the present invention.

[0029] Figure 3 The diagram shows the steps of the generation method provided by the present invention. Detailed Implementation

[0030] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0031] In the description of this invention, it should be noted that the terms "upper," "lower," "inner," "outer," "front end," "rear end," "both ends," "one end," and "the other end," etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings. They are used only for the convenience of describing this invention and for simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation. Therefore, they should not be construed as limitations on this invention. Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance.

[0032] In the description of this invention, it should be noted that, unless otherwise explicitly specified and limited, the terms "installed," "equipped with," "connected," etc., should be interpreted broadly. For example, "connection" can be a fixed connection, a detachable connection, or an integral connection; it can be a mechanical connection or an electrical connection; it can be a direct connection or an indirect connection through an intermediate medium; it can be a connection within two components. Those skilled in the art can understand the specific meaning of the above terms in this invention based on the specific circumstances.

[0033] [First Embodiment] like Figures 1-2 The figure shown is a dynamic generation system for human-computer interaction interfaces based on a large language model agent provided in the first embodiment of the present invention. The system includes: The operator terminal module provides a natural language input environment, a voice input environment, and an interface output environment for users to input natural language intentions. As one preferred implementation, the natural language input environment can be a text input box, the voice input environment can be a speech-to-text unit, and the interface output environment can be any one or more combinations of a browser page, a mobile embedded browsing component, a desktop client window, or a native application client interface to meet different input and output needs.

[0034] The large language model proxy scheduling module is connected to the operator terminal module to receive the natural language intent input by the user. Based on the parsing result of the natural language intent, it sends the generated skill call request to the skill management module and the general interface scheduling module, and sends the generated interface description language to the interface description generation and verification module. The large language model is connected to the large language model proxy scheduling module to parse the natural language intent input by the user, generate the corresponding skill call request based on the parsing result, and generate and output the corresponding interface description language based on the parsing result of the natural language intent and the structured result returned by the external service interface. If the current intent requires calling an external service interface, the large language model will output a skill call request. If the current intent already has enough information to avoid calling external service interfaces, the large language model will output the interface description language.

[0035] It is worth noting that the large language model selected in this embodiment can be either a locally deployed model or a remotely deployed model. This embodiment does not limit the specific type of large language model selected.

[0036] The skill management module is connected to the large language model proxy scheduling module and the general interface scheduling module to provide the general interface scheduling module with skill description files for calling external service interfaces based on skill call requests. The skill management module provided in this embodiment includes a skill registry, a skill discovery unit, a skill draft storage unit, a skill description file storage unit, and a manual review and improvement unit; wherein... The skill registry generates a list of skills that can be selected by the large language model based on the skill description file; When the skill discovery unit does not have a skill in the skill list that matches the user's natural language intent, it generates a candidate skill description file and sends it to the skill draft storage unit for storage. The skill draft storage unit internally stores candidate skill description files generated by the skill discovery unit; The skill description file storage unit stores skill description files as well as candidate skill description files that have been manually reviewed and confirmed by the enhancement unit. The manual review and enhancement unit confirms the candidate skill description files generated by the skill discovery unit. Successfully confirmed candidate skill description files are moved to the skill description file storage and the skill registry is reloaded to add the new skill description files to the skill list. In this way, the new ability can take effect without restarting the system.

[0037] It is worth noting that in the skill management module provided in this embodiment, Candidate skill description files are stored only in the skill draft storage unit before being confirmed or after confirmation failure, and cannot be provided to the large language model for use by the skill registry. Candidate skill description files are stored in the skill description file storage unit only after successful confirmation, and can be provided to the large language model for use by the skill registry.

[0038] In the skill management module provided in this embodiment, the skill description file is used to express the capabilities of external service interfaces. A skill description document should include at least the skill name, purpose description, parameter structure, interface call specifications, and manual instructions. Skill Name: A unique identifier for the skill, which the large language model selects from the skill list, such as "weather.query"; Usage description: Describe the capability boundaries of this skill in natural language, so that large language models can determine whether the current intent matches it, such as "query the current weather of a specified city"; Parameter structure: Declare the parameters required to invoke the skill and their types, such as {"city":"string"}; Manual Explanation Text: Usage notes supplemented by human review and improvement units to improve the accuracy of the large language model in selecting this skill.

[0039] The complete example is: {"Skill Name":"weather.query","Purpose Description":"Query the current weather of a specified city","Parameter Structure":{"city":"string"},"Interface Call Specification":{"Request Method":"GET","Interface Address":"https: / / ***.*******.*** / weather","Query Parameters":{"city":"a certain city"}},"Manual Description Text":"Used to display the weather information of a specified city"}; An API call specification describes the request method, API address, path parameters, query parameters, request headers, timeout, and return value handling method. Therefore, an API call specification should at least include the request method, API address, path parameters, query parameters, request headers, timeout, and return result handling method. The meanings and examples of each field are as follows: Request method: The method used to make the request, such as "GET" or "POST"; Interface address: The access address of the external service interface, such as "https: / / ***.*******.*** / stock"; Path parameters: Parameters embedded in the interface address path segment, such as {"code":"600000"}; Query parameters: Parameters appended to the query string, such as {"range":"1d"}; Request headers: Headers that must be included when making the call, such as authentication information {"Authorization":"Bearer"} <token>"}; Timeout: The maximum allowed waiting time for a single call. If this timeout is exceeded, the call is considered to have failed, such as "3000 milliseconds". Return result processing method: rules for parsing the interface returned data into structured results, such as "reading the data field in the returned data as a structured result".

[0040] Through this skill description file, the system can directly call external service interfaces through the general interface scheduling module without writing dedicated adaptation code.

[0041] The general interface scheduling module is connected to the large language model proxy scheduling module and the skill management module on one end, and to the external service interface on the other end, so as to call the external service interface according to the skill call request and the interface call specification in the skill description file. In the general interface scheduling module provided in this embodiment, when calling an external service interface: 1) First, read the interface call specification in the skill description file; 2) Then, fill in the call parameters in the skill call request output by the large language model into the corresponding positions in the corresponding interface address, path parameters or query parameters according to their definitions in the interface call specification; 3) Finally, the data returned by the external service interface is parsed into structured results and returned to the large language model agent scheduling module.

[0042] The interface description generation and verification module is connected to the large language model proxy scheduling module to verify the generated interface description language. The interface description language in this embodiment is a non-executable data structure that does not contain script code, page source code, or specific front-end framework code. The interface description language includes at least a node type field and a node attribute field. The node type field describes the predefined component corresponding to the node, such as an information card, list, form, chart, or partition container; the node attribute field describes the component's title, content, data, link, or submission parameters. As an example, a node in the interface description language can be represented as: {"Node Type":"Chart Node","Node Attribute":{"Chart Type":"Line Chart","Title":"Stock Trend","Data":[{"Time":"09:30","Price":10.2},{"Time":"10:00","Price":10.5}]}} (the above values ​​are only examples).

[0043] In this embodiment, the interface description generation and verification module includes a syntax verification unit, a syntax repair unit, and a node whitelist verification unit; wherein, The syntax verification unit performs standard parsing on the interface description language; when the parsing result conforms to the preset structure specification, the standard parsing is considered successful and the interface description language is sent to the node whitelist verification unit; when the parsing result does not conform to the preset structure specification, the standard parsing is considered to have failed and the interface description language is sent to the syntax repair unit. The syntax repair unit performs repair parsing on the interface description language when standard parsing fails. Repair parsing only corrects correctable format errors in the interface description language when standard parsing fails. Correctable format errors include at least missing parentheses or quotation marks, forced conversion of field value types (such as outputting a number as a string), and correctable spelling errors in field names. When the parsing result of the repaired parsing conforms to the preset structure specification, the repaired parsing is considered successful, and the repaired interface description language is sent to the node whitelist verification unit. When the parsing result of the repaired parsing does not conform to the preset structure specification, the repaired parsing is considered to have failed, and a corresponding fallback interface description is generated based on the interface description language that failed to be repaired. The node whitelist verification unit verifies whether the node type in the verification interface description language belongs to the preset node set.

[0044] The purpose of setting up syntax verification units, syntax repair units, and node whitelist verification units is that, since the output of large language models has a certain degree of randomness, slight format jitter does not affect semantic integrity. If no repair step is set, the interface description language that could have been used will be directly discarded, reducing the success rate and efficiency of interface generation.

[0045] By setting up a syntax validation unit, a syntax repair unit, and a node whitelist validation unit, the three validation steps progressively filter from three levels: format validity, repairability, and node security. Each step targets different types of invalid data and therefore cannot be substituted for one another. 1) The syntax validation unit excludes interface description languages ​​with illegal structures that cannot be parsed into legal structures, such as data that cannot be parsed due to missing required fields, disordered nesting, or illegal characters; 2) The syntax repair unit does not exclude data, but rather salvages interface description languages ​​that have only minor format errors but are semantically complete (such as interface description languages ​​with minor format errors such as missing brackets or type casting errors). It avoids mistakenly killing usable results due to format jitter in the output of the large language model. It is only ultimately excluded when the data is still invalid after repair. 3) Although the node whitelist verification unit excludes legally formatted interface description languages ​​that include node types outside the preset node set, such data will lead to the rendering of unreviewed components, which is a major source of security risks.

[0046] After the above three layers of filtering, the interface description language entering the rendering stage is both formatted correctly and node-safe. Combined with the limitation that the interface description language itself is a non-executable data structure, the goal of not executing the model's output content is achieved.

[0047] The preset node set includes at least information card nodes, grid nodes, statistical value nodes, list nodes, form nodes, chart nodes, and partition container nodes; among them, Chart nodes can be selected from one or more combinations of line charts, bar charts, or pie charts; The partition container node can generate multiple independent interface areas based on the natural language intent input by the same user.

[0048] The purpose of this design is to generate multiple independent, heterogeneous interface areas with a single natural language intent from the user, eliminating the need for separate interactions for each type of information. For example, when a user inputs "My Morning Panel: City Weather, Stock Trends, Today's Tech News," the partition container node can simultaneously generate a weather partition, a stock trend chart partition, and a news list partition. Each partition contains an independently renderable child node, and each partition renders, updates, and interacts independently without affecting others. This allows information from different sources and in different formats to be presented side-by-side within the same human-computer interaction interface, increasing information density and the completeness of a single interaction. Furthermore, because partition container nodes can recursively nest child nodes, complex interfaces can be organized in a tree structure, facilitating expansion.

[0049] The system also includes a multi-form interface rendering module, which is connected to the interface description generation and verification module to generate the corresponding human-computer interaction interface based on the verified interface description language. The interface description language is a non-executable data structure, and it includes at least a node type field and a node attribute field. It does not contain script code, page source code, or specific front-end framework code. For example: {"Node Type":"Chart Node","Node Attribute":{"Chart Type":"Line Chart","Title":"Stock Trend","Data":[{"Time":"09:30","Price":10.2},{"Time":"10:00","Price":10.5}]}}; where the node type field specifies which predefined component (information card, list, form, chart, partition container, etc.) the node corresponds to, and the node attribute field describes the component's title, content, data, link, or submission parameters (the above values ​​are just examples). Because it only describes "what to display" and does not contain "how to execute" code, the rendering end does not need to execute the model output to complete the interface presentation.

[0050] The multi-form interface rendering module selects predefined components based on the node type field and sets the component content based on the node attribute field to generate a human-computer interaction interface that corresponds to the user's natural language intent in real time. When the node is a grid node or a partition container node, the multi-form interface rendering module recursively renders its child nodes.

[0051] For example: When a node's node type field is set to "chart node" and its node attribute field contains the chart type "line chart" and stock trend data, the multi-form interface rendering module selects the line chart component from the predefined components and fills the title and data from the node attribute field into the component, thereby rendering the stock trend chart. When the node type field is a list node, the list component is selected, and the list is rendered using the item data in the node attribute field.

[0052] It is important to emphasize that the multi-form interface rendering module only "selects" from the preset component library according to the node type field and "fills" according to the node attribute field. It does not execute any content in the interface description language throughout the process, so there is no risk of executing the model output code.

[0053] The multi-form interface rendering module can be deployed in one or more of the following: browser, mobile embedded browsing component, desktop client or native application client.

[0054] Based on this, the system also includes: The interface state persistence module is connected to the multi-form interface rendering module. The interface state persistence module internally stores a snapshot of the interface description language of the generated interface, user input text, and tool call trajectory. Furthermore, the multi-form interface rendering module can restore historical interfaces based on snapshots of the interface description language.

[0055] As a preferred option, the interface state persistence module also includes a fixed workbench unit. The fixed workbench unit copies the user-selected interface description language snapshot as a fixed workbench entry and prioritizes rendering the fixed workbench entry during subsequent generation processes.

[0056] Specific examples: When a user inputs "My Morning Panel: City Weather, Stock Trends, Today's Tech News," the large language model can select the weather skill, stock data skill, and news skill respectively. The general interface scheduling module calls the corresponding external service interface, and the interface description generation and verification module generates partition container nodes. These partition container nodes include a weather partition, a stock trend chart partition, and a news list partition, each containing an independently renderable child node. In this way, a single natural language intent can generate multiple heterogeneous interface regions.

[0057] After a user generates a stock chart interface during the first session, the interface state persistence module saves a snapshot of the interface's description language. When the user refreshes the client, the system does not re-invoke the large language model or the stock data interface; instead, the multi-form interface rendering module directly restores the interface based on the interface description language snapshot. If the user pins the stock chart to the workbench, the pinned workbench unit saves an independent pinned workbench entry and prioritizes rendering this entry at the start of subsequent sessions.

[0058] The purpose of this setting is: 1) After a user pins a frequently used interface as a fixed workbench item, the multi-form interface rendering module will render the item first when the subsequent session starts, without the need to re-enter the natural language intent, and the interface will be visible immediately. 2) Since the system directly renders based on the saved interface description language snapshot, there is no need to call the large language model for inference again, nor is there a need to call the external service interface again, thereby reducing the model inference cost and interface call overhead, and shortening the interface rendering latency. 3) This allows the temporary interfaces that are dynamically generated at one time to be preserved as stable workbenches that can be reused for a long time, bridging the gap between "dynamic generation" and "long-term use". This is also the reason why fixed workbench items are saved separately from the interface description language snapshots - snapshots are used to restore historical interfaces, while fixed workbench items are used for long-term priority presentation, and the two have different purposes.

[0059] [Second Embodiment] like Figure 3 As shown, the second embodiment of the present invention also provides a method for dynamically generating human-computer interaction interfaces based on large language model proxies, applied to the human-computer interaction interface dynamic generation system based on large language model proxies mentioned in the first embodiment, including the following steps: S100: The user inputs natural language intent through the operator's terminal module; S200: The large language model agent scheduling module receives the skill list generated from the natural language intent and the skill registry; S300: The large language model parses the natural language intent and determines whether a skill needs to be invoked based on the skill invocation request and skill list generated by the parsing results; S401: When a matching skill exists, the general interface scheduling module calls the external service interface according to the corresponding skill description file and returns the structured result; S402: When no matching skill exists, the skill discovery unit generates a candidate skill description file and sends it to the skill draft storage unit for storage. After manual review and confirmation by the improvement unit, it is moved to the skill description file storage unit for storage and triggers the skill registry to be reloaded to add the newly added skill description file to the skill list. The general interface scheduling module calls the external service interface according to the corresponding newly added skill description file and returns the structured result. S500: The large language model generates an interface description language based on the parsing results of natural language intent and the structured results returned by external service interfaces; S600: The interface description generation and verification module performs standard parsing on the interface description language. If the standard parsing fails, it performs repair parsing and then verifies whether its node type belongs to the preset node set. S700: The multi-form interface rendering module generates the corresponding human-computer interaction interface based on the verified interface description language. S800: The interface state persistence module saves the interface description language snapshot, user input text, and tool call trajectory of the generated interface, and copies the interface description language snapshot selected by the user as a fixed workbench item, and prioritizes rendering the fixed workbench item in subsequent generation processes.

[0060] It will be apparent to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above, and that the invention can be implemented in other specific forms without departing from its spirit or essential characteristics. Therefore, the embodiments should be considered in all respects as exemplary and non-limiting, and the scope of the invention is defined by the appended claims rather than the foregoing description. Thus, all variations falling within the meaning and scope of equivalents of the claims are intended to be included within the present invention. No reference numerals in the claims should be construed as limiting the scope of the claims.< / token>

Claims

1. A dynamic generation system for human-computer interaction interfaces based on a large language model agent, the system comprising: The operator terminal module provides a natural language input environment, a voice input environment, and an interface output environment for users to input natural language intentions. The large language model proxy scheduling module is connected to the operator terminal module to receive the natural language intent input by the user, and according to the parsing result of the natural language intent, sends the generated skill call request to the skill management module and the general interface scheduling module, and sends the generated interface description language to the interface description generation and verification module. The large language model is data-connected to the large language model proxy scheduling module to parse the natural language intent input by the user, generate the corresponding skill call request based on the parsing result, and generate and output the corresponding interface description language based on the parsing result of the natural language intent and the structured result returned by the external service interface. The skill management module is data-connected to the large language model proxy scheduling module and the general interface scheduling module, so as to provide the general interface scheduling module with a skill description file for calling external service interfaces according to the skill call request; A general interface scheduling module, one end of which is connected to the large language model proxy scheduling module and the skill management module, and the other end is connected to the external service interface, so as to call the external service interface according to the skill call request and the interface call specification in the skill description file. The interface description generation and verification module is connected to the large language model proxy scheduling module to verify the generated interface description language. A multi-form interface rendering module is connected to the interface description generation and verification module to generate a corresponding human-computer interaction interface based on the verified interface description language. Its features are: The skill management module internally includes a skill registry, a skill discovery unit, a skill draft storage unit, a skill description file storage unit, and a manual review and improvement unit; among which... The skill registry generates a list of skills that can be selected by the large language model based on the skill description file. When the skill discovery unit does not have a skill in the skill list that matches the user's natural language intent, it generates a candidate skill description file and sends it to the skill draft storage unit for storage. The skill draft storage unit internally stores candidate skill description files generated by the skill discovery unit; The skill description file storage unit stores skill description files and candidate skill description files that have been manually reviewed and confirmed by the improvement unit. The manual review and enhancement unit confirms the candidate skill description files generated by the skill discovery unit. Successfully confirmed candidate skill description files are moved to the skill description file storage and the skill registry is reloaded to add the newly added skill description files to the skill list.

2. The human-computer interaction interface dynamic generation system based on large language model agent according to claim 1, characterized in that: In the general interface scheduling module, when calling an external service interface: 1) First, read the interface call specification in the skill description file; 2) Then, fill in the call parameters in the skill call request output by the large language model into the corresponding positions in the corresponding interface address, path parameters or query parameters according to their definitions in the interface call specification; 3) Finally, the data returned by the external service interface is parsed into structured results and returned to the large language model agent scheduling module.

3. The human-computer interaction interface dynamic generation system based on large language model agent according to claim 1, characterized in that: In the skill management module The skill description file shall include at least the skill name, usage description, parameter structure, interface call specification, and manual description text; wherein... The interface call specification includes at least the request method, interface address, path parameters, query parameters, request headers, timeout time, and return result processing method.

4. The human-computer interaction interface dynamic generation system based on large language model agent according to claim 1, characterized in that: In the skill management module The candidate skill description file is stored only in the skill draft storage unit before it is confirmed or after the confirmation fails, and cannot be provided to the large language model for use by the skill registry. The candidate skill description file is stored in the skill description file storage unit only after it is successfully confirmed, and can be provided to the large language model for use by the skill registry.

5. The human-computer interaction interface dynamic generation system based on large language model agent according to claim 1, characterized in that: The interface description generation and verification module includes a syntax verification unit, a syntax repair unit, and a node whitelist verification unit; wherein... The syntax verification unit performs standard parsing on the interface description language; when the parsing result conforms to the preset structure specification, the standard parsing is considered successful and the interface description language is sent to the node whitelist verification unit; when the parsing result does not conform to the preset structure specification, the standard parsing is considered to have failed and the interface description language is sent to the syntax repair unit. The syntax repair unit performs repair parsing on the interface description language when standard parsing fails. This repair parsing only corrects recoverable format errors in the interface description language when standard parsing fails. These recoverable format errors include at least missing parentheses or quotation marks, forced type conversion of field values, and correctable spelling errors in field names. If the parsing result conforms to the preset structure specifications, the repair parsing is considered successful, and the repaired interface description language is sent to the node whitelist verification unit. If the parsing result does not conform to the preset structure specifications, the repair parsing is considered a failure, and a corresponding fallback interface description is generated based on the failed interface description language. The node whitelist verification unit verifies whether the node type in the verification interface description language belongs to a preset node set.

6. The human-computer interaction interface dynamic generation system based on large language model agent according to claim 5, characterized in that: The preset node set includes at least information card nodes, grid nodes, statistical value nodes, list nodes, form nodes, chart nodes, and partition container nodes; among them... The chart nodes are selected from one or more combinations of line charts, bar charts, or pie charts; The partition container node can generate multiple independent interface areas based on the natural language intent input by the same user.

7. The human-computer interaction interface dynamic generation system based on large language model agent according to claim 1, characterized in that: In the multi-form interface rendering module The interface description language is a non-executable data structure, and the interface description language includes at least a node type field and a node attribute field; The multi-form interface rendering module selects predefined components according to the node type field and sets the component content according to the node attribute field to generate a human-computer interaction interface that corresponds to the user's natural language intent in real time. The multi-form interface rendering module can be deployed in one or more of the following: browser, mobile embedded browsing component, desktop client, or native application client.

8. The human-computer interaction interface dynamic generation system based on large language model agent according to claim 7, characterized in that: The system also includes: The interface state persistence module is data-connected to the multi-form interface rendering module. The interface state persistence module internally stores a snapshot of the interface description language of the generated interface, user input text, and tool call trajectory. Furthermore, the multi-form interface rendering module can restore historical interfaces based on interface description language snapshots.

9. The human-computer interaction interface dynamic generation system based on large language model agent according to claim 8, characterized in that: The interface state persistence module also includes a fixed workbench unit, which copies the user-selected interface description language snapshot as a fixed workbench entry and prioritizes rendering the fixed workbench entry during subsequent generation processes.

10. A method for dynamically generating human-computer interaction interfaces based on large language model proxies, applied to the human-computer interaction interface dynamic generation system based on large language model proxies as described in any one of claims 1-9, characterized in that: The method includes the following steps: S100: The user inputs natural language intent through the operator's terminal module; S200: The large language model agent scheduling module receives the skill list generated from the natural language intent and the skill registry; S300: The large language model parses the natural language intent and determines whether a skill needs to be invoked based on the skill invocation request and skill list generated from the parsing results; S401: When a matching skill exists, the general interface scheduling module calls the external service interface according to the corresponding skill description file and returns the structured result; S402: When no matching skill exists, the skill discovery unit generates a candidate skill description file and sends it to the skill draft storage unit for storage. After manual review and confirmation by the improvement unit, it is moved to the skill description file storage unit for storage and triggers the skill registry to be reloaded to add the newly added skill description file to the skill list. The general interface scheduling module calls the external service interface according to the corresponding newly added skill description file and returns the structured result. S500: The large language model generates an interface description language based on the parsing results of natural language intent and the structured results returned by external service interfaces; S600: The interface description generation and verification module performs standard parsing on the interface description language. If the standard parsing fails, it performs repair parsing and then verifies whether its node type belongs to the preset node set. S700: The multi-form interface rendering module generates the corresponding human-computer interaction interface based on the verified interface description language. S800: The interface state persistence module saves the interface description language snapshot, user input text, and tool call trajectory of the generated interface, and copies the interface description language snapshot selected by the user as a fixed workbench entry, and prioritizes rendering the fixed workbench entry in subsequent generation processes.

Images