Intelligent automatic analysis and integrated fusion processing system for multi-source data

Abstract

The invention discloses an intelligent automatic analysis and integrated fusion processing system for multi-source data, and belongs to the field of software automation. Comprising a multi-source input unit, a unified semantic modeling unit, an automatic analysis unit, an automatic preprocessing unit, an automatic collaborative execution unit and a security authentication mechanism, wherein the security authentication mechanism comprises primary security authentication and secondary security authentication. According to the invention, end-to-end automatic closed loop from demand understanding to autonomous analysis of the processing path to execution landing can be realized, and key appeals in a complex project business scene can be accurately responded.

Description

[0001] This application is the following application.

[0002] The application number is: 2025117245080

[0003] Application date: November 24, 2025

[0004] The application is titled: A divisional application for an automated multi-source analysis and integrated processing system based on artificial intelligence. Technical Field

[0005] This invention relates to the field of software automation, and more specifically to an intelligent automated analysis and integrated fusion processing system for multi-source data. Background Technology

[0006] In the field of software automation, traditional methods typically rely on specialized artificial intelligence models to complete the input and output of single tasks in isolation. For example, they might use generative AI to construct simulated data and execute calls based solely on interface documentation. Similarly, commercially available RPA (Robotic Process Automation) tools rely on manual coding or artificial intelligence natural language processing models to generate scripts that have been interpreted and understood. Both approaches suffer from operational complexity, requiring extensive manual coding and specific prompts. Human intervention is needed to understand the context, manually arrange the order of interface calls, manually pre-configure basic database data, and even maintain parameter mappings and state transfers item by item. This not only makes the automation chain fragile and difficult to maintain but also prone to overlooking implicit dependencies such as key business constraints, aggregate parameters, and boundary conditions. Especially in scenarios where business complexity increases and parameter combinations grow exponentially, traditional methods will expose serious efficiency bottlenecks when collaborative coding is required, involving multiple heterogeneous project materials such as requirements documents, design specifications, and data models. Maintenance costs will skyrocket, coverage scenarios will become fragmented, and human oversights will become frequent, ultimately reducing automation to "semi-automation" and failing to support the needs of large-scale, high-fidelity, and adaptive engineering practices. When faced with real-world, complex business scenarios in a project, and needing to combine the business logic, data dependencies, and process relationships in the requirements document to achieve automated connection of multiple interfaces, parameter linkage, and closed-loop execution, existing conditions are often inefficient and have limited effectiveness.

[0007] Therefore, how to provide an automated multi-source analysis and integrated processing system based on artificial intelligence is a problem that urgently needs to be solved by those skilled in the art. Summary of the Invention

[0008] In view of this, the present invention provides an intelligent automated analysis and integrated fusion processing system for multi-source data, realizing an end-to-end automated closed loop from demand understanding to autonomous analysis and processing path to execution and implementation, accurately responding to the key demands in complex project business scenarios, so as to solve the technical problems existing in the above-mentioned prior art.

[0009] To achieve the above objectives, the present invention adopts the following technical solution: A smart automated analysis and integrated fusion processing system for multi-source data includes: The multi-source input unit is used to receive multi-source heterogeneous data documents uploaded by users, as well as input natural language. A unified semantic modeling unit, connected to the multi-source input unit, is used to perform semantic decoupling, intelligent reconstruction and standardized modeling of the multi-source content after file recognition and extraction, and automatic archiving into the database; The automated analysis unit, connected to the unified semantic modeling unit, decomposes the intent elements of user input through a multi-layer semantic parsing engine, identifying user behavior goals, target objects, constraints, and implicit subtasks; it constructs a dynamic semantic association graph, linking project documents, framework assets, and user history information to bridge semantic gaps; based on semantic integrity, it performs intelligent pathfinding, deriving supported query dimensions, input parameter formats, return structure paradigms, and business rules and format constraints to be followed during data injection; and with the help of a rule reasoning engine, domain knowledge graph, and semantic probability model, it performs feasibility verification and structural optimization of the derivation results, outputting a complete structured execution intent path. An automated preprocessing unit, connected to the automated analysis unit, intelligently generates an expected execution plan that meets the user's initial goals; An automated collaborative execution unit is connected to the automated preprocessing unit. This unit begins execution after the user confirms that the expected execution plan is correct. The security authentication mechanism, including initial security authentication and secondary security authentication, is used to achieve end-to-end security control and intent alignment.

[0010] Optionally, the multi-source input unit specifically includes: automatically identifying the type of input source, performing lightweight pre-validation on multimodal data to filter invalid or corrupted inputs, and uniformly aggregating the user's input requirements or problem descriptions along with metadata into a buffer pool.

[0011] Optionally, the multi-source input unit is used to perform format recognition and extract file content information for pre-verification of uploaded multi-source heterogeneous files.

[0012] Optionally, the unified semantic modeling unit specifically includes the following processes: Preprocess multi-source heterogeneous files, remove format differences, and restore them to a unified intermediate representation; Deep semantic understanding is performed based on domain ontology to extract key entities, relationships between entities, operational intentions, contextual constraints, and implicit logical rules. Perform semantic decoupling, restoring the original expression to atomic semantic units of subject-action-goal-constraint; Intelligent completion and logical reconstruction are performed. Through pattern recognition, potential functional module divisions, data flow paths or dependencies are obtained, and standardized expressions that conform to preset semantic paradigms are generated. The reconstructed semantic units are encoded and hierarchically categorized to form a set of structured semantic objects with rich meta-semantic tags.

[0013] Optionally, the automated preprocessing unit specifically includes the following processes: Based on structured execution intentions, multiple execution paths that can achieve the goal are automatically derived; Each execution path is independently simulated to generate a request example, simulated response structure, estimated execution time, and status of dependent services. The application uses a rules engine and permission policies to conduct compliance and risk assessments on each path; All pre-planning schemes are presented to users in a structured, comparative, and interactive manner; Based on the user's selections, output a complete, traceable, and revisable expected execution plan.

[0014] Optionally, the automated collaborative execution unit specifically includes the following processes: Parse the structured execution plan after user confirmation, and extract the task sequence, dependent resources, target framework, parameter contract and execution constraints; The executable instruction stream is automatically generated based on the execution intent path output by the automated analysis unit, and the adapter is dynamically matched according to the target carrier type. Intelligent orchestration and scheduling based on task dependencies enables collaborative execution across multiple platforms or tools; Real-time monitoring of the status, time consumption, and anomalies of each subtask; construction of a visual execution trajectory map; and self-recovery processing based on preset strategies. After the task is completed, the outputs of each stage are collected, structured and packaged into an execution result package, and then archived.

[0015] Optionally, the initial security authentication process includes: Verify the legality of the source of original materials uploaded by users, and identify and block unauthorized formats and malicious files; The compliance semantic model is used to identify sensitive words, detect illegal intent, and assess contextual risks in text, image OCR results, and structured field descriptions. By combining user identity, project permissions, and organizational policies, it can be determined whether the input content exceeds the scope of the user's role. Identified risky content is isolated and a risk alert is generated to immediately notify the user. Only content that passes the verification is allowed to proceed to the next stage of processing.

[0016] Optionally, the secondary security authentication process includes: Compare the pre-generated execution plan with the user's original intent to detect semantic deviations, over-inferences, or missing constraints; Perform syntax security verification, data compliance checks, and behavior legality determination on instructions to be executed. If a risk is detected, the execution flow will be automatically intercepted and the user will be provided with details of the risk and suggestions for modification. The automated collaborative execution unit is only authorized to initiate actual operations after the user's final confirmation.

[0017] As can be seen from the above technical solutions, compared with the prior art, the present invention discloses an intelligent automated analysis and integrated fusion processing system for multi-source data. Through multi-source input units, unified semantic modeling units, automated analysis units, automated preprocessing units, automated collaborative execution units, and security authentication mechanisms, it realizes an end-to-end automated closed loop from demand understanding to autonomous analysis and processing path to execution implementation, accurately responding to the key demands in complex project business scenarios. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0019] Figure 1 This is a schematic diagram of the overall execution architecture of the framework in an embodiment of the present invention.

[0020] Figure 2 This is a schematic diagram of the basic process of the multi-source input unit of the framework node of the present invention.

[0021] Figure 3 This is a schematic diagram illustrating the specific process of the unified semantic modeling unit for nodes in the framework of this invention.

[0022] Figure 4 This is a schematic diagram illustrating the specific process of the automated analysis unit for the framework nodes of this invention.

[0023] Figure 5 This is a schematic diagram of the specific process of the automated preprocessing unit of the framework node of the present invention.

[0024] Figure 6 This is a schematic diagram illustrating the specific process of the automated collaborative execution unit of the framework nodes in this invention.

[0025] Figure 7 This is a schematic diagram illustrating the specific process of the first security authentication of the framework node in this invention.

[0026] Figure 8 This is a schematic diagram illustrating the specific process of secondary security authentication for nodes in the framework of this invention. Detailed Implementation

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

[0028] Example 1: This invention discloses an intelligent automated analysis and integrated fusion processing system for multi-source data, comprising: a multi-source input unit for supporting user input and uploading of natural language requirements or problem statements, and aggregating diverse heterogeneous data (such as documents, images, structured / unstructured data, etc.); a unified semantic modeling unit for performing semantic decoupling, intelligent reconstruction, and standardized modeling of input data based on a standardized structural index of a preset framework, and automatically archiving it into a database; an automated analysis unit for dynamically identifying and deeply understanding the true intent and contextual relationships of user-input semantic content; and an automated preprocessing unit for intelligently generating data that conforms to the user's initial... The expected output scheme of the target is provided for user review and confirmation. The automated collaborative execution unit automatically schedules and executes operations after the user confirms the feasibility of the preprocessing scheme, supporting the integration with one or more third-party frameworks / platforms to complete closed-loop tasks. Among them, security authentication mechanisms are embedded between the multi-source input unit and the unified semantic modeling unit, and between the automated preprocessing unit and the automated collaborative execution unit: the first authentication is used to intercept and filter input sources containing illegal content, non-compliant semantics or potential risks; the second authentication is used to verify whether the pre-generated results match the user's true intent and ensure that the output content is legal and compliant, without any overstepping or harmful behavior, so as to achieve full-process security and controllability and intent alignment.

[0029] As a further aspect of this invention, the multi-source input unit specifically includes the following process: While uploading a multi-source file ontology, the user simultaneously inputs a natural language statement of purpose or other intent. The framework prioritizes automatically identifying the input source type (e.g., text input box, file drag-and-drop, speech transcription, image scanning, database integration, etc.) and performs preliminary format detection and metadata extraction on the raw data (e.g., file type, interface design, scene dimension, data structure, exception requirements, etc.). Subsequently, the multi-source input unit performs lightweight pre-validation on the multimodal data, filtering invalid, corrupted, or severely formatted inputs, and temporarily caching and uniquely identifying reasonable data. Simultaneously, the user's purposeful or other intent-driven description of needs or problems, along with metadata, is uniformly aggregated into a buffer pool, providing a standardized, traceable, and auditable raw data set for the subsequent unified semantic modeling unit, ensuring the integrity, parsability, and relevance of the source information.

[0030] As a further aspect of this invention, a unified semantic modeling unit is established. The specific process includes: constructing a cross-modal, cross-format semantic parsing system for the various types of heterogeneous documents currently uploaded (such as requirements specifications, interface design documents, database table structures, technical solutions, meeting minutes, etc.). The unit does not process the incoming natural language requirements descriptions or problem statements. The framework first preprocesses and extracts content from these original files, identifying their multimodal information such as text, tables, fields, and comments, stripping away document format differences, and restoring them to a unified intermediate representation.

[0031] Building upon this foundation, a semantic parsing engine powered by artificial intelligence performs deep semantic understanding based on domain ontology. It meticulously identifies metadata in each document, extracting core semantic elements, including key entities (such as "user," "order," and "payment interface"), relationships between entities (such as "call," "dependency," and "mapping"), operational intents (such as "create," "query," and "validate"), contextual constraints (such as "administrator only" and "timeout 30 seconds"), and implicit logical rules. Through a cross-document keyword semantic alignment mechanism (e.g., mapping "user ID," "userId," and "UID" to the same ontology node), it achieves automatic normalization and association matching of the same concepts from different sources.

[0032] Subsequently, the framework performs a "semantic decoupling" process, deconstructing and purifying the mixed expressions in the original document (such as colloquial descriptions, redundant embellishments, nested sentences, or non-standard terminology), stripping away surface expressions and restoring them to atomic semantic units. A typical structure is a quadruple: "subject-action-goal-constraint," ensuring that each semantic fragment is independent, unambiguous, composable, and reusable.

[0033] Furthermore, by leveraging knowledge enhancement and contextual reasoning capabilities, the system intelligently completes and logically reconstructs fragmented, ambiguous, or missing information (e.g., inferring business meaning from database field names or completing call scenarios by combining interface parameters); and through pattern recognition technology, it discovers potential functional module divisions, data flow paths, or dependencies, generating standardized expressions that conform to preset semantic paradigms.

[0034] Ultimately, the framework encodes and hierarchically categorizes the reconstructed semantic units based on a unified structured indexing system, forming a set of structured semantic objects with rich meta-semantic tags. These objects are stored in the project system map, maintaining a high degree of organization and traceability, awaiting dynamic matching, fusion, and reasoning with users' natural language input in the next stage.

[0035] As a further aspect of this invention, the automated analysis unit specifically includes the following process: The framework receives structured and standardized data objects from the unified semantic modeling unit, and decomposes the original input requirements or problem descriptions into intent elements through a multi-layer semantic parsing engine, identifying user behavior goals, target objects, constraints, and implicit subtasks. For example, when a user requests that "the requirements document describes certain data as belonging to a specific functional module, but the corresponding query interface is not found in the current framework; the interface definition needs to be supplemented, and simulated data needs to be injected into the underlying data storage according to its parameter specifications, and then the result is returned through the interface call," the framework will automatically extract the core intent chain: complete the missing interface → construct simulated data that conforms to the interface contract → execute the interface call and return the verification result. The framework embeds a context-aware mechanism that automatically associates user historical queries or operation trajectories, the current project document system (such as requirements specifications, interface definition drafts, data model descriptions), and existing framework assets (such as business routing lists, data table structure metadata) to construct a dynamic semantic association graph, used to bridge the semantic gap between document descriptions and framework implementation. For example, when a requirements document specifies that "a certain type of data should be queried under a certain module," but the framework lacks a corresponding interface, the framework will combine the document's description of the data's usage scenarios, the interaction patterns of related modules, and the field semantics of the data storage structure to deduce the query dimensions, input parameter formats, return structure paradigms, and business rules and format constraints that the interface should support during data injection. During the semantic completion and intent verification phase, the framework leverages artificial intelligence, a rule-based reasoning engine, a domain knowledge graph, and a semantic probability model to perform feasibility checks and structural optimization on the derived interface definition. For instance, if the document describes that certain data needs to support "filtering by time period and type," the framework will automatically supplement general pagination parameters, standardized time formats, and enumeration value constraints, ensuring that the generated simulated data covers boundary conditions and typical scenarios. Simultaneously, the framework assesses whether the operation poses risks of permission conflicts, environment mismatches, or structural incompatibility. If it detects that the target data table lacks write permissions or the interface path is already occupied, it will automatically generate risk warnings and alternative suggestions, such as "Direct writing is prohibited in the current environment; please confirm whether to switch to sandbox mode" or "It is recommended to add a version prefix to the interface path to avoid conflicts." Ultimately, the framework outputs a complete structured intent, including the main task objective, decomposed sub-steps, dependent resource references, execution constraints, semantic confidence scores, and recommended execution paths. It does not rely on specific field names or database syntax, but is encapsulated in a purely semantic and portable form of expression, such as: "Locate the function affiliation based on document chapters → Derive the input and output contract of the missing interface → Generate simulated business data that conforms to the contract → Inject it into the specified data container → Call the newly generated interface and capture the structured response."This output serves as the input benchmark for subsequent modules, ensuring that the entire framework not only responds to user-defined instructions but also proactively bridges the semantic gaps between requirements, design, implementation, and verification, achieving an intelligent transformation from vague descriptions to executable, verifiable, and traceable engineering closed-loop systems.

[0036] As a further aspect of this invention: the automated preprocessing unit, specifically comprising the following steps: upon receiving the structured intent output by the automated analysis unit (e.g., "Section 3.7 of the requirements document requests the acquisition of a list of active users for the past 30 days for operational analysis"), firstly, based on the semantic context and the system asset library, automatically derives multiple execution paths that can achieve the goal: for example, path one is "calling a query interface for existing user activity," and path two is "directly querying the active user table in the database and executing a database statement"; subsequently, the system performs a complete pre-render for each path: for the interface call path, automatically generates a request example (including header information, parameters, and authentication methods), a simulated response structure (including field descriptions, data examples, and status codes), and estimates the execution time and dependent service status; for the database query path, generates a standard database statement and estimates the execution time and dependent service status. The system assesses the impact on the number of rows, whether index optimization is needed, and whether sensitive fields are involved, while also noting the execution environment (e.g., "Test database only"). Simultaneously, the system performs compliance and risk assessments for each path, such as "API path requires authentication; the current user has not configured a key" or "The query statement does not include pagination, which may return millions of data entries; pagination is recommended." Finally, all pre-demonstration solutions are presented in a structured, comparative, and interactive manner, allowing users to expand to view details, compare execution costs, assess risk levels, and choose to "confirm execution of a path," "merge optimized paths," or "return adjustment requests." For example, users might see: "Solution 1 (API call): Returns a string structure, including pagination; data is anonymized; estimated execution time in milliseconds; Solution 2 (database query): Returns the original fields, without pagination; requires manual processing of tens of thousands of rows, posing a performance risk," and displays confirmation information. To improve user decision-making efficiency, the framework automatically scores the semantic alignment of the pre-simulation plan with the original requirements document, similar historical tasks, and the current state of the framework, highlighting differences and items requiring confirmation. For example, "The requirements document requires support for 'filtering by role,' but the current plan does not include this parameter; should it be added?" or "The simulation data does not cover 'null value boundary scenarios'; should the generation strategy be expanded?" Finally, the framework outputs a complete, traceable, and revisable expected execution plan, including an execution blueprint, pre-simulation results, a risk list, adjustment suggestions, and a confirmation entry point, for final user review. Users can answer "confirm execution," "execute after partial adjustments," or "return for modification." All interactions are recorded and fed back to upstream modules, forming a closed-loop optimization mechanism. This process ensures that the framework reaches semantic, operational, and risk consensus with the user before actual execution, achieving intelligent prediction and human-machine collaborative confirmation mechanisms that ensure "execution is correct."

[0037] As a further aspect of this invention, an automated collaborative execution unit is defined as follows: After the user confirms the feasibility of the preprocessing scheme in the previous unit, the unit automatically schedules and executes the operation, supporting integration with single or multiple third-party frameworks / platforms to complete closed-loop tasks. The specific process is embodied in an intelligent scheduling framework that dynamically orchestrates, links across frameworks, monitors execution, and achieves a closed-loop result. Upon receiving the user's confirmation instruction, the framework first parses the structured execution scheme output by the preprocessing unit, extracting the task sequence, dependent resources, target framework, parameter contracts, and execution constraints. Then, it initiates the execution process, automatically generating an executable instruction stream based on the semantic path in the scheme, and dynamically matching an adapter according to the target carrier type. For example, if the requirements document describes "the need to generate data query logic based on user behavior statistics rules in the document and execute it," the framework will automatically and intelligently derive the corresponding structured query statement, encapsulate it into a standard database statement script, and securely inject it into the target data environment through a pre-configured database middleware channel (such as an execution proxy supporting a certain database protocol). Before execution, it automatically adds transaction control, resource isolation, and rollback flags to ensure operational atomicity and environmental security. If a task involves multi-framework collaboration, such as "generating an interface definition and then synchronously registering it to the interface gateway, triggering automatic verification by the test platform," the framework will schedule multiple executors in dependency order. First, it will call the interface management platform to create endpoints and write metadata, then trigger the test engine to construct request messages, initiate calls, capture responses, and compare expected results, all without manual intervention. During execution, the framework collects the status, time, logs, and exception information of each subtask in real time, constructing a visual execution trajectory graph. For example, if "interface registration fails and a conflicting path already exists, an automatic renaming strategy will be triggered." When an exception occurs, the framework will automatically retry, downgrade, or terminate according to preset strategies, while simultaneously pushing alarms and repair suggestions. After the task is completed, the framework automatically collects the outputs of each stage (such as execution logs, returned data, status reports, and performance metrics), and structurally encapsulates them into an execution result package. This package, along with version snapshots, operation audit records, and semantic traceability codes, is archived together, forming a complete closed loop from requirement description to framework implementation. The entire process does not rely on hard coding or manual configuration. All operations are completed based on semantic inference and dynamic adaptation. For example, when faced with a scenario where "the requirements document requires monthly aggregation of active users and writing to a report", the framework can automatically parse the time dimension, aggregation logic, and target storage location, generate corresponding SQL statements, and execute them through middleware, achieving fully automatic, highly reliable, and cross-platform collaborative execution from document semantics to framework behavior.

[0038] As a further aspect of this invention: the initial security authentication process includes the following steps: After receiving the original materials uploaded by the user (such as requirement documents, interface specifications, screenshots, structured data tables, etc.), the framework first initiates source legitimacy verification to identify and block unauthorized formats, disguised files, script injection carriers, or known malicious file fingerprints. Subsequently, it enters semantic layer scanning, using an AI-based compliance semantic model to perform sensitive word recognition, violation intent detection, and contextual risk assessment on text, image OCR results, and structured field descriptions. For example, it detects whether there are any hints of unauthorized operation (such as "bypassing access control to obtain all user data"), illegal business requests (such as "forging transaction records"), prohibited content such as political / violent / pornographic content, or hidden high-risk content. Operational semantics (such as "clear database" and "delete logs") are not accompanied by approval context. At the same time, the system combines user identity, project permissions, and organizational policies to determine whether the input content exceeds the scope of the user's role. For example, if a regular developer uploads a request to modify the core financial table structure, the framework will automatically mark it as "permission exceeded and pending review". All identified risky content is isolated and a structured risk report is generated, which includes the risk type, semantic fragment, context location, and suggested handling methods (such as blocking, desensitization, and transfer to manual review). Only when the content passes all compliance checks or is released after manual review is it allowed to enter the unified semantic modeling unit for subsequent processing. This builds the first security barrier before semantic reconstruction, ensuring that the modeling source is pure, legal, and uncontaminated.

[0039] As a further aspect of this invention, secondary security authentication specifically includes the following process: After the user confirms the preprocessing scheme, the framework does not execute it immediately. Instead, it first compares whether the pre-generated scheme (such as generated database statements, interface definitions, data injection scripts, and call instruction sequences) truly reflects the user's original intent and whether there are semantic deviations, excessive deductions, or hidden side effects. For example, if the user only requests to "query data from the last seven days," but the database statement in the scheme does not have a limit on the number of records or does not declare time filtering, the framework will determine it as a "risk of exceeding the scope" and require correction. At the same time, it initiates a compliance review of the output content, performing syntax security verification on the instructions to be executed (such as whether the generated database statement contains deletion without conditions, whether the interface exposes internal fields, and whether the script calls unauthorized interfaces), and data... Compliance checks (such as whether the simulated data contains real ID numbers or mobile phone numbers that have not been anonymized) and behavior legality determination (such as whether it attempts to write to the production environment or violates the principle of data minimization); if any overstepping of boundaries, ambiguous authorization, or potentially harmful behavior is detected, the framework will automatically intercept the execution flow and proactively notify the user, while also providing modification suggestions or alternative safe paths (such as "suggest adding conditional limits", "enable pseudonym generator for simulated data", "switch to sandbox environment for execution"); only after the user confirms that it is acceptable will the automated collaborative execution unit be authorized to start the real operation, ensuring that every framework action is not only technically feasible, but also semantically correct, legally compliant, and risk-controllable, achieving a secure alignment and responsibility loop between "what the user wants to do" and "what the framework will do".

[0040] Example 2: like Figure 1 As shown, this embodiment is an intelligent automated analysis and integrated fusion processing system for multi-source data. The figure includes a multi-source input unit, a unified semantic modeling unit, an automated analysis unit, an automated preprocessing unit, and an automated collaborative execution unit. Security authentication processes are included between the multi-source input unit and the unified semantic modeling unit, and between the automated preprocessing unit and the automated collaborative execution unit, as well as the interaction relationships between them. Wherein: Multi-source input units such as Figure 2 As shown: Users upload heterogeneous files from multiple sources, for example: [Requirements Specification] - "After a user submits an order, the system must initiate a payment request within 3 seconds and save the payment record. If a refund is generated, the order status must be modified." [API Documentation] - Payment Interface: POST request / api / pay, body: userId, orderId; [Database table structure] -table:t_order,fields:user_id,status,create_time; [Meeting Minutes] - "Administrators can manually trigger the refund process"; [System Architecture Diagram] - in JPG format, showing the flow of business data from the system cache to the database. User-submitted request description: [As an administrator, please find Zhang San's payment record from yesterday afternoon, initiate a refund, and check if the refund was successful after completion.]

[0041] Unified semantic modeling unit such as Figure 3 As shown: by Figure 2 The multi-source metadata of the final output, after initial security authentication, is input into this unit. For example, starting from the first stage of preprocessing and content extraction, format differences are eliminated, and a unified intermediate representation is established: text paragraph extraction: "Call payment interface"; table field identification: userId → user ID; annotation parsing: [status: 0 - pending payment, 1 - paid, 2 - refunded]; uniformly encoded as plain text + structured JSON fragments. This is then input into the second stage for deep semantic parsing to extract: entities: user, order, payment interface, administrator; relationships: user [creates] order, order [triggers] payment interface; intent: create, query, validate, refund; constraints: orders are limited to administrators and specified personnel only; implicit logic: refunds are possible when order status = 2. In the third stage, cross-document semantic alignment and normalization are performed, mapping synonyms to the same ontology node. For example: "User ID" ≡ "userId" ≡ "user_id" → ontology node: User.id; "Payment Interface" ≡ " / api / pay" → ontology node: PaymentService; "Refund" ≡ "Manual Refund" → operation type: RefundAction. In the fourth stage, semantic decoupling is performed, restoring the data to atomic quadruples: (Subject: User, Action: Create, Target: Order, Constraint: None); (Subject: System, Action: Call, Target: Payment Interface, Constraint: Within 3 seconds); (Subject: Administrator, Action: Trigger, Target: Refund, Constraint: Order Paid). In the fifth stage of input, intelligent completion and logical restructuring rely on the knowledge enhancement and contextual reasoning capabilities of artificial intelligence. For example: inference: orderId comes from the primary key of the t_order table; completion: call failure → log recording + alarm sending; pattern recognition: order placement → payment → callback → status update. In the sixth stage of input, structured encoding and classification are performed, and the data is tagged and stored according to the index system. For example: index path: subject domain = e-commerce > task type = order processing > priority = P0 > associated resources = payment gateway, t_order → output: a standardized semantic object collection (JSON Schema format). The data processed in the above units is stored in the project system graph, waiting for the next unit to match it with the natural language requirements submitted by the user.

[0042] Automated analysis units such as Figure 4 As shown: by Figure 3 The final project system diagram is described and input into this unit, for example: The project system diagram includes: Input 1: [Requirements Specification] → "Save records after payment, and change order status upon refund"; [API Documentation] → POST / api / pay(userId,orderId); [Database] → t_order(status: 0 pending payment / 1 paid / 2 refunded); [Meeting Minutes] → "Administrators can manually trigger refunds"; [Architecture Diagram OCR Analysis] → Data Flow: System → Cache → DB.

[0043] Input 2: The user submitted the following request: [As an administrator, please help me find Zhang San's payment record from yesterday afternoon, initiate a refund, and check if the refund was successful after completion.]

[0044] Step 1, Multi-layer semantic parsing: Deconstructing intent elements: Role: Administrator; Main tasks: Find payment records → Initiate a refund → Verify results; • Time constraint: Yesterday afternoon; • Subject: Zhang San (mapped to userId or user_id); Implicit subtasks: identity recognition, data location, operation execution, and status verification.

[0045] Step 2, Dynamic Semantic Association Graph Construction: Linking historical trajectories, project documents, or framework assets: • Match "Zhang San" → in the user table, name ≈ "Zhang San" → get userId; • "Payment Records" → associated with the log system or payment transaction record (implicit but not explicitly defined); • "Initiate Refund" → Matches meeting minutes "Administrators can manually issue refunds" → Infers that the refund API needs to be called or the order status needs to be updated; • "Whether the query was successful" → can be obtained through the API response or by querying t_order.status.

[0046] Step 3, Dual-path intelligent route finding and generation: Feasibility schemes are determined based on semantic integrity. Path 1: Call via API (Recommended)

[0047] - It is deduced that a "refund interface" is missing → Combined with "modify order status" + "administrator privileges"

[0048] - Automatically generate interface contract suggestions: POST / api / refund body:{orderId,operatorRole:"admin",reason:"manual"} - Execution chain: 1. Query t_orderWHERE user_id=xxx AND create_time∈[yesterday 2-6 PM] AND status=1 2. Call the refund API to be completed (simulated execution) 3. Check the order status again or call / api / order / {id} to get the latest status. Path 2: Direct database operation (alternative)

[0049] -If the current environment allows administrative writes: UPDATE t_order SET status=2 WHERE user_id=...AND status=1; - Verification required: Does it violate business rules? Are there any audit log requirements? Step 4, Semantic completion and feasibility verification: Integrating knowledge graph + rule engine + probabilistic model: • Complete parameter specifications: Time format ISO8601, status enumeration value validation • Simulated data injection coverage scenarios: normal refunds, duplicate operations, and accidental refunds in non-payment states. Risk detection: - Target table lacks write permissions → Direct modification of the database is prohibited. - Refund API not registered → Prompt: "It is recommended to add the API definition to the API gateway." - Sandbox environment available → We recommend enabling simulation mode for execution.

[0050] Step 5: Output the structured intent model (for use by the preprocessing and execution units), as shown below:

[0051] Automated preprocessing units such as Figure 5 As shown: by Figure 4 The structured intent model data representing the final output is input into this unit, for example: Input: A structured intent model output by the automated analysis unit, including the main task, sub-steps, resource references, recommended paths, confidence levels, and constraints.

[0052] Step 1, Execution Path Deduction: Generate multiple solutions based on semantic context and system asset library (this step is consistent with the path deduction included in the automated analysis unit, but depends on whether the user requests interruption or regeneration; crucially, the paths generated in this step will be pre-rendered): Path 1: Call the API (Recommended)

[0053] Action: Initiate a refund → Call POST / api / refund

[0054] -Conditions: User is an administrator, order status = paid Path 2: Direct database update (alternative)

[0055] -Action: UPDATE t_order SET status=2 WHERE orderId=...

[0056] -Conditions: Test environment only, approval and authorization required.

[0057] Step 2, Independent pre-run of each path: Automatically generate execution details and simulation feedback: Path 1 rehearsal (API call) Request example: POST / api / refund; Headers:Authorization:Bearer <token>; Body:{"orderId":"ODR20250405001","operator":"admin"}; • Simulated response: 200 OK; {"result":"success","refundId":"RF2025...","amount":99.9}; • Field descriptions: refundId is a unique identifier, and amount is rounded to two decimal places; • Estimated time: <300ms, dependent on payment gateway service (currently healthy); • Data masking: Sensitive fields have been masked; Path Two Preview (Database Operations): SQL statement: UPDATE t_order SET status=2,update_time=NOW() WHERE user_id='U1003'AND status=1; • Estimated number of rows affected: 1 row; • Index recommendation: A combined index of user_id and status exists; • Sensitive fields: No plaintext password, but related to changes in transaction status; • Execution environment restrictions: Execution is only permitted in a test environment; Step 3, Compliance and Risk Assessment: Application rule engine and permission policy verification: • Risks associated with Path 1: - The current user has not configured an API key → Authentication credentials are missing; - The interface is not registered to the gateway → You need to deploy or enable simulation mode first; • Risks associated with Path Two: Directly writing to the database in the production environment is prohibited → This is a violation of regulations; - No transaction rollback mechanism → Risk of data inconsistency exists; General recommendations: - It is recommended to add pagination parameters to prevent full table scans; -Add audit log entries to record the operator and timestamp; Step 4, Structured Comparison Presentation: Supports interactive viewing, comparison, and selection.

[0058] Step 5: Generate a traceable execution plan, including blueprints, rehearsals, risks, recommendations, and entry points.

[0059] Step 6, User Confirmation and Closed-Loop Feedback: All selections are recorded and fed back to the upstream module: User operation example: Select: "Execute after partial adjustments": →Add the role=admin parameter; → Enable sandbox mode; →The system automatically updates the execution plan and enters the collaborative execution unit; Feedback mechanism: - The user rejected path two → recorded the "Disable direct connection to DB" preference; - Repeated reminders of incomplete parameters → triggering knowledge base optimization suggestions; Automated collaborative execution units such as Figure 6 As shown: The path pre-simulation result output from step 5, after undergoing secondary security authentication, is input into this unit, for example: Input: A structured execution plan after user security authentication and confirmation, including task sequence, path selection, parameter contract, target platform, risk marker, etc.

[0060] Step 1: Analyze the execution plan and define the task blueprint: The system receives the structured execution plan confirmed by the user and extracts the complete task sequence, target platform, parameter contract, and execution constraints. For example, for the requirement of "initiating a refund for Zhang San and verifying the result," the system identifies three core steps: ① query payment records; ② call the refund interface; ③ verify the refund status. Simultaneously, the system clarifies the target system (e.g., database, API gateway), execution environment (sandbox mode), and security requirements (authentication required, rollback support) for each step.

[0061] Step 2: Dynamically Generate Instructions and Match Execution Adapters: Based on the target type of each task, the system automatically selects the corresponding execution adapter and generates runnable instructions. For database operations, it generates compliant SQL statements and attaches transaction control and isolation flags; for API calls, it constructs HTTP requests containing authentication tokens and correctly formatted parameters to ensure compatibility with the target service. All instructions are generated based on semantic inference, requiring no manual coding or configuration.

[0062] Step 3: Intelligent orchestration and scheduling for cross-system collaboration: The system schedules tasks in an orderly manner according to dependencies and supports parallel linkage across multiple platforms. For example, while calling the refund interface, an asynchronous query to the database is initiated to verify whether the order status is updated synchronously. The service layer processing result is judged by the interface response code, and the consistency of the underlying data is confirmed by changes in database fields, forming a dual closed-loop verification mechanism of "interface + data".

[0063] Step 4: Real-time monitoring and automatic error recovery: During execution, the system continuously collects the status, time consumption, logs, and error information of each subtask. If issues such as interface timeouts or path conflicts occur, the system will automatically retry, rename, or switch to an alternative path according to preset strategies, and push alarm notifications. All error handling processes are traceable, ensuring execution stability and security.

[0064] Step 5: Collect output results and complete closed-loop archiving: After the task is completed, the system automatically summarizes the execution results, including returned data, log chains, performance indicators and audit records, and encapsulates them into a standardized execution result package, while associating the original requirement document chapters and semantic traceability codes.

[0065] Initial security certification, such as Figure 7 As shown: by Figure 2 Output input to Figure 3 The initial security certification performed before commencement includes the following specific certifications: [Source legitimacy verification]: 1. File format whitelist check (only .docx, .xlsx, .pdf, .png, .json and other authorized formats are allowed); 2. Detection of file extension spoofing (e.g., .php spoofing as .png); 3. Identification of script injection vectors (such as HTML embedded JS, malicious macros); 4. Fingerprint comparison of known malicious files (based on hash / signature database); 5. If the upload fails, proceed with the following steps: [Block Upload] + Log the message + Send Alarm.

[0066] 6. If approved → Proceed to the next stage with valid documents; [Multimodal semantic layer scanning]: 1. Text content: NLP compliance semantic model analysis; 2. Image content: After OCR extracts the text, it is fed into the semantic model; 3. Structured fields: Semantic parsing of field names / description text; The following detections are performed in parallel: ① Sensitive word matching (regular expression + dictionary + context understanding); ② Identification of illegal intent (such as "forgery", "bypass", "clear"); ③ Semantic detection of high-risk operations (deletion / export / permission change without approval context); ④ Filtering of political / violent / pornographic / illegal information; ⑤ If a risk is identified → proceed to

Risk Isolation and Report Generation

[0067] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the apparatus disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the description is relatively simple; relevant parts can be referred to the method section.

[0068] The above description of the disclosed embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.< / token>

Claims

1. A smart automated analysis and integrated fusion processing system for multi-source data, characterized in that, include: The multi-source input unit is used to receive multi-source heterogeneous data documents uploaded by users, as well as input natural language. A unified semantic modeling unit, connected to the multi-source input unit, is used to perform semantic decoupling, intelligent reconstruction and standardized modeling of the multi-source content after file recognition and extraction, and automatic archiving into the database; An automated analysis unit, connected to the unified semantic modeling unit, decomposes the intent elements of user input through a multi-layer semantic parsing engine, and identifies user behavior goals, objects of action, constraints, and implicit subtasks. Construct a dynamic semantic association graph to link project documents, framework assets, and user history information to fill semantic gaps; perform intelligent pathfinding based on semantic integrity to deduce supported query dimensions, input parameter formats, return structure paradigms, and business rules and format constraints to be followed when injecting data; By leveraging a rule-based reasoning engine, domain knowledge graph, and semantic probability model, the inference results are validated for feasibility and optimized for structure, outputting a complete structured execution intent path. An automated preprocessing unit, connected to the automated analysis unit, intelligently generates an expected execution plan that meets the user's initial goals; An automated collaborative execution unit is connected to the automated preprocessing unit. This unit begins execution after the user confirms that the expected execution plan is correct. The security authentication mechanism, including initial security authentication and secondary security authentication, is used to achieve end-to-end security control and intent alignment.

2. The intelligent automated analysis and integrated fusion processing system for multi-source data according to claim 1, characterized in that, The multi-source input unit specifically includes: automatically identifying the type of input source, performing lightweight pre-validation on multimodal data to filter invalid or corrupted inputs, and uniformly aggregating the user's input requirements or problem descriptions along with metadata into a buffer pool.

3. The intelligent automated analysis and integrated fusion processing system for multi-source data according to claim 1, characterized in that, The multi-source input unit is used to perform format recognition and extract file content information for pre-verification of uploaded multi-source heterogeneous files.

4. The intelligent automated analysis and integrated fusion processing system for multi-source data according to claim 1, characterized in that, The unified semantic modeling unit specifically includes the following processes: Preprocess multi-source heterogeneous files, remove format differences, and restore them to a unified intermediate representation; Deep semantic understanding is performed based on domain ontology to extract key entities, relationships between entities, operational intentions, contextual constraints, and implicit logical rules. Perform semantic decoupling, restoring the original expression to atomic semantic units of subject-action-goal-constraint; Intelligent completion and logical reconstruction are performed. Through pattern recognition, potential functional module divisions, data flow paths or dependencies are obtained, and standardized expressions that conform to preset semantic paradigms are generated. The reconstructed semantic units are encoded and hierarchically categorized to form a set of structured semantic objects with rich meta-semantic tags.

5. The intelligent automated analysis and integrated fusion processing system for multi-source data according to claim 1, characterized in that, The automated preprocessing unit specifically includes the following processes: Based on structured execution intentions, multiple execution paths that can achieve the goal are automatically derived; Each execution path is independently simulated to generate a request example, simulated response structure, estimated execution time, and status of dependent services. The application uses a rules engine and permission policies to conduct compliance and risk assessments on each path; All pre-planning schemes are presented to users in a structured, comparative, and interactive manner; Based on the user's selections, output a complete, traceable, and revisable expected execution plan.

6. The intelligent automated analysis and integrated fusion processing system for multi-source data according to claim 4, characterized in that, The automated collaborative execution unit specifically includes the following processes: Parse the structured execution plan after user confirmation, and extract the task sequence, dependent resources, target framework, parameter contract and execution constraints; The executable instruction stream is automatically generated based on the execution intent path output by the automated analysis unit, and the adapter is dynamically matched according to the target carrier type. Intelligent orchestration and scheduling based on task dependencies enables collaborative execution across multiple platforms or tools; Real-time monitoring of the status, time consumption, and anomalies of each subtask; construction of a visual execution trajectory map; and self-recovery processing based on preset strategies. After the task is completed, the outputs of each stage are collected, structured and packaged into an execution result package, and then archived.

7. The intelligent automated analysis and integrated fusion processing system for multi-source data according to claim 1, characterized in that, The initial security authentication process includes: Verify the legality of the source of original materials uploaded by users, and identify and block unauthorized formats and malicious files; The compliance semantic model is used to identify sensitive words, detect illegal intent, and assess contextual risks in text, image OCR results, and structured field descriptions. By combining user identity, project permissions, and organizational policies, it can be determined whether the input content exceeds the scope of the user's role. Identified risky content is isolated and a risk alert is generated to immediately notify the user. Only content that passes the verification is allowed to proceed to the next stage of processing.

8. The intelligent automated analysis and integrated fusion processing system for multi-source data according to claim 1, characterized in that, The secondary security authentication process specifically includes: Compare the pre-generated execution plan with the user's original intent to detect semantic deviations, over-inferences, or missing constraints; Perform syntax security verification, data compliance checks, and behavior legality determination on instructions to be executed. If a risk is detected, the execution flow will be automatically intercepted and the user will be provided with details of the risk and suggestions for modification. The automated collaborative execution unit is only authorized to initiate actual operations after the user's final confirmation.

Images