IDE provision device capable of generating flow graph on basis of graphics, and artificial intelligence application development system using same

Abstract

The present invention relates to an IDE provision device for generating a flow graph on basis of graphics, and an artificial intelligence applicator development system using same. The artificial intelligence application development system according to the present invention comprises: an IDE provision device (1) for providing an IDE through which a developer can generate a flow graph on the basis of graphics; a storage device (2) having a node library and a project library; and a flow graph execution engine (3) for interpreting and executing the flow graph generated through the IDE. The IDE provision device (1) includes a user interface (20) for enabling the developer to generate the flow graph by using nodes and edges, wherein the user interface (20) includes a node calling means by which the developer calls 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.

Description

An IDE device capable of generating flowcharts based on graphics, and an artificial intelligence application development system using this device.

[0001] The present invention relates to an integrated development environment providing device that enables easy development of artificial intelligence applications based on graphics, and an artificial intelligence application development system using the same.

[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 object of the present invention is to provide an IDE providing device that provides an IDE capable of generating a flowchart based on a graphic base.

[0008] In addition, the present invention has another technical purpose of providing an artificial intelligence application development system capable of developing an artificial intelligence application through the creation of a flowchart.

[0009] According to a first aspect of the present invention, an IDE providing device provides an IDE capable of graphically generating a flowchart used in developing an artificial intelligence application or model, the IDE providing device having a user interface for a developer, the user interface including a workspace and a selection menu, the selection menu including a node list for selecting a node required for generating a flowchart, the user interface including a node calling means for a developer to call a node from the node list to the workspace, and an edge connecting means for connecting between nodes called to the workspace via an edge, the edge including a first edge for setting a process flow and a second edge for setting a data flow.

[0010] According to the present invention, an IDE is provided that enables developers to graphically create flowcharts using nodes and edges. The IDE provides a means to configure process and data flows within the flowchart. This provides a foundation for graphically developing loop and decision tree processes and artificial intelligence applications that require user interaction.

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

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

[0013] FIG. 2b is a drawing showing an example of a flowchart registration window (201) provided by the IDE provider (1) when the flowchart registration menu (222) is selected in FIG. 2a.

[0014] FIG. 2c is a drawing showing an example of an interface screen provided by the IDE provider (1) when the developer selects the flowchart extension menu (224) in FIG. 2a.

[0015] FIG. 2d is a drawing showing an example of a list of categories (225a) selectable through the node selection menu (225) in FIG. 2a;

[0016] FIG. 2e is a diagram showing an example of a list of nodes (225b) that can be selected through selection of a category list (225a) in FIG. 2d.

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

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

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

[0020] 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).

[0021] Figure 4 is a drawing showing the types of nodes for setting up data flow and an example of their configuration.

[0022] Figure 5 is a drawing showing the types of nodes for setting up a process flow and an example of their configuration.

[0023] FIG. 6a is a drawing showing an example of a setting window (214) provided corresponding to a path selection node (301) in FIG. 5.

[0024] FIG. 6b is a drawing showing an example of a setting window (215) provided corresponding to the loop control node (302) in FIG. 5.

[0025] FIG. 6c is a drawing showing an example of a setting window (216) provided corresponding to the match-branch node (303) in FIG. 5.

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

[0027] According to a first aspect of the present invention, an IDE providing device provides an IDE capable of graphically generating a flowchart used in developing an artificial intelligence application or model, the IDE providing device having a user interface for a developer, the user interface including a workspace and a selection menu, the selection menu including a node list for selecting a node required for generating a flowchart, the user interface including a node calling means for a developer to call a node from the node list to the workspace, and an edge connecting means for connecting between nodes called to the workspace via an edge, the edge including a first edge for setting a process flow and a second edge for setting a data flow.

[0028] In addition, the node is characterized in that it can be connected to other nodes through an edge and has a process port for setting up a process flow.

[0029] In addition, the node is characterized in that it is connectable to other nodes through an edge and has a data port for establishing a data flow, and the data port includes a data input port and a data output port.

[0030] Additionally, the user interface is characterized in that it rejects the creation of an edge if there is an error in the edge connection between nodes.

[0031] Additionally, it is characterized in that the colors of the first edge and the second edge are set differently.

[0032] According to a second aspect of the present invention, an artificial intelligence application development system is provided, which is a development system for developing an artificial intelligence application, comprising: an IDE providing device that provides an IDE capable of generating a flowchart on a graphic basis; and a storage device having a node library and a project library, wherein the IDE providing device has a user interface that allows a developer to generate a flowchart using nodes and edges, and a flowchart generator that generates flowchart information in a project library corresponding to the flowchart, wherein the user interface has a workspace, and also has a node calling means for allowing a developer to call a desired node to the workspace, and an edge connecting means for connecting edges between nodes, wherein the edges include a first edge for setting a process flow and a second edge for setting a data flow, wherein 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 flowchart information includes node information and edge information of a node included in the flowchart.

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

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

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

[0036] In addition, the artificial intelligence application development system is characterized by further including a flowchart execution engine for interpreting and executing the flowchart information.

[0037] In addition, the flowchart execution engine is characterized in that if there is an error in the flowchart information, it notifies this through the user interface.

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

[0039] Figure 1 is a block diagram showing 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 providing device (1) that provides an integrated development environment (IDE) that allows developers to create flowcharts based on graphics, a storage unit (2) that stores various data necessary for the operation of the IDE and the development of AI, and a flowchart execution engine that interprets and executes flowcharts developed through the IDE.

[0040] 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).

[0041] The storage unit (2) comprises a node library (21) in which node information for creating a flowchart is stored, and a project library (22) in which all information related to the application the developer wishes to develop is stored. These libraries will be described in detail later.

[0042] The flowchart execution engine (3) interprets and executes flowcharts created by developers. The flowchart execution engine (3) manages data inputs corresponding to nodes, conditional branching, and interactions with external devices when executing the flowchart. The flowchart execution engine (3) can preferably be utilized as a means for testing and debugging flowcharts created by developers, i.e., applications.

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

[0044] 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) includes a project name selection menu (221) for registering and selecting a project name, a flowchart registration menu (222) for registering a new flowchart, and a flowchart selection menu (223) for selecting and loading an existing registered flowchart. Fig. 2b is a drawing showing an example of a flowchart registration window (201) provided by the user interface (20) when the flowchart registration menu (222) is selected. In the drawing, the flowchart registration window (201) includes a name field (201a) for entering a flowchart name, a category field (201b) for selecting or registering a category, and a registration button (201c). The flowchart registered through the flowchart registration window (201) is saved in the project library (3) along with the project name, and can then be viewed and selected through the flowchart selection menu (223).

[0045] A display window (23) is provided on the upper side of the workspace (21) to display the project name and flowchart name. The display window (23) displays the project name and flowchart name selected by the developer through the project name selection menu (221) and the flowchart selection menu (223). In other words, the display window (23) displays the project name and flowchart name related to the application currently being developed.

[0046] One side of the flowchart registration menu (222) is provided with an extension menu (224) related to the flowchart. Fig. 2c is a drawing showing an example of an interface screen provided by the IDE provider (1) when a developer selects the flowchart extension menu (224). In the drawing, the flowchart extension menu (224) is provided with a number of selection items (224a to 224f) that the developer can select in relation to the flowchart currently being worked on. These selection items include a delete item (224a) for initializing the workspace (21), an edit item (224b) for returning to the flowchart registration window (201) of Fig. 2b to modify or edit flowchart-related information, a copy item (224c) for copying the work content, a download item (224d) for saving the flowchart to a local memory or other storage means, a flowchart delete item (224e) for deleting the corresponding flowchart list, and an upload item (224f) for uploading the flowchart that was downloaded.

[0047] Meanwhile, in FIG. 2a, the user interface (20) includes a node selection menu (225). The node selection menu (225) preferably includes a category list and a node list. These can be viewed and selected by the developer by selecting the node selection menu (225). FIG. 2d is a diagram illustrating an example of a category list (225a) selectable through the node selection menu (225). In the present invention, the list of node categories provided through the user interface (20) and the method of providing the same are not specified.

[0048] In addition, FIG. 2e is a diagram illustrating an example of a node list (225b) selectable through a node selection menu (225). In FIG. 2d, when a developer selects a desired node category, the user interface (20) provides a node list (225b) corresponding to the selected category. 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.

[0049] Each node in the node list (225b) 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 selecting an appropriate flowchart or node from the flowchart selection menu (223) and node selection menu (225).

[0050] FIG. 2f is a diagram showing an example of a method for calling a desired node from a node list (225b) to a workspace (21). When a developer wishes to call a desired node to a workspace (21), the developer clicks on the desired node item in the node list (225b) 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 then be moved to a desired location by dragging and dropping again. The method for calling the node (30) to the workspace (21) is not specified.

[0051] Fig. 2g is a drawing showing 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) having an 'add node' item is provided in the corresponding clicked 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 category list (225a) and a node list (225b) that are displayed step-by-step from this selection window (211).

[0052] Returning to FIG. 2f, 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.

[0053] FIG. 2h is a diagram illustrating an example of a selection window (213) related to a node (30) provided by a 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 node (30). At this time, the selection window (213) includes a selection item for setting the node as the start node of the flowchart, and selection items for cutting, copying, duplicating, and deleting the node.

[0054] Returning to FIG. 2f, 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.

[0055] FIG. 3 is a diagram illustrating 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 (225b) 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.

[0056] In a preferred embodiment of the present invention, the category list (225a) of the node selection menu (225) includes a data flow category that includes a list of nodes for setting up a data flow. Fig. 4 is a diagram illustrating the types of nodes included in the data flow category, i.e., nodes for setting up a data flow, and an example of their configuration.

[0057] In a more preferred embodiment of the present invention, the category list (225a) of the node selection menu (225) includes a flow control category that includes a list of nodes for setting up a process flow. Fig. 5 is a diagram illustrating the types of nodes included in the flow control category, i.e., nodes for setting up a process flow, and examples of their configurations. Nodes for setting up a process flow include a path selection node (301), a loop control node (302), and a match-branch node (303).

[0058] The path selection node (301) provides a function that allows the user to select a path of the process flow. The IDE provider (1) provides a setting window that allows the developer to set the number of branches of the path selection node (301). Fig. 6a is a drawing showing an example of a setting window (214) provided in response to the path selection node (301). The setting window (214) is created when the developer clicks the path selection node (301) area with the mouse. The setting window (214) has an add branch button (214a) for the developer to add a branch port, and a remove branch button (214b) for the developer to remove a branch port. In addition, the setting window (214) has a lock button (214c) for locking or unlocking a value set by the developer, i.e., the number of branch ports. In the drawing, the node (301a) represents a state in which the developer has increased the number of branch ports of the path selection node (301) using the setting window (231).

[0059] The loop control node (302) provides developers with the ability to control the repetitive execution of a process flow. The IDE provider (1) provides a settings window that allows developers to set the number of repetitions of the process flow. Figure 6b is a diagram illustrating an example of a settings window (215) provided in response to the loop control node (302).

[0060] The match-branch node (303) provides a function to branch input by pattern. The IDE provider (1) provides a setting window in which the developer can set the match pattern and branch. Fig. 6c is a drawing showing an example of a setting window (216) provided in response to the match-branch node (303). The setting window (216) has a field (216a) for the developer to define a pattern, buttons (216b, 216c) for adding and removing the field and branch, and a lock button (216d) for locking or releasing the setting value through the setting window (216). In the drawing, the node (303a) shows a state in which the developer has added a branch port of the match-branch node (303) using the setting window (216).

[0061] Figures 4 and 5 are exemplary examples of nodes for establishing process flow and data flow, and the configuration and types of these nodes are not specified. The configuration and types of nodes may be appropriately changed depending on the application or programming language. The nodes for establishing process flow and data flow provide the effect of simplifying the overall structure of the flowchart and enabling developers to easily create flowcharts. The flowchart according to the present invention includes process flow as well as data flow in a single flowchart. This provides a basis for establishing loops and decision tree processes and user interaction that are not possible in a flowchart with only data flow.

[0062] Returning to Fig. 1, the storage unit (2) comprises a node library (21) and a project library (22). The node library (21) stores node information for each node corresponding to the node provided to the developer by the IDE provider (1), i.e., the node list (225b) provided through the node selection menu (225) in Fig. 2e. Here, 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.

[0063] The project library (22) 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 (3) 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 in relation to the application.

[0064] In FIGS. 1 and 2b, when a developer registers a flowchart through an input window (201), the IDE provider (1), i.e., the flowchart generator (11), generates a flowchart file along with directory information in the project library (3). When the developer calls a node (30) to the workspace (21) in FIG. 3, the flowchart generator (11) retrieves node information from the node library (2) and stores it in the flowchart file. When the developer connects nodes using an edge (40), the flowchart generator (11) generates the connection information and stores it in the flowchart file. Accordingly, the node information corresponding to the flowchart created by the developer and their connection information are stored in the flowchart file.

[0065] Meanwhile, in Fig. 2a, the user interface (20) has a flowchart work button (226) for editing a flowchart and a run button (227) for executing the generated flowchart. The developer (227) can use these buttons to execute or modify the flowchart. The run button (227) is for executing the flowchart execution engine (3) in Fig. 1. Fig. 7 is a drawing showing an example of a state in which the developer presses the run button (227) after creating a flowchart. When the developer selects the run button (227), the IDE provider (1) activates the execution display window (228) of the user interface (20) and executes the flowchart execution engine (3). The flowchart execution engine (3) interprets the node information and edge information stored in the flowchart file of the project library (22) to execute the flowchart.

[0066] In a preferred embodiment, when an error occurs in the flowchart when the flowchart execution engine (3) 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 the prompt input node (70a) 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 also activates the prompt input window (71) of the prompt input node (70a) so that the developer can reset the prompt input. In addition, at this time, the operation of the flowchart execution engine (3) is temporarily suspended, and the display of the execution button (228) of the user interface (20) is set to a temporarily suspended state. When the developer executes an appropriate prompt input in the prompt input window (71), locks the lock button (71a), and presses the complete button (71b), the IDE provider (1) resumes the operation of the flowchart execution engine (3). Preferably, the flowchart execution engine (3) can be utilized for developers to test and debug AI applications.

[0067] 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 an IDE providing device that provides an IDE that can graphically create a flowchart used in developing an artificial intelligence application or model, It has a user interface for developers, The above user interface includes a workspace and a selection menu, The above selection menu provides a list of nodes for selecting the nodes required to create a flowchart, The above user interface includes a node calling means for developers to call nodes from the node list to the workspace, and It has an edge connection means for connecting nodes called as workspaces through edges. An IDE providing device capable of generating a flowchart based on graphics, wherein the above edge includes a first edge for setting a process flow and a second edge for setting a data flow.

2. In paragraph 1, An IDE providing device capable of generating a flowchart based on graphics, wherein the above node is capable of connecting to other nodes through edges and has a process port for setting a process flow.

3. In paragraph 1, An IDE providing device capable of generating a flowchart based on graphics, wherein the above node is connectable to other nodes through an edge, has a data port for establishing a data flow, and the data port includes a data input port and a data output port.

4. In paragraph 1, An IDE providing a graphical flowchart generation device characterized in that the user interface rejects the creation of edges if there is an error in the edge connection between nodes.

5. In paragraph 1, An IDE providing device capable of generating a flowchart based on graphics, characterized in that the colors of the first edge and the second edge are set differently.

6. In a development system for developing artificial intelligence applications, An IDE provider that provides an IDE that can create flowcharts on a graphical basis, It consists of a storage device that contains a node library and a project library, The above IDE provider has a user interface that allows developers to create flowcharts using nodes and edges, and a flowchart generator that creates flowchart information in a project library corresponding to the flowchart. 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 between nodes. The above edge includes a first edge for setting up a process flow and a second edge for setting up a data flow, 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 flowchart information includes node information and edge information of nodes included in the flowchart.

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

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

9. In paragraph 8, An artificial intelligence application development system, characterized in that 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.

10. In paragraph 6, An artificial intelligence application development system characterized in that the above artificial intelligence application development system further comprises a flowchart execution engine for interpreting and executing the flowchart information.

11. In paragraph 10, An artificial intelligence application development system characterized in that the above flowchart execution engine notifies the user interface if there is an error in the flowchart information.

Images