Artificial intelligence application development system

Abstract

The present invention relates to an artificial intelligence application development system for enabling easy development of an artificial intelligence application on the basis of graphics. The artificial intelligence application development system according to the present invention comprises: an IDE providing device (1) for providing an IDE through which a developer can develop an application in a graphic base; and a storage device having a node library and a project library. The IDE providing device (1) includes a user interface (20) which enables a developer to generate a flow graph by using nodes and edges, wherein the user interface (20) includes a node calling means for enabling the developer to call the nodes to a workspace and an edge connection means for connecting the edges for setting a process flow or a data flow between the nodes. In addition, the IDE providing device (1) comprises a hyperparameter engine (13) for setting hyperparameters for the nodes and a flow-graph engine (12) for interpreting and executing the flow graph.

Description

Artificial Intelligence Application Development System

[0001] The present invention relates to an artificial intelligence application development system that enables easy development of artificial intelligence applications based on graphics.

[0002] Recently, artificial intelligence (AI) based on machine learning or deep learning has become widespread. Machine learning relies on statistical logic for efficiently analyzing massive amounts of data. As a typical example, machine learning establishes a hypothesis function to interpret sample data, commonly referred to as training data or a training set, and generates a loss function or cost function corresponding to the error between the hypothesis and the actual data. Then, using the gradient descent algorithm, weights and bias values ​​are calculated to minimize the loss (cost), completing an AI model or application that can predict or produce the user's desired results.

[0003] When creating AI applications, data flow diagrams are created, taking into account the flow of data, and coding is performed using an appropriate programming language. Programming languages ​​for AI development include Python, R, C / C++, Java, JavaScript, Julia, Scala, Ruby, MATLAB, Octave, and SA. These are text-based programming languages. Creating AI algorithms or applications using these programming languages ​​requires specialized knowledge of the programming language. AI algorithms, in particular, involve highly complex and difficult mathematical operations, and their coding requires significant manpower and time.

[0004] Recently, generative AI applications such as Amazon CodeWhisperer have been proposed to help developers build AI applications quickly and safely by utilizing large language models (LLM: Large Language Mode) and foundation models (FM: Foundation Model) in an integrated development environment (IDE).

[0005] In addition, Korean Patent Publication No. 10-2021-0123152 (Title: Automatic instruction generation device for artificial intelligence processor and optimization method thereof), Registration Patent No. 10-2271449 (Title: Artificial intelligence model platform and artificial intelligence model platform operation method), and Registration Patent No. 10-2352991 (Title: Artificial intelligence model generation method using artificial intelligence model generation platform providing system) disclose methods by which users can easily create AI applications. The above methods simply enable users to develop their own desired artificial intelligence models by using existing artificial intelligence algorithms or models.

[0006] In addition, Korean Patent No. 10-0633241 (Title: Embedded Linux Education Integrated Development Environment System), Patent No. 10-0553707 (Title: SCORM-based Content Creation System), Patent No. 10-0860963 (Title: Device and Method for Component-based Software Development), Patent Publication No. 10-2018-0048213 (Title: Method and Device for Configuring User-Defined Member Editing Window in Integrated Development Environment), Patent No. 10-2622652 (Title: Method and Device for Automatic Software Development for a Group of Controller-based Devices), Patent Publication No. 10-2022-0050362 (Title: GUI-based Integrated Development Environment Providing System for Algorithm Configuration) and Patent Publication No. 10-2023-0089495 (Title: Spiking Neural Network Input Data Processing System for GUI-based Integrated Development Environment) include graphic-based A system providing an integrated development environment (IDE) is disclosed. These inventions enable the development of content such as applications using graphics or with minimal program coding. However, these inventions have the drawback of not being able to adequately address the development of applications with complex and diverse decision tree structures, such as artificial intelligence.

[0007] The technical purpose of the present invention is to provide a development system that enables developers to develop artificial intelligence applications easily and conveniently.

[0008] An artificial intelligence application development system according to the present invention is a development system for developing an artificial intelligence application, comprising an IDE providing device that provides an IDE for a developer to develop an application graphically, a storage device having a node library and a project library, and an LLM adapter for connection with an LLM model, wherein the IDE providing device comprises a user interface for a developer to create a flowchart using nodes and edges, and a flowchart engine for interpreting and executing the flowchart, wherein the user interface comprises a workspace, a node calling means for a developer to call a desired node to the workspace, and an edge connecting means for connecting edges for setting a process flow and a data flow between nodes, and wherein the node calling means includes a node directory list for providing a node list classified by purpose, and the node directory list includes an LLM directory for providing a node list for utilizing LLM.

[0009] According to the present invention, an IDE that enables developers to develop AI applications graphically is provided. The IDE includes a user interface that allows developers to create graphical flowcharts using nodes and edges, and a flowchart generator that stores flowchart information corresponding to the flowchart in a project library. Furthermore, the IDE includes a flowchart engine that allows developers to test and debug their developed applications. Developers can develop their desired AI applications simply by graphically creating flowcharts through the IDE, and can then test and debug these applications using the flowchart engine.

[0010] Figure 1 is a block diagram showing the configuration of an artificial intelligence application development system according to one embodiment of the present invention.

[0011] FIG. 2a is a drawing showing an example of a user interface (20) provided by the IDE provider (1) in FIG. 1.

[0012] Figure 2b is a drawing showing an example of a submenu (201) of the work management menu (221) in Figure 2a.

[0013] FIG. 2c is a drawing showing an example of a flowchart registration window (202) provided by an IDE provider (1) when a flowchart registration item (201a) is selected in FIG. 2a.

[0014] Figure 2d is a drawing showing an example of a submenu (203) of the flowchart name display window (223) in Figure 2a.

[0015] FIG. 2e is a drawing showing an example of a directory list displayed through a list display section (227) when a node button (225) is clicked in FIG. 2a.

[0016] FIG. 2f is a drawing showing an example of a list of nodes (227b) selectable via the node button (225) in FIG. 2a.

[0017] Figure 2g is a drawing showing an example of a method for loading a desired node from a node list (225b) into a workspace (21).

[0018] Figure 2h is a drawing showing an example of another way of calling a node (30) as a workspace (21).

[0019] FIG. 2i is a drawing showing an example of a hyperparameter setting means provided by an IDE provider (1).

[0020] FIG. 2j is a drawing showing an example of a selection window (213) related to a node (30) provided by a user interface (20).

[0021] Figure 3 is a drawing showing an example of a work process for creating a flowchart in a workspace (21) using a user interface (20).

[0022] Fig. 4 is a drawing showing an example of a call LLM node (30a) and its hyperparameter setting means (241).

[0023] Figure 5 is a flowchart showing an example of the configuration of a chatbot implemented using a call LLM node (30a) and a user input node (30b: User input) for prompt input.

[0024] Fig. 6 is a drawing showing an example of an instruction node (30c) and its hyperparameter setting means (242).

[0025] Fig. 7 is a flowchart showing another configuration example of a chatbot implemented using the call LLM node (30a) and the user input node (30b: User input) in Fig. 5.

[0026] Figure 8 is a drawing showing an example of a state in which a developer presses the run button (229) after creating a flowchart.

[0027] Fig. 9 is a drawing showing another example of a user interface (20) provided by an IDE provider (1).

[0028] Fig. 10 is a drawing showing an example of an interface screen provided to a user when the user selects the chatbot execution button (229a).

[0029] Fig. 11 is a drawing showing an example of a response content (93) generated by a flowchart engine (12) in response to a user's prompt input (92).

[0030] An artificial intelligence application development system according to the present invention is a development system for developing an artificial intelligence application, comprising an IDE providing device that provides an IDE for a developer to develop an application graphically, a storage device having a node library and a project library, and an LLM adapter for connection with an LLM model, wherein the IDE providing device comprises a user interface for a developer to create a flowchart using nodes and edges, and a flowchart engine for interpreting and executing the flowchart, wherein the user interface comprises a workspace, a node calling means for a developer to call a desired node to the workspace, and an edge connecting means for connecting edges for setting a process flow and a data flow between nodes, and wherein the node calling means includes a node directory list for providing a node list classified by purpose, and the node directory list includes an LLM directory for providing a node list for utilizing LLM.

[0031] Additionally, the node list is characterized in that it includes a call LLM node or an instruction node.

[0032] In addition, the IDE providing device is characterized in that it additionally includes a hyperparameter engine that provides a hyperparameter setting means for setting hyperparameters for a node called as a workspace.

[0033] In addition, the node library has node information related to a node that can be called by a developer, and the node information includes program source or code information corresponding to the node, and the project library stores flowchart information corresponding to a flowchart created through a workspace, and the flowchart information is characterized in that it includes node information and edge information of a node included in the flowchart.

[0034] Additionally, the node information is characterized by being written in JSON.

[0035] Additionally, the node is characterized by having a process port connected to an edge.

[0036] In addition, the node is characterized by having a data port connected to an edge, and the data port includes a data input port and a data output port.

[0037] In addition, the edge is characterized by including a first edge connected to a process port to establish a process flow, and a second edge connected to a data port to establish a data flow.

[0038] In addition, the IDE providing device provides a first setting means for the call LLM node, and the first setting means is characterized by having a selection window for a user to select an LLM service.

[0039] In addition, the first setting means is characterized in that it additionally has a setting window for the user to set LLM parameters.

[0040] In addition, the IDE providing device is characterized in that it provides a second setting means for the instruction node, and the second setting means provides an input window for inputting an instruction.

[0041] Additionally, the user interface is characterized by providing a run window for the user to execute prompt input for the LLM.

[0042] Hereinafter, embodiments of the present invention will be described with reference to the drawings. However, the embodiments described below are merely exemplary of one preferred implementation of the present invention, and these examples are not intended to limit the scope of the present invention. The present invention can be implemented with various modifications without departing from the technical spirit thereof.

[0043] Figure 1 is a block diagram illustrating the configuration of an AI application development system according to one embodiment of the present invention. The AI ​​application (hereinafter simply referred to as "AI") development system comprises an IDE provider (1) that provides an integrated development environment (IDE) that allows developers to develop AI based on graphics, and a storage unit (2) that stores various data necessary for the operation of the IDE and the development of AI.

[0044] The IDE provider (1) is configured programmatically. The IDE provider (1) comprises a flowchart generator (11) and a user interface (20). The flowchart generator (11) provides a means for a developer to create a flowchart including a data flow and a process flow in conjunction with the user interface (20). The user interface (20) preferably includes a GUI (Graphical User Interface). The developer can create a flowchart graphically through the user interface (20).

[0045] In addition, the IDE provider (1) has a flowchart engine (12). The flowchart engine (12) interprets and executes a flowchart created by a developer. The flowchart engine (12) manages data input, conditional branching, and interaction with external devices. The flowchart engine (12) can preferably be utilized as a means for testing and debugging a flowchart created by a developer, i.e., an application. In addition, in a preferred embodiment, the AI ​​development system has an execution record storage unit (3). The execution record storage unit (3) stores and manages execution records by the flowchart engine (12).

[0046] In a preferred embodiment of the present invention, the IDE providing device (1) is equipped with a hyperparameter engine (13). The hyperparameter engine (13) provides a means for developers to easily set various hyperparameters required for AI execution in conjunction with a user interface (20).

[0047] The storage unit (2) has a node library (2a) in which node information for creating a flowchart is stored, a project library (2b) in which all information related to the application that the developer wishes to develop is stored, and a template library (2c) in which flowchart information that the developer can reference and utilize is stored.

[0048] In a preferred embodiment of the present invention, the AI ​​development system comprises a knowledge base system (4). The knowledge base system (4) collects various contents, including documents, from various sources such as databases, file storage devices, or websites through an importer (4c) at the request of the IDE, and manages a vector database (4a) and a knowledge base storage unit (4b).

[0049] In addition, in another preferred embodiment of the present invention, the AI ​​development system is provided with an LLM adapter (5) to provide a basis for utilizing a large language model (LLM), such as for utilizing a chatbot.

[0050] Fig. 2a is a diagram illustrating an example of a user interface (20) provided by an IDE provider (1). The user interface (20) basically includes a workspace (21) and a number of selection menus (22). The workspace (21) is for creating flowcharts. As described below, a developer creates a flowchart graphically by calling nodes into the workspace (21) and appropriately connecting the nodes using edges.

[0051] The selection menu (22) can be selected by the developer by clicking on the corresponding area, for example, with a mouse (not shown). Of course, in another preferred implementation example, the selection menu (22) can be implemented so that the developer can select it using a keyboard shortcut. The selection menu (22) has a task management menu (221). Fig. 2b is a drawing showing an example of a submenu (201) of the task management menu (221). The submenu (201) of the task management menu (221) basically has a flowchart registration item (201a) for registering a new flowchart, and a project switching item (201b) for selecting or switching a project to work on.

[0052] FIG. 2c is a diagram showing an example of a flowchart registration window (202) provided by the user interface (20) when a flowchart registration item (201a) is selected. In the diagram, the flowchart registration window (202) has a name field (202a) for entering a flowchart name, a type selection item (202b) for defining the type of the flowchart, i.e., the flowchart to be registered as a project flowchart or template, a tag field (202c) for selecting or entering tag information for the developer to classify or define a directory of the flowchart, and a registration button (201d). A flowchart defined as a project flowchart in the type selection item (202b) is stored in the project library (2b) together with the project name, and can thereafter be searched and selected through the flowchart selection menu (224). In this regard, the flowchart defined as a template in the type selection item (202b) is stored in the template library (2c) and can then be searched and selected through the template selection menu (225).

[0053] In Fig. 2b, the submenu (201) of the work management menu (221) includes a workspace emptying item (201d) for initializing the workspace (21) by removing the flowchart called to the workspace (21), a copying item (201e) for temporarily storing the work content performed through the workspace (21), a pasting item (201f) for re-calling or pasting the copied work content, a downloading item (201g) for storing the work content in local memory, etc., and an uploading item (201c) for calling the downloaded flowchart. Here, the selection items of 201d to 201g are preferably provided to the developer in a state where the flowchart is called in the workspace (21).

[0054] Returning to Fig. 2a, the selection menu (22) is provided with a project name display window (222) and a flowchart name display window (223), which display the project name and the flowchart name, respectively. The display windows (222, 223) display the name of the project currently being worked on and the flowchart name. In addition, the display windows (222, 223) provide submenus for developers to register new projects and flowcharts or manage registered projects and flowcharts, respectively. The developer can call up the submenus by clicking on these display windows (221, 222).

[0055] Although not specifically shown in the drawing, the submenu of the project name display window (221) is provided with a menu for the project manager to register or delete the project name, and preferably a menu for registering or deleting the developer who will participate in the project. Fig. 2d is a drawing showing an example of the submenu (203) of the flowchart name display window (223). In the drawing, the submenu (203) is provided with a flowchart registration item (203a), a project conversion item (203b), a flowchart download item (203c), and a flowchart upload item (203d), similar to the work management menu (221). In addition, the submenu (203) is provided with an empty item (203e) for deleting the work contents of the workspace (21), an edit flowchart information item (203f) for calling the flowchart registration window (202) of Fig. 2c to change or modify information related to the flowchart, a copy item (203g) for duplicating the work contents of the workspace (21), and a delete item (203h) for deleting the current flowchart name from the project library (2b).

[0056] In addition, in FIG. 2A, the selection menu (22) is provided with a flowchart button (224) for calling a selectable flowchart list, a node button (225) for calling a node list, and a template button (226) for calling a template list. In addition, a list display section (227) is provided below these buttons (224 to 226) for displaying a list of flowcharts, nodes, or templates that the developer can select and call in response to the selected button. In addition, in a preferred embodiment, the selection menu (22) is provided with a search window (228) for the developer to search for and call a desired flowchart using the flowchart name.

[0057] Preferably, the flowchart, node, or template list displayed in the list display unit (227) is classified and provided in accordance with the directory information. The developer can click on the directory information in the list display unit (227) to view and select the desired list. In addition, in another preferred embodiment, the flowchart and template are stored and provided using the tag information set by the developer through the tag field (202c) in FIG. 2c as directory information. In another preferred embodiment, the directory provided through the list display unit (227) may include multiple subdirectories.

[0058] Meanwhile, FIG. 2e is a diagram showing an example of a directory list displayed through a list display unit (227) when a developer clicks a node button (225). In the diagram, the directory list (225a) preferably includes a chatbot directory (Chat) for the developer to utilize a chatbot, a content directory (Content) for utilizing content, a data flow directory (Data flow) for appropriately setting data flow, a process control directory (Flow control) for appropriately controlling process flow, a knowledge base directory (Knowledge bases) for utilizing a knowledge base system (4), an LLM directory (LLMs) for utilizing an LLM model, and a tool directory (Tools) for providing tools for data search or web utilization. In the present invention, the node directory list provided through the user interface (20) and the method of providing the same are not specified.

[0059] In addition, Fig. 2f is a diagram illustrating an example of a node list (227b) selectable via a node button (225). In Fig. 2e, when a developer selects a desired node directory, the user interface (20) provides a subdirectory or node list (227b) corresponding to the directory. In the present invention, the node list provided by the user interface (20) and the method of providing the same are not specified and may be modified in various ways.

[0060] Each node in the node list (227b) corresponds to a task performed by the program, including operations. One node can correspond to one program module. Developers can create a desired flowchart by importing an appropriate flowchart or node using the flowchart button (224), node button (225), or template button.

[0061] Fig. 2g is a diagram showing an example of a method for calling a desired node from a node list (227b) to a workspace (21). When a developer wants to call a desired node to a workspace (21), the developer clicks on the desired node item in the node list (227b) with the mouse and then calls the node (30) to a desired location in the workspace (21) by dragging and dropping. The node (30) called to the workspace (21) can be moved to a desired location again by dragging and dropping. The method for calling the node (30) to the workspace (21) is not specified.

[0062] Fig. 2h is a diagram illustrating another example of a method of calling a node (30) in a workspace (21). When a developer right-clicks on an empty area of ​​the workspace (21) with the mouse, a selection window (211) equipped with an 'add node' item is provided in the corresponding click area of ​​the workspace (21). The developer can call a desired node (30) in the workspace (21) by selecting a desired node item from a directory list (227a) and a node list (227b) that are displayed step-by-step from this selection window (211).

[0063] Returning to FIG. 2g, the node (30) has a number of elements (31 to 33) that are schematically arranged. The node (30) basically has an element (31) for defining the work content. In addition, the node (30) has elements (32, 33) for inputting and outputting data as needed. The type and number of elements provided in the node (30) may vary depending on the type of the node (30), i.e., the work that the node (30) must perform.

[0064] Typically, the program source code that constitutes an application contains a number of hyperparameters, and their values ​​need to be appropriately set during programming. In Fig. 1, the hyperparameter engine (13) provides a tool that allows developers to easily set hyperparameters for a node (30). Fig. 2i is a diagram illustrating an example of a hyperparameter setting means provided by the hyperparameter engine (12). When a specific node (30) includes a hyperparameter, if the developer clicks an element (31) of the node (30) with the left mouse button, the hyperparameter engine (12) provides a setting window (212) on the right side of the workspace (21) as a setting means for inputting or setting hyperparameters. In addition, in a preferred implementation example, the setting window (212) is provided with a lock button (212a) that allows the developer to lock or unlock the hyperparameter value in a toggle manner. Developers can set or input hyperparameter values ​​through the settings window (212) and confirm the settings using the lock button (212a). Furthermore, the provision of these setting tools is not limited to setting hyperparameter values. For example, the IDE provider (1) can provide an input window in the same manner when a specific node requires command or prompt input.

[0065] FIG. 2J is a diagram illustrating an example of a selection window (213) related to a node (30) provided by the user interface (20). When a developer right-clicks on a node (30) area, the user interface (20) provides a selection window (213) related to the corresponding node (30). At this time, the selection window (213) includes a selection item for setting the corresponding node as the start node of the flowchart, and selection items for cutting, copying, duplicating, and deleting the corresponding node. In addition, the selection window (213) preferably includes a selection item for collectively releasing the lock status of all hyperparameters input and locked through the setting window (212) in FIG. 2H.

[0066] Returning to FIG. 2g, the node (30) has ports (31a, 32a, 33a) that can be connected to other nodes (30). The node (30) basically has a process port (31a) for establishing a process flow, and optionally includes data ports (32a, 33a) for establishing a data flow. In addition, the data ports (32a, 33a) may include an input port (32a) for data input, and an output port (33a) for data output. In a preferred embodiment, the ports (31a, 32a, 33a) are set to different shapes or colors according to their functions so that developers can easily distinguish the ports. The developer creates a flowchart by appropriately connecting the ports (31a, 32a, 33a) of the nodes (30) using edges.

[0067] FIG. 3 is a diagram showing an example of a process for creating a flowchart in a workspace (21) using a user interface (20). When creating a flowchart in a workspace (21), first, a desired node (30) is called from a node list (227b) and the node (30) is placed in the workspace (21). Then, the process port (31a) and the data port (32a, 33a) of the node (30) are connected with an edge (40) to set the process flow and the data flow in the flowchart. The creation or connection of an edge (40) is executed by clicking on one port (31a, 32a, 33a) with the mouse and dragging the mouse to another desired port (31a, 32a, 33a). In addition, in a preferred implementation example, the IDE provider (1) sets the colors of the edges that set the process flow and the edges that set the data flow differently, so that the developer can easily recognize the process flow and the data flow. In addition, in another preferred implementation example, the IDE provider (1) prevents errors in the flowchart to the greatest extent possible by refusing to create an edge when a developer improperly sets up a process flow or data flow, for example, when a process port (31a) of one node is connected to a data port (32a, 33a) of another node, or when a developer improperly executes an edge connection between nodes, such as when a developer improperly executes an input / output port connection between nodes.

[0068] Meanwhile, as described in FIG. 2e, the node directory list (227a) includes LLM directories (LLMs) for utilizing the LLM model. As can be seen from FIG. 2f, the node list (227b) corresponding to the LLM directory includes Call LLM nodes, Instruction nodes, and the like. Of course, the types of nodes included in the LLM directory in the present invention are not specified. Other appropriate nodes may be added or deleted from the LLM directory.

[0069] FIG. 4 is a diagram showing an example of a call LLM node (30a) and its hyperparameter setting means (241). The call LLM node (30a) transmits a prompt (question or request) entered by a user to the LLM and enables a response to be received. The setting means (241) of the call LLM node (30a) includes a selection window (241a) through which a developer can select an LLM service such as OpenAI, Cohere, Ollama, Anthropic, Groq, GoogleAI, IBM, Deepseek, etc., and a selection window (241b) through which a model or version of the corresponding LLM service can be selected. In addition, the setting means (241) preferably provides a setting window (241c) through which a developer can set LLM parameters such as Temperature, Maximum tokens, Top P, Frequency penalty, Presence penalty, Stop sequences, etc.

[0070] Developers can easily and simply implement a chatbot using the call LLM node (30a). FIG. 5 (FIG. 3) is a flowchart illustrating an example of a chatbot configuration implemented using the call LLM node (30a) and a user input node (30b: User input) for prompt input. As described above, the first and second edges (40a, 40b) in the drawing are for setting the process flow in the flowchart. The first edge (40a) defines the execution order of the user input node (30b) and the call LLM node (30a). In addition, the feedback loop defined as the second edge (40b) provides a function that allows users to repeatedly and continuously utilize the chatbot by setting the process flow back to the user input node (30b) after the execution of the call LLM node (30a). Additionally, the third edge (40c) defines a data flow in which a user prompt entered through the user input node (30b) is provided to the call LLM node (30a).

[0071] Figure 6 is a diagram illustrating an example of an instruction node (30c) and its hyperparameter setting means (242). The instruction node (30c) provides information or commands necessary for other nodes to perform tasks, thereby facilitating smooth process progress. For example, a developer can define the response format of the aforementioned call LLM node (30a) or designate its output structure through the instruction node (30c). The setting means (242) of the instruction node (30c) provides an input window (242a) for the user to input instructions.

[0072] Fig. 7 is a flowchart illustrating another configuration example of a chatbot implemented using the call LLM node (30a) and the user input node (30b: User input) of Fig. 5. Fig. 7 is configured to provide an instruction set through an instruction node (30c) to the call LLM node (30a) using the fourth edge (40d).

[0073] Returning to Fig. 1, the storage unit (2) comprises a node library (2a), a project library (2b), and a template library (2c). The node library (2a) stores node information for each node corresponding to the node list (227b) provided through the list display unit (227) in Fig. 2f. The node information includes program source or code information corresponding to the node. In a preferred embodiment, the node information is written in, for example, JSON (JavaScript Object Notation). Of course, the programming language for writing the node information is not specified in the present invention.

[0074] The project library (2b) stores flowchart information created by the developer through the workspace (1). This flowchart information is stored in correspondence with the flowchart name registered by the developer. Here, the flowchart information includes program source or code information corresponding to the nodes included in the flowchart, and connection information between nodes, i.e., edge (40, Fig. 3) information. That is, the project library (2b) stores node information constituting the flowchart in correspondence with the flowchart name, and its process flow information and data flow information. The flowchart information may correspond to source or code information written in a programming language related to the application.

[0075] Additionally, for flowcharts that are frequently and repeatedly used, developers can save their own flowcharts in the template library (2c) using the flowchart information editing item (203f) of FIG. 2d and the flowchart registration window (202) of FIG. 2c. Flowcharts saved in this manner are provided, along with their category information, as a user interface (20) to display a list of flowcharts that developers can search and select via the template button (226). This function can provide a foundation for easily implementing, for example, a multi-agent system comprising multiple agents.

[0076] In FIGS. 1 and 2c, when a developer registers a flowchart through an input window (202), the IDE provider (1), i.e., the flowchart generator (11), generates a flowchart file along with directory information in the project library (2b). When the developer calls a node (30) as a workspace (21) in FIG. 3, the flowchart generator (11) retrieves node information from the node library (2a) and stores it in a flowchart file. When the developer connects nodes using an edge (40), the flowchart generator (11) generates the connection information and stores it in a flowchart file. Accordingly, the node information corresponding to the flowchart created by the developer and their connection information are stored in the flowchart file. In addition, the hyperparameter engine (13) provides the developer with a hyperparameter setting window (212) as needed, and when the developer inputs or sets a hyperparameter and then locks the lock button (212a), the corresponding hyperparameter value is registered in the flowchart file.

[0077] Meanwhile, in Fig. 2a, the user interface (20) has a run button (229) for executing the generated flowchart and a flowchart operation button (230) for editing the flowchart. The developer can use these buttons to execute or modify the flowchart. The run button (229) is for executing the flowchart engine (12) in Fig. 1. Fig. 8 is a drawing showing an example of a state in which the developer presses the run button (229) after creating the flowchart. When the developer selects the run button (229), the IDE provider (1) activates the execution display window (231) of the user interface (20) and executes the flowchart engine (12). The flowchart engine (12) interprets the node information and edge information stored in the flowchart file of the project library (2b) to execute the flowchart. For example, in the embodiment of FIG. 6, the flowchart engine (12) transmits the user's input prompt to the LLM model through the LLM adapter (5) in FIG. 1, generates a response, and provides it to the user.

[0078] In a preferred embodiment, when an error occurs in a flowchart when the flowchart engine (12) executes the flowchart, the IDE provider (1) provides an interface screen for the developer to correct the error. For example, when there is an error in a user input node (30b) in the flowchart, the IDE provider (1) enables the developer to recognize the node with the error by displaying the node in a different color, and provides the developer with an error window (80). The error window (80) preferably provides a node information display unit (81) for displaying information on the node with the error and a correction unit (82) for the developer to correct the error information. The configuration or form of the correction unit (82) may vary depending on the node where the error occurred. For example, when there is an error in the user input in the user input node (70), the IDE provider (1) provides an input field (82a) for executing the user input in the correction unit (82). Additionally, in a more preferred embodiment, the error window (80) is provided with a guidance section to guide the developer on the error content. In addition, the error window (80) is preferably provided with a lock button (83) that allows the developer to lock the corrections after correcting the error, and a termination button (84) for terminating the error correction.

[0079] If there is an error in the flowchart, the IDE provider (1) activates an error window (80) so that the developer can correct the error. In addition, at this time, the operation of the flowchart engine (12) is temporarily suspended, and the display of the run button (229) of the user interface (20) is set to a paused state. When the developer corrects the error in the error window (80), locks the lock button (93), and presses the exit button (84), the IDE provider (1) resumes the operation of the flowchart engine (12). The above operation is performed in the same manner even if the developer improperly sets the hyperparameters for a specific node. Preferably, the flowchart engine (12) can be utilized for the purpose of allowing the developer to test and debug the application.

[0080] In addition, in a preferred embodiment, the IDE provider (1) provides an interface function that allows the user to efficiently utilize the chatbot function by easily executing a prompt input. Fig. 9 is a drawing showing another example of a user interface (20) provided by the IDE provider (1). In this example, a chatbot execution button (229a) is provided as a submenu of the execution button (229). The chatbot execution button (229a) provides the user with a prompt input window for, for example, a user input node (30b).

[0081] Fig. 10 is a diagram illustrating an example of an interface screen provided to a user when the user selects the chatbot execution button (229a). In the diagram, the interface screen is provided with a prompt input window (91) for the user to input a prompt, and a confirmation button (91a). When the user inputs the desired prompt in the prompt input window (91) and selects the confirmation button (91a), the flowchart engine (12) in Fig. 1 transmits the user's prompt to the LLM model, more precisely, to the LLM model selected by the user through the call LLM node (30a), and generates a response. Fig. 11 is a diagram illustrating an example of a response content (93) generated by the flowchart engine (12) in response to the user's prompt input (92). At this time, a prompt input window (91) is preferably provided below the response content (93) so that the user can continuously input a prompt.

[0082] The embodiments of the present invention have been described above. However, the present invention is not limited to the above-described embodiments, and various modifications may be made without departing from the technical spirit thereof.

Claims

1. In a development system for developing artificial intelligence applications, An IDE provider that provides an IDE that allows developers to develop applications based on graphics, Storage device that contains node libraries and project libraries, and Consists of an LLM adapter for connection with the LLM model, The above IDE provider comprises a user interface that allows developers to create flowcharts using nodes and edges, and a flowchart engine for interpreting and executing flowcharts. The above user interface has a workspace, a node calling means for the developer to call the desired node to the workspace, and an edge connecting means for connecting edges to establish process flow and data flow between nodes. The above node calling means includes a node directory list for providing a node list classified by purpose, An artificial intelligence application development system, characterized in that the above node directory list includes an LLM directory for providing a node list for utilizing LLM.

2. In paragraph 1, An artificial intelligence application development system, wherein the above node list includes a call LLM node or an instruction node.

3. In paragraph 2, An artificial intelligence application development system characterized in that the above IDE provider device additionally includes a hyperparameter engine that provides a hyperparameter setting means for setting hyperparameters for a node called as a workspace.

4. In paragraph 1, The above node library has node information related to a node that can be called by a developer, and the node information includes program source or code information corresponding to the node. An artificial intelligence application development system characterized in that the above project library stores flowchart information corresponding to a flowchart created through a workspace, and the flowchart information includes node information and edge information of nodes included in the flowchart.

5. In paragraph 4, An artificial intelligence application development system characterized in that the above node information is written in JSON.

6. In paragraph 1, An artificial intelligence application development system, characterized in that the above node has a process port connected to an edge.

7. In paragraph 6, An artificial intelligence application development system, wherein the above node has a data port connected to an edge, and the data port includes a data input port and a data output port.

8. In paragraph 7, An artificial intelligence application development system characterized in that the above edge includes a first edge connected to a process port to establish a process flow, and a second edge connected to a data port to establish a data flow.

9. In paragraph 3, The above IDE provider provides a first configuration means for the call LLM node, An artificial intelligence application development system characterized in that the first setting means has a selection window for a user to select an LLM service.

10. In paragraph 9, An artificial intelligence application development system, characterized in that the first setting means further comprises a setting window for a user to set LLM parameters.

11. In paragraph 3, The above IDE provider provides a second configuration means for the instruction node, An artificial intelligence application development system characterized in that the second setting means provides an input window for inputting instructions.

12. In paragraph 1, An artificial intelligence application development system characterized in that the user interface provides an execution window for a user to execute a prompt input for LLM.

Images