Software development session summarization methods, apparatus, equipment, and media

By binding listening nodes to the software development session flow and categorizing and recording information by topic, the problem of information loss and redundancy in AI-assisted software development is solved, enabling the continuous reuse of information across sessions and improving development efficiency.

CN123115407APending Publication Date: 2026-11-17GUANGZHOU FANGGUI INFORMATION TECHNOLOGY CO LTD
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611276765.7
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-21
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In the development of AI-assisted software, existing technologies suffer from issues of information loss and redundancy in conversation information, requiring developers to repeatedly describe background information and AI assistants to repeatedly analyze confirmed information.

Method used

Listening nodes are bound to different execution stages of the session flow, key information is captured through memory retrieval rules, and memory records are generated according to content topics and written to the remote memory service for reuse across sessions.

Benefits of technology

It enables the accurate capture of key R&D information during conversations, avoiding information redundancy and loss, improving R&D efficiency, and allowing the AI ​​assistant to maintain memory across different conversations, reducing repetitive descriptions and analyses.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123115407A_ABST
    Figure CN123115407A_ABST
Patent Text Reader

Abstract

This application relates to the field of software development technology, and discloses a software development session summarization method, apparatus, device, and medium. The method includes: registering multiple listening nodes in a session engine used for software development, with each listening node binding to a different execution stage of the session flow between the user and the session model; when the session flow reaches the execution stage bound to the current listening node, determining the memory retrieval rule corresponding to the current listening node; extracting target information from the session content of the execution stage corresponding to the current listening node according to the memory retrieval rule; classifying the target information according to content topics to obtain at least one memory record corresponding to the content topic, and writing the memory record to a remote memory service for retrieval and loading into the session context. This application achieves timely storage of key development information during the session and continuous reuse across sessions, avoiding information loss and redundancy.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This application relates to the field of software development technology, and in particular to a software development session summarization method, apparatus, device, and medium thereof. Background Technology

[0002] With the development of artificial intelligence technology, more and more software development teams are using AI assistants (conversational models) to help with coding, defect checking, requirements analysis, and other development tasks. The interaction between developers and AI assistants takes the form of conversations, and a complete development task often requires multiple conversations to complete.

[0003] During a conversation, the AI ​​assistant has a limited capacity for context. When the amount of interactive content accumulates to a certain level, the system needs to compress the context. When a conversation ends, the information accumulated in the conversation is no longer perceived by the AI ​​assistant. This results in the loss of key information confirmed in the previous conversation in subsequent conversations, forcing developers to repeat the background description and the AI ​​assistant to repeat the analysis.

[0004] In summary, existing technologies face a contradiction between information loss and information redundancy when processing conversation information in AI-assisted R&D scenarios. How to capture key R&D information during the conversation and achieve cross-conversation reuse is a technical problem that urgently needs to be solved. Summary of the Invention

[0005] The purpose of this application is to solve the above-mentioned problems by providing a software development session summarization method, apparatus, device, and medium.

[0006] According to one aspect of this application, a method for summarizing software development sessions is provided, comprising the following steps: Multiple listening nodes are registered in the session engine used for software development, and the multiple listening nodes are respectively bound to different execution stages of the session flow; When the session flow reaches the execution stage bound to the current listening node, the memory retrieval rule corresponding to the current listening node is determined; According to the memory retrieval rules, target information is extracted from the session content of the execution phase corresponding to the current monitoring node; The target information is classified according to the content theme to obtain at least one memory record for the corresponding content theme, and the memory record is written to the remote memory service for retrieval and loading into the session context.

[0007] According to another aspect of this application, a software development session summarization apparatus is provided, comprising: The node registration module is used to register multiple listening nodes in the session engine used for software development. The multiple listening nodes are respectively bound to different execution stages of the session flow. The rule determination module is used to determine the memory retrieval rule corresponding to the current listening node when the session flow is executed to the execution stage bound to the current listening node; The information extraction module is used to extract target information from the session content of the execution phase corresponding to the current monitoring node according to the memory extraction rules. The memory storage module is used to classify the target information according to the content theme, obtain at least one memory record for the corresponding content theme, and write the memory record to the remote memory service for retrieval and loading into the session context.

[0008] According to another aspect of this application, an electronic device is provided, including a central processing unit and a memory, wherein the central processing unit is configured to invoke and run a computer program stored in the memory to perform the steps of the software development session summary method described in this application.

[0009] According to another aspect of this application, a non-volatile readable storage medium is provided, which stores a computer program implemented according to the software development session digest method in the form of computer-readable instructions, wherein the computer program, when invoked by a computer, performs the steps included in the method.

[0010] Compared to existing technologies, this application binds listening nodes to different execution stages of the session flow, enabling each listening node to extract target information in a targeted manner according to its corresponding memory retrieval rules, and generate memory records by content theme classification and write them to the remote memory service. This allows for the accurate capture of key R&D information during the session, avoiding information redundancy caused by full storage and preventing the loss of key information when the session is interrupted, thus achieving cross-session information continuity and reuse. Attached Figure Description

[0011] Figure 1 This is an exemplary network architecture suitable for applying the software development session summarization method of this application; Figure 2 This is a flowchart illustrating one embodiment of the software development session summarization method of this application. Figure 3 This is a schematic block diagram of the software development session summarization device of this application; Figure 4 This is a schematic diagram of the structure of an electronic device used in this application. Detailed Implementation

[0012] The embodiments of this application are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain this application, and should not be construed as limiting this application.

[0013] Those skilled in the art will understand that, unless specifically stated otherwise, the singular forms “a,” “an,” “the,” and “the” used herein may also include the plural forms. It should be further understood that the term “comprising” as used in this application means the presence of the stated features, integers, steps, operations, elements, and / or components, but does not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof. It should be understood that when we say an element is “connected” or “coupled” to another element, it can be directly connected or coupled to the other element, or there may be intermediate elements. Furthermore, “connected” or “coupled” as used herein can include wireless connections or wireless coupling. The term “and / or” as used herein includes all or any units and all combinations of one or more associated listed items.

[0014] Those skilled in the art will understand that, unless otherwise defined, all terms used herein (including technical and scientific terms) have the same meaning as commonly understood by one of ordinary skill in the art to which this application pertains. It should also be understood that terms such as those defined in general dictionaries should be understood to have the same meaning as in the context of the prior art, and should not be interpreted in an idealized or overly formal sense unless specifically defined as herein.

[0015] Those skilled in the art will understand that the terms "client," "terminal," and "terminal device" as used herein include both devices that receive wireless signals, devices that only possess wireless signal receiver capabilities without transmission capabilities, and devices with receiving and transmitting hardware, devices that have receiving and transmitting hardware capable of bidirectional communication over a bidirectional communication link. Such devices may include: cellular or other communication devices such as personal computers or tablets, having single-line displays, multi-line displays, or cellular or other communication devices without multi-line displays; PCS (Personal Communications Service) that can combine voice, data processing, fax, and / or data communication capabilities; PDAs (Personal Digital Assistants) that may include radio frequency receivers, pagers, internet / intranet access, web browsers, notepads, calendars, and / or GPS (Global Positioning System) receivers; and conventional laptops and / or handheld computers or other devices that have and / or include radio frequency receivers. As used herein, "client," "terminal," and "terminal device" can be portable, transportable, installed in a means of transportation (air, sea, and / or land), or suitable and / or configured to operate locally and / or in a distributed manner, operating in any other location on Earth and / or in space. "Client," "terminal," and "terminal device" as used herein can also be a communication terminal, an internet access terminal, or a music / video playback terminal, such as a PDA, a MID (Mobile Internet Device), and / or a mobile phone with music / video playback capabilities, or a smart TV, set-top box, etc.

[0016] The hardware referred to by the names "server," "client," and "service node" in this application is essentially an electronic device with the equivalent capabilities of a personal computer. It is a hardware device with the necessary components revealed by the von Neumann architecture, such as a central processing unit (including an arithmetic logic unit and a control unit), memory, input devices, and output devices. The computer program is stored in its memory, and the central processing unit loads the program stored in the secondary storage into the main memory to run it, execute the instructions in the program, and interact with the input and output devices to complete specific functions.

[0017] It should be noted that the concept of "server" used in this application can also be extended to apply to server clusters. Based on network deployment principles as understood by those skilled in the art, the servers should be logically divided; physically, these servers can be independent yet accessible through interfaces, or they can be integrated into a single physical computer or a computer cluster. Those skilled in the art should understand this flexibility and should not use it to constrain the implementation of the network deployment method described in this application.

[0018] One or more of the technical features of this application, unless explicitly specified herein, can be deployed on a server and accessed by a client remotely calling the online service interface provided by the server, or can be directly deployed and run on a client for access.

[0019] Unless otherwise specified, all data involved in this application may be stored remotely on a server or on a local terminal device, as long as it is suitable for use by the technical solution of this application.

[0020] Those skilled in the art will understand that although the various methods in this application are described based on the same concept and thus present commonality among them, they can be performed independently unless otherwise specified. Similarly, the various embodiments disclosed in this application are all based on the same inventive concept; therefore, concepts expressed in the same way, as well as concepts that are appropriately changed for convenience but are expressed differently, should be understood equivalently.

[0021] Unless otherwise expressly stated, the various embodiments disclosed in this application can be combined in a cross-cutting manner to flexibly construct new embodiments, as long as such combination does not depart from the inventive spirit of this application and can meet the needs of the prior art or solve a certain deficiency in the prior art. Those skilled in the art should be aware of such modifications.

[0022] To facilitate understanding of the various embodiments of this application, exemplary network architectures and application scenarios will be introduced first.

[0023] like Figure 1As shown, the network architecture of this application aims to build a cross-session memory management system for software development scenarios. By automatically capturing and persistently storing key development information during sessions, the AI ​​assistant can maintain its memory across different sessions, avoiding the repeated loss of development information. This network architecture includes a client 80, an application server 81, and a memory server 82. The client 80 is the terminal device used by developers, who interact with the AI ​​assistant through it, submitting input and receiving responses from the AI ​​assistant. The application server 81 is the server running the session engine, responsible for managing the execution of the session flow, including registering listening nodes, determining memory retrieval rules, extracting target information from the session content, and generating memory records categorized by content topic. The memory server 82 is a remote server providing memory storage and retrieval services, responsible for receiving and storing the memory records written by the application server 81, and returning relevant memory records to the application server 81 when needed.

[0024] Client 80 and application server 81 are connected via network communication. Input from the R&D personnel is sent to application server 81, and the response from application server 81 is returned to client 80. Application server 81 and memory server 82 are connected via network communication. Application server 81 sends generated memory records to memory server 82 for storage, and can also retrieve existing memory records from memory server 82.

[0025] In practice, application server 81 pre-registers multiple listening nodes in the session flow, with each listening node bound to a different execution stage of the session flow. When the session flow reaches the execution stage bound to a certain listening node, application server 81 determines the memory retrieval rule corresponding to that listening node and extracts target information from the session content of the current stage according to the rule. Subsequently, application server 81 categorizes the extracted target information according to content topics, generates corresponding memory records, and writes the memory records to memory server 82 via the network. When a new session flow starts, application server 81 retrieves the corresponding memory record from memory server 82 based on the user identifier and loads the retrieved memory record into the current session context.

[0026] Through the above architecture, this application achieves automatic and accurate capture of key R&D information during the session, avoiding information redundancy caused by full storage, and also avoiding the loss of key information when the session ends or the context is compressed. This enables the AI ​​assistant to continue its memory between different sessions, and R&D personnel do not need to repeat the background description, thus improving R&D efficiency.

[0027] In one exemplary application scenario, the software development session summarization method of this application can be applied to the following application scenarios: A software development team is fixing a build failure issue in an online payment system. Troubleshooting this problem involves multiple steps, including dependency checks, log analysis, cache cleanup, and build verification, which cannot be completed in a single session. It requires developers and an AI assistant to collaborate through multiple sessions to resolve the issue.

[0028] Developers initiate an initial session through the client, describing the problem to the AI ​​assistant. The AI ​​assistant then begins a step-by-step troubleshooting process, including checking project dependency versions, analyzing build logs, and identifying suspected cache corruption. During this process, session content accumulates, gradually approaching the context's capacity limit. Just before the context is compressed, the application server automatically writes the current troubleshooting progress to the memory server. After compression, the application server reads the record from the memory server and loads it into the session context, allowing the AI ​​assistant to resume troubleshooting from where it left off, without requiring developers to re-describe their work.

[0029] When the session ends, the application server writes the confirmed conclusions from the session to the memory server.

[0030] The next day, the developers started a new session to continue working on another issue with the system. Upon session startup, the application server automatically retrieved the previous day's saved troubleshooting conclusions from the memory server and loaded them into the current session context. When a developer entered a statement related to a previous issue, the application server, based on the historical troubleshooting conclusions loaded in the current session context, performed association identification on the input statement, determining that it matched a previously identified root cause. In response to the matching result, the application server triggered a check of the cache state and performed cache cleanup according to the validated methods from the historical troubleshooting conclusions, subsequently automatically executing the build verification process. Throughout this process, the developers could complete the problem localization and resolution without needing to re-describe the problem background, troubleshooting steps, or historical operations.

[0031] Through the above application scenario description, this application enables the AI ​​assistant to maintain its memory of the R&D context across multiple sessions. R&D personnel do not need to repeatedly describe background information, and the AI ​​assistant does not need to repeatedly analyze known conclusions, thus significantly improving R&D efficiency.

[0032] Through the detailed description of the network architecture and application scenarios described above, a better understanding of the specific application of the software development session summarization method of this application in the field of software development technology can be achieved. The following will elaborate on the detailed description of various specific embodiments of this application based on these exemplary contents.

[0033] like Figure 2 As shown, in one embodiment, the software development session summarization method of this application includes: Step S5100: Register multiple listening nodes in the session engine used for software development. The multiple listening nodes are respectively bound to different execution stages of the session flow between the user and the session model.

[0034] Multiple listener nodes are registered in the session engine used for software development. Each listener node is bound to an execution phase of the session flow between the user and the session model. By establishing listening mechanisms at multiple key points in the session flow, the listener node corresponding to a certain execution phase can be triggered when the session flow reaches that phase.

[0035] A session engine is a software program that manages the interaction between a user and a session model. It is responsible for receiving user input, scheduling the session model to generate responses, maintaining the context window, and controlling the progression of the session flow. In software development scenarios, users submit instructions or questions to the session model through a client, such as code writing, defect investigation, and requirements analysis. The session model generates corresponding responses, and the two parties continuously interact during a session. A session flow is a complete interaction process between the user and the session model, starting from the user initiating the interaction, going through multiple rounds of input and response, until the session ends. The session flow goes through different execution phases, each corresponding to a specific type of operation in the session, such as user input submission, context window management, task execution, and session termination. The session content generated in different execution phases has different characteristics.

[0036] Listener nodes are pre-defined event response units in the session engine, with each listener node corresponding to a specific execution phase. When the session flow reaches that execution phase, the corresponding listener node is triggered, thereby executing the preset operation. By setting listener nodes in multiple execution phases of the session flow, the system can obtain the session content of the corresponding phase at key points during the session, rather than waiting until the session ends to perform unified processing.

[0037] The registration of listener nodes is completed during session engine initialization and remains unchanged throughout the entire session engine's runtime, applicable to all session flows passing through the session engine. When a session flow reaches a certain execution stage, the session engine determines whether a corresponding listener node exists for that stage; if it exists, the listener node is triggered; otherwise, the session flow continues normally. In one embodiment, listener node registration is implemented through a configuration table. The session engine reads a preset listener node configuration file at startup, establishing a mapping relationship between listener nodes and execution stages in memory. During session flow execution, this mapping relationship is queried to determine whether to trigger the corresponding listener node. In another embodiment, listener node registration is implemented through callback functions. In the session engine's source code, a callback function is pre-associated with each execution stage. When the session flow reaches that stage, the corresponding callback function is automatically invoked; this callback function is the corresponding listener node.

[0038] This application uses multiple listening nodes, each corresponding to a different execution phase. These listening nodes operate independently of each other; triggering one listening node does not affect the operation of other listening nodes. A session may trigger multiple listening nodes, or only one or some of them, depending on the actual execution phases experienced by the session.

[0039] Step S5200: When the session flow reaches the execution stage bound to the current listening node, determine the memory retrieval rule corresponding to the current listening node.

[0040] When the session flow reaches the execution stage bound to a certain listening node, that listening node is triggered, and the system determines its corresponding memory retrieval rule based on that listening node. Since the session content generated in different execution stages has different characteristics and contains different types of valuable information, each listening node corresponds to an independent memory retrieval rule, which defines what type of information should be extracted from the session content of the current stage.

[0041] Memory retrieval rules can be configured during the session engine initialization phase, synchronously with the registration of listening nodes. When a listening node is triggered, the system retrieves the corresponding memory retrieval rule based on the node's identifier. In one embodiment, the memory retrieval rule is bound to the listening node during registration, and each listening node's data structure directly contains its corresponding memory retrieval rule. When the node is triggered, the system directly reads the memory retrieval rule from the node's data structure without additional query operations. In another embodiment, memory retrieval rules are stored in an independent rule base. Each record in the rule base contains a mapping relationship between the listening node identifier and the corresponding memory retrieval rule. When a listening node is triggered, the system uses the node's identifier as an index to query the corresponding memory retrieval rule from the rule base. In yet another embodiment, memory retrieval rules are stored in the form of rule templates. Each rule template contains a rule identifier and a corresponding information type definition. When a listening node registers, it is associated with a rule template identifier. When the node is triggered, the system loads the corresponding rule template based on the associated rule template identifier as the node's current memory retrieval rule.

[0042] Step S5300: Extract target information from the session content of the execution phase corresponding to the current listening node according to the memory retrieval rules.

[0043] The system has determined the corresponding memory retrieval rules based on the currently triggered monitoring node. This step, according to these rules, extracts target information from the session content of the execution phase corresponding to the current monitoring node. Session content refers to the interaction data generated between the user and the session model during this execution phase, and the memory retrieval rules define the types of information to be extracted. Through this step, the system extracts only valuable information corresponding to the current execution phase, rather than indiscriminately acquiring all session content, thus ensuring that the extracted results match the information characteristics of the current phase.

[0044] In a session flow, the session content generated at different execution stages differs in information value and type. Some information has cross-session reuse value, such as long-term constraints expressed by users, task execution progress, and verified technical conclusions; other information is temporary and only meaningful within the current session. If all session content is retrieved without differentiation, a large amount of useless information will be introduced, increasing storage burden and impacting subsequent retrieval efficiency. Based on memory retrieval rules, target information conforming to the definition of the rules is selectively extracted from the session content of the current execution stage. The extraction scope is limited to the execution stage corresponding to the current listening node, rather than the entire content of the entire session flow. This stage-by-stage, rule-by-rule extraction method ensures that the results of each extraction match the actual content characteristics of the current stage.

[0045] Once a listening node is triggered and the memory retrieval rules are determined, the system extracts target information from the session content of the current execution phase. The scope of extraction is the session content generated in the execution phase corresponding to the current listening node, and the extraction is based on the determined memory retrieval rules. In one embodiment, the memory retrieval rules define a list of keywords or key phrases for the target information. The system performs text matching on the session content of the current execution phase and identifies content fragments that match the keywords or key phrases as target information. This method is suitable for scenarios where the target information has clear textual features. In another embodiment, the memory retrieval rules define a structural pattern for the target information. The system performs structured parsing on the session content of the current execution phase and identifies content that conforms to the structural pattern as target information. This method is suitable for scenarios where the target information has a fixed format or fixed structure. In yet another embodiment, the memory retrieval rules define a semantic category for the target information. The system uses a session model to perform semantic understanding on the session content of the current execution phase and identifies content belonging to that semantic category as target information. This method is suitable for scenarios where the target information does not have fixed textual features or structural patterns and requires judgment at the semantic level.

[0046] The extraction operation is executed asynchronously in the background, without blocking the normal progress of the current session. This means the extraction process and the interaction between the user and the session model occur in parallel, and the user will not perceive any additional waiting time.

[0047] Step S5400: Classify the target information according to the content theme to obtain at least one memory record for the corresponding content theme, and write the memory record to the remote memory service for retrieval and loading into the session context.

[0048] The system has extracted target information from the session content of the current execution phase according to memory retrieval rules. This step categorizes the target information according to content topics, obtaining at least one memory record for each content topic, and writes the memory record to the remote memory service for retrieval and loading into the session context during the session flow. Through this step, the target information is broken down into topic-independent memory records and persistently stored in the remote memory service, enabling the memory records to be retrieved and loaded when needed, achieving information continuity across sessions.

[0049] The extracted target information may involve multiple different content topics. For example, the results of a single extraction may contain information related to project configuration and information related to coding standards. If this information is stored as a single record, it will be difficult to accurately match content related to a specific topic during retrieval, affecting reuse efficiency.

[0050] The purpose of writing to the remote memory service is to enable the memory records to be retrieved and loaded later, meaning that the memory records in the remote memory service can be read and injected into the current session context when needed by the session flow.

[0051] When classifying target information according to content themes, the system identifies the various content themes contained in the target information, merges information belonging to the same content theme into one memory record, and generates independent memory records for information belonging to different content themes. If the target information involves only one content theme, one memory record is generated; if it involves multiple content themes, multiple memory records are generated separately. Each memory record is written to the remote memory service as an independent storage unit, containing the content theme identifier and the corresponding information content. After writing, the memory record is persistently stored in the remote memory service and is not lost when the session ends. In one embodiment, content theme identification is achieved through keyword matching. The system determines the content theme to which the target information belongs based on keywords or key phrases appearing in the target information and merges information corresponding to the same keywords into one memory record. In another embodiment, content theme identification is achieved through semantic analysis. The system uses a session model to perform semantic understanding of the target information, identifies the various content themes it contains, and merges information belonging to the same semantic theme into one memory record.

[0052] Regarding writing to the remote memory service, the application server can call the write interface provided by the remote memory service via network request to send the generated memory record to the remote memory service. The remote memory service then persists the memory record upon receipt. The write operation can be performed in the background without blocking the normal progress of the current session.

[0053] The writing method for the remote memory service is not limited to the above-mentioned network request call to the write interface. It can also be written asynchronously through a message queue or directly through a database connection.

[0054] As can be seen from the above embodiments, this application achieves the following outstanding effects: First, this application addresses the issue of critical information loss due to session interruption by setting up monitoring nodes at different execution stages of the session flow. This ensures information capture occurs during the session rather than after it ends. Since different execution stages generate different types of information, each monitoring node corresponds to an independent memory retrieval rule, extracting only valuable information relevant to the current stage, rather than indiscriminately saving the entire session content. This stage-by-stage and rule-by-rule extraction method avoids the mixing of temporary content and irrelevant information, resolving the information redundancy problem caused by full saving, and effectively mitigating the conflict between information loss and information redundancy.

[0055] Secondly, this application categorizes the extracted target information according to content themes, generating independent memory records for information belonging to different themes and persistently storing them in a remote memory service. Each memory record, as an independent storage unit, is not lost when the session ends. When historical memories need to be accessed during a session, the corresponding memory record can be retrieved from the remote memory service by theme and loaded into the current session context. This allows the session model to continue its memory across different sessions, eliminating the need for developers to repeatedly describe background information and for the session model to repeatedly analyze known conclusions, thus achieving cross-session reuse of key R&D information.

[0056] Furthermore, in this application, the triggering of the listening nodes, the extraction of target information, and the writing of memory records are all performed in the background, without blocking the normal progress of the current session flow. The interaction between the user and the session model will not incur additional waiting due to memory retrieval and storage operations, ensuring the smoothness of the session flow and the user experience. At the same time, the multiple listening nodes are independent of each other; the triggering of one node does not affect the operation of other nodes, giving the system good scalability and stability.

[0057] Based on any embodiment of the method in this application, multiple listening nodes are registered in a session engine used for software development, including any one or more of the following: Step S5210: Register a user input listening node, which is used to bind the execution phase when the user submits input to the session model.

[0058] Register a user input listener node in the session engine. This node is bound to the execution phase when a user submits input to the session model. When a user submits input to the session model, the session flow enters this execution phase, and the user input listener node is triggered. Through this node, the system can capture valuable information from each user input submission in a timely manner.

[0059] In software development scenarios, users submit input to a session model via a client. This input may include code writing instructions, problem descriptions, and requirements specifications. In some inputs, users express long-term constraints or preferences, such as coding style requirements, project architecture constraints, and technology selection preferences. This type of information is not only meaningful for the current input but also has reusable value in subsequent sessions.

[0060] The execution phase bound to the user input listening node is the phase when the user submits input to the session model; that is, this node is triggered every time the user submits input. By setting the listening node at this phase, the system can promptly identify and capture valuable information contained within the user input at its entry point.

[0061] User input listening nodes are registered during session engine initialization and bound to the execution phase corresponding to the user input submission operation. When a user submits input to the session model through the client, the session engine detects the input submission operation, determines that the session flow has entered the execution phase corresponding to the user input, and triggers the user input listening node. In one embodiment, the triggering of the user input listening node is synchronized with the reception of user input. After receiving user input, but before passing the input to the session model, the session engine first triggers the user input listening node to perform information extraction operations, and then passes the input to the session model to generate a response. In another embodiment, the triggering of the user input listening node is executed asynchronously after the user input is received. After receiving user input, the session engine immediately passes the input to the session model to generate a response, and simultaneously triggers the user input listening node to perform information extraction operations in the background. This method does not increase the user's waiting time.

[0062] Step S5220: Register a context capacity monitoring node to bind to the execution phase when the context capacity reaches a preset threshold and context compression is about to be performed.

[0063] A context capacity monitoring node is registered in the session engine. This node is bound to the execution phase where the context capacity reaches a preset threshold and context compression is about to be performed. When the context capacity in the session flow reaches the preset threshold, the session engine will perform context compression, at which point the context capacity monitoring node is triggered. Through this node, the system can capture valuable information in the current phase in time before the context is compressed, avoiding the loss of this information due to compression.

[0064] When processing user input and generating responses, the conversation model needs to maintain a context window. The context window stores the interactions that have occurred in the current session, providing a reference for the conversation model when generating responses. However, the context window has a capacity limit; as the session continues and interactions accumulate, the context capacity gradually approaches this limit. When the context capacity reaches a preset threshold, the conversation engine needs to perform a compression operation on the context to make room.

[0065] Context compression removes or summarizes some historical interaction content; this information no longer exists in the original context after compression. If valuable information from the current stage is not saved before compression, this information will be lost after compression, causing the progress of the currently executing task to be interrupted.

[0066] The execution phase bound to the context capacity monitoring node is the phase when the context capacity reaches a preset threshold and context compression is about to occur, i.e., before the compression operation takes place. By setting the monitoring node at this phase, the system can capture valuable information in a timely manner before compression occurs.

[0067] The session engine continuously monitors the current capacity of the context window during operation. When the context capacity reaches a preset threshold, the session engine determines that context compression is about to be performed and triggers the context capacity monitoring node. After the monitoring node is triggered, it performs an information extraction operation. After extraction is completed, the session engine continues to perform the context compression operation. In one embodiment, the triggering of the context capacity monitoring node is performed synchronously before the context compression operation. After detecting that the context capacity has reached the threshold, the session engine first triggers the monitoring node to complete the information extraction, and then performs the compression operation. This method ensures that information extraction is completed before compression. In another embodiment, the triggering of the context capacity monitoring node and the context compression operation are performed in parallel. After detecting that the context capacity has reached the threshold, the session engine simultaneously starts information extraction and context compression. Information extraction targets the original session content before compression. This method reduces waiting time.

[0068] The preset threshold can be set according to the total capacity of the context window. The preset threshold can be set to a fixed percentage of the total capacity of the context window, such as 80% or 90%.

[0069] Step S5230: Register a task completion listening node, which is used to bind the session model to complete the execution phase of a task.

[0070] Register a task completion listener node in the session engine. This node is bound to the execution phase of a task completed by the session model. When a session model completes a task, the session flow enters the corresponding execution phase, and the task completion listener node is triggered. Through this node, the system can promptly capture valuable information generated during the task execution process upon task completion.

[0071] In software development scenarios, interactions between users and session models often revolve around specific development tasks, such as troubleshooting a build failure, implementing a new feature module, or fixing a code defect. When a session model completes a task, the conclusions, experiences, and verification results generated during the task execution process have high cross-session reuse value.

[0072] The execution phase bound to the task completion listening node is the phase in which a task is completed in the session model. By setting a listening node at this phase, the system can capture valuable information generated during task execution in a timely manner at the time of task completion, rather than waiting until the session ends to process it uniformly.

[0073] The session engine needs to determine whether the session model has completed a task. When the determination result is that the task is completed, the session flow enters the execution phase corresponding to task completion, triggering the task completion listening node. In one embodiment, task completion is explicitly confirmed by the user. The user sends a task completion confirmation command to the session model through the client. After receiving the confirmation command, the session engine determines that the current task is completed and triggers the task completion listening node. In another embodiment, task completion is automatically determined by the session model. When generating a response, the session model determines whether the goal of the current task has been achieved. If it has been achieved, it sends a task completion signal to the session engine. After receiving the signal, the session engine triggers the task completion listening node. In yet another embodiment, task completion is determined by the session engine based on preset task completion conditions. The session engine predefines the judgment conditions for task completion. When the state in the session flow meets the conditions, the session engine determines that the task is completed and triggers the task completion listening node.

[0074] Step S5240: Register a session termination listening node, which is used in the execution phase when the session process ends.

[0075] Register a session termination listener node in the session engine. This node is bound to the execution phase at the end of the session flow. When the session flow ends, the session termination listener node is triggered. Through this node, the system can finally capture valuable information from the current session at the end of the session flow, ensuring that no valuable information generated before the session ends is missed.

[0076] The conversation flow begins with user-initiated interaction, proceeds through multiple rounds of input and response, and ultimately ends. Conversation termination may be triggered by the user actively closing the session, or by reasons such as session timeout or system exception. Regardless of the reason for session termination, the information accumulated during the conversation flow will no longer be perceived by the conversation model after the session ends.

[0077] The execution phase bound to the session termination listener node is the end phase of the session flow, i.e., the last execution phase of the session flow. By setting the listener node at this phase, the system can perform a final information capture at the end of the session, overwriting information that other listener nodes failed to cover during the session, as a final processing step for the entire session flow.

[0078] The session termination listener node can be registered during session engine initialization, establishing a binding relationship with the execution phase corresponding to the end of the session flow. When the session flow ends, the session engine triggers the session termination listener node. In one embodiment, session termination is actively triggered by the user, who sends a session close command through the client. Upon receiving this command, the session engine determines that the session flow has ended and triggers the session termination listener node. In another embodiment, session termination is triggered by session timeout. The session engine presets a session timeout period; if the user does not submit new input within the preset time, the session engine determines that the session flow has ended and triggers the session termination listener node. In yet another embodiment, session termination is triggered by system exception. When the session engine detects that the session flow has been interrupted due to an exception, it determines that the session flow has ended and triggers the session termination listener node, ensuring that valuable information generated before the abnormal interruption can be captured.

[0079] As can be seen from the above embodiments, this application sets corresponding listening nodes for each of the four key execution stages of the session flow, enabling the system to capture valuable information generated in each stage at the corresponding time: when the user submits input, when the context is about to be compressed, when the task is completed, and when the session flow ends. This ensures that valuable information generated in different stages of the session flow can be captured in a timely manner at the time of its generation, especially the task progress information generated before context compression will not be lost due to compression. At the same time, since each listening node is only triggered in its corresponding execution stage, the system will not extract information in irrelevant stages, avoiding the mixing of unnecessary information and controlling information redundancy while solving the problem of information loss.

[0080] Based on any embodiment of the method in this application, the memory retrieval rule corresponding to the current monitoring node is determined, including any one or more of the following: Step S5310: When the session flow reaches the execution stage bound to the user input listening node, determine that the corresponding memory retrieval rule is to extract the constraint information and / or preference information of the user input.

[0081] When the session flow reaches the execution phase bound to the user input listening node, the memory retrieval rule corresponding to that node is determined to be the extraction of constraint information and / or preference information from the user input. That is, when the user submits input to the session model, the system identifies and extracts the constraint information and / or preference information expressed by the user from that input as the target information.

[0082] In software development scenarios, when users submit input to a session model via a client, the input may include not only specific instructions for the current task but also long-term constraints and preferences expressed by the user. Constraint information refers to the restrictions that the session model needs to continuously adhere to during the development process, such as coding standards, interface compatibility requirements, and performance metrics. Preference information refers to the user's expressed technical selection preferences or work habits during development, such as a preference for a particular programming language, coding style, or testing method.

[0083] Constraint and preference information are characterized by being embedded within specific task instructions when expressed by the user, lacking an independent form of expression; their validity typically spans multiple sessions, remaining effective throughout subsequent development. If this type of information is not identified and extracted from user input in a timely manner, it will gradually be submerged or lost as the session progresses and context is compressed, causing the session model to fail to adhere to user constraints and preferences in subsequent interactions.

[0084] When a user input monitoring node is triggered, the system identifies constraint information and / or preference information from the user's current input. The scope of identification is limited to the user's current input, excluding historical interactions within the session flow. In one embodiment, the system identifies constraint and preference information through keyword matching. It predefines keyword sets for constraint and preference categories, matches the user input, and identifies statements matching these keywords as constraint or preference information. In another embodiment, the system uses a session model to perform semantic understanding of the user input, determining whether it contains constraint or preference information. The session model determines whether the information represents a long-term, valid constraint or technical preference expressed by the user; if so, it identifies it as target information. In yet another embodiment, the system combines keyword matching and semantic understanding. It first performs preliminary screening using keyword matching to extract statements that may contain constraints or preferences, and then uses a session model to semantically confirm the screening results, eliminating false positives.

[0085] Step S5320: When the session flow reaches the execution stage bound to the context capacity listening node, determine that the corresponding memory retrieval rule is to retrieve task execution status information.

[0086] When the session flow reaches the execution phase bound to the context capacity monitoring node, the memory retrieval rule corresponding to that node is determined to be the extraction of task execution status information. That is, when the context capacity reaches a preset threshold and context compression is about to be performed, the system extracts the execution status information of the current task from the current session content as the target information.

[0087] Task execution status information refers to a description of the current task's progress at the time context compression occurs, including the task's current objective, completed steps, decisions made, next steps, and current obstacles. This information reflects the complete progress status of the task at a specific point in time.

[0088] During the session flow, when the context capacity reaches a preset threshold, the session engine will perform context compression. Compression removes or summarizes some historical interaction content; after compression, detailed progress information during task execution will no longer exist in the context in its original form. If the task execution state information is not saved before compression, the session model will be unable to perceive the current task's progress after compression, leading to task interruption and forcing the user to re-describe the task progress. Therefore, the memory retrieval rule corresponding to the context capacity listening node is set to extract task execution state information. The purpose is to save the current task progress state before compression occurs, allowing the session model to continue executing the task after compression.

[0089] When the context capacity listening node is triggered, the system extracts task execution status information from the current session content. The extraction scope includes all session content generated in the current session flow, and the extracted objects are information related to the current task execution progress. In one embodiment, the system uses a session model to summarize the current session content and generate a summary description of the task execution status. The session model generates a structured task status description based on information such as the task objective, executed operations, and obtained results in the session content, serving as the task execution status information. In another embodiment, the system extracts specific types of information related to task execution from the current session content. The system identifies task objective descriptions, operation records, decision records, and plan descriptions in the session content and summarizes this information into task execution status information.

[0090] Step S5330: When the session flow reaches the execution stage bound to the task completion listening node, determine the corresponding memory retrieval rule as extracting root cause information, execution result information and verification conclusion information.

[0091] When the session flow reaches the execution phase bound to the task completion monitoring node, the memory retrieval rule corresponding to that node is determined to be the extraction of root cause information, execution result information, and verification conclusion information. That is, when the session model completes a task, the system extracts the root cause information, execution result information, and verification conclusion information of the task from the current session content as the target information.

[0092] In software development scenarios, when a session model completes a task, the information generated during task execution that has high cross-session reuse value includes three categories: root cause information, which refers to the root cause of the problem located during task execution. For example, when troubleshooting build failures, the root cause finally located (such as dependency version conflicts, cache corruption, etc.) is the root cause information, which has direct reference value when encountering similar problems in the future; execution result information, which refers to the final processing result of the task, such as which file was repaired, which configurations were changed, and what solution was adopted. Execution result information records the actual output of the task and is valuable when backtracking or referencing it in the future; and verification conclusion information, which refers to the conclusions obtained after verifying the execution results, such as whether the build passed after the repair, whether the test was successful, and whether the performance indicators were met. Verification conclusion information confirms the validity of the execution results and is valuable for reference when judging whether the solution is reliable in the future.

[0093] When the task completion monitoring node is triggered, the system extracts root cause information, execution result information, and verification conclusion information from the current session content. The extraction scope covers session content related to the currently completed task. In one embodiment, the system uses a session model to analyze the session content during task execution, identifying root cause information, execution result information, and verification conclusion information. The session model determines, based on the context of task execution, which content pertains to the root cause of the problem, which pertains to the final processing result, and which pertains to the verification conclusion of the result. In another embodiment, the system obtains the three types of information by sending specific instructions to the session model. The system sequentially sends instructions to the session model requesting a summary of the root cause, a summary of the execution result, and a summary of the verification conclusion. The session model generates corresponding descriptions as root cause information, execution result information, and verification conclusion information, respectively. In yet another embodiment, the system extracts information in segments based on the session content generated at different stages of task execution: root cause information is extracted from the session content generated during the task investigation stage, execution result information is extracted from the session content generated during the task execution stage, and verification conclusion information is extracted from the session content generated during the task verification stage.

[0094] Step S5340: When the session flow reaches the execution stage bound to the session termination listening node, determine that the corresponding memory retrieval rule is to extract conclusion information and experience information.

[0095] When the session flow reaches the execution phase bound to the session termination listening node, the memory retrieval rule corresponding to that node is determined to be the extraction of conclusion information and experience information. That is, when the session flow ends, the system extracts the confirmed conclusion information and reusable experience information from the session content of this session as the target information.

[0096] At the end of the session, some validated conclusions and reusable experiences may have been generated. This information differs from the information extracted when the task is completed in step S5330: the information extracted when the task is completed focuses on the execution result of a specific task, while the information extracted when the session ends focuses on the general knowledge accumulated throughout the entire session.

[0097] Specifically, conclusion information refers to factual conclusions that have been confirmed and are stable during this session. For example, it has been confirmed that the calling method of a certain interface must carry specific parameters, or that the value range of a certain configuration item has been confirmed as a certain interval. The characteristic of conclusion information is that it has been verified and has a high degree of credibility. Experience information refers to practical knowledge accumulated during this session that has guiding significance for subsequent R&D work. For example, troubleshooting paths for a certain type of problem, best practices in a certain scenario, and usage techniques for a certain tool. The characteristic of experience information is that it may come from a single practice and has not been verified multiple times, but it has reference value for subsequent work.

[0098] When the session termination monitoring node is triggered, the system extracts conclusion and experience information from the session content of the current session. The extraction scope covers all session content generated during the current session. In one embodiment, the system uses a session model to summarize all session content, identifying confirmed conclusions and reusable experience. The session model determines which content constitutes confirmed conclusions and which constitutes reusable experience based on the discussion process, verification results, and final confirmation status within the session content. In another embodiment, the system obtains conclusion and experience information by sending specific instructions to the session model. The system sends an instruction to the session model requesting a summary of confirmed conclusions and reusable experience in the current session, and the session model generates corresponding descriptions based on the current context. In yet another embodiment, the system supplements the extraction with information already extracted by the task completion monitoring node. When the session termination monitoring node is triggered, the system determines whether there is valuable information in the current session not covered by the task completion monitoring node (e.g., general experience across multiple tasks, facts confirmed even without forming a complete task, etc.), and extracts this information as conclusion or experience.

[0099] As can be seen from the above embodiments, this application determines corresponding memory retrieval rules for the listening nodes at four different execution stages in the session flow. This ensures that when the user submits input, only constraint information and / or preference information is extracted; when the context is about to be compressed, only task execution status information is extracted; when the task is completed, only root cause information, execution result information, and verification conclusion information are extracted; and when the session ends, only conclusion information and experience information are extracted. Each execution stage extracts only specific types of information that match its information characteristics. This ensures that all valuable information in the session flow is fully captured at the time of its generation without omission, and also ensures that each stage does not extract content that is irrelevant to it. Thus, while solving the problem of key information being lost when the session is interrupted, it avoids information redundancy caused by full storage, enabling the captured information to be accurately retrieved and reused in the session.

[0100] Based on any embodiment of the method in this application, before writing the memory record to the remote memory service, the method includes: Step S5410: Determine the scope type of the memory record. The scope type includes personal scope and team shared scope.

[0101] Before writing a memory record to a remote memory service, determine the scope type of that memory record. Scope types include personal scope and team-shared scope. By assigning a scope identifier to each memory record before writing, it is clear whether the memory record belongs to the personal information of a specific user or is shared information belonging to the entire team.

[0102] In software development scenarios, the scope of use for different memory records varies. Some information is only meaningful to the user who generated it, such as personal coding preferences and work habits; this type of information should not be seen or used by other team members. Other information is valuable to the entire team, such as project-level architectural constraints, public interface calling standards, and confirmed technical conclusions; this type of information should be accessible and usable by other team members in their respective conversations.

[0103] Before a memory record is written to the remote memory service, the system determines its scope type for each memory record. Scope types include personal scope and team-shared scope. Memory records determined to have a personal scope belong only to the user who generated the information, while memory records determined to have a team-shared scope belong to the user's team, and other team members can retrieve and use them. In one embodiment, the scope type is manually specified by the user. When submitting input on the client, the user can mark the scope type of the current information through interface options or commands, and the system determines the scope type of the memory record based on the user's specification. In another embodiment, the scope type is automatically determined by the system based on the content of the memory record. The system analyzes the content of the memory record to determine whether the information is only related to a specific user (such as personal preferences or habits) or related to the entire team (such as project constraints or public norms), and automatically determines the scope type accordingly.

[0104] Scope types can be further subdivided into project-level scopes, meaning a memory record belongs only to a specific project. Members within that project can retrieve and use it, while members of other projects cannot see it. This refinement is suitable for scenarios where the same user participates in multiple projects simultaneously, and there is a need for information isolation between different projects.

[0105] Step S5420: Write the scope type as the storage identifier of the memory record into the remote memory service so that the memory records of the personal scope are stored separately from the memory records of the team-shared scope.

[0106] By using scope type as the storage identifier for memory records in the remote memory service, memory records in personal scopes are stored separately from those in team-shared scopes. By isolating personal memories and team-shared memories at the storage level in the remote memory service, retrieval can be performed based on scope type, avoiding confusion and misuse between the two types of memories.

[0107] Storage identifiers are markings added by the remote memory service when storing memory records, used to distinguish memory records from different scopes during retrieval. Separate storage means that memory records in personal scopes and those in team-shared scopes are not stored together in the remote memory service. Specifically, memory records in personal scopes are only visible within the retrieval scope of their respective users, while memory records in team-shared scopes are visible within the retrieval scope of all team members. This isolation mechanism ensures the privacy of personal information while guaranteeing the accessibility of shared information within the team.

[0108] When a memory record is written to the remote memory service, the determined scope type is written along with it as the storage identifier of the memory record. Upon receiving the memory record and its storage identifier, the remote memory service stores the memory record in the corresponding storage area based on the storage identifier. In one embodiment, the remote memory service sets up two independent storage areas: one for storing memory records in a personal scope and the other for storing memory records in a team-shared scope. The system writes the memory records to the corresponding storage area based on the storage identifier. In another embodiment, the remote memory service sets up a unified storage area, with a scope identifier field appended to each memory record. The system distinguishes between personal memories and team-shared memories based on the scope identifier field and filters searches based on this field. In yet another embodiment, personal scope memory records are written with the user identifier as an additional storage identifier, and searches are performed based on the user identifier; team-shared scope memory records are written with the team identifier as an additional storage identifier, and searches are performed based on the team identifier.

[0109] As can be seen from the above embodiments, this application determines the scope type of a memory record before it is written to the remote memory service, and writes the scope type as a storage identifier along with the memory record. This allows memory records in a personal scope to be stored separately from memory records in a team-shared scope. This enables cross-session information reuse while further differentiating the scope of information reuse. Personal memories are only visible within the retrieval scope of their respective users, while team-shared memories are visible within the retrieval scope of all team members. This avoids misreading of personal privacy information by other members and ensures that the experience accumulated by the team can be reused by all members. It also allows the retrieval results to accurately match the actual needs of the current user and further reduces the impact of irrelevant information on retrieval efficiency.

[0110] Based on any embodiment of the method in this application, after writing the memory record to the remote memory service, the method includes: Step S5510: After the session flow completes the execution context compression, read the memory record corresponding to the task execution status information from the remote memory service.

[0111] After the session flow completes execution context compression, the memory record corresponding to the task execution status information is read from the remote memory service. When the context capacity reaches a preset threshold and context compression is about to be performed, the system has already extracted the task execution status information and written it to the remote memory service. This step, after context compression is complete, reads back the memory record from the remote memory service, providing a data source for reloading the task execution status information into the session context.

[0112] As explained in step S5320, when the context capacity reaches a preset threshold, the session engine will perform context compression. The compression operation removes or summarizes some historical interaction content; after compression, detailed progress information during task execution no longer exists in the context in its original form. Without restoration, the session model will be unable to perceive the current task's progress after compression, leading to task interruption. This step, after context compression is complete, reads the memory record corresponding to the task execution state information saved before compression from the remote memory service. This memory record contains a description of the task progress before compression; reading this record restores the perception of the current task state.

[0113] After the session flow completes the context compression operation, the system initiates a read request to the remote memory service, requesting to read the memory record corresponding to the task execution status information. Upon receiving the request, the remote memory service locates and returns the corresponding memory record. In one embodiment, the system reads the memory record using its unique identifier. When writing to the remote memory service in step S5400, each memory record is assigned a unique identifier. After context compression, the system initiates a read request to the remote memory service using this unique identifier, and the remote memory service returns the corresponding memory record. In another embodiment, the system retrieves the memory record using its content topic identifier. The system initiates a retrieval request to the remote memory service using the content topic identifier corresponding to the task execution status information, and the remote memory service returns the memory record matching that topic identifier. In yet another embodiment, the system reads the memory record using its timestamp. The system initiates a read request to the remote memory service using the timestamp written before compression as a condition to obtain the memory record corresponding to the most recently written task execution status information.

[0114] Step S5520: Load the memory record into the compressed session context so that the session model can continue to execute the current task.

[0115] The read memory record is loaded into the compressed session context, allowing the session model to continue executing the current task based on this memory record and the compressed session context. Even after context compression, the session model can still perceive the progress status of the current task and continue execution from where it was interrupted, rather than starting over.

[0116] After context compression, the historical interactions in the session context have been removed or summarized. If the session model's response were to continue directly at this point, it would lack awareness of the current task's progress and be unable to determine the next action. This step loads the memory record corresponding to the read task execution status information into the compressed session context, essentially supplementing the compressed context with descriptive information about the task's progress. When generating subsequent responses, the session model can refer to the task objective, completed steps, and next steps in this memory record, thus resuming execution of the current task from where it was interrupted.

[0117] After successfully reading the memory record corresponding to the task execution status information, the system loads the memory record into the compressed session context. Once loaded, the session model can perceive the content of the memory record when generating a response next time. In one embodiment, the system inserts the memory record as a separate context entry into the compressed session context. This entry is located at the end of the compressed context content, and the session model uses it as one of the reference information when generating subsequent responses. In another embodiment, the system appends the content of the memory record to the system prompt section of the compressed context. The system prompt is a fixed area that the session model prioritizes referencing each time a response is generated; placing the task execution status information in this area ensures that the session model can perceive the task progress with each response. In yet another embodiment, the system injects the content of the memory record as a new user input into the compressed session context. The session model treats this content as background information provided by the user and continues executing the current task accordingly.

[0118] As can be seen from the above embodiments, this application reads the memory record corresponding to the task execution status information saved before compression from the remote memory service after context compression is completed, and loads the memory record into the compressed session context. This allows the session model to continue executing the current task based on the memory record. Context compression no longer causes interruption of the current task, and the session model can still perceive the current progress of the task after compression, resuming execution from the point of interruption without requiring the user to re-describe the task progress. This solves the problem of key information loss caused by context compression, ensuring task continuity even with limited capacity. It is a concrete manifestation of capturing and reusing key R&D information during the session within the same session.

[0119] Based on any embodiment of the method in this application, the method further includes: Step S5610: Register a session startup listener node to bind to the execution phase of the session process startup.

[0120] A session startup listener node is registered in the session engine, and this node is bound to the execution phase of the session flow startup. When a new session flow starts, the session flow enters the corresponding execution phase, and the session startup listener node is triggered. Through this node, the system can automatically perform the retrieval and loading of memory records each time a session flow starts, enabling the session model to inherit historically accumulated knowledge at the beginning of the session.

[0121] In steps S5100 to S5400, the system has captured valuable information and written it to the remote memory service at multiple execution stages of the session flow. These memory records are persistently stored in the remote memory service and are not lost when the session flow ends. However, when a new session flow starts, the session model's context is empty and lacks the ability to perceive historical information. The role of the session start listening node is to automatically retrieve memory records related to the current user from the remote memory service and load them into the current session context each time a session flow starts, enabling the session model to perceive historical information at the beginning of the session. This node is the entry point for cross-session information reuse and complements the aforementioned write-type listening nodes; that is, the write-type nodes are responsible for saving information during the session, while the session start listening node is responsible for restoring information at the beginning of the session.

[0122] The session initiation listener node registers during session engine initialization and establishes a binding relationship with the execution phase corresponding to the session flow initiation. When a user initiates a new session through the client, the session engine detects the session flow initiation, determines that the session flow has entered the corresponding execution phase, and triggers the session initiation listener node. In one embodiment, the triggering of the session initiation listener node is performed synchronously before the session model generates the first response. After receiving the user's first input and before passing it to the session model, the session engine first triggers the session initiation listener node to perform the retrieval and loading of memory records, and then passes the user input along with the loaded memory records to the session model. In another embodiment, the triggering of the session initiation listener node is performed asynchronously when the session flow starts. After detecting the start of the session flow, the session engine immediately triggers the session initiation listener node to perform the retrieval and loading operations in the background, while simultaneously advancing the session flow normally. If the retrieval and loading operations are completed before the session model generates the first response, the first response can refer to the loaded memory records.

[0123] Step S5620: When the session flow reaches the execution stage bound to the session startup listening node, the corresponding memory record is extracted from the remote memory service according to the current user identifier, and the memory record is loaded into the context of the current session flow.

[0124] When the session flow reaches the execution phase bound to the session initiation listening node, the corresponding memory record is retrieved from the remote memory service based on the current user identifier and loaded into the context of the current session flow. The session model can perceive the user's historically accumulated memory information at the start of a new session, without requiring the user to re-describe the background, thus achieving information continuation across sessions.

[0125] User identifiers are unique markers used to distinguish different users. Memory records stored in the remote memory service are associated with user identifiers, and each memory record can be traced back to the user who created it. Retrieving a record based on the current user identifier allows access to all relevant historical memory records accumulated by that user. Using the current user identifier as the search criterion, the memory records corresponding to that user are extracted from the remote memory service and loaded into the context of the current session flow. Once loaded, the session model can refer to this historical memory information when generating responses, thus continuing the perception of historical knowledge in new sessions.

[0126] When the session initiation listening node is triggered, the system obtains the current user's user identifier and initiates a retrieval request to the remote memory service based on this user identifier. The remote memory service searches for the corresponding memory record based on the user identifier and returns the search result to the system. The system loads the returned memory record into the context of the current session flow. In one embodiment, the system retrieves all memory records corresponding to the user identifier and loads all retrieved memory records into the current session context. This method is suitable for scenarios where the user has accumulated a small number of memory records. In another embodiment, the system filters the memory records corresponding to the user identifier, loading only memory records that meet preset conditions into the current session context. The preset conditions may include a time range (e.g., only loading memory records within a certain recent time period) and a content theme (e.g., only loading memory records related to the current session theme). This method is suitable for scenarios with a large number of memory records and where the loading volume needs to be controlled. In another embodiment, the system sorts the memory records corresponding to the user identifier according to their relevance, loads the memory records with higher rankings into the current session context, and does not load the memory records with lower rankings. The criteria for judging relevance may include the degree of semantic matching between the memory record and the content first entered by the current user, the time of the memory record, etc. When there are a large number of memory records, this method prioritizes loading the memory records most relevant to the current session.

[0127] As can be seen from the above embodiments, this application binds the session startup listening node to the execution phase of the session process startup by registering the session startup listening node. When the session process starts, it extracts the corresponding memory record from the remote memory service based on the current user identifier and loads it into the current session context. This allows the session model to automatically inherit the user's historically accumulated memory information each time a new session process starts, without requiring the user to re-describe the background or the session model to repeatedly analyze known conclusions. The write-type node saves key information to the remote memory service during the session, and the session startup listening node restores the historical memory to the current context when a new session begins, thereby achieving the continuous reuse of key R&D information across different sessions.

[0128] Based on any embodiment of the method in this application, the method further includes: Step S5710: Store the memory record as a memory file in a preset file format. The memory file contains a metadata header.

[0129] The memory records are stored as memory files in a preset file format, and the memory files contain metadata headers. Through this step, the memory records stored in the remote memory service are converted into files of a specific format, enabling the memory records to be transferred and shared between different model tools in the form of files.

[0130] In real-world R&D scenarios, a team may use multiple model tools simultaneously (such as conversational development assistants, code completion tools, and automated testing tools), with each tool maintaining its own local data directory. If memory records are only stored in a remote memory service, these memory information cannot be directly shared between the different model tools.

[0131] When converting memory records into memory files, the system encapsulates the memory records stored in the remote memory service according to a preset file format to generate corresponding memory files. Each memory file contains two parts: a metadata header and the main content. The metadata header records descriptive information about the memory file, while the main content records the actual information content of the memory record. In one embodiment, the preset file format is a markup language format. The memory file is stored in the form of a markup language file, the metadata header is represented by a predefined header structure in the markup language, and the main content is represented by the main text area of ​​the markup language. This format is characterized by good readability and ease of manual editing and review. In another embodiment, the preset file format is a structured data exchange format. The memory file is stored in the form of key-value pairs, with the metadata header and main content serving as different key-value pair groups. This format is characterized by high parsing efficiency and ease of programmatic processing. In yet another embodiment, the preset file format is a custom format. The system defines a dedicated file structure, and the metadata header and main content are arranged according to this structure. This format is suitable for scenarios with special requirements for file structure.

[0132] The above file formats are functionally equivalent, all capable of encapsulating memory records into memory files containing metadata headers and body content. Those skilled in the art can choose any of these formats to implement the record, depending on the reading capabilities of the modeling tool and the team's usage habits.

[0133] Step S5720: Read memory files from the local directories corresponding to multiple model tools, and archive the memory files according to the source project based on the metadata header.

[0134] Memory files are read from the local directories corresponding to multiple model tools, and archived according to the source project based on the metadata header. Through this step, memory files scattered across the local directories of different model tools are centrally read and categorized by project, providing a unified archiving basis for subsequent comparisons and distribution.

[0135] In real-world R&D scenarios, a team may use multiple modeling tools simultaneously. Each tool maintains its own local data directory, containing the memory files it generates. Because the directory structures, file names, and storage locations of these tools may differ, the memory files are scattered across their local directories, lacking unified management. This step reads the memory files from the local directories of each modeling tool and archives them based on the source project information recorded in the metadata header. After archiving, memory files from the same source project are grouped together, while memory files from different source projects are separated, forming a unified view organized by project.

[0136] The system sequentially accesses the local directories corresponding to each model tool and reads the memory files within them. After reading, the system parses the metadata header of each memory file to obtain the source project information recorded therein, and then categorizes the memory files into the corresponding project groups based on the source project information. In one embodiment, the local directory paths of each model tool are pre-configured in the system, and the system accesses each directory sequentially according to the configured paths, reading all files that conform to a preset file format as memory files. In another embodiment, each model tool actively registers its local directory path with the system when generating memory files. The system determines the local directory location of each tool based on the registration information, and then accesses and reads the files sequentially.

[0137] Step S5730: Compare the archived memory files with the distributed memory files to determine the new and modified items.

[0138] The archived memory files are compared with the distributed memory files to identify new and modified items. This step allows the system to determine which memory files are new and which have been modified relative to the distributed version, thus defining the scope of content to be distributed and avoiding duplicate distribution of unchanged memory files.

[0139] The system archives memory files in the local directories of each model tool according to their source projects. However, not all archived memory files need to be distributed to other tools. Some memory files may have already been distributed without change; duplicate distribution not only wastes resources but may also cause conflicts at the receiving end. This step compares the archived memory files with the distributed memory files to identify two types of differences: new items (memory files that exist after archiving but are not in the distributed records) and modified items (memory files that exist after archiving and are also in the distributed records, but whose content has changed). Only new and modified items need to be distributed.

[0140] The system compares the archived memory files one by one with the distributed memory records. The distributed memory records store the identifiers and content information of each previously distributed memory file. Through comparison, the system determines which memory files are new, which are modified, and which remain unchanged. In one embodiment, the system compares by file identifier. Each memory file has a unique identifier. The system matches the identifier of the archived memory file with the identifier in the distributed records. If the identifier of the archived memory file does not exist in the distributed records, the file is a new item; if it exists but the content is different, the file is a modified item. In another embodiment, the system compares by the digest value of the file content. The system calculates a content digest value for each archived memory file and compares it with the digest value stored in the distributed records. If the digest value does not exist in the distributed records, it is a new item; if it exists but the digest value is different, it is a modified item. In another embodiment, the system compares the file's modification time. The system compares the last modification time of the archived file with the distribution time recorded in the distribution record. If the last modification time is later than the distribution time, the file is a modified item; if the archived file has no corresponding record in the distribution record, it is a newly added item.

[0141] The above comparison methods are functionally equivalent and can all identify newly added and modified items. Those skilled in the art can choose any one of these methods based on the characteristics of the memory file and the structure of the distributed records, or they can combine the above methods.

[0142] Step S5740: Distribute the memory files corresponding to the new and modified items to the local directory corresponding to the target model tool.

[0143] The memory files corresponding to the new and modified items are distributed to the local directory of the target model tool. Through this step, the new and modified memory files are synchronized to the local directories of other model tools, enabling all model tools to share the same project experience and achieve memory information interoperability between multiple model tools.

[0144] The target model tool refers to the model tool that needs to receive the memory distribution. This can be any tool used by the team other than the tool that generated the memory file, or any other tool. After distribution, each model tool's local directory contains the latest memory file, achieving memory sharing across tools.

[0145] The system writes the memory files corresponding to the identified new and modified items one by one into the local directory of the target model tool. Once writing is complete, the target model tool can read these memory files from its local directory. In one embodiment, the system directly copies the memory files to the target model tool's local directory; if a file with the same name already exists in the target directory, the new file overwrites the old one. In another embodiment, the system first packages the memory files corresponding to the new and modified items into a distribution package, and then sends the distribution package to the target model tool's local directory for unpacking. This method is suitable for scenarios with a large number of memory files to be distributed, reducing the number of transmissions. In yet another embodiment, the system only sends the differences between the memory files corresponding to the new and modified items to the target model tool. The target model tool updates the existing memory files in its local directory based on the differences. This method is suitable for scenarios with large memory file sizes where only partial updates are needed.

[0146] As can be seen from the above embodiments, this application stores memory records in a preset file format as memory files containing metadata headers. It reads these memory files from the local directories corresponding to multiple model tools and archives them according to the source project. The archived memory files are compared with the distributed memory files to determine new and modified items. Then, the memory files corresponding to the new and modified items are distributed to the local directories corresponding to the target model tools. This ensures that memory information is no longer limited to a single model tool but can be synchronized and shared among multiple model tools used by the team. Each model tool can obtain the same project experience, avoiding the inability to share experience due to data isolation between tools. This step further expands the scope of cross-session reuse from within a single tool to between multiple tools, enabling the reuse of key R&D information in a wider R&D toolchain and further reducing repetitive work for R&D personnel.

[0147] like Figure 3As shown, a software development session summarization device according to one aspect of this application includes a node registration module 5100, a rule determination module 5200, an information extraction module 5300, and a memory storage module 5400. The node registration module 5100 is used to register multiple listening nodes in a session engine for software development, wherein the multiple listening nodes are respectively bound to different execution stages of the session flow between a user and a session model. The rule determination module 5200 is used to determine the memory extraction rule corresponding to the current listening node when the session flow reaches the execution stage bound to the current listening node. The information extraction module 5300 is used to extract target information from the session content of the execution stage corresponding to the current listening node according to the memory extraction rule. The memory storage module 5400 is used to classify the target information according to content topics, obtain at least one memory record corresponding to the content topic, and write the memory record to a remote memory service for retrieval and loading into the session context.

[0148] Based on any embodiment of the device in this application, the node registration module 5100 includes any one or more of the following: The input listening module is used to register user input listening nodes and to bind the execution phase of the user submitting input to the session model. The capacity monitoring module is used to register context capacity monitoring nodes, which are used to bind to the execution phase when the context capacity reaches a preset threshold and context compression is about to be performed. The completion listening module is used to register task completion listening nodes, which are used to bind the session model to complete the execution phase of a task. The termination listening module is used to register a session termination listening node, which is used to bind to the execution phase when the session process ends.

[0149] Based on any embodiment of the device in this application, the rule determination module 5200 includes any one or more of the following: The input extraction module is used to determine the corresponding memory extraction rule as extracting the constraint information and / or preference information of the user input when the session flow reaches the execution stage bound to the user input listening node; The state extraction module is used to determine the corresponding memory extraction rule as extracting task execution state information when the session process reaches the execution stage bound to the context capacity listening node. The conclusion extraction module is used to determine the corresponding memory extraction rule when the session process reaches the execution stage bound to the task completion monitoring node, which is to extract root cause information, execution result information and verification conclusion information. The experience extraction module is used to determine the corresponding memory extraction rule as extracting conclusion information and experience information when the session flow reaches the execution stage bound to the session termination listening node.

[0150] Based on any embodiment of the device in this application, the memory storage module 5400 includes: A scope determination module is used to determine the scope type of the memory record, wherein the scope type includes personal scope and team-shared scope; The identifier writing module is used to write the scope type as the storage identifier of the memory record into the remote memory service, so that the memory records of personal scopes are stored separately from the memory records of team-shared scopes.

[0151] Based on any embodiment of the device in this application, the memory storage module 5400 further includes: The memory retrieval module is used to read the memory record corresponding to the task execution status information from the remote memory service after the session process has completed the execution context compression; The memory loading module is used to load the memory records into the compressed session context so that the session model can continue to execute the current task.

[0152] Based on any embodiment of the apparatus in this application, the software development session summarization apparatus further includes: The startup listening module is used to register session startup listening nodes, which are used to bind to the execution phase of the session startup process; The startup retrieval module is used to extract the corresponding memory record from the remote memory service based on the current user identifier when the session flow reaches the execution stage bound to the session startup listening node, and load the memory record into the context of the current session flow.

[0153] Based on any embodiment of the apparatus in this application, the software development session summarization apparatus further includes: The file storage module is used to store the memory records as memory files in a preset file format, and the memory files include metadata headers; The file archiving module is used to read the memory files from the local directories corresponding to multiple model tools and archive the memory files according to the source project based on the metadata header; The file comparison module is used to compare the archived memory files with the distributed memory files to determine the new and modified items; The file distribution module is used to distribute the memory files corresponding to the new items and the modified items to the local directory corresponding to the target model tool.

[0154] like Figure 4 As shown in the diagram, another embodiment of this application also provides an electronic device, wherein the internal structure of the electronic device is illustrated. The electronic device includes a processor, a computer-readable storage medium, a memory, and a network interface connected via a system bus. The computer-readable storage medium stores an operating system, a database, and computer-readable instructions. The database may store a sequence of control information. When the computer-readable instructions are executed by the processor, the processor can implement the software development session summary method described in this application. The processor of the electronic device provides computing and control capabilities to support the operation of the entire electronic device. The memory of the electronic device may store computer-readable instructions. When the computer-readable instructions are executed by the processor, the processor can execute the software development session summary method described in this application. The network interface of the electronic device is used for communication with a terminal. Those skilled in the art will understand that... Figure 4 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 electronic device to which the present application is applied. The specific electronic device may include more or fewer components than shown in the figure, or combine certain components, or have different component arrangements.

[0155] In this execution method, the processor is used for execution. Figure 3 The specific functions of each module and its submodules are defined within the system. The memory stores the program code and various data required to execute the aforementioned modules or submodules. The network interface is used for data transmission between the user terminal and the server. In this execution method, the memory stores the program code and data required to execute all modules / submodules in the software development session summary device of this application. The server can call the server's program code and data to execute the functions of all submodules.

[0156] This application also provides a storage medium storing computer-readable instructions, which, when executed by one or more processors, cause the one or more processors to perform the steps of the method described in any embodiment of this application.

[0157] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments of this application can be implemented by a computer program instructing related hardware. This computer program can be stored in a non-volatile readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The aforementioned storage medium can be a computer-readable storage medium such as a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM).

[0158] The above description is only a partial implementation method of this application. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principles of this application, and these improvements and modifications should also be considered within the scope of protection of this application.

Claims

1. A software development session summarization method, characterized in that, include: Multiple listening nodes are registered in the session engine used for software development, and the multiple listening nodes are respectively bound to different execution stages of the session flow between the user and the session model; When the session flow reaches the execution stage bound to the current listening node, the memory retrieval rule corresponding to the current listening node is determined; According to the memory retrieval rules, target information is extracted from the session content of the execution phase corresponding to the current monitoring node; The target information is classified according to the content theme to obtain at least one memory record for the corresponding content theme, and the memory record is written to the remote memory service for retrieval and loading into the session context.

2. The software development session summarization method according to claim 1, characterized in that, Registering multiple listening nodes in the session engine used for software development includes any one or more of the following: Registered user input listening nodes are used to bind to the execution phase of user input submission to the session model; Register a context capacity monitoring node to bind to the execution phase when the context capacity reaches a preset threshold and context compression is about to be performed; Register a task completion listener node, which is used to bind the session model to complete the execution phase of a task; Register a session termination listener node to bind to the execution phase at the end of the session process.

3. The software development session summarization method according to claim 2, characterized in that, The determination of the memory retrieval rules corresponding to the current monitoring node includes any one or more of the following: When the session flow reaches the execution stage bound to the user input listening node, the corresponding memory retrieval rule is determined to be the extraction of constraint information and / or preference information from the user input. When the session flow reaches the execution stage bound to the context capacity listening node, the corresponding memory retrieval rule is determined to be the retrieval of task execution status information; When the session process reaches the execution stage bound to the task completion monitoring node, the corresponding memory retrieval rule is determined to be the extraction of root cause information, execution result information, and verification conclusion information. When the session flow reaches the execution stage bound to the session termination listening node, the corresponding memory retrieval rule is determined to be the extraction of conclusion information and experience information.

4. The software development session summarization method according to claim 1, characterized in that, Before writing the memory record to the remote memory service, the following steps are included: Determine the scope type of the memory record, including personal scope and team-shared scope; The scope type is written as the storage identifier of the memory record into the remote memory service so that the memory records of the personal scope are stored separately from the memory records of the team-shared scope.

5. The software development session summarization method according to claim 3, characterized in that, After writing the memory record to the remote memory service, the process includes: After the session process completes execution context compression, the memory record corresponding to the task execution status information is read from the remote memory service; The memory record is loaded into the compressed session context so that the session model can continue to execute the current task.

6. The software development session summarization method according to any one of claims 1-5, characterized in that, The method further includes: Register a session startup listener node to bind to the execution phase of the session startup process; When the session flow reaches the execution stage bound to the session initiation listening node, the corresponding memory record is extracted from the remote memory service according to the current user identifier, and the memory record is loaded into the context of the current session flow.

7. The software development session summarization method according to claims 1-5, characterized in that, The method further includes: The memory record is stored as a memory file in a preset file format, and the memory file includes a metadata header; The memory files are read from the local directories corresponding to multiple model tools, and archived according to the source project based on the metadata header; Compare the archived memory files with the distributed memory files to determine the new and modified items; Distribute the memory files corresponding to the new and modified items to the local directory corresponding to the target model tool.

8. A software development session summarization device, characterized in that, include: The node registration module is used to register multiple listening nodes in the session engine used for software development. The multiple listening nodes are respectively bound to different execution stages of the session flow between the user and the session model. The rule determination module is used to determine the memory retrieval rule corresponding to the current listening node when the session flow is executed to the execution stage bound to the current listening node; The information extraction module is used to extract target information from the session content of the execution phase corresponding to the current monitoring node according to the memory extraction rules. The memory storage module is used to classify the target information according to the content theme, obtain at least one memory record for the corresponding content theme, and write the memory record to the remote memory service for retrieval and loading into the session context.

9. An electronic device comprising a central processing unit and a memory, characterized in that, The central processing unit is used to invoke and run a computer program stored in the memory to perform the steps of the method as described in any one of claims 1 to 7.

10. A non-volatile storage medium, characterized in that, It stores, in the form of computer-readable instructions, a computer program implemented according to any one of claims 1 to 7, which, when invoked by a computer, executes the steps included in the corresponding method.