Code-free Agent construction method and system based on large language model

Abstract

The invention discloses a code-free Agent construction method and system based on a large language model, and relates to the technical field of artificial intelligence and software engineering. The method comprises the following steps: constructing a large language model, an Agent capability semantic model and a database in a server, wherein the Agent capability semantic model analyzes a semantic report to generate a code-free Agent structure; the large language model generates an execution plan according to the code-free Agent structure, and the server starts arrangement and scheduling of the execution plan; managing the execution process of each task and monitoring the execution process; and the system checks and processes the execution result, and re-executes or adjusts the execution of the uncompleted or abnormal task. According to the method, code-free Agent construction is created through the large language model and the Agent capability semantic model, and the problems that when an existing Agent encounters an exception in the execution process, autonomous adjustment cannot be conducted, and manual intervention is relied on are solved.

Description

Technical Field

[0001] This invention belongs to the field of artificial intelligence and software engineering technology, and in particular relates to a method and system for constructing no-code agents based on large language models. Background Technology

[0002] With the development of large language models, intelligent agents are widely used in data analysis, business automation, operations management, customer service, and other fields. However, existing agent building technologies still have the following problems: Agent building is highly dependent on programming skills; existing agent frameworks usually require writing scripts, configuring YAML, or orchestrating code, making them difficult for non-technical personnel to use. Although LangChain exists as an agent programming framework for developers, it does not provide agent generation tools for non-technical personnel; low-code platforms still have an "implicit code barrier"—even with low-code methods, it is necessary to understand process nodes, variables, and conditional logic, resulting in a high learning cost.

[0003] Agent behavior rules are static and lack semantic understanding capabilities. Most agents can only execute predefined processes and cannot dynamically generate execution strategies based on user intent. Task execution lacks self-verification and self-correction capabilities; when agents encounter anomalies during execution, they cannot adjust autonomously and rely on manual intervention. Therefore, there is an urgent need for a truly code-free agent construction solution that is designed for business and product personnel. Summary of the Invention

[0004] The purpose of this invention is to provide a no-code agent construction method and system based on a large language model. By using a large language model and an agent capability semantic model to create no-code agents, it solves the problems of existing agents being unable to make autonomous adjustments when encountering anomalies during execution and relying on manual intervention.

[0005] To solve the above-mentioned technical problems, the present invention is achieved through the following technical solution: This invention relates to a code-free agent construction method based on a large language model, the method of which is as follows: S1: Construct a large language model, an Agent capability semantic model, and a database within the server. Natural language is input, the large language model recognizes the natural language, and the database performs semantic parsing on the natural language to generate a semantic report. The Agent capability semantic model parses the semantic report to generate a no-code Agent structure. S2: The large language model generates an execution plan based on the no-code agent structure. The server initiates the orchestration and scheduling of the execution plan. After the orchestration and scheduling are completed, each task in the orchestration is executed. S3: Manages and monitors the execution process of each task and generates execution result reports in real time; S4: The system verifies and processes the execution results, and re-executes or adjusts the execution of incomplete or abnormal tasks.

[0006] The present invention is further configured such that the large language model recognizes natural language by converting human-understandable natural language into language mathematical vectors that the model can process, and the Agent capability semantic model analyzes, splits and extracts the language mathematical vectors to form a semantic report; The semantic report includes task keywords, task requirements, task association requirements, and task execution time.

[0007] The present invention is further configured such that the system within the server applies structured constraints to the natural language input, guiding the user to express their needs from a semantic dimension. The semantic dimension needs include the agent's role semantics, the agent's target semantics, the agent's capability boundary semantics, and the agent's output semantics.

[0008] The present invention is further configured such that the Agent capability semantic model includes a task intent vector, a set of capability requirements, a tool invocation semantic mapping, and execution constraint rules; The task intent vector is a low-dimensional mathematical vector that can be computed and recognized by a computer, which is expressed in the user's natural language. The set of required capabilities is the set of all capabilities required to complete a task; The tool invocation semantic mapping is to associate the tool invocation intent in the user's natural language requirements with the standardized interface of the tools that the Agent can invoke. The execution constraint rules are a set of all restrictions, rules, and boundaries, and are the core of ensuring the safe, compliant, and controllable execution of tasks.

[0009] The present invention is further configured such that the no-code Agent structure includes Agent identity configuration, a list of callable capabilities, a state management strategy, a context memory strategy, and execution strategy generation rules.

[0010] The present invention is further configured such that the orchestration and scheduling of the execution plan includes: Based on the task objectives and capability configuration, the overall task is broken down into subtasks; The execution order of subtasks is determined based on the dependencies and priority rules between them. Based on the mapping relationship between capabilities and tools, select the corresponding tool or system and generate the calling parameters; Structured referencing and passing of intermediate results generated during the execution of subtasks.

[0011] The present invention is further configured such that managing and monitoring the execution process of each task includes: Real-time collection of the execution progress and result status of each subtask; Record key intermediate results and their associated context information; Monitor for abnormal states, resource anomalies, or task deviations that occur during execution; Adjust the execution path or scheduling strategy based on the current task context and state rules.

[0012] The present invention is further configured such that the system verifies and processes the execution result, including: Verify the completeness of the output results to confirm whether the results related to the task objectives are complete; Judge the consistency between the execution result and the task objective; Identify abnormal situations, failure states, or results that do not meet expectations in the execution results; When the system detects that the execution result does not meet expectations, it will automatically trigger at least one of the following processing methods based on the preset operation strategy or exception handling rules: Re-execute or adjust the execution order of incomplete or abnormal subtasks; Switch to available tools or resources, and adjust the invocation method or parameter configuration; Mark the current task status and initiate a request for user-supplemented information or manual intervention.

[0013] The no-code agent building system based on a large language model includes a processor and a memory, on which computer programs are stored. The processor executes the no-code agent building method based on the large language model.

[0014] The system specifically includes: The natural language input module is used to receive a natural language task description input by the user and convert the natural language task description into a standard input format that the system can process; Agent semantic model is used to perform semantic understanding and intent modeling of natural language task descriptions and to construct a structured semantic representation for agent generation; The no-code agent generation module is used to automatically generate executable agent definitions based on the semantic model without requiring the user to write any code.

[0015] The task execution orchestration module is used to orchestrate the execution flow of the Agent and bind task nodes to system tools; The Agent state management module is used to manage the execution state and context information of the Agent during its operation. The execution verification and feedback module is used to verify the execution results of the Agent and feed the verification results back to the system. The Agent runtime environment module is used to deploy, schedule, execute, and monitor the runtime environment of Agents generated by the no-code Agent generation system.

[0016] The present invention has the following beneficial effects: This invention enables truly code-free agent construction, allowing non-technical personnel to directly create and use agents. The agent execution logic is highly flexible, supporting the autonomous decomposition and execution of complex tasks, and reducing the agentization cost for enterprises.

[0017] Of course, any product implementing this invention does not necessarily need to achieve all of the advantages described above at the same time. Attached Figure Description

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

[0019] Figure 1 This is a schematic diagram illustrating the construction process of a code-free agent construction method based on a large language model.

[0020] Figure 2 A schematic diagram of the components of a code-free agent building system based on a large language model.

[0021] Figure 3 A platform for generating agents. Detailed Implementation

[0022] 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.

[0023] Please see Figure 1-3 This invention is a code-free agent construction method based on a large language model, and the method is as follows: S1: Construct a large language model, an Agent capability semantic model, and a database within the server. Natural language is input, the large language model recognizes the natural language, and the database performs semantic parsing on the natural language to generate a semantic report. The Agent capability semantic model parses the semantic report to generate a no-code Agent structure. S2: The large language model generates an execution plan based on the no-code agent structure. The server initiates the orchestration and scheduling of the execution plan. After the orchestration and scheduling are completed, each task in the orchestration is executed. S3: Manages and monitors the execution process of each task and generates execution result reports in real time; S4: The system verifies and processes the execution results, and re-executes or adjusts the execution of incomplete or abnormal tasks.

[0024] An Agent runtime platform is established, and servers are deployed within the platform. A large language model and an Agent capability semantic model are built within the servers. The core of the large language model's language processing is to first convert natural language into mathematical vectors that machines can compute, then capture the semantics, logic, and contextual relationships of the language through a multi-layered deep learning architecture, and finally output results according to task requirements. The natural language needs to be analyzed by comparing it with language data in the database. The natural language can be an input sentence or a piece of language collected from speech (speech collection requires identification of language type, dialect, etc., and ultimately conversion into Mandarin). The semantic report facilitates the Agent capability semantic model's recognition and generates a no-code Agent structure.

[0025] The capabilities of Agents have been transformed from "fragmented functional modules" into "machine-understandable, matchable, and schedulable semantic assets." This transformation is the core support for large language model-driven Agents (intelligent operation and maintenance Agents, intelligent assistant Agents, etc.) to achieve "task intent-capability matching-automatic execution."

[0026] The Agent structure includes: Agent identity configuration, list of callable capabilities, state management strategy, context memory strategy, and execution strategy generation rules.

[0027] Agent identity configuration is mainly controlled and managed based on which identity (Agent build level).

[0028] The list of callable capabilities defines the scope of regulation and management.

[0029] State management strategy is the core mechanism for unified monitoring, updating, transferring, and safeguarding the agent's own state, task state, and interaction state throughout the entire lifecycle of the agent.

[0030] Context memory strategy is the core mechanism that enables agents to continuously perceive, store, and recall interaction and scenario-related information, thereby achieving coherent decision-making and personalized responses.

[0031] The execution strategy generation rules are the core principle system by which an agent automatically derives action plans that are feasible, logical, and can close the loop based on its own state, task objectives, contextual memory, and constraints.

[0032] Large language models identify natural language by converting human-understandable natural language into mathematical vectors that the model can process. Agent-capable semantic models analyze, decompose, and extract these mathematical vectors to generate semantic reports.

[0033] The core of the Agent Capability Semantic Model is to transform the natural language description of needs / tasks and mathematical logic into structured vectors that can be recognized by the Agent. Then, through three steps of analysis, decomposition, and extraction, the core intent, key parameters, and execution logic are decomposed to support the Agent in accurately generating execution strategies.

[0034] Language vectors: carrying semantic information (intent, constraints, needs) in natural language, are the core of understanding needs; mathematical vectors: carrying numerical values, logical relationships, and calculation rules (parameters, formulas, thresholds), are the core of implementation. The two work together, enabling the agent to understand both natural language needs and mathematical logic for implementation.

[0035] Vector analysis: Identifying the core intent (language), core logic (mathematics), and clarifying the core objective carried by the vector core; Vector decomposition: The overall vector is decomposed into sub-semantic / sub-logical units to break the overall ambiguity; Vector extraction: Extracting key information that can be directly used for agent execution (language: constraints, preferences; mathematics: parameters, formulas).

[0036] The semantic report includes task keywords, task requirements, task association requirements, and task execution time.

[0037] Extract keywords from natural language to identify tasks, task requirements, relationships between tasks, and required execution time to generate a report.

[0038] Structured constraints refer to the mechanism by which a system, through preset rules, format frameworks, and validation logic, transforms the user's natural language input from free and unregulated text into structured information that the system can accurately parse, unambiguously interpret, and directly process. The core purpose is to solve the problems of ambiguity and polysemy in natural language, ensuring that the server can efficiently identify core requirements and key parameters, and avoiding parsing deviations and execution errors.

[0039] Agent role semantics (e.g., analytical, executive, collaborative).

[0040] The agent's target semantics (the expected final state).

[0041] Agent capability boundary semantics (resources that can be used and untouchable restrictions).

[0042] The output semantics of the agent (the form of the result rather than the way it was generated).

[0043] The task intent vector is used to describe the core objective that the agent needs to accomplish, representing the expected task completion state.

[0044] A set of capability requirements describes the types of capabilities needed to complete a task, with each capability corresponding to its importance and dependencies.

[0045] The mapping relationship between capabilities and tools describes which tools or systems can support different capabilities, and is used for tool selection in the subsequent execution phase.

[0046] Execution constraints and rule descriptions describe the limitations imposed on the Agent during its execution.

[0047] The task intent vector is a low-dimensional mathematical vector that can be computed and recognized by a computer, which is expressed in the user's natural language. The set of required capabilities is the set of all capabilities required to complete a task; The tool invocation semantic mapping is to associate the tool invocation intent in the user's natural language requirements with the standardized interface of the tools that the Agent can invoke. The execution constraint rules are a set of all restrictions, rules, and boundaries, and are the core of ensuring the safe, compliant, and controllable execution of tasks.

[0048] The core of orchestration and scheduling is global planning + precise decomposition + reasonable allocation. Subtask decomposition based on task objectives and Agent capability configuration is the first core action in orchestration and scheduling. This involves breaking down complex overall tasks into actionable subtasks and ensuring that each subtask matches the capability boundaries of its corresponding Agent. Ultimately, orderly scheduling achieves the global objective, avoiding task chaos, capability mismatch, and execution inefficiency. The execution order of subtasks is determined based on their dependencies and priority rules.

[0049] In the Agent orchestration and scheduling system, the structured referencing and transmission of intermediate results of subtasks refers to the mechanism of transforming the non-standardized intermediate data output after the execution of subtasks into a unified structured format, and then accurately transferring and traceably referencing it among subsequent subtasks through preset rules.

[0050] The system verifies and processes the execution results, including: verifying the completeness of the output results to confirm whether the results related to the task objective are complete; judging the consistency between the execution results and the task objective; and identifying abnormal situations, failure states, or results that do not meet expectations in the execution results.

[0051] When the system detects that the execution result does not meet expectations, it will automatically trigger at least one of the following processing methods based on the preset operation strategy or exception handling rules: Re-execute or adjust the execution order of incomplete or abnormal subtasks; switch available tools or resources, adjust the invocation method or parameter configuration; mark the current task status and initiate user supplementary information or manual intervention requests.

[0052] The natural language input module (voice input, text input) is used to receive the natural language task description input by the user and convert the natural language task description into a standard input format that the system can process (large language model analysis, Agent capability semantic model parsing to generate a no-code Agent structure). Agent semantic model is used to perform semantic understanding and intent modeling on natural language task descriptions (after analysis of large language models) and to construct a structured (code-free agent structure) semantic representation for agent generation; The no-code Agent generation module (a submodule of the Agent semantic model) is used to automatically generate executable Agent definitions based on the semantic model without requiring users to write any code. The task execution orchestration module is used to orchestrate the execution flow of the Agent and bind task nodes to system tools; The Agent state management module is used to manage the execution state and context information of the Agent during its operation. The execution verification and feedback module is used to verify the execution results of the Agent and feed the verification results back to the system. The Agent runtime environment module is used for deployment, scheduling, execution, and monitoring. The Agent runtime environment is generated by the Agent generation system.

[0053] Implementation Scenario Description In a company's IT operations and maintenance scenario, business personnel want to build an intelligent operations and maintenance agent to complete the following tasks: Regularly check the server's operating status; Automatically analyze the cause when an anomaly is detected; Generate an operation and maintenance report and notify relevant personnel.

[0054] The business personnel in question lack programming skills and are unable to write scripts or configure processes.

[0055] Agent construction process Step S101: Natural Language Agent Requirement Input. The user inputs the following Agent requirement description in natural language: Create an operations and maintenance agent to check the server's CPU, memory, and disk status daily; If an anomaly is detected, analyze the possible causes and generate an operations and maintenance report to send to the administrator.

[0056] The input does not contain any code, scripts, or process configuration content.

[0057] Step S102: Agent Capability Semantic Analysis and Modeling The system calls a large language model to perform semantic parsing of natural language requirements.

[0058] Construct a semantic model of agent capabilities, agent roles, and operation and maintenance monitoring agents; Objectives: System status monitoring, anomaly analysis, and report generation.

[0059] l Capability requirements set: System status query capability; anomaly detection capability; text report generation capability; Execution constraints: Execution cycle is daily; Anomaly condition is resource utilization exceeding a preset threshold.

[0060] The semantic model is stored in the form of structured semantic data, rather than in the form of processes or code.

[0061] Step S103: Automatic generation of no-code agent structure Based on the Agent capability semantic model, the system automatically generates a no-code Agent structure, including: Agent identity configuration; mapping relationships for invoked system tools; context memory management strategy; task execution strategy generation rules.

[0062] The Agent structure does not expose any editable code or flowcharts to the user.

[0063] Agent execution process Step S104: Execution orchestration and scheduling based on task semantics. During Agent execution, the large language model dynamically generates an execution plan based on the current task semantics, including: Obtain server resource usage status; perform anomaly detection on the obtained data; if anomalies are found, analyze the cause of the anomalies; generate an operation and maintenance report; and notify the administrator.

[0064] The above execution steps are not pre-configured processes, but are generated by the model at runtime based on semantics.

[0065] Step S105: Agent execution process management and status awareness The agent is aware of the execution status in real time during execution, including: Check if the tool was successfully invoked; if the data was retrieved completely; and if any abnormal data exists.

[0066] When a server fails to acquire data, the Agent automatically adjusts its execution strategy and calls a backup interface to complete the data acquisition.

[0067] Step S106: Verify execution results and adjust operating strategy After the task is completed, the agent performs semantic validation on the generated operation and maintenance report, including: Does the report content cover the original target task? Is the anomaly analysis consistent with the monitoring data? Does the report format conform to the preset specifications?

[0068] When verification fails, the Agent automatically triggers a re-analysis process, corrects the report content, and outputs it again.

[0069] In the description of this specification, references to terms such as "an embodiment," "example," "specific example," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of the invention. In this specification, illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples.

[0070] The preferred embodiments of the present invention disclosed above are merely illustrative of the invention. These preferred embodiments do not exhaustively describe all details, nor do they limit the invention to the specific implementations described. Clearly, many modifications and variations can be made based on the content of this specification. This specification selects and specifically describes these embodiments to better explain the principles and practical applications of the invention, thereby enabling those skilled in the art to better understand and utilize the invention. The invention is limited only by the claims and their full scope and equivalents.

Claims

1. A no-code Agent construction method based on a large language model, characterized in that, The method is as follows: S1: Construct a large language model, an Agent capability semantic model, and a database within the server. Natural language is input, the large language model recognizes the natural language, and the database performs semantic parsing on the natural language to generate a semantic report. The Agent capability semantic model parses the semantic report to generate a no-code Agent structure. S2: The large language model generates an execution plan based on the no-code agent structure. The server initiates the orchestration and scheduling of the execution plan. After the orchestration and scheduling are completed, each task in the orchestration is executed. S3: Manages and monitors the execution process of each task and generates execution result reports in real time; S4: The system verifies and processes the execution results, and re-executes or adjusts the execution of incomplete or abnormal tasks.

2. The large language model-based no-code Agent construction method according to claim 1, characterized in that, The large language model identifies natural language by converting human-understandable natural language into linguistic mathematical vectors that the model can process. The Agent-capable semantic model analyzes, splits, and extracts these linguistic mathematical vectors to generate a semantic report. The semantic report includes task keywords, task requirements, task association requirements, and task execution time.

3. The large language model-based no-code Agent construction method according to claim 1, characterized in that, The system within the server imposes structured constraints on natural language input, guiding users to express their needs from a semantic dimension. These semantic dimension needs include the agent's role semantics, the agent's target semantics, the agent's capability boundary semantics, and the agent's output semantics.

4. The large language model-based no-code Agent construction method according to claim 1, characterized in that, The Agent capability semantic model includes a task intent vector, a set of capability requirements, a tool invocation semantic mapping, and execution constraint rules. The task intent vector is a low-dimensional mathematical vector that can be computed and recognized by a computer, which is expressed in the user's natural language. The set of required capabilities is the set of all capabilities required to complete a task; The tool invocation semantic mapping is to associate the tool invocation intent in the user's natural language requirements with the standardized interface of the tools that the Agent can invoke. The execution constraint rules are a set of all restrictions, rules, and boundaries, and are the core of ensuring the safe, compliant, and controllable execution of tasks.

5. The method for constructing a code-free agent based on a large language model according to claim 4, characterized in that, The no-code agent structure includes agent identity configuration, a list of callable capabilities, a state management strategy, a context memory strategy, and execution strategy generation rules.

6. The method for constructing a code-free agent based on a large language model according to claim 1, characterized in that, The orchestration and scheduling of the execution plan includes: Based on the task objectives and capability configuration, the overall task is broken down into subtasks; The execution order of subtasks is determined based on the dependencies and priority rules between them. Based on the mapping relationship between capabilities and tools, select the corresponding tool or system and generate the calling parameters; Structured referencing and passing of intermediate results generated during the execution of subtasks.

7. The method for constructing a code-free agent based on a large language model according to claim 1, characterized in that, Managing and monitoring the execution process of each task includes: Real-time collection of the execution progress and result status of each subtask; Record key intermediate results and their associated context information; Monitor for abnormal states, resource anomalies, or task deviations that occur during execution; Adjust the execution path or scheduling strategy based on the current task context and state rules.

8. The method for constructing a code-free agent based on a large language model according to claim 1, characterized in that, The system verifies and processes the execution results, including: Verify the completeness of the output results to confirm whether the results related to the task objectives are complete; Judge the consistency between the execution result and the task objective; Identify abnormal situations, failure states, or results that do not meet expectations in the execution results; When the system detects that the execution result does not meet expectations, it will automatically trigger at least one of the following processing methods based on the preset operation strategy or exception handling rules: Re-execute or adjust the execution order of incomplete or abnormal subtasks; Switch to available tools or resources, and adjust the invocation method or parameter configuration; Mark the current task status and initiate a request for user-supplemented information or manual intervention.

9. A code-free agent construction system based on a large language model, characterized in that, It includes a processor and a memory, wherein the memory stores a computer program, and the processor executes the steps of the code-free agent construction method based on a large language model as described in any one of claims 1-8.

10. The code-free agent construction system based on a large language model according to claim 9, characterized in that, Specifically, it includes: The natural language input module is used to receive a natural language task description input by the user and convert the natural language task description into a standard input format that the system can process; Agent Capability Semantic Model: This model is used to perform semantic understanding and intent modeling of natural language task descriptions, and to construct a structured semantic representation for Agent generation. The task execution orchestration module is used to orchestrate the execution flow of the Agent and bind task nodes to system tools; The Agent state management module is used to manage the execution state and context information of the Agent during its operation. The execution verification and feedback module is used to verify the execution results of the Agent and feed the verification results back to the system.

Images