Man-machine interaction method and system based on MCP large language model dynamic graphical user interface generation

Abstract

The invention discloses a man-machine interaction method and system based on MCP large language model dynamic graphical user interface generation, and relates to the field of man-machine interaction, and the method comprises the steps that an intelligent back end maps an identified user interaction intention into a structured MCP message frame through a protocol encoder; after the rendering front end receives the message frame, a virtual component structure tree is generated through strong type protocol specification verification, an interface updating patch is obtained through difference calculation, and a local component is dynamically instantiated to generate a real-time interaction interface; then capturing user operation, packaging the user operation into a state feedback message, returning the state feedback message to a rear end, triggering incremental reasoning of the model to determine whether to update an interface, and forming an intention-protocol-rendering-feedback interactive closed loop; according to the method, dynamic interaction of generation and evolution of a large language model interface along with natural language dialogue is achieved, the stability and safety of generation are improved through protocol layer strong verification, and low-delay response and deep man-machine cooperation are achieved through a difference rendering and event feedback mechanism.

Description

Technical Field

[0001] This application relates to the field of human-computer interaction, and in particular to a human-computer interaction method and system based on the generation of dynamic graphical user interfaces using the MCP large language model. Background Technology

[0002] Currently, the interaction between large language models and users mainly relies on natural language text interfaces. To improve interaction efficiency, the industry generally adopts two existing technical paths. The first path is static rendering technology based on pre-defined components. In this approach, the large language model outputs structured data through function calls, and the front-end rendering engine fills the data into the corresponding components according to a predefined layout template. While this method ensures rendering stability, the graphical user interface (GUI) is fixed during the development phase, making it unable to dynamically adjust to the real-time, non-standardized interaction needs generated by the large model in open dialogues, resulting in a serious lack of flexibility. The second path is real-time code generation technology, where the model directly outputs the front-end source code and compiles and renders it in real-time in the client sandbox. Although this path offers high flexibility, due to the common illusion phenomenon in models, the generated code often contains syntax errors or logical vulnerabilities, which can easily lead to front-end interface crashes or malfunctions. Furthermore, executing unaudited dynamically generated code on the client side also poses significant system security risks.

[0003] The aforementioned technical problems stem from practical needs in high-level application scenarios such as complex industrial configurations, professional multidimensional data analysis, and dynamic task flow management. In these specific technical fields, users urgently require systems capable of instantly generating highly adaptable graphical control panels based on the current business logic context, rather than simply providing text feedback or fixed data displays. From a technical perspective, the key technical obstacle to accurately identifying and defining this major problem lies in the fact that the traditional graphical user interface development paradigm always follows a pre-defined, then-runned logic, which has a deep-seated architectural conflict with the non-deterministic and real-time characteristics of large model outputs. Therefore, how to establish a graphical interaction framework that possesses both structural stability and dynamic evolution capabilities for non-deterministic model intentions without relying on high-risk source code generation is a core technical obstacle that current technologies struggle to overcome.

[0004] In summary, existing large-scale model interactive interfaces are mostly statically preset or rely on manual construction, resulting in the technical challenge of not being able to dynamically generate matching components based on real-time intent. Furthermore, they suffer from technical defects in the process of transforming large-scale model intents into complex interfaces, including redundant adaptation logic, poor cross-platform compatibility, discontinuous operation-feedback-response closed-loop links, and low human-computer collaboration efficiency. Summary of the Invention

[0005] The purpose of this application is to provide a human-computer interaction method and system based on the generation of dynamic graphical user interface of large language model MCP, which can realize dynamic interaction of large language model interface with the generation and evolution of natural language dialogue. It improves the stability and security of generation through strong verification of protocol layer, and realizes low latency response and deep human-computer collaboration by using differential rendering and event feedback mechanism.

[0006] To achieve the above objectives, this application provides the following solution: Firstly, this application provides a human-computer interaction method for generating a dynamic graphical user interface based on an MCP large language model. The large language model includes an intelligent backend, an MCP intermediary layer, and a rendering frontend. The method includes: acquiring natural language commands input by the user; identifying the user's intent in the natural language commands through the semantic deconstruction engine of the intelligent backend; determining whether graphical intervention is triggered based on the user's intent using an interaction intent recognition algorithm; if so, outputting an interaction intent feature vector; otherwise, not performing graphical intervention; mapping the interaction intent feature vector into a structured MCP message frame by calling the protocol encoder of the intelligent backend through the MCP intermediary layer; the MCP message frame consists of three logical segments: a protocol header, a component payload field, and an event definition field; receiving the MCP message frame using the rendering frontend, and calling the protocol verification header of the rendering frontend. The engine performs parsing and verification based on the strongly typed protocol specification, generating a verified virtual component structure tree. This structure tree is then input into the rendering frontend's state manager, which uses a differential calculation algorithm based on the component's unique identifier to generate an interface update patch package. The patch package is sent to the rendering frontend's component mapping engine, which retrieves the target control from the local native component library and dynamically instantiates it, generating a real-time interactive interface. The rendering frontend's event listening module monitors the user's physical actions on the real-time interactive interface in real time, and its event capture module encapsulates a reverse state feedback message based on the event definition domain in the MCP message frame. This reverse state feedback message is then sent back to the intelligent backend for incremental inference, and the result of the incremental inference determines whether to generate a new round of update instructions, thus forming a closed loop for human-computer interaction.

[0007] In a second aspect, this application also provides a computer system, including: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model as described in the first aspect.

[0008] According to the specific embodiments provided in this application, the following technical effects are disclosed: This application identifies user intent through an intelligent backend and determines when graphical intervention is required. It then maps non-deterministic semantics into structured MCP message frames using a protocol encoder, achieving decoupling of semantics and presentation and enabling dynamic generation. Upon receiving the MCP message frames, the rendering frontend first performs validation using a strongly typed protocol specification, intercepting illegal parameters to ensure the determinism and security of the interface generation. It then calculates differential update packets using a virtual tree comparison algorithm and dynamically instantiates them using local components. This incremental update mechanism reduces rendering overhead and enables higher-level interaction. Finally, the system captures user actions on the frontend interface and encapsulates them into status feedback messages according to the protocol, sending them back to the backend. This triggers incremental inference in the model to determine whether to update the interface, forming a deep closed loop of intent-protocol-rendering-feedback. This makes the interface a visual extension of the model's inference, improving the efficiency of human-computer collaboration. In summary, this application achieves dynamic interaction of a large language model interface as it is generated and evolves with natural language dialogue. It improves the stability and security of generation through strong validation at the protocol layer and achieves low-latency response and deep human-computer collaboration through differential rendering and event feedback mechanisms. Attached Figure Description

[0009] To more clearly illustrate the technical solutions in the embodiments of this application or related technologies, the drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0010] Figure 1 This is a flowchart illustrating a human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model, as provided in an embodiment of this application.

[0011] Figure 2 This is an internal structure diagram of a computer system provided in an embodiment of this application. Detailed Implementation

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

[0013] Terminology Explanation: LLM (Large Language Model): refers to a large-scale pre-trained language model based on a deep learning architecture, which serves as the semantic understanding core of interactive instructions and the generation engine of MCP protocol sequences in this invention.

[0014] MCP (Multi-modal Control Protocol): A structured middleware protocol that sits between a large language model and a front-end rendering engine. It encapsulates the semantic intent of a model into standardized data frames that include component types, attribute parameters, and event binding logic.

[0015] GUI (Graphical User Interface): refers to a human-computer interaction interface displayed in a graphical manner. In this invention, it is specifically a digital interface with dynamic interactive capabilities generated in real time by the MCP protocol.

[0016] Dynamic GUI Generation: refers to the technical process by which a system infers interaction requirements in real time and builds and updates interface components based on the context of human-computer dialogue during runtime, rather than calling preset static templates.

[0017] Interaction Closed-loop Feedback: This refers to the process where user actions (such as clicking, swiping, etc.) on generated GUI components are captured as event signals and transmitted back to the large language model via the MCP protocol, triggering the model to generate subsequent responses and update the interface again.

[0018] Component Mapping Logic: refers to the technical rules by which the front-end rendering engine retrieves and instantiates the corresponding interactive controls from the local component library based on the description fields in the MCP protocol.

[0019] To make the above-mentioned objectives, features and advantages of this application more apparent and understandable, the application will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0020] Example 1, as Figure 1 As shown, this embodiment provides a human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model. The large language model includes: an intelligent backend, an MCP mediation layer, and a rendering frontend. The method includes: S1. Obtain the natural language instructions input by the user, identify the user's intent in the natural language instructions through the semantic deconstruction engine of the intelligent backend, and determine whether to trigger graphical intervention based on the user's intent using the interaction intent recognition algorithm. If yes, output the interaction intent feature vector; otherwise, do not perform graphical intervention.

[0021] In practical applications, the calculation formula for the interactive intent recognition algorithm is as follows: .

[0022] in, Score the complexity of the intent. This is the semantic feature vector after the natural language instruction has been converted. It is a pre-defined feature library of interaction paradigms.

[0023] when When the threshold is exceeded, the output will include an interaction intent feature vector containing the component type and layout requirements. .

[0024] Furthermore, the intelligent backend is deployed on a GPU cluster and exchanges data frequently with terminal nodes distributed in a heterogeneous network environment through standard encrypted communication protocols.

[0025] Optionally, the deployment location of the large language model intelligent backend in this embodiment can also be migrated from the cloud computing power cluster to the edge computing node or mobile terminal local environment with local inference capabilities. This deployment adjustment is intended to adapt to specific environments with weak network or high privacy requirements.

[0026] Optionally, at the underlying implementation level of the rendering front-end, in addition to using virtual DOM for differential comparison and updates, Canvas hardware-accelerated rendering or WebGL technology can also be used to carry complex dynamic charts defined by the MCP protocol to adapt to industrial monitoring scenarios with ultra-high performance requirements.

[0027] S2. The protocol encoder of the intelligent backend is invoked according to the MCP intermediary layer to map the interaction intent feature vector into a structured MCP message frame; the MCP message frame consists of three logical paragraphs: protocol header, component payload field, and event definition field.

[0028] Optionally, the expression for the MCP message frame is as follows: .

[0029] in, For the generated MCP message frame, The protocol header contains the transaction ID and rendering strategy. For component loads using a recursive tree structure, Define declarative event responses. This step transforms non-deterministic semantic requirements into standardized interface control instructions.

[0030] Furthermore, the protocol header is used to maintain session state consistency; the protocol header includes: a globally unique transaction identifier, a protocol version number, and a rendering strategy identifier (e.g., instructing the front end to perform a full redraw or a partial incremental update).

[0031] Furthermore, the component load domain is used to characterize the physical layout of the interface using a recursive tree structure, defining the component type, style constraint parameters, and initial data source for each interactive node; the component type includes at least one of the following: slider, live chart, and multi-select configurator; the style constraint parameters include at least one of the following: color, spacing, and responsive layout width.

[0032] Furthermore, the event definition domain is a declarative logic injection, which is used to specify the method of capturing events and the message format sent back to the intelligent backend when the user performs physical actions on the rendering frontend, so as to complete the logic loop without relying on the execution of local scripts.

[0033] Furthermore, the interaction intent feature vector includes: component type and layout requirements.

[0034] In practical applications, the intent-protocol mapping mechanism established through steps S1-S2 achieves technical decoupling between semantic logic and visual presentation. It primarily utilizes the MCP protocol as an intermediate abstraction layer, transforming the non-deterministic semantics output by the large model into a structured instruction stream. The technical effects of this approach are: it overcomes the limitations of traditional preset templates, enabling the dynamic construction of customized interactive tools that match the user's immediate needs based on real-time context. This protocol-driven generation method not only reduces the complexity of front-end development but also enhances the infinite evolutionary capabilities of the human-computer interaction system.

[0035] S3. Utilize the rendering frontend to receive MCP message frames, call the rendering frontend's protocol verification engine to perform parsing and verification based on the strongly typed protocol specification, and generate a verified virtual component structure tree. Step S3 specifically includes: S31. Receive MCP message frames using the rendering front-end.

[0036] S32. Perform legality checks and semantic alignment on data frames through the protocol verification engine of the rendering front end; S33. The front-end protocol verification engine performs real-time verification of the attribute parameters of the MCP message frame based on the strong type protocol specification to determine whether an illegal component definition or a parameter exceeding the logical threshold is detected. If so, the local reset logic is automatically triggered or an error retransmission request is sent to the backend; if not, a verified virtual component structure tree is generated.

[0037] Furthermore, the strongly typed protocol specification is a pre-defined component definition specification document.

[0038] Furthermore, the expression for the virtual component structure tree is as follows: in, For virtual component structure tree, This is a validation function used to intercept logical illusion parameters that do not conform to the specifications. The predefined component specification document ensures the system stability for subsequent rendering.

[0039] Optionally, in addition to strong type schema verification, a secondary filtering based on a rule engine or a manual intervention review process can be introduced to further improve system security for the security verification mechanism in the MCP protocol.

[0040] In practical applications, step S3 addresses the technical issue of output illusions that may arise from large models. This embodiment introduces strong type validation and fault tolerance mechanisms at the MCP protocol layer. During the protocol decoding phase, the rendering frontend performs real-time validation of the received attribute parameters according to the preset component specification document. If an illegal component definition or a parameter exceeding the logical threshold is detected, it will automatically trigger a partial reset logic or send an error retransmission request to the backend, rather than causing the entire frontend interface to crash.

[0041] In addition, the rendering engine has polymorphic adaptation capabilities, which can automatically transform the interactive intent components abstracted in the MCP protocol into native controls that are most suitable for the current hardware environment according to the screen size and input mode of the terminal device, thereby ensuring the logical consistency of the solution on the web, mobile and smart wearable devices.

[0042] S4. Input the virtual component structure tree into the state manager of the rendering front end, and use the differential calculation algorithm based on the unique identifier of the component to generate the interface update patch package.

[0043] Optionally, the expression for the interface update patch package is as follows: .

[0044] in, This is a virtual tree alignment algorithm. This step creates a snapshot of the current terminal's cached interface state. It uses a depth-first search to compare component attribute dictionaries, identifying the set of nodes that need to be updated, added, or destroyed to achieve a partial refresh.

[0045] In practical applications, the rendering front-end's state manager compares the current virtual component tree of the interface with the received new protocol description, calculating the difference in the interface state. This difference-based update mechanism reduces rendering performance overhead. During the actual drawing phase, the front-end's component mapping engine retrieves and dynamically instantiates the corresponding interactive controls from the local native component library based on the component type identifier in the MCP instruction. For example, when the protocol requires the generation of a parameter configuration panel with real-time feedback capabilities, the front-end automatically assembles multiple controlled components and binds the internal states of these components to the event listeners defined in the MCP in real time.

[0046] S5. Send the UI update patch package to the component mapping engine of the rendering front end. Use the component mapping engine to retrieve the target control in the local native component library and perform dynamic instantiation to generate a real-time interactive interface.

[0047] In practical applications, the virtual tree comparison and incremental update principle in steps S4-S5 improves the system's response efficiency. By calculating the minimum difference between the target state and the current state, local attribute injection or state reorganization is performed only on the affected component nodes. This approach reduces the technical burden on network transmission load and terminal rendering pressure, achieving sub-millisecond visual interaction feedback. It maintains extremely low operation latency even when sustaining complex graphical interactions, thus optimizing the user experience.

[0048] S6. The event listening module of the rendering front end monitors the physical actions on the user's real-time interactive interface in real time, and the event capturing module of the rendering front end encapsulates the reverse state feedback message according to the event definition field in the MCP message frame.

[0049] Optionally, the expression for the status feedback message is as follows: .

[0050] in, For status feedback messages, For captured user operation parameters, This triggers a snapshot of the component's state at the moment of triggering. This step enables the structured collection of user interaction behavior data.

[0051] In practical applications, when a user performs interactive operations on a dynamically generated graphical interface, the front-end event bubbling module converts the operation into a status feedback message based on the preset feedback strategy in the original MCP instruction. This feedback message is transmitted back to the large-scale intelligent model backend via an asynchronous uplink. Upon receiving this signal, the backend module fuses and infers it with previous session history to determine whether the user has completed intent confirmation or triggered a new task flow through graphical operation. If the model determines that further interface adjustments are needed, a new round of MCP instructions will be generated, thus forming a dynamic closed-loop circuit of "intent-protocol-rendering-feedback".

[0052] Furthermore, the status feedback message specifically includes: the specific parameter value modified by the user and a complete snapshot of the current interface status.

[0053] S7. The reverse state feedback message is sent back to the intelligent backend for incremental reasoning, and the result of incremental reasoning is used to determine whether to generate a new round of update instructions, thus forming a closed loop of human-computer interaction.

[0054] Optionally, the expression for the updated task decision state is as follows: .

[0055] in, The updated task decision status. For the context of the dialogue history.

[0056] When the decision requires further adjustments to the UI, the system loops back to step S2 to perform subsequent operations.

[0057] Optionally, this embodiment optimizes real-time performance in complex scenarios by configuring preloading logic in the backend of the large model. Based on the prediction of user dialogue trends, the large model can pre-calculate several potential MCP component packages and push them to the frontend cache pool. When the user's subsequent instructions touch upon the relevant intent, the frontend can achieve instantaneous interface switching with sub-millisecond latency. The hardware and software deployment of the entire system is also highly flexible. The intelligent backend can be deployed on a high-performance GPU cluster, exchanging data frequently with a large number of terminal nodes distributed in a heterogeneous network environment through standard encrypted communication protocols. This protocol-driven architecture completely overcomes the technical difficulties of low security, poor stability, and difficult cross-platform adaptation under the traditional large model code generation method, providing a complete technical path for building a truly language-driven human-computer interaction interface.

[0058] In practical applications, the reverse event feedback mechanism constructed through steps S6-S7 achieves deep closed-loop synchronization between model inference and interface state. Its technical principle lies in converting user physical operations into state feedback messages conforming to the MCP specification in real time and sending them back to the backend for incremental inference. The graphical interface is no longer an isolated display medium but becomes a visual extension of the large model's inference capabilities. Users can directly intervene in the model's subsequent decision-making logic through graphical operations, forming a collaborative evolution paradigm of perception-decision-execution-feedback, improving the accuracy of complex task processing and the depth of human-computer collaboration. Existing technologies cannot dynamically generate entirely new interface layouts based on non-standardized complex contexts as in steps S1-S2 of this embodiment, resulting in extremely low adaptability to long-tail intentions. Secondly, due to the lack of the standard protocol feedback loop described in steps S6-S7 of this embodiment, user operations on the interface are difficult to maintain real-time deep synchronization with the large model's inference state, and the interaction link exhibits unidirectional and fragmented characteristics. This highly coupled and static architecture cannot meet the high-order interaction requirements of on-demand, real-time construction and logical closed-loop evolution achieved in this embodiment.

[0059] In summary, the technical effects of this application are as follows: This application identifies user intent through an intelligent backend and determines when graphical intervention is required. It then maps non-deterministic semantics into structured MCP message frames using a protocol encoder, achieving decoupling of semantics and presentation and enabling dynamic generation. Upon receiving the MCP message frames, the rendering frontend first performs validation using a strongly typed protocol specification, intercepting illegal parameters to ensure the determinism and security of the interface generation. It then calculates differential update packets using a virtual tree comparison algorithm and dynamically instantiates them using local components. This incremental update mechanism reduces rendering overhead and enables higher-level interaction. Finally, the system captures user actions on the frontend interface and encapsulates them into status feedback messages according to the protocol, sending them back to the backend. This triggers incremental inference in the model to determine whether to update the interface, forming a deep closed loop of intent-protocol-rendering-feedback. This makes the interface a visual extension of the model's inference, improving the efficiency of human-computer collaboration. In summary, this application achieves dynamic interaction of a large language model interface as it is generated and evolves with natural language dialogue. It improves the stability and security of generation through strong validation at the protocol layer and achieves low-latency response and deep human-computer collaboration through differential rendering and event feedback mechanisms.

[0060] Example 2: This example provides a computer system, which can be a server or a terminal, and its internal structure diagram can be as follows. Figure 2As shown, the computer system includes a processor, memory, input / output (I / O) interfaces, and a communication interface. The processor, memory, and I / O interfaces are connected via a system bus, and the communication interface is also connected to the system bus via the I / O interfaces. The processor provides computational and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and a database. The internal memory provides the environment for the operating system and computer programs stored in the non-volatile storage media. The database stores forced oscillation samples and sub / supersynchronous oscillation samples. The I / O interfaces are used for information exchange between the processor and external devices. The communication interface is used for communication with external terminals via a network connection. When the computer program is executed by the processor, it implements the aforementioned method for rapid prediction and identification of the dominant frequency of sub / supersynchronous oscillations in new energy power systems based on transfer learning.

[0061] Those skilled in the art will understand that Figure 2 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer system to which the present application is applied. A specific computer system may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0062] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments described above. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM).

[0063] The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, etc., and are not limited to these.

[0064] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. The same or similar parts between the various embodiments can be referred to each other.

[0065] This document uses specific examples to illustrate the principles and implementation methods of this application. The descriptions of the above embodiments are only for the purpose of helping to understand the methods and core ideas of this application. Furthermore, those skilled in the art will recognize that, based on the ideas of this application, there will be changes in the specific implementation methods and application scope. Therefore, the content of this specification should not be construed as a limitation of this application.

Claims

1. A human-computer interaction method based on dynamic graphical user interface generation using the MCP large language model, wherein the large language model includes: The intelligent backend, MCP intermediary layer, and rendering frontend are characterized in that the method includes: The system obtains natural language commands input by the user, identifies the user's intent in the natural language commands through the semantic deconstruction engine of the intelligent backend, and determines whether to trigger graphical intervention based on the user's intent using an interaction intent recognition algorithm. If so, it outputs the interaction intent feature vector; otherwise, it does not perform graphical intervention. According to the MCP intermediary layer, the protocol encoder of the intelligent backend is called to map the interaction intent feature vector into a structured MCP message frame; the MCP message frame consists of three logical paragraphs: protocol header, component payload field, and event definition field. The rendering frontend receives MCP message frames, calls the protocol verification engine of the rendering frontend to perform parsing and verification based on the strongly typed protocol specification, and generates a virtual component structure tree that has passed the verification. Input the virtual component structure tree into the state manager of the rendering front end, and use the differential calculation algorithm based on the unique identifier of the component to generate the interface update patch package; The UI update patch package is sent to the component mapping engine of the rendering front end. The component mapping engine retrieves the target control in the local native component library and performs dynamic instantiation to generate a real-time interactive interface. The event listening module of the rendering front end monitors the physical actions on the user's real-time interactive interface in real time, and the event capturing module of the rendering front end encapsulates the reverse state feedback message according to the event definition field in the MCP message frame. The reverse state feedback message is sent back to the intelligent backend for incremental reasoning, and a new round of update instructions is re-determined based on the incremental reasoning results, thus forming a closed loop of human-computer interaction.

2. The human-computer interaction method based on the MCP large language model dynamic graphical user interface generation according to claim 1, characterized in that, The rendering frontend receives MCP message frames, calls the frontend's protocol verification engine to perform parsing and verification based on the strongly typed protocol specification, and generates a verified virtual component structure tree, specifically including: Receive MCP message frames using the rendering front-end; The protocol verification engine at the rendering front end performs legality checks and semantic alignment on the data frames. The front-end protocol validation engine performs real-time validation of the attribute parameters of MCP message frames based on the strong type protocol specification to determine whether an illegal component definition or parameters exceeding the logical threshold are detected. If so, it automatically triggers local reset logic or sends an error retransmission request to the backend; if not, it generates a validated virtual component structure tree.

3. The human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model according to claim 1, characterized in that, The protocol header is used to maintain session state consistency; the protocol header includes: a globally unique transaction identifier, a protocol version number, and a rendering strategy identifier.

4. The human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model according to claim 1, characterized in that, The component load domain is used to characterize the physical layout of the interface in a recursive tree structure, defining the component type, style constraint parameters, and initial data source for each interactive node. The component types include at least one of the following: slider, live chart, and multi-select configurator; the style constraint parameters include at least one of the following: color, spacing, and responsive layout width.

5. The human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model according to claim 1, characterized in that, The event definition domain is a declarative logic injection. The event definition domain is used to specify the method of capturing events and the message format sent back to the intelligent backend when the user performs physical actions on the rendering frontend, so as to complete the logic loop without relying on the execution of local scripts.

6. The human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model according to claim 1, characterized in that, The intelligent backend is deployed on a GPU cluster and exchanges data frequently with terminal nodes distributed in a heterogeneous network environment through standard encrypted communication protocols.

7. The human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model according to claim 1, characterized in that, The status feedback message specifically includes: the specific parameter values ​​modified by the user and a complete snapshot of the current interface status.

8. The human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model according to claim 1, characterized in that, The interaction intent feature vector includes: component type and layout requirements.

9. The human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model according to claim 1, characterized in that, The strongly typed protocol specification is a pre-defined component definition specification document.

10. A computer system, comprising: A memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that the processor executes the computer program to implement the human-computer interaction method for generating a dynamic graphical user interface based on the MCP large language model as described in any one of claims 1-9.

Images