Data analysis and judgment generation method and device, electronic equipment and storage medium

Abstract

The application embodiment proposes a research and judgment data generation method and device, electronic equipment and storage medium, the method comprises: obtaining the target intention category and target entity set of the research and judgment instruction; based on the preset industry knowledge architecture, the target intention category and the target entity set, a multi-layer dependent network is constructed; when it is determined that the data item layer nodes in the minimum generable set corresponding to the chapter layer nodes are all in the ready state, the chapter content is generated, and based on the data item identifier of the data item layer node in the minimum generable set, a structured paragraph label is generated in the chapter content; when it is determined that the unnecessary data item layer node is in the ready state after the corresponding chapter content is generated, based on the structured paragraph label, the target paragraph associated with the unnecessary data item layer node in the chapter content is locally rewritten and updated; the updated chapter content is merged to obtain the target research and judgment result, and the reliability of the research and judgment generation result in the complex business scenario is improved.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to methods, apparatus, electronic devices and storage media for generating analytical data. Background Technology

[0002] In large-scale model-assisted vertical industry report generation scenarios, related technologies typically rely on general-purpose intelligent agents for text generation and task orchestration. In these solutions, task decomposition and data tool invocation are often decided arbitrarily by the large language model. However, due to the lack of a dedicated industry knowledge architecture and fine-grained dependency network constraints, the system struggles to accurately construct the logical connections between business sections, analytical data, and underlying tools. This free orchestration model, lacking industry prior knowledge, is prone to high tool invocation error rates and mismatches between acquired data and actual needs when facing highly specialized analytical tasks.

[0003] To generate reports, related technologies typically trigger the overall writing of text content directly based on initially acquired data. However, this approach fails to establish a precise mapping between specific data items and the generated text, lacking a structured tracking mechanism. When some data arrives asynchronously later or the tool's call status changes, the solutions usually have to regenerate the entire chapter or allow the model to make free inferences in the absence of key data. This can easily lead to logical inconsistencies in the system's output text, making it difficult for the final content to provide rigorous and objective data support. Therefore, when handling complex business tasks, these technologies suffer from unreliable generated results and poor content consistency. Summary of the Invention

[0004] This application provides a data generation method, apparatus, electronic device, and storage medium for analysis, which can solve the above-mentioned technical problems.

[0005] To achieve the above objectives, a first aspect of this application proposes a method for generating analytical data, the method comprising: Obtain the analysis command, extract features from the analysis command, and obtain the target intent category and target entity set; Based on the preset industry knowledge architecture, the target intent category and the target entity set, a multi-layer dependency network is constructed. The multi-layer dependency network includes chapter layer nodes, data item layer nodes and tool layer nodes with hierarchical dependency relationships. The data item layer nodes carry data item identifiers, and the data content of the data item layer nodes is obtained after calling the tool layer nodes associated with the data item layer nodes. When it is determined that all data item layer nodes in the minimum generateable set corresponding to the chapter layer node are in a ready state, the chapter content corresponding to the chapter layer node is generated, and structured paragraph tags are generated in the chapter content based on the data item identifier of the data item layer node in the minimum generateable set. When it is determined that the non-essential data item layer node is in a ready state after the corresponding chapter content is generated, the target paragraph associated with the non-essential data item layer node in the chapter content is locally rewritten and updated based on the structured paragraph tag. The non-essential data item layer node is the data item layer node that does not belong to the minimum generateable set. The updated chapter content corresponding to all the chapter-level nodes is merged to obtain the target assessment result.

[0006] In some embodiments, constructing a multi-layer dependency network based on a preset industry knowledge architecture, the target intent category, and the target entity set includes: Based on the target intent category and the entity type in the target entity set, the preset chapter templates in the industry knowledge architecture are matched to obtain multiple candidate chapters; Determine the semantic similarity between the descriptive text of each candidate chapter and the judgment instruction; From a plurality of candidate chapters, candidate chapters with semantic similarity greater than a preset threshold are determined as target chapter nodes, and the multi-layer dependency network is constructed based on the target chapter nodes and the data item layer nodes and tool layer nodes associated with the target chapter nodes.

[0007] In some embodiments, before constructing the multi-layer dependency network based on a preset industry knowledge architecture, the target intent category, and the target entity set, the method further includes: When obtaining the judgment instruction and establishing the corresponding generation task, the current release version of the industry knowledge architecture is obtained, and the version number of the current release version is used as the execution version to be associated in the context of the generation task; The multi-layered dependency network is constructed based on the execution version, and the data content is obtained.

[0008] In some embodiments, before generating the chapter content corresponding to the chapter layer node, the method further includes: When there are unready data item layer nodes in the minimum generateable set corresponding to the chapter layer node, the timing duration is obtained, and the unready data item layer node is the data item layer node in an unready state. When the timeout duration reaches the preset timeout duration threshold, and there are still unread data item layer nodes in the minimum generateable set, the state of the unread data item layer node is changed to an unavailable state, and a semantic placeholder for the unread data item layer node is generated. Based on the data item layer nodes in the ready state within the minimum generateable set and the semantic placeholders, the chapter content corresponding to the chapter layer nodes is generated.

[0009] In some embodiments, the step of partially rewriting and updating the target paragraph associated with the non-essential data item layer node in the chapter content based on the structured paragraph tags includes: Based on all the structured paragraph tags in the chapter content, determine the forward mapping relationship from the data item identifier to the paragraph identifier, and the reverse mapping relationship from the paragraph identifier to the paragraph content; Based on the positive mapping relationship, determine the target paragraph identifier corresponding to the data item identifier of the non-essential data item layer node; Based on the reverse mapping relationship, the target paragraph content corresponding to the target paragraph identifier is determined; The target paragraph content is combined with the data content of the non-essential data item layer node to obtain a partial rewrite prompt. The target paragraph content is then rewritten based on the partial rewrite prompt to obtain the updated target paragraph content.

[0010] In some embodiments, after merging the chapter content corresponding to all the updated chapter layer nodes to obtain the target assessment result, the method further includes: A structured analysis card is generated based on the multidimensional metadata in the target analysis results, wherein the multidimensional metadata includes a conclusion summary; Based on the entity identifiers in the target entity set, the geographical range data and timestamp data in the structured judgment card, and the conclusion summary, a geospatial index, a time-series index, an entity association index, and a semantic vector index are constructed, and the structured judgment card is stored in the judgment memory pool.

[0011] In some embodiments, the method further includes: Obtain cross-session analysis instructions, and retrieve candidate structured analysis cards from the analysis memory pool based on the geospatial index, the temporal index, the entity association index, and the semantic vector index; Determine the entity matching degree, geographical overlap degree, and semantic similarity between the cross-session judgment instruction and each candidate structured judgment card; Determine the time difference between the current time and the timestamp data of each of the candidate structured judgment cards, multiply the time difference by a preset time-effect decay coefficient, and perform an exponential operation to obtain the time-effect decay weight; The entity matching degree, geographical overlap degree and semantic similarity are weighted and summed based on the preset first weight, second weight and third weight respectively, and then multiplied by the time-effect decay weight to obtain the composite score; Based on the composite score, a target judgment card is determined from the candidate multiple structured judgment cards, and a summary of the conclusion of the target judgment card is added to the current session context.

[0012] To achieve the above objectives, a second aspect of this application provides an analytical data generation apparatus, the apparatus comprising: The instruction acquisition module is used to acquire and analyze instructions, extract features from the analysis instructions, and obtain the target intent category and target entity set. The network generation module is used to construct a multi-layer dependency network based on a preset industry knowledge architecture, the target intent category, and the target entity set. The multi-layer dependency network includes chapter layer nodes, data item layer nodes, and tool layer nodes with hierarchical dependency relationships. The data item layer nodes carry data item identifiers, and the data content of the data item layer nodes is obtained after calling the tool layer nodes associated with the data item layer nodes. The chapter content generation module is used to generate chapter content corresponding to the chapter layer node when it is determined that all data item layer nodes in the minimum generateable set corresponding to the chapter layer node are in a ready state, and to generate structured paragraph tags in the chapter content based on the data item identifier of the data item layer node in the minimum generateable set. The content update module is used to perform local rewrite updates on the target paragraph associated with the non-essential data item layer node in the chapter content based on the structured paragraph tags when it is determined that the non-essential data item layer node is in a ready state after the corresponding chapter content is generated. The non-essential data item layer node is the data item layer node that does not belong to the minimum generateable set. The analysis result generation module is used to merge the chapter content corresponding to all the updated chapter layer nodes to obtain the target analysis result.

[0013] To achieve the above objectives, a third aspect of this application provides an electronic device, which includes a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the data generation method for analysis as described in the first aspect.

[0014] To achieve the above objectives, a fourth aspect of the present application provides a storage medium, which is a computer-readable storage medium storing a computer program that, when executed by a processor, implements the data generation method for analysis as described in the first aspect.

[0015] The data generation method, apparatus, electronic device, and storage medium proposed in this application include the following steps: First, obtaining an analysis instruction and extracting features from the analysis instruction to obtain a target intent category and a target entity set; then, constructing a multi-layer dependency network based on a preset industry knowledge architecture, target intent category, and target entity set. The multi-layer dependency network includes chapter-level nodes, data item-level nodes, and tool-level nodes with hierarchical dependencies. The data item-level nodes carry data item identifiers, and the data content of the data item-level nodes is obtained after calling the tool-level nodes associated with them; next, when the minimum possible value corresponding to the chapter-level node is determined... When all data item layer nodes within the generated set are in a ready state, the chapter content corresponding to the chapter layer nodes is generated, and structured paragraph tags are generated in the chapter content based on the data item identifiers of the data item layer nodes within the minimum generateable set. Then, when it is determined that the non-essential data item layer nodes are in a ready state after the corresponding chapter content is generated, the target paragraphs associated with the non-essential data item layer nodes in the chapter content are partially rewritten and updated based on the structured paragraph tags. Non-essential data item layer nodes are data item layer nodes that do not belong to the minimum generateable set. Finally, the chapter content corresponding to all the updated chapter layer nodes is merged to obtain the target assessment result. This application embodiment acquires judgment instructions and extracts features, constructing a multi-layer dependency network based on a preset industry knowledge architecture, including chapter-level nodes, data item-level nodes, and tool-level nodes. This ensures that task decomposition and underlying tool invocation are subject to structured prior constraints, establishing accurate logical connections between business chapters, analysis data, and underlying tools. This reduces tool invocation error rates and ensures the matching degree between acquired data and actual needs. Furthermore, by triggering chapter content generation when data within the minimum generateable set is ready, and generating structured paragraph tags based on data item identifiers in the generated chapter content, a precise mapping and tracking mechanism between specific data items and generated text is established. This allows for accurate identification of the affected scope and partial rewriting and updating of target paragraphs based on the structured paragraph tags when unnecessary data items arrive asynchronously. This avoids free model inference when key data is missing and full rewriting caused by late data arrival. Thus, while saving system inference resources, it ensures the consistency of the output text logic and objective data support, improving the reliability of judgment generation results in complex business scenarios.

[0016] Other features and advantages of this application will be set forth in the description which follows, and will be apparent in part from the description, or may be learned by practicing the application. The objectives and other advantages of this application may be realized and obtained by means of the structures particularly pointed out in the description, claims and drawings. Attached Figure Description

[0017] Figure 1 This is a flowchart of a data generation method for analysis provided in an embodiment of this application.

[0018] Figure 2 This is another embodiment of the present application, providing an execution version association flowchart.

[0019] Figure 3 yes Figure 1 The flowchart for step 102.

[0020] Figure 4 This is a schematic diagram of the hierarchical structure of the investment research industry knowledge architecture provided in another embodiment of this application.

[0021] Figure 5 This is a schematic diagram of the structure and flow logic of a multi-layer dependency network of chapter-data item-tool provided in another embodiment of this application.

[0022] Figure 6 This is a flowchart of chapter content timed degradation processing provided in another embodiment of this application.

[0023] Figure 7 This is a schematic diagram of a chapter content generation and patch injection process based on a data-ready event-driven approach, provided in another embodiment of this application.

[0024] Figure 8 yes Figure 1 The flowchart for step 104.

[0025] Figure 9 This is a flowchart of the generation and storage of a structured assessment card provided in another embodiment of this application.

[0026] Figure 10 This is a schematic diagram of the data structure and class diagram entity association of the structured judgment card provided in another embodiment of this application.

[0027] Figure 11 This is a flowchart of a structured analysis card recall process provided in another embodiment of this application.

[0028] Figure 12 This is a schematic diagram of the cross-session analysis card recall and context injection process provided in another embodiment of this application.

[0029] Figure 13This is a schematic diagram of the structure of the data generation device for analysis provided in another embodiment of this application.

[0030] Figure 14 This is a schematic diagram of the hardware structure of an electronic device provided in another embodiment of this application. Detailed Implementation

[0031] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0032] It should be noted that although functional modules are divided in the device schematic diagram and the logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than the module division in the device or the order in the flowchart.

[0033] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs. The terminology used herein is for the purpose of describing embodiments of this application only and is not intended to limit this application.

[0034] In large-scale model-assisted vertical industry report generation scenarios (such as professional investment research), related technologies typically rely on general-purpose intelligent agent platforms to provide natural language text generation capabilities and initial task orchestration. However, long-form reports in specialized fields have extremely high requirements for data rigor and logical derivation processes. In related technical solutions, task decomposition and the order of data tool invocation are often decided arbitrarily by the large language model based on its general cognition. Due to the lack of a dedicated industry knowledge architecture (i.e., the lack of industry ontology definitions and task decomposition schemas as prior constraints), the system struggles to accurately construct the logical connections between business chapters, analytical data, and underlying interface tools when facing complex business scenarios. This free orchestration mode, lacking industry priors, results in randomness in the flow path of the same type of analytical task in different execution sessions. This not only easily leads to high error rates in tool selection and invocation but also causes a misalignment between the acquired data dimensions and actual business needs, making it difficult to guarantee the consistency of the generated results.

[0035] Meanwhile, regarding the internal generation and scheduling mechanisms, related technologies generally adopt a relatively coarse, serial generation mode, lacking fine-grained scheduling algorithms based on chapter and data dependencies. To complete report generation, these solutions typically trigger the overall writing task of the corresponding chapter content directly after initially acquiring the required data. This execution method fails to establish a precise mapping relationship between the structured data items collected at the underlying level and the natural language text generated by the large language model. The output of the large model presents unlabeled, unstructured text, resulting in a lack of structured tracking methods for the destination of key data within the system.

[0036] Furthermore, in real-world business environments, the response times of multi-source heterogeneous data interfaces often vary, frequently resulting in some non-essential data arriving asynchronously only after the main content of the corresponding chapter has been generated. When faced with such subsequent data arrivals or changes in the status of external tool calls, existing solutions lack precise paragraph-level labeling methods for the output content, making it impossible to isolate and locate the affected local areas within the already generated text. Therefore, the system typically has to regenerate the entire chapter. This not only results in a significant waste of system inference computing power and increased processing time but also easily disrupts the overall stability of the original report content.

[0037] Furthermore, when encountering anomalies such as the failure of critical tool calls across the entire process, if the scheduling layer lacks effective timeout fallback and degradation mechanisms to prevent deadlocks, the relevant technologies may cause the scheduler to be permanently blocked and waiting. Even if the system forcibly overcomes the error and continues execution, it often has no choice but to allow the large language model to make free inferences without key data quantification indicators (i.e., generating model illusions), which will directly lead to logical inconsistencies in the system's output text. Therefore, when handling complex and rigorous business tasks, the overall scheduling efficiency of these technologies is low, making it difficult to provide rigorous and objective data support for the final content, resulting in unreliable judgments and poor consistency in content logic.

[0038] Based on this, this application embodiment acquires judgment instructions and extracts features, constructs a multi-layer dependency network based on a preset industry knowledge architecture, including chapter-level nodes, data item-level nodes, and tool-level nodes. This makes task decomposition and underlying tool invocation subject to structured prior constraints, establishes accurate logical connections between business chapters, analysis data, and underlying tools, reduces tool invocation error rates, and ensures the matching degree between acquired data and actual needs. Furthermore, by triggering chapter content generation when data within the minimum generateable set is ready, and generating structured paragraph tags based on data item identifiers in the generated chapter content, a precise mapping and tracking mechanism between specific data items and generated text is established. This allows for accurate determination of the affected scope and partial rewriting and updating of target paragraphs based on the structured paragraph tags when unnecessary data items arrive asynchronously. This avoids free model inference when key data is missing and full rewriting caused by late data arrival. Thus, while saving system inference resources, it ensures the consistency of the output text logic and objective data support, and improves the reliability of judgment generation results in complex business scenarios.

[0039] The following will further describe the data generation method, apparatus, electronic device and storage medium for analysis provided in the embodiments of this application.

[0040] Reference Figure 1 This is an optional flowchart of the data generation method for analysis provided in the embodiments of this application. Figure 1 The method may include, but is not limited to, steps 101 to 105. It is also understood that this embodiment... Figure 1 The order of steps 101 to 105 is not specifically limited; the order of steps can be adjusted or certain steps can be added or removed according to actual needs. The data generation method for analysis provided in this application can be applied to any processing system with computing resources (such as servers, smart terminals, computing processors, etc.).

[0041] Step 101: Obtain the analysis command, extract features from the analysis command, and obtain the target intent category and target entity set.

[0042] Step 101 will be described in detail below.

[0043] In step 101 of some embodiments, the system first receives a natural language analysis instruction from the front-end or upstream module. Then, it obtains the target intent category corresponding to the analysis instruction through intent classification operations (e.g., identifying whether the current task is report generation or briefing generation); at the same time, it performs entity extraction operations based on the ontology layer to extract the set of target entities contained in the analysis instruction (such as specific sector, land parcel, and other entity information).

[0044] Step 102: Based on the preset industry knowledge architecture, target intent category and target entity set, construct a multi-layer dependency network. The multi-layer dependency network includes chapter layer nodes, data item layer nodes and tool layer nodes with hierarchical dependency relationships. Among them, the data item layer nodes carry data item identifiers, and the data content of the data item layer nodes is obtained after calling the tool layer nodes associated with the data item layer nodes.

[0045] Step 102 is described in detail below.

[0046] In step 102 of some embodiments, the system uses a pre-loaded industry knowledge architecture as a foundation, combined with the obtained target intent category and target entity set, to match the chapters and data requirements that meet the current task through rule matching and semantic scoring, thereby constructing a multi-layer dependency network (i.e., a multi-layer directed acyclic graph) containing chapter layer nodes, data item layer nodes, and tool layer nodes. In this multi-layer dependency network, data item layer nodes are assigned specific data item identifiers and do not generate data themselves; the actual data content can only be obtained by calling the specific tool layer nodes (such as backend data source interfaces) bound to them downstream. This logically and tightly connects the text chapters with the underlying data interfaces.

[0047] Understandably, an industry knowledge architecture, or investment research industry schema, is a pre-built formalized specification for a vertical domain. It typically includes an ontology layer (defining relevant entities and attributes), a chapter template layer (defining report structure and data dependencies), a KPI dictionary layer, a tool mapping layer, and an agent capability layer. Its main function is to provide the system with prior business constraints for the professional domain.

[0048] Reference Figure 2 Before constructing a multi-layer dependency network based on a preset industry knowledge architecture, target intent category, and target entity set, the method also includes the following steps 201 to 202.

[0049] Step 201: When obtaining the analysis instructions and establishing the corresponding generation task, obtain the current release version of the industry knowledge architecture and use the version number of the current release version as the execution version to associate it in the context of the generation task.

[0050] Step 202: Build a multi-layer dependency network based on the execution version and obtain the data content.

[0051] Steps 201 to 202 are described in detail below.

[0052] In step 201 of some embodiments, during actual operation, when the scheduling execution module receives the user's judgment instruction and allocates memory to initialize a generation task, the system sends a request to the storage industry knowledge architecture service module to obtain a snapshot of the latest released version of the knowledge architecture. Upon successful acquisition, the system uses the version number corresponding to the knowledge architecture snapshot as the execution version, binding and locking it within the context of the current generation task. At the underlying design level, this operating mechanism is similar to the snapshot isolation principle in database systems, that is, establishing a consistent business rule benchmark for each independently started task at that time and place.

[0053] The execution version (i.e., the schema snapshot version number) refers to the business snapshot that the system reads from the industry knowledge architecture server (i.e., the industry schema service module) at the physical moment when a report generation task is created, and writes the snapshot and its corresponding version number into the task context where the task is located. The version number locked at this time is the execution version of the task.

[0054] In step 202 of some embodiments, after version locking is completed, the current generation task begins its substantive workflow. Subsequently, when the system constructs the topology of a multi-layered dependency network (i.e., a three-layered directed acyclic graph containing chapters, data items, and tools), when determining the state of the minimum generateable set for each chapter, and when formatting and validating the input parameters before actually calling the underlying tools, all operation instructions are based on the snapshot corresponding to the locked execution version in the aforementioned context.

[0055] Specifically, if, during the report's several-minute generation and execution period, operations personnel perform a hot update to the industry knowledge architecture (e.g., modifying dependencies in a chapter or replacing the mapping of a data interface), the new version of the architecture released by the backend will only apply to newly created tasks after the update. The internal data flow network and tool call space of currently executing tasks will continue to progress steadily according to the initially bound execution version, and the system remains isolated from external updates. Simultaneously, the backend service maintains reference counts for each version snapshot to ensure that as long as there are tasks that depend on that execution version, the old version snapshot will not be reclaimed until the task is completed.

[0056] To ensure the logical coherence and data structure consistency of long text analysis tasks throughout the entire execution cycle, this embodiment introduces a version isolation mechanism during the construction and flow of the multi-layer dependency network. Specifically, when obtaining the analysis instruction and establishing the corresponding generation task (i.e., the task creation time), the scheduling module requests the industry knowledge architecture (i.e., industry schema) service module to read the latest released version of the knowledge architecture snapshot, and writes and locks the obtained version number as the execution version in the context of the current generation task, so as to provide a globally consistent rule benchmark for each independently started report generation task.

[0057] After completing the version locking operation, all operations of the current generation task throughout its subsequent lifecycle are strictly limited to the constraints of this execution version. Whether it's the topology construction of the three-layer directed acyclic graph (multi-layer dependency network), the dynamic determination of the minimum generateable set corresponding to each chapter node, or the input parameter rule verification before calling underlying tools, everything is based on the knowledge architecture snapshot corresponding to the execution version. When the industry knowledge architecture service module releases a new version of the architecture configuration during system operation (i.e., a hot update occurs), those analysis tasks already in progress will be completely unaffected by this new version change and will continue to use their bound execution version until the generation process ends; the newly released knowledge architecture version only applies to tasks created after the hot update operation.

[0058] To ensure that the system does not exhaust storage resources due to the infinite accumulation of historical versions during version isolation, the industry knowledge architecture service module also maintains a reference count for each version snapshot in the background. This reference counting mechanism is used to track and record in real time the number of tasks currently being executed associated with each version snapshot. When the system detects that the reference count of a historical version snapshot has dropped to zero, it indicates that all generation tasks dependent on that version have been completed and exited. Only then can the system safely reclaim and release that version snapshot, thus achieving a dynamic balance between isolation mechanisms and resource reclamation.

[0059] Furthermore, when building the network and acquiring underlying data based on the execution version, each agent in the system invokes tools according to the constraints set by the tool mapping layer in the knowledge architecture. During this process, the search space for agent tool invocation is no longer a vast set of all tools, but is converged to a subset of tools corresponding to the current task subgraph, thus significantly improving tool matching efficiency. Before actually initiating an interface call to the backend, the system also performs strict format and semantic validation on the tool's input parameters based on the ontology layer and KPI dictionary layer. If the input parameter structure is found to be inconsistent with the specifications of the current execution version, the system will not initiate an invalid call to the backend, but will directly return validation error information to the agent, allowing the agent to reassemble compliant call input parameters, thereby effectively ensuring the security and accuracy of the underlying data acquisition process.

[0060] Through steps 201 to 202 above, by introducing a version isolation mechanism that locks the execution version at the time of task creation, the global consistency of the chapter template, minimum achievable set definition, and tool mapping rules followed by the long text analysis task throughout the entire execution cycle is effectively guaranteed. This avoids problems such as sudden changes in the underlying multi-layer dependency network structure, logical breakage between completed nodes and nodes to be executed, or failure of tool input parameter verification caused by reading new version parameters midway when the system is undergoing high-frequency business adjustments or hot updates of industry standards. Thus, while ensuring that the intelligent analysis system has flexible iterative expansion capabilities, the anti-interference capability of the task in execution and the final success rate of the workflow are improved.

[0061] Reference Figure 3 Based on a pre-defined industry knowledge architecture, target intent categories, and target entity set, a multi-layer dependency network is constructed, including the following steps 301 to 303.

[0062] Step 301: Based on the target intent category and the entity type in the target entity set, match the preset chapter templates in the industry knowledge architecture to obtain multiple candidate chapters.

[0063] Step 302: Determine the semantic similarity between the description text of each candidate chapter and the judgment instruction.

[0064] Step 303: Select candidate chapters with semantic similarity greater than a preset threshold from multiple candidate chapters as target chapter nodes, and construct a multi-layer dependency network based on the target chapter nodes and the data item layer nodes and tool layer nodes associated with the target chapter nodes.

[0065] Steps 301 to 303 are described in detail below.

[0066] In step 301 of some embodiments, in actual operation, the system performs a first round of precise filtering on the chapter templates in the huge industry knowledge architecture based on the extracted target intent category (e.g., extracting the intent enumeration value as "report generation") and the entity type in the target entity set (e.g., extracting entities containing "land parcel" or "sector") to obtain multiple candidate chapters. This allows for the rapid elimination of obviously irrelevant business chapters with minimal computational overhead, thereby initially defining a candidate chapter set that conforms to the basic characteristics of the current task.

[0067] In step 302 of some embodiments, since users' original input instructions are often vague or colloquial in real business scenarios, relying solely on rule matching can easily lead to omissions or misjudgments. Therefore, the solution of this application extracts the pre-configured descriptive text of each chapter node in each candidate chapter, and uses a relevant semantic analysis model to calculate the semantic similarity score between the descriptive text and the user's original input judgment instruction.

[0068] In step 303 of some embodiments, after obtaining the semantic scores of each candidate chapter, the system compares and verifies them with a system-preset similarity threshold (such as θ_sem). Only candidate chapters with similarity scores exceeding the threshold are ultimately confirmed as target chapter nodes. For example, when a user inputs the instruction "Help me see if this land is worth bidding on," although the literal meaning does not match standard intent words such as "report generation," it will still be correctly retained by the system because its cosine similarity with the description of the relevant evaluation chapter in the semantic vector space is high. After determining all target chapter nodes, the system uses these nodes as the top-level starting point, traverses downwards, and associates the data item layer nodes required to generate these chapters as well as the bottom-level tool layer nodes, thereby trimming and assembling the global industry knowledge architecture into a multi-layer dependency network specific to the current task.

[0069] See Figure 4 This is a hierarchical structure diagram of the investment research industry knowledge architecture provided in the embodiments of this application. For example... Figure 4 As shown, the investment research industry schema adopts a five-layer formal structure from top to bottom. It defines the business logic cognition to the specific underlying execution entity in sequence. Its overall structure can be formally represented as: Schema = {Ontology,ChapterTemplate, KPIDict, ToolMap, AgentCapability}.

[0070] Specifically, at the top of the knowledge architecture (schema) of this investment research industry is the ontology layer. This layer is mainly used to define the core entity types within the investment research business domain, their corresponding characteristic attributes, and the relationships between entities. The entity types defined in the ontology layer include at least land parcels, districts, projects, developers, competitors, customer groups, and industries. For each entity type, the ontology layer defines its own set of attributes. For example, the "land parcel" entity type includes attribute information such as coordinates, area, plot ratio, and land use nature (in practical applications, it may also include the land transfer time, etc.). At the same time, the ontology layer also predefines the logical network relationships between entities, such as defining association rules such as "land parcel belongs to district," "projects compete in districts," and "customer groups commute to districts," thereby establishing the basic business cognitive framework for the entire analysis system.

[0071] Below the ontology layer is the ChapterTemplate layer. This layer primarily defines the macro framework and generation rules for professional investment research reports, specifically including the chapter structure definition, inter-chapter dependencies, and a pre-declaration of the data item set required for each chapter and its corresponding minimum achievable set (M(c)). As an optional implementation scenario, this layer can define a professional investment research report as containing five standard chapters: Land Value Analysis, Market Value Analysis, Customer Situation Analysis, Industry Situation Analysis, and Overall Positioning. In the definition of inter-chapter dependencies, the Overall Positioning chapter can be further defined as having a strong logical dependency on the first four chapters. This means that when the system generates the content of the Overall Positioning chapter, it must reference and rely on the key delivery indicators produced by the first four chapters.

[0072] The chapter template layer is further linked to the KPI dictionary layer (KPIDict) and the tool mapping layer (ToolMap). The KPI dictionary layer is responsible for standardizing the data standards of various quantitative indicators in investment research, specifically defining the standard naming, calculation formulas, and corresponding units and value ranges for each indicator to ensure consistency in statistical standards when multiple agents collaboratively process data. The tool mapping layer is responsible for sinking abstract data items from the business layer to the underlying physical call nodes, defining the many-to-many mapping relationship between data items and backend tools. For example... Figure 4 As shown, the tool mapping layer not only standardizes the basic data mapping, but also defines the primary and backup tools and the fallback chain mechanism in detail. When the primary tool fails to be called due to network or interface abnormalities, the system can call the backup tool in sequence according to the fallback chain specification, which ensures the robustness of the system's data acquisition process.

[0073] At the bottom of the entire architecture is the Agent Capability layer. This layer is primarily used to define the boundaries of responsibilities and corresponding schema subsets that each agent registered in the system must undertake. For example... Figure 4 As shown, the system registers three specific types of agents for investment research: the analysis assistant agent, the report generation agent, and the briefing generation agent. Through the layered constraints and progressive transmission of the above five-layer structure, this application's solution transforms complex vertical industry prior knowledge into a structured network that can be parsed by the system, providing precise navigation and guidance for the collaborative orchestration of multiple agents.

[0074] See Figure 5 , Figure 5 This is a schematic diagram illustrating the structure and flow logic of the multi-layer dependency network of chapters, data items, and tools provided in this application embodiment. After the system (e.g., the report generation agent) receives the assessment task, it constructs a multi-layer dependency network specific to this report task based on the currently locked execution version schema, namely a three-layer directed acyclic graph G=(V, E). Figure 5 As shown, this multi-layered dependency network is clearly divided into chapter layers, data item layers, and tool layers from top to bottom. The topmost layer is the chapter layer node V. C It covers specific business chapters and nodes, from "Land Value Analysis" (c1) to "Overall Analysis and Positioning" (c5). Each chapter-level node not only includes a chapter identifier and name, but also defines the required set of data items and a pre-declared minimum generateable set M(c5). i ), current chapter generation status (e.g., WAITING or GENERATING), timeout threshold T max And core attributes such as chapter weights used for macro-level progress calculations. Furthermore, within the chapter layer, there are also horizontal strong logical dependency edges between chapters (such as...). Figure 5 (The dashed arrow pointing to the preceding chapter is shown in c5). This dependency edge carries a set of key transitive metrics, which indicates that when generating a concluding chapter (such as c5) of a summary nature, key metrics such as the overall score and average transaction price can be directly extracted from the data items already ready in the preceding chapter and written into the shared context, thereby breaking the timing bottleneck that traditionally requires each chapter to wait completely sequentially.

[0075] Located in the middle layer of the network is the data item layer node V. D It contains all the structured data units necessary to generate the corresponding chapter report (such as...). Figure 5(d1 to d8 in the table). Each data item layer node's attribute set records in detail the data item identifier, readiness status (such as PENDING, READY, or NOT_AVAILABLE), primary tool identifier, a list of degraded chains sorted by primary / backup priority, and a readiness timestamp. The chapter layer and the data item layer are connected via "requirement dependency edges," which carry importance weight attributes. For example... Figure 5 As indicated by the symbols on the connecting lines, for necessary data items with a weight of 1 (such as d1 and d2), they strictly belong to the minimum generate set M(c) of the corresponding chapter. i For non-essential data items with a weight of 0 (such as d8), they are excluded from the minimum generateable set as supplementary information. Furthermore, the system performs topology analysis when constructing the graph. Once a data item layer node with an in-degree greater than 1 (i.e., shared data that multiple chapters depend on, such as customer group and population analysis potentially depending on the same underlying indicator) is identified, the system adds it to a global deduplication queue to ensure that the underlying tools are called only once in a single task, and synchronously broadcasts the readiness status change event of this data to all related chapter nodes.

[0076] At the bottom of the network is the tool layer node V_T, which represents various physical call interfaces or data sources in the system backend (as shown by t1 to t6 in the diagram). Each tool layer node records the tool identifier, specific call interface, input parameter schema validation reference, concurrency limit (N), and the response time quantiles of the most recent k calls continuously monitored by the system (e.g., P95), used for subsequent adaptive adjustment of concurrency. The data item layer and the tool layer are connected by a "output dependency edge," which carries the primary / backup priority sequence number attribute. For example... Figure 5 The identifier “produce, priority=0” indicates that the primary tool is currently being called; if the sequence number is greater than 0, the system will call the corresponding backup data tool according to the aforementioned demotion chain list.

[0077] Based on the three-layer directed acyclic graph constructed above, the system can implement fine-grained triggering and deadlock prevention scheduling based on the "minimum achievable set". After static pre-declaration, the minimum achievable set M(c_i) will be dynamically shrunk at runtime: if it is found that all degradation chain tools for a certain data item are invalid and unreachable, the system will decisively remove the data item from M(c_i). iThe system removes and marks data items as unavailable, and injects semantic placeholders into the prompt word template of the large language model. In the actual task flow, when a chapter (e.g., c2) receives a ready event for any associated data item, the system will check in real time whether all core data items in its minimum generateable set M(c2) are ready (or have undergone degradation processing); once the conditions are met, the system will immediately trigger the content generation task for that chapter without waiting for the return of unnecessary data items such as d8.

[0078] To further ensure the robustness of long-form analysis and generation tasks under extreme conditions, this scheduling architecture is also configured with a robust timeout fallback mechanism. Combined with... Figure 5 The T-marked in each chapter node max According to the parameters, when a chapter-level node first enters the waiting state, the system will start an independent chapter-level timer for it; if the waiting time reaches T... max If the threshold is reached and there are still unready data items within its minimum generateable set, the system will no longer wait. Instead, it will directly downgrade the remaining unready data items (forcibly changing them to an unavailable state and injecting semantic placeholders), then update the chapter status to FORCE_TRIGGERED and force the start of content generation. In addition, the scheduling module will globally maintain a task-level watchdog timer T. total Once the global timer expires, the system will force-trigger all chapter nodes that are still blocked and waiting, thereby completely preventing overall scheduling deadlock caused by the failure of the underlying tool's entire network and ensuring that the analysis report can be successfully output in any complex business scenario.

[0079] Through steps 301 to 303 above, by constructing a two-stage hybrid matching mechanism that includes precise rule matching and semantic similarity scoring, the system not only uses rule filtering to ensure the response efficiency and accuracy of basic retrieval, but also effectively compensates for the weak generalization ability of traditional single keyword matching through similarity calculation in the semantic space dimension. This improves the system's coverage and fault tolerance for vague wording, non-standard instructions, and expressions containing new entity types, reduces the frequency of manual intervention due to failure of pre-parsing, and enables the constructed multi-layer dependency network to more accurately meet the user's real business needs.

[0080] In one example, upon receiving an analysis command from a user via the front-end interaction module, the multi-agent orchestration module first performs feature extraction and parsing on the command. Specifically, the system categorizes the user command into intent categories to obtain the corresponding target intent categories (e.g., intent category enumeration values ​​could include analysis question answering, report generation, and briefing generation). This intent classification process can be implemented using a lightweight classifier or a large language model. Simultaneously, the system extracts entities from the user command based on a preset ontology layer, thereby obtaining a target entity set containing specific entity types. For example, if the user command is "Analyze the investment value of plot B in sector A," the system can extract an entity set containing "sector: A" and "plot: B."

[0081] After obtaining the target intent category and target entity set, the system employs a two-stage matching strategy to match and construct the multi-layered dependency network (i.e., schema subgraph) required for the current task from the chapter template layer of the industry knowledge architecture. The first stage is the rule matching stage: the system uses the extracted intent category enumeration values ​​and entity types in the entity set as precise filtering conditions to perform preliminary screening of the chapter template layer, filtering out chapter nodes that match the current task type and the involved entity types, thus obtaining a candidate chapter set. The precise rule matching in this stage has low computational overhead, can quickly complete the filtering, and cover the vast majority of instructions using standard wording.

[0082] The second stage is the semantic scoring stage: To address scenarios with ambiguous intents or non-standard expressions that are difficult to cover with precise rules, the system further calculates the semantic similarity (e.g., by calculating cosine similarity) between the preset descriptive text of each candidate chapter and the original user instruction, based on the candidate chapter set retained from the first stage. Subsequently, the system selects candidate chapters with semantic similarity scores exceeding a preset threshold as target chapter nodes, and combines these target chapter nodes with their associated data item layer nodes and tool layer nodes to form a multi-layer dependency network. For example, when a user inputs a colloquial instruction like "Help me see if this land is worth investing in," although it differs literally from standard intent words like "report generation," it can still be accurately included in the network through semantic vector space similarity calculation.

[0083] Furthermore, to improve system response efficiency and ensure version isolation, the results of the two-stage matching are cached using a combination of intent category and entity set as the key, and this cache is bound to the execution version of the current task. Once the industry knowledge architecture version is updated, the corresponding cache will automatically become invalid, thereby preventing the system from using the old version of network logic to build new tasks.

[0084] Finally, based on the chapters, data items, and tool requirements determined in the multi-layered dependency network constructed through the above matching, the system queries the Agent capability layer in the architecture for the pre-declared capabilities of each agent, and then assigns specific task nodes to the matched agents, generating an agent collaboration graph. During the allocation process, if multiple candidate agents can undertake the same node task, the system will comprehensively evaluate the agent's expertise, current system load, and historical execution success rate, and select the optimal executing agent according to the preset priority, thereby ensuring smooth and efficient task distribution and collaboration.

[0085] Step 103: When it is determined that all data item layer nodes in the minimum generateable set corresponding to the chapter layer node are in the ready state, generate the chapter content corresponding to the chapter layer node, and generate structured paragraph tags in the chapter content based on the data item identifiers of the data item layer nodes in the minimum generateable set.

[0086] Step 103 will be described in detail below.

[0087] In step 103 of some embodiments, the system continuously monitors the status of each node in the aforementioned multi-layered dependency network. When it is found that all core data items within the minimum generateable set upon which a chapter-level node depends have been successfully invoked and are in a ready state, the scheduling module no longer waits for other irrelevant data but immediately triggers the content generation task for that chapter. When invoking the large language model for generation, the system forces the model to embed structured paragraph tags at the corresponding logical paragraphs of the output text based on the data item identifiers. In this way, each generated paragraph can be traced back to the specific data source it depends on.

[0088] The minimum generateable set refers to a subset of core data items pre-declared for each chapter in the chapter template layer. For a given chapter, if any data item in this set is missing, the core conclusion of that chapter cannot be established. Non-essential data items refer to the remaining data items included in the set of data items required for a chapter but excluded from the minimum generateable set. These data items exist as supplementary information; their absence only affects the completeness of the chapter content and does not hinder the output of the core conclusion. Structured paragraph tags refer to the specific identifiers that the system must output when generating prompt words, specifying that the large language model must output (including open tags carrying data item dependency declaration attributes and corresponding closed tags). These tags are used to establish a computer-parseable mapping relationship between natural language paragraphs and underlying data items.

[0089] Reference Figure 6 Before generating the chapter content corresponding to the chapter layer node, the method also includes the following steps 601 to 603.

[0090] Step 601: When there are unready data item layer nodes in the minimum generateable set corresponding to the chapter layer node, obtain the time duration. Unready data item layer nodes are data item layer nodes in an unready state.

[0091] Step 602: When the timeout duration reaches the preset timeout duration threshold, and there are still unready data item layer nodes in the minimum achievable set, change the state of the unready data item layer nodes to the unavailable state, and generate semantic placeholders for the unready data item layer nodes.

[0092] Step 603: Based on the data item layer nodes in the ready state within the minimum generateable set and the semantic placeholders, generate the chapter content corresponding to the chapter layer nodes.

[0093] Steps 601 to 603 are described in detail below.

[0094] In step 601 of some embodiments, when the system performs pipeline scheduling based on a multi-layer dependency network, if a chapter-level node attempts to initiate content generation and detects that there are still data item-level nodes in a non-ready state (i.e., WAITING state) in its corresponding minimum generateable set, the chapter will enter a waiting sequence. At this time, in order to prevent the chapter from waiting indefinitely, the scheduling module will immediately start an independent chapter-level timer for the chapter when it first enters the waiting state, and begin acquiring and accumulating the timer duration.

[0095] In step 602 of some embodiments, the scheduling module continuously monitors the aforementioned timing duration over time. When the timing duration reaches a preset timeout threshold (T... max This refers to the maximum tolerable waiting limit set by the system for each business chapter. It limits the maximum time a chapter-level node can spend waiting for data items within its minimum generateable set to become ready. If the system re-verifies and finds that there are still unready data item level nodes within the chapter's minimum generateable set that have failed to return data, the system will stop waiting. At this point, the scheduling module will perform a final degradation operation on these unready data items: at the state machine level, its ready state is changed from waiting to unavailable (i.e., NOT_AVAILABLE, signifying that the data acquisition process has been completely abandoned); at the content level, corresponding semantic placeholders are generated for these missing data items to logically sever the chapter's hard dependency on these abnormal data.

[0096] Among them, semantic placeholders refer to a specific control text (e.g., "[Note: {data item name} data is temporarily unavailable, the following content is a qualitative description]") that the system forcibly injects into the content generation prompt word template of the large language model after determining that a certain data item is unavailable. Its function is to guide the large language model to automatically adjust the corresponding chapter description to qualitative analysis when quantitative data is missing, rather than blindly guessing.

[0097] In step 603 of some embodiments, after completing the aforementioned state change and placeholder injection, the generation state of the chapter layer node is forcibly updated to timeout trigger (FORCE_TRIGGERED) by the system. Subsequently, the system provides the data snapshots corresponding to the data item layer nodes already in the ready state within the minimum generateable set, along with the generated semantic placeholder set, as context input to the large language model, and immediately starts the content generation task for that chapter. Guided by the semantic placeholders, the large language model performs quantitative analysis based on existing real data and naturally switches to qualitative descriptions when encountering missing data, thereby successfully completing the writing task of this chapter.

[0098] Through steps 601 to 603 above, by introducing a timeout mechanism and degradation strategy based on chapter-level timers, the overall scheduling deadlock caused by external network fluctuations or tool-wide crashes is avoided. Under extreme abnormal conditions, this mechanism can promptly block meaningless waiting and force the process to advance by injecting semantic placeholders. This ensures that complex report generation tasks can always produce results within a controllable and limited time. It also uses the instruction-following capability of large models to guide qualitative descriptions, effectively suppressing model illusions caused by missing core data and ensuring the rigor and objectivity of the final judgment text.

[0099] In the entire process of generating chapter content, in order to improve the efficiency of multi-source heterogeneous data flow and the stability of the large language model generation process, the system scheduling module also coordinates and executes a variety of scheduling optimization mechanisms.

[0100] First, to address the potential asynchronous or delayed arrival of non-essential data items during acquisition, the system introduces a patch injection mechanism for late-arriving data items. Specifically, when the large language model initiates the content generation task, the scheduling module pre-embeds strict paragraph tag specifications in the system prompts. This requires the model to define the boundaries of each logical paragraph using open tags with specific attributes (e.g., tags carrying chapter numbers, paragraph numbers, and identifiers of dependent data items) and closed tags. After the large language model completes the initial generation of the chapter content, the system's internal paragraph tag parsing unit iterates through and parses all output tags, extracting the identifier attributes from each tag. Within the current task context, it constructs a forward mapping table from data item identifiers to the corresponding paragraph identifier set, and a reverse mapping table from paragraph identifiers to the original paragraph content.

[0101] Based on the mapping table constructed above, the patch injection mechanism can adaptively adopt two update modes depending on when the data arrives. If a non-essential data item is ready while the corresponding chapter is still in the content generation execution phase (i.e., in the GENERATING state), the system adopts the in-generation injection mode, encapsulating the new data into an incremental context fragment according to a preset format and directly appending it to the current streaming inference session through the underlying interface. This allows the large model to naturally integrate the data in the generation of subsequent paragraphs without interrupting the entire inference process. If the data item is only ready after the chapter content generation task has been completed, the system adopts the partial rewrite mode. That is, it uses the aforementioned forward mapping table to locate the set of affected paragraph identifiers and accurately extracts the original content of the affected paragraphs from the reverse mapping table accordingly. Subsequently, the system encapsulates the extracted original content, the new data item, and the partial rewrite prompts into a lightweight revision task and sends it to the model. Compared to traditional full-chapter rewriting, this partial rewriting method not only significantly reduces the context size and inference computational power consumption of a single input to a large model, but also effectively avoids the repeated generation of unaffected paragraphs, maintaining the consistency of the logic in long texts.

[0102] Secondly, to overcome the time bottleneck that requires all preceding chapters to be generated before a summary chapter can be started, the scheduling module implemented an early binding optimization mechanism for the final chapter. For final chapter nodes with strong logical dependencies (i.e., dependent on the analysis results of preceding chapters), the scheduling module no longer mechanically waits for the large model text generation of preceding chapters to finish. Once the data items in the minimum generateable set of the preceding chapters reach a ready state, the system directly extracts key transmission indicators such as comprehensive scores, price ranges, and customer group tags from these ready underlying data and writes them into the shared context of the final chapter node in advance. With this early binding mechanism, the final chapter node can start the content generation task of the large language model in parallel with the preceding chapters, effectively improving the overall concurrent writing efficiency of complex analysis reports.

[0103] Furthermore, to address potential failures, timeouts, or exceptions in the actual invocation of underlying tool interfaces, the system employs a multi-level degradation mechanism to ensure a smooth generation process. When an exception occurs, the system strictly retryes the process step-by-step according to the pre-configured degradation chain for each data item node: First, it attempts a first-level degradation, invoking an alternative tool of the same dimension (e.g., downgrading the real-time data interface to a monthly statistics interface); if this also fails, it proceeds to a second-level degradation, invoking historical snapshot data with timestamps; if all alternative solutions are exhausted, the system performs a final degradation, marking the data item as unavailable at the physical level and injecting semantic placeholders at the prompt level, guiding the large language model to automatically adjust the corresponding quantitative description to qualitative analysis. After the final degradation process, the data item is logically considered ready, thus satisfying the minimum achievable set condition and ensuring that no degradation operation at any level causes blockage or waiting in the overall scheduling chain.

[0104] Furthermore, to ensure both data acquisition efficiency and the stability of the underlying data source, the scheduling module implements an adaptive concurrency adjustment mechanism. The system continuously monitors and records the response time quantiles (such as P50 and P95) of each tool-layer node in the most recent calls. When the P95 latency of a tool node exceeds a preset warning threshold, the system automatically lowers the concurrency call limit for that tool; conversely, if the response latency remains below the threshold, the system gradually increases the concurrency limit. In conjunction with this dynamic scheduling process, the system also calculates and updates the session-level normalized progress value in real time for front-end presentation, using chapters as the basic granularity and based on the weights assigned to each chapter according to the target word count. Simultaneously, the scheduling module intercepts repeatedly triggered execution requests at the same time and directly returns the current progress snapshot based on the idempotent key composed of the session identifier and the hash value of the analysis parameters, thereby ensuring the idempotency of task scheduling and the orderly allocation of resources in high-concurrency scenarios.

[0105] Reference Figure 7 This is a schematic diagram of the chapter content generation and patch injection process based on data-ready event-driven methods provided in an embodiment of this application. For example... Figure 7 As shown, the entire scheduling process begins when the system receives a ready event for a certain underlying data item. After receiving this event, the scheduling module first determines, for the associated specific chapter layer node (c_i), whether all core data items in its corresponding minimum achievable set (M ci) are in a ready state.

[0106] When all data items within the minimum generateable set are determined to be ready, the system further checks the current state (ci state) of the chapter. If the chapter is already in the generating or completed state, the system returns directly without repeating the process; if the chapter is in the waiting state, the system formally triggers the generation task for that chapter. Upon triggering generation, the system generates a data snapshot (snapshot R_ci) for the currently ready data items, and then uses this snapshot as context input to start the content generation task of the Large Language Model (LLM). During this generation process, the system attaches specific paragraph tagging specifications to the LLM, requiring it to carry structured paragraph tags when outputting natural language text. After the chapter content is completely generated, the system updates the chapter's state to completed.

[0107] On the other hand, when it is determined that there are still unready data items within the minimum generateable set, the system will enter a timeout determination branch to check whether the chapter-level timer started for that chapter has reached the preset timeout duration threshold (T_max). If it has not timed out, the chapter continues to wait; if it has reached the timeout duration threshold, in order to prevent the scheduling flow from getting blocked, the system will activate a deadlock prevention fallback mechanism. At this time, the system will perform final degradation processing on the remaining unready data items in the minimum generateable set and inject the corresponding semantic placeholders into the large model. After completing the above degradation preparation, the system will forcibly change the state of the chapter to forced timeout trigger (FORCE_TRIGGERED) and then merge it into the main process to forcibly trigger subsequent chapter generation tasks.

[0108] like Figure 7 As shown in the lower left corner, the patch injection process for non-essential data items (i.e., supplementary data items that belong to the required data set R of a chapter but not to the minimum generateable set M) is illustrated when they arrive asynchronously. When such non-essential data items are acquired and ready only after the main generation process has started, the system triggers a patch injection check to see if the text generation of the current target chapter has finished. If the chapter text is still being generated (i.e., not yet finished), the system uses Mode 1, adding the ready non-essential data as incremental context directly to the current streaming inference session, allowing the large model to naturally integrate into subsequent writing; if the chapter text has finished generating, the system uses Mode 2, precisely locating the target paragraph affected by the arriving data item by querying a pre-built mapping table, and extracting the original text to trigger a local rewriting.

[0109] also, Figure 7The lower right corner also shows the global watchdog mechanism, which serves as the bottom line for system security. Independent of the scheduling logic within each chapter, the system maintains a watchdog timer for the global task. When the entire task's turnaround time reaches the preset global timeout threshold (T_total), the system will directly execute a forced trigger operation on all chapter nodes that are still in the waiting state, thereby ensuring that the system can still reliably output the final judgment result even in extreme call anomalies.

[0110] Step 104: When it is determined that the non-essential data item layer node is in a ready state after the corresponding chapter content is generated, based on the structured paragraph tags, the target paragraph associated with the non-essential data item layer node in the chapter content is locally rewritten and updated. The non-essential data item layer node is the data item layer node that does not belong to the minimum generateable set.

[0111] Step 104 will be described in detail below.

[0112] In step 104 of some embodiments, if a supplementary non-essential data item is called and becomes ready only after the main content of the chapter (i.e., the non-essential data item layer node in the corresponding chapter content) has been generated, the system will trigger a lightweight local patch injection process to parse the previously generated structured paragraph tags and build a mapping table between data item identifiers and text paragraphs. Then, based on this mapping table, the system can locate the target paragraph affected by this later data. Subsequently, the system extracts the original text of the target paragraph, combines it with the newly arrived data content to trigger a local rewrite generation task, and then replaces the rewritten content back into the original chapter, as described below.

[0113] Reference Figure 8 Based on structured paragraph tags, the target paragraphs associated with non-essential data item layer nodes in the chapter content are partially rewritten and updated, including the following steps 801 to 804.

[0114] Step 801: Based on all structured paragraph tags in the chapter content, determine the forward mapping relationship from data item identifier to paragraph identifier, and the reverse mapping relationship from paragraph identifier to paragraph content.

[0115] Step 802: Based on the forward mapping relationship, determine the target paragraph identifier corresponding to the data item identifier of the non-essential data item layer node.

[0116] Step 803: Based on the reverse mapping relationship, determine the target paragraph content corresponding to the target paragraph identifier.

[0117] Step 804: Combine the target paragraph content with the data content of the non-essential data item layer nodes to obtain the partial rewrite prompt information, and rewrite the target paragraph content based on the partial rewrite prompt information to obtain the updated target paragraph content.

[0118] Steps 801 to 804 are described in detail below.

[0119] In step 801 of some embodiments, after the large language model completes the initial content generation of a certain chapter, the system scheduling module will perform post-processing on the generated text. At this time, it traverses all the structured paragraph tags embedded in the text according to the specifications (such as preset tag tags carrying paragraph ID and data dependency ID) in order to extract the correspondence between data items and paragraphs in a structured way by parsing the attribute fields in these tags. In this way, a forward mapping relationship and a reverse mapping relationship are established simultaneously in the background database or memory, so as to transform the originally unstructured and unaddressable long natural language text into a set of structured and independently indexable text blocks.

[0120] Among them, the forward mapping relationship refers to the lookup relationship established in memory by the system after parsing the text generated by the large language model, which is a one-way lookup relationship from the data item identifier to its associated paragraph identifier. Its function is that when a certain underlying data arrives asynchronously, the system can quickly determine which specific paragraph in the article the data should belong to or affect by looking up the table.

[0121] The reverse mapping relationship refers to the search relationship established by the system that points unidirectionally from the paragraph identifier to the corresponding initially generated paragraph content (i.e., the original text snapshot). Its function is to provide an accurate original text index so that when the system needs to perform a rewriting operation, it can accurately "strip" and extract the natural language text of a specific paragraph.

[0122] In step 802 of some embodiments, the response time of multi-source data interfaces often varies in actual business processes. When a non-essential data item layer node (i.e., data not included in the minimum generateable set) that is supplementary in nature obtains the real data and triggers the ready event only after its corresponding chapter content has been generated, the system enters the patch injection process, that is, extracts the data item identifier of the non-essential data item, and performs a matching query based on the constructed positive mapping relationship to determine the target paragraph identifier affected by this delayed data.

[0123] In step 803 of some embodiments, after determining the target paragraph identifier, the system performs a reverse lookup based on the reverse mapping relationship, so as to accurately retrieve the corresponding target paragraph content from the cache by inputting the target paragraph identifier, so as to ensure that the system only extracts the local text that needs to be modified, without touching or interfering with other normal paragraphs in the chapter that do not need to be updated.

[0124] In step 804 of some embodiments, after preparing the relevant materials, the system combines the extracted target paragraph content with the specific data content of the previously prepared non-essential data items, and adds preset revision rules to generate local rewriting prompts for model inference. Subsequently, the system submits these prompts to the underlying large language model, triggering a lightweight local generation task. At this point, based on the prompts, logical rewriting and data supplementation are performed only on the target paragraph content. Finally, the system receives the updated target paragraph content output by the model and performs precise point-to-point replacement of the old paragraphs in the original chapter text, thereby completing the incremental update flow of the entire analysis data.

[0125] Among them, the local rewrite prompt information refers to the set of prompt words (Prompt) that the system encapsulates and splices together according to a predetermined template, including the extracted original text of the target paragraph, newly acquired non-essential data content, and preset rewrite control instructions (such as limiting the model to only supplement data in this paragraph without changing the overall tone) in order to strictly constrain the modification boundary of the large language model.

[0126] Through steps 801 to 804 above, by introducing structured paragraph tags and constructing a positive and negative dual mapping mechanism, the system can accurately extract the affected local text for targeted revision when faced with asynchronous delays or state changes in non-essential business data. This not only reduces the context scale of a single processing by a large language model and saves a lot of inference computing power and response time, but also effectively ensures the stability and consistency of the content of unaffected paragraphs in the report, and improves the overall reliability of the judgment results under complex workflow tasks.

[0127] Step 105: Merge the chapter content corresponding to all updated chapter layer nodes to obtain the target analysis result.

[0128] Step 105 is described in detail below.

[0129] In step 105 of some embodiments, after the system confirms that the generation tasks of all the aforementioned chapter-level nodes have been completed, the updated text content carried by each chapter-level node is sequentially merged and finally a structurally complete target assessment result is output, such as a complete investment research report text, for researchers to study and view.

[0130] In addition, refer to Figure 9 After merging the chapter content corresponding to all updated chapter layer nodes to obtain the target judgment result, the method also includes the following steps 901 to 902.

[0131] Step 901: Generate a structured analysis card based on the multidimensional metadata in the target analysis results. The multidimensional metadata includes a conclusion summary.

[0132] Step 902: Based on the entity identifiers in the target entity set, the geographical range data and timestamp data in the structured judgment cards, and the conclusion summary, construct the geospatial index, time-series index, entity association index, and semantic vector index, and store the structured judgment cards in the judgment memory pool.

[0133] Steps 901 to 902 are described in detail below.

[0134] In step 901 of some embodiments, in relevant business scenarios, lengthy natural language reports (i.e., target assessment results), while easy for end users to read, are difficult to reuse directly by subsequent machine systems. Therefore, after merging all chapter contents, the scheduling module triggers a post-processing data sedimentation process. Specifically, the system parses and extracts information from the generated target assessment results to extract multi-dimensional metadata (e.g., extracting core KPI values, specific land parcels or project entities involved from each chapter); simultaneously, the system calls the briefing generation Agent or lightweight model to logically compress the target assessment results, generating a highly condensed conclusion summary; subsequently, the system encapsulates these structured multi-dimensional metadata, along with the conclusion summary, into a structured assessment card according to a preset object-like format.

[0135] Among them, multidimensional metadata refers to the collection of multidimensional information accumulated by the analysis system during the execution of various chapters and the invocation of underlying tools. The structured analysis card Ψ refers to a standardized data carrier that is further refined and encapsulated after the system completes the generation of a single long text analysis report. This card is a comprehensive data object containing multiple structured fields such as a unique card identifier, geographic coordinates (Geo), timestamp (Time), analysis dimension (Dim), quantitative indicators (KPI), related entities (ENT), and text summary (Summary).

[0136] See Figure 10 , Figure 10 This is a schematic diagram of the data structure and class diagram entity associations of the structured analysis card provided in this application embodiment. After the content generation tasks of the large language model in each chapter are completed, the scheduling module will not only merge the generation results of each independent chapter into a complete natural language investment research report text in sequence, but also, in order to facilitate subsequent machine readability and long-term memory reuse, the system will also encapsulate and extract the core output data of this analysis according to the preset schema architecture specification, as shown below. Figure 10 The structured analysis card Ψ is shown.

[0137] This structured analysis card is defined as an aggregated data carrier encompassing multi-dimensional attributes, formally represented as: Ψ = {id, geo, time, dim, KPI, ENT, summary, snapshot, conf}. In the class diagram, the Card class serves as the anchor point of the overall structure, maintaining several basic attribute fields, including a unique card identifier (id) for global retrieval, an analysis output timestamp (time) recording the accurate moment the report was generated, and a summary text of the conclusion extracted and compressed by the model. This summary text provides a direct material basis for subsequent semantic retrieval.

[0138] The structured analysis card is linked to multiple detailed business and spatial entity objects. Specifically, the geo field points to the Geo class, whose internal attributes finely define longitude, latitude, block ID, and grid ID, allowing for flexible expression of geographic ranges at three different granularities: point, grid, and polygon during actual spatial retrieval. The dim field points to the Dim class, which defines the core business perspective of this analysis, and its optional enumeration items explicitly cover land, market, customer, industry, and overall positioning. The ENT field maps to the associated entity set class, which records the target entities involved in this analysis (including entity ID, entity type, and entity name), and the specific type range of the entity is subject to prior constraints from the underlying ontology layer of the system.

[0139] Furthermore, to ensure the data rigor, traceability, and objectivity of the judgment process, the card also integrates quantitative indicators and status monitoring entities. Specifically, the KPI field is associated with a quantitative indicator class, used to structurally store all core indicator key-value pairs (including indicator name key, specific value value, and unit of measurement) generated from this judgment. The standard naming and unit definitions of these indicators are uniformly validated and constrained by the system's KPI dictionary layer. The snapshot field is associated with a data snapshot class, recording the snapshot reference, data source, and timestamp, serving as a tracking credential of the underlying raw data used in the judgment. The conf field corresponds to a confidence label class, where the system automatically calculates and assigns a quantitative confidence score to the judgment result based on the data completeness during the task scheduling process and whether tool degrades have been triggered.

[0140] After the structured analysis card is packaged and packaged, the system also triggers a persistent storage process. The card will be synchronously written into the system's underlying dual-layer memory architecture, which includes a short-lived session-level memory pool and a long-term user-level memory pool. The persistence duration of the card can be flexibly adjusted by the system administrator according to the storage resource configuration.

[0141] In step 902 of some embodiments, to ensure that the generated structured analysis cards can be accurately recalled from massive amounts of historical data, this application establishes a four-dimensional indexing system for the cards. Specifically, before storing them in the underlying database, the system performs the following index building actions: based on the geographical range data (such as latitude and longitude coordinates, and plate grid identifiers) carried within the card, a geospatial index is built so that spatial retrieval can be performed based on spatial overlap; based on the timestamp data when the card was generated, a time-series index is built to apply time-attenuation weights during subsequent retrieval; based on the entity identifiers (such as the IDs of specific developers or specific competitor projects) in the current task target entity set, an entity association index is built to support graph-based entity intersection (jaccard) retrieval; then, the system inputs the extracted conclusion summary text into a vectorized embedding model for encoding to generate high-dimensional semantic vectors, thereby constructing a semantic vector index to support semantic cosine retrieval across representation forms.

[0142] Specifically, to achieve efficient retrieval and persistent management of structured analysis cards, the analysis memory service module in the system constructs a multi-dimensional underlying index system for the generated and encapsulated structured analysis cards ψ. Specifically, this module builds four types of index structures around the core metadata fields of the cards, including geospatial, temporal, entity association, and semantic vectors.

[0143] First, the analysis and memory service module constructs a geospatial index. This index uses the specific geographic coordinates and the corresponding tile or raster identifier contained in the spatial field (i.e., the ψ.geo field) of the structured analysis card as the index key. By establishing this spatial dimension mapping relationship, the system can support the rapid and accurate retrieval of relevant historical analysis records according to specific physical locations or spatial ranges in subsequent cross-session tasks. Second, for the time dimension, this module constructs a time-series index using the timestamp field (i.e., the ψ.time field) of card generation or archiving as the index key. Relying on this time-series index, the system can not only support the orderly display of analysis cards in the front-end application page according to time sequence, but also efficiently respond to data filtering and backtracking requests based on specific business time windows.

[0144] Furthermore, to support tracing and knowledge graph-based queries based on specific business entities, the analysis and memory service module constructs an entity association index. In practice, the system iterates through and extracts each entity identifier from the set of associated entities within a card (i.e., the ψ.ENT field), and uses this to build an inverted index structure pointing from "entity identifier" to "card identifier." Based on this inverted index, when a user or agent queries a specific developer or target competitor, the system can instantly locate all historical cards containing that entity. Simultaneously, to overcome the limitations of traditional literal keyword matching, the module also constructs a semantic vector index. The system calls relevant embedding models to perform vectorized embedding processing on the conclusion summary field (i.e., the ψ.summary field) in the card, converting it into a high-dimensional embedding vector, and constructs an underlying semantic vector index based on these embedding vectors, thereby supporting deep semantic retrieval across different representation forms.

[0145] Understandably, at the specific engineering implementation level, the underlying storage and retrieval engines for the four types of indexes can be appropriately selected based on the actual system architecture and data scale. For example, geospatial indexes, time-series indexes, entity association indexes, and semantic vector indexes can be implemented using specific technical means such as spatial databases, time-series databases, inverted index engines, and specialized vector databases, respectively.

[0146] After the four-dimensional index is constructed and bound, the system persistently writes the structured judgment card and index data into the judgment memory pool. The judgment memory pool is the underlying persistent storage medium or knowledge base built by the system to achieve long-term memory across sessions. It is used to store all structured judgment cards and their related index information for the long term, so that subsequent agents can recall and refer to historical context when processing new tasks.

[0147] Through steps 901 to 902 above, the analysis results are reduced in dimensionality, refined, and encapsulated into structured analysis cards. A four-dimensional index system covering space, time, entity, and semantics is also established. This enables the system to transform each analysis result into a reusable digital asset and store it in the analysis memory pool. This provides a solid data foundation for efficient retrieval and context injection when handling cross-session related tasks. While avoiding repeated calls to the underlying interface to save computing power, it also improves the logical continuity and stability of the analysis perspective in long-term, multi-round business interactions.

[0148] In addition, refer to Figure 11 The data generation method for analysis also includes the following steps 1101 to 1105.

[0149] Step 1101: Obtain cross-session analysis instructions, and retrieve candidate structured analysis cards from the analysis memory pool based on geospatial index, temporal index, entity association index, and semantic vector index.

[0150] Step 1102: Determine the entity matching degree, geographical overlap degree, and semantic similarity between the cross-session assessment instruction and each candidate structured assessment card.

[0151] Step 1103: Determine the time difference between the current time and the timestamp data of each candidate structured judgment card, multiply the time difference by the preset time decay coefficient, and perform exponential operation to obtain the time decay weight.

[0152] Step 1104: Based on the preset first weight, second weight and third weight, the entity matching degree, geographical overlap degree and semantic similarity are weighted and summed, and multiplied by the time decay weight to obtain the composite score.

[0153] Step 1105: Determine the target judgment card from multiple candidate structured judgment cards based on the composite score, and add the conclusion summary of the target judgment card to the current session context.

[0154] Steps 1101 to 1105 are described in detail below.

[0155] In step 1101 of some embodiments, when the system receives a cross-session assessment instruction with coherent business intent, it also initiates a retrieval from the underlying storage pool to collaboratively utilize the previously built four-dimensional index engine (i.e., geospatial index, time-series index, entity association index, and semantic vector index) to perform preliminary coarse screening from the assessment memory pool, and retrieve a batch of structured assessment cards that have potential intersections with the current instruction in terms of location, time, entity, or semantics, as candidate structured assessment cards for subsequent scoring.

[0156] In step 1102 of some embodiments, after obtaining the set of candidate structured analysis cards, the system begins to calculate the multidimensional matching degree between the current cross-session analysis instruction and each candidate card. Specifically, the system calculates sub-scores for three independent dimensions: entity matching degree (e.g., calculating the Jaccard intersection of the entity set extracted by the current instruction and the historical entity set of the card); geographic overlap (e.g., calculating the spatial overlap ratio between the analysis grid involved in the current instruction and the historical coordinate system of the card); and semantic similarity (by extracting the semantic features of the current instruction, calculating its cosine similarity distance with the candidate card summary text in the vector space).

[0157] In step 1103 of some embodiments, the system further extracts the timestamp data that comes with the candidate card when it is packaged, and calculates the time difference between it and the current time. Then, the system multiplies the time difference with a preset time decay coefficient and uses the product result as an exponent for exponential operation (similar to the decay function calculation) to obtain a time decay weight between 0 and 1, so that the weight of newly generated cards is close to 1, while the weight of older cards gradually approaches 0.

[0158] In step 1104 of some embodiments, different attention weights (i.e., first weight, second weight, and third weight, which can be flexibly adjusted according to the focus of specific business scenarios) are pre-configured for the three dimensions of entity, space, and semantics. Then, the obtained entity matching degree, geographical overlap degree, and semantic similarity are multiplied by the corresponding preset weights and weighted summation is performed. Finally, they are multiplied by the step timeliness decay weight to obtain a composite score that takes into account both multidimensional relevance and timeliness.

[0159] In step 1105 of some embodiments, after the composite scores of all candidate cards have been calculated, the system will sort them in descending order according to their scores, and extract one or more (Top-K) structured judgment cards with the highest scores as target judgment cards. The system will also extract highly condensed conclusion summary fields from these target judgment cards and inject them as prior knowledge into the system prompts or conversation context of the current large language model (such as the Agent currently performing the task).

[0160] Reference Figure 12 This is a schematic diagram of the cross-session analysis card recall and context injection process provided in the embodiments of this application. Figure 12 As shown, in multi-round business interaction scenarios, when the system receives a cross-session analysis command input by the user, the scheduling module first initiates the pre-process feature extraction and parsing. Specifically, the system extracts entities from the current analysis command to obtain a set of entities (E_q) containing specific business objects, extracts the geographical range to clarify the spatial region involved in the command (G_q), and calls the relevant embedding model to perform vectorized embedding processing on the command, thereby obtaining a high-dimensional command vector (v_q).

[0161] After completing the basic feature extraction, the system uses these features as search criteria to perform preliminary screening of candidate cards from the underlying persistent analysis memory pool. To balance recall and computational efficiency, the preliminary screening criteria can be set as follows: the entity set recorded in the historical analysis cards intersects with the entity set E_q extracted by the current instruction, or the geographical range associated with the historical cards overlaps physically with the geographical range G_q involved in the current instruction. Structured analysis cards that meet either of these conditions will be extracted as candidate cards for subsequent fine-grained ranking and scoring.

[0162] After entering the composite scoring calculation stage, the system will perform multi-dimensional, fine-grained component calculations on each selected candidate card ψ. For example... Figure 12 As shown in the calculation module in the middle section, the system calculates the intersection degree at the entity level (s_ent = jaccard(ψ.ENT, E_q), the geographical overlap degree based on the spatial overlap ratio (s_geo = spatialOverlap(ψ.geo, G_q), and the semantic similarity (s_sem = cosine(ψ.summary_vec, v_q)) obtained by calculating the cosine distance between the card summary vector and the current instruction vector. In addition, the system introduces a timeliness decay weight (w_t = exp(-λ_d ·(now - ψ.time)) to reflect the freshness of the data. In this process, the timeliness decay coefficient λ is configured differently based on the business characteristics of different judgment dimensions; for example, for frequently updated market transaction data, the corresponding λ is set relatively large to accelerate decay, while for relatively slow-changing industry structure data, a smaller decay coefficient is set.

[0163] Finally, the system fuses the multidimensional matching degree calculated above with the timeliness weight to obtain the final composite score. The specific scoring logic is as follows: using preset fusion weight coefficients (such as α, β, and γ, with a sum of 1, α+β+γ=1), the entity matching degree, geographical overlap, and semantic similarity are weighted and summed respectively. Then, the summation result is multiplied by the timeliness decay weight w_t to obtain the composite score score(ψ) = (α·s_ent + β·s_geo + γ·s_sem) · w_t. After obtaining the composite scores of all candidate cards, the system sorts them in descending order of score and extracts the top K (Top-K) candidate cards. The system extracts the conclusion summary (summary field) text from these Top-K cards and compresses it into a priori context fragment according to a preset template, then directly injects it into the system prompt words of the current agent. Through this recall and injection process, the Agent currently executing the task can accurately inherit and maintain the continuity of cross-session analysis logic without relying on reading massive and redundant complete historical dialogue records.

[0164] To more clearly illustrate the specific execution logic of the presentation arrangement method based on multi-card relationship recognition in this embodiment, the above process will be described in an exemplary manner with a specific investment research business application scenario.

[0165] Suppose that investment researchers actively selected three structured analysis cards (p=3) in the historical card list of the front-end system and triggered the "Generate Briefing" command. These three cards are: Card A (analysis dimension: "Market", associated entity: "Land Parcel A", generation time: "today"), Card B (analysis dimension: "Market", associated entity: "Land Parcel B", generation time: "yesterday"), and Card C (analysis dimension: "Market", associated entity: "Land Parcel C", generation time: "six months ago"). During step T1, the system first identifies the relationship between these three cards. Since the intersection of the analysis dimensions of cards A, B, and C is not empty (all are "Market"), and the intersection of their associated entities is empty (they are different objects, Land Parcel A, B, and C respectively), the system will accurately identify the current card set relationship type as "horizontal comparison type" according to preset rules, determining that its business intent is to conduct a horizontal comparison of the advantages and disadvantages of different objects under the same business dimension.

[0166] Subsequently, the system enters the briefing template matching stage in step T2. Based on the identified "horizontal comparison" relationship, the system accurately retrieves the corresponding briefing skeleton from the underlying briefing template library. This briefing skeleton predefines the chapter order and transition logic suitable for horizontal comparison business, such as setting a list of essential structural elements such as "Overview of the Overall Market Environment," "Comparative Analysis of Core Competitor Data," and "Final Investment Priority Recommendations," thereby defining clear text boundaries for the subsequent generation of the large language model.

[0167] Before submitting the generation task to the large language model, the system performs rigorous time-sensitive weighting and confidence pass-through calculations in step T3. The system calculates the citation weights for cards A, B, and C using a preset formula. Since cards A and B were generated relatively recently and have normal initial confidence levels, their calculated citation weights are both greater than the preset threshold. However, for card C, since its generation time is now half a year ago, the time difference (Δt) is large. After exponential decay calculation, its final citation weight decays to below the preset threshold. Based on this, the system determines that the timeliness of card C's data is insufficient to support the current objective comparison decision, so it is automatically removed from the main conclusion generation corpus of the briefing. At the same time, the system downgrades card C, listing it as historical reference data in the appendix of the briefing, and automatically generates a prompt message such as "Note: The data of plot C is more than 180 days old and is for historical trend reference only."

[0168] Finally, in step T4, the system sends the previously retrieved "horizontal comparison" report skeleton, along with the structured data of cards A and B retained after time-weighted filtering, into the large language model. Under the constraints of the report skeleton, the large language model performs a comparative analysis of the market performance of plot A and plot B, generating a logically coherent and well-structured report text. Through this process, the system not only automates the integration of multiple scattered analysis cards but also effectively avoids the interference of outdated historical data on the final analysis conclusions, improving the reliability and professionalism of the report output.

[0169] Through steps 1101 to 1105 above, by establishing a composite scoring and recall mechanism that integrates entity, geographic, semantic, and temporal decay, highly relevant historical analysis conclusions can be accurately identified and retrieved. At the same time, exponential time decay weights are used to automatically filter out outdated interference information, ensuring the timeliness of the introduced data. Furthermore, by injecting only the compressed "conclusion summary" into the current context, the token overhead of system reasoning is greatly reduced while maintaining a high degree of continuity in cross-session analysis logic, thus improving the collaborative workflow efficiency of long-cycle and complex investment research tasks.

[0170] Through steps 101 to 105 above, a multi-layer dependency network is constructed by introducing a pre-defined industry knowledge architecture, which forms clear prior constraints on the divergent behavior of the large model, effectively reducing the error rate of tool calls and ensuring a high degree of matching between the collected data and real business needs. At the same time, by using the minimum achievable set determination mechanism, immediate triggering is achieved when key data is complete, avoiding redundant waiting time in the traditional serial mode and shortening the total generation time. Furthermore, a precise mapping between the underlying data and natural language text is established using structured paragraph tags, enabling the system to perform precise paragraph-level local rewriting updates when processing unnecessary data that arrives later. This avoids the waste of inference computing power caused by full rewriting and maintains the stability of unaffected paragraph content, thereby significantly improving the reliability of the generated results and the consistency of text logic in complex business scenarios.

[0171] In one embodiment, the technical process of the data generation method for analysis provided in this application specifically includes: Step S1: After the system receives a user instruction, it first triggers the pre-feature analysis and basic preparation process. The industry schema service module preloads a five-layer schema architecture for investment research, including the ontology layer and chapter template layer, as the business prior knowledge base for the entire system. Based on this, the system enters the Agent collaboration graph generation stage in Step S2. The system sequentially performs intent classification and entity extraction operations on the original user instruction, and adopts a two-stage matching strategy combining rule matching and semantic scoring to accurately map the abstract user intent into a schema subgraph limited by industry knowledge, thereby constructing an Agent collaboration graph that guides the division of labor and cooperation of specific intelligent agents.

[0172] Following the network construction steps described above, the workflow transitions to step S3, the version isolation and tool call constraint stage. To ensure the logical continuity of the long text analysis task throughout the entire execution cycle, the system implements a version isolation mechanism at this point, firmly locking the currently acquired schema execution version snapshot into the context of this task. Under this strict version locking specification, the system establishes constraints on the tool search space of the underlying data interface, ensuring that all subsequent tool calls are legitimate calls subject to schema security constraints, effectively resisting potential interference from hot architecture updates during concurrent execution.

[0173] After completing the basic framework setup and environment locking, the system enters the core area of ​​multi-layer dependency network modeling and generation scheduling shown in step S4. The system instantiates and constructs a multi-layer dependency network, where chapter-level nodes carry key attributes such as the current generation status, timeout threshold (T_max), and weights; data item-level nodes record the data readiness status and corresponding retry / degradation chains in detail. Based on this dependency network, the system scheduling module continuously monitors and determines whether the minimum generateable set (M_ci) of each chapter is ready. If the condition is met, the system immediately triggers the Large Language Model (LLM) to start the content generation task and attaches strict paragraph label specification instructions; if the condition is not met and the chapter-level waiting time has reached the set timeout threshold T_max, the system will decisively execute a forced ultimate degradation strategy, forcibly triggering the generation of chapter content, thereby completely eliminating the possibility of system deadlock under complex network calls.

[0174] Under the overall coordination of the minimum achievable set management unit, the system implements various optimization mechanisms, including statically pre-declared dependency filtering, paragraph tag parsing and patch injection for asynchronous data, early binding of the final chapter to break through serial timing bottlenecks, and multi-level degradation and adaptive underlying concurrency to handle interface anomalies. After all chapter generation tasks are completed, the system, through step S6, encapsulates the multi-dimensional key information generated in this analysis into standardized structured analysis cards according to a preset format, thus completing the assetization and accumulation of the analysis results.

[0175] Subsequently, in step S7, the system extracts and constructs geospatial indexes, temporal indexes, entity association indexes, and semantic vector indexes for the newly generated structured analysis cards, building a robust four-dimensional constraint system and storing it in the memory pool. Based on this, in step S8, when the system encounters a new business instruction, it initiates a cross-session context recall process. Through rigorous composite scoring logic, the system accurately retrieves the Top-K historical analysis cards with the highest scores and injects the prior knowledge, such as the conclusion summaries contained within, into the prompts of the currently executing agent with minimal computational overhead. Through this rigorous, closed-loop, and highly parallel processing flow, the system ultimately outputs high-quality investment research reports or briefings to the front end.

[0176] This application also provides an analysis data generation device that can implement the above-described analysis data generation method, referring to... Figure 13 The device 1300 includes: The instruction acquisition module 1310 is used to acquire and analyze instructions, extract features from the analysis instructions, and obtain the target intent category and target entity set. The network generation module 1320 is used to construct a multi-layer dependency network based on a preset industry knowledge architecture, target intent category and target entity set. The multi-layer dependency network includes chapter layer nodes, data item layer nodes and tool layer nodes with hierarchical dependency relationships. Among them, the data item layer nodes carry data item identifiers, and the data content of the data item layer nodes is obtained after calling the tool layer nodes associated with the data item layer nodes. The chapter content generation module 1330 is used to generate chapter content corresponding to the chapter layer node when all data item layer nodes in the minimum generateable set corresponding to the chapter layer node are in a ready state, and to generate structured paragraph tags in the chapter content based on the data item identifiers of the data item layer nodes in the minimum generateable set. The content update module 1340 is used to perform local rewrite updates on the target paragraph associated with the non-essential data item layer node in the chapter content based on the structured paragraph tags when it is determined that the non-essential data item layer node is in a ready state after the corresponding chapter content is generated. The non-essential data item layer node is a data item layer node that does not belong to the minimum generateable set. The analysis result generation module 1350 is used to merge the chapter content corresponding to all updated chapter layer nodes to obtain the target analysis result.

[0177] In the above embodiments, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, the specific implementation of the data generation device is basically the same as the specific implementation of the data generation method described above, and will not be repeated here.

[0178] This application also provides an electronic device, including: At least one memory; At least one processor; At least one program; The program is stored in memory, and the processor executes at least one program to implement the data generation method described above. The electronic device can be any smart terminal, including mobile phones, tablets, personal digital assistants (PDAs), and in-vehicle computers.

[0179] Please see Figure 14 , Figure 14 The hardware structure of an electronic device according to another embodiment is illustrated. The electronic device includes: The processor 1401 can be implemented using a general-purpose CPU (Central Processing Unit), microprocessor, application-specific integrated circuit (ASIC), or one or more integrated circuits, and is used to execute relevant programs to implement the technical solutions provided in the embodiments of this application. The memory 1402 can be implemented in the form of ROM (Read-Only Memory), static storage device, dynamic storage device, or RAM (Random Access Memory). The memory 1402 can store the operating system and other applications. When the technical solutions provided in the embodiments of this specification are implemented through software or firmware, the relevant program code is stored in the memory 1402 and is called and executed by the processor 1401 to execute the data generation method of the embodiments of this application. The input / output interface 1403 is used to implement information input and output; The communication interface 1404 is used to enable communication and interaction between this device and other devices. Communication can be achieved through wired means (such as USB, Ethernet cable, etc.) or wireless means (such as mobile network, WIFI, Bluetooth, etc.). Bus 1405 transmits information between various components of the device (e.g., processor 1401, memory 1402, input / output interface 1403, and communication interface 1404); The processor 1401, memory 1402, input / output interface 1403 and communication interface 1404 are connected to each other within the device via bus 1405.

[0180] This application embodiment also provides a storage medium, which is a computer-readable storage medium storing a computer program. When the computer program is executed by a processor, it implements the above-described data generation method for analysis.

[0181] Memory, as a non-transitory computer-readable storage medium, can be used to store non-transitory software programs and non-transitory computer-executable programs. Furthermore, memory may include high-speed random access memory, and may also include non-transitory memory, such as at least one disk storage device, flash memory device, or other non-transitory solid-state storage device. In some embodiments, memory may optionally include memory remotely located relative to the processor, and these remote memories can be connected to the processor via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof.

[0182] The embodiments described in this application are for the purpose of more clearly illustrating the technical solutions of the embodiments of this application, and do not constitute a limitation on the technical solutions provided by the embodiments of this application. As those skilled in the art will know, with the evolution of technology and the emergence of new application scenarios, the technical solutions provided by the embodiments of this application are also applicable to similar technical problems.

[0183] Those skilled in the art will understand that the technical solutions shown in the figures do not constitute a limitation on the embodiments of this application, and may include more or fewer steps than shown, or combine certain steps, or different steps.

[0184] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

[0185] Those skilled in the art will understand that all or some of the steps in the methods disclosed above, as well as the functional modules / units in the systems and devices, can be implemented as software, firmware, hardware, or suitable combinations thereof.

[0186] The terms “first,” “second,” “third,” “fourth,” etc. (if present) in the specification and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms “comprising” and “having,” and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0187] It should be understood that in this application, "at least one (item)" means one or more, and "more than" means two or more. "And / or" is used to describe the relationship between related objects, indicating that three relationships can exist. For example, "A and / or B" can represent three cases: only A exists, only B exists, and both A and B exist simultaneously, where A and B can be singular or plural. The character " / " generally indicates that the preceding and following related objects are in an "or" relationship. "At least one (item) of the following" or similar expressions refer to any combination of these items, including any combination of single or plural items. For example, at least one (item) of a, b, or c can represent: a, b, c, "a and b", "a and c", "b and c", or "a and b and c", where a, b, and c can be single or multiple.

[0188] In the several embodiments provided in this application, it should be understood that the disclosed apparatus and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of the units described above is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. The coupling or direct coupling or communication connection between the shown or discussed units may be through some interfaces, or indirect coupling or communication connection between the apparatus or units, and may be electrical, mechanical, or other forms.

[0189] The units described above as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0190] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0191] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes multiple instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this application. The aforementioned storage medium includes various media capable of storing programs, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0192] The preferred embodiments of the present application have been described above with reference to the accompanying drawings, but this does not limit the scope of the claims of the present application. Any modifications, equivalent substitutions, and improvements made by those skilled in the art without departing from the scope and substance of the embodiments of the present application shall be within the scope of the claims of the present application.

Claims

1. A method for generating analytical data, characterized in that, The method includes: Obtain the analysis command, extract features from the analysis command, and obtain the target intent category and target entity set; Based on the preset industry knowledge architecture, the target intent category and the target entity set, a multi-layer dependency network is constructed. The multi-layer dependency network includes chapter layer nodes, data item layer nodes and tool layer nodes with hierarchical dependency relationships. The data item layer nodes carry data item identifiers, and the data content of the data item layer nodes is obtained after calling the tool layer nodes associated with the data item layer nodes. When it is determined that all data item layer nodes in the minimum generateable set corresponding to the chapter layer node are in a ready state, the chapter content corresponding to the chapter layer node is generated, and structured paragraph tags are generated in the chapter content based on the data item identifier of the data item layer node in the minimum generateable set. When it is determined that the non-essential data item layer node is in a ready state after the corresponding chapter content is generated, the target paragraph associated with the non-essential data item layer node in the chapter content is locally rewritten and updated based on the structured paragraph tag. The non-essential data item layer node is the data item layer node that does not belong to the minimum generateable set. The updated chapter content corresponding to all the chapter-level nodes is merged to obtain the target assessment result.

2. The data generation method for analysis according to claim 1, characterized in that, The construction of a multi-layer dependency network based on the preset industry knowledge architecture, the target intent category, and the target entity set includes: Based on the target intent category and the entity type in the target entity set, the preset chapter templates in the industry knowledge architecture are matched to obtain multiple candidate chapters; Determine the semantic similarity between the descriptive text of each candidate chapter and the judgment instruction; From a plurality of candidate chapters, candidate chapters with semantic similarity greater than a preset threshold are determined as target chapter nodes, and the multi-layer dependency network is constructed based on the target chapter nodes and the data item layer nodes and tool layer nodes associated with the target chapter nodes.

3. The data generation method for analysis according to claim 1, characterized in that, Before constructing the multi-layer dependency network based on the preset industry knowledge architecture, the target intent category, and the target entity set, the method further includes: When obtaining the judgment instruction and establishing the corresponding generation task, the current release version of the industry knowledge architecture is obtained, and the version number of the current release version is used as the execution version to be associated in the context of the generation task; The multi-layered dependency network is constructed based on the execution version, and the data content is obtained.

4. The data generation method for analysis according to claim 1, characterized in that, Before generating the chapter content corresponding to the chapter layer node, the method further includes: When there are unready data item layer nodes in the minimum generateable set corresponding to the chapter layer node, the timing duration is obtained, and the unready data item layer node is the data item layer node in an unready state. When the timeout duration reaches the preset timeout duration threshold, and there are still unread data item layer nodes in the minimum generateable set, the state of the unread data item layer node is changed to an unavailable state, and a semantic placeholder for the unread data item layer node is generated. Based on the data item layer nodes in the ready state within the minimum generateable set and the semantic placeholders, the chapter content corresponding to the chapter layer nodes is generated.

5. The data generation method for analysis according to claim 1, characterized in that, The step of partially rewriting and updating the target paragraphs associated with the non-essential data item layer nodes in the chapter content based on the structured paragraph tags includes: Based on all the structured paragraph tags in the chapter content, determine the forward mapping relationship from the data item identifier to the paragraph identifier, and the reverse mapping relationship from the paragraph identifier to the paragraph content; Based on the positive mapping relationship, determine the target paragraph identifier corresponding to the data item identifier of the non-essential data item layer node; Based on the reverse mapping relationship, the target paragraph content corresponding to the target paragraph identifier is determined; The target paragraph content is combined with the data content of the non-essential data item layer node to obtain a partial rewrite prompt. The target paragraph content is then rewritten based on the partial rewrite prompt to obtain the updated target paragraph content.

6. The data generation method for analysis according to claim 1, characterized in that, After merging the chapter content corresponding to all the updated chapter-level nodes to obtain the target assessment result, the method further includes: A structured analysis card is generated based on the multidimensional metadata in the target analysis results, wherein the multidimensional metadata includes a conclusion summary; Based on the entity identifiers in the target entity set, the geographical range data and timestamp data in the structured judgment card, and the conclusion summary, a geospatial index, a time-series index, an entity association index, and a semantic vector index are constructed, and the structured judgment card is stored in the judgment memory pool.

7. The data generation method for analysis according to claim 6, characterized in that, The method further includes: Obtain cross-session analysis instructions, and retrieve candidate structured analysis cards from the analysis memory pool based on the geospatial index, the temporal index, the entity association index, and the semantic vector index; Determine the entity matching degree, geographical overlap degree, and semantic similarity between the cross-session judgment instruction and each candidate structured judgment card; Determine the time difference between the current time and the timestamp data of each of the candidate structured judgment cards, multiply the time difference by a preset time-effect decay coefficient, and perform an exponential operation to obtain the time-effect decay weight; The entity matching degree, geographical overlap degree and semantic similarity are weighted and summed based on the preset first weight, second weight and third weight respectively, and then multiplied by the time-effect decay weight to obtain the composite score; Based on the composite score, a target judgment card is determined from the candidate multiple structured judgment cards, and a summary of the conclusion of the target judgment card is added to the current session context.

8. A data generation device for analysis, characterized in that, The device includes: The instruction acquisition module is used to acquire and analyze instructions, extract features from the analysis instructions, and obtain the target intent category and target entity set. The network generation module is used to construct a multi-layer dependency network based on a preset industry knowledge architecture, the target intent category, and the target entity set. The multi-layer dependency network includes chapter layer nodes, data item layer nodes, and tool layer nodes with hierarchical dependency relationships. The data item layer nodes carry data item identifiers, and the data content of the data item layer nodes is obtained after calling the tool layer nodes associated with the data item layer nodes. The chapter content generation module is used to generate chapter content corresponding to the chapter layer node when it is determined that all data item layer nodes in the minimum generateable set corresponding to the chapter layer node are in a ready state, and to generate structured paragraph tags in the chapter content based on the data item identifier of the data item layer node in the minimum generateable set. The content update module is used to perform local rewrite updates on the target paragraph associated with the non-essential data item layer node in the chapter content based on the structured paragraph tags when it is determined that the non-essential data item layer node is in a ready state after the corresponding chapter content is generated. The non-essential data item layer node is the data item layer node that does not belong to the minimum generateable set. The analysis result generation module is used to merge the chapter content corresponding to all the updated chapter layer nodes to obtain the target analysis result.

9. An electronic device, characterized in that, The system includes a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the data generation method for analysis as described in any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the data generation method for analysis as described in any one of claims 1 to 7.

Images