An evolvable industrial simulation question-answering agent system and a simulation question-answering method thereof

Abstract

The application relates to the technical field of artificial intelligence and industrial simulation, in particular to an evolvable industrial simulation question and answer intelligent agent system and a simulation question and answer method thereof. The evolvable industrial simulation question and answer intelligent agent system comprises a knowledge base module, a tool calling module, an intelligent agent core module, a user interaction module and a log and audit module; the knowledge base module comprises a multi-element knowledge collection unit, a document loading and cutting unit, a vectorization embedding and storage unit, a semantic retrieval unit, a knowledge evolution unit, a rule base and a case base; the application has the beneficial effects that (1) knowledge is dynamically evolved and updated autonomously and timely; (2) the system has the capability of autonomously refining knowledge from simulation results; (3) tool calling is intelligentized, and the system realizes "question and answer as calculation"; (4) the system has strong capabilities of complex problem disassembly and iterative solution; and (5) the system has excellent adaptability and expandability.

Description

Technical Field

[0001] This invention relates to the field of interdisciplinary technology of artificial intelligence and industrial simulation, and in particular to an evolvable industrial simulation question-answering intelligent agent system and its simulation question-answering method. Background Technology

[0002] Industrial simulation technology plays a crucial role in product design, performance verification, and optimization decisions. With the widespread adoption of simulation technologies such as computational fluid dynamics and finite element analysis, engineers need to master complex simulation software operation procedures and possess deep domain knowledge, creating a high technical barrier.

[0003] Traditional simulation analysis workflows have the following problems: First, knowledge acquisition is difficult: the simulation field involves a large amount of scattered professional knowledge, including theoretical models, boundary condition settings, mesh generation strategies, solver parameter configurations, etc. This knowledge is scattered in various carriers such as academic papers, technical manuals, and project reports, and there is a lack of effective integration and retrieval mechanisms. Second, the tools are complex to use: mainstream simulation software is powerful but complex to operate, requiring users to have professional software operation skills and domain experience, resulting in a steep learning curve. Third, insufficient experience transfer: simulation analysis relies heavily on expert experience, but expert knowledge is difficult to systematically accumulate and share, leading to repeated exploration of similar problems and low efficiency; Fourth, low level of intelligence: Some simulation automation tools are mostly scripted implementations with fixed processes, lacking the ability to understand natural language problems and unable to adaptively adjust analysis strategies according to specific problems.

[0004] In recent years, breakthroughs in large language model technology have provided new possibilities for natural language understanding and knowledge reasoning. However, directly applying general-purpose large language models to industrial simulation faces the following challenges: lack of domain expertise, inability to access specialized simulation tools, difficulty in ensuring computational accuracy and reliability, and lagging knowledge updates.

[0005] Therefore, there is an urgent need for an intelligent system that integrates the ability to understand large language models, the execution capabilities of professional simulation tools, and the support of domain knowledge bases to achieve intelligent solutions to industrial simulation problems and continuous evolution of knowledge. Summary of the Invention

[0006] This invention aims to address the technical problems in existing industrial simulation technologies, such as difficulty in acquiring knowledge, complexity in tool use, insufficient experience transfer, and low level of intelligence. It provides an evolvable industrial simulation question-answering intelligent agent system and its simulation question-answering method. The specific technical solution is as follows: An evolvable industrial simulation question-answering intelligent agent system includes: a knowledge base module, a tool invocation module, an intelligent agent core module, a user interaction module, and a log and audit module; The knowledge base module includes a multi-source knowledge acquisition unit, a document loading and segmentation unit, a vectorized embedding and storage unit, a semantic retrieval unit, a knowledge evolution unit, a rule base, and a case base; The tool invocation module includes a tool definition and registration unit, a tool invocation and processing unit, and an intelligent analysis and knowledge extraction unit. The core module of the intelligent agent includes a master control intelligent agent, a task planning intelligent agent, a tool invocation intelligent agent, and a knowledge interaction intelligent agent; The system adopts a hierarchical collaborative architecture and achieves intelligent understanding of simulation problems, task planning, tool scheduling, and knowledge evolution through a closed-loop mechanism of "perception-learning-decision-action-feedback".

[0007] The knowledge base module is used to construct and maintain a dynamically evolving, multi-dimensional, and integrated simulation knowledge system to support the cognitive reasoning and decision-making of intelligent agents. The tool invocation module is used to realize the intelligent matching, automated invocation, and result parsing of simulation tools. The intelligent agent core module is used to complete problem understanding, task planning, tool scheduling, and autonomous learning based on a multi-agent collaborative architecture. The user interaction module is used to provide a multimodal human-computer interaction interface and transparent process display. The log and audit module is used to record the entire process of system operation and ensure traceability and security.

[0008] Furthermore, the multi-source knowledge acquisition unit is configured as follows: it has dedicated acquisition adapters for academic databases, news media, and enterprise internal data; it supports three data acquisition methods: API calls (where API is an application programming interface), web crawling, and file parsing; and it encapsulates the acquisition results into a standard format carrying source identifiers and timestamp metadata. The document loading and segmentation unit is configured as follows: a built-in multi-format file parser is used to extract text content from text files, PDF documents, Word documents, and Excel spreadsheets by calling the corresponding parsing modules; a block-segmentation strategy is adopted: a fixed block size of 512 characters is used, English is segmented by sentence based on the NLTK library (NLTK is a natural language toolkit), and Chinese is segmented by character; and each text block, together with the original file identifier and block number, constitutes a structured document unit; The vectorized embedding and storage unit is configured to: use an embedding model to convert each text block into a semantic vector; and achieve efficient storage through a vector database. The semantic retrieval unit is configured to: convert the user's query text into a query vector using the same embedding model; call the vector database search interface, passing in the query vector, the number of returned results, and the similarity threshold; and return a list of results sorted in descending order of cosine similarity, with each result containing document block content, metadata, and a similarity score. The knowledge evolution unit includes an incremental update and fusion subunit and a knowledge summarization and logging subunit.

[0009] The similarity threshold, as defined by the user, is used in knowledge base retrieval to determine whether a result is "relevant enough and worth returning". Its function is to pass the similarity threshold when retrieving the knowledge base, and the system will filter out candidate documents that are below the similarity threshold and retain candidate documents that are above the similarity threshold as the final return result or provide them to subsequent models.

[0010] The incremental update and fusion subunit is used to support timed triggering of update tasks, incrementally crawling each data source, and ensuring that only newly added or changed content is vectorized and stored in the database through content deduplication and similarity calculation mechanisms. The knowledge summarization and logging subunit is used to summarize the newly added knowledge in each update using a large model, extract core viewpoints, key data and conclusions, and form an "update knowledge log" containing source, update time, core content summary, and related simulation model or case information.

[0011] When the knowledge summarization and logging subunit calls the large language model, it uses a preset prompt word template. This template requires the model to extract the following from the input new knowledge text: core viewpoints, key data (values, units), and concluding statements, and output them in JSON format according to source, update time, summary, and associated simulation model / case. The model output is stored in the log after format verification.

[0012] The deduplication mechanism described above uses MD5 to calculate hash values ​​for text or files. If the hashes are the same, the text is considered duplicated, and the duplicate values ​​are removed. The similarity calculation mechanism uses cosine similarity, an index used to measure the directional similarity between two vectors. Its core idea is to calculate the cosine of the angle between the two vectors: the smaller the angle, the closer the cosine value is to 1, indicating that the two vectors are more similar; a 90° angle results in a cosine of 0, indicating no correlation; a cosine of -1 indicates completely opposite directions. In practical applications, such as text semantic matching and vector retrieval, text is usually converted into high-dimensional vectors, and the semantic similarity is determined by calculating cosine similarity. This approach has the advantage of being unaffected by vector length and focusing only on semantic direction.

[0013] Secondly, the vectorized embedding and storage unit configuration adopts the embedding model, which transforms each text block into a semantic vector; and achieves efficient storage through a database; the database adopts the QdrantStore vector database (where embedding is an embedded model and QdrantStore is a database).

[0014] Furthermore, the tool definition and registration unit is configured to: encapsulate simulation post-processing operations into Python tool objects, the simulation post-processing operations including data loading, slice extraction, isosurface generation, and time series data extraction; provide an isolated running environment through a sandbox service; and uniformly register all tools to the agent's toolkit after being encapsulated by an adapter; the tool invocation and processing unit is configured to: the agent invokes a post-processing tool matching the model type to execute post-processing operations through API or script, the post-processing operations including at least data loading, slice extraction, isosurface generation, and time series data extraction.

[0015] The tool invocation module is designed to enable intelligent matching, automated invocation, and result parsing of simulation tools, supporting the execution of complex tasks.

[0016] The simulation tools are uniformly encapsulated through "tool adapters," and their core mechanisms include standard interface definition, multi-tool adaptation, adapter responsibilities, and result standardization. The standard interface is defined as follows: class ToolAdapter: def run(self, input_params: dict) ->dict: pass .

[0017] Multi-tool adaptation includes at least one of the tools: OpenFOAM, ParaView, and Gmsh. The adapter's responsibilities include three steps: parameter conversion, execution scheduling, and result parsing. Parameter conversion refers to converting JSON format to the tool's format, while result standardization means unifying the output results.

[0018] The post-processing operation of the API or script specifically involves connecting the API to the corresponding tool and executing the post-processing operation through script commands, which includes a three-layer mapping mechanism: a. Semantic parsing layer: Transforms natural language into structured parameters, extracts key entities, and maps them to solver input keywords; For example: Input: "Maximum stress under 1000N axial load" Output: { "load": 1000, "direction": "axial", "target": "max_stress" } b. Parameter Normalization Layer Same parameter { "geometry": {}, "mesh": {}, "solver": {}, "postprocess": {} } c. Tool Mapping Layer Map standard parameters to tool commands Standard parameters: { "solver": "cfd", "velocity": 50 } Mapped to simpleFoam -velocity 50 .

[0019] Furthermore, the intelligent analysis and knowledge extraction unit is configured as follows: The simulation results returned by the tool are analyzed in depth and first converted into text descriptions. The key physical quantities, boundary conditions, geometric parameters and conclusive statements are extracted by calling the large language model to form structured text conclusions. The conclusions, input parameters and tool call chains are encapsulated into knowledge entries and stored in the case library in the knowledge base.

[0020] The case library stores historical cases, and the tool invocation module enables intelligent matching, automated invocation, and result parsing of simulation tools, supporting the execution of complex tasks. Its technical implementation consists of two parts: input and output. Input: The agent issues tool invocation commands in JSON format (where JSON stands for JavaScript object notation), including tool type, operation commands, and parameter list (such as coordinate range, variable name, time step, etc.); the input is processed through three steps: tool definition and registration, tool invocation and processing, and intelligent analysis and knowledge extraction, and then output is given. Outputs include main outputs and auxiliary outputs. The main output is the complete simulation result data; the auxiliary output is the simulation process report, which includes a list of tools and parameters used, a summary of the execution log, success / failure flags, exception handling records, and automatically generated text conclusions.

[0021] Furthermore, the master control agent is configured to: receive user natural language input; coordinate the collaborative work of the task planning agent, tool calling agent, and knowledge interaction agent; and trigger autonomous learning and knowledge evolution processes.

[0022] Furthermore, the task planning agent is configured as follows: based on a simulation workflow template library, it generates a JSON-formatted task execution plan through a large language model. The task execution plan includes a list of steps, tool types, input parameters, dependencies, and exception handling strategies.

[0023] Furthermore, the tool invocation agent is configured to: execute tool invocations in a planned order; monitor execution status and handle exceptions, including failure retry, rollback, and manual intervention; and support asynchronous parallel execution of dependency-free steps.

[0024] The core intelligent agent module serves as the system's brain, employing a multi-agent collaborative architecture. It consists of a master intelligent agent, a task planning intelligent agent, a tool invocation intelligent agent, and a knowledge interaction intelligent agent, which work together to complete problem understanding, task planning, tool scheduling, and autonomous learning.

[0025] Furthermore, the knowledge interaction agent is configured to continuously check the completeness of intermediate results; if information is missing, it generates follow-up questions and returns them through the user interaction module, wherein the number of interaction rounds does not exceed 3. Secondly, the decision path, which includes user questions, intent recognition, task planning, tool calls, intermediate results, and final answers, is encapsulated as a case and stored in the database; new and old cases are compared using clustering algorithms to identify similar patterns; and if a new case cannot be covered by existing case patterns and its simulation conclusion is verified to be correct, a large language model is called to generate candidate rules, which are then added to the rule base in the knowledge base module after manual review.

[0026] The core is that the simulation conclusions are verified to be correct. The system's intelligent agent automatically verifies the correctness of the simulation conclusions. The verification methods include: comparing the key output parameters of the simulation results with the standard results of similar problems in the historical case library, and judging them as correct when the relative error is less than a preset threshold; or automatically passing the verification based on the convergence criterion and the consistency check of physical laws.

[0027] Limiting the maximum number of interaction rounds to 3 rounds is significant because it allows the agent to complete information retrieval and decision-making within a limited number of steps by artificially setting an upper limit for the "think-action loop." This avoids getting stuck in an infinite loop or over-reasoning, while achieving the best balance between response quality, response speed, and call cost, and improving the overall stability and controllability of the system.

[0028] The decision path, which includes user questions, intent recognition, task planning, tool calls, intermediate results, and final answers, is encapsulated as a case and stored in the database; the database is a MongoDB database, and the candidate rules are IF-THEN candidate rules (IF-THEN means if-then, which is a conditional rule).

[0029] The clustering algorithm used is HDBSCAN (Hierarchical Density Clustering), which is based on the principle of hierarchical density distribution. It can adaptively cluster dynamically growing case semantic vectors without pre-setting the number of categories, while identifying new patterns and abnormal samples, thereby supporting knowledge evolution and rule generation.

[0030] The semantic vector is obtained by sequentially concatenating the user question, intent recognition result, task plan, tool call chain description, and result summary in the case, and then inputting them into the same embedding model as the knowledge base. The vector dimension is fixed by the system.

[0031] The core intelligent agent module, serving as the system's brain, employs a multi-agent collaborative architecture. It comprises a master intelligent agent, a task planning intelligent agent, a tool invocation intelligent agent, and a knowledge interaction intelligent agent, working together to complete problem understanding, task planning, tool scheduling, and autonomous learning. Its technical implementation primarily consists of three steps: "input-processing-output," as detailed below: Input: User's natural language question, such as "Analyze the maximum stress of the part under a 1000N axial load"; Processing: (1) Identification and keyword extraction: The input is natural language (e.g., "analyze the maximum stress of the part under a 1000N axial load"), the key entities are extracted using the LLM model and mapped to solver input keywords (e.g., analysis type: statics, load: force, magnitude 1000N, direction axial, target: maximum stress), and material properties can be automatically matched from the associated material library or prompted to be selected by the user. Boundary conditions, contact definitions, etc. are automatically set according to geometric features and load descriptions; (2) Task decomposition and planning (Thought stage): The master control agent transmits the intention to the task planning agent, which generates a JSON-formatted task execution plan based on the simulation workflow template library and through a large language model, including a list of steps, tool types, input parameters, dependencies and exception handling strategies. (3) Tool scheduling and execution monitoring (Action phase, i.e. execution phase): The tool calling agent executes the tool calls in the planned order, monitors the execution status, handles exceptions (failure retry, rollback, manual intervention), and supports asynchronous parallel execution of dependency-free steps; (4) Result Observation and Iterative Optimization (Observation Phase): The planning agent continuously checks the completeness of intermediate results. If information is missing, follow-up questions are generated and returned through the user interaction module, with a maximum of 3 rounds of interaction; if the timeout occurs, partial results are returned and uncertainty is marked; (5) Autonomous learning and evolution: After the task is completed, the master control agent triggers the learning process: the decision path, namely user question, intent recognition, task plan, tool call, intermediate result and final answer, is encapsulated as a case and stored in MongoDB (where MongoDB is a specific database instance or collection); the new and old cases are compared by clustering algorithm to identify similar patterns; if the new case cannot be covered by the existing case pattern, the large language model is called to generate IF-THEN candidate rules, which are added to the rule base in the knowledge base module after manual review; Output: Task execution plan: presented in JSON format, including a list of steps, required tools and parameters, for easy tracking and debugging; Intermediate reasoning process and final answer: Provides a transparent reasoning chain, including the thinking, observations and final conclusions at each step, enhancing interpretability; Newly generated case studies and rule suggestions: Output summaries of new cases and rule candidates generated during the self-learning process, supporting continuous updates to the knowledge base.

[0032] Furthermore, the core module of the intelligent agent also includes a large language model output constraint unit. This unit is used to ensure the structured and stable nature of the model output, and its technical implementation is as follows: (1) Prompt word template constraints: The system has a pre-set task parsing prompt word template, which explicitly requires the model to "output only in strict JSON format and not contain any additional explanatory text", and provides pre-defined field examples. For example, for airfoil flow analysis, the prompt word includes the following field definitions: analysis type, geometric parameters, boundary condition array, and target output array. The template also requires the model to directly extract information from the user's question to fill in the above fields. If a required field is missing in the user's question, the corresponding field will be output as null. (2) JSON Pattern Validation: After calling the large language model, the system uses a predefined JSON pattern to validate the format of the text returned by the model. The validation includes: whether it is valid JSON, whether it contains all required fields, and whether the field types match. If the validation passes, the parsed JSON object is passed to the subsequent task planning unit; if the validation fails, the retry and correction process begins. (3) Retry and Correction Mechanism: The system automatically appends the error message of the failed verification to the new prompt, requiring the model to correct the output and retaining the original user question. The maximum number of retries is 3. During each retry, the system will appropriately adjust the severity of the prompt (e.g., emphasizing "must strictly follow the JSON format"). If the verification passes after a retry, execution continues; if it still fails after 3 retries, it will switch to exception handling. (4) Exception handling mechanism: If a valid structured output cannot be obtained after retries, the system will perform one of the following operations according to the preset strategy: (a) transfer to manual intervention, requesting the user to rephrase the problem in a clearer way through the user interaction module; (b) return an error message, informing the user that "the system failed to parse the current problem. Please check your input or try again later." This exception handling strategy is connected with "manual intervention" to ensure the robustness of the system.

[0033] The predefined JSON schema is not a single fixed schema, but rather a JSON schema defined according to the task type (task parsing, task planning, knowledge extraction, rule generation). Before calling the large language model, the system dynamically selects the corresponding JSON schema for verification based on the current stage of the agent (identified by the master agent).

[0034] The above mechanism applies to all stages involving the invocation of large language models, such as task parsing, task execution plan generation, knowledge extraction, and rule generation, to ensure the consistency, reliability, and controllability of system output.

[0035] Furthermore, the user interaction module includes a multimodal input receiving unit and a session context management unit, wherein the multimodal input receiving unit is used to transmit user input in real time via WebSocket (network communication protocol), encapsulate it into a unified request object, including input type identifier, timestamp and specific content; The conversation context management unit is used to maintain an independent context store for each user session and record historical interactions in chronological order to form a complete dialogue trajectory; and the response generation unit is used to subscribe to the inference process results returned by the agent core in an asynchronous manner and obtain the text description of the inference process, intermediate calculation results and final answer in real time.

[0036] The user interaction module is designed to provide a natural and efficient human-computer interaction interface, supporting multimodal input and output.

[0037] Its technical implementation mainly involves the following methods: Multimodal input reception: The front end transmits user input in real time via WebSocket, encapsulating it into a unified request object containing input type identifier (text / file), timestamp, and specific content. Text input calls a large language model for intent recognition and entity extraction; file uploads are automatically extracted by a format parser from geometric features, mesh information, or log summaries. As a backend service, the session context management maintains an independent context store for each user session, recording the request objects, parsing results, intermediate processes returned by the agent, and final responses of historical interactions in chronological order, forming a complete dialogue trajectory; Response generation: After the parsed user requirements are integrated with the current context, the response generator encapsulates them into a structured task request and sends it to the agent core module via the HTTP (Hypertext Transfer Protocol) interface. The response generator subscribes to the reasoning process results returned by the agent core in an asynchronous manner, obtains the text description of the reasoning process, intermediate calculation results (such as numerical values, graph paths) and the final answer in real time, and combines this information into a response object that can be rendered by the front end.

[0038] Furthermore, the log and audit module includes: a log recording unit, an audit trail unit, a performance analysis unit, and a security mechanism unit.

[0039] The log recording unit records timestamps, operator IP (Internet Protocol), call parameters, and execution status for each user request, problem analysis, tool call, knowledge retrieval, and result generation. The audit tracking unit supports multi-dimensional log retrieval by user, time period, task type, etc., and generates operation audit reports. The performance analysis unit is used to statistically analyze the response time of each module, tool call frequency, and knowledge update contribution. The security mechanism unit is used for encrypted storage of log data, hierarchical access control, and secondary authentication for sensitive operations.

[0040] Among them, log records form a complete operation trajectory, audit tracking generates operation audit reports that meet enterprise compliance requirements, performance analysis assists in optimizing resource allocation, and security mechanisms enable secondary authentication of sensitive operations through hierarchical control of access permissions.

[0041] Furthermore, a system-based, evolvable industrial simulation question-answering method includes the following steps: Step S1: Receive the user's natural language questions and optional simulation file input through the user interaction module; Step S2: The main control agent of the core module calls the large language model to perform intent recognition and key entity extraction to obtain structured information. Step S3: Generate a task execution plan in JSON format using a task planning agent based on a simulation workflow template library; Step S4: The intelligent agent is invoked by the tool to call the corresponding simulation tools in the planned sequence to perform geometric processing, mesh generation, solution calculation and post-processing; Step S5: The simulation results are analyzed in depth by the intelligent analysis and knowledge extraction unit to form structured text conclusions; Step S6: Generate natural language responses and exportable analysis reports through the user interaction module; Step S7: The complete decision path of this task is encapsulated into a case and stored in the case library through the knowledge interaction agent. The new case is compared with the historical case through the clustering algorithm. If it is found that the new case cannot be covered by the existing case pattern and its simulation conclusion is verified to be correct, the large language model is called to generate candidate rules. Finally, after the result and candidate rules are manually reviewed and found to be correct, the newly generated candidate rules are added to the rule library to realize the continuous evolution of the knowledge base.

[0042] In step S3, a task execution plan in JSON format is generated by the task planning agent based on the simulation workflow template library; the template library structure under the JSON format task execution is as follows: { "template_id": "string", "template_name": "string", "description": "string", "applicable_scenarios": [], "workflow": { "steps": [] } } .

[0043] The beneficial effects of this invention are as follows: (1) Dynamic evolution of knowledge, autonomous and timely updates: This invention achieves automatic and continuous updates of the knowledge base through a multi-source knowledge acquisition adapter and incremental update mechanism, overcoming the fundamental defects of traditional static knowledge bases that rely on manual maintenance and have delayed updates. The system can actively absorb the latest simulation technology, industry standards and internal enterprise experience to ensure the timeliness and accuracy of knowledge content and meet the stringent requirements of rapid knowledge iteration in industrial sites; (2) Possesses the ability to autonomously extract knowledge from simulation results: The unique simulation result knowledge extraction process of this invention can automatically identify simulation models, call post-processing tools, analyze data, and generate structured knowledge entries, realizing the value mining and knowledge transformation of the massive amount of simulation models and calculation result data accumulated by enterprises. This is an important breakthrough from the existing system, which can only process document-type knowledge, and significantly improves the depth and practicality of the knowledge base; (3) Intelligent tool invocation, realizing "question-answering as computation": Through semantic encapsulation of tool libraries and intelligent invocation mechanism based on the ReAct framework, the system can accurately understand user intent and dynamically select and invoke professional tools such as CFD solvers and post-processing software for real-time computation and analysis. This solves the problem of limited tool invocation capabilities or reliance on fixed templates in existing systems, enabling them to cope with complex problems requiring precise computation and dynamic simulation, and expanding the capability boundaries of question-answering systems. (Where ReAct is an artificial intelligence framework or method that combines reasoning and action); (4) Strong ability to decompose and iteratively solve complex problems: By drawing on and strengthening the ReAct mechanism, the agent of this invention has the ability to deeply reason about complex and multi-level problems and decompose tasks. It can decompose a problem into ordered sub-steps, and perform iterative solution and answer optimization through multiple tool calls, parameter adjustments and result evaluations, thereby providing a more reliable and in-depth solution than one-time retrieval and generation; (5) Excellent system adaptability and scalability: Thanks to the modular design and standardized access support for multi-source knowledge and various tools, this invention can be flexibly adapted to different industrial simulation sub-fields (such as fluid, structure, and electromagnetic) and the diverse software tool ecosystem within enterprises, and has good universality and expansion potential. Attached Figure Description

[0044] Figure 1 This is a schematic diagram of the overall architecture of the evolvable industrial simulation question-answering intelligent agent system of the present invention; Figure 2 A flowchart illustrating the knowledge-based question-and-answer and tool-calling process based on the ReAct mechanism; Figure 3 A flowchart illustrating the workflow of a tool calling a module; Figure 4 Diagram of a collaborative architecture for an evolvable industrial simulation question-answering intelligent agent; Figure 5 The interaction flowchart for the user interaction module; Figure 6 This is a functional architecture diagram of the logging and auditing module; Figure 7 A simulation question-answering method for an evolvable industrial simulation question-answering agent; Figure 8This is a flowchart of the task execution for the airfoil flow analysis example in Example 4. Detailed Implementation

[0045] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be described in further detail below with reference to the accompanying drawings.

[0046] Example 1: An Evolvable Industrial Simulation Question-Answering Intelligent Agent System.

[0047] like Figure 1 As shown, this system comprises five main modules: a knowledge base module, a tool invocation module, an intelligent agent core module, a user interaction module, and a log and audit module. The knowledge base module includes a multi-source knowledge acquisition unit, a document loading and segmentation unit, a vectorized embedding and storage unit, a semantic retrieval unit, a knowledge evolution unit, a rule base, and a case library. The tool invocation module includes a tool definition and registration unit, a tool invocation and processing unit, and an intelligent analysis and knowledge extraction unit. The intelligent agent core module mainly includes a master intelligent agent, a task planning intelligent agent, a tool invocation intelligent agent, and a knowledge interaction intelligent agent.

[0048] The specific configurations for each module are as follows: (a) Knowledge Base Module The multi-source knowledge acquisition unit is configured with: dedicated acquisition adapters for academic databases, news media, and enterprise internal data; support for three data acquisition methods: API calls, web crawlers, and file parsing; and uniformly encapsulates the acquisition results into a standard format carrying source identifiers and timestamp metadata.

[0049] The document loading and segmentation unit is configured as follows: a built-in multi-format file parser is used to extract text content from text files, PDF documents, Word documents, and Excel spreadsheets by calling the corresponding parsing modules; a block-based strategy is adopted, with a fixed block size of 512 characters, English is segmented by sentence based on the NLTK library, and Chinese is segmented by character; each text block, together with the original file identifier and block number, constitutes a structured document unit.

[0050] The vectorized embedding and storage unit is configured to: use an embedding model to convert each text block into a semantic vector, and store it through the QdrantStore vector database.

[0051] The semantic retrieval unit is configured to: convert the text of the user's query into a query vector using the same embedding model; call the vector database search interface, passing in the query vector, the number of returned results, and the similarity threshold; and return a list of results sorted in descending order of cosine similarity, with each result containing document block content, metadata, and a similarity score.

[0052] The similarity threshold is used to determine the relevance of the search results. The system will filter out candidate documents below the threshold and retain documents above the threshold as the returned results.

[0053] The knowledge evolution unit includes an incremental update and fusion subunit and a knowledge summarization and logging subunit.

[0054] The incremental update and fusion subunit supports timed triggering of update tasks, incrementally crawling each data source, and ensuring that only newly added or changed content is vectorized and stored in the database through content deduplication and similarity calculation mechanisms. The deduplication mechanism uses MD5 to calculate hash values ​​for text or files, and if the hashes are the same, it is determined to be duplicated; the similarity calculation mechanism uses cosine similarity calculation. The knowledge summarization and logging subunit summarizes the newly added knowledge in each update using a large language model, extracts core viewpoints, key data, and conclusions, and forms an updated knowledge log containing source, update time, core content summary, and related simulation model or case information.

[0055] (ii) Tool Call Module The tool definition and registration unit is configured as follows: Post-simulation processing operations are encapsulated into Python tool objects, including data loading, slice extraction, isosurface generation, and time series data extraction; an isolated runtime environment is provided through a sandbox service; all tools are uniformly registered to the agent's toolset after being encapsulated by an adapter. The simulation tools are uniformly encapsulated through a tool adapter, which includes standard interface definitions, multi-tool adaptation, adapter responsibilities, and result standardization mechanisms. The standard interface definitions are as follows: class ToolAdapter: def run(self, input_params: dict) ->dict: pass The multi-tool adaptation includes the OpenFOAM tool; the adapter's responsibilities include three steps: parameter conversion, execution scheduling, and result parsing. Parameter conversion refers to converting JSON format parameters into a tool-specific format, and result standardization refers to unifying the output results.

[0056] The tool invocation and processing unit is configured such that the agent invokes a post-processing tool matched to the unit, and performs post-processing operations via API or script. These post-processing operations include data loading, slice extraction, isosurface generation, and time series data extraction. The API or script execution of the post-processing operations specifically includes a three-layer mapping mechanism: a semantic parsing layer, which converts natural language into structured parameters, extracts key entities, and maps them to solver input keywords; a parameter standardization layer, which unifies parameters from different sources into a standardized intermediate representation; and a tool mapping layer, which maps standardized parameters to commands or invocation sequences for specific tools.

[0057] The intelligent analysis and knowledge extraction unit is configured to: perform in-depth analysis on the simulation results returned by the tool, first converting them into text descriptions; call a large language model to extract key physical quantities, boundary conditions, geometric parameters, and conclusive statements to form structured text conclusions; and encapsulate the conclusions, input parameters, and tool call chains into knowledge entries and store them in the case library of the knowledge base.

[0058] The case library stores historical cases. Its input is tool invocation commands issued by the agent in JSON format, including tool type, operation commands, and parameter lists. Outputs include main output and auxiliary output. The main output is complete simulation result data, while the auxiliary output is a simulation process report, including a list of tools and parameters used, an execution log summary, success / failure flags, exception handling records, and automatically generated text conclusions. The specific workflow of the tool invocation module is as follows: Figure 3 As shown.

[0059] (III) Core Module of Intelligent Agent The master control agent is configured to: receive user natural language input; coordinate the collaborative work of the task planning agent, tool calling agent, and knowledge interaction agent; and trigger autonomous learning and knowledge evolution processes.

[0060] The task planning agent is configured as follows: based on a simulation workflow template library, it generates a JSON-formatted task execution plan through a large language model. The task execution plan includes a list of steps, tool types, input parameters, dependencies, and exception handling strategies.

[0061] The tool invocation agent is configured to: execute tool invocations in a planned order; monitor execution status and handle exceptions, including failure retry, rollback, and manual intervention; and support asynchronous parallel execution of dependency-free steps.

[0062] The knowledge interaction agent is configured as follows: it continuously checks the completeness of intermediate results; if information is missing, it generates follow-up questions and returns them through the user interaction module, with no more than three interaction rounds; it encapsulates the decision path, including user questions, intent recognition, task planning, tool calls, intermediate results, and final answers, into a case and stores it in the database; it compares new and old cases using a clustering algorithm to identify similar patterns; and if a new case cannot be covered by existing case patterns, and its simulation conclusion is verified to be correct, it calls a large language model to generate candidate rules, which are then manually reviewed and added to the rule base in the knowledge base module. The database is a MongoDB database, the clustering algorithm is the HDBSCAN hierarchical density clustering algorithm, and the candidate rules are IF-THEN candidate rules.

[0063] The core module of the intelligent agent also includes a large language model output constraint unit. This large language model output constraint unit ensures the structure and stability of the output through the following mechanisms: prompt word template constraint, requiring the model to output only strictly JSON format without any additional explanatory text; JSON pattern validation, using a predefined JSON pattern to validate the format of the text returned by the model, including whether it is valid JSON, whether it contains all required fields, and whether the field types match; a retry and correction mechanism, appending error information to a new prompt word when validation fails, requiring the model to correct its output, with a maximum of 3 retries; and an exception handling mechanism, transferring to manual intervention or returning an error message when retries still fail. The collaborative architecture of the master intelligent agent, task planning intelligent agent, tool invocation intelligent agent, and knowledge interaction intelligent agent is as follows: Figure 4 As shown.

[0064] (iv) User interaction module The user interaction module includes a multimodal input receiving unit and a session context management unit. The multimodal input receiving unit transmits user input in real-time via WebSocket, encapsulating it into a unified request object containing an input type identifier, timestamp, and specific content. The session context management unit maintains independent context storage for each user session, recording historical interactions in chronological order to form a complete dialogue trajectory. The user interaction module also includes a response generation unit, which asynchronously subscribes to the inference process results returned by the agent's core, obtaining the text description of the inference process, intermediate calculation results, and the final answer in real-time, and sending the combined response object to the front end via an HTTP interface. The interaction flow of the user interaction module is as follows: Figure 5 As shown.

[0065] (v) Log and Audit Module The log and audit module includes a log recording unit, an audit tracing unit, a performance analysis unit, and a security mechanism unit. The log recording unit records the timestamps, operator IP addresses, call parameters, and execution status of each user request, problem analysis, tool call, knowledge retrieval, and result generation, forming a complete operation trajectory. The audit tracing unit supports multi-dimensional log retrieval by user, time period, task type, etc., and generates operation audit reports that meet enterprise compliance requirements. The performance analysis unit statistically analyzes the response time of each module, tool call frequency, and knowledge update contribution, assisting in optimizing resource allocation. The security mechanism unit encrypts and stores log data, implements hierarchical access control, and performs secondary authentication for sensitive operations. The functional architecture of the log and audit module is as follows: Figure 6 As shown.

[0066] The above system operates according to the following process: The first step is user interaction and problem standardization: users raise engineering problems in natural language, the user interaction module receives and preprocesses them, and then passes the standardized problems to the core module of the intelligent agent. The second step involves the core reasoning and task planning of the intelligent agent: (e.g.) Figure 2 As shown, the core module of the intelligent agent completes core decisions based on the ReAct loop mechanism, analyzes user problems and decomposes complex engineering tasks into sub-tasks that can be executed step by step; it determines the knowledge support and simulation tools that the task needs to call, and synchronously sends query and retrieval instructions to the knowledge base module and tool call instructions to the tool call module. The third step involves multi-module collaborative task execution: The knowledge base module provides engineering knowledge retrieval results for the agent based on knowledge collected from multiple sources, such as documents, papers, and databases. Simultaneously, driven by a dynamic knowledge evolution process, it continuously and automatically collects, updates, and summarizes multi-source knowledge. The tool invocation module receives invocation commands from the agent, dynamically invokes tools through semantic matching, drives the simulation software to perform calculations, and sends the tool execution results back to the agent's core module. The agent's core module receives the knowledge retrieval results and tool execution results, and, using the ReAct loop mechanism, determines whether further knowledge supplementation, tool parameter adjustment, or iterative solution is needed until the problem is fully solved. The fourth step is result feedback and process auditing: the log and auditing module fully records the agent's reasoning and decision-making process, tool call records, and knowledge retrieval traces to ensure that the process is traceable and meets compliance management requirements; finally, the solution results are fed back to the user, forming a complete link from problem input to closed-loop verification.

[0067] The system adopts a hierarchical collaborative architecture and achieves intelligent understanding of simulation problems, task planning, tool scheduling, and knowledge evolution through a closed-loop mechanism of perception-learning-decision-action-feedback.

[0068] Example 2: An Evolvable Industrial Simulation Question-and-Answer Method.

[0069] Based on the above system, this embodiment provides an evolvable industrial simulation question-answering method. For example... Figure 7 As shown, the method includes the following steps: Step S1: Receive the user's natural language questions and optional simulation file input through the user interaction module; Step S2: The main control agent of the core module calls the large language model to perform intent recognition and key entity extraction to obtain structured information. Step S3: Generate a task execution plan in JSON format using a task planning agent based on a simulation workflow template library; Step S4: The intelligent agent is invoked by the tool to call the corresponding simulation tools in the planned sequence to perform geometric processing, mesh generation, solution calculation and post-processing; Step S5: The simulation results are analyzed in depth by the intelligent analysis and knowledge extraction unit to form structured text conclusions; Step S6: Generate natural language responses and exportable analysis reports through the user interaction module; Step S7: The complete decision path of this task is encapsulated into a case and stored in the case library through the knowledge interaction agent. The new case is compared with the historical case through the clustering algorithm. If it is found that the new case cannot be covered by the existing case pattern and its simulation conclusion is verified to be correct, the large language model is called to generate candidate rules. Finally, after the result and candidate rules are manually reviewed and found to be correct, the newly generated candidate rules are added to the rule library to realize the continuous evolution of the knowledge base.

[0070] Example 3: Solving CFD flow field simulation problems using this system.

[0071] When a user asks, "Calculate the pressure distribution in the chassis area of ​​a certain car model at a speed of 120 km / h, and analyze the trend of the lift coefficient," In this system, the intelligent agent is identified as a CFD problem, and it is determined that CFD solution tools (such as OpenFOAM) and ParaView are needed for post-processing (wherein, OpenFOAM is a free and open-source computational fluid dynamics (CFD) software package, and ParaView is an open-source scientific visualization software for visualizing large-scale datasets). The agent uses the ReAct loop: Thought (Intelligent Agent Thinking): "Users need to calculate pressure distribution and lift coefficient, so they need to run CFD to solve it first." Action (Intelligent Agent Action): "Invokes the OpenFOAM solver, passing in the geometric model and boundary conditions of the vehicle model"; Observe (Agent Feedback): "Solution complete, pressure field and velocity field data obtained"; Thought (Intelligent Agent Thinking): "The results need to be post-processed to extract the pressure distribution cloud map and lift coefficient curve." Action (Intelligent Agent Action): "Invoke ParaView, load the result file, generate a chassis area pressure cloud map, and extract data on the change of lift coefficient over time" (where ParaView is an open-source, interactive 3D data visualization software used to process and visualize large scientific datasets). Observe (agent feedback): "Obtain cloud maps and data curves"; Thought (Agent Thinking): "Needs to analyze trends and draw conclusions"; Action (Agent Action): "Invokes the built-in analysis script, calculates the steady-state value of the lift coefficient, and generates analysis text"; The intelligent agent integrates the results and generates a final answer, including a pressure cloud map, a lift coefficient curve, and analysis conclusions. At the same time, it returns the conclusion "At 120km / h, the lift coefficient of this vehicle model is 0.32, which meets the design expectations" to the user and stores it in the knowledge base.

[0072] It should be noted that after the agent has thought about the question, if it determines that it can answer the question directly, it will retrieve the relevant context from the knowledge base, generate the final answer directly, and output the final answer, thus ending the question-and-answer session.

[0073] Example 4: The system was used to perform fluid dynamics analysis around an airfoil, as detailed below: 1) User Input: Users can submit natural language questions through the user interaction module, such as: "Analyze the aerodynamic performance of the NACA 0012 airfoil under conditions of incoming flow velocity of 50 m / s, angle of attack of 5 degrees, and standard atmospheric pressure. Calculate the lift coefficient and drag coefficient, and check whether significant flow field separation occurs." Users can also upload airfoil geometry files. 2) Task Parsing and Initiation: The master control agent of the core module receives input, calls the large language model for intent recognition and key entity extraction, and obtains structured information: airfoil type (NACA 0012), incoming flow velocity (50 m / s), angle of attack (5°), atmospheric conditions (standard atmospheric pressure), and target parameters (lift coefficient, drag coefficient, flow field separation check). The master control agent transmits the intent to the task planning agent, which generates a JSON (JavaScript Object Notation) format task execution plan based on the simulation workflow template library (external aerodynamic analysis template). The plan includes five steps: geometry processing and computational domain creation, mesh generation, solution calculation, post-processing analysis, and report generation, specifying the tool types and parameters required for each step. 3) Geometric Processing and Computational Domain Creation: The tool invokes the intelligent agent to call the geometric processing tool (such as a script based on Open CASCADE (an open-source full-size 3D geometry library)) as planned. This tool imports NACA 0012 airfoil curve data, automatically cleans the geometry to ensure smooth curves, and constructs a C-shaped computational domain based on the "best practice rules for external flow field" in the knowledge base (obtained through semantic retrieval, such as "domain boundary distance is at least 15 times the chord length of the airfoil"), identifies the boundaries of the far field, airfoil wall, axis of symmetry, etc., and returns the processed geometric model file and boundary identification information. 4) Mesh Generation: The tool calls the intelligent agent to invoke the mesh generation tool (such as Gmsh (a 3D finite element mesh generation software)); the tool automatically selects a hybrid mesh strategy based on the "external incompressible flow" type and high-precision requirements: generating a boundary layer mesh near the airfoil wall, and automatically calculating the height of the first mesh layer based on the Reynolds number to satisfy y + The requirement is approximately equal to 1; an unstructured triangular mesh is generated in the far-field region. After mesh generation, a quality check is performed (twist < 0.85, aspect ratio < 100), and adaptive refinement is performed in the airfoil leading edge and wake regions, returning the mesh file and mesh quality report; 5) Solving calculations: The tool calls the intelligent agent to call the CFD (fluid dynamics) solver, such as OpenFOAM.

[0074] The solver performs the following sub-operations: a: Physical model selection: The solver calculates the Reynolds number based on the formula Re=ρvL / μRe. If Re>4000, it is determined to be turbulent, and the SST k−ω turbulent model is selected; if Re<2300, it is determined to be laminar, and the laminar model is selected; if it is between the two, it is a transitional flow, and either the turbulent model or the laminar model can be selected according to the user's accuracy requirements. At the same time, based on the "flow around an airfoil" scenario and the "engineering accuracy" requirements, the SST k−ω turbulent model is confirmed to be selected from the knowledge base. b. Boundary condition settings: Automatically assign values ​​to each boundary of the computational domain: the far-field boundary is set to pressure far-field conditions (given Mach number and angle of attack), and the airfoil wall is set to a no-slip adiabatic wall. c. Solver parameter configuration: Set the solver to pressure-based steady-state solver and select the second-order discretization scheme to obtain higher accuracy; d. Execution and Monitoring: Submit calculations and monitor the residual curves and lift and drag coefficients in real time. When the main residuals decrease to 1e... -5 When the force coefficient fluctuation is less than 0.1%, the system automatically determines convergence and terminates the solution, returning the result file (pressure field, velocity field, etc.) and convergence log. 6) Post-processing: The tool calls the intelligent agent to call the post-processing tool (such as ParaView) to analyze the results. First, the key indicators are extracted: the final average values ​​of the lift coefficient Cl and the drag coefficient Cd are calculated; second, the flow field is analyzed: the distribution curve of the pressure coefficient Cp along the airfoil surface is generated; streamline diagrams or vorticity cloud diagrams are generated; finally, compliance judgment is made: the calculated Cl and Cd values ​​are compared with typical experimental values ​​or high-precision simulation results of the same working conditions in the knowledge base (within a reasonable error range), and qualitative conclusions such as "good flow adhesion" or "moderate tail separation" are given based on the flow field analysis. 7) Report Generation: The response generator in the user interaction module collects all intermediate results (mesh files, convergence curves, pressure distribution maps, streamline diagrams, etc.) and final conclusions, combines them into a natural language response, and pushes it to the front end for display via WebSocket. It also generates an exportable PDF aerodynamic performance analysis report, including input conditions, calculation settings, mesh size, key results (Cl, Cd values), flow field visualization charts, and qualitative conclusions. 8) Knowledge Update and Evolution: After the task is completed, the master control agent triggers the learning process: the complete decision path of this task (user question, intent recognition result, task plan, tool call records, intermediate results, and final answer) is encapsulated as a case and stored in the case library. The knowledge interaction agent compares the new case with the historical case through a clustering algorithm. It finds that the SST k-ω model (Shear Stress Transport model) has been successfully verified for this working condition and has no conflict with the existing rule library. Then, rule extraction is triggered: the large language model is called to generate candidate rules "IF airfoil flow and incoming flow velocity ≈ 50 m / s AND angle of attack ≈ 5° THEN Recommend using SST k-ω turbulence model". After manual review, the rules are added to the rule library to achieve continuous evolution of the knowledge base.

[0075] The task execution flow in this embodiment is as follows: Figure 8 As shown.

[0076] The problem in this embodiment is solved using traditional simulation analysis, and compared with the solution using the intelligent agent system and question-answering method of this invention. The results are shown in Table 1 below: Table 1. Comparison of the answering performance of the intelligent agent system and question-answering method of this invention with that of traditional simulation analysis. .

[0077] As shown in the table above, the intelligent agent system and question-answering method of this invention have a significant efficiency improvement compared to traditional simulation analysis.

Claims

1. An evolvable industrial simulation question-answering intelligent agent system, characterized in that: include: Knowledge base module, tool calling module, intelligent agent core module, user interaction module, and log and audit module; The knowledge base module includes a multi-source knowledge acquisition unit, a document loading and segmentation unit, a vectorized embedding and storage unit, a semantic retrieval unit, a knowledge evolution unit, a rule base, and a case base; The tool invocation module includes a tool definition and registration unit, a tool invocation and processing unit, and an intelligent analysis and knowledge extraction unit. The core module of the intelligent agent mainly includes a master control intelligent agent, a task planning intelligent agent, a tool invocation intelligent agent, and a knowledge interaction intelligent agent. The system adopts a hierarchical collaborative architecture and achieves intelligent understanding of simulation problems, task planning, tool scheduling, and knowledge evolution through a closed-loop mechanism of "perception-learning-decision-action-feedback". The multi-source knowledge acquisition unit is configured with: dedicated acquisition adapters for academic databases, news media, and enterprise internal data; support for three data acquisition methods: API calls, web crawlers, and file parsing; and uniformly encapsulates the acquisition results into a standard format carrying source identifiers and timestamp metadata. The document loading and segmentation unit is configured as follows: it has a built-in multi-format file parser, which calls the corresponding parsing module to extract text content for text files, PDF documents, Word documents and Excel spreadsheets respectively; A chunking strategy is adopted, with a fixed chunk size of 512 characters. English text is segmented by sentence based on the NLTK library, and Chinese text is segmented by character. Each text chunk, together with the original file identifier and chunk number, constitutes a structured document unit. The vectorized embedding and storage unit is configured to: use an embedding model to convert each text block into a semantic vector, and store it through a vector database; The semantic retrieval unit is configured to: convert the text of the user's query into a query vector using the same embedding model; call the vector database search interface, passing in the query vector, the number of returned results, and the similarity threshold; and return a list of results sorted in descending order of cosine similarity, with each result containing document block content, metadata, and a similarity score. The knowledge evolution unit includes an incremental update and fusion subunit and a knowledge summarization and logging subunit. The incremental update and fusion subunit is used to support timed triggering of update tasks, incrementally crawling each data source, and ensuring that only newly added or changed content is vectorized and stored in the database through content deduplication and similarity calculation mechanisms. The knowledge summarization and logging subunit is used to summarize and extract core viewpoints, key data and conclusions from the newly added knowledge stored in the database each time, using a large model, and forming an updated knowledge log that includes the source, update time, core content summary, and related simulation model or case information. The tool definition and registration unit is configured as follows: simulation post-processing operations are encapsulated as Python tool objects, including data loading, slice extraction, isosurface generation, and time series data extraction; an isolated running environment is provided through a sandbox service, and all tools are uniformly registered to the agent's toolkit after being wrapped by an adapter; the tool invocation and processing unit is configured as follows: the agent invokes the post-processing tool matching the tool invocation module, and executes the post-processing operation through API or script, the post-processing operation including at least data loading, slice extraction, isosurface generation, and time series data extraction; The intelligent analysis and knowledge extraction unit is configured as follows: it performs in-depth analysis on the simulation results returned by the tool, first converts them into text descriptions, calls a large language model to extract key physical quantities, boundary conditions, geometric parameters and conclusive statements to form structured text conclusions; and encapsulates the conclusions, input parameters and tool call chains into knowledge entries and stores them in the case library in the knowledge base module. The main control agent is configured to: receive user natural language input; coordinate the collaborative work of the task planning agent, tool calling agent, and knowledge interaction agent; and trigger the autonomous learning and knowledge evolution process. The knowledge interaction agent is configured as follows: it continuously checks the completeness of intermediate results; if information is missing, it generates follow-up questions and returns them through the user interaction module, with no more than 3 interaction rounds; secondly, it encapsulates the decision path, including user questions, intent recognition, task plan, tool calls, intermediate results, and final answers, into cases and stores them in the database; it compares new and old cases using clustering algorithms to identify similar patterns; and if a new case cannot be covered by existing case patterns and its simulation conclusion is verified to be correct, it calls a large language model to generate candidate rules, which are then added to the rule base in the knowledge base module after manual review. The user interaction module is used to provide a multimodal human-computer interaction interface and transparent process display; the log and audit module is used to record the entire system operation process and ensure traceability and security.

2. The evolvable industrial simulation question-answering intelligent agent system according to claim 1, characterized in that: The task planning agent is configured as follows: based on a simulation workflow template library, it generates a JSON-formatted task execution plan through a large language model. The task execution plan includes a list of steps, tool types, input parameters, dependencies, and exception handling strategies.

3. The evolvable industrial simulation question-answering intelligent agent system according to claim 1, characterized in that: The tool invocation agent is configured to: execute tool invocations in a planned order; monitor execution status and handle exceptions, including failure retry, rollback, and manual intervention; and support asynchronous parallel execution of dependency-free steps.

4. The evolvable industrial simulation question-answering intelligent agent system according to claim 1, characterized in that: The core module of the intelligent agent also includes a large language model output constraint unit; the large language model output constraint unit ensures the structured and stable output through prompt word template constraints, JSON pattern validation, retry and correction mechanisms and exception handling mechanisms.

5. The evolvable industrial simulation question-answering intelligent agent system according to claim 1, characterized in that: The user interaction module includes: a multimodal input receiving unit and a session context management unit; The multimodal input receiving unit is used to transmit user input in real time via WebSocket and encapsulate it into a unified request object; the session context management unit is used to maintain an independent context storage for each user session and record historical interactions in chronological order to form a complete dialogue trajectory.

6. The evolvable industrial simulation question-answering intelligent agent system according to claim 1, characterized in that: The log and audit module includes: a log recording unit, an audit trail unit, a performance analysis unit, and a security mechanism unit; The logging unit records timestamps, operator IPs, call parameters, and execution status for each user request, problem analysis, tool call, knowledge retrieval, and result generation; the audit tracing unit supports multi-dimensional log retrieval by user, time period, and task type, and generates operation audit reports. The performance analysis unit is used to calculate the response time of each module, the frequency of tool calls, and the contribution of knowledge updates. The security mechanism unit is used for encrypted storage of log data, hierarchical access control, and secondary authentication for sensitive operations.

7. An evolvable industrial simulation question-answering method based on the system described in any one of claims 1-6, characterized in that: Includes the following steps: Step S1: Receive the user's natural language questions and optional simulation file input through the user interaction module; Step S2: The main control agent of the core module calls the large language model to perform intent recognition and key entity extraction to obtain structured information. Step S3: Generate a task execution plan in JSON format using the task planning agent based on the simulation workflow template library; Step S4: The intelligent agent is invoked by the tool to call the corresponding simulation tools in the planned sequence to perform geometric processing, mesh generation, solution calculation and post-processing; Step S5: The simulation results are analyzed in depth by the intelligent analysis and knowledge extraction unit to form structured text conclusions; Step S6: Generate natural language responses and exportable analysis reports through the user interaction module; Step S7: The complete decision path of this task is encapsulated into a case and stored in the case library through the knowledge interaction agent. The new case is compared with the historical cases through the clustering algorithm. If it is found that the new case cannot be covered by the existing case pattern and its simulation conclusion is verified to be correct, the large language model is called to generate candidate rules. Finally, after the simulation conclusion and candidate rules are manually reviewed and found to be correct, the newly generated candidate rules are added to the rule library to realize the continuous evolution of the knowledge base.

Images