Tree structure-based multi-user large model interaction method, device and platform

Abstract

The application relates to a tree structure-based multi-user large model interaction method, device and platform, which comprises the following steps: in response to a conversation sharing request of a first user interacting with a generative large model, forming nodes according to the interaction content of each round and constructing parent-child association relationships between the nodes according to the sequence between the interactions of each round to form a conversation tree; whenever a second user conducts additional interaction with the generative large model at any target node of the conversation tree, branching at the target node according to the conversation information to form a conversation branch; and updating the conversation tree based on the conversation branch. The application substantially improves the dynamicity, flexibility, collaboration and manageability of conversation content, and can effectively meet the efficient exploration and collaboration in the multi-user large model interaction process.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of natural language processing and large model interaction, and particularly relates to a tree structure-based multi-user large model interaction method, device and platform. BACKGROUND

[0002] At present, large model service providers usually provide large model interaction services to users through Web pages or mobile applications, and the interaction mode is basically one question and one answer.

[0003] Under this mode, each user input and model output constitutes the minimum unit of information in the interaction process; a number of minimum units form a complete conversation in chronological order. Each user has an independent conversation set, and the conversation content between different users is isolated and cannot access or interfere with each other.

[0004] On this basis, some service providers further provide a historical message modification function, that is, allow users to modify the sent messages, and use the modified content and the previous historical messages as the context to generate new model outputs. Different platforms have different ranges of modification permissions: some platforms only allow the modification of the last user message, and some platforms support the modification of any historical message.

[0005] In addition, some service providers also provide a conversation sharing function, which allows users to share the content of a conversation with others in the form of a sharing link, picture, document, and applet. The user who accepts the sharing can copy the shared content to his own account through scanning the code and continue to ask questions based on the copy, but the connection with the original conversation is broken.

[0006] In summary, first, the current sharing function is essentially generating a dialogue copy at a specific time. Once the sharing is completed, even if the original conversation has new dialogue content, the shared copy will not be updated synchronously, causing information isolation and unable to continuously evolve.

[0007] Second, the content shared by most platforms is only for reading, or even if it allows to continue to ask questions, it is implemented in the form of a copy, which is equivalent to breaking the connection with the original conversation. The subsequent dialogue development is completely isolated and cannot be integrated into the original context tree, lacking continuity and collaboration.

[0008] Third, existing implementations are usually based on linear dialogue history, and users can only proceed step by step along the fixed timeline. If you want to modify the content of a historical node or continue to ask questions from it, you often need to copy a new dialogue, which involves a lot of repetitive operations and a fragmented user experience.

[0009] Fourth, the sharing mechanism is designed for one-way propagation (from the sharer to the recipient), lacking the ability to collaboratively explore based on the same dialogue context. It is impossible to have multiple people around the same topic based on the same context tree to ask questions and share knowledge accumulation and exploration paths.

[0010] Fifth, as a static copy, once generated, the content format and structure are basically fixed, making it difficult to support subsequent flexible addition, organization, archiving, and other advanced functions. SUMMARY

[0011] The present application provides a tree structure-based multi-user large model interaction method, device and platform, aiming to solve the problems of content staticization, inability to dynamically update, limited branch exploration, and insufficient multi-user collaboration capability in the conversation sharing and collaboration process of existing large model interaction systems.

[0012] In a first aspect, the present application provides a tree structure-based multi-user large model interaction method, which comprises:

[0013] In response to a conversation sharing request of a first user interacting with a generative large model, forming nodes according to each round of interaction content, and constructing parent-child association relationships between nodes according to the order between each round of interaction to form a conversation tree;

[0014] Whenever a second user conducts additional interaction with the generative large model at any target node of the conversation tree, branching at the target node according to conversation information to form a conversation branch; and updating the conversation tree based on the conversation branch.

[0015] In a second aspect, the present application also provides a tree structure-based multi-user large model interaction device, which comprises:

[0016] A conversation tree initial construction unit for, in response to a conversation sharing request of a first user interacting with a generative large model, forming nodes according to each round of interaction content, and constructing parent-child association relationships between nodes according to the order between each round of interaction to form a conversation tree;

[0017] A conversation tree extension unit for, whenever a second user conducts additional interaction with the generative large model at any target node of the conversation tree, branching at the target node according to conversation information to form a conversation branch; and updating the conversation tree based on the conversation branch.

[0018] In a third aspect, the present application also provides a conversation sharing platform, which is deployed with the above-mentioned tree structure-based multi-user large model interaction device;

[0019] The tree structure-based multi-user large model interaction device accesses the generative large model through a large model interaction interface to call the generative large model through the large model interaction interface to provide a large model interaction service for a user.

[0020] The tree structure-based multi-user large model interaction device is also communicatively connected to a database to store and read session data through the database.

[0021] In a fourth aspect, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, and the processor implements the steps of the tree structure-based multi-user large model interaction method when executing the computer program.

[0022] In a fifth aspect, a computer readable storage medium is provided, and the computer readable storage medium stores a computer program, and the computer program implements the steps of the tree structure-based multi-user large model interaction method when executed by a processor.

[0023] The above at least one technical solution adopted by the embodiments of the present application can achieve the following beneficial effects:

[0024] First, the present application supports dynamic synchronization and real-time updating of session content. The shared session is no longer a static copy, but is updated synchronously with the increase and modification of the original session content, so that the shared content remains up-to-date, improving the real-time and consistency of information sharing.

[0025] Second, the present application supports modification of any node and multi-branch exploration. Users can modify or add questions at any node in the session history, and the system automatically generates new branches from the node to form a tree-like evolution structure, supporting multi-path exploration and divergent thinking, and breaking through the limitations of traditional linear sessions.

[0026] Third, the present application improves the efficiency of multi-person collaboration and co-creation. Multiple users can independently explore based on the same shared session, each forming a branch while retaining logical connections, greatly improving the efficiency and innovation space of collaboration based on the same topic.

[0027] Fourth, the present application enhances the scalability and manageability of session content. The tree structure-based organization method can support subsequent diversified expansion functions, such as session summary, branch merging, and structured display, significantly improving the management efficiency and utilization value of large-scale session data.

[0028] In summary, the present application substantially improves the dynamic, flexibility, collaboration, and manageability of session content, effectively meeting the needs of efficient exploration and collaboration in the process of multi-user large model interaction. BRIEF DESCRIPTION OF DRAWINGS

[0029] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings needed to be used in the description of the embodiments of the present application will be briefly introduced. Obviously, the drawings in the following description are only some embodiments of the present application, and other drawings can be obtained by those skilled in the art without creative labor on the basis of these drawings.

[0030] Figure 1 A structural schematic diagram of a conversation sharing platform according to an embodiment of the present application is shown;

[0031] Figure 2 A flowchart of a multi-user large model interaction method based on a tree structure according to an embodiment of the present application is shown;

[0032] Figure 3 A structural schematic diagram of an initial conversation tree according to an embodiment of the present application is shown;

[0033] Figure 4 A structural schematic diagram of an updated conversation tree according to another embodiment of the present application is shown;

[0034] Figure 5 A structural schematic diagram of a re-updated conversation tree according to still another embodiment of the present application is shown;

[0035] Figure 6 A flowchart of a multi-user large model interaction method based on a tree structure according to another embodiment of the present application is shown;

[0036] Figure 7 A structural schematic diagram of a multi-user large model interaction device based on a tree structure according to an embodiment of the present application is shown;

[0037] Figure 8 A structural schematic diagram of a computer device according to an embodiment of the present application is shown. DETAILED DESCRIPTION

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

[0039] The concept of the application is that by introducing a conversation data organization method based on tree structure management, dynamic synchronization of conversation content, flexible modification and branch generation of historical nodes are realized, significantly improving the controllability, collaboration and exploration efficiency of multiple users in the large model interaction process.

[0040] Specifically, for the problem of dynamic synchronization, the existing conversation sharing method is based on static copies and cannot reflect the subsequent evolution of the original conversation. The application proposes a sharing mechanism that can dynamically update and synchronize in real time with the original conversation, ensuring that the shared content is always updated.

[0041] For the problem of flexible modification and branch generation of historical nodes, users in existing technologies can only interact linearly and cannot freely modify and branch from historical nodes. The application uses tree structure management to manage conversation history, allowing users to continue interacting from any node and generating independent branches, supporting multi-path exploration.

[0042] For the problem of multi-person collaboration, the content interaction after sharing in existing systems is limited and isolated, lacking the ability for multiple people to explore the same conversation context together. The application supports multiple people to freely explore based on the shared conversation tree, forming independent branches and maintaining logical association with the original conversation, enhancing the collaboration experience.

[0043] For the problem of version control and backtracking, existing technologies lack fine-grained conversation version control and backtracking mechanisms. The application explicitly manages each interaction node, supports users to backtrack and compare different branch evolution processes, facilitating knowledge organization and reuse.

[0044] For the problem of scalability and manageability, static copies have poor scalability. The application is based on a tree conversation structure, supports diversified expansion of conversation content, and significantly improves the maintainability and utilization value of conversation data.

[0045] The application is mainly applied to scenarios where multiple users interact with generative large models. Generative large models can be understood as interactive generative large models based on natural language processing methods. Generative large models can be any of the existing technologies, which are not limited by the application.

[0046] Figure 1 The structure of the conversation sharing platform according to an embodiment of the application is shown, from Figure 1 It can be seen that the conversation sharing platform 100 is deployed with the tree structure based multi-user large model interaction device of the application, which is used to realize the business logic of the tree structure based multi-user large model interaction method of the application (see Figure 7 ).

[0047] The tree structure-based multi-user large model interaction device can be deployed in the core service layer of the conversation sharing platform 100, and the core service layer also has an API gateway. The API gateway is used for routing user requests. In this application, the conversation sharing request of the user reaches the API gateway of the core service layer of the conversation sharing platform 100, and the API gateway routes it to the tree structure-based multi-user large model interaction device. The tree structure-based multi-user large model interaction device provides conversation tree arrangement services and has the business logic of the tree structure-based multi-user large model interaction method provided by this application.

[0048] And from Figure 1 It can be seen that the tree structure-based multi-user large model interaction device accesses the generative large model through the large model interaction interface to call the generative large model through the large model interaction interface to provide large model interaction services for users. Specifically, in some embodiments, the tree structure-based multi-user large model interaction device can realize the interaction between the user and the generative large model on the conversation sharing platform 100 through technical means such as "prepare context request" and "return model inference result".

[0049] And the tree structure-based multi-user large model interaction device is also communicatively connected to a database. The database provides data storage services. Specifically, the tree structure-based multi-user large model interaction device stores and reads conversation recording data, conversation trees, conversation branches, nodes, and other data through the database.

[0050] Please refer to FIG. 1 again. The method of this application can be applied to the conversation sharing platform 100, which is specifically executed by the tree structure-based multi-user large model interaction device. Multiple users are in network communication connection with the conversation sharing platform 100. Each user can exchange topics on the conversation sharing platform 100. The conversation sharing platform can be presented in various forms such as community forums and public accounts. This application does not limit this. Figure 1 The conversation sharing platform "accesses" the generative large model. The access method can be through an API interface (as shown in the figure), and the API calling process can also be packaged using an official or third-party developed SDK, and any one of the customized fine-tuning methods, and this application does not limit this.

[0051] A user interacts with the generative large model, and then can share and publish his conversation with the generative large model in the form of a conversation tree to the conversation sharing platform. Other users, even the original user who initiated the conversation, can "continue to ask" at any node of the conversation tree, thereby realizing the common participation of multiple users in the conversation, which has strong expandability.

[0052] It should be noted that Figure 1For the application of the present application, the present application is not limited to the above scenarios and system architecture, and any system or platform or architecture that can implement the business logic of the tree structure based multi-user large model interaction method of the present application can be used.

[0053] Figure 2 The flowchart of the tree structure based multi-user large model interaction method according to an embodiment of the present application is shown, from Figure 2 It can be seen that the present embodiment includes steps S210-S220:

[0054] Step S210, in response to the session sharing operation of the first user interacting with the generative large model, forming nodes according to the content of each round of interaction, and constructing the parent-child association relationship between nodes according to the order between each round of interaction, to form a conversation tree.

[0055] A user, hereinafter referred to as a first user A, interacts with a generative large model on a topic, and in the interaction process, the first user A usually interacts with the generative large model for at least one round of interaction. "Interaction" generally refers to various data carriers input by the user into the generative large model, including but not limited to text, images, videos, and other forms of files and structured or unstructured data. The generative large model responds to the user's input, and the specific form of interaction is not limited by the present application. For the convenience of explanation, the following describes the text interaction mode of user asking and generative large model answering, such as one round of interaction usually refers to: the first user A asks a question Q1, and the generative large model responds to the question Q1 and gives an answer A1, and the question Q1 and the answer A1 form a question and answer pair. Here, the content of the first user A interacting with the generative large model is referred to as the first session information.

[0056] After the first user A finishes interacting with the generative large model on a topic, the session can be shared. The sharing method can use any of the existing technologies, such as generating a sharing link, an image, a document, a mini-program, etc. The session can be shared to a session sharing platform, such as a community forum or a public account, etc.

[0057] Specifically, a "share" virtual button can be provided on the front-end interface of the first user A interacting with the generative large model, and when the user clicks the virtual button, a "session sharing request" is generated and sent to the session sharing platform, thereby realizing the sharing operation of the session.

[0058] After the session sharing platform receives the session sharing request, it constructs a conversation tree according to the content to be shared by the first user A, and shares the session in the form of a tree structure.

[0059] The conversation tree is constructed in the following manner: nodes of the conversation tree are formed according to the content of each round of interaction, and a parent-child association relationship between nodes is constructed according to the order between each round of interaction.

[0060] The definition of the node (Checkpointer) and the node identity (Checkpointer ID) is as follows: the node refers to a specific session record, which is a fixed checkpoint in the session history. Each time the user initiates a question and the generative large model generates a reply, a new node (Checkpointer) is formed, and a unique node identity (Checkpointer ID) is assigned to the node for subsequent positioning and reference.

[0061] The sharing of the conversation tree in this step can be understood as initial session sharing. The conversation tree can be constructed in the following manner: obtaining the session record data of each round of interaction of the first user, and structuring the session record data into session information; taking the session information of one round of interaction as a node, and assigning a node identity to the node; for any node, marking the preceding node adjacent to the node as its parent node, and marking the subsequent node adjacent to the node as its child node, to construct a parent-child association relationship between nodes; assigning an identity to the formed conversation tree, and attributing it to the first user.

[0062] Please refer to Figure 3 , Figure 3 The structure diagram of the initial conversation tree according to an embodiment of the present application is shown from Figure 3 As can be seen, the first user A initiates a total of 3 rounds of interaction, namely question Q1, question Q2, and question Q3, and the order of the questions is question Q1, question Q2, and question Q3. The generative large model generates replies A1, A2, and A3, respectively. Question Q1 and reply A1 form a question and answer pair, question Q2 and reply A2 form a question and answer pair, and question Q3 and reply A3 form a question and answer pair.

[0063] After obtaining the record data of question Q1, question Q2, question Q3, reply A1, reply A2, and reply A3, the information can be structured to form session information. Then, the session information of each round of interaction is taken as a node Checkpointer, and a node identity is assigned to it, for example, question Q1 and reply A1 are assigned a node identity Checkpointer ID1, question Q2 and reply A2 are assigned a node identity Checkpointer ID2, and question Q3 and reply A3 are assigned a node identity Checkpointer ID3.

[0064] The session information can include, but is not limited to, a user message, a model reply message, and context information; the context information includes at least one of a system message input to a large model, a historical message, a session round, and user information.

[0065] The user message can be understood as a question raised by the user to the generative large model, and the model reply message can be understood as a reply to the question raised by the user to the generative large model. The session information can include not only the content of the conversation between the user and the generative large model, but also some other information, such as context information, which includes at least one of a system message input to a large model, a historical message, a session round, and user information.

[0066] Then, the association relationship between Checkpointer ID1, Checkpointer ID2, and Checkpointer ID3 is constructed. Checkpointer ID1, Checkpointer ID2, and Checkpointer ID3 are in a parent-child node relationship, specifically, Checkpointer ID1 is the parent node of Checkpointer ID2, and Checkpointer ID2 is the parent node of Checkpointer ID3. Alternatively, Checkpointer ID2 is the child node of Checkpointer ID1, and Checkpointer ID3 is the child node of Checkpointer ID2. One parent node can have multiple child nodes, and one child node has only one parent node. The connection of such parent-child association relationship represents the flow from one dialogue state to another dialogue state.

[0067] Finally, the session tree identity is assigned to the formed session tree. At present, each node in the formed session tree can be understood as the root node (Root Node) of the whole session tree, and it is attributed to the first user A.

[0068] The session sharing platform publishes the session tree for other users to browse.

[0069] Furthermore, some embodiments of this application support personalized display definitions. For example, a "hide" virtual button is set next to each node in the session tree. If a user does not want to display a certain question, they can click the virtual button, and the session sharing platform will ignore that node. For example, if a user does not want to display Checkpointer ID2, they can choose to hide Checkpointer ID2. The session sharing platform will re-establish the association between Checkpointer ID3 and Checkpointer ID1, mark Checkpointer ID1 as the parent node of Checkpointer ID3, and hide Checkpointer ID2 when displaying.

[0070] Step S220: Whenever a second user makes an additional interaction with the generative large model at any target node of the session tree, the session tree is branched at the target node to form a session branch based on the session information; and the session tree is updated based on the session branch.

[0071] Users can browse the public session tree on the session sharing platform. The user mentioned here is referred to as the second user. It should be noted that the first user and the second user can be the same or different. That is, the second user can be any user other than the first user, or the first user themselves. In other words, any user can ask follow-up questions, and this application does not impose any restrictions on this.

[0072] This application provides a "follow-up question" mechanism. Next to each node in the public session tree, there is a virtual "continue asking questions" button. A second user can click this virtual button to continue interacting with the question at that node, asking further questions and interacting with the generative large model. For example, if the second user B... Figure 3 The node Checkpointer ID2 in the shown conversation tree is used for follow-up questions. The second user first asks question Q4, and the generative big model responds with A4. The second user then asks question Q5, and the generative big model responds with A5. The content of the interaction between the second user B and the generative big model is recorded as the second conversation information. After completing the conversation, the second user can click the "Publish" virtual button to share their conversation to the conversation sharing platform.

[0073] The session-sharing platform performs a "fork" based on the second user's session content. A fork refers to a user initiating a new interaction based on a historical checkpointer. The platform automatically generates a new session branch (thread) based on that checkpoint, forming a tree-like topology. After each fork, the user continues the conversation in their own thread without affecting the original historical content.

[0074] After the second user clicks "post", a post request is generated, and the session sharing platform responds to the post request of the second user to fork at the target node of the follow-up question according to the second session information generated by the second user B interacting with the generative large model, such as the Checkpointer ID2 here, to form a session branch Thread; and update the original session tree based on the formed session branch, and share the updated session tree.

[0075] The specific operation of the fork is: obtaining the session record data of each round of interaction of the second user, and structuring the session record data into session information; taking the target node as the starting node to construct a session branch, in which the session information of one round of interaction is taken as a node, and for any node, the preceding node adjacent to the node is marked as its parent node, and the subsequent node adjacent to the node is marked as its child node, to construct the parent-child association relationship between the nodes; assigning a session branch identity to the formed session branch, and attributing it to the second user.

[0076] After obtaining the record data of question Q4, question Q5, reply A4 and reply A5, these information can be structured to form session information. Then, the session information of each round of interaction is taken as a node Checkpointer, and a node identity is assigned to it, such as Checkpointer ID4 for question Q4 and reply A5, and Checkpointer ID5 for question Q5 and reply A5. As before, the session information can include but is not limited to: user messages, model reply messages and context information; wherein the context information includes at least one of: system messages input to the large model, historical messages, session rounds and user information.

[0077] Then the association relationship between each node is constructed. Specifically, taking the node as the Checkpointer ID2 starting node, according to the order of the question, the Checkpointer ID2 is marked as the parent node of the Checkpointer ID4 (i.e. the Checkpointer ID4 is the child node of the Checkpointer ID2), the Checkpointer ID4 is marked as the parent node of the Checkpointer ID5 (i.e. the Checkpointer ID5 is the child node of the Checkpointer ID4), and the Checkpointer ID2, the Checkpointer ID4 and the Checkpointer ID5 form a session branch (Thread). As can be seen, the session branch refers to an independent inquiry clue continued by a user based on a certain node. Each Thread represents a session branch that evolves according to the user interaction track from a certain node, has an independent life cycle and context. That is, each session branch Thread in the tree structure retains its starting node and subsequent evolution path.

[0078] Similarly, the formed session branch is given a unique session branch identity (Thread ID). Here, the session branch formed by the Checkpointer ID2, the Checkpointer ID4 and the Checkpointer ID5 is allocated a session branch identity Thread ID1, and is attributed to the second user B. After the second user B publishes, a session tree as shown in FIG. 4 is formed. Figure 4 As can be seen from FIG. 4, on the basis of FIG. 3, the session tree increases a session branch Thread ID1, and it belongs to the second user B. Figure 4 Figure 3

[0079] And in some embodiments of the present application, when there are multiple second users, different second users can inquire in parallel based on the same target node or different target nodes to form different session branches.

[0080] ​​As before, after the second user B finishes publishing the conversation tree, the second user C also asks questions and raises question Q6 at Checkpointer ID2, and the generative large model provides answer A6. After the second user C clicks to publish, the conversation sharing platform obtains the record data of question Q6 and answer A6, and can structure these information to form conversation information. Then, each round of interactive conversation information is taken as a node Checkpointer, and a node identity is assigned to it, such as the node identity of question Q6 and answer A6 being Checkpointer ID6. Then, the association between nodes is constructed, specifically, the node is taken as the starting node Checkpointer ID2, Checkpointer ID2 is marked as the parent node of Checkpointer ID6 (i.e., Checkpointer ID6 is the child node of Checkpointer ID2), and Checkpointer ID2 and Checkpointer ID6 form a conversation branch (Thread). Here, the conversation branch formed by Checkpointer ID2 and Checkpointer ID6 is assigned a conversation branch identity ThreadID2, and is attributed to the second user C.

[0081] After the second user C finishes publishing, a conversation tree as shown in Figure 5 is formed, and it can be seen from Figure 5 that, on the basis of Figure 4 , the conversation tree increases a conversation branch Thread ID2, and it belongs to the second user C.

[0082] Similarly, the second user can also ask questions at Checkpointer ID3, thereby realizing branching at Checkpointer ID3, and forking a conversation branch (not shown in the figure).

[0083] By analogy, whenever a new user asks questions, this step S220 is executed. Each complete conversation is presented in a tree structure. The newly generated conversation record belongs to the personal conversation branch of the initiating user, and is also retained in the overall tree structure.

[0084] Finally, the conversation tree is updated according to the formed conversation branch, on the one hand, the new conversation branch is added to the tree structure of the entire conversation tree, and on the other hand, the function of continuing to ask questions is supported for the nodes of the newly added conversation branch.

[0085] As before, the second user B's Thread ID1 contains the node Checkpointer ID4, if there is a new user, the second user D, which can also continue to ask on the basis of Checkpointer ID4.

[0086] As can be seen, when a user wants to perform a "continue to ask" operation on a historical node, the system allows the user to fork based on the node and create a new Thread. The Thread represents a new session path starting from the historical node, and the platform logically takes the original node as the starting point of the new session branch, forming a tree-like branch structure and maintaining the consistency of the original context.

[0087] In addition, in some embodiments of the present application, a user not only has the right to continue to ask for the nodes in the session branch initiated by himself, but also has the right to edit; other users not only have the right to continue to ask for the session branch initiated by the user, but also have the right to edit. The following will be described respectively for the editing scenarios of a user for a node.

[0088] First, a user edits a node belonging to his own session branch

[0089] In some embodiments of the present application, the method further comprises: in response to any first user or second user modifying operation on any historical node belonging to himself, freezing and hiding the historical node and its subsequent nodes, and marking the historical node as an edited version and retaining the original record for subsequent version tracing; generating a replacement node according to the user's interaction content with the generative large model based on the modification operation, and updating the historical node in a covering manner using the replacement node.

[0090] If a user wants to modify the user's question content of a historical node belonging to himself, the platform can adopt the following strategy: the platform first freezes the original historical node content and marks it as an edited version, and retains the original record for subsequent version tracing, and hides the original historical node and the node content subsequent to the historical node.

[0091] The platform regards the modified message as a new version of the node, regenerates the node content, deletes or hides the large model reply content on the original subsequent path, and makes the new node and its subsequent nodes appear as a new Thread branch.

[0092] The modification operation only acts on the Thread owned by the current user and does not affect the branches generated by other users based on the same node, ensuring data isolation and consistency in a multi-user collaboration environment.

[0093] Further, the application also supports history version rollback and recovery. Specifically, in some embodiments, the method further comprises: in response to a version viewing operation of any user on any history node belonging to the user himself, displaying multiple versions of the history node; and in response to a rollback operation of the user on an edited version of the history node, switching the history node to the edited version.

[0094] The platform also supports user viewing of history version records of any node. For a node Checkpointer that has been edited, the user can switch to view the original content and the modified content, and can choose to restore to any history version, thereby providing complete version rollback capability. At the same time, the platform also records meta information of all editing operations, including operation time, initiating user, original content, etc., improving the auditability and traceability of the system.

[0095] Secondly, a user edits a node in a session branch belonging to himself

[0096] In some embodiments of the application, the method further comprises: in response to a modification operation of any user on any history node belonging to another user, generating a new node and performing a fork to form a new session branch, the new session branch taking the history node as a starting node; and attributing the new session branch to the user who performs the modification operation.

[0097] If a user modifies a history node of another user, the original node and session branch are retained, and on this basis, a new node is generated according to the modification content of the user and the reply content generated by the generative large model, and a fork is performed at the history node, specifically, the fork is performed with the new node as a starting node, and the generated new session branch is attributed to the user who performs the modification operation.

[0098] As can be seen, the embodiments of the application provide perfect version control and rollback capability, and the session history is explicitly managed in the form of nodes and branches. A user can at any time rollback to any history node, view the evolution path, and compare the development of different branches, which is helpful for knowledge organization, achievement comparison and reuse. In this way, all Forked session branches Threads under a certain topic are displayed in the form of a unified tree structure aggregation, for all users to browse. Each Thread evolves independently, but from the overall perspective, they collectively constitute a complete topic session tree.

[0099] In some embodiments of the application, multiple session trees can be displayed at the same time, and different session trees are isolated from each other. That is, parallel management of several session trees is supported, each tree representing an independent topic, and the session trees of different topics are isolated from each other and are managed, browsed and interacted with each other without affecting each other.

[0100] As can be seen from the above,

[0101] First, the conversation dynamically updates and evolves like a tree. The conversation content dynamically expands with the user's follow-up questions, showing a clear tree structure and intuitively presenting the exploration process.

[0102] Second, multiple users can collaborate while data is isolated. Each user has an independent follow-up thread that does not interfere with others, while they can jointly build a rich topic conversation tree.

[0103] Third, any node can be forked for flexible exploration. Users can continue to ask questions at any historical node, expanding multiple exploration paths and promoting in-depth thinking from multiple angles.

[0104] Fourth, the unified platform can be visually managed. The platform centrally displays all topics and their evolution context, supports browsing, searching, and archiving by topic, and improves management and use efficiency.

[0105] Figure 6 shows a flowchart of a tree structure-based multi-user large model interaction method according to another embodiment of the present application. As can be seen from Figure 6 , for a user A, as the creator, its workflow is shown in the left figure of Figure 6 , which dialogues with the generative large model, thereby generating a series of dialogue records, which serve as the basis for subsequent generation of conversation tree nodes. The user A and the generative large model can provide virtual buttons. When it is determined that the user A decides to share, a conversation sharing request is generated and sent to the conversation sharing platform along with the dialogue records.

[0106] The processing flow of the platform is shown in the middle figure of Figure 6 . After the platform receives the shared content, it builds an initial conversation tree, which contains several nodes of the user A and an initial conversation branch Thread A. The initial conversation tree is publicly visible on the conversation sharing platform.

[0107] A user B, as a user of the conversation sharing platform, can browse the conversation tree and choose to initiate additional interaction at any node. When the user B publishes, the conversation sharing platform builds a new conversation branch Thread B for the user B by forking at the selected node where the follow-up question is initiated. The user B can have a new dialogue with the generative large model in his own conversation branch.

[0108] The conversation sharing platform updates the initial conversation tree according to the new conversation branch generated by the user B. Thus, all users see a dynamically growing, multi-branch shared conversation knowledge base.

[0109] As shown in Figure 2As can be seen from the method, first, the application supports dynamic synchronization and real-time updating of conversation content. The shared conversation is no longer a static copy, but is updated synchronously with the increase and modification of the original conversation content, so that the shared content remains up-to-date, improving the real-time and consistency of information sharing.

[0110] Second, the application supports modification and multi-branch exploration of any node. Users can modify or add questions at any node in the conversation history, and the system automatically generates new branches from the node to form a tree-like evolution structure, supporting multi-path exploration and divergent thinking, and breaking through the limitations of traditional linear dialogue.

[0111] Third, the application improves the efficiency of multi-user collaboration and co-creation. Multiple users can independently explore based on the same shared conversation, each forming a branch while preserving logical associations, greatly improving collaboration efficiency and innovation space based on the same topic.

[0112] Fourth, the application enhances the scalability and manageability of conversation content. Based on the tree structure organization, it can support subsequent diversified expansion functions such as conversation summary, branch merging and structured display, significantly improving the management efficiency and utilization value of large-scale conversation data.

[0113] In summary, the application has substantially improved the dynamic, flexibility, collaboration and manageability of conversation content, effectively meeting the needs of users for efficient exploration and collaboration in large model interaction.

[0114] Figure 7 The structure of the tree structure-based multi-user large model interaction device according to an embodiment of the application is shown. Figure 7 As can be seen, the tree structure-based multi-user large model interaction device 700 includes:

[0115] The conversation tree initial construction unit 710 is configured to, in response to a conversation sharing request of a first user interacting with a generative large model, form nodes according to each round of interaction content, and construct parent-child association relationships between nodes according to the order between each round of interaction, to form a conversation tree.

[0116] The conversation tree extension unit 720 is configured to, whenever a second user performs additional interaction with the generative large model at any target node of the conversation tree, branch at the target node based on conversation information to form a conversation branch, and update the conversation tree based on the conversation branch.

[0117] In some embodiments of the present application, the above-mentioned device further comprises: a rollback unit, configured to, in response to any user's modification operation on any historical node affiliated to himself / herself, freeze and hide the historical node and its subsequent nodes, mark the historical node as an edited version and keep an original record for subsequent version tracing; generate a replacement node according to the user's interaction content with the generative large model based on the modification operation, and update the historical node in a covering manner with the replacement node.

[0118] In some embodiments of the present application, in the above-mentioned device, the rollback unit is further configured to, in response to any user's version viewing operation on any historical node affiliated to himself / herself, display multiple versions of the historical node; and in response to the user's rollback operation on the edited version of the historical node, switch the historical node to the edited version.

[0119] In some embodiments of the present application, in the above-mentioned device, the rollback unit is further configured to, in response to any user's modification operation on any historical node affiliated to another user, generate a new node and perform a fork to form a new conversation branch, the new conversation branch taking the historical node as a starting node; and attribute the new conversation branch to the user who performed the modification operation.

[0120] In some embodiments of the present application, in the above-mentioned device, the conversation tree initial construction unit 710 is configured to obtain conversation record data of each round of interaction of the first user, and structure the conversation record data into conversation information; take the conversation information of one round of interaction as one node, and assign a node identity to the node; for any node, mark the preceding node adjacent to the node as its parent node, and mark the subsequent node adjacent to the node as a child node, to construct a parent-child association relationship between nodes; assign a conversation tree identity to the formed conversation tree, and attribute it to the first user.

[0121] In some embodiments of the present application, in the above-mentioned device, the conversation tree extension unit 720 is configured to obtain conversation record data of each round of interaction of the second user, and structure the conversation record data into conversation information; construct a conversation branch taking the target node as a starting node, in the conversation branch, take the conversation information of one round of interaction as one node, and for any node, mark the preceding node adjacent to the node as its parent node, and mark the subsequent node adjacent to the node as a child node, to construct a parent-child association relationship between nodes; assign an identity to the formed conversation branch, and attribute it to the second user.

[0122] In some embodiments of the present application, in the above device, the session information includes: a user message, a model reply message, and context information; wherein the context information includes at least one of: a system message input to the large model, a historical message, a session turn, and user information.

[0123] In some embodiments of the present application, in the above device, the session tree initial establishment unit 710 is further configured to simultaneously display multiple session trees, and different session trees are isolated from each other.

[0124] In some embodiments of the present application, in the above device, the session tree expansion unit 720 is configured to, when the second user is multiple, different second users can ask questions based on the same target node or different target nodes in parallel to form different session branches.

[0125] In some embodiments of the present application, in the above device, the first user and the second user can be the same or different.

[0126] For specific limitations of the tree structure-based multi-user large model interaction device, please refer to the limitations of the tree structure-based multi-user large model interaction method described above, which will not be repeated here. Each module in the above tree structure-based multi-user large model interaction device can be realized by software, hardware, and combinations thereof, in whole or in part. The above modules can be embedded in or independent of the processor in the computer device in hardware form, or can be stored in the memory in the computer device in software form, so that the processor calls and executes the operations corresponding to each module.

[0127] In one embodiment, a computer device is provided, and an internal structure diagram of the computer device can be as shown in Figure 8 The computer device includes a processor, a memory, a network interface, and a database connected by a system bus. The processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage media stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage media. The network interface of the computer device is configured to communicate with an external client through a network connection. The computer program is executed by the processor to implement the functions or steps of a tree structure-based multi-user large model interaction method.

[0128] In one embodiment, a computer readable storage medium is provided, and a computer program is stored on the computer readable storage medium. The computer program is executed by the processor to implement the steps of the tree structure-based multi-user large model interaction method of the present application.

[0129] It should be noted that the functions or steps of the above-mentioned computer-readable storage medium or computer device can correspond to the related description in the foregoing method embodiments. To avoid repetition, they will not be described one by one here.

[0130] A person of ordinary skill in the art can understand that all or part of the processes in the above-mentioned embodiments can be completed by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer readable storage medium. When the computer program is executed, it can include the processes of the above-mentioned embodiments. Any reference to memory, storage, database or other medium used in the embodiments provided by the present application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. As an illustration but not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink) DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM) and memory bus dynamic RAM (RDRAM) and the like.

[0131] Those skilled in the art can clearly understand that, for the convenience and brevity of description, only the division of the above-mentioned functional units and modules is exemplified. In actual application, the above-mentioned functions can be completed by different functional units and modules according to needs, that is, the internal structure of the device is divided into different functional units or modules to complete all or part of the functions described above.

[0132] The above-described embodiments are only used to illustrate the technical solutions of the present application, rather than limit them. Although the present application has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that they can modify the technical solutions recorded in the foregoing embodiments, or make equivalent replacements for some technical features. Such modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the embodiments of the present application, and should be included in the protection scope of the present application.

Claims

1. A method for multi-user large model interaction based on tree structure, characterized in that, The method comprises: in response to a conversation sharing request of a first user interacting with a generative large model, forming nodes according to each round of interaction content, and constructing parent-child association relationship between nodes according to the order between each round of interaction, to form a conversation tree; whenever a second user interacts with the generative large model at any target node of the conversation tree, branching at the target node according to conversation information to form a conversation branch; and updating the conversation tree based on the conversation branch; in response to any user's modification operation on any historical node belonging to himself, freezing and hiding the historical node and its subsequent nodes, and marking the historical node as an edited version and retaining the original record for subsequent version tracing; generating a replacement node according to the user's interaction content with the generative large model based on the modification operation, and updating the historical node in a covering manner with the replacement node; in response to any user's modification operation on any historical node belonging to others, generating a new node and branching to form a new conversation branch, with the historical node as the starting node; attributing the new conversation branch to the user who performs the modification operation; the first user is different from the second user; the method further comprises: obtaining conversation record data of each round of interaction of the first user, and structuring the conversation record data into conversation information; taking the conversation information of one round of interaction as a node, and assigning a node identity to the node; for any node, marking the preceding node adjacent to the node as its parent node, and marking the subsequent node adjacent to the node as its child node, to construct the parent-child association relationship between nodes; assigning a conversation tree identity to the formed conversation tree, and attributing it to the first user; the method further comprises: obtaining conversation record data of each round of interaction of the second user, and structuring the conversation record data into conversation information; constructing a conversation branch with the target node as the starting node, in which the conversation branch, taking the conversation information of one round of interaction as a node, and for any node, marking the preceding node adjacent to the node as its parent node, and marking the subsequent node adjacent to the node as its child node, to construct the parent-child association relationship between nodes; assigning a conversation branch identity to the formed conversation branch, and attributing it to the second user.

2. The method of claim 1, wherein, the method further comprises: in response to any user's version viewing operation on any historical node belonging to himself, displaying multiple versions of the historical node; in response to the user's backtracking operation on the edited version of the historical node, switching the historical node to the edited version.

3. The method of any one of claims 1-2, wherein, the conversation information comprises: user messages, large model reply messages, and context information; wherein the context information comprises at least one of: system messages input to the large model, historical messages, conversation rounds, and user information.

4. The method of claim 1, wherein, the method further comprises: simultaneously displaying multiple conversation trees, and different conversation trees are isolated from each other.

5. The method of claim 1, wherein, When the second user is multiple, different second users perform additional interactions in parallel based on the same target node or different target nodes to form different conversation branches.

6. A tree structure based multi-user large model interaction apparatus, characterized in that, The device comprises: a conversation tree initial construction unit configured to, in response to a conversation sharing request of a first user interacting with a generative large model, form nodes according to the content of each round of interaction, and construct parent-child association relationships between the nodes according to the order between each round of interaction, to form a conversation tree; a conversation tree extension unit configured to, whenever a second user performs additional interaction with the generative large model at any target node of the conversation tree, fork at the target node according to conversation information to form a conversation branch, and update the conversation tree based on the conversation branch; a backtracking unit configured to, in response to a modification operation of any user on any historical node belonging to himself, freeze and hide the historical node and subsequent nodes, mark the historical node as an edited version and keep an original record for subsequent version tracing, generate a replacement node according to the content of the user's interaction with the generative large model based on the modification operation, and update the historical node in a covering manner using the replacement node; the backtracking unit is further configured to, in response to a modification operation of any user on any historical node belonging to others, generate a new node and fork to form a new conversation branch, the new conversation branch taking the historical node as a starting node, and attribute the new conversation branch to the user who performs the modification operation; the first user is different from the second user; the conversation tree initial construction unit is further configured to obtain conversation record data of each round of interaction of the first user, structure the conversation record data into conversation information, take the conversation information of one round of interaction as a node, assign a node identity to the node, for any node, mark the preceding node adjacent to the node as its parent node, mark the subsequent node adjacent to the node as a child node, to construct parent-child association relationships between the nodes, assign a conversation tree identity to the formed conversation tree, and attribute it to the first user; the conversation tree extension unit is further configured to obtain conversation record data of each round of interaction of the second user, structure the conversation record data into conversation information, take the conversation information of one round of interaction as a node, and for any node, mark the preceding node adjacent to the node as its parent node, mark the subsequent node adjacent to the node as a child node, to construct parent-child association relationships between the nodes, assign an identity to the formed conversation branch, and attribute it to the second user.

7. A conversation sharing platform, characterized by, The conversation sharing platform is deployed with the tree structure-based multi-user large model interaction device of claim 6; The tree structure-based multi-user large model interaction device accesses a generative large model through a large model interaction interface, calls the generative large model through the large model interaction interface, and provides large model interaction services for users. The tree structure-based multi-user large model interaction device is further communicatively connected with a database, and the database is used for storage and reading operation of conversation data.

8. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, The computer program is executed by the processor to implement the steps of the tree structure-based multi-user large model interaction method according to any one of claims 1 to 5.

9. A computer-readable storage medium storing a computer program, the computer program comprising instructions that, when executed by a computer, cause the computer to perform the method of any one of claims 1 to 8. The computer program is executed by the processor to implement the steps of the tree structure-based multi-user large model interaction method according to any one of claims 1 to 5.

Images