Application development method based on large model technology

Abstract

The invention relates to the technical field of computers, and discloses an application development method based on a large model technology, and the method comprises the steps: 1, carrying out the demand analysis, and converting a fuzzy business description into an executable technical scheme through natural language understanding and a structured modeling technology; 2, carrying out architecture design and planning, and constructing a code-free and low-code dual-mode collaborative architecture; 3, establishing a visual arrangement engine, and establishing a dual-mode development interface of a code-free development mode and a low-code development mode; step 4, aiming at different requirements of a code-free scene and a low-code scene, a dynamic adaptation strategy is adopted, and differentiated resource management of lightweight adaptation and elastic expansion is carried out; and step 5, performing field adaptation, and obtaining the industry exclusive capability according to the general model and the field knowledge through code-free rapid adaptation and low-code deep customization. By means of the scheme, the development threshold can be lowered, the efficiency can be improved, and the accuracy of cross-industry application is improved.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and more specifically to an application development method based on large model technology. Background Technology

[0002] Current application development solutions based on large-model technology mainly focus on several directions. In terms of multi-model integration and logic orchestration, various AI models such as large language models, visual models, and reinforcement learning models are integrated, and the logical flow is orchestrated to achieve intelligent application development in complex scenarios. In the field of low-code / no-code platform development, existing solutions encapsulate large models into visual components or APIs, enabling business users to develop independently through low-code platforms. Technical solutions in the area of ​​model training and optimization mainly optimize the model training process through techniques such as data rearrangement, instruction distribution, and knowledge distillation. However, the above existing technologies have the following problems: Development threshold and efficiency issues: Although existing low-code platforms have lowered the technical threshold, complex scenarios still rely on professional development capabilities (such as model fine-tuning and component adaptation), and compatibility issues need to be resolved when integrating multiple models, resulting in high debugging costs.

[0003] Insufficient model dependency and generality: It relies on third-party pre-trained models or specific domain data, has weak cross-domain transfer capabilities, and is difficult to quickly adapt to diverse business needs; vertical domain solutions are usually limited to a single scenario and lack a general development framework.

[0004] Resource and cost issues: Training and deploying high-performance models requires a large amount of computing resources, which is difficult for small and medium-sized enterprises to afford; some solutions rely on high-quality labeled data or professional knowledge graphs, which have high upfront costs.

[0005] Flexibility and customization limitations: Visual components and predefined processes are difficult to meet the needs of complex business logic, such as dynamic strategy adjustment and deep multimodal fusion, requiring additional code development or model reconstruction. Summary of the Invention

[0006] This invention provides an application development method based on large model technology, which enables the construction, deployment, and optimization of low-code / no-code AI applications through large models, and is applicable to intelligent application development scenarios in multiple fields.

[0007] Therefore, the present invention provides the following technical solution: An application development method based on large model technology, the method comprising: Step 1: Conduct requirements analysis, and transform vague business descriptions into executable technical solutions through natural language understanding and structured modeling techniques. Step 2: Perform architecture design and planning, and build a dual-mode collaborative architecture of no-code and low-code; Step 3: Build a visual orchestration engine and create a dual-mode development interface for no-code and low-code development. Step 4: For the different needs of no-code and low-code scenarios, adopt a dynamic adaptation strategy to carry out differentiated resource management with lightweight adaptation and elastic expansion. Step 5: Perform domain adaptation. Through no-code rapid adaptation and low-code deep customization, industry-specific capabilities are obtained based on general models and domain knowledge.

[0008] Optionally, step 1 includes: Step 11: Input and extract multimodal requirements. Business personnel input requirements in a multimodal manner using natural language and visual prototypes. The system uses large model semantic parsing technology to extract key business elements. Step 12: Perform dual-mode demand processing, design differentiated processing flows for different user groups, and use a demand conversion engine to achieve cross-mode demand docking.

[0009] Optionally, in step 12, firstly, a rapid no-code requirement transformation is performed. This involves using large-scale model semantic parsing and visual interaction technology to achieve zero-code structuring of business requirements, including natural language requirement parsing and zero-code indicator mapping. During natural language requirement parsing, a three-level processing flow of intent recognition, template matching, and element extraction is constructed. Ambiguous requirements are clarified through multi-round dialogue. Based on keyword matching, three most relevant templates are recommended from the industry template library, generating an interactive requirement confirmation form. Business personnel can adjust details by checking boxes and dragging, and after confirmation, the structured input required for no-code development is automatically generated. During zero-code indicator mapping, an abstract target is transformed into monitorable indicators through a business target quantification engine and a visual configuration interface. The Analytic Hierarchy Process (AHP) is used to decompose macro-level targets, and slider and drop-down menu components support dynamic adjustment of indicator thresholds. The system provides real-time prompts regarding the impact of configuration and generates a path diagram for indicator achievement. Secondly, it performs in-depth definition of low-code requirements, providing developers with tools for fine-grained configuration of technical parameters and layered modeling of complex requirements. This includes technical parameter configuration and complex requirement decomposition. When configuring technical parameters, it constructs a three-dimensional configuration system of model performance, system resources, and security policies, allowing for customization of domain-specific performance indicators and association with model optimization parameters. It also provides visualized configuration of API call frequency, data storage cycle, and system-level parameters, and uses a parameter conflict detection engine to automatically identify configuration contradictions. When decomposing complex requirements, it employs process layering and node expansion technology to break down complex requirements into a three-level process of data access, model processing, and result output.

[0010] Optionally, in step 2, the no-code and low-code dual-mode collaborative architecture includes no-code dedicated components and low-code extension components. The no-code dedicated components encapsulate technical complexity within the components through a dual engine of visual drag-and-drop and parameter configuration. Each no-code dedicated component corresponds to a complete business unit. The low-code extension components provide limited code intervention interfaces based on standardized capabilities to meet medium complexity requirements. A no-code component interaction specification is established between the no-code dedicated components and the low-code extension components to establish an interaction system with standardized data flow, visualized logic control, and automated exception handling, ensuring efficient and stable collaboration between components.

[0011] Optionally, in step 2, when designing the architecture of the no-code dedicated component, firstly, multiple composite components are pre-encapsulated, with each composite component containing complete business logic; then, a business configuration interface is provided, hiding technical parameters and offering configuration options from a business perspective; when designing the architecture of the low-code extension component, firstly, a programmable interface is opened to support the writing of complex logic; then, parameterized adjustment is performed, exposing the core parameters of the model through sliders and drop-down menus.

[0012] Optionally, in step 3, the visual orchestration engine includes a process parser and a resource scheduler. The process parser converts the component processes dragged and dropped by the user into machine-executable logic diagrams, supporting the parsing of conditional branches, loops, and parallel tasks. The resource scheduler dynamically allocates computing power according to the complexity of the process and monitors resource usage. The no-code development mode allows business personnel to independently build applications by setting up templated processes and zero-code logic configuration. The low-code development mode provides developers with a hybrid development environment of visual orchestration and code enhancement through code enhancement and advanced logic control, balancing efficiency and flexibility.

[0013] Optionally, in step 4, the lightweight adaptation for no-code scenarios ensures process operation under resource-constrained conditions through model optimization and monitoring alerts, including automatic model selection and no-code monitoring alerts; the elastic expansion for low-code scenarios supports developers to customize resource allocation and deep model optimization to meet the requirements of high concurrency and high precision, including dynamic allocation of computing power and deep model optimization.

[0014] Optionally, in step 5, the no-code rapid adaptation imports domain knowledge in a visual manner, triggers lightweight fine-tuning, and quickly improves the model's performance in specific scenarios, including visual knowledge import and zero-code fine-tuning; the low-code deep customization achieves deep integration of complex domain knowledge and the model through code-connected knowledge graphs and custom rule engines, including code-level knowledge fusion and deep model fine-tuning.

[0015] An application development apparatus based on large model technology, the apparatus comprising: The requirements analysis unit performs requirements analysis, transforming vague business descriptions into executable technical solutions through natural language understanding and structured modeling techniques. The architecture design unit is responsible for architecture design and planning, and building a collaborative architecture in both no-code and low-code modes. The engine building unit builds a visual orchestration engine and establishes a dual-mode development interface for both no-code and low-code development modes. The dynamic adaptation unit adopts a dynamic adaptation strategy to manage differentiated resources for lightweight adaptation and elastic scaling, targeting the different needs of no-code and low-code scenarios. The domain adaptation unit performs domain adaptation, enabling rapid no-code adaptation and deep low-code customization to obtain industry-specific capabilities based on general models and domain knowledge.

[0016] A computer-readable storage medium having a computer program stored thereon, the computer program being executed by a processor to perform the steps of the application development method based on large model technology.

[0017] The application development method based on large-scale model technology provided by this invention is an application development method based on large-scale model (LLM) and related artificial intelligence technologies. In particular, it involves a technical solution for building, deploying and optimizing low-code / no-code AI applications through large-scale models, which is applicable to intelligent application development scenarios in multiple fields such as finance, healthcare, industry, and e-commerce. This invention encapsulates Large Language Models (LLM), multimodal models, and domain-specific models into standardized, pluggable components, supporting parameter configuration, functional expansion, and version management, thus resolving multi-model compatibility issues. It designs a flowchart-based visual development interface, allowing users to build AI application logic by dragging and dropping components and configuring parameters. It includes predefined business process templates (such as intelligent customer service dialogue flows and data analysis pipelines) to achieve "zero-code" or "light-code" development. The invention features an automatic model selection algorithm that dynamically matches the optimal model combination based on input data characteristics and business scenario requirements. Combined with computing resource monitoring technology, it achieves dynamic resource allocation and load balancing across cloud and edge computing. It supports injecting domain knowledge into large models through knowledge graphs and industry rule bases, and provides domain adaptation tools for general models (such as lightweight fine-tuning frameworks and prompt engineering templates) to improve the accuracy of cross-industry applications. Compared with existing technologies, this invention has the following technical advantages: Lowering the development threshold and improving efficiency: It provides a standardized and modular framework for developing large model applications, supporting the rapid assembly of model components through low-code / no-code methods, reducing reliance on professional technologies and debugging costs.

[0018] Enhance versatility and cross-domain adaptability: Build an extensible model integration architecture to support seamless access and dynamic collaboration of multiple types of large models (such as LLM and multimodal models), and improve application adaptability across industries and scenarios.

[0019] Optimize resource utilization and cost control: Reduce computing power and data labeling costs through lightweight model design, automated resource scheduling and efficient data utilization technologies to meet the development needs of enterprises of different sizes.

[0020] Enhance flexibility and customization capabilities: Provides open interfaces and a configurable strategy engine to support custom orchestration of complex business logic and deep customization of model functions, adapting to diverse intelligent development needs. Attached Figure Description

[0021] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the embodiments will be briefly described below. Obviously, the drawings described below are merely some embodiments of the present invention, and those skilled in the art can obtain other drawings based on these drawings without creative effort.

[0022] Figure 1 This is a flowchart of an application development method based on large model technology in a specific embodiment of the present invention; Figure 2 This is a schematic diagram of the structure of an application development device based on large model technology in a specific embodiment of the present invention. Detailed Implementation

[0023] The specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are for illustration and explanation only and are not intended to limit the present invention.

[0024] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. 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 should fall within the scope of protection of the present invention.

[0025] like Figure 1 The diagram shown is a flowchart of an application development method based on large model technology in an embodiment of the present invention, including the following steps: Step 101: Conduct requirements analysis and transform the fuzzy business description into an executable technical solution through natural language understanding and structured modeling techniques.

[0026] Step 11 involves inputting and extracting multimodal requirements. Business personnel input requirements using multimodal methods such as natural language and visual prototypes. The system then uses large-scale model semantic parsing technology to extract key business elements, such as parsing entities like "complaint type" and "processing flow" from "designing an intelligent customer service system," and generating a requirement specification document containing quantitative indicators, requiring a requirement coverage rate of ≥95%. This stage is particularly adapted to local scenarios. For example, in the manufacturing industry, it supports parsing industrial protocol (Modbus / TCP) requirements, embedding "one-stop online service" process templates within the scenario, and automatically recognizing terms such as "certificate and license processing" to ensure the completeness and industry-specific nature of the requirements.

[0027] Step 22 involves dual-mode requirement processing, designing differentiated processing flows for different user groups. The core of this process relies on a "requirement conversion engine" to achieve cross-mode requirement integration, specifically including: First, rapid no-code requirement transformation is achieved using a "large-scale model semantic parsing + visual interaction" technology to realize zero-code structuring of business requirements, solving the problem of requirement expression and transformation for non-technical personnel. First, natural language requirement parsing is performed: a three-level processing flow of "intent recognition - template matching - element extraction" is constructed. Ambiguous requirements are clarified through multi-round dialogue (e.g., inquiring about the target industry of the customer service system); based on keyword matching, three most relevant templates are recommended from the industry template library (with process previews and configuration examples); an interactive requirement confirmation form is generated, allowing business personnel to adjust details by checking boxes and dragging, and automatically generating the structured input required for no-code development after confirmation. Second, zero-code indicator mapping is performed: through a "business goal quantification engine + visual configuration interface," abstract goals are transformed into monitorable indicators. The Analytic Hierarchy Process (AHP) is used to break down macro goals (e.g., breaking down "improving customer satisfaction" into sub-indicators such as "work order response time," and providing industry benchmark values); components such as sliders and drop-down menus support dynamic adjustment of indicator thresholds, with the system providing real-time prompts on the impact of configuration and generating a path diagram for indicator achievement.

[0028] Secondly, we provide in-depth low-code requirement definition: We offer developers tools for "refined configuration of technical parameters + layered modeling of complex requirements," solving the problem of accurately describing professional requirements such as multi-system integration and high-performance computing. First, we configure technical parameters: We construct a three-dimensional configuration system of "model performance - system resources - security strategy." Customizable domain-specific performance indicators (such as "fraud detection accuracy > 99%" and "inference latency < 200ms" in financial risk control scenarios) are linked to model optimization parameters. We provide visualized configuration of system-level parameters such as API call frequency and data storage cycle, and integrate a parameter conflict detection engine to automatically identify configuration contradictions (such as conflicts between strong encryption and performance in high-concurrency scenarios). Second, we decompose complex requirements: Using "layered process + node expansion" technology, we decompose complex requirements into a three-level process of "data access - model processing - result output." Taking an industrial quality inspection system as an example, the access layer supports data reading from industrial cameras and sensors, the processing layer can insert custom algorithms, and the output layer supports quality inspection report generation and PLC instruction output. Each node provides a standardized development interface, supporting configuration of data flow mapping between nodes through a low-code interface.

[0029] Specifically, when rapidly transforming requirements without code, the "Large Model Semantic Parsing + Visual Interaction" technology is adopted to achieve zero-code structuring of business requirements, focusing on solving the problem of requirement expression and transformation for non-technical personnel. This includes natural language requirement parsing and zero-code indicator mapping. In natural language requirement parsing, firstly, business intent is identified by parsing the user's natural language requirement (e.g., "Make a customer complaint system") using the large model, automatically matching the "intelligent customer service" template; secondly, requirement elements are extracted, identifying key business elements (e.g., "complaint type" and "processing flow"), generating a visual requirement confirmation form; thirdly, natural language requirement parsing leverages the contextual understanding capabilities of the Large Language Model (LLM) to construct a three-level processing flow of "intent recognition - template matching - element extraction": multi-round dialogue intent clarification; when the user inputs a vague requirement (e.g., "I want a customer service system"), the system generates follow-up questions through the large model ("Is this for e-commerce,..."). Is it a financial or customer service scenario? This process gradually clarifies the business scenario; intelligent matching of industry templates utilizes a keyword extraction module to analyze core needs (such as "customer service" and "work order processing"), and recommends the three most relevant templates from the industry template library (such as "e-commerce customer service template," "financial customer service template," and "intelligent work order template") through a template matching algorithm. Each template includes a process preview diagram and typical configuration examples; visual confirmation of requirement elements generates an interactive confirmation form containing "process framework," "configurable parameters," and "expected output." Business personnel can adjust details (such as modifying the node order of the "work order processing process") by checking boxes and dragging. After confirmation, the structured input required for no-code development is automatically generated.

[0030] When mapping metrics with zero code, the business metrics are visualized first, transforming "improving processing efficiency" into "work order response time < 5 minutes," with the target configured visually via a progress bar. Then, through a "business target quantification engine + visual configuration interface," abstract business targets are transformed into monitorable technical metrics: the target decomposition algorithm uses the Analytic Hierarchy Process (AHP) to break down macro-level targets such as "improving customer satisfaction" into quantifiable sub-metrics such as "work order response time," "automatic resolution rate," and "manual transfer rate," with each sub-metric providing an industry benchmark value (e.g., the median work order response time in the e-commerce industry is 3 minutes); the interactive configuration interface provides components such as sliders and drop-down menus, supporting business personnel to dynamically adjust metric thresholds (e.g., when increasing the "automatic resolution rate" target from 70% to 80%, the system provides real-time prompts to increase the number of knowledge base entries), and generates a metric achievement path diagram (displaying the contribution of each node to the target under the current configuration).

[0031] When defining low-code requirements in depth, the low-code requirements definition provides developers with tools for "fine-grained configuration of technical parameters + layered modeling of complex requirements," solving the problem of accurately describing professional requirements such as multi-system integration and high-performance computing. The main steps include configuring technical parameters and breaking down complex requirements. When configuring technical parameters, firstly, define custom model evaluation metrics (such as "false positive rate <0.5%" and "false negative rate <1%" for financial risk control models); then, configure system-level parameters, such as API call frequency limits and data storage cycles; finally, construct a three-dimensional configuration system of "model performance - system resources - security strategy," supporting developers to define domain-specific technical specifications: model performance metrics are customized for financial risk control scenarios, and metrics such as "fraud detection accuracy >99%" and "model inference latency <200ms" can be configured, along with model optimization parameters (such as selecting INT8 quantization to reduce latency, or enabling model distillation to improve accuracy). System-level parameter visualization management allows for configuring API call strategies (such as "limiting calls to the same user IP to 50 per minute") and data storage strategies (such as "encrypting and storing sensitive data for 180 days") in tabular form. It also integrates a parameter conflict detection engine to automatically identify and prompt configuration contradictions (such as "enabling strong encryption simultaneously in high-concurrency scenarios may lead to performance bottlenecks").

[0032] When decomposing complex requirements, a three-tiered process model of "data access - model processing - result output" is adopted, supporting coded node expansion. Employing a "process layering + node expansion" technology, complex requirements such as multimodal fusion and distributed computing are transformed into a developable technical architecture. The three-tiered process model breaks down the "industrial quality inspection system" requirements into: Access layer: industrial camera image acquisition (supporting Modbus / TCP protocol access), sensor data reading; Processing layer: defect identification model (supporting PyTorch / TensorFlow framework), dimensional measurement algorithm (custom C++ code can be inserted); Output layer: quality inspection report generation (supporting PDF / Excel format), PLC control command output. Coded node interface design: Each process node provides a standardized development interface (e.g., processing layer nodes support "model input / output data format definition" and "computing resource requirement declaration"). Developers can configure data flow between nodes through a low-code interface (e.g., the RGB data output by the "image preprocessing node" is automatically mapped to the "input_tensor" parameter of the "defect identification model").

[0033] Step 102 involves architecture design and planning. The system will construct a dual-mode collaborative architecture of no-code and low-code, organically combining basic capability sharing with advanced function extensions. The no-code module implements component drag-and-drop based on a visual orchestration engine, while the low-code module supports code injection and complex logic customization. Both share a model component library through standardized interfaces. Domestic solutions will be prioritized for the technology stack selection, such as Baidu Wenxin Large Model and Alibaba OceanBase database. The architecture must comply with local standards such as the Financial Information Security Protection Standard 2.0. The output system architecture design document must have a compliance rate of ≥98% to establish a compliance foundation for subsequent development.

[0034] The no-code, dedicated components utilize a dual-engine approach of visual drag-and-drop and parameter configuration to encapsulate technical complexity within the components, enabling "AI application development even with zero technical background." Each component corresponds to a complete business unit; for example, the "Intelligent Customer Service Dialogue Block" integrates core NLP capabilities (intent recognition, entity extraction), process control (dialogue turn limits), and output adaptation (text / image reply switching). Business personnel don't need to write a single line of code; they can simply combine components like building blocks to construct customer service systems, reporting tools, and other applications. After dragging and dropping components, the system simulates the process in real time. For instance, inputting the test question "When will my order arrive?" immediately displays how the component parses the intent (identifying it as "logistics query") and calls the knowledge base (returning a link to query the logistics tracking number), helping users intuitively verify the configuration's effectiveness.

[0035] When designing a no-code architecture, the first step is to pre-package composite components such as an "intelligent customer service dialogue block," a "data report generator," and a "work order processing engine," each with built-in complete business logic. For example, the "intelligent customer service dialogue block" integrates intent recognition, knowledge base retrieval, and human referral logic. Users can simply drag and drop it onto the canvas to generate a complete workflow including "welcome message - problem classification - automatic reply - work order creation." Then, a business-oriented configuration interface is provided, hiding technical parameters (such as the model temperature parameter) and offering configuration options from a business perspective. Taking the customer service component as an example, users can set "user satisfaction thresholds" (e.g., triggering human intervention below 70 points) and "work order priority rules" (marking inquiries containing the keyword "refund" as high priority) through a visual panel, without needing to understand the model's internal mechanisms.

[0036] The low-code extension components, building upon standardized capabilities, provide a "limited code intervention" interface to meet medium-complexity needs. The "lightweight" and "secure" nature of code injection allows for code injection at specific nodes (such as data preprocessing or model output post-processing), but restricts the scope of code execution (only allowing calls to specified APIs to avoid system-level risks). For example, in an e-commerce reporting component, developers can inject Python code to clean order data (removing invalid fields), but cannot access the underlying database. The "visualized" and "intelligent" parameter tuning, in addition to manual parameter adjustment, allows the system to recommend optimal parameters based on historical configuration data using AI (e.g., the default number of customer service dialogue rounds is set to 5, based on industry average dialogue depth), reducing developer debugging costs.

[0037] When designing a low-code architecture, firstly, an entry point for Python / JavaScript code injection is provided to support the writing of complex logic. For example, in a financial risk control scenario, developers can inject a custom risk scoring formula: "Credit Score = Base Score (600) + Asset Score (Deposit × 0.01) - Liability Score (Loan × 0.02)", to achieve personalized modification of the pre-trained model. Then, parameter adjustments are made, exposing the core parameters of the model through sliders and drop-down menus, such as "temperature" (controlling output randomness) and "top_p" (kernel sampling threshold) of LLM. Developers can fine-tune these parameters through the low-code interface to balance the creativity and accuracy of the generated content (e.g., setting temperature=0.8 in customer service scenarios to ensure flexible responses; setting temperature=0.3 in reporting scenarios to ensure data accuracy).

[0038] Establish no-code component interaction specifications, namely, establish an interaction system of "standardized data flow, visualized logic control, and automated exception handling" to ensure efficient and stable collaboration between components. This includes an interaction foundation layer, an interaction mode layer, and an interaction guarantee layer. The interaction foundation layer defines data interface standards (such as input field naming conventions: user input is uniformly "user_input", and model output is uniformly "model_output") and communication protocols (asynchronous calls based on HTTP / HTTPS, supporting streaming responses, suitable for long text generation scenarios).

[0039] The interaction mode layer includes zero-code data flow and low-code parameter adjustment. Zero-code data flow achieves automatic data mapping through a three-level component chain of "data source-processing-target." First, automatic field mapping ensures automatic matching of data interfaces between components (e.g., the "user input" field is automatically connected to the "text_input" parameter of the "intent recognition model"). For example, based on component metadata (e.g., the "user input component" is labeled as "text type," and the "intent recognition component" requires "text type" input), the system automatically completes field connections, avoiding manual configuration errors. When a user drags and drops the "Excel data import component" and the "report generation component," the system recognizes the "date" and "amount" fields in Excel and automatically maps them to the X and Y axes of the report. Then, a visual data flow diagram displays the real-time data flow path between components, allowing no-code users to understand the process logic. For example, on the visualization canvas, arrows dynamically show the direction of data flow, and node colors indicate status (green: normal, yellow: warning, red: fault). Clicking on a node allows viewing real-time data content (e.g., the cleaned data list output by the "data cleaning component").

[0040] Low-code parameter adjustment combines "AI parameter recommendation" and a "code snippet library" to provide intelligent assistance. For example, when adjusting the "temperature" of LLM, the system suggests that "increasing this value will increase response diversity, suitable for creative scenarios; decreasing this value will improve response accuracy, suitable for customer service scenarios." When adjusting low-code parameters, AI parameter recommendations are based on historical project data (e.g., in 100 customer service systems, 90% set the "maximum number of dialogue rounds" to 5-8 rounds) and the current business scenario (e.g., the complexity of e-commerce customer service inquiries), recommending default parameters. The code snippet library includes 50+ commonly used scripts (such as data cleaning scripts and API authentication codes), supporting one-click insertion. For example, when connecting to the WeChat Work API, simply select the "WeChat Work Message Push" template to automatically generate OAuth2.0 authentication code; developers only need to fill in the AppID and Secret.

[0041] The interaction protection layer has built-in error circuit breaker (ECB) and retry mechanism (RM). If a component times out (does not respond for more than 5 seconds), the circuit breaker will be automatically triggered and a backup component will be switched. Failed requests will be automatically retried 3 times (with an interval of 1 second) to ensure the robustness of the process.

[0042] Step 103: Build a visual orchestration engine and create a dual-mode development interface for no-code and low-code development.

[0043] The visual orchestration engine serves as a "visual bridge" connecting user needs with technical implementation. It covers 80% of general scenarios and 20% of complex scenarios through "rapid deployment in no-code mode" and "deep customization in low-code mode." The visual orchestration engine includes a process parser and a resource scheduler. The process parser converts user-drag-and-drop component flows into machine-executable logic diagrams, supporting the parsing of conditional branches (if-else), loops (for / while), and parallel tasks (concurrent calls to multiple models). The resource scheduler dynamically allocates computing power based on process complexity (e.g., no-code flows use shared GPU resources, while low-code flows support dedicated GPU configurations) and monitors resource usage (GPU memory, CPU utilization).

[0044] The no-code development model focuses on "rapid deployment in simple scenarios," enabling business users to independently build applications through "template-driven + logic visualization." Specifically, it includes: Step 1a: Build a templated process.

[0045] Industry Template Library: Over 100 predefined templates covering 8 major sectors including e-commerce, finance, and education. Each template includes a complete workflow and configuration parameters. For example, the "E-commerce Customer Service Template" includes 5 nodes: "Welcome Message - Intent Recognition - Knowledge Base Response - Work Order Generation - Satisfaction Survey," with preset trigger rules for keywords such as "refund" and "logistics."

[0046] Intelligent recommendation engine: When users input business keywords (such as "employee attendance"), the engine uses NLP to analyze the requirements and matches the three most relevant templates (such as "attendance approval template", "attendance report template", and "attendance exception handling template"). It supports previewing the template process and configuration interface.

[0047] Template-based workflow construction significantly shortens the development cycle through "keyword matching + scenario-based recommendation." The templates are configurable and extensible; they are not fixed, and users can modify the node order and add custom components. For example, in the "e-commerce customer service template," a "user authentication component" can be inserted to provide differentiated services for members and non-members. Based on industry best practices, the templates are derived from real-world projects at Thousandsands. For instance, the financial customer service template includes a "compliance script verification" node, and the medical template includes "symptom standardization mapping" logic to ensure the process complies with industry standards.

[0048] Step 1b: Configure the logic with zero code.

[0049] Conditional branch visualization: Configure business rules (such as "Automatically transfer to human customer service if a user complains") via the "If-Then" visualization button. Loop process presets: Built-in loop templates such as "Daily data synchronization" and "Weekly report generation" support timed triggering configuration. Zero-code logic configuration transforms abstract business rules into an intuitive graphical interface, supporting the no-code implementation of complex logic.

[0050] "Multi-dimensional support" for condition configuration: In addition to keyword matching, it supports condition types such as numerical comparison (e.g., "order amount > 1000 yuan"), time judgment (e.g., "working days 9:00-18:00"), and data status (e.g., "report generation completed").

[0051] "Visual monitoring" of the loop process: After configuring the "Daily Data Synchronization" task, the system automatically generates monitoring charts to display the historical synchronization success rate and time consumption, and supports manual retry of abnormal tasks.

[0052] Low-code development provides developers with a hybrid development environment that combines visual orchestration with code enhancement, balancing efficiency and flexibility. Specifically, it includes: Step 2a, code enhancement features, allows developers to perform "precise code injection" at key nodes, enabling functionalities that cannot be covered by standardized components.

[0053] Personalized data processing: For example, in medical reporting scenarios, Python code can be injected to convert patient temperature data into "fever level" (37.5℃-38℃ is low fever, >38℃ is high fever) and generate corresponding nursing suggestions.

[0054] "Visual debugging" for API integration: When configuring the API, online test calls are supported (enter test parameters and view the return results in real time) to ensure interface connectivity.

[0055] Custom function writing: Insert Python code snippets into process nodes to implement functions such as data processing and logical judgment. For example, in a financial risk control process, insert the code "if credit score < 600: reject loan application" to achieve personalized decision-making.

[0056] Deep API Integration: Configure OAuth2.0 authentication and Webhook callbacks through a low-code interface, supporting seamless integration with internal enterprise systems (ERP, CRM) and third-party services (Alipay, WeChat Pay). For example, when configuring the "WeChat Enterprise Notification Component," simply enter the CorpID and AgentID, and the system will automatically generate the API call code.

[0057] Step 2b, advanced logic control.

[0058] Parallel workflow design: Supports concurrent calls to multiple models (such as simultaneous execution of text sentiment analysis and entity recognition), and outputs results through "merging strategies" (such as intersection and union) to improve processing efficiency (30% faster than serial processing).

[0059] Error handling script: Write custom error handling logic, such as "when the model call fails, log and trigger the backup model" and "if it still fails after 3 retries, send an alert to the administrator's email".

[0060] Advanced logic control enables developers to build complex, "industrial-grade" processes that meet high reliability requirements. "Resource optimization" for parallel processes automatically allocates computing resources for parallel tasks through load balancing algorithms (e.g., deploying two models on different GPUs to avoid memory contention). A "layered mechanism" for exception handling implements three levels of protection: "component-level circuit breaking - process-level retry - system-level alerts." For example, if a component fails, a local retry (RM) is triggered first; if that fails, the component is circuit-broken and a backup (ECB) is switched on, while an email containing error logs is sent to the administrator.

[0061] Step 104: To address the different needs of no-code and low-code scenarios, a dynamic adaptation strategy is adopted to perform differentiated resource management with lightweight adaptation and elastic expansion, taking into account both efficiency and performance.

[0062] No-code scenarios ensure that simple processes run stably on general-purpose computing power, avoiding resource waste (e.g., limiting the number of single-process models to ≤3 and GPU memory usage to ≤4GB). Low-code scenarios support complex processes to call resources on demand, realizing elastic scaling of computing power (e.g., automatically expanding GPU instances during peak periods and releasing resources during off-peak periods).

[0063] Lightweight adaptation for no-code scenarios ensures process operation under resource-constrained conditions through "model optimization + monitoring and early warning". Specifically, this includes: Step 3a, Automatic Model Selection. Based on a three-dimensional matching algorithm of "scene features-model capabilities-resource constraints", the optimality of model selection is ensured.

[0064] Feature extraction: Analyze the key features in the template (such as "number of dialogue rounds" and "multi-round interaction requirements" in the customer service template, and "data volume" and "visualization type" in the report template) to generate scene feature vectors.

[0065] Model matching: Select models from the lightweight model library that meet the computing power constraints (e.g., video memory ≤ 2GB) and capability matching (e.g., multi-turn support of dialogue models ≥ 80%), sort them by accuracy and inference speed (IS), and select the model with the highest overall score.

[0066] Scenario-based model recommendation: Based on the template type (e.g., "Customer Service Template" corresponds to a dialogue model, "Report Template" corresponds to a data analysis model), the optimal model is selected from the "Lightweight Model Library". For example, in the customer service scenario, a dialogue model with 13 parameters is selected by default (balancing effectiveness and efficiency, with a video memory usage of ≤2GB), rather than a large model with tens of billions of parameters.

[0067] Resource quota control: Preset computing power limit for no-code users (simultaneous invocation of ≤3 model components in a single process, with each model having ≤4GB of video memory), and limit resource usage through technical means (such as containerized deployment, setting CPU and memory quotas).

[0068] Step 3b: No-code monitoring and alerting. Through "passive monitoring + proactive recovery," business personnel do not need to concern themselves with the underlying technical details.

[0069] Real-time monitoring metrics: Collects 10+ metrics such as model call success rate, response time, and video memory usage, and displays them in the form of a dashboard on the console.

[0070] Automated recovery: When a component failure is detected, the system automatically performs a three-level process of "retry → switch to backup component → notify administrator", and the entire process requires no manual intervention.

[0071] Visual alarm configuration: Users can set alarm conditions by checking boxes (such as "model call success rate <90%" and "response time >10 seconds"), and the system supports multi-channel notifications (email, SMS, and in-platform pop-ups).

[0072] Automatic recovery strategy: Predefined common fault handling procedures, such as automatically switching to the backup model when a component times out (no response for more than 5 seconds); triggering automatic restart when the model success rate is consistently below the threshold.

[0073] Low-code scenario elastic scaling supports developers' "custom resource allocation + deep model optimization" to meet high concurrency and high accuracy requirements. Specifically, it includes: Step 4a: Dynamic allocation of computing power, balancing performance and cost through "static configuration + dynamic adjustment".

[0074] Static resource planning: During the process design phase, developers allocate fixed computing power (such as specifying the use of NVIDIA A100 GPU with 16GB of video memory) to key nodes (such as financial risk control model inference nodes) to ensure the stability of core functions.

[0075] Dynamic elastic scaling: Integrates with KubernetesHPA to automatically adjust the number of model instances based on CPU utilization (e.g., scaling up when it exceeds 80%) and request queue length (e.g., scaling up when the backlog of requests exceeds 1000), achieving "resources fluctuate with load".

[0076] Developer-defined strategies: Allow configuration of GPU / CPU resource allocation (e.g., critical model nodes have 16GB of dedicated video memory, while non-critical nodes share 8GB of video memory), support KubernetesHPA (HorizontalPodAutoscaler) script writing, and enable automatic scaling of model instances (e.g., scaling from 2 instances to 10 instances when the request volume suddenly increases).

[0077] Load balancing algorithm: Requests are allocated using a "minimum response time" strategy to ensure efficient utilization of computing resources. Write KubernetesHPA configuration code to implement automatic scaling of model instances.

[0078] Step 4b involves in-depth model optimization, providing a "toolchain + interface" to lower the barrier to model optimization.

[0079] The "Visual Selection" of quantization tools: A drop-down menu of quantization methods (FP16, INT8, INT4) is provided in the low-code interface, and the impact of each method on accuracy and speed is displayed (e.g., after INT8 quantization, the inference speed is improved by 30%, but the accuracy is reduced by 1.5%).

[0080] "One-click connection" for distributed training: No need to manually write distributed code, just select the framework (DDP / FSDP) and the number of nodes (e.g., 4 cards / 8 cards), and the system will automatically generate training scripts and submit them to the cluster.

[0081] Custom compression strategies: Supports FP16 / INT8 quantization (reduces GPU memory usage by 30%-50% and improves inference speed by 20%) and model pruning (removes redundant parameters while maintaining accuracy loss of <5%).

[0082] Distributed training interface: Connects to frameworks such as DDP (DataDistributedParallel) and FSDP (FullyShardedDataParallel) to support distributed fine-tuning of large models (such as training financial models on an 8-GPU cluster).

[0083] Step 105: Perform domain adaptation to address the issue of "general models performing poorly in vertical domains". Through "no-code rapid adaptation" and "low-code deep customization", we can achieve "general model + domain knowledge = industry-specific capabilities".

[0084] No-code imports domain knowledge (terminology, rules) visually, triggering lightweight fine-tuning to quickly improve model performance in specific scenarios. Low-code integration enables deep fusion of complex domain knowledge with the model through code-based connections to knowledge graphs (KG) and custom rule engines.

[0085] No-code domain adaptation enables business users to autonomously inject domain knowledge without the need for professional data annotation and training. Specifically, it includes: Step 5a, Visual Knowledge Import.

[0086] Tabular knowledge graph: Supports importing domain-specific terminology lists from Excel (e.g., "credit report" in the financial field corresponds to "personal credit assessment document," and "BMI" in the medical field corresponds to "body mass index"), automatically generating "terminology-model response" mapping relationships. For example, after importing an e-commerce terminology list, the model's accuracy in understanding terms such as "SKU" and "ASIN" increased from 60% to 95%.

[0087] Visual editing of the rule base: Configure industry rules by dragging and dropping "condition-action" cards (such as "body temperature > 38℃ → trigger fever warning" in the medical scenario, and "answering questions incorrectly > 3 times → push knowledge point review link" in the education scenario).

[0088] Visual knowledge import transforms abstract domain knowledge into rules and mappings that the model can understand, achieving the transformation from "business experience to model capabilities." The "intelligent mapping" of the glossary involves the system using NLP technology to identify the contextual meaning of terms after importing the Excel glossary, automatically associating them with the model's output space. For example, the financial term "non-performing loan" corresponds to "risk level: high" in the model output, rather than a literal translation. The "scenario-based guidance" for rule configuration provides industry-specific rule templates (such as medical rule templates containing "symptom-disease-treatment suggestion" triples). Users only need to fill in specific parameters (such as body temperature threshold and treatment measures) to complete the rule definition.

[0089] Step 5b involves fine-tuning the process with zero code, using "few-shot learning + automated training" to solve the problem of scarce domain data.

[0090] Transparency in the fine-tuning process: Displaying the fine-tuning progress (amount of data processed, remaining time) and changes in performance metrics (accuracy improvement curve, loss function decline trend), allowing users to intuitively experience the domain adaptation effect.

[0091] Lightweight data annotation: Guide users to annotate 50-100 pieces of domain data through a visual interface (such as annotating typical questions and correct responses in customer service scenarios), and the system will automatically generate a training dataset.

[0092] Performance Comparison Dashboard: Real-time display of model output comparison before and after fine-tuning (such as the accuracy of customer service responses and the improvement in compliance rate), supporting A / B testing.

[0093] The low-code domain-specific deep customization provides developers with a toolchain for "knowledge graph integration + deep model training," meeting the high-precision requirements of vertical domain scenarios. Specifically, it includes: Step 6a, code-level knowledge integration.

[0094] Knowledge Graph API Integration: By calling graph databases such as Neo4j and Stardog through code, complex knowledge reasoning can be achieved (such as "technical features-prior art-innovation points" association queries in the patent field). For example, in patent analysis scenarios, the model can determine whether a technical solution possesses novelty based on the knowledge graph.

[0095] Rule engine extension: Supports writing custom rule parsing code (such as regular expression matching, decision tree algorithm implementation) to handle structured (database tables) and unstructured (documents, contracts) domain knowledge.

[0096] Code-level knowledge fusion organically combines symbolic knowledge (rules) with numerical knowledge (models), enhancing the model's logical reasoning capabilities. The knowledge graph's "dynamic query" allows for real-time querying of the knowledge graph to obtain domain-specific information during model reasoning. For example, when assessing loan applications, a financial risk control model queries the company's knowledge graph for information on "equity structure" and "litigation records" as a basis for decision-making. The rules engine's "custom extension" allows developers to write Python code to implement complex rules (such as "when a user's age is >60 and the loan amount is >500,000, manual review and telephone follow-up are required") and embed these rules into the model's reasoning process.

[0097] Step 6b, fine-tuning the model depth: Code-based fine-tuning configuration: Supports setting frozen layers (e.g., fine-tuning only the last 3 layers of the LLM while retaining the general capabilities of the underlying layers) and learning rate scheduling strategies (e.g., linear decay after warm-up).

[0098] Distributed fine-tuning support: It connects to the HuggingFaceTrainer interface to enable multi-GPU parallel fine-tuning (such as training a medical diagnostic model on an 8-GPU cluster), improving training speed by more than 5 times.

[0099] Model depth fine-tuning achieves high performance for domain-specific models through "fine-grained parameter control + training process monitoring." The frozen layer strategy allows developers to freeze the lower-level general layers of the model (e.g., the first 10 layers handle general semantics) and fine-tune only the upper-level domain-related layers (the last 5 layers handle financial terminology), reducing training data requirements while maintaining general capabilities. Training metric monitoring displays metrics such as loss, accuracy, and F1-score during training in a low-code interface, and supports resume training from the last saved checkpoint after an interruption.

[0100] This invention first focuses on requirements understanding and analysis. Business personnel input requirements through multimodal methods such as natural language and visual prototypes. The system then extracts key business elements using large-scale model semantic parsing technology. Next, a dual-mode collaborative architecture of no-code and low-code is constructed, organically combining basic capability sharing with advanced function expansion. Focusing on large-scale model optimization and domain adaptation, the model size is compressed by 70% through knowledge distillation and INT8 quantization technology, adapting to edge computing devices (such as NVIDIA Jetson) for small and medium-sized enterprises. Simultaneously, knowledge graph fusion improves accuracy in vertical domains; for example, after injecting knowledge into medical scenarios, symptom recommendation accuracy increases from 75% to 92%, with an algorithm accuracy of ≥90% to ensure application reliability. The no-code platform provides a visual component library and automated orchestration tools. Business personnel can drag and drop components such as "intelligent customer service dialogue blocks" to quickly build applications, such as generating an enterprise notification system within 2 hours, with a basic function completeness rate of ≥95%. A built-in AI assistant recommends components in real time and verifies logical vulnerabilities; for example, it automatically prompts "refund scenarios not covered" when configuring customer service processes, reducing manual debugging costs. Local industry components such as "cross-border e-commerce logistics query" further lower the domain adaptation threshold. The low-code platform transforms visual processes into Python code through a code generation engine, supporting custom logic injection. For example, it allows writing formulas like "Credit Score = Basic Score + Asset Score - Liability Score" in financial risk control systems, or configuring credit scoring API authentication through a low-code interface. Code generation efficiency is ≥80% higher than manual coding, while also being compatible with domestic databases (such as Huawei GaussDB), meeting the dual demands of complex businesses for flexibility and performance. System integration and testing connect the data links between no-code and low-code modules. Automated testing simulates high-concurrency scenarios; after optimization, the edge inference latency of the industrial quality inspection model has been reduced from 500ms to 80ms, with a system pass rate ≥99%. The security audit module addresses code privacy risks, ensuring data compliance in scenarios such as finance, such as automatically detecting missing user data encryption logic. Deployment and operation adopt a hybrid cloud-native and edge computing architecture, using Kubernetes for elastic scaling. For example, the number of customer service model instances in e-commerce can be scaled from 10 to 100, increasing QPS by 5 times. Edge nodes support resume transmission after network outages, and in industrial scenarios, quality inspection data is cached locally for 24 hours, ensuring system availability ≥99.9%. Intelligent monitoring collects real-time metrics such as model latency and memory usage, automatically triggering circuit breakers or switching to backup models in case of anomalies to ensure service continuity. Iteration and evolution are based on continuous optimization of the platform using user feedback. For example, a "dialect recognition" component has been added based on user needs, and "smart data access" requirements collected from the developer community drive the expansion of the low-code toolchain. Third-party developers can upload industry templates, which, after review, are shared in the template marketplace, forming a positive cycle of "requirement collection - feature iteration - ecosystem co-construction," driving the continuous evolution of the platform's capabilities.Each stage is closely linked to deliverables and metrics, such as requirement specifications guiding architecture design, production environment data, and algorithm optimization, embodying the core logic of "requirement-driven development and data-driven iteration." Dual-mode collaboration enables 80% of general scenarios to be rapidly implemented through no-code solutions, and 20% of complex scenarios to be deeply customized with low-code solutions. Overall development efficiency is improved by over 60%, and computing power costs are reduced by 50%-70%, providing local enterprises with efficient, flexible, and cost-controllable AI development solutions, assisting in the digital transformation of government, manufacturing, finance, and other fields. In one embodiment, this invention is applied to typical no-code development scenarios, focusing on "high-frequency, standardized business needs." It achieves the instant transformation from "business needs to usable applications" through "drag-and-drop zero-code components + visual configuration," primarily targeting SMEs and non-technical personnel, lowering the entry barrier for AI applications. First, a no-code intelligent customer service system is built, based on an "intelligent customer service solution template," integrating natural language processing (NLP) and process automation capabilities, supporting multi-channel access (webpage, APP, WeChat official account), and achieving full-process digitalization of "consultation reception - problem handling - work order closed loop." This mainly includes the construction of the no-code intelligent customer service system and no-code domain adaptation. During the construction of the no-code intelligent customer service system, the templated process construction achieves visual orchestration of customer service logic through "three-level process modeling," including rapid generation of basic processes and deep configuration of business rules. The basic workflow is quickly generated by dragging and dropping the "Welcome Message Component," "Intent Recognition Component," "Knowledge Base Reply Component," and "Work Order Generation Component" from the "Customer Service Template Library" onto the canvas. This automatically generates a standard customer service workflow, including: Welcome Message: "Hello! How can I help you?" Intent Recognition: Parses user questions using a pre-trained NLP model (supports multi-turn dialogue, with a default of 5 turns); Knowledge Base Matching: Retrieves answers from an industry knowledge base (supports text and mixed text / image replies); Work Order Creation: Generates a work order when no answer can be matched, supporting custom work order fields (question type, urgency level).

[0101] The business rules are deeply configurable through the "Conditional Branch Editor," allowing for the setting of complex rules, including: Keyword triggering: When user input contains "refund" or "complaint," it is automatically marked as a high-priority work order; Dialogue turn control: If the issue remains unresolved after more than 10 dialogue turns, it is forcibly transferred to human customer service; Time-of-day strategy: At night (22:00-8:00), it automatically switches to message mode, triggering a work order processing reminder before 9:00 the next day. Dragging and dropping the "Customer Service Dialogue Block" component automatically generates a "Welcome Message - Intent Recognition - Knowledge Base Reply - Work Order Generation" workflow. Business rules can be configured via the visual interface to "jump to the refund processing workflow when user input contains 'refund.'"

[0102] No-code domain adaptation includes importing e-commerce terminology and configuring customer service scheduling rules. Importing e-commerce terminology automatically optimizes responses to high-frequency questions such as "product size" and "logistics inquiry." Configuring customer service scheduling rules involves setting online hours for human customer service representatives via a calendar component and automatically triggering the message flow when they are offline. No-code domain adaptation enhances the industry professionalism of the customer service system through "knowledge injection + model fine-tuning," including visual knowledge graphs and building intelligent scheduling and load balancing. Visual knowledge graph construction includes: terminology import: supporting batch uploading of domain terms (such as "credit report" and "equal principal and interest repayment" in the financial field) via Excel, and the system automatically generates "terminology-response template" mappings. For example, when a user asks "How to check a credit report?", the system directly replies with a preset official query link and step-by-step instructions; rule base editing: configuring industry-specific logic through drag-and-drop "rule cards," such as "logistics tracking number query → automatic redirection to third-party logistics API interface" in e-commerce scenarios, and "symptom description → automatic matching of department recommendations" in medical scenarios. Intelligent scheduling and load balancing include: Customer service scheduling: Set human customer service shifts through the calendar component (supports shift rotation, shift adjustment, and holiday scheduling), and automatically generate a customer service online status table; Load balancing: When the number of people in the human customer service queue is greater than 5, "intelligent diversion" is automatically triggered: complex issues are transferred to human agents, and simple issues are prioritized for handling by the "intelligent assistant", improving service efficiency by more than 30%.

[0103] Next, a zero-code data reporting system is established. This system provides "data-driven decision-making" tools, enabling business personnel to independently complete data access, analysis, and visualization, covering scenarios such as operational reports, financial reports, and user analysis. Rapid data access supports the integration of multi-source heterogeneous data, with a built-in data preprocessing engine, including multi-source data access and intelligent data cleaning. Multi-source data access includes: File import: Supports drag-and-drop upload of Excel / CSV files, automatically identifies table headers (such as "date," "metric," and "value") and generates field mappings, supporting batch processing of millions of data points; Database integration: Configures database connections such as MySQL and PostgreSQL through a visual interface, supports visual editing of SQL statements (no manual coding required), and automatically generates data query previews; API access: Pre-packages 30+ commonly used API interfaces such as WeChat Work, DingTalk, and Baidu Statistics, and achieves real-time data synchronization through OAuth2.0 authentication configuration (such as automatically fetching WeChat Official Account readership data). Intelligent data cleaning includes: automatically detecting and handling missing values ​​(filling in default values / deleting invalid rows), duplicate values ​​(duplicate removal), and format errors (unifying date formats); it supports custom cleaning rules (such as filtering "test orders" in e-commerce scenarios, setting a filter condition of "consumption amount > 0"). Zero-code analysis configuration enables data insights through "intelligent analysis components + visual interaction." First, the analysis component ecosystem includes: basic analysis: drag and drop "sum / average calculation component" and "percentage analysis component" to generate basic indicators; advanced analysis: supports "RFM user segmentation component" (automatically classifying high-value users and dormant users) and "time series forecasting component" (predicting future trends based on the Prophet algorithm); visualization components: providing 20+ chart types such as line charts, bar charts, heatmaps, and funnel charts, supporting dynamic drill-down (clicking chart nodes to drill down to detailed data). Then, configure the interaction and output, including: dynamic filtering: configure report filtering conditions (such as "filter by month" and "compare by region") through drop-down menus and date pickers, and refresh the analysis results in real time; notification strategy: set email / SMS notification rules, such as "automatically send an alert report to the operations director's email when the user churn rate is >15%"; access control: support configuring report viewing permissions (department, role, and user three-level permissions), and automatically anonymize sensitive data (such as hiding the middle four digits of the user's mobile phone number).

[0104] In one embodiment, this invention is applied to typical low-code development scenarios, addressing the needs of "multi-system integration, high-performance computing, and deep industry adaptation." It implements complex business logic through "code enhancement + strategy customization," primarily targeting enterprise-level developers and technical teams. This includes a low-code financial risk control system and a low-code industrial quality inspection system. The low-code financial risk control system constructs an intelligent risk control system based on "rule engine + model reasoning," supporting core functions such as credit approval, anti-money laundering detection, and transaction monitoring, meeting the high compliance requirements of the financial industry. First, code enhancement is implemented to achieve full-link customization of "data preprocessing - model reasoning - decision output", including: inserting Python code: custom risk scoring formula (such as "credit score = basic score + asset score - liability score"); connecting to credit reporting API: configuring OAuth2.0 authentication through the low-code interface and calling the central bank credit reporting interface to obtain user credit reports; multi-source data fusion processing: performing credit data cleaning, inserting Python code to filter abnormal data in credit reports (such as resetting "current overdue number" to 0 when it is negative), and third-party data access, configuring the central bank credit reporting API and Qichacha API through the low-code interface, automatically generating complete code including signature authentication and pagination query, supporting batch retrieval of enterprise / personal credit data; risk scoring model customization: custom scoring formula: writing code to implement industry-specific scoring logic (such as "mortgage score = basic score (500) + property valuation × 0.001 - monthly debt expenditure × 0.5"); model parameter adjustment: setting the "temperature" parameter of LLM through the slider to control the certainty of risk description (such as setting it to 0.1 when the approval report is generated to ensure rigorous expression).

[0105] Then, dynamic strategy configuration is performed; decision tree code is written to implement the complex rule logic of "triggering manual review when loan amount > 500,000"; deep model fine-tuning is performed: a pre-trained model in the financial field is called, and only the parameters of the last three layers are fine-tuned through code settings; intelligent decision-making through "dynamic rule adjustment + deep model optimization" is achieved through dynamic strategy configuration: multi-level decision tree modeling is performed, and a visual decision tree editor draws the decision tree through a low-code interface, defining complex approval rules and managing rule versions, supporting strategy version iteration (such as distinguishing between "special strategies during the epidemic" and "regular strategies"), and verifying different strategies through A / B testing. Strategy pass rate and risk indicators; Model deep fine-tuning and monitoring: Perform domain model fine-tuning, call the pre-trained model in the financial field (such as Ant Group's financial NLP model), and fine-tune only the parameters of the last three layers through code settings, focusing on capabilities such as "understanding financial terminology" and "generating compliance language". Fine-tuning data can be quickly collected through the system's built-in annotation tool (supports training with 50-100 small samples) and real-time risk monitoring is performed. Prometheus is integrated to monitor model inference latency (requirement <200ms) and false positive rate (target <0.3%). In case of anomalies, the model will be automatically restarted or a backup model will be switched.

[0106] For low-code industrial quality inspection systems, we integrate machine vision and Internet of Things (IoT) technologies to achieve defect detection and quality control in the production process, supporting edge deployment and cloud collaboration. First, multimodal code integration is performed; Image recognition component: PyTorch code is inserted to customize image preprocessing logic (such as defect area localization algorithm); Equipment data access: Real-time reading of industrial sensor data is achieved through Modbus protocol code; Multimodal code integration enables fusion analysis of "image data + sensor data": Visual inspection code is customized, image preprocessing is inserted into PyTorch code to achieve defect area localization, and multimodal fusion aligns the visual inspection results (defect location) with sensor data (vibration frequency, temperature) through timestamps to build a "defect type - equipment status" association model (such as "bearing temperature too high + surface crack → judged as a major defect"); Industrial protocol interface: Modbus / TCP protocol code is used to achieve real-time communication with PLC and sensors, support configuration of device address and register number, and automatically parse binary data into readable engineering parameters (such as pressure value, speed); OPCUA protocol support is provided, and server address and security policy are configured through a low-code interface to achieve data interoperability with industrial control systems such as Siemens and Schneider. Then, code is deployed at the edge; EdgeTPU compilation scripts are written to convert the visual model to TensorFlowLite format and deploy it to the edge nodes of industrial cameras; code for resuming data transmission after network interruption is implemented to cache quality inspection data locally when the network is interrupted and automatically synchronize it to the cloud after recovery; the edge deployment code is optimized for the low computing power environment of industrial sites to ensure stable operation in offline scenarios: lightweight model deployment is performed, and the EdgeTPU compilation uses the TensorFlowLite converter to convert the visual model to the quantization format supported by EdgeTPU. After INT8 quantization, the model size is reduced by 70% and the inference speed is increased by 50%, supporting operation on edge devices such as Raspberry Pi and NVIDIA Jetson; the model caching mechanism is to pre-store commonly used defect feature templates on the edge nodes, and continue to perform quality inspection based on the local model when the network is interrupted, avoiding production line downtime. Resume data transmission after network interruption and data security: The local cache is designed as a circular buffer to store quality inspection data, supporting the storage of 24 hours of data (approximately 100,000 records). Each data record includes a timestamp, device number, and test result. Resume transmission after interruption automatically resumes synchronization from the last uploaded record after network recovery, avoiding duplicate transmission. Data encryption uses the AES-256 algorithm to encrypt locally stored data and the TLS 1.3 protocol during transmission to ensure secure data flow between the edge and the cloud.

[0107] Accordingly, embodiments of the present invention also provide an application development apparatus based on large model technology, such as... Figure 2 The image shown is a schematic diagram of one possible structure of the device. This application development device based on large-scale model technology includes the following modules: The requirements analysis unit 201 performs requirements analysis, transforming vague business descriptions into executable technical solutions through natural language understanding and structured modeling techniques. The Architecture Design Unit 202 is responsible for architecture design and planning, and building a dual-mode collaborative architecture that combines no-code and low-code approaches. Engine Building Unit 203: Build a visual orchestration engine and establish a dual-mode development interface for no-code and low-code development modes. The dynamic adaptation unit 204 adopts a dynamic adaptation strategy to perform differentiated resource management with lightweight adaptation and elastic expansion, targeting the different needs of no-code and low-code scenarios. Domain Adaptation Unit 205 performs domain adaptation, achieving industry-specific capabilities based on general models and domain knowledge through rapid no-code adaptation and deep low-code customization.

[0108] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that the present invention is not limited to the described order of actions, because according to the present invention, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily essential to the present invention.

[0109] The present invention also provides a storage medium, which is a computer-readable storage medium storing a computer program thereon, the computer program being executable when it runs. Figure 1 The method shown may include some or all of the steps. The storage medium may include read-only memory (ROM), random access memory (RAM), magnetic disk or optical disk, etc. The storage medium may also include non-volatile memory or non-transitory memory, etc.

[0110] The above embodiments can be implemented, in whole or in part, by software, hardware, firmware, or any other combination thereof. When implemented using software, the above embodiments can be implemented, in whole or in part, as a computer program product. The computer program product includes one or more computer instructions or computer programs. When the computer instructions or computer program are loaded or executed on a computer, all or part of the processes or functions described in the embodiments of this application are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions can be transmitted from one website, computer, server, or data provider to another website, computer, server, or data provider via wired or wireless means.

[0111] The embodiments of the present invention have been described in detail above. Specific implementation methods have been used to illustrate the present invention. The descriptions of the embodiments above are only for the purpose of helping to understand the methods and systems of the present invention, and are merely some, not all, embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention, and the content of this specification should not be construed as a limitation of the present invention. Therefore, any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for developing an application based on large model technology, characterized by, The method comprises: Step 1, conducting a demand analysis, converting fuzzy business descriptions into executable technical solutions through natural language understanding and structured modeling techniques; Step 2, conducting architecture design and planning, building a no-code and low-code dual-mode collaborative architecture; Step 3, building a visual orchestration engine, establishing a no-code development mode and a low-code development mode dual-mode development interface; Step 4, for different needs of no-code and low-code scenarios, adopt dynamic adaptation strategy, light-weight adaptation and elastic expansion of differentiated resource management; Step 5, field adaptation, through no-code rapid adaptation and low-code deep customization, according to the general model and domain knowledge, get industry-specific capabilities. 2.The large model technology-based application development method of claim 1, wherein, Step 1 includes: Step 11, input and element extraction of multi-modal demand, business personnel input demand through natural language and visual prototype multi-modal way, system extracts key business elements with the help of large model semantic analysis technology; Step 12, dual-mode demand processing, design different processing procedures for different user groups, use demand conversion engine to realize cross-mode demand docking. 3.The large model technology-based application development method of claim 2, wherein, In step 12, first, no-code demand rapid transformation, using large model semantic analysis + visual interaction technology, realizing zero-code structuring of business demand, including natural language demand analysis and zero-code index mapping; When analyzing natural language demand, a three-level processing procedure of intent recognition-template matching-element extraction is constructed, fuzzy demand is clarified through multiple rounds of dialogue, three most relevant templates are recommended from the industry template library based on keyword matching, an interactive demand confirmation sheet is generated, business personnel can adjust details by checking and dragging, and structured input required for no-code development is automatically generated after confirmation; When zero-code index mapping, through business target quantification engine + visual configuration interface, abstract goals are converted into monitorable indexes, macro goals are decomposed by analytic hierarchy process AHP, index threshold values are dynamically adjusted by slider and drop-down menu components, system real-time prompts configuration influence and generates index achievement path diagram; Secondly, low-code demand deep definition, providing technical parameter fine configuration + complex demand hierarchical modeling tools for developers, including technical parameter configuration and complex demand decomposition, when configuring technical parameters, a three-dimensional configuration system of model performance-system resources-security policy is constructed, domain-specific capability indexes can be customized, and model optimization parameters can be associated, API call frequency and data storage cycle system-level parameters can be visualized, and parameter conflict detection engine is used to automatically identify configuration conflicts; When complex demand decomposition, use process layering + node expansion technology to decompose complex demand into data access-model processing-result output three-level process. 4.The large model technology-based application development method of claim 1, wherein, In step 2, the codeless and low-code dual-mode collaborative architecture includes codeless exclusive components and low-code expansion components. The codeless exclusive components encapsulate technical complexity inside the components through a visual drag-and-drop and parameter configuration dual-engine. Each codeless exclusive component corresponds to a complete business unit. The low-code expansion components provide limited code intervention interfaces based on standardized capabilities to meet medium complexity requirements. Codeless component interaction specifications are established between the codeless exclusive components and the low-code expansion components to establish an interaction system that standardizes data flow, visualizes logic control, and automates exception handling, ensuring efficient and stable collaboration between components. 5.The large model technology-based application development method of claim 4, wherein, In step 2, during the architecture design of the codeless exclusive components, multiple composite components are pre-packaged, each with complete business logic. A business-oriented configuration interface is then provided, hiding technical parameters and offering configuration options from a business perspective. During the architecture design of the low-code expansion components, programmable interfaces are opened to support complex logic coding. Parameterized adjustments are then made by exposing model core parameters through sliders and drop-down menus. 6.The large model technology-based application development method of claim 1, wherein, In step 3, the visual orchestration engine includes a flow parser and a resource scheduler. The flow parser converts user-dragged component flows into machine-executable logic graphs, supporting the parsing of conditional branches, loops, and parallel tasks. The resource scheduler dynamically allocates computing power based on flow complexity and monitors resource usage. The codeless development mode allows business personnel to independently complete application construction by building templated processes and zero-code logic configurations. The low-code development mode provides a hybrid development environment with visual orchestration and code enhancement for developers, balancing efficiency and flexibility. 7.The large model technology-based application development method of claim 1, wherein, In step 4, lightweight adaptation in codeless scenarios is achieved through model optimization and monitoring and early warning to ensure process operation under resource constraints, including automatic model selection and codeless monitoring and alarm. Elastic expansion in low-code scenarios supports developers to customize resource allocation and deep model optimization to meet high concurrency and high precision requirements, including dynamic allocation of computing power and deep optimization of models. 8.The large model technology-based application development method of claim 1, wherein, In step 5, the codeless rapid adaptation imports domain knowledge through a visual method, triggers lightweight fine-tuning, and quickly improves model performance in specific scenarios, including visual knowledge import and zero-code fine-tuning. The low-code deep customization realizes the deep integration of complex domain knowledge and models through code interfacing with knowledge graphs and custom rule engines, including code-level knowledge fusion and model deep fine-tuning. 9.A device for developing an application based on large model technology, characterized by The device includes: A requirement analysis unit performs requirement analysis, converts fuzzy business descriptions into executable technical solutions through natural language understanding and structured modeling techniques. An architecture design unit performs architecture design and planning, building a codeless and low-code dual-mode collaborative architecture. An engine building unit builds a visual orchestration engine, establishing a codeless development mode and a low-code development mode dual-mode development interface. The dynamic adaptation unit adopts a dynamic adaptation strategy for different needs of the no-code scene and the low-code scene, and performs differentiated resource management of lightweight adaptation and elastic expansion. The domain adaptation unit performs domain adaptation, and obtains industry-specific capabilities according to the general model and domain knowledge through no-code quick adaptation and low-code deep customization.

10. A computer-readable storage medium having stored thereon a computer program, characterized in that, The computer program, when executed by a processor, performs the steps of the application development method based on the large model technology in any one of claims 1 to 8.

Images