Intelligent collaborative development method, device and equipment for large language model application

Abstract

The invention provides an intelligent collaborative development method, device and equipment for large language model application, and relates to the field of software development. The invention aims to realize the whole process automation from thinking to code design through multi-person cooperation. On the basis of hierarchical canvas design, the main canvas is used for carding development thoughts and flexibly setting nodes, and the sub-canvas is used for generating and editing actual codes. Each canvas node (thought node, planning node, task node and development node) interacts with the large language model to support intelligent content generation and design. And an integrated development environment is also integrated, so that real-time data interaction between codes generated by the canvas and the IDE can be realized. In addition, historical records generated by the nodes can also be submitted and stored through the version control system, and it is ensured that all changes and historical versions are effectively managed. According to the method, the development efficiency and the code quality are remarkably improved, and the defects of a traditional development tool in the aspects of collaboration, automation and code management are overcome.

Description

Technical Field

[0001] The present invention relates to the field of software development technology, and in particular to an intelligent collaborative development method, device and equipment for large language model applications. Background Art

[0002] With the increasing complexity of software development, how to improve development efficiency, reduce errors, and promote team collaboration has become an important topic in the current technology field. The traditional software development process usually requires the combined use of multiple development tools, such as requirements management tools, design tools, integrated development environments (IDEs, such as VSCode), version control systems, etc. Although these tools each provide support for different stages of the development process, the switching and data inconsistencies between them often lead to reduced development efficiency. In addition, the collaboration of team members during the development process relies on frequent communication and manual synchronization, which increases the complexity of management and coordination. Especially in large projects, the incoordination in the development process may lead to serious development bottlenecks and code quality issues.

[0003] In recent years, large language models (LLMs) and retrieval-augmented generation (RAG) technologies have shown great potential in code generation and automated design. These technologies can generate code snippets, design plans, or other related technical documents based on natural language instructions, significantly reducing the workload of developers. However, current application scenarios are mostly for single-person use, and the contextual understanding of the generated content and the logical relationship across steps have not been fully solved, which is particularly prominent in complex development tasks involving multi-person collaboration.

[0004] Although existing collaborative development tools can partially achieve information sharing and task allocation among teams, they usually lack seamless integration across tools and stages. In particular, between code design and actual development, existing tools often cannot provide real-time and synchronous interaction, resulting in a gap between design and implementation, further increasing the difficulty of code maintenance and communication costs. Summary of the invention

[0005] In view of the fact that existing collaborative development tools lack seamless integration across tools and stages, and that there are difficulties in code maintenance and high communication costs in complex development tasks involving multi-person collaboration, the present invention provides an intelligent collaborative development method, device, and equipment for large language model applications. The present invention uses a large language model to achieve full process automation from idea building to code generation, and provides efficient team collaboration and real-time code debugging functions by integrating IDE (such as VSCode) and version control system (Git). The present invention supports multi-node interaction and customized workflows, greatly improving development efficiency and flexibility.

[0006] In a first aspect, the present invention provides an intelligent collaborative development method for a large language model application, comprising: Step 1: In response to a user request, enter the main canvas interface; Step 2: In response to the user's note node creation operation, create an idea node and a planning node in the main canvas interface; wherein the idea node interacts with the large language model to convert the user's idea into a specific concept text or code snippet; the planning node interacts with the large language model to define the project structure or module design according to the content of all idea nodes associated with the planning node; Step 3: After the user selects a planning node in the main canvas interface, in response to the user's task tool operation, a sub-canvas interface is entered and multiple task nodes associated with the planning node are generated in the sub-canvas interface; wherein the task nodes interact with the large language model to generate specific development task text or code snippets; After the user selects a task node in the sub-canvas interface, multiple development nodes associated with the task node are generated in response to the user's development tool operation; wherein the development nodes interact with the IDE in real time to ensure that the code in the development process is consistent with the project design; Step 4: In response to the content submitted by the user and the operation of the wiring tool, multiple note nodes in the main canvas and the sub-canvas are connected in order to form a complete workflow.

[0007] Furthermore, it also includes: saving the historical records and prompt word records generated by each note node through a version control system.

[0008] Furthermore, it also includes: providing a collection tool and a subset tool; wherein the collection tool allows the user to integrate multiple note nodes to generate a new note node; the subset tool allows the user to split a single note node into multiple sub-note nodes.

[0009] Furthermore, the wiring tool allows the user to establish contextual dependencies and / or logical relationships between different note nodes.

[0010] Furthermore, each note node has an editing interface, and an input box is provided on the editing interface, and the input box is used to receive user input; Correspondingly, the interaction process between each note node and the large language model specifically includes: the user summons the AI ​​tool by entering preset instructions in the input box. Once the AI ​​tool is summoned, the large language model is called to generate specific text or code snippets based on the preliminary content input by the user, and the generated content is displayed in the editing interface for the user to browse.

[0011] Furthermore, it also includes: responding to user needs, performing multi-node real-time interaction, specifically including: capturing each user operation in real time, and synchronizing the node changes caused by the user operation to the interface of other project members.

[0012] Furthermore, it also includes: creating a message board in the main canvas interface and / or the sub-canvas interface, wherein the message board allows users to leave messages to interact with other project members.

[0013] In a second aspect, the present invention provides an intelligent collaborative development device for a large language model application, comprising: an interaction module, an intelligent collaborative development module, a large language model, and an IDE; An interactive module, used to access a variety of input devices, wherein the input devices are used for users to input requests or perform operations; the operations include note node creation operations, node selection operations, and tool operations; The intelligent development module is used to enter the main canvas interface in response to a user request; create a thought node and a planning node in the main canvas interface in response to a user's note node creation operation; after the user selects a planning node in the main canvas interface, enter the sub-canvas interface in response to the user's task tool operation and generate multiple task nodes associated with the planning node in the sub-canvas interface; after the user selects a task node in the sub-canvas interface, generate multiple development nodes associated with the task node in response to the user's development tool operation; in response to the content submitted by the user and the connection tool operation, connect multiple note nodes in the main canvas and the sub-canvas in order to form a complete workflow; The big language model is used to interact with the note node; specifically, the idea node interacts with the big language model to convert the user's idea into a specific concept text or code snippet; the planning node interacts with the big language model to define the project structure or module design according to the content of all idea nodes associated with the planning node; the task node interacts with the big language model to generate a specific development task text or code snippet; IDE, used to interact with development nodes in real time to ensure that the code during development is consistent with the project design.

[0014] Furthermore, a version control system is included to save the historical records generated by each note node.

[0015] The intelligent collaborative development device of the present invention is a collaborative development platform based on a large language model and hierarchical canvas interaction, which aims to integrate the whole process of development from idea to code design into a unified environment, and is particularly suitable for complex team collaboration scenarios. The platform integrates a large language model, IDE and Git version control system to form a full-process automated environment from idea construction to code generation, debugging and preservation.

[0016] In a third aspect, the present invention provides an electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the method described in the first aspect when executing the program.

[0017] In a fourth aspect, the present invention provides a non-transitory computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the method described in the first aspect.

[0018] Beneficial effects of the present invention: (1) Improve development efficiency: By integrating idea building, planning and design, task decomposition, and code development functions on a unified canvas, the present invention significantly reduces the switching time between tools and improves development efficiency. Users can complete the entire process from idea to code on one platform, avoiding the frequent context switching in traditional development and ensuring smooth information transmission and data consistency.

[0019] (2) Optimizing the application of large language models: By embedding large models in the canvas and interacting with the IDE in real time, the automatically generated code can be directly used in actual development, reducing the workload of manual debugging and improving the quality of generated code.

[0020] (3) Optimizing team collaboration: The hierarchical canvas and multi-node real-time interaction mechanism of the present invention greatly improve the efficiency of team collaboration. Team members can organize and plan ideas on the main canvas, develop code on the sub-canvas, and keep information synchronized through real-time interaction. This integrated collaboration platform reduces communication barriers and ensures project consistency and collaborative work effects.

[0021] (4) Enhanced code quality and consistency: Automated code generation and version control management ensure code style and version consistency. Code content generation relies on a common library of code components to ensure consistent style of submitted code and reduce errors and omissions in manual judgment. At the same time, each submitted code is automatically saved through Git. These improve code quality and management reliability and reduce the complexity of version management.

[0022] (5) Improve real-time debugging capabilities: Through close integration with the IDE, the present invention allows users to enter the IDE at any time to debug the code during the canvas node editing process. This real-time debugging capability enables developers to verify and adjust the code instantly, shortening the development cycle and improving the accuracy of the code.

[0023] (6) Simplify the development process: The present invention provides a fully automated development environment that integrates a large language model, IDE, and version control system. This integration simplifies each link in the development process, allowing developers to focus more on creation and problem solving rather than tool and process management.

[0024] The present invention greatly improves the efficiency and collaboration of software development through an integrated development platform and automated management, enabling the development team to complete the entire development process from idea to code more quickly and efficiently. BRIEF DESCRIPTION OF THE DRAWINGS

[0025] Figure 1 One of the flow charts of an intelligent collaborative development method for a large language model application provided by an embodiment of the present invention; Figure 2 A second flow chart of an intelligent collaborative development method for a large language model application provided by an embodiment of the present invention; Figure 3 A schematic diagram of a planning tool and a development tool provided by an embodiment of the present invention; Figure 4 A schematic diagram of a connection tool provided by an embodiment of the present invention; Figure 5 A schematic diagram of a collection tool provided by an embodiment of the present invention; Figure 6 A schematic diagram of a subset tool provided by an embodiment of the present invention; Figure 7 The process of content editing by the note node and AI interaction provided in the embodiment of the present invention; Figure 8 The interaction mode between the canvas / IDE and the user provided in the embodiment of the present invention; Fig. 9 The development node and IDE interaction process provided by the embodiment of the present invention; Fig.10 A schematic diagram of the structure of an intelligent collaborative development device for a large language model application provided by an embodiment of the present invention; Fig.11 A structural block diagram of an electronic device provided by an embodiment of the present invention. DETAILED DESCRIPTION

[0026] In order to make the purpose, technical solution and advantages of the present invention clearer, the technical solution in the embodiment of the present invention will be clearly described below in conjunction with the drawings in the embodiment of the present invention. Obviously, the described embodiment is a part of the embodiment of the present invention, not all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0027] The relevant professional terms in the technical field involved in the present invention are explained as follows: (1) Large Language Model A large language model is an artificial intelligence model based on deep learning technology, trained on a large amount of text data, and capable of understanding, generating, and translating human language. This type of model generates natural language output related to the input by identifying patterns and contexts, and is widely used in tasks such as dialogue systems, text generation, and content summarization.

[0028] (2) RAG (Retrieval-Augmented Generation) RAG is a technical framework that combines information retrieval and generative models. It retrieves relevant content from a knowledge base or document collection and then uses a generative model to generate text. This approach enhances the ability of the generative model to leverage external knowledge to generate more accurate and informative answers or content.

[0029] (3) IDE (Integrated Development Environment) An integrated development environment (IDE) is an all-in-one software application for program developers, which usually includes a code editor, compiler, debugger, and graphical user interface. The main purpose of an IDE is to simplify the software development process and improve development efficiency. Common IDEs include Visual Studio Code, Eclipse, and IntelliJIDEA.

[0030] (4) Git Git is a distributed version control system used to track changes in software development projects and coordinate collaboration among multiple developers. Git allows users to modify code locally, commit and manage versions, and push these changes to remote repositories such as GitHub or GitLab to achieve team collaboration and version control. It provides a powerful history function to ensure that each version of the project can be traced and restored.

[0031] Combination Figure 1 and Figure 2 As shown, an embodiment of the present invention provides an intelligent collaborative development method for a large language model application, comprising the following steps: S101: In response to a user request, entering the main canvas interface; Specifically, the system responds to the user's request and launches the AI ​​programmer's application. After startup, the system will display the main canvas interface, where users can start the preliminary planning and design of software development. The main canvas interface is the core working area of ​​the entire system, through which users can manage the overall structure, layout and workflow of the project. The main canvas contains multiple tools and functions that allow users to create and edit the main components of the project, such as note nodes.

[0032] S102: In response to the user's note node creation operation, create an idea node and a planning node in the main canvas interface; wherein the idea node interacts with the large language model to convert the user's idea into a specific concept text or code snippet; the planning node interacts with the large language model to define a project structure or module design according to all idea node contents associated with the planning node; Specifically, the functions of idea nodes mainly include the following two aspects: (1) Preliminary conception and idea collection. Idea nodes are the starting point of the development process. Users generate preliminary ideas, concepts or code drafts through these nodes. This stage aims to capture users' creativity and ideas and lay the foundation for subsequent detailed planning and execution. (2) Interaction with the large language model. Idea nodes help users transform vague ideas into specific text or code snippets by interacting with the large language model. The large language model can provide suggestions, supplementary information or generate code drafts to accelerate the formation of ideas. At the same time, the necessity of setting up idea nodes is reflected in the following two aspects: (1) Meeting innovation and diversity. Idea nodes allow users to explore various possibilities at the beginning of the project to ensure that all potential solutions and ideas are considered. (2) Reduce risks. By quickly generating and evaluating preliminary concepts, users can identify potential problems or opportunities in the early stages of development, thereby reducing risks in the subsequent development process.

[0033] The functions of planning nodes mainly include the following three aspects: (1) Structured design and detailed planning. Planning nodes transform the initial ideas in idea nodes into more structured project plans. This stage aims to refine the initial concepts, define them as specific modules or functions, and clarify the overall architecture of the project. (2) Extract structured data with keywords. When generating a planning node, users need to provide a keyword. The keyword is used to extract structured data from the planning content. These data will provide a basis for the next step of task node generation, making the creation of tasks more targeted and operational. (3) Further interaction with the large language model. Planning nodes help users further define project structures, such as module design, data structure, interface specifications, etc., through interaction with the large language model. These plans provide clear guidance for subsequent task decomposition and code development. At the same time, the necessity of setting planning nodes is reflected in the following three aspects: (1) Ensure development consistency. Planning nodes provide clear directions and standards for project development, ensuring that all development activities are carried out around a clear structure. (2) Reduce rework. By designing the project structure in detail in the planning node, potential design problems can be identified and solved in advance, reducing later rework and adjustments. (3) Optimize task allocation. By extracting structured data through keywords, tasks can be allocated more effectively, ensuring that each task can be accurately defined and executed.

[0034] S103: After the user selects a planning node in the main canvas interface, in response to the user's task tool operation, a sub-canvas interface is entered and multiple task nodes associated with the planning node are generated in the sub-canvas interface; wherein the task nodes interact with the large language model to generate specific development task text or code snippets; After the user selects a task node in the sub-canvas interface, multiple development nodes associated with the task node are generated in response to the user's development tool operation; wherein the development nodes interact with the IDE in real time to ensure that the code in the development process is consistent with the project design; Specifically, users can perform a series of operations in the canvas interface to create multiple note nodes. In response to the user's operations, the system uses the note tool to generate different types of note nodes, including idea nodes (idea construction), planning nodes (planning design), task nodes (task decomposition) and development nodes (code development). These nodes are created in sequence to form a workflow for development work.

[0035] The canvas is divided into the main canvas and the sub-canvas. Idea nodes and planning nodes are located in the main canvas; after selecting the planning node, click the task tool to enter the sub-canvas, create a task node under the sub-canvas, and generate multiple development nodes based on the task node. Users can create idea nodes and planning nodes in the main canvas node. When the user uses the task tool in the main canvas interface, the system will respond to the user's operation and open a new sub-canvas interface. In the sub-canvas, the system will automatically generate multiple task nodes associated with the main canvas planning node. These nodes are refinements of the planning node content in the main canvas. Users can select a task node in the sub-canvas to generate multiple development nodes.

[0036] The functions of task nodes mainly include the following three aspects: (1) Task refinement and clear division of labor. Task nodes further decompose the modules or functions defined in the planning nodes into specific development tasks. This stage decomposes complex projects into manageable subtasks and clarifies the goals and execution methods of each task. (2) Relying on structured data to generate tasks. The number and content of task nodes generated directly depend on the structured data extracted from the planning nodes. Based on this data, task nodes can be precisely defined to ensure that the goals and scope of development tasks are clear. (3) Interacting with large language models to generate tasks. Task nodes generate specific development tasks or code snippets by interacting with large language models. Large language models can help users define the implementation steps of tasks, generate code samples, or provide technical support. At the same time, the necessity of setting task nodes is reflected in the following two aspects: (1) Improving execution efficiency. Task nodes decompose large projects into multiple independent tasks, which are easy to assign to different developers or teams for parallel processing, thereby improving project execution efficiency. (2) Reducing communication costs. Task nodes clarify the goals and scope of each development task, reducing communication costs and misunderstanding risks between teams.

[0037] The functions of development nodes mainly include the following three aspects: (1) Actual development and code implementation. Development nodes are the specific execution stages of task nodes. Task nodes are mapped to sub-canvases to generate multiple development nodes, on which developers actually write and test code. (2) Information extraction and keyword generation of development nodes. When generating development nodes, users need to provide extracted information and keywords. After extracting structured data from task nodes, the system generates multiple development nodes. These development nodes represent specific development steps or code implementation parts. (3) Real-time interaction with IDE. Development nodes interact with IDE in real time to ensure that the code in the development process is consistent with the project design. While the code is being written, it can be debugged, optimized, and verified in the IDE. At the same time, the necessity of setting up development nodes is reflected in the following two aspects: (1) Ensuring code quality and consistency. Real-time interaction between development nodes and IDE enables code to be tested and optimized while being developed, ensuring the consistency of code quality and project design. (2) Improving development flexibility. By decomposing tasks into development nodes, developers can work independently on their respective sub-canvases while ensuring seamless integration with the overall project.

[0038] Task tools and development tools are used to plan and execute project tasks respectively. Users can select a planning node on the canvas and use the task tool to split it into multiple parallel task nodes, each of which corresponds to a specific development task. Then, users can use the development tool in the sub-canvas to further refine the task node into multiple development steps. Each development step can directly perform one-way code transmission with the IDE to achieve real-time code generation and debugging. Figure 3 shown.

[0039] S104: In response to the content submitted by the user and the connection tool operation, multiple note nodes in the main canvas and the sub-canvas are connected in order to form a complete workflow.

[0040] Specifically, through the connection tool, the system organizes each note node and its content (such as text description, code snippet, task description, etc.) into a complete workflow, clearly showing the overall process of project development and the details of each stage. In this way, users can comprehensively plan and design the project to ensure the coherence and logic between each development step.

[0041] The Wiring Tool allows users to establish contextual dependencies and / or logical relationships between different note nodes, such as Figure 4As shown. Users can select dependent context nodes during generation, and A note becomes the knowledge base of B note when generating content using a large language model. That is, A note forms a context dependency relationship with B note, and the arrow points from A note to B note. Users can also drag the mouse from one node to another, and the system will automatically generate a line to indicate the logical relationship between A note and B note, with an arrow pointing from A note to B note. That is, there is a logical dependency between A note and B note but no context dependency, which is the user's logical sorting of their own ideas. The connection function is crucial to building a complete workflow, and users can intuitively see the order and dependency of tasks.

[0042] An intelligent collaborative development method for a large language model application provided in an embodiment of the present invention aims to automate the entire process from ideas to code design through multi-person collaboration. The method is based on a hierarchical canvas design, including a main canvas and a sub-canvas; the main canvas is used for combing development ideas and flexibly setting nodes, and the sub-canvas is used for generating and editing actual code. Each note node (idea node, planning node, task node, and development node) interacts with the large language model to support intelligent content generation and design. The system integrates an integrated development environment (IDE, such as VSCode), which can automatically build a development environment and realize real-time data interaction between the code generated by the canvas and the IDE. Users can enter the IDE at any time during the editing process to debug the code and update the code in real time.

[0043] On the basis of the above embodiments, the intelligent collaborative development method in this embodiment further provides a collection tool and a subset tool.

[0044] Specifically, Figure 5 As shown in the figure, the collection tool allows users to combine multiple related nodes to generate a new summary node. Users can select multiple nodes on the canvas and drag them to the collection tool with the mouse. The system will automatically generate a new summary node and save the content of the original node for future reference. This function is particularly suitable for knowledge organization and summary in the project. Figure 6 As shown in the figure, the subset tool provides users with the function of splitting the content of a single node into multiple sub-nodes. Users can select a node and select the subset tool through the right-click menu. The system will automatically generate multiple sub-nodes based on the node content, and each sub-node contains corresponding structured information. This tool is particularly useful in the process of task decomposition and refinement.

[0045] On the basis of the above embodiments, in order to strengthen the collaborative relationship between project members and promote communication, the intelligent collaborative development method in this embodiment also provides a message board tool.

[0046] Specifically, users can create a message board in the main canvas interface and / or the sub-canvas interface, which allows users to leave messages to interact with other project members. Users can right-click or touch the blank area of ​​the canvas to create a message board and leave communication records or task assignment information of team members. The message board is similar to other nodes and supports real-time synchronization to ensure that all team members can instantly obtain the latest message information.

[0047] The above-mentioned embodiment of the present invention enables users to complete complex project management and development tasks in a unified interface by providing a set of highly integrated tools and node operation mechanisms. In the entire development process, tools and node operations are interrelated and integrated. Users can plan the overall structure of the project on the main canvas and complete the various stages of the project through the cooperation of nodes and tools. In the above-mentioned embodiment, project tasks are planned and executed through task tools and development tools, and these nodes are connected into a complete workflow through connection tools to ensure that all links from ideas to planning and development can be seamlessly connected. Knowledge organization and summarization are achieved through collection tools, and task decomposition and refinement are achieved through subset tools. At the same time, the message board tool also ensures real-time communication between team members, providing a strong guarantee for the smooth progress of the project. This integrated operation not only improves work efficiency, but also significantly enhances the flexibility and operability of the system, providing strong support for users.

[0048] In the above embodiments, each note node has an editing interface, and an input box is provided on the editing interface, and the input box is used to receive user input. Correspondingly, the interaction process between each note node and the large language model specifically includes: the user summons the AI ​​tool by entering a preset instruction in the input box, and once the AI ​​tool is summoned, the large language model is called to generate specific text or code snippets according to the preliminary content input by the user, and the generated content is displayed in the editing interface for the user to browse.

[0049] Specifically, users can double-click a note node to enter the editing mode, which includes text generation, text editing, submission and saving, and history recording. In the editing mode, users can write content in Markdown format, or use symbols such as / , @, #, $, etc. to summon specific context tools, public library tools, or programming tools to insert relevant content in the note node. In addition, users can also customize the position and layout of note nodes in the main canvas interface by dragging, resizing, moving, and connecting to suit specific project needs.

[0050] In the present invention, each note node has the function of real-time interaction with the AI ​​big model, and users can use AI to generate and edit content. This process not only includes traditional manual editing, but also integrates the ability of AI-assisted generation, thereby improving the efficiency and quality of content production. The system supports interaction with AI through a variety of input devices (such as mouse, keyboard, touchpad, touch screen), providing users with a more natural and intuitive editing experience.

[0051] Specifically, users edit or generate content in the editing interface of the note node. The interaction process between the note node and AI is as follows: Figure 7 shown.

[0052] S701: User input and AI tool summoning.

[0053] The editing interface provides a dedicated input box for receiving user text or code input. Users can quickly summon different AI tools by entering specific characters or commands in the input box. These AI tools support a variety of functions, such as selecting contexts, calling Python public libraries, and using programming gadgets. These functions can provide corresponding suggestions or generate code snippets based on the user's specific needs, helping users complete editing work more quickly. Users can customize AI tools as needed.

[0054] S702: AI content generation and browsing.

[0055] Once the AI ​​tool is summoned, the system will call the large language model to process the preliminary content entered by the user and generate the corresponding text or code content. The generation process is real-time and usually does not exceed a few seconds, ensuring that the user can see the generated results in time. The generated content will be automatically displayed in the editing interface, and the user can browse the content by dragging, scrolling or touch gestures. This browsing method supports multiple input devices, allowing users to choose the most suitable way to view the generated content according to their own operating habits.

[0056] S703: Content editing and adjustment.

[0057] Based on the generated content, users can further edit and adjust the text or code. Editing operations support precise character or code block operations. Users can position the cursor by clicking the mouse, enter new content using the keyboard, or select and adjust through gestures on the touch screen. The system supports precise operations of multiple input devices. For example, users can use the mouse to select and copy text, use the keyboard to edit content word by word, or zoom in on a specific area for detailed inspection through the touch screen. The operations at this stage are designed to ensure that the generated content meets user needs and meets high-quality standards.

[0058] Based on the above embodiments, the intelligent collaborative development method in this embodiment also includes the following steps: saving the historical records and prompt word records generated by each note node through a version control system (such as Git) to ensure that all changes and historical versions are effectively managed.

[0059] Specifically, after the content editing is completed, the user can submit the edited content (which may include text, design documents, code, etc.) to Git for version control by clicking the submit button or using shortcut keys. When submitting, the system will automatically save the current history (including the time of submission, the person who modified it, notes, prompt words, titles, and actual text or code content, etc.), ensuring that every submission of the user is fully recorded. Users can also use shortcut keys or touch gestures to quickly access the history interface to view past submission versions, or restore to a previous version when necessary. The integration of Git ensures that users can access and restore previously edited content at any time, providing security for the version management of the project. This not only ensures that each submitted content can be traced and restored, but also allows users to compare and roll back between different versions.

[0060] In the above embodiments, Figure 8 As shown, the note node supports a variety of human-computer interaction methods. Users can use the mouse, keyboard, touchpad, touch screen, and click, drag, and zoom to manage and edit the content of these nodes. For example, in the main canvas and sub-canvas, users can select single or multiple nodes by clicking, adjust the layout of the nodes by dragging, or adjust the display ratio of the nodes by zooming gestures. These interaction methods can meet the needs of different input devices and provide users with a flexible and efficient operating experience. On this basis, the intelligent collaborative development method in this embodiment also supports real-time collaboration of note nodes, including the following steps: responding to user needs, performing multi-node real-time interaction, specifically including: capturing each user operation in real time, and synchronizing the node changes caused by the user operation to the interface of other project members.

[0061] Specifically, during the multi-node real-time interaction, each user's operation will be captured by the system in real time and displayed synchronously on the interface of all collaborators. Whether it is editing the node content, adjusting the node position, or scaling the node, the system can synchronize these changes to other users' interfaces within a delay of no more than 0.1 seconds, ensuring smooth multi-user collaboration. During the multi-node real-time interaction, the message board tool can also be used to better realize communication and discussion between note nodes.

[0062] Furthermore, the intelligent collaborative development method in the embodiment of the present invention also supports sharing and positioning functions. Users can select one or more note nodes and share the content of these nodes with other team members through shortcut keys or gesture operations. The shared content can be sent to other members by generating links, or directly synchronized to other users in the system. The shared content supports automatic positioning. After other members click the sharing link, they can directly locate the shared note node position on their canvas and highlight these nodes on the canvas to facilitate collaboration and discussion.

[0063] In the above embodiment, it is mentioned that the development node can interact with the IDE in real time. In this embodiment, the interaction process between the two is described in detail.

[0064] Specifically, the IDE integration function in this embodiment allows users to debug code at any time during the development process. The code generated by the development note will be transmitted to the IDE in real time and the corresponding development files will be generated. Users can quickly switch between the canvas and the IDE through mouse, keyboard or touch operations. Fig. 9 shown.

[0065] S901: Initialize IDE development environment Users can initialize a development environment at any time, such as Java development environment, Python development environment, etc. Users can enter the IDE interface by clicking the mouse, using keyboard shortcuts, or touching. The initialized IDE environment will generate corresponding development folders and basic code structures based on the content of the Note node, ensuring that users can quickly enter the code writing and debugging stage.

[0066] S902: Real-time code transmission and synchronization When editing the development note of the canvas, the code files submitted by the user through Git will be transferred to the IDE in real time and automatically synchronized to the corresponding development files. This one-way transmission mechanism ensures seamless switching between the canvas and the IDE, and guarantees the real-time and consistency of the code. Users can edit, run, and debug the code through the IDE, but these changes will not be fed back to the note node, and the content of the note node remains unchanged to ensure separation of responsibilities and data consistency between the canvas and the IDE.

[0067] S903: Debugging and running Users can use standard debugging tools in the IDE to debug and run the generated code. The debugging process supports breakpoint setting, variable monitoring, single-step execution and other functions to help users quickly locate and fix problems in the code. It should be noted that the code changes after debugging will not be automatically submitted to the canvas note node, and the transmission from the IDE to the canvas is one-way. The canvas only serves as a generation and transmission point for code and development logic. The debugging and running process in the IDE is independent of the canvas operation.

[0068] S904: Generation and deployment After development and debugging are completed, users can choose to deploy the code from the IDE to the corresponding runtime environment. The deployment operation is completely independent of the canvas note node, and users need to manually perform the deployment process in the IDE. The canvas system does not directly support deployment operations, nor does it record deployment information through the note node. Generation and deployment are independent processes, and the system's version history only covers the generated code content, not the deployment process.

[0069] The intelligent collaborative development method provided by the embodiment of the present invention combines the automated version control and history record management with the real-time synchronous debugging function of the IDE in the above embodiment, thereby improving the convenience and security of code management. Through the integration of Git and IDE, the system can provide users with a complete, closed-loop development process management tool.

[0070] Corresponding to the above method, such as Fig.10 As shown, an embodiment of the present invention provides an intelligent collaborative development device for a large language model application, including: an interaction module, an intelligent collaborative development module, a large language model and an IDE.

[0071] Among them, the interactive module is used to access a variety of input devices, and the input devices are used for users to input requests or perform operations; the operations include note node creation operations, node selection operations and tool operations. The intelligent development module is used to respond to user requests and enter the main canvas interface; respond to the user's note node creation operation, create idea nodes and planning nodes in the main canvas interface; when the user selects a planning node in the main canvas interface, respond to the user's task tool operation to enter the sub-canvas interface and generate multiple task nodes associated with the planning node in the sub-canvas interface; when the user selects a task node in the sub-canvas interface, respond to the user's development tool operation, generate multiple development nodes associated with the task node; respond to the content submitted by the user and the connection tool operation, connect multiple note nodes in the main canvas and sub-canvas in order to form a complete workflow. The big language model is used to interact with the note node; specifically: the idea node interacts with the big language model to convert the user's ideas into specific concept text or code snippets; the planning node interacts with the big language model to define the project structure or module design based on the content of all idea nodes associated with the planning node; the task node interacts with the big language model to generate specific development task text or code snippets. The IDE is used to interact with the development node in real time to ensure that the code in the development process is consistent with the project design.

[0072] The intelligent collaborative development device provided by the embodiment of the present invention provides an intelligent, efficient and real-time collaborative development platform through innovations in large language models, hierarchical canvases, IDE integration and automated version control. The specific manifestations are as follows: (1) Multi-node real-time interaction mechanism based on large language models. By embedding the large language model into each node of the canvas, full-process intelligent support from idea construction, planning and design, task decomposition to code development is achieved. Each node is a container that interacts with the large language model. Users can communicate with the large model in the node to generate code or design content. Through the draft connection function, users can manually connect drafts and organize them into a complete product idea, thereby further optimizing the flexibility of idea construction and planning. This multi-node real-time interaction mechanism not only improves development efficiency, but also ensures seamless connection between various development links. (2) Tight integration of hierarchical canvases and IDEs. A hierarchical design is introduced in the canvas, including a main canvas and a sub-canvas. The main canvas is used to organize and plan development ideas, while the sub-canvas focuses on actual code development. The canvas is tightly integrated with the IDE. Users can initialize the development environment at any time and enter the IDE to debug the code at any time during the node editing process. This design not only improves the flexibility of development, but also realizes real-time interaction between the code and the development environment, which is a key improvement that has never been achieved in the prior art. (3) Full-process intelligent collaboration platform. A complete intelligent collaboration platform covering from idea construction to code generation is provided, which solves the inconsistency and collaboration difficulties of traditional development tools in multi-step processes. By integrating large models, canvas interaction, IDE, and version control systems, the present invention realizes the automation and intelligence of the entire process, significantly improving development efficiency and collaboration effects. At the same time, the message board function provides a new way for team collaboration and communication, further enhancing the collaboration and communication efficiency of the system. (4) Cross-tool real-time data interaction. Real-time data interaction between the canvas, IDE, and version control system is realized. The code generated in the development node can be instantly transferred to the IDE for debugging, and the version control system can capture and save each submitted code change in real time. This cross-tool real-time interaction capability greatly improves the smoothness and consistency of the development process.

[0073] The present invention is applied to product development scenarios, including product research, demand discussion, business process and function discussion, development planning, etc. At the same time, it can be integrated with the conference system, and the conference generated content becomes a note node and is added to the project implementation process as a context dependency.

[0074] It should be noted that the intelligent collaborative development device provided in the embodiment of the present invention is to implement the above method embodiments. Its specific functions can be referred to the above method embodiments and will not be repeated here.

[0075] Fig.11An example of a physical structure diagram of an electronic device is shown in FIG. Fig.11 As shown, the electronic device may include: a processor (processor) 1101, a communication interface (Communications Interface) 1102, a memory (memory) 1103 and a communication bus 1104, wherein the processor 1101, the communication interface 1102, and the memory 1103 communicate with each other through the communication bus 1104. The processor 1101 can call the logic instructions in the memory 1103 to execute the intelligent collaborative development method, which includes: entering the main canvas interface in response to a user request; creating an idea node and a planning node in the main canvas interface in response to the user's note node creation operation; wherein the idea node interacts with the large language model to convert the user's idea into a specific concept text or code snippet; the planning node interacts with the large language model to define the project structure or module design according to all idea node contents associated with the planning node; when the user selects the planning node in the main canvas interface, entering the sub-canvas interface in response to the user's task tool operation and generating multiple task nodes associated with the planning node in the sub-canvas interface; wherein the task node interacts with the large language model to generate a specific development task text or code snippet; when the user selects the task node in the sub-canvas interface, generating multiple development nodes associated with the task node in response to the user's development tool operation; wherein the development node interacts with the IDE in real time to ensure that the code in the development process is consistent with the project design; in response to the content submitted by the user and the connection tool operation, the multiple note nodes in the main canvas and the sub-canvas are connected in order to form a complete workflow.

[0076] In addition, when the logic instructions in the above-mentioned memory 1103 are implemented in the form of software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on such an understanding, the technical solution of the present invention, in essence, or the part that contributes to the prior art or the part of the technical solution, can be embodied in the form of a software product, which is stored in a storage medium and includes several instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0077] An embodiment of the present invention also provides a computer program product, which includes a computer program stored on a non-transitory computer-readable storage medium, and the computer program includes program instructions. When the program instructions are executed by a computer, the computer can execute the intelligent collaborative development method provided by the above-mentioned method embodiments.

[0078] An embodiment of the present invention further provides a non-transitory computer-readable storage medium having a computer program stored thereon. When the computer program is executed by a processor, the intelligent collaborative development method provided by the above-mentioned method embodiments is implemented.

[0079] Through the description of the above implementation methods, those skilled in the art can clearly understand that each implementation method can be implemented by means of software plus a necessary general hardware platform, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solution is essentially or the part that contributes to the prior art can be embodied in the form of a software product, and the computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, a disk, an optical disk, etc., including a number of instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to execute the methods described in each embodiment or some parts of the embodiments.

[0080] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. An intelligent collaborative development method for large language model applications, characterized in that: include: Step 1: In response to a user request, enter the main canvas interface; Step 2: In response to the user's note node creation operation, create an idea node and a planning node in the main canvas interface; wherein the idea node interacts with the large language model to convert the user's idea into a specific concept text or code snippet; the planning node interacts with the large language model to define the project structure or module design according to the content of all idea nodes associated with the planning node; Step 3: After the user selects a planning node in the main canvas interface, in response to the user's task tool operation, a sub-canvas interface is entered and multiple task nodes associated with the planning node are generated in the sub-canvas interface; wherein the task nodes interact with the large language model to generate specific development task text or code snippets; After the user selects a task node in the sub-canvas interface, multiple development nodes associated with the task node are generated in response to the user's development tool operation; wherein the development nodes interact with the IDE in real time to ensure that the code in the development process is consistent with the project design; Step 4: In response to the content submitted by the user and the operation of the wiring tool, multiple note nodes in the main canvas and the sub-canvas are connected in order to form a complete workflow.

2. The intelligent collaborative development method for a large language model application according to claim 1, characterized in that: Also includes: The history and prompt word records generated by each note node are saved through the version control system.

3. The intelligent collaborative development method for a large language model application according to claim 1, characterized in that: Also includes: Providing a collection tool and a subset tool; wherein the collection tool allows the user to combine multiple note nodes to generate a new note node; The subset tool allows the user to split a single note node into multiple sub-note nodes.

4. The intelligent collaborative development method for a large language model application according to claim 1, characterized in that: The wiring tool allows the user to establish contextual dependencies and / or logical relationships between different note nodes.

5. The intelligent collaborative development method for a large language model application according to claim 1, characterized in that: Each note node has an editing interface, on which an input box is provided, and the input box is used to receive user input; Correspondingly, the interaction process between each note node and the large language model specifically includes: the user summons the AI ​​tool by entering preset instructions in the input box. Once the AI ​​tool is summoned, the large language model is called to generate specific text or code snippets based on the preliminary content input by the user, and the generated content is displayed in the editing interface for the user to browse.

6. The intelligent collaborative development method for a large language model application according to claim 1, characterized in that: Also includes: In response to user needs, multi-node real-time interaction is carried out, specifically including: capturing each user operation in real time, and synchronizing the node changes caused by the user operation to the interface of other project members.

7. The intelligent collaborative development method for a large language model application according to claim 1, characterized in that: Also includes: A message board is created in the main canvas interface and / or the sub-canvas interface, wherein the message board allows users to leave messages to interact with other project members.

8. An intelligent collaborative development device for large language model applications, characterized in that: include: Interaction module, intelligent collaborative development module, large language model and IDE; An interactive module, used to access a variety of input devices, wherein the input devices are used for users to input requests or perform operations; the operations include note node creation operations, node selection operations, and tool operations; The intelligent development module is used to enter the main canvas interface in response to a user request; create a thought node and a planning node in the main canvas interface in response to a user's note node creation operation; when the user selects a planning node in the main canvas interface, enter the sub-canvas interface in response to the user's task tool operation and generate multiple task nodes associated with the planning node in the sub-canvas interface; when the user selects a task node in the sub-canvas interface, generate multiple development nodes associated with the task node in response to the user's development tool operation; In response to user-submitted content and wiring tool operations, multiple note nodes in the main canvas and sub-canvas are connected in order to form a complete workflow; The large language model is used to interact with the note node. Specifically, the idea node interacts with the large language model to convert the user's ideas into specific concept text or code snippets. The planning node interacts with the large language model to define the project structure or module design according to the content of all idea nodes associated with the planning node; the task node interacts with the large language model to generate specific development task text or code snippets; IDE, used to interact with development nodes in real time to ensure that the code during development is consistent with the project design.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the program, the method according to any one of claims 1 to 7 is implemented.

10. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the method according to any one of claims 1 to 7 is implemented.

Images