system

Abstract

Provide a system. The present invention includes: a means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology; A means of documenting the organized and clarified requirements in a consistent format; a means for providing an interface that facilitates real-time communication between stakeholders; A means to integrate knowledge bases for specific industries or domains and provide access to the information needed during the requirements definition process; A means to learn from past projects and best practices to help improve the requirements definition process; A means to automate the organization, classification, and importance evaluation of requirements, A system including:

Description

[Technical Field]

[0001] The technology of the present disclosure relates to a system. [Background technology]

[0002] Patent document 1 discloses a persona chatbot control method performed by at least one processor, the method including the steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to a description of the chatbot character, encoding the prompt, and inputting the encoded prompt into a language model to generate a chatbot utterance in response to the user utterance. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] Japanese Patent Publication No. 2022-180282 Summary of the Invention [Problem to be solved by the invention]

[0004] Requirements definition is a critical step in the success of a project or product, but poorly defined requirements and disagreements among stakeholders often occur. These issues can lead to delays in the development process, reduced quality, and decreased customer satisfaction. Furthermore, it can be difficult to access the necessary information and domain knowledge during the requirements definition process, which can hinder efficient requirements definition. The present invention aims to solve these issues, improve the efficiency of requirements definition, and thereby increase project progress speed, product quality, and customer satisfaction. [Means for solving the problem]

[0005] The present invention provides a system that includes a means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology, a means for documenting the organized and clarified requirements in a consistent format, a means for providing an interface that promotes real-time communication between stakeholders, a means for integrating a knowledge base related to a specific industry or domain and making information necessary for the requirements definition process accessible, a means for learning from past projects and best practices and supporting improvement of the requirements definition process, and a means for automating the organization, classification, and importance evaluation of requirements. This enables users to perform efficient and consistent requirements definition, resolves disagreements between stakeholders, and improves the speed and quality of project progress.

[0006] "Input requirements" refers to the needs and specifications for a project or product that a user presents to the system in natural language or other form.

[0007] "Natural language processing technology" is a general term for technologies and methodologies that enable computers to understand, analyze, and generate human language.

[0008] "Organization and clarification" refers to the process of systematically organizing input requirements and converting the content into a clear and consistent format.

[0009] "Consistent format" refers to a state in which requirements are organized without inconsistencies or omissions and have a unified structure and expression method.

[0010] "Real-time communication between stakeholders" refers to real-time information exchange and discussion among all stakeholders involved in a project or product.

[0011] An "interface" refers to the means or channel for communicating information between a user and a system.

[0012] A "knowledge base" refers to a structured database or information system that collects important information and data about a particular industry or domain.

[0013] A "process" is a series of steps or actions taken to achieve a particular goal.

[0014] "Execution" refers to actually putting the planned steps or actions into action.

[0015] "Learning" refers to the process of acquiring new knowledge from past data and experience and improving the performance of a system.

[0016] "Automation" refers to machines or software performing tasks autonomously with minimal human intervention.

[0017] "Requirements organization and classification" refers to the process of systematically organizing multiple requirements and separating them into specific categories or groups.

[0018] "Importance assessment" refers to the process of determining which of multiple requirements has the highest priority and then ranking or scoring them. [Brief explanation of the drawings]

[0019] [Figure 1] 1 is a conceptual diagram showing an example of the configuration of a data processing system according to a first embodiment. [Figure 2] 1 is a conceptual diagram showing an example of main functions of a data processing device and a smart device according to a first embodiment. [Figure 3] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a second embodiment. [Figure 4] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and smart glasses according to a second embodiment. [Figure 5] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a third embodiment. [Figure 6]FIG. 11 is a conceptual diagram showing an example of main functions of a data processing device and a headset-type terminal according to a third embodiment. [Figure 7] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a fourth embodiment. [Figure 8] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and a robot according to a fourth embodiment. [Figure 9] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 10] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 11] FIG. 3 is a sequence diagram showing a processing flow of the data processing system according to the first embodiment. [Figure 12] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 1. [Figure 13] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system according to the second embodiment when an emotion engine is combined. [Figure 14] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 2 when an emotion engine is combined. DETAILED DESCRIPTION OF THE INVENTION

[0020] An example of an embodiment of a system according to the technology of the present disclosure will be described below with reference to the accompanying drawings.

[0021] First, the terms used in the following description will be explained.

[0022] In the following embodiments, a coded processor (hereinafter simply referred to as a "processor") may be a single arithmetic device or a combination of multiple arithmetic devices. Furthermore, a processor may be a single type of arithmetic device or a combination of multiple types of arithmetic devices. Examples of arithmetic devices include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), and an APU (Accelerated Processing Unit).

[0023] In the following embodiments, a coded RAM (Random Access Memory) is a memory in which information is temporarily stored and is used as a working memory by a processor.

[0024] In the following embodiments, the coded storage is one or more non-volatile storage devices that store various programs, various parameters, etc. Examples of non-volatile storage devices include flash memory (SSD (Solid State Drive)), magnetic disks (e.g., hard disks), and magnetic tapes.

[0025] In the following embodiments, a communication I / F (Interface) with a symbol is an interface including a communication processor, an antenna, etc. The communication I / F controls communication between multiple computers. Examples of communication standards applied to the communication I / F include wireless communication standards including 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), Bluetooth (registered trademark), etc.

[0026] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." In other words, "A and / or B" means that it may be only A, only B, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" is also applied when three or more things are expressed connected by "and / or."

[0027] [First embodiment]

[0028] FIG. 1 shows an example of the configuration of a data processing system 10 according to the first embodiment.

[0029] 1, a data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

[0030] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0031] The smart device 14 includes a computer 36, a reception device 38, an output device 40, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The reception device 38, the output device 40, and the camera 42 are also connected to the bus 52.

[0032] The reception device 38 includes a touch panel 38A, a microphone 38B, and the like, and receives user input. The touch panel 38A detects contact with an indicator (for example, a pen or a finger) to receive user input by the touch of the indicator. The microphone 38B detects the user's voice to receive user input by voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0033] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form of expression that the user 20 can perceive (for example, audio and / or text). The display 40A displays visible information such as text and images in accordance with instructions from the processor 46. The speaker 40B outputs audio in accordance with instructions from the processor 46. The camera 42 is a compact digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0034] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54.

[0035] FIG. 2 shows an example of the main functions of the data processing device 12 and the smart device 14.

[0036] 2, in the data processing device 12, a specific process is performed by the processor 28. A specific processing program 56 is stored in the storage 32. The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific process is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0037] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0038] In the smart device 14, the processor 46 performs the reception output process. The storage 50 stores a reception output program 60. The reception output program 60 is used in conjunction with the specific processing program 56 by the data processing system 10. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0039] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0040] This invention relates to a requirements definition support tool that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This tool uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions.

[0041] Specific methods for carrying out the invention

[0042] Organizing and clarifying requirements

[0043] 1. User enters requirements

[0044] Users enter requirements in natural language through a user interface, which are concrete statements of needs and specifications for a project or product.

[0045] 2. The device sends the input to the server

[0046] The device receives the requirements entered by the user and sends them to the server in JSON format, which makes it easier for the server to parse the requirements.

[0047] 3. The server organizes and clarifies the requirements

[0048] The server applies natural language processing techniques using generative AI models to the requirements received, organizes and clarifies the requirements, and documents the organized requirements in a consistent format.

[0049] Communication Support

[0050] 1. User enters a question

[0051] Users enter specific requirements or project-related questions in natural language to resolve information gaps or doubts about the project.

[0052] 2. The device sends the question to the server

[0053] The device receives a question from the user and sends it in JSON format to the server, which analyzes the question and begins processing it to generate an appropriate answer.

[0054] 3. The server answers the question

[0055] The server uses a generative AI model to generate answers to questions, which are written in natural language and in a user-friendly format.

[0056] Providing domain knowledge

[0057] 1. User enters specific domain information

[0058] Users input information about a specific industry or field in natural language, allowing them to access the domain knowledge they need during the requirements definition process.

[0059] 2. The device sends the domain information to the server

[0060] The device sends the domain information received from the user in JSON format to the server, which receives this information and begins processing it to provide knowledge about the domain.

[0061] 3. The server provides domain knowledge

[0062] The server uses generative AI models to generate knowledge about a specific domain and provides it to the user.

[0063] Automation and efficiency

[0064] 1. The user enters the task they want to automate

[0065] Users input tasks they want to automate, such as organizing and categorizing requirements and evaluating their importance, in natural language, thereby improving work efficiency.

[0066] 2. The device sends the task to the server

[0067] The device receives a task from the user and sends it in JSON format to the server, which analyzes the task and starts the process for automation.

[0068] 3. Server automates tasks

[0069] The server uses the generative AI model to automate the task, which is then automatically processed and the results are provided to the user.

[0070] Specific examples

[0071] For example, if a user inputs "I want the requirements for a customer management system organized," the following steps are executed: The terminal sends the requirements to the server, which analyzes, organizes, and documents them in a consistent format. The server returns the generated document to the terminal, which displays it to the user, providing the user with clear and organized requirements.

[0072] Also, if a user asks, "When is the new feature released?", the device sends this question to the server, which uses the generative AI model to generate an answer, which is then returned to the device, which displays it to the user, allowing them to know the release date.

[0073] Through these processes, the present invention improves the efficiency and quality of the requirements definition phase, contributing to the success of the project.

[0074] The processing flow will be explained below.

[0075] Step 1:

[0076] User inputs requirements. Through a user interface, the user inputs project or product requirements in natural language. For example, "The customer management system needs the ability to add, edit, and delete customer information."

[0077] Step 2:

[0078] The terminal sends input to the server. The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[0079] Step 3:

[0080] The server receives the requirements. The server parses the received HTTP request and extracts the requirements information in JSON format.

[0081] Step 4:

[0082] The server analyzes the requirements using natural language processing technology. It then uses a generative AI model to understand the context of the requirements and organize and clarify them. For example, it clarifies the requirement as "Provide the ability to add, edit, and delete customer information."

[0083] Step 5:

[0084] The server documents the analysis results in a consistent format. The server reconstructs the organized and clarified requirements into an appropriate format and documents them in a consistent format.

[0085] Step 6:

[0086] The server sends the documented requirements back to the device, which then generates a JSON response containing the requirements organized in a consistent format and sends it back to the device as an HTTP response.

[0087] Step 7:

[0088] The terminal displays the results to the user. The terminal parses the JSON response received from the server and displays the organized requirements in the user interface, allowing the user to see clear and organized requirements.

[0089] Step 8:

[0090] The user types in a question: The user types in natural language a follow-up question about the requirement, for example, "What is the release date for the new feature?"

[0091] Step 9:

[0092] The device sends the question to the server. The device converts the user's question into JSON format and sends it to the server via an HTTP request.

[0093] Step 10:

[0094] The server receives the question, parses the HTTP request, and extracts the question information in JSON format.

[0095] Step 11:

[0096] The server generates an answer to the question. The server uses a generative AI model to generate an appropriate answer to the question it receives. For example, it generates an answer such as, "The release date for the new feature is the 1st of next month."

[0097] Step 12:

[0098] The server returns the generated answer to the device. The server creates a JSON response containing the generated answer and returns it to the device as an HTTP response.

[0099] Step 13:

[0100] The terminal displays the answer to the user. The terminal parses the JSON response received from the server and displays the generated answer in the user interface, allowing the user to check the answer to the question.

[0101] Step 14:

[0102] User enters specific domain information. The user enters information about a specific industry or domain in natural language. For example, "What are the key requirements in the financial industry?"

[0103] Step 15:

[0104] The device sends the domain information to the server. The device converts the domain information received from the user into JSON format and sends it to the server via an HTTP request.

[0105] Step 16:

[0106] The server receives the domain information. The server parses the received HTTP request and extracts the domain information in JSON format.

[0107] Step 17:

[0108] The server provides domain knowledge, which it then uses a generative AI model to generate domain-specific knowledge and translate it into a form that can be presented to the user, for example explaining the importance of security and data protection in the financial industry.

[0109] Step 18:

[0110] The server returns the generated domain knowledge to the terminal. The server generates a JSON response including the generated domain knowledge and returns it to the terminal as an HTTP response.

[0111] Step 19:

[0112] The terminal displays the domain knowledge to the user. The terminal parses the JSON response received from the server and displays the generated domain knowledge in the user interface, allowing the user to check important information about a specific domain.

[0113] Step 20:

[0114] The user inputs the task they want to automate. The user inputs the task they want to automate, such as organizing, categorizing, and evaluating the importance of requirements, in natural language. For example, they can input "List new requirements and categorize them."

[0115] Step 21:

[0116] The device sends the task to the server. The device converts the task received from the user into JSON format and sends it to the server via an HTTP request.

[0117] Step 22:

[0118] The server receives the task. The server parses the received HTTP request and extracts the task information in JSON format.

[0119] Step 23:

[0120] The server automates the task: Using generative AI models, the server automates the incoming task and takes appropriate action, such as listing new requirements and classifying each requirement into the appropriate category.

[0121] Step 24:

[0122] The server returns the results of the automated task to the device. The server generates a JSON response containing the results of the automated task and returns it to the device as an HTTP response.

[0123] Step 25:

[0124] The terminal displays the automation results to the user. The terminal parses the JSON response received from the server and displays the results of the automated task in the user interface, allowing the user to check the results of the automated task and take any necessary actions.

[0125] Through the above steps, the present invention can significantly streamline the requirements definition process, improving the speed at which projects progress and the quality of products.

[0126] Example 1

[0127] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0128] Traditional requirements definition processes rely on manual work to organize and clarify requirements, which is inefficient and prone to errors. In addition, insufficient communication between stakeholders can delay overall project progress. Furthermore, difficulty in accessing specific domain knowledge makes it difficult to define high-quality requirements. These issues inevitably lead to a decline in project speed, product quality, and customer satisfaction.

[0129] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0130] In this invention, the server

[0131] [Means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;

[0132] [Means of using generative AI models to clarify and clarify requirements and flesh out ambiguities;

[0133] [A means of converting documents into a consistent format and presenting them to users; and

[0134] This automates the organization and clarification of requirements, improving efficiency and reducing errors. Providing consistent documentation also promotes real-time communication between stakeholders, improving project progress. Furthermore, access to specific domain knowledge leads to higher-quality requirements definition, which is expected to improve project quality and customer satisfaction.

[0135] The "means for receiving input requirements" refers to a function for transmitting requirements input by a user in natural language to a server via a terminal, and for the server to receive the requirements.

[0136] "Natural language processing technology" refers to technology that enables computers to understand, analyze, and process human language. This technology can be used to organize and clarify input requirements.

[0137] A "generative AI model" is a type of artificial intelligence technology, specifically a model trained for natural language generation and understanding. In this invention, it is used to organize and clarify requirements.

[0138] "Means for documenting in a consistent format" refers to a function that allows organized and clarified requirements to be documented in a consistent format (e.g., Markdown or PDF) to make them easier for users to understand.

[0139] "Means for converting documents" refers to the ability to take requirements generated by a generative AI model and convert them into a specific format (e.g., Markdown or PDF).

[0140] "Interfaces that promote real-time communication" refers to user interfaces that facilitate instant communication between stakeholders, allowing them to share and discuss questions and opinions about requirements in real time.

[0141] A "knowledge base for a specific industry or domain" refers to a database that stores specialized knowledge about a specific industry or field. It is possible to access the information needed during the requirements definition process.

[0142] "Means of learning from past projects and best practices" refers to the ability to learn from data and success stories of past projects and use these insights to help improve the requirements definition process.

[0143] "Means to automate the organization, classification, and importance evaluation of requirements" refers to the function that automatically organizes, classifies, and evaluates the importance of requirements based on the requirements entered by the user, thereby improving work efficiency.

[0144] This invention relates to a requirements definition support system for streamlining the requirements definition phase of a project. This system uses generative AI models and natural language processing technology to support the organization, clarification, and documentation of requirements, thereby improving project progress speed, product quality, and customer satisfaction.

[0145] The main components of the system include a terminal for users to input requirements, a server for processing the input requirements, a generative AI model (e.g., GPT-4 (registered trademark)), and natural language processing technology.

[0146] Hardware and Software

[0147] Device: A PC or mobile device that provides a user interface (such as a web form or chat window).

[0148] Server: A backend server that receives and processes requests. The server uses the Flask framework and Python.

[0149] Generative AI models: Includes generative AI techniques such as GPT-4.

[0150] Libraries: Document generation libraries such as Pandoc or ReportLab.

[0151] Program processing

[0152] The user inputs requirements in natural language and sends them to the server via the device. The device converts the input requirements into JSON format and sends it as an HTTP POST request to the server. The server receives the request and uses a generative AI model (GPT-4) to organize and clarify the requirements. The generated content is then converted into a structured document using natural language processing techniques to clarify any ambiguities.

[0153] The generated document is converted into a consistent format (such as Markdown or PDF) and sent back from the server to the device. The device receives the document and displays it to the user. This allows the user to obtain organized and clarified requirements, enabling the project to proceed efficiently.

[0154] Specific examples

[0155] A user types, "I want you to organize the requirements for my customer management system." The device sends these requirements to the server, which uses a generative AI model to organize and clarify the requirements, and then sends the documented requirements back to the device.

[0156] Or, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate an answer to the question. This answer is returned to the device and displayed to the user.

[0157] Prompt Sentence Examples

[0158] "I want you to clarify the requirements for a customer management system."

[0159] "When are the new features released?"

[0160] "Tell me about EHR systems in the medical field."

[0161] This system configuration will streamline work during the requirements definition phase and contribute to the success of the project.

[0162] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0163] Processing Steps

[0164] The processing flow of the system program will be explained in the following steps.

[0165] Step 1:

[0166] User enters requirements

[0167] explanation

[0168] A user enters project requirements in natural language using the system's user interface (e.g., a web form or chat window).

[0169] Input and Output

[0170] Input: Requirements written in natural language (e.g., "Please organize the requirements for a customer management system.")

[0171] Output: Requirement data entered into the terminal

[0172] Specific actions

[0173] The user enters the requirements in the text box and presses the submit button.

[0174] Step 2:

[0175] The device sends the input requirements to the server

[0176] explanation

[0177] The terminal receives the requirements entered by the user, converts them into JSON format, and sends them to the server.

[0178] Input and Output

[0179] Input: Requirements data written in natural language

[0180] Output: Structured requirements data in JSON format (e.g., {"type": "requirement", "content": "Please organize the requirements for a customer management system"})

[0181] Specific actions

[0182] The terminal uses JavaScript code to convert the form contents into JSON format and uses the Axios library to send an HTTP POST request to the server.

[0183] Step 3:

[0184] The server receives and analyzes the requirements

[0185] explanation

[0186] The server analyzes the JSON formatted requirements data received from the terminal and inputs it into the generative AI model (GPT-4).

[0187] Input and Output

[0188] Input: Structured requirements data in JSON format

[0189] Output: Requirements data in natural language format that is fed into a generative AI model

[0190] Specific actions

[0191] The server uses the Flask framework to receive HTTP requests, parses the JSON data using Python code, and then sends the requirements data to the generative AI model (GPT-4 API).

[0192] Step 4:

[0193] The server organizes and clarifies the requirements

[0194] explanation

[0195] The server uses generative AI models to organize and clarify requirements.

[0196] Input and Output

[0197] Input: Natural language requirements data sent to the GPT-4 API

[0198] Output: Organized and clarified requirements data (text format)

[0199] Specific actions

[0200] The results returned by the generative AI model are then used in Python code to further apply natural language processing to flesh out any ambiguities in the requirements.

[0201] Step 5:

[0202] Server documents requirements

[0203] explanation

[0204] The server converts the organized and clarified requirements into a consistent format (e.g., Markdown or PDF).

[0205] Input and Output

[0206] Input: Organized and clarified requirements data (text format)

[0207] Output: Documented requirements (e.g., Markdown or PDF)

[0208] Specific actions

[0209] The server uses libraries such as Pandoc and ReportLab to convert the generated text into Markdown or PDF format and save it as a document file.

[0210] Step 6:

[0211] The server sends the generated document back to the device

[0212] explanation

[0213] The server returns the generated document to the terminal as an HTTP response.

[0214] Input and Output

[0215] Input: Documented requirements (e.g., Markdown or PDF)

[0216] Output: JSON response containing the document URL (e.g., {"status": "success", "document_url": "https: / / example.com / documents / requirements_12345.pdf"})

[0217] Specific actions

[0218] The server generates a JSON response containing the document's URL and uses the Flask framework to send an HTTP response to the device.

[0219] Step 7:

[0220] The device displays the document to the user.

[0221] explanation

[0222] The terminal parses the received JSON response and displays the obtained document URL to the user.

[0223] Input and Output

[0224] Input: A JSON response containing the document URL

[0225] Output: The document that is displayed to the user (e.g., a PDF displayed in a web browser)

[0226] Specific actions

[0227] The device parses the JSON response and displays the obtained URL in an iframe tag or a new browser tab. For example, set the URL as the src attribute of the iframe tag as shown below.

[0228] html

[0229] <iframe src="https: / / example.com / documents / requirements_12345.pdf" width="100%" height="600px">< / iframe>

[0230] Through these steps, users will have clear and organized requirements, allowing the project to proceed efficiently.

[0231] (Application example 1)

[0232] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0233] Introducing or improving robots in factories requires the organization and clarification of a wide range of requirements. This process can be delayed due to a lack of communication between stakeholders or unclear requirements, which can have a negative impact on product quality and project progress. Furthermore, a lack of knowledge about a specific industrial domain makes it difficult to define optimal requirements. To solve these problems, a support system is needed that can streamline and clarify requirements definition, facilitate communication, and provide specialized knowledge.

[0234] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0235] In this invention, the server includes means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology, means for documenting the organized and clarified requirements in a consistent format, and means for providing an interface that promotes real-time communication between stakeholders. This allows users to analyze input requirements and document them in a unified format, and also provides industrial domain knowledge and task automation functions, thereby improving the progress speed and quality of projects.

[0236] "Requirements organization" is the process of clarifying the needs and specifications for a project or product and organizing them in a consistent format.

[0237] "Natural language processing technology" is a technology that enables computers to understand, analyze, and generate human language.

[0238] Documentation is the process of organizing information and data, converting it into a consistent format, and recording it as a document.

[0239] "Real-time communication" is a means of communication that allows stakeholders to exchange information without any time lag.

[0240] An "interface" is a means of providing a screen or method of operation for a user to interact with a system or application.

[0241] "Domain knowledge" is specialized knowledge about a particular industry or field.

[0242] "JSON format" is an abbreviation for JavaScript Object Notation, and is a lightweight format for structuring and representing data.

[0243] A "generative AI model" is a type of artificial intelligence, an advanced machine learning model for generating and editing text.

[0244] Documentation is the process of consistently recording information such as requirements, specifications, and project status.

[0245] "Task automation" is a system that automatically processes specified tasks without human intervention.

[0246] "Industrial domain knowledge" refers to specialized knowledge and know-how in the manufacturing and industrial fields.

[0247] To realize this invention, it is important to build a system that uses a generative AI model, natural language processing technology, and JSON format data transmission and analysis means. This system includes the following steps.

[0248] First, the user inputs requirements for introducing or improving a factory robot in natural language. The device used by the user (smartphone, tablet, computer, etc.) sends the input requirements to the server. At this time, the data is sent in JSON format.

[0249] The server then analyzes the received requirements using a generative AI model (e.g., the T5 model) to organize and clarify the requirements. The generative AI model is implemented using Hugging Face's transformers library. As a result of this analysis, the requirements are documented in a unified format. The documented requirements are then sent back from the server to the device and presented to the user.

[0250] Similarly, when a user inputs a question about a requirement, the device sends the question in JSON format to the server, which uses a generative AI model to generate an answer in real time, which is also displayed to the user on the device.

[0251] In addition, when a user inputs information about a specific industry or domain, the server uses a generative AI model to generate domain knowledge and provides it to the user. Also, when the user inputs the tasks they want to automate (organizing and classifying requirements, assessing importance, etc.), the server analyzes them and automates them.

[0252] The above process will streamline requirements definition and facilitate communication between stakeholders when introducing or improving factory robots. Furthermore, the provision of industrial domain knowledge and task automation functions are expected to improve the speed and quality of project progress.

[0253] As a concrete example, a project manager might input, "Please organize the requirements for a new assembly line for factory robots." That input is sent in JSON format to a server, which parses it using a generative AI model and documents the organized and clarified requirements in a unified format. The server then sends the document back to the terminal, which displays it to the user (project manager). Similarly, when a user asks, "When is the next product update?" the server uses the generative AI model to generate an answer and displays it to the user.

[0254] An example of a prompt is as follows:

[0255] "Organize the requirements for a new assembly line for factory robots."

[0256] "Automate the classification of quality control data."

[0257] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0258] Step 1:

[0259] The user inputs requirements for the introduction and improvement of factory robots in natural language using the device they use (smartphone, tablet, computer, etc.). The input requirements are converted into JSON format and sent to the server.

[0260] Step 2:

[0261] The device sends the user-entered requirements in JSON format to the server, which makes the data easier to parse.

[0262] Step 3:

[0263] The server analyzes the received requirements using a generative AI model (e.g., the T5 model) to organize and clarify the requirements. The generative AI model is implemented using Hugging Face's transformers library. As a result of this analysis, the requirements are organized in a consistent format.

[0264] Step 4:

[0265] The server documents the organized and clarified requirements and structures them in JSON format, which is then sent back to the device.

[0266] Step 5:

[0267] The terminal receives the documented requirements in JSON format returned from the server and displays them to the user, who can then review the organized requirements.

[0268] Step 6:

[0269] The user enters a question about the requirements in natural language, which is also converted to JSON format by the device and sent to the server.

[0270] Step 7:

[0271] The device receives questions from users and sends them in JSON format to the server, which analyzes the questions and generates answers in real time using a generative AI model.

[0272] Step 8:

[0273] The server uses a generative AI model to generate answers to questions, which are also written in natural language.

[0274] Step 9:

[0275] The server returns the generated answer to the terminal, which then displays the answer to the user, allowing the user to obtain the answer to their question.

[0276] Step 10:

[0277] When a user inputs information about a specific industry or domain, the device converts it into JSON format and sends it to the server, which uses generative AI models to generate domain knowledge and provide it to the user.

[0278] Step 11:

[0279] When a user wants to automate a task, they input the task in natural language and send it to the device. The device then sends the task in JSON format to the server, which then processes it for automation.

[0280] Step 12:

[0281] The server uses the generative AI model to automate the task and returns the results in JSON format to the device, which then displays the results to the user, allowing them to obtain the results of the automated task.

[0282] Furthermore, an emotion engine that estimates the user's emotion may be combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59 and perform identification processing using the user's emotion.

[0283] This invention relates to a requirements definition support tool that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This tool uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions. It also has an emotion engine that recognizes user emotions and adds a function to adjust the requirements definition process based on the recognized emotions.

[0284] Specific methods for carrying out the invention

[0285] Organizing and clarifying requirements

[0286] 1. User enters requirements

[0287] Users enter requirements in natural language through a user interface, which are concrete statements of needs and specifications for a project or product.

[0288] 2. The device sends the input to the server

[0289] The terminal converts the requirements entered by the user into JSON format and sends it to the server through an HTTP request, making it easier for the server to parse the requirements.

[0290] 3. The server organizes and clarifies the requirements

[0291] The server applies natural language processing techniques using generative AI models to the requirements received, organizes and clarifies the requirements, and documents the organized requirements in a consistent format.

[0292] Communication Support

[0293] 1. User enters a question

[0294] Users enter specific requirements or project-related questions in natural language to resolve information gaps or doubts about the project.

[0295] 2. The device sends the question to the server

[0296] The device receives a question from the user and sends it in JSON format to the server, which analyzes the question and begins processing it to generate an appropriate answer.

[0297] 3. The server answers the question

[0298] The server uses a generative AI model to generate answers to questions, which are written in natural language and in a user-friendly format.

[0299] Providing domain knowledge

[0300] 1. User enters specific domain information

[0301] Users input information about a specific industry or field in natural language, allowing them to access the domain knowledge they need during the requirements definition process.

[0302] 2. The device sends the domain information to the server

[0303] The device sends the domain information received from the user in JSON format to the server, which receives this information and begins processing it to provide knowledge about the domain.

[0304] 3. The server provides domain knowledge

[0305] The server uses generative AI models to generate knowledge about a specific domain and provides it to the user.

[0306] Automation and efficiency

[0307] 1. The user enters the task they want to automate

[0308] Users input tasks they want to automate, such as organizing and categorizing requirements and evaluating their importance, in natural language, thereby improving work efficiency.

[0309] 2. The device sends the task to the server

[0310] The device converts the task received from the user into JSON format and sends it to the server via an HTTP request. The server analyzes the task and starts the process for automation.

[0311] 3. Server automates tasks

[0312] The server uses the generative AI model to automate the task, which is then automatically processed and the results are provided to the user.

[0313] Emotion engine integration

[0314] 1. Recognize user emotions

[0315] The emotion engine analyzes user input and user interface behavior to recognize user emotions, for example, by inferring emotions based on input text and click frequency.

[0316] 2. The device sends emotional information to the server

[0317] The device sends the recognized user emotion information to the server in JSON format, allowing the server to adjust subsequent processes based on the emotion.

[0318] 3. The server adjusts the process based on emotions

[0319] The server then adjusts the requirements definition and communication support processes based on the received emotional information. For example, if the user is feeling stressed, it will provide more detailed guidance.

[0320] Specific examples

[0321] For example, if a user types "I want you to organize the requirements for a customer management system," the terminal sends this to the server, which then analyzes, organizes, and documents the requirements in a consistent format. At the same time, the system recognizes the user's emotions based on the speed and context of their input, and displays additional help messages if the user is feeling stressed.

[0322] Furthermore, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate an answer. At the same time, it monitors the user's emotions and responds quickly if the user is in a hurry.

[0323] Through these processes, the present invention contributes to the success of projects by significantly streamlining the requirements definition process and enabling flexible responses to user emotions.

[0324] The processing flow will be explained below.

[0325] Step 1:

[0326] The user enters requirements. Through a user interface, the user enters project or product requirements in natural language. For example, the user might enter, "The customer management system needs the ability to add, edit, and delete customer information."

[0327] Step 2:

[0328] The terminal sends input to the server. The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[0329] Step 3:

[0330] The server receives the requirements. The server parses the received HTTP request and extracts the requirements information in JSON format.

[0331] Step 4:

[0332] The server analyzes the requirements using natural language processing technology. It then uses a generative AI model to understand the context of the requirements and organize and clarify them. For example, it clarifies the requirement as "Provide the ability to add, edit, and delete customer information."

[0333] Step 5:

[0334] The server documents the organized requirements. The server documents the organized and clarified requirements in a consistent format.

[0335] Step 6:

[0336] The server returns the documented requirements to the device. The server generates a JSON response containing the documented requirements and returns it to the device as an HTTP response.

[0337] Step 7:

[0338] The terminal displays the results to the user. The terminal parses the JSON response received from the server and displays the organized requirements in the user interface, allowing the user to see clear and organized requirements.

[0339] Step 8:

[0340] User enters a question: A user enters a question in natural language about a specific requirement or project, such as "What is the release date for the new feature?"

[0341] Step 9:

[0342] The device sends the question to the server. The device converts the entered question into JSON format and sends it to the server via an HTTP request.

[0343] Step 10:

[0344] The server receives the question, parses the HTTP request, and extracts the question information in JSON format.

[0345] Step 11:

[0346] The server generates an answer to the question. The server uses a generative AI model to generate an appropriate answer to the question. For example, it generates an answer such as "The release date for the new feature is the 1st of next month."

[0347] Step 12:

[0348] The server returns the answer to the device. The server creates a JSON response containing the answer and returns it to the device as an HTTP response.

[0349] Step 13:

[0350] The terminal displays the answer to the user. The terminal parses the JSON response received from the server and displays the generated answer in the user interface, allowing the user to check the answer to the question.

[0351] Step 14:

[0352] User enters specific domain information. The user enters information about a specific industry or domain in natural language. For example, "What are the key requirements in the financial industry?"

[0353] Step 15:

[0354] The device sends the domain information to the server. The device converts the domain information received from the user into JSON format and sends it to the server via an HTTP request.

[0355] Step 16:

[0356] The server receives the domain information. The server parses the received HTTP request and extracts the domain information in JSON format.

[0357] Step 17:

[0358] The server provides domain knowledge: Using generative AI models, the server generates knowledge about a specific domain and provides it to the user, for example explaining the importance of security and data protection in the financial industry.

[0359] Step 18:

[0360] The server returns the generated domain knowledge to the terminal. The server generates a JSON response including the generated domain knowledge and returns it to the terminal as an HTTP response.

[0361] Step 19:

[0362] The terminal displays the domain knowledge to the user. The terminal parses the JSON response received from the server and displays the generated domain knowledge in the user interface, allowing the user to check important information about a specific domain.

[0363] Step 20:

[0364] The user inputs the task they want to automate. The user inputs the task they want to automate, such as organizing, categorizing, and evaluating the importance of requirements, in natural language. For example, they might input "List new requirements and categorize them."

[0365] Step 21:

[0366] The device sends the task to the server. The device converts the task received from the user into JSON format and sends it to the server via an HTTP request.

[0367] Step 22:

[0368] The server receives the task. The server parses the received HTTP request and extracts the task information in JSON format.

[0369] Step 23:

[0370] The server automates the task: Using generative AI models, the server automates the incoming task and takes appropriate action, such as listing new requirements and classifying each requirement into the appropriate category.

[0371] Step 24:

[0372] The server returns the results of the automated task to the device. The server generates a JSON response containing the results of the automated task and returns it to the device as an HTTP response.

[0373] Step 25:

[0374] The terminal displays the automation results to the user. The terminal parses the JSON response received from the server and displays the results of the automated task in the user interface, allowing the user to check the results of the automated task and take any necessary actions.

[0375] Emotion engine integration

[0376] Step 26:

[0377] The emotion engine recognizes the user's emotions. The emotion engine analyzes the user's input and behavior on the user interface to recognize the user's emotions. For example, it infers the user's emotions based on the entered text, typing speed, click frequency, etc.

[0378] Step 27:

[0379] The device sends the emotion information to the server. The device sends the recognized emotion information of the user to the server in JSON format, which allows the server to adjust subsequent processes based on the emotion.

[0380] Step 28:

[0381] The server adjusts the process based on the emotion. The server adjusts the requirements definition and communication support processes based on the emotion information it receives. For example, if the user is feeling stressed, it will respond by providing more detailed guidance.

[0382] Through the above steps, the present invention significantly streamlines the requirements definition process and enables flexible responses to user emotions, thereby contributing to the success of the project.

[0383] Example 2

[0384] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0385] Traditional requirements definition processes are often manual and require a great deal of time and effort. Real-time communication between stakeholders is difficult, which can delay information sharing and decision-making. Furthermore, the process is often carried out without consideration of user feelings, which can result in an unsatisfactory user experience. It is necessary to resolve these issues, streamline the requirements definition process, and improve project progress speed, product quality, and customer satisfaction.

[0386] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0387] In this invention, the server includes: [means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;] [means for documenting the organized and clarified requirements in a consistent format; and] [means for recognizing the user's emotions using an emotion engine and adjusting the requirements definition process based on the recognized emotions.] This makes it possible to improve the efficiency of the requirements definition process, realize smooth communication between stakeholders, and realize responses that correspond to the user's emotions.

[0388] "Means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology" refers to a function for receiving requirements that a user inputs to the system in natural language, systematically organizing them using natural language processing technology, and clarifying the content.

[0389] "Means for documenting organized and clarified requirements in a consistent format" refers to a function for documenting organized and clarified requirements using natural language processing technology in accordance with certain rules and formats, and for saving and displaying them in a consistent format.

[0390] "Means for providing an interface that promotes real-time communication among stakeholders" is a function that provides a user interface that helps real-time information sharing and communication among those involved in the project.

[0391] "A means of integrating knowledge bases related to specific industries or fields and enabling access to information needed during the requirements definition process" is a function that integrates a database that aggregates knowledge related to specific industries or fields, making it easy to access information needed during the requirements definition process.

[0392] "Means for recognizing user emotions using an emotion engine and adjusting the requirements definition process based on the recognized emotions" refers to a function that uses an emotion engine that analyzes emotions from user input and behavior to recognize the user's current emotional state and adjusts the requirements definition procedure and interactions according to those emotions.

[0393] "Means of learning from past projects and best practices to help improve the requirements definition process" is a function that learns from past project data and industry best practices, and uses that knowledge to help streamline and improve the requirements definition process.

[0394] "Means for automating the organization, classification, and importance evaluation of requirements" refers to a function that automates the process of properly organizing and classifying requirements and evaluating their importance. This reduces the manual workload and enables faster and more accurate requirements management.

[0395] This invention is a requirements definition support system that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This system uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions. It also features an emotion engine that recognizes user emotions. Furthermore, the requirements definition process can be dynamically adjusted based on the emotions recognized by this emotion engine.

[0396] Specifically, users input project or product requirements in natural language through a user interface. This input is converted to JSON format by the terminal and sent to the server via an HTTP request. The server then applies natural language processing techniques using generative AI models to the received requirements to organize and clarify them. The organized requirements are then documented in a consistent format.

[0397] To support real-time communication, users input questions about specific requirements or projects. The device converts the input into JSON format and sends it to the server via an HTTP request. The server then uses a generative AI model to generate answers to the questions and provides them to the user. Additionally, when users input information about a specific industry or field, the device sends it to the server, which then generates domain knowledge and provides it to the user.

[0398] With the automation and efficiency feature, when a user inputs automation tasks such as organizing and categorizing requirements and assessing their importance, the device converts the input into JSON format and sends it to the server via an HTTP request. The server then uses a generative AI model to automate the task and provides the results to the user.

[0399] The integration of an emotion engine allows the system to recognize emotions from user input and behavior and adjust subsequent processes based on those emotions. For example, if the user is feeling stressed, the system will provide detailed guidance to improve the user experience.

[0400] For example, if a user types "I want you to organize the requirements for a customer management system," the terminal sends this to the server, which then analyzes, organizes, and documents the requirements in a consistent format. It can also recognize emotions from the user's typing speed and context, and display additional help messages if the user is feeling stressed.

[0401] Furthermore, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate a quick answer, while simultaneously monitoring the user's emotions and responding even faster if they are in a hurry.

[0402] Through these processes, the present invention significantly improves the efficiency of the requirements definition process and makes it possible to respond to user emotions, thereby greatly contributing to the success of the project.

[0403] Examples of prompts include:

[0404] "I want you to clarify the requirements for a customer management system."

[0405] "When are the new features released?"

[0406] Please provide the latest domain information.

[0407] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0408] Organizing and clarifying requirements

[0409] Step 1:

[0410] User enters requirements

[0411] The user inputs specific requirements for a project or product in natural language. For example, they input specific content such as "database requirements for a new customer management system." The input data is requirement information in text format.

[0412] Step 2:

[0413] The device sends the input requirements to the server

[0414] The terminal acquires the requirements entered by the user and converts them into JSON format. For example, if the entered requirements are "Database requirements for a new customer management system," they are converted into the following JSON data:

[0415] json

[0416] {

[0417] "requirement": "Database requirements for the new customer management system"

[0418] }

[0419] This is sent to the server as an HTTP POST request.

[0420] Step 3:

[0421] The server organizes and clarifies the requirements

[0422] The server analyzes the received requirements data and applies natural language processing techniques using a generative AI model to organize and clarify the requirements. For example, if the requirement is "The database should have high availability and scalability," the server extracts keywords such as "availability" and "scalability" and generates an organized document. The results are output in document format.

[0423] Communication Support

[0424] Step 1:

[0425] The user enters a question

[0426] A user types in natural language a question about a specific requirement or project, for example, "What is the release date for the new feature?" The input data is a textual question.

[0427] Step 2:

[0428] The device sends a question to the server

[0429] The device converts the question received from the user into JSON format and sends it to the server via an HTTP request, for example:

[0430] json

[0431] {

[0432] "question": "When is the new feature release date?"

[0433] }

[0434] Step 3:

[0435] The server answers the question

[0436] The server uses a generative AI model to analyze the question and generate an appropriate answer, such as "The new feature will be released on December 15, 2023," in natural language format.

[0437] Providing domain knowledge

[0438] Step 1:

[0439] User enters specific domain information

[0440] A user inputs information about a specific industry or field in natural language. For example, "What are the latest trends in the fintech industry?" The input data is domain information in text format.

[0441] Step 2:

[0442] The device sends the domain information to the server.

[0443] The terminal converts the domain information received from the user into JSON format and sends it to the server via an HTTP request. For example, convert it as follows:

[0444] json

[0445] {

[0446] "domain_info": "What are the latest trends in the fintech industry?"

[0447] }

[0448] Step 3:

[0449] The server provides domain knowledge

[0450] The server uses the generative AI model to generate domain-specific knowledge, such as "Digital banking and smart contracts are hot topics in the latest FinTech industry" in natural language.

[0451] Automation and efficiency

[0452] Step 1:

[0453] The user enters the task they want to automate.

[0454] The user inputs the task to be automated, such as organizing and categorizing requirements, evaluating their importance, etc. in natural language. For example, the user might input "Automatically organize the list of requirements according to priority." The input data is the automation task in text format.

[0455] Step 2:

[0456] The device sends the task to the server

[0457] The device converts the task received from the user into JSON format and sends it to the server via an HTTP request, for example:

[0458] json

[0459] {

[0460] "task": "Automatically organize the requirements list by priority"

[0461] }

[0462] Step 3:

[0463] Server automates tasks

[0464] The server uses the generative AI model to automate tasks, specifically by analyzing the incoming requirements, assessing the importance of each requirement, and organizing them according to priority. The results are output as an organized list of requirements.

[0465] Emotion engine integration

[0466] Step 1:

[0467] Emotion engine recognizes user emotions

[0468] The emotion engine analyzes user input and behavior to recognize emotions. For example, it infers emotions such as "irritated" from input text, click frequency, and usage time. Input data is user behavior logs and text data.

[0469] Step 2:

[0470] The device sends emotional information to the server.

[0471] The device sends the user's recognized emotion information to the server in JSON format. For example, it can be converted as follows:

[0472] json

[0473] {

[0474] "emotion": "frustrated"

[0475] }

[0476] Step 3:

[0477] Server adjusts process based on emotion

[0478] The server adjusts the requirements definition and communication process based on the emotional information received, for example, if the user is feeling stressed, it displays additional guidance or support messages.

[0479] (Application example 2)

[0480] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0481] The requirements definition phase of a project is often complex and time-consuming, and poor communication between stakeholders and a lack of domain knowledge can affect quality and progress speed. Furthermore, in projects requiring advanced technology such as autonomous vehicles, it is particularly important to organize and clarify requirements, provide domain knowledge, support real-time communication, and adjust the process while taking user emotions into consideration. Therefore, solutions are needed to efficiently and effectively execute such a complex requirements definition phase.

[0482] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0483] In this invention, the server includes: [means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;] [means for documenting the organized and clarified requirements in a consistent format;] [means for providing an interface that promotes real-time communication between stakeholders;] [means for integrating a knowledge base related to a specific industry or domain and making necessary information accessible during the requirements definition process;] [means for learning from past projects and best practices and supporting improvement of the requirements definition process;] [means for automating the organization, classification, and importance assessment of requirements;] [means for integrating an emotion engine, analyzing user emotions, and adjusting the process; and] [means for analyzing requirements related to autonomous vehicles and providing information on necessary sensors and machine learning models.] This enables the requirements definition phase of a project to be carried out efficiently and effectively, improving progress speed with high quality, and enabling the provision of domain knowledge and real-time communication support, especially in projects that require advanced technology such as autonomous vehicles.

[0484] Organizing and clarifying requirements using natural language processing techniques is the process of modularizing project or product needs and specifications into a consistent and easy-to-understand format.

[0485] "Documenting in a consistent format" means recording the organized and clarified requirements in a document in a standardized format so that they can be easily used in subsequent processes.

[0486] An "interface that promotes real-time communication between stakeholders" is a user interface that enables those involved in a project to share information in real time and communicate smoothly.

[0487] "Integrating a knowledge base for a specific industry or domain" means using a database that systematically compiles specialized knowledge in a specific industry or technical field, enabling quick and accurate access to the information needed when defining requirements.

[0488] "Learning from past projects and best practices" refers to techniques and methodologies for analyzing the results and success stories of previous projects and applying that knowledge to the next project.

[0489] "Automating the organization, classification, and importance evaluation of requirements" means that the machine automatically analyzes the input requirements, classifies them by item, and evaluates their importance.

[0490] "Integrating an emotion engine, analyzing user emotions, and adjusting the process" means incorporating an engine into the system that analyzes the user's emotions and stress level, and then appropriately adjusting the way the project is progressing based on the results.

[0491] "Analyzing requirements related to autonomous vehicles and providing information on necessary sensors and machine learning models" means specifically defining the functions and performance required for autonomous vehicles and providing information on the hardware and software components required for them.

[0492] This invention provides a system that integrates multiple technologies to streamline the requirements definition phase of a project and obtain high-quality results. Specifically, this system includes the following components:

[0493] First, a user inputs project or product requirements in natural language. These requirements are entered into a terminal through a designated user interface. The terminal converts the input requirements into JSON format and sends it to the server via an HTTP request. The server then applies natural language processing techniques using generative AI models to organize and clarify the requirements and document the results in a consistent format.

[0494] Next, an interface is provided to facilitate real-time communication between stakeholders. The device receives users' questions and opinions and sends them to the server, which then uses a generative AI model to generate appropriate answers. As a result, project participants can smoothly share information and make quick decisions.

[0495] Furthermore, it integrates knowledge bases related to specific industries and domains, making necessary information accessible during the requirements definition process. When a user inputs specific domain information, the device transmits the information to the server, which then uses generative AI models to provide relevant knowledge.

[0496] It also includes a means to learn from past projects and best practices to help improve the requirements definition process. The server analyzes data using machine learning models to analyze past deliverables and success stories and apply the knowledge to the next project.

[0497] Furthermore, it provides a means to automate the organization, classification, and importance evaluation of requirements. When a user inputs a task they want to automate in natural language, the device sends the task to the server, which then uses a generative AI model to automatically process the task.

[0498] It also includes a means for integrating an emotion engine, analyzing the user's emotions, and adjusting the process. The emotion engine analyzes the user's input and behavior, recognizes the user's emotions, and then the server adjusts the process based on that information. For example, if the user is feeling stressed, it provides more detailed guidance.

[0499] Finally, it includes a means for analyzing requirements related to autonomous vehicles and providing information on the necessary sensors and machine learning models. When a user inputs the requirements for an autonomous vehicle, the device sends them to the server, which then provides information on the necessary hardware and software.

[0500] For example, if a user asks, "What kind of sensors do autonomous vehicles need?", the device sends the question to the server, which uses a generative AI model to generate an answer. The answer is returned in the form of, "An autonomous vehicle needs LiDAR, RADAR, cameras, ultrasonic sensors, etc." At this time, the user's emotions are also analyzed, and if the user is in a hurry, a quick response is made.

[0501] Through the above means, the system of the present invention can streamline the requirements definition phase of a project and obtain high-quality results.

[0502] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0503] Step 1:

[0504] Users enter project or product requirements in natural language.

[0505] Input: Project or product requirements (natural language text)

[0506] Specific operation: The user inputs requirements through a device such as a smartphone, smart glasses, or head-mounted display.

[0507] Step 2:

[0508] The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[0509] Input: User-entered requirements (natural language text)

[0510] Data processing: converting natural language text into JSON format

[0511] Output: HTTP request (JSON format data)

[0512] Specific operation: The application on the device parses the text, encodes it into JSON format, and sends a POST request to the server.

[0513] Step 3:

[0514] The server applies natural language processing technology using a generative AI model to the requirements received, organizing and clarifying the requirements.

[0515] Input: HTTP request (JSON format data)

[0516] Data Computing: Analyzing natural language text using generative AI models to organize and clarify requirements

[0517] Output: Organized and clarified requirements (structured data)

[0518] What it does: A natural language processing engine running on the server parses the requirements text, categorizes and prioritizes them, and generates structured data.

[0519] Step 4:

[0520] The server documents the organized and clarified requirements in a consistent format.

[0521] Input: Organized and clarified requirements (structured data)

[0522] Data transformation: converting structured data into a consistent document format

[0523] Output: Document file (e.g. PDF or Word)

[0524] Specific operation: The server's document generation engine converts the structured data into a document format based on a template and saves or transmits it.

[0525] Step 5:

[0526] The server provides an interface that facilitates real-time communication between stakeholders.

[0527] Input: Questions and opinions from stakeholders (natural language text)

[0528] Data Computing: Parsing Questions and Generating Answers with Generative AI Models

[0529] Output: Answer text (natural language text)

[0530] Specific operation: The server provides a real-time chat function, receives inquiries from stakeholders, and generates answers using a generative AI model.

[0531] Step 6:

[0532] The user enters information about a specific industry or domain, and the device sends the information to a server.

[0533] Input: Information about a specific industry or domain (natural language text)

[0534] Data processing: converting natural language text into JSON format

[0535] Output: HTTP request (JSON format data)

[0536] Specific operation: The device converts the text into JSON format and sends it to the server.

[0537] Step 7:

[0538] The server provides knowledge about a specific industry or domain.

[0539] Input: HTTP request (JSON format data)

[0540] Data Computing: Using generative AI models to analyze relevant knowledge and generate information

[0541] Output: Domain knowledge text (natural language text)

[0542] Specific operation: The server extracts relevant information from the knowledge base, analyzes it using a generative AI model, and provides it in text format.

[0543] Step 8:

[0544] The server analyzes the user's emotions and adjusts the subsequent process.

[0545] Input: Emotional information (user behavior and input text)

[0546] Data calculation: Emotion analysis with emotion engine

[0547] Output: The adjusted process (e.g., guidance message)

[0548] Specific operation: The server's emotion engine analyzes the emotion information and adjusts the way the project proceeds as needed.

[0549] Step 9:

[0550] The user inputs the requirements for the autonomous vehicle, and the terminal sends the requirements to the server.

[0551] Input: Requirements related to autonomous vehicles (natural language text)

[0552] Data processing: converting natural language text into JSON format

[0553] Output: HTTP request (JSON format data)

[0554] Specific operation: The terminal converts the requirement text into JSON format and sends it to the server.

[0555] Step 10:

[0556] The server provides information on sensors and machine learning models required for autonomous vehicles.

[0557] Input: HTTP request (JSON format data)

[0558] Data Computing: Using generative AI models to analyze and provide relevant information

[0559] Output: Information about sensors and machine learning models (natural language text)

[0560] Specific operation: The server generates relevant technical information and provides it to the user.

[0561] Through these steps, the requirements definition phase of the project will be streamlined and produce high-quality results.

[0562] The specific processing unit 290 transmits the result of the specific processing to the smart device 14. In the smart device 14, the control unit 46A causes the output device 40 to output the result of the specific processing. The microphone 38B acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0563] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (registered trademark) (Internet search engine).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0564] In the above embodiment, an example in which the specific process is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific process may be performed by the smart device 14.

[0565] [Second embodiment]

[0566] FIG. 3 shows an example of the configuration of a data processing system 210 according to the second embodiment.

[0567] 3, the data processing system 210 includes the data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0568] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0569] The smart glasses 214 include a computer 36, a microphone 238, a speaker 240, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, and the camera 42 are also connected to the bus 52.

[0570] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[0571] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[0572] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0573] Fig. 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Fig. 4, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0574] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0575] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0576] In the smart glasses 214, the reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0577] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal."

[0578] This invention relates to a requirements definition support tool that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This tool uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions.

[0579] Specific methods for carrying out the invention

[0580] Organizing and clarifying requirements

[0581] 1. User enters requirements

[0582] Users enter requirements in natural language through a user interface, which are concrete statements of needs and specifications for a project or product.

[0583] 2. The device sends the input to the server

[0584] The device receives the requirements entered by the user and sends them to the server in JSON format, which makes it easier for the server to parse the requirements.

[0585] 3. The server organizes and clarifies the requirements

[0586] The server applies natural language processing techniques using generative AI models to the requirements received, organizes and clarifies the requirements, and documents the organized requirements in a consistent format.

[0587] Communication Support

[0588] 1. User enters a question

[0589] Users enter specific requirements or project-related questions in natural language to resolve information gaps or doubts about the project.

[0590] 2. The device sends the question to the server

[0591] The device receives a question from the user and sends it in JSON format to the server, which analyzes the question and begins processing it to generate an appropriate answer.

[0592] 3. The server answers the question

[0593] The server uses a generative AI model to generate answers to questions, which are written in natural language and in a user-friendly format.

[0594] Providing domain knowledge

[0595] 1. User enters specific domain information

[0596] Users input information about a specific industry or field in natural language, allowing them to access the domain knowledge they need during the requirements definition process.

[0597] 2. The device sends the domain information to the server

[0598] The device sends the domain information received from the user in JSON format to the server, which receives this information and begins processing it to provide knowledge about the domain.

[0599] 3. The server provides domain knowledge

[0600] The server uses generative AI models to generate knowledge about a specific domain and provides it to the user.

[0601] Automation and efficiency

[0602] 1. The user enters the task they want to automate

[0603] Users input tasks they want to automate, such as organizing and categorizing requirements and evaluating their importance, in natural language, thereby improving work efficiency.

[0604] 2. The device sends the task to the server

[0605] The device receives a task from the user and sends it in JSON format to the server, which analyzes the task and starts the process for automation.

[0606] 3. Server automates tasks

[0607] The server uses the generative AI model to automate the task, which is then automatically processed and the results are provided to the user.

[0608] Specific examples

[0609] For example, if a user inputs "I want the requirements for a customer management system organized," the following steps are executed: The terminal sends the requirements to the server, which analyzes, organizes, and documents them in a consistent format. The server returns the generated document to the terminal, which displays it to the user, providing the user with clear and organized requirements.

[0610] Also, if a user asks, "When is the new feature released?", the device sends this question to the server, which uses the generative AI model to generate an answer, which is then returned to the device, which displays it to the user, allowing them to know the release date.

[0611] Through these processes, the present invention improves the efficiency and quality of the requirements definition phase, contributing to the success of the project.

[0612] The processing flow will be explained below.

[0613] Step 1:

[0614] User inputs requirements. Through a user interface, the user inputs project or product requirements in natural language. For example, "The customer management system needs the ability to add, edit, and delete customer information."

[0615] Step 2:

[0616] The terminal sends input to the server. The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[0617] Step 3:

[0618] The server receives the requirements. The server parses the received HTTP request and extracts the requirements information in JSON format.

[0619] Step 4:

[0620] The server analyzes the requirements using natural language processing technology. It then uses a generative AI model to understand the context of the requirements and organize and clarify them. For example, it clarifies the requirement as "Provide the ability to add, edit, and delete customer information."

[0621] Step 5:

[0622] The server documents the analysis results in a consistent format. The server reconstructs the organized and clarified requirements into an appropriate format and documents them in a consistent format.

[0623] Step 6:

[0624] The server sends the documented requirements back to the device, which then generates a JSON response containing the requirements organized in a consistent format and sends it back to the device as an HTTP response.

[0625] Step 7:

[0626] The terminal displays the results to the user. The terminal parses the JSON response received from the server and displays the organized requirements in the user interface, allowing the user to see clear and organized requirements.

[0627] Step 8:

[0628] The user types in a question: The user types in natural language a follow-up question about the requirement, for example, "What is the release date for the new feature?"

[0629] Step 9:

[0630] The device sends the question to the server. The device converts the user's question into JSON format and sends it to the server via an HTTP request.

[0631] Step 10:

[0632] The server receives the question, parses the HTTP request, and extracts the question information in JSON format.

[0633] Step 11:

[0634] The server generates an answer to the question. The server uses a generative AI model to generate an appropriate answer to the question it receives. For example, it generates an answer such as, "The release date for the new feature is the 1st of next month."

[0635] Step 12:

[0636] The server returns the generated answer to the device. The server creates a JSON response containing the generated answer and returns it to the device as an HTTP response.

[0637] Step 13:

[0638] The terminal displays the answer to the user. The terminal parses the JSON response received from the server and displays the generated answer in the user interface, allowing the user to check the answer to the question.

[0639] Step 14:

[0640] User enters specific domain information. The user enters information about a specific industry or domain in natural language. For example, "What are the key requirements in the financial industry?"

[0641] Step 15:

[0642] The device sends the domain information to the server. The device converts the domain information received from the user into JSON format and sends it to the server via an HTTP request.

[0643] Step 16:

[0644] The server receives the domain information. The server parses the received HTTP request and extracts the domain information in JSON format.

[0645] Step 17:

[0646] The server provides domain knowledge, which it then uses a generative AI model to generate domain-specific knowledge and translate it into a form that can be presented to the user, for example explaining the importance of security and data protection in the financial industry.

[0647] Step 18:

[0648] The server returns the generated domain knowledge to the terminal. The server generates a JSON response including the generated domain knowledge and returns it to the terminal as an HTTP response.

[0649] Step 19:

[0650] The terminal displays the domain knowledge to the user. The terminal parses the JSON response received from the server and displays the generated domain knowledge in the user interface, allowing the user to check important information about a specific domain.

[0651] Step 20:

[0652] The user inputs the task they want to automate. The user inputs the task they want to automate, such as organizing, categorizing, and evaluating the importance of requirements, in natural language. For example, they can input "List new requirements and categorize them."

[0653] Step 21:

[0654] The device sends the task to the server. The device converts the task received from the user into JSON format and sends it to the server via an HTTP request.

[0655] Step 22:

[0656] The server receives the task. The server parses the received HTTP request and extracts the task information in JSON format.

[0657] Step 23:

[0658] The server automates the task: Using generative AI models, the server automates the incoming task and takes appropriate action, such as listing new requirements and classifying each requirement into the appropriate category.

[0659] Step 24:

[0660] The server returns the results of the automated task to the device. The server generates a JSON response containing the results of the automated task and returns it to the device as an HTTP response.

[0661] Step 25:

[0662] The terminal displays the automation results to the user. The terminal parses the JSON response received from the server and displays the results of the automated task in the user interface, allowing the user to check the results of the automated task and take any necessary actions.

[0663] Through the above steps, the present invention can significantly streamline the requirements definition process, improving the speed at which projects progress and the quality of products.

[0664] Example 1

[0665] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0666] Traditional requirements definition processes rely on manual work to organize and clarify requirements, which is inefficient and prone to errors. In addition, insufficient communication between stakeholders can delay overall project progress. Furthermore, difficulty in accessing specific domain knowledge makes it difficult to define high-quality requirements. These issues inevitably lead to a decline in project speed, product quality, and customer satisfaction.

[0667] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0668] In this invention, the server

[0669] [Means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;

[0670] [Means of using generative AI models to clarify and clarify requirements and flesh out ambiguities;

[0671] [A means of converting documents into a consistent format and presenting them to users; and

[0672] This automates the organization and clarification of requirements, improving efficiency and reducing errors. Providing consistent documentation also promotes real-time communication between stakeholders, improving project progress. Furthermore, access to specific domain knowledge leads to higher-quality requirements definition, which is expected to improve project quality and customer satisfaction.

[0673] The "means for receiving input requirements" refers to a function for transmitting requirements input by a user in natural language to a server via a terminal, and for the server to receive the requirements.

[0674] "Natural language processing technology" refers to technology that enables computers to understand, analyze, and process human language. This technology can be used to organize and clarify input requirements.

[0675] A "generative AI model" is a type of artificial intelligence technology, specifically a model trained for natural language generation and understanding. In this invention, it is used to organize and clarify requirements.

[0676] "Means for documenting in a consistent format" refers to a function that allows organized and clarified requirements to be documented in a consistent format (e.g., Markdown or PDF) to make them easier for users to understand.

[0677] "Means for converting documents" refers to the ability to take requirements generated by a generative AI model and convert them into a specific format (e.g., Markdown or PDF).

[0678] "Interfaces that promote real-time communication" refers to user interfaces that facilitate instant communication between stakeholders, allowing them to share and discuss questions and opinions about requirements in real time.

[0679] A "knowledge base for a specific industry or domain" refers to a database that stores specialized knowledge about a specific industry or field. It is possible to access the information needed during the requirements definition process.

[0680] "Means of learning from past projects and best practices" refers to the ability to learn from data and success stories of past projects and use these insights to help improve the requirements definition process.

[0681] "Means to automate the organization, classification, and importance evaluation of requirements" refers to the function that automatically organizes, classifies, and evaluates the importance of requirements based on the requirements entered by the user, thereby improving work efficiency.

[0682] This invention relates to a requirements definition support system for streamlining the requirements definition phase of a project. This system uses generative AI models and natural language processing technology to support the organization, clarification, and documentation of requirements, thereby improving project progress speed, product quality, and customer satisfaction.

[0683] The main components of the system include a terminal for users to input requirements, a server for processing the input requirements, a generative AI model (e.g., GPT-4), and natural language processing technology.

[0684] Hardware and Software

[0685] Device: A PC or mobile device that provides a user interface (such as a web form or chat window).

[0686] Server: A backend server that receives and processes requests. The server uses the Flask framework and Python.

[0687] Generative AI models: Includes generative AI techniques such as GPT-4.

[0688] Libraries: Document generation libraries such as Pandoc or ReportLab.

[0689] Program processing

[0690] The user inputs requirements in natural language and sends them to the server via the device. The device converts the input requirements into JSON format and sends it as an HTTP POST request to the server. The server receives the request and uses a generative AI model (GPT-4) to organize and clarify the requirements. The generated content is then converted into a structured document using natural language processing techniques to clarify any ambiguities.

[0691] The generated document is converted into a consistent format (such as Markdown or PDF) and sent back from the server to the device. The device receives the document and displays it to the user. This allows the user to obtain organized and clarified requirements, enabling the project to proceed efficiently.

[0692] Specific examples

[0693] A user types, "I want you to organize the requirements for my customer management system." The device sends these requirements to the server, which uses a generative AI model to organize and clarify the requirements, and then sends the documented requirements back to the device.

[0694] Or, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate an answer to the question. This answer is returned to the device and displayed to the user.

[0695] Prompt Sentence Examples

[0696] "I want you to clarify the requirements for a customer management system."

[0697] "When are the new features released?"

[0698] "Tell me about EHR systems in the medical field."

[0699] This system configuration will streamline work during the requirements definition phase and contribute to the success of the project.

[0700] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0701] Processing Steps

[0702] The processing flow of the system program will be explained in the following steps.

[0703] Step 1:

[0704] User enters requirements

[0705] explanation

[0706] A user enters project requirements in natural language using the system's user interface (e.g., a web form or chat window).

[0707] Input and Output

[0708] Input: Requirements written in natural language (e.g., "Please organize the requirements for a customer management system.")

[0709] Output: Requirement data entered into the terminal

[0710] Specific actions

[0711] The user enters the requirements in the text box and presses the submit button.

[0712] Step 2:

[0713] The device sends the input requirements to the server

[0714] explanation

[0715] The terminal receives the requirements entered by the user, converts them into JSON format, and sends them to the server.

[0716] Input and Output

[0717] Input: Requirements data written in natural language

[0718] Output: Structured requirements data in JSON format (e.g., {"type": "requirement", "content": "Please organize the requirements for a customer management system"})

[0719] Specific actions

[0720] The terminal uses JavaScript code to convert the form contents into JSON format and then uses the Axios library to send an HTTP POST request to the server.

[0721] Step 3:

[0722] The server receives and analyzes the requirements

[0723] explanation

[0724] The server analyzes the JSON formatted requirements data received from the terminal and inputs it into the generative AI model (GPT-4).

[0725] Input and Output

[0726] Input: Structured requirements data in JSON format

[0727] Output: Requirements data in natural language format that is fed into a generative AI model

[0728] Specific actions

[0729] The server uses the Flask framework to receive HTTP requests, parses the JSON data using Python code, and then sends the requirements data to the generative AI model (GPT-4 API).

[0730] Step 4:

[0731] The server organizes and clarifies the requirements

[0732] explanation

[0733] The server uses generative AI models to organize and clarify requirements.

[0734] Input and Output

[0735] Input: Natural language requirements data sent to the GPT-4 API

[0736] Output: Organized and clarified requirements data (text format)

[0737] Specific actions

[0738] The results returned by the generative AI model are then used in Python code to further apply natural language processing to flesh out any ambiguities in the requirements.

[0739] Step 5:

[0740] Server documents requirements

[0741] explanation

[0742] The server converts the organized and clarified requirements into a consistent format (e.g., Markdown or PDF).

[0743] Input and Output

[0744] Input: Organized and clarified requirements data (text format)

[0745] Output: Documented requirements (e.g., Markdown or PDF)

[0746] Specific actions

[0747] The server uses libraries such as Pandoc and ReportLab to convert the generated text into Markdown or PDF format and save it as a document file.

[0748] Step 6:

[0749] The server sends the generated document back to the device

[0750] explanation

[0751] The server returns the generated document to the terminal as an HTTP response.

[0752] Input and Output

[0753] Input: Documented requirements (e.g., Markdown or PDF)

[0754] Output: JSON response containing the document URL (e.g., {"status": "success", "document_url": "https: / / example.com / documents / requirements_12345.pdf"})

[0755] Specific actions

[0756] The server generates a JSON response containing the document's URL and uses the Flask framework to send an HTTP response to the device.

[0757] Step 7:

[0758] The device displays the document to the user.

[0759] explanation

[0760] The terminal parses the received JSON response and displays the obtained document URL to the user.

[0761] Input and Output

[0762] Input: A JSON response containing the document URL

[0763] Output: The document that is displayed to the user (e.g., a PDF displayed in a web browser)

[0764] Specific actions

[0765] The device parses the JSON response and displays the obtained URL in an iframe tag or a new browser tab. For example, set the URL as the src attribute of the iframe tag as shown below.

[0766] html

[0767] <iframe src="https: / / example.com / documents / requirements_12345.pdf" width="100%" height="600px">< / iframe>

[0768] Through these steps, users will have clear and organized requirements, allowing the project to proceed efficiently.

[0769] (Application example 1)

[0770] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0771] Introducing or improving robots in factories requires the organization and clarification of a wide range of requirements. This process can be delayed due to a lack of communication between stakeholders or unclear requirements, which can have a negative impact on product quality and project progress. Furthermore, a lack of knowledge about a specific industrial domain makes it difficult to define optimal requirements. To solve these problems, a support system is needed that can streamline and clarify requirements definition, facilitate communication, and provide specialized knowledge.

[0772] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0773] In this invention, the server includes means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology, means for documenting the organized and clarified requirements in a consistent format, and means for providing an interface that promotes real-time communication between stakeholders. This allows users to analyze input requirements and document them in a unified format, and also provides industrial domain knowledge and task automation functions, thereby improving the progress speed and quality of projects.

[0774] "Requirements organization" is the process of clarifying the needs and specifications for a project or product and organizing them in a consistent format.

[0775] "Natural language processing technology" is a technology that enables computers to understand, analyze, and generate human language.

[0776] Documentation is the process of organizing information and data, converting it into a consistent format, and recording it as a document.

[0777] "Real-time communication" is a means of communication that allows stakeholders to exchange information without any time lag.

[0778] An "interface" is a means of providing a screen or method of operation for a user to interact with a system or application.

[0779] "Domain knowledge" is specialized knowledge about a particular industry or field.

[0780] "JSON format" is an abbreviation for JavaScript Object Notation, and is a lightweight format for structuring and representing data.

[0781] A "generative AI model" is a type of artificial intelligence, an advanced machine learning model for generating and editing text.

[0782] Documentation is the process of consistently recording information such as requirements, specifications, and project status.

[0783] "Task automation" is a system that automatically processes specified tasks without human intervention.

[0784] "Industrial domain knowledge" refers to specialized knowledge and know-how in the manufacturing and industrial fields.

[0785] To realize this invention, it is important to build a system that uses a generative AI model, natural language processing technology, and JSON format data transmission and analysis means. This system includes the following steps.

[0786] First, the user inputs requirements for introducing or improving a factory robot in natural language. The device used by the user (smartphone, tablet, computer, etc.) sends the input requirements to the server. At this time, the data is sent in JSON format.

[0787] The server then analyzes the received requirements using a generative AI model (e.g., the T5 model) to organize and clarify the requirements. The generative AI model is implemented using Hugging Face's transformers library. As a result of this analysis, the requirements are documented in a unified format. The documented requirements are then sent back from the server to the device and presented to the user.

[0788] Similarly, when a user inputs a question about a requirement, the device sends the question in JSON format to the server, which uses a generative AI model to generate an answer in real time, which is also displayed to the user on the device.

[0789] In addition, when a user inputs information about a specific industry or domain, the server uses a generative AI model to generate domain knowledge and provides it to the user. Also, when the user inputs the tasks they want to automate (organizing and classifying requirements, assessing importance, etc.), the server analyzes them and automates them.

[0790] The above process will streamline requirements definition and facilitate communication between stakeholders when introducing or improving factory robots. Furthermore, the provision of industrial domain knowledge and task automation functions are expected to improve the speed and quality of project progress.

[0791] As a concrete example, a project manager might input, "Please organize the requirements for a new assembly line for factory robots." That input is sent in JSON format to a server, which parses it using a generative AI model and documents the organized and clarified requirements in a unified format. The server then sends the document back to the terminal, which displays it to the user (project manager). Similarly, when a user asks, "When is the next product update?" the server uses the generative AI model to generate an answer and displays it to the user.

[0792] An example of a prompt is as follows:

[0793] "Organize the requirements for a new assembly line for factory robots."

[0794] "Automate the classification of quality control data."

[0795] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0796] Step 1:

[0797] The user inputs requirements for the introduction and improvement of factory robots in natural language using the device they use (smartphone, tablet, computer, etc.). The input requirements are converted into JSON format and sent to the server.

[0798] Step 2:

[0799] The device sends the user-entered requirements in JSON format to the server, which makes the data easier to parse.

[0800] Step 3:

[0801] The server analyzes the received requirements using a generative AI model (e.g., the T5 model) to organize and clarify the requirements. The generative AI model is implemented using Hugging Face's transformers library. As a result of this analysis, the requirements are organized in a consistent format.

[0802] Step 4:

[0803] The server documents the organized and clarified requirements and structures them in JSON format, which is then sent back to the device.

[0804] Step 5:

[0805] The terminal receives the documented requirements in JSON format returned from the server and displays them to the user, who can then review the organized requirements.

[0806] Step 6:

[0807] The user enters a question about the requirements in natural language, which is also converted to JSON format by the device and sent to the server.

[0808] Step 7:

[0809] The device receives questions from users and sends them in JSON format to the server, which analyzes the questions and generates answers in real time using a generative AI model.

[0810] Step 8:

[0811] The server uses a generative AI model to generate answers to questions, which are also written in natural language.

[0812] Step 9:

[0813] The server returns the generated answer to the terminal, which then displays the answer to the user, allowing the user to obtain the answer to their question.

[0814] Step 10:

[0815] When a user inputs information about a specific industry or domain, the device converts it into JSON format and sends it to the server, which uses generative AI models to generate domain knowledge and provide it to the user.

[0816] Step 11:

[0817] When a user wants to automate a task, they input the task in natural language and send it to the device. The device then sends the task in JSON format to the server, which then processes it for automation.

[0818] Step 12:

[0819] The server uses the generative AI model to automate the task and returns the results in JSON format to the device, which then displays the results to the user, allowing them to obtain the results of the automated task.

[0820] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0821] This invention relates to a requirements definition support tool that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This tool uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions. It also has an emotion engine that recognizes user emotions and adds a function to adjust the requirements definition process based on the recognized emotions.

[0822] Specific methods for carrying out the invention

[0823] Organizing and clarifying requirements

[0824] 1. User enters requirements

[0825] Users enter requirements in natural language through a user interface, which are concrete statements of needs and specifications for a project or product.

[0826] 2. The device sends the input to the server

[0827] The terminal converts the requirements entered by the user into JSON format and sends it to the server through an HTTP request, making it easier for the server to parse the requirements.

[0828] 3. The server organizes and clarifies the requirements

[0829] The server applies natural language processing techniques using generative AI models to the requirements received, organizes and clarifies the requirements, and documents the organized requirements in a consistent format.

[0830] Communication Support

[0831] 1. User enters a question

[0832] Users enter specific requirements or project-related questions in natural language to resolve information gaps or doubts about the project.

[0833] 2. The device sends the question to the server

[0834] The device receives a question from the user and sends it in JSON format to the server, which analyzes the question and begins processing it to generate an appropriate answer.

[0835] 3. The server answers the question

[0836] The server uses a generative AI model to generate answers to questions, which are written in natural language and in a user-friendly format.

[0837] Providing domain knowledge

[0838] 1. User enters specific domain information

[0839] Users input information about a specific industry or field in natural language, allowing them to access the domain knowledge they need during the requirements definition process.

[0840] 2. The device sends the domain information to the server

[0841] The device sends the domain information received from the user in JSON format to the server, which receives this information and begins processing it to provide knowledge about the domain.

[0842] 3. The server provides domain knowledge

[0843] The server uses generative AI models to generate knowledge about a specific domain and provides it to the user.

[0844] Automation and efficiency

[0845] 1. The user enters the task they want to automate

[0846] Users input tasks they want to automate, such as organizing and categorizing requirements and evaluating their importance, in natural language, thereby improving work efficiency.

[0847] 2. The device sends the task to the server

[0848] The device converts the task received from the user into JSON format and sends it to the server via an HTTP request. The server analyzes the task and starts the process for automation.

[0849] 3. Server automates tasks

[0850] The server uses the generative AI model to automate the task, which is then automatically processed and the results are provided to the user.

[0851] Emotion engine integration

[0852] 1. Recognize user emotions

[0853] The emotion engine analyzes user input and user interface behavior to recognize user emotions, for example, by inferring emotions based on input text and click frequency.

[0854] 2. The device sends emotional information to the server

[0855] The device sends the recognized user emotion information to the server in JSON format, allowing the server to adjust subsequent processes based on the emotion.

[0856] 3. The server adjusts the process based on emotions

[0857] The server then adjusts the requirements definition and communication support processes based on the received emotional information. For example, if the user is feeling stressed, it will provide more detailed guidance.

[0858] Specific examples

[0859] For example, if a user types "I want you to organize the requirements for a customer management system," the terminal sends this to the server, which then analyzes, organizes, and documents the requirements in a consistent format. At the same time, the system recognizes the user's emotions based on the speed and context of their input, and displays additional help messages if the user is feeling stressed.

[0860] Furthermore, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate an answer. At the same time, it monitors the user's emotions and responds quickly if the user is in a hurry.

[0861] Through these processes, the present invention contributes to the success of projects by significantly streamlining the requirements definition process and enabling flexible responses to user emotions.

[0862] The processing flow will be explained below.

[0863] Step 1:

[0864] The user enters requirements. Through a user interface, the user enters project or product requirements in natural language. For example, the user might enter, "The customer management system needs the ability to add, edit, and delete customer information."

[0865] Step 2:

[0866] The terminal sends input to the server. The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[0867] Step 3:

[0868] The server receives the requirements. The server parses the received HTTP request and extracts the requirements information in JSON format.

[0869] Step 4:

[0870] The server analyzes the requirements using natural language processing technology. It then uses a generative AI model to understand the context of the requirements and organize and clarify them. For example, it clarifies the requirement as "Provide the ability to add, edit, and delete customer information."

[0871] Step 5:

[0872] The server documents the organized requirements. The server documents the organized and clarified requirements in a consistent format.

[0873] Step 6:

[0874] The server returns the documented requirements to the device. The server generates a JSON response containing the documented requirements and returns it to the device as an HTTP response.

[0875] Step 7:

[0876] The terminal displays the results to the user. The terminal parses the JSON response received from the server and displays the organized requirements in the user interface, allowing the user to see clear and organized requirements.

[0877] Step 8:

[0878] User enters a question: A user enters a question in natural language about a specific requirement or project, such as "What is the release date for the new feature?"

[0879] Step 9:

[0880] The device sends the question to the server. The device converts the entered question into JSON format and sends it to the server via an HTTP request.

[0881] Step 10:

[0882] The server receives the question, parses the HTTP request, and extracts the question information in JSON format.

[0883] Step 11:

[0884] The server generates an answer to the question. The server uses a generative AI model to generate an appropriate answer to the question. For example, it generates an answer such as "The release date for the new feature is the 1st of next month."

[0885] Step 12:

[0886] The server returns the answer to the device. The server creates a JSON response containing the answer and returns it to the device as an HTTP response.

[0887] Step 13:

[0888] The terminal displays the answer to the user. The terminal parses the JSON response received from the server and displays the generated answer in the user interface, allowing the user to check the answer to the question.

[0889] Step 14:

[0890] User enters specific domain information. The user enters information about a specific industry or domain in natural language. For example, "What are the key requirements in the financial industry?"

[0891] Step 15:

[0892] The device sends the domain information to the server. The device converts the domain information received from the user into JSON format and sends it to the server via an HTTP request.

[0893] Step 16:

[0894] The server receives the domain information. The server parses the received HTTP request and extracts the domain information in JSON format.

[0895] Step 17:

[0896] The server provides domain knowledge: Using generative AI models, the server generates knowledge about a specific domain and provides it to the user, for example explaining the importance of security and data protection in the financial industry.

[0897] Step 18:

[0898] The server returns the generated domain knowledge to the terminal. The server generates a JSON response including the generated domain knowledge and returns it to the terminal as an HTTP response.

[0899] Step 19:

[0900] The terminal displays the domain knowledge to the user. The terminal parses the JSON response received from the server and displays the generated domain knowledge in the user interface, allowing the user to check important information about a specific domain.

[0901] Step 20:

[0902] The user inputs the task they want to automate. The user inputs the task they want to automate, such as organizing, categorizing, and evaluating the importance of requirements, in natural language. For example, they might input "List new requirements and categorize them."

[0903] Step 21:

[0904] The device sends the task to the server. The device converts the task received from the user into JSON format and sends it to the server via an HTTP request.

[0905] Step 22:

[0906] The server receives the task. The server parses the received HTTP request and extracts the task information in JSON format.

[0907] Step 23:

[0908] The server automates the task: Using generative AI models, the server automates the incoming task and takes appropriate action, such as listing new requirements and classifying each requirement into the appropriate category.

[0909] Step 24:

[0910] The server returns the results of the automated task to the device. The server generates a JSON response containing the results of the automated task and returns it to the device as an HTTP response.

[0911] Step 25:

[0912] The terminal displays the automation results to the user. The terminal parses the JSON response received from the server and displays the results of the automated task in the user interface, allowing the user to check the results of the automated task and take any necessary actions.

[0913] Emotion engine integration

[0914] Step 26:

[0915] The emotion engine recognizes the user's emotions. The emotion engine analyzes the user's input and behavior on the user interface to recognize the user's emotions. For example, it infers the user's emotions based on the entered text, typing speed, click frequency, etc.

[0916] Step 27:

[0917] The device sends the emotion information to the server. The device sends the recognized emotion information of the user to the server in JSON format, which allows the server to adjust subsequent processes based on the emotion.

[0918] Step 28:

[0919] The server adjusts the process based on the emotion. The server adjusts the requirements definition and communication support processes based on the emotion information it receives. For example, if the user is feeling stressed, it will respond by providing more detailed guidance.

[0920] Through the above steps, the present invention significantly streamlines the requirements definition process and enables flexible responses to user emotions, thereby contributing to the success of the project.

[0921] Example 2

[0922] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0923] Traditional requirements definition processes are often manual and require a great deal of time and effort. Real-time communication between stakeholders is difficult, which can delay information sharing and decision-making. Furthermore, the process is often carried out without consideration of user feelings, which can result in an unsatisfactory user experience. It is necessary to resolve these issues, streamline the requirements definition process, and improve project progress speed, product quality, and customer satisfaction.

[0924] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[0925] In this invention, the server includes: [means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;] [means for documenting the organized and clarified requirements in a consistent format; and] [means for recognizing the user's emotions using an emotion engine and adjusting the requirements definition process based on the recognized emotions.] This makes it possible to improve the efficiency of the requirements definition process, realize smooth communication between stakeholders, and realize responses that correspond to the user's emotions.

[0926] "Means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology" refers to a function for receiving requirements that a user inputs to the system in natural language, systematically organizing them using natural language processing technology, and clarifying the content.

[0927] "Means for documenting organized and clarified requirements in a consistent format" refers to a function for documenting organized and clarified requirements using natural language processing technology in accordance with certain rules and formats, and for saving and displaying them in a consistent format.

[0928] "Means for providing an interface that promotes real-time communication among stakeholders" is a function that provides a user interface that helps real-time information sharing and communication among those involved in the project.

[0929] "A means of integrating knowledge bases related to specific industries or fields and enabling access to information needed during the requirements definition process" is a function that integrates a database that aggregates knowledge related to specific industries or fields, making it easy to access information needed during the requirements definition process.

[0930] "Means for recognizing user emotions using an emotion engine and adjusting the requirements definition process based on the recognized emotions" refers to a function that uses an emotion engine that analyzes emotions from user input and behavior to recognize the user's current emotional state and adjusts the requirements definition procedure and interactions according to those emotions.

[0931] "A means of learning from past projects and best practices to help improve the requirements definition process" is a function that learns from past project data and industry best practices, and uses that knowledge to help streamline and improve the requirements definition process.

[0932] "Means for automating the organization, classification, and importance evaluation of requirements" refers to a function that automates the process of properly organizing and classifying requirements and evaluating their importance. This reduces the manual workload and enables faster and more accurate requirements management.

[0933] This invention is a requirements definition support system that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This system uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions. It also features an emotion engine that recognizes user emotions. Furthermore, the requirements definition process can be dynamically adjusted based on the emotions recognized by this emotion engine.

[0934] Specifically, users input project or product requirements in natural language through a user interface. This input is converted to JSON format by the terminal and sent to the server via an HTTP request. The server then applies natural language processing techniques using generative AI models to the received requirements to organize and clarify them. The organized requirements are then documented in a consistent format.

[0935] To support real-time communication, users input questions about specific requirements or projects. The device converts the input into JSON format and sends it to the server via an HTTP request. The server then uses a generative AI model to generate answers to the questions and provides them to the user. Additionally, when users input information about a specific industry or field, the device sends it to the server, which then generates domain knowledge and provides it to the user.

[0936] With the automation and efficiency feature, when a user inputs automation tasks such as organizing and categorizing requirements and assessing their importance, the device converts the input into JSON format and sends it to the server via an HTTP request. The server then uses a generative AI model to automate the task and provides the results to the user.

[0937] The integration of an emotion engine allows the system to recognize emotions from user input and behavior and adjust subsequent processes based on those emotions. For example, if the user is feeling stressed, the system will provide detailed guidance and improve the user experience.

[0938] For example, if a user types "I want you to organize the requirements for a customer management system," the terminal sends this to the server, which then analyzes, organizes, and documents the requirements in a consistent format. It can also recognize emotions from the user's typing speed and context, and display additional help messages if the user is feeling stressed.

[0939] Furthermore, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate a quick answer, while simultaneously monitoring the user's emotions and responding even faster if they are in a hurry.

[0940] Through these processes, the present invention significantly improves the efficiency of the requirements definition process and makes it possible to respond to user emotions, thereby greatly contributing to the success of the project.

[0941] Examples of prompts include:

[0942] "I want you to clarify the requirements for a customer management system."

[0943] "When are the new features released?"

[0944] Please provide the latest domain information.

[0945] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0946] Organizing and clarifying requirements

[0947] Step 1:

[0948] User enters requirements

[0949] The user inputs specific requirements for a project or product in natural language. For example, they input specific content such as "database requirements for a new customer management system." The input data is requirement information in text format.

[0950] Step 2:

[0951] The device sends the input requirements to the server

[0952] The terminal acquires the requirements entered by the user and converts them into JSON format. For example, if the entered requirements are "Database requirements for a new customer management system," they are converted into the following JSON data:

[0953] json

[0954] {

[0955] "requirement": "Database requirements for the new customer management system"

[0956] }

[0957] This is sent to the server as an HTTP POST request.

[0958] Step 3:

[0959] The server organizes and clarifies the requirements

[0960] The server analyzes the received requirements data and applies natural language processing techniques using a generative AI model to organize and clarify the requirements. For example, if the requirement is "The database should have high availability and scalability," the server extracts keywords such as "availability" and "scalability" and generates an organized document. The results are output in document format.

[0961] Communication Support

[0962] Step 1:

[0963] The user enters a question

[0964] A user types in natural language a question about a specific requirement or project, for example, "What is the release date for the new feature?" The input data is a textual question.

[0965] Step 2:

[0966] The device sends a question to the server

[0967] The device converts the question received from the user into JSON format and sends it to the server via an HTTP request, for example:

[0968] json

[0969] {

[0970] "question": "When is the new feature release date?"

[0971] }

[0972] Step 3:

[0973] The server answers the question

[0974] The server uses a generative AI model to analyze the question and generate an appropriate answer, such as "The new feature will be released on December 15, 2023," in natural language format.

[0975] Providing domain knowledge

[0976] Step 1:

[0977] User enters specific domain information

[0978] A user inputs information about a specific industry or field in natural language. For example, "What are the latest trends in the fintech industry?" The input data is domain information in text format.

[0979] Step 2:

[0980] The device sends the domain information to the server.

[0981] The terminal converts the domain information received from the user into JSON format and sends it to the server via an HTTP request. For example, convert it as follows:

[0982] json

[0983] {

[0984] "domain_info": "What are the latest trends in the fintech industry?"

[0985] }

[0986] Step 3:

[0987] The server provides domain knowledge

[0988] The server uses the generative AI model to generate domain-specific knowledge, such as "Digital banking and smart contracts are hot topics in the latest FinTech industry" in natural language.

[0989] Automation and efficiency

[0990] Step 1:

[0991] The user enters the task they want to automate.

[0992] The user inputs the task to be automated, such as organizing and categorizing requirements, evaluating their importance, etc. in natural language. For example, the user might input "Automatically organize the list of requirements according to priority." The input data is the automation task in text format.

[0993] Step 2:

[0994] The device sends the task to the server

[0995] The device converts the task received from the user into JSON format and sends it to the server via an HTTP request, for example:

[0996] json

[0997] {

[0998] "task": "Automatically organize the requirements list by priority"

[0999] }

[1000] Step 3:

[1001] Server automates tasks

[1002] The server uses the generative AI model to automate tasks, specifically by analyzing the incoming requirements, assessing the importance of each requirement, and organizing them according to priority. The results are output as an organized list of requirements.

[1003] Emotion engine integration

[1004] Step 1:

[1005] Emotion engine recognizes user emotions

[1006] The emotion engine analyzes user input and behavior to recognize emotions. For example, it infers emotions such as "irritated" from input text, click frequency, and usage time. Input data is user behavior logs and text data.

[1007] Step 2:

[1008] The device sends emotional information to the server.

[1009] The device sends the user's recognized emotion information to the server in JSON format. For example, it can be converted as follows:

[1010] json

[1011] {

[1012] "emotion": "frustrated"

[1013] }

[1014] Step 3:

[1015] Server adjusts process based on emotion

[1016] The server adjusts the requirements definition and communication process based on the emotional information received, for example, if the user is feeling stressed, it displays additional guidance or support messages.

[1017] (Application example 2)

[1018] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[1019] The requirements definition phase of a project is often complex and time-consuming, and poor communication between stakeholders and a lack of domain knowledge can affect quality and progress speed. Furthermore, in projects requiring advanced technology such as autonomous vehicles, it is particularly important to organize and clarify requirements, provide domain knowledge, support real-time communication, and adjust the process while taking user emotions into consideration. Therefore, solutions are needed to efficiently and effectively execute such a complex requirements definition phase.

[1020] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[1021] In this invention, the server includes: [means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;] [means for documenting the organized and clarified requirements in a consistent format;] [means for providing an interface that promotes real-time communication between stakeholders;] [means for integrating a knowledge base related to a specific industry or domain and making necessary information accessible during the requirements definition process;] [means for learning from past projects and best practices and supporting improvement of the requirements definition process;] [means for automating the organization, classification, and importance assessment of requirements;] [means for integrating an emotion engine, analyzing user emotions, and adjusting the process; and] [means for analyzing requirements related to autonomous vehicles and providing information on necessary sensors and machine learning models.] This enables the requirements definition phase of a project to be carried out efficiently and effectively, improving progress speed with high quality, and enabling the provision of domain knowledge and real-time communication support, especially in projects that require advanced technology such as autonomous vehicles.

[1022] Organizing and clarifying requirements using natural language processing techniques is the process of modularizing project or product needs and specifications into a consistent and easy-to-understand format.

[1023] "Documenting in a consistent format" means recording the organized and clarified requirements in a document in a standardized format so that they can be easily used in subsequent processes.

[1024] An "interface that promotes real-time communication between stakeholders" is a user interface that enables those involved in a project to share information in real time and communicate smoothly.

[1025] "Integrating a knowledge base for a specific industry or domain" means using a database that systematically compiles specialized knowledge in a specific industry or technical field, enabling quick and accurate access to the information needed when defining requirements.

[1026] "Learning from past projects and best practices" refers to techniques and methodologies for analyzing the results and success stories of previous projects and applying that knowledge to the next project.

[1027] "Automating the organization, classification, and importance evaluation of requirements" means that the machine automatically analyzes the input requirements, classifies them by item, and evaluates their importance.

[1028] "Integrating an emotion engine, analyzing user emotions, and adjusting the process" means incorporating an engine into the system that analyzes the user's emotions and stress level, and then appropriately adjusting the way the project is progressing based on the results.

[1029] "Analyzing requirements related to autonomous vehicles and providing information on necessary sensors and machine learning models" means specifically defining the functions and performance required for autonomous vehicles and providing information on the hardware and software components required for them.

[1030] This invention provides a system that integrates multiple technologies to streamline the requirements definition phase of a project and obtain high-quality results. Specifically, this system includes the following components:

[1031] First, a user inputs project or product requirements in natural language. These requirements are entered into a terminal through a designated user interface. The terminal converts the input requirements into JSON format and sends it to the server via an HTTP request. The server then applies natural language processing techniques using generative AI models to organize and clarify the requirements and document the results in a consistent format.

[1032] Next, an interface is provided to facilitate real-time communication between stakeholders. The device receives users' questions and opinions and sends them to the server, which then uses a generative AI model to generate appropriate answers. As a result, project participants can smoothly share information and make quick decisions.

[1033] Furthermore, it integrates knowledge bases related to specific industries and domains, making necessary information accessible during the requirements definition process. When a user inputs specific domain information, the device transmits the information to the server, which then uses generative AI models to provide relevant knowledge.

[1034] It also includes a means to learn from past projects and best practices to help improve the requirements definition process. The server analyzes data using machine learning models to analyze past deliverables and success stories and apply the knowledge to the next project.

[1035] Furthermore, it provides a means to automate the organization, classification, and importance evaluation of requirements. When a user inputs a task they want to automate in natural language, the device sends the task to the server, which then uses a generative AI model to automatically process the task.

[1036] It also includes a means for integrating an emotion engine, analyzing the user's emotions, and adjusting the process. The emotion engine analyzes the user's input and behavior, recognizes the user's emotions, and then the server adjusts the process based on that information. For example, if the user is feeling stressed, it provides more detailed guidance.

[1037] Finally, it includes a means for analyzing requirements related to autonomous vehicles and providing information on the necessary sensors and machine learning models. When a user inputs the requirements for an autonomous vehicle, the device sends them to the server, which then provides information on the necessary hardware and software.

[1038] For example, if a user asks, "What kind of sensors do autonomous vehicles need?", the device sends the question to the server, which uses a generative AI model to generate an answer. The answer is returned in the form of, "An autonomous vehicle needs LiDAR, RADAR, cameras, ultrasonic sensors, etc." At this time, the user's emotions are also analyzed, and if the user is in a hurry, a quick response is made.

[1039] Through the above means, the system of the present invention can streamline the requirements definition phase of a project and obtain high-quality results.

[1040] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1041] Step 1:

[1042] Users enter project or product requirements in natural language.

[1043] Input: Project or product requirements (natural language text)

[1044] Specific operation: The user inputs requirements through a device such as a smartphone, smart glasses, or head-mounted display.

[1045] Step 2:

[1046] The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[1047] Input: User-entered requirements (natural language text)

[1048] Data processing: converting natural language text into JSON format

[1049] Output: HTTP request (JSON format data)

[1050] Specific operation: The application on the device parses the text, encodes it into JSON format, and sends a POST request to the server.

[1051] Step 3:

[1052] The server applies natural language processing technology using a generative AI model to the requirements received, organizing and clarifying the requirements.

[1053] Input: HTTP request (JSON format data)

[1054] Data Computing: Analyzing natural language text using generative AI models to organize and clarify requirements

[1055] Output: Organized and clarified requirements (structured data)

[1056] What it does: A natural language processing engine running on the server parses the requirements text, categorizes and prioritizes them, and generates structured data.

[1057] Step 4:

[1058] The server documents the organized and clarified requirements in a consistent format.

[1059] Input: Organized and clarified requirements (structured data)

[1060] Data transformation: converting structured data into a consistent document format

[1061] Output: Document file (e.g. PDF or Word)

[1062] Specific operation: The server's document generation engine converts the structured data into a document format based on a template and saves or transmits it.

[1063] Step 5:

[1064] The server provides an interface that facilitates real-time communication between stakeholders.

[1065] Input: Questions and opinions from stakeholders (natural language text)

[1066] Data Computing: Parsing Questions and Generating Answers with Generative AI Models

[1067] Output: Answer text (natural language text)

[1068] Specific operation: The server provides a real-time chat function, receives inquiries from stakeholders, and generates answers using a generative AI model.

[1069] Step 6:

[1070] The user enters information about a specific industry or domain, and the device sends the information to a server.

[1071] Input: Information about a specific industry or domain (natural language text)

[1072] Data processing: converting natural language text into JSON format

[1073] Output: HTTP request (JSON format data)

[1074] Specific operation: The device converts the text into JSON format and sends it to the server.

[1075] Step 7:

[1076] The server provides knowledge about a specific industry or domain.

[1077] Input: HTTP request (JSON format data)

[1078] Data Computing: Using generative AI models to analyze relevant knowledge and generate information

[1079] Output: Domain knowledge text (natural language text)

[1080] Specific operation: The server extracts relevant information from the knowledge base, analyzes it using a generative AI model, and provides it in text format.

[1081] Step 8:

[1082] The server analyzes the user's emotions and adjusts the subsequent process.

[1083] Input: Emotional information (user behavior and input text)

[1084] Data calculation: Emotion analysis with emotion engine

[1085] Output: The adjusted process (e.g., guidance message)

[1086] Specific operation: The server's emotion engine analyzes the emotion information and adjusts the way the project proceeds as needed.

[1087] Step 9:

[1088] The user inputs the requirements for the autonomous vehicle, and the terminal sends the requirements to the server.

[1089] Input: Requirements related to autonomous vehicles (natural language text)

[1090] Data processing: converting natural language text into JSON format

[1091] Output: HTTP request (JSON format data)

[1092] Specific operation: The terminal converts the requirement text into JSON format and sends it to the server.

[1093] Step 10:

[1094] The server provides information on sensors and machine learning models required for autonomous vehicles.

[1095] Input: HTTP request (JSON format data)

[1096] Data Computing: Using generative AI models to analyze and provide relevant information

[1097] Output: Information about sensors and machine learning models (natural language text)

[1098] Specific operation: The server generates relevant technical information and provides it to the user.

[1099] Through these steps, the requirements definition phase of the project will be streamlined and produce high-quality results.

[1100] The specific processing unit 290 transmits the result of the specific processing to the smart glasses 214. In the smart glasses 214, the control unit 46A causes the speaker 240 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[1101] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1102] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the smart glasses 214.

[1103] [Third embodiment]

[1104] FIG. 5 shows an example of the configuration of a data processing system 310 according to the third embodiment.

[1105] 5, the data processing system 310 includes the data processing device 12 and a headset type terminal 314. An example of the data processing device 12 is a server.

[1106] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1107] The headset type terminal 314 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a display 343. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the display 343 are also connected to the bus 52.

[1108] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[1109] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[1110] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1111] Fig. 6 shows an example of the main functions of the data processing device 12 and the headset type terminal 314. As shown in Fig. 6, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1112] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[1113] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[1114] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[1115] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the headset type terminal 314 will be referred to as the "terminal."

[1116] This invention relates to a requirements definition support tool that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This tool uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions.

[1117] Specific methods for carrying out the invention

[1118] Organizing and clarifying requirements

[1119] 1. User enters requirements

[1120] Users enter requirements in natural language through a user interface, which are concrete statements of needs and specifications for a project or product.

[1121] 2. The device sends the input to the server

[1122] The device receives the requirements entered by the user and sends them to the server in JSON format, which makes it easier for the server to parse the requirements.

[1123] 3. The server organizes and clarifies the requirements

[1124] The server applies natural language processing techniques using generative AI models to the requirements received, organizes and clarifies the requirements, and documents the organized requirements in a consistent format.

[1125] Communication Support

[1126] 1. User enters a question

[1127] Users enter specific requirements or project-related questions in natural language to resolve information gaps or doubts about the project.

[1128] 2. The device sends the question to the server

[1129] The device receives a question from the user and sends it in JSON format to the server, which analyzes the question and begins processing it to generate an appropriate answer.

[1130] 3. The server answers the question

[1131] The server uses a generative AI model to generate answers to questions, which are written in natural language and in a user-friendly format.

[1132] Providing domain knowledge

[1133] 1. User enters specific domain information

[1134] Users input information about a specific industry or field in natural language, allowing them to access the domain knowledge they need during the requirements definition process.

[1135] 2. The device sends the domain information to the server

[1136] The device sends the domain information received from the user in JSON format to the server, which receives this information and begins processing it to provide knowledge about the domain.

[1137] 3. The server provides domain knowledge

[1138] The server uses generative AI models to generate knowledge about a specific domain and provides it to the user.

[1139] Automation and efficiency

[1140] 1. The user enters the task they want to automate

[1141] Users input tasks they want to automate, such as organizing and categorizing requirements and evaluating their importance, in natural language, thereby improving work efficiency.

[1142] 2. The device sends the task to the server

[1143] The device receives a task from the user and sends it in JSON format to the server, which analyzes the task and starts the process for automation.

[1144] 3. Server automates tasks

[1145] The server uses the generative AI model to automate the task, which is then automatically processed and the results are provided to the user.

[1146] Specific examples

[1147] For example, if a user inputs "I want the requirements for a customer management system organized," the following steps are executed: The terminal sends the requirements to the server, which analyzes, organizes, and documents them in a consistent format. The server returns the generated document to the terminal, which displays it to the user, providing the user with clear and organized requirements.

[1148] Also, if a user asks, "When is the new feature released?", the device sends this question to the server, which uses the generative AI model to generate an answer, which is then returned to the device, which displays it to the user, allowing them to know the release date.

[1149] Through these processes, the present invention improves the efficiency and quality of the requirements definition phase, contributing to the success of the project.

[1150] The processing flow will be explained below.

[1151] Step 1:

[1152] User inputs requirements. Through a user interface, the user inputs project or product requirements in natural language. For example, "The customer management system needs the ability to add, edit, and delete customer information."

[1153] Step 2:

[1154] The terminal sends input to the server. The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[1155] Step 3:

[1156] The server receives the requirements. The server parses the received HTTP request and extracts the requirements information in JSON format.

[1157] Step 4:

[1158] The server analyzes the requirements using natural language processing technology. It then uses a generative AI model to understand the context of the requirements and organize and clarify them. For example, it clarifies the requirement as "Provide the ability to add, edit, and delete customer information."

[1159] Step 5:

[1160] The server documents the analysis results in a consistent format. The server reconstructs the organized and clarified requirements into an appropriate format and documents them in a consistent format.

[1161] Step 6:

[1162] The server sends the documented requirements back to the device, which then generates a JSON response containing the requirements organized in a consistent format and sends it back to the device as an HTTP response.

[1163] Step 7:

[1164] The terminal displays the results to the user. The terminal parses the JSON response received from the server and displays the organized requirements in the user interface, allowing the user to see clear and organized requirements.

[1165] Step 8:

[1166] The user types in a question: The user types in natural language a follow-up question about the requirement, for example, "What is the release date for the new feature?"

[1167] Step 9:

[1168] The device sends the question to the server. The device converts the user's question into JSON format and sends it to the server via an HTTP request.

[1169] Step 10:

[1170] The server receives the question, parses the HTTP request, and extracts the question information in JSON format.

[1171] Step 11:

[1172] The server generates an answer to the question. The server uses a generative AI model to generate an appropriate answer to the question it receives. For example, it generates an answer such as, "The release date for the new feature is the 1st of next month."

[1173] Step 12:

[1174] The server returns the generated answer to the device. The server creates a JSON response containing the generated answer and returns it to the device as an HTTP response.

[1175] Step 13:

[1176] The terminal displays the answer to the user. The terminal parses the JSON response received from the server and displays the generated answer in the user interface, allowing the user to check the answer to the question.

[1177] Step 14:

[1178] User enters specific domain information. The user enters information about a specific industry or domain in natural language. For example, "What are the key requirements in the financial industry?"

[1179] Step 15:

[1180] The device sends the domain information to the server. The device converts the domain information received from the user into JSON format and sends it to the server via an HTTP request.

[1181] Step 16:

[1182] The server receives the domain information. The server parses the received HTTP request and extracts the domain information in JSON format.

[1183] Step 17:

[1184] The server provides domain knowledge, which it then uses a generative AI model to generate domain-specific knowledge and translate it into a form that can be presented to the user, for example explaining the importance of security and data protection in the financial industry.

[1185] Step 18:

[1186] The server returns the generated domain knowledge to the terminal. The server generates a JSON response including the generated domain knowledge and returns it to the terminal as an HTTP response.

[1187] Step 19:

[1188] The terminal displays the domain knowledge to the user. The terminal parses the JSON response received from the server and displays the generated domain knowledge in the user interface, allowing the user to check important information about a specific domain.

[1189] Step 20:

[1190] The user inputs the task they want to automate. The user inputs the task they want to automate, such as organizing, categorizing, and evaluating the importance of requirements, in natural language. For example, they can input "List new requirements and categorize them."

[1191] Step 21:

[1192] The device sends the task to the server. The device converts the task received from the user into JSON format and sends it to the server via an HTTP request.

[1193] Step 22:

[1194] The server receives the task. The server parses the received HTTP request and extracts the task information in JSON format.

[1195] Step 23:

[1196] The server automates the task: Using generative AI models, the server automates the incoming task and takes appropriate action, such as listing new requirements and classifying each requirement into the appropriate category.

[1197] Step 24:

[1198] The server returns the results of the automated task to the device. The server generates a JSON response containing the results of the automated task and returns it to the device as an HTTP response.

[1199] Step 25:

[1200] The terminal displays the automation results to the user. The terminal parses the JSON response received from the server and displays the results of the automated task in the user interface, allowing the user to check the results of the automated task and take any necessary actions.

[1201] Through the above steps, the present invention can significantly streamline the requirements definition process, improving the speed at which projects progress and the quality of products.

[1202] Example 1

[1203] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1204] Traditional requirements definition processes rely on manual work to organize and clarify requirements, which is inefficient and prone to errors. In addition, insufficient communication between stakeholders can delay overall project progress. Furthermore, difficulty in accessing specific domain knowledge makes it difficult to define high-quality requirements. These issues inevitably lead to a decline in project speed, product quality, and customer satisfaction.

[1205] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1206] In this invention, the server

[1207] [Means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;

[1208] [Means of using generative AI models to clarify and clarify requirements and flesh out ambiguities;

[1209] [A means of converting documents into a consistent format and presenting them to users; and

[1210] This automates the organization and clarification of requirements, improving efficiency and reducing errors. Providing consistent documentation also promotes real-time communication between stakeholders, improving project progress. Furthermore, access to specific domain knowledge leads to higher-quality requirements definition, which is expected to improve project quality and customer satisfaction.

[1211] The "means for receiving input requirements" refers to a function for transmitting requirements input by a user in natural language to a server via a terminal, and for the server to receive the requirements.

[1212] "Natural language processing technology" refers to technology that enables computers to understand, analyze, and process human language. This technology can be used to organize and clarify input requirements.

[1213] A "generative AI model" is a type of artificial intelligence technology, specifically a model trained for natural language generation and understanding. In this invention, it is used to organize and clarify requirements.

[1214] "Means for documenting in a consistent format" refers to a function that allows organized and clarified requirements to be documented in a consistent format (e.g., Markdown or PDF) to make them easier for users to understand.

[1215] "Means for converting documents" refers to the ability to take requirements generated by a generative AI model and convert them into a specific format (e.g., Markdown or PDF).

[1216] "Interfaces that promote real-time communication" refers to user interfaces that facilitate instant communication between stakeholders, allowing them to share and discuss questions and opinions about requirements in real time.

[1217] A "knowledge base for a specific industry or domain" refers to a database that stores specialized knowledge about a specific industry or field. It is possible to access the information needed during the requirements definition process.

[1218] "Means of learning from past projects and best practices" refers to the ability to learn from data and success stories of past projects and use these insights to help improve the requirements definition process.

[1219] "Means to automate the organization, classification, and importance evaluation of requirements" refers to the function that automatically organizes, classifies, and evaluates the importance of requirements based on the requirements entered by the user, thereby improving work efficiency.

[1220] This invention relates to a requirements definition support system for streamlining the requirements definition phase of a project. This system uses generative AI models and natural language processing technology to support the organization, clarification, and documentation of requirements, thereby improving project progress speed, product quality, and customer satisfaction.

[1221] The main components of the system include a terminal for users to input requirements, a server for processing the input requirements, a generative AI model (e.g., GPT-4), and natural language processing technology.

[1222] Hardware and Software

[1223] Device: A PC or mobile device that provides a user interface (such as a web form or chat window).

[1224] Server: A backend server that receives and processes requests. The server uses the Flask framework and Python.

[1225] Generative AI models: Includes generative AI techniques such as GPT-4.

[1226] Libraries: Document generation libraries such as Pandoc or ReportLab.

[1227] Program processing

[1228] The user inputs requirements in natural language and sends them to the server via the device. The device converts the input requirements into JSON format and sends it as an HTTP POST request to the server. The server receives the request and uses a generative AI model (GPT-4) to organize and clarify the requirements. The generated content is then converted into a structured document using natural language processing techniques to clarify any ambiguities.

[1229] The generated document is converted into a consistent format (such as Markdown or PDF) and sent back from the server to the device. The device receives the document and displays it to the user. This allows the user to obtain organized and clarified requirements, enabling the project to proceed efficiently.

[1230] Specific examples

[1231] A user types, "I want you to organize the requirements for my customer management system." The device sends these requirements to the server, which uses a generative AI model to organize and clarify the requirements, and then sends the documented requirements back to the device.

[1232] Or, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate an answer to the question. This answer is returned to the device and displayed to the user.

[1233] Prompt Sentence Examples

[1234] "I want you to clarify the requirements for a customer management system."

[1235] "When are the new features released?"

[1236] "Tell me about EHR systems in the medical field."

[1237] This system configuration will streamline work during the requirements definition phase and contribute to the success of the project.

[1238] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1239] Processing Steps

[1240] The processing flow of the system program will be explained in the following steps.

[1241] Step 1:

[1242] User enters requirements

[1243] explanation

[1244] A user enters project requirements in natural language using the system's user interface (e.g., a web form or chat window).

[1245] Input and Output

[1246] Input: Requirements written in natural language (e.g., "Please organize the requirements for a customer management system.")

[1247] Output: Requirement data entered into the terminal

[1248] Specific actions

[1249] The user enters the requirements in the text box and presses the submit button.

[1250] Step 2:

[1251] The device sends the input requirements to the server

[1252] explanation

[1253] The terminal receives the requirements entered by the user, converts them into JSON format, and sends them to the server.

[1254] Input and Output

[1255] Input: Requirements data written in natural language

[1256] Output: Structured requirements data in JSON format (e.g., {"type": "requirement", "content": "Please organize the requirements for a customer management system"})

[1257] Specific actions

[1258] The terminal uses JavaScript code to convert the form contents into JSON format and then uses the Axios library to send an HTTP POST request to the server.

[1259] Step 3:

[1260] The server receives and analyzes the requirements

[1261] explanation

[1262] The server analyzes the JSON formatted requirements data received from the terminal and inputs it into the generative AI model (GPT-4).

[1263] Input and Output

[1264] Input: Structured requirements data in JSON format

[1265] Output: Requirements data in natural language format that is fed into a generative AI model

[1266] Specific actions

[1267] The server uses the Flask framework to receive HTTP requests, parses the JSON data using Python code, and then sends the requirements data to the generative AI model (GPT-4 API).

[1268] Step 4:

[1269] The server organizes and clarifies the requirements

[1270] explanation

[1271] The server uses generative AI models to organize and clarify requirements.

[1272] Input and Output

[1273] Input: Natural language requirements data sent to the GPT-4 API

[1274] Output: Organized and clarified requirements data (text format)

[1275] Specific actions

[1276] The results returned by the generative AI model are then used in Python code to further apply natural language processing to flesh out any ambiguities in the requirements.

[1277] Step 5:

[1278] Server documents requirements

[1279] explanation

[1280] The server converts the organized and clarified requirements into a consistent format (e.g., Markdown or PDF).

[1281] Input and Output

[1282] Input: Organized and clarified requirements data (text format)

[1283] Output: Documented requirements (e.g., Markdown or PDF)

[1284] Specific actions

[1285] The server uses libraries such as Pandoc and ReportLab to convert the generated text into Markdown or PDF format and save it as a document file.

[1286] Step 6:

[1287] The server sends the generated document back to the device

[1288] explanation

[1289] The server returns the generated document to the terminal as an HTTP response.

[1290] Input and Output

[1291] Input: Documented requirements (e.g., Markdown or PDF)

[1292] Output: JSON response containing the document URL (e.g., {"status": "success", "document_url": "https: / / example.com / documents / requirements_12345.pdf"})

[1293] Specific actions

[1294] The server generates a JSON response containing the document's URL and uses the Flask framework to send an HTTP response to the device.

[1295] Step 7:

[1296] The device displays the document to the user.

[1297] explanation

[1298] The terminal parses the received JSON response and displays the obtained document URL to the user.

[1299] Input and Output

[1300] Input: A JSON response containing the document URL

[1301] Output: The document that is displayed to the user (e.g., a PDF displayed in a web browser)

[1302] Specific actions

[1303] The device parses the JSON response and displays the obtained URL in an iframe tag or a new browser tab. For example, set the URL as the src attribute of the iframe tag as shown below.

[1304] html

[1305] <iframe src="https: / / example.com / documents / requirements_12345.pdf" width="100%" height="600px">< / iframe>

[1306] Through these steps, users will have clear and organized requirements, allowing the project to proceed efficiently.

[1307] (Application example 1)

[1308] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1309] Introducing or improving robots in factories requires the organization and clarification of a wide range of requirements. This process can be delayed due to a lack of communication between stakeholders or unclear requirements, which can have a negative impact on product quality and project progress. Furthermore, a lack of knowledge about a specific industrial domain makes it difficult to define optimal requirements. To solve these problems, a support system is needed that can streamline and clarify requirements definition, facilitate communication, and provide specialized knowledge.

[1310] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1311] In this invention, the server includes means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology, means for documenting the organized and clarified requirements in a consistent format, and means for providing an interface that promotes real-time communication between stakeholders. This allows users to analyze input requirements and document them in a unified format, and also provides industrial domain knowledge and task automation functions, thereby improving the progress speed and quality of projects.

[1312] "Requirements organization" is the process of clarifying the needs and specifications for a project or product and organizing them in a consistent format.

[1313] "Natural language processing technology" is a technology that enables computers to understand, analyze, and generate human language.

[1314] Documentation is the process of organizing information and data, converting it into a consistent format, and recording it as a document.

[1315] "Real-time communication" is a means of communication that allows stakeholders to exchange information without any time lag.

[1316] An "interface" is a means of providing a screen or method of operation for a user to interact with a system or application.

[1317] "Domain knowledge" is specialized knowledge about a particular industry or field.

[1318] "JSON format" is an abbreviation for JavaScript Object Notation, and is a lightweight format for structuring and representing data.

[1319] A "generative AI model" is a type of artificial intelligence, an advanced machine learning model for generating and editing text.

[1320] Documentation is the process of consistently recording information such as requirements, specifications, and project status.

[1321] "Task automation" is a system that automatically processes specified tasks without human intervention.

[1322] "Industrial domain knowledge" refers to specialized knowledge and know-how in the manufacturing and industrial fields.

[1323] To realize this invention, it is important to build a system that uses a generative AI model, natural language processing technology, and JSON format data transmission and analysis means. This system includes the following steps.

[1324] First, the user inputs requirements for introducing or improving a factory robot in natural language. The device used by the user (smartphone, tablet, computer, etc.) sends the input requirements to the server. At this time, the data is sent in JSON format.

[1325] The server then analyzes the received requirements using a generative AI model (e.g., the T5 model) to organize and clarify the requirements. The generative AI model is implemented using Hugging Face's transformers library. As a result of this analysis, the requirements are documented in a unified format. The documented requirements are then sent back from the server to the device and presented to the user.

[1326] Similarly, when a user inputs a question about a requirement, the device sends the question in JSON format to the server, which uses a generative AI model to generate an answer in real time, which is also displayed to the user on the device.

[1327] In addition, when a user inputs information about a specific industry or domain, the server uses a generative AI model to generate domain knowledge and provides it to the user. Also, when the user inputs the tasks they want to automate (organizing and classifying requirements, assessing importance, etc.), the server analyzes them and automates them.

[1328] The above process will streamline requirements definition and facilitate communication between stakeholders when introducing or improving factory robots. Furthermore, the provision of industrial domain knowledge and task automation functions are expected to improve the speed and quality of project progress.

[1329] As a concrete example, a project manager might input, "Please organize the requirements for a new assembly line for factory robots." That input is sent in JSON format to a server, which parses it using a generative AI model and documents the organized and clarified requirements in a unified format. The server then sends the document back to the terminal, which displays it to the user (project manager). Similarly, when a user asks, "When is the next product update?" the server uses the generative AI model to generate an answer and displays it to the user.

[1330] An example of a prompt is as follows:

[1331] "Organize the requirements for a new assembly line for factory robots."

[1332] "Automate the classification of quality control data."

[1333] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1334] Step 1:

[1335] The user inputs requirements for the introduction and improvement of factory robots in natural language using the device they use (smartphone, tablet, computer, etc.). The input requirements are converted into JSON format and sent to the server.

[1336] Step 2:

[1337] The device sends the user-entered requirements in JSON format to the server, which makes the data easier to parse.

[1338] Step 3:

[1339] The server analyzes the received requirements using a generative AI model (e.g., the T5 model) to organize and clarify the requirements. The generative AI model is implemented using Hugging Face's transformers library. As a result of this analysis, the requirements are organized in a consistent format.

[1340] Step 4:

[1341] The server documents the organized and clarified requirements and structures them in JSON format, which is then sent back to the device.

[1342] Step 5:

[1343] The terminal receives the documented requirements in JSON format returned from the server and displays them to the user, who can then review the organized requirements.

[1344] Step 6:

[1345] The user enters a question about the requirements in natural language, which is also converted to JSON format by the device and sent to the server.

[1346] Step 7:

[1347] The device receives questions from users and sends them in JSON format to the server, which analyzes the questions and generates answers in real time using a generative AI model.

[1348] Step 8:

[1349] The server uses a generative AI model to generate answers to questions, which are also written in natural language.

[1350] Step 9:

[1351] The server returns the generated answer to the terminal, which then displays the answer to the user, allowing the user to obtain the answer to their question.

[1352] Step 10:

[1353] When a user inputs information about a specific industry or domain, the device converts it into JSON format and sends it to the server, which uses generative AI models to generate domain knowledge and provide it to the user.

[1354] Step 11:

[1355] When a user wants to automate a task, they input the task in natural language and send it to the device. The device then sends the task in JSON format to the server, which then processes it for automation.

[1356] Step 12:

[1357] The server uses the generative AI model to automate the task and returns the results in JSON format to the device, which then displays the results to the user, allowing them to obtain the results of the automated task.

[1358] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1359] This invention relates to a requirements definition support tool that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This tool uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions. It also has an emotion engine that recognizes user emotions and adds a function to adjust the requirements definition process based on the recognized emotions.

[1360] Specific methods for carrying out the invention

[1361] Organizing and clarifying requirements

[1362] 1. User enters requirements

[1363] Users enter requirements in natural language through a user interface, which are concrete statements of needs and specifications for a project or product.

[1364] 2. The device sends the input to the server

[1365] The terminal converts the requirements entered by the user into JSON format and sends it to the server through an HTTP request, making it easier for the server to parse the requirements.

[1366] 3. The server organizes and clarifies the requirements

[1367] The server applies natural language processing techniques using generative AI models to the requirements received, organizes and clarifies the requirements, and documents the organized requirements in a consistent format.

[1368] Communication Support

[1369] 1. User enters a question

[1370] Users enter specific requirements or project-related questions in natural language to resolve information gaps or doubts about the project.

[1371] 2. The device sends the question to the server

[1372] The device receives a question from the user and sends it in JSON format to the server, which analyzes the question and begins processing it to generate an appropriate answer.

[1373] 3. The server answers the question

[1374] The server uses a generative AI model to generate answers to questions, which are written in natural language and in a user-friendly format.

[1375] Providing domain knowledge

[1376] 1. User enters specific domain information

[1377] Users input information about a specific industry or field in natural language, allowing them to access the domain knowledge they need during the requirements definition process.

[1378] 2. The device sends the domain information to the server

[1379] The device sends the domain information received from the user in JSON format to the server, which receives this information and begins processing it to provide knowledge about the domain.

[1380] 3. The server provides domain knowledge

[1381] The server uses generative AI models to generate knowledge about a specific domain and provides it to the user.

[1382] Automation and efficiency

[1383] 1. The user enters the task they want to automate

[1384] Users input tasks they want to automate, such as organizing and categorizing requirements and evaluating their importance, in natural language, thereby improving work efficiency.

[1385] 2. The device sends the task to the server

[1386] The device converts the task received from the user into JSON format and sends it to the server via an HTTP request. The server analyzes the task and starts the process for automation.

[1387] 3. Server automates tasks

[1388] The server uses the generative AI model to automate the task, which is then automatically processed and the results are provided to the user.

[1389] Emotion engine integration

[1390] 1. Recognize user emotions

[1391] The emotion engine analyzes user input and user interface behavior to recognize user emotions, for example, by inferring emotions based on input text and click frequency.

[1392] 2. The device sends emotional information to the server

[1393] The device sends the recognized user emotion information to the server in JSON format, allowing the server to adjust subsequent processes based on the emotion.

[1394] 3. The server adjusts the process based on emotions

[1395] The server then adjusts the requirements definition and communication support processes based on the received emotional information. For example, if the user is feeling stressed, it will provide more detailed guidance.

[1396] Specific examples

[1397] For example, if a user types "I want you to organize the requirements for a customer management system," the terminal sends this to the server, which then analyzes, organizes, and documents the requirements in a consistent format. At the same time, the system recognizes the user's emotions based on the user's typing speed and context, and displays additional help messages if the user is feeling stressed.

[1398] Furthermore, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate an answer. At the same time, it monitors the user's emotions and responds quickly if the user is in a hurry.

[1399] Through these processes, the present invention contributes to the success of projects by significantly streamlining the requirements definition process and enabling flexible responses to user emotions.

[1400] The processing flow will be explained below.

[1401] Step 1:

[1402] User inputs requirements. Through a user interface, the user inputs project or product requirements in natural language. For example, "The customer management system needs the ability to add, edit, and delete customer information."

[1403] Step 2:

[1404] The terminal sends input to the server. The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[1405] Step 3:

[1406] The server receives the requirements. The server parses the received HTTP request and extracts the requirements information in JSON format.

[1407] Step 4:

[1408] The server analyzes the requirements using natural language processing technology. It then uses a generative AI model to understand the context of the requirements and organize and clarify them. For example, it clarifies the requirement as "Provide the ability to add, edit, and delete customer information."

[1409] Step 5:

[1410] The server documents the organized requirements. The server documents the organized and clarified requirements in a consistent format.

[1411] Step 6:

[1412] The server returns the documented requirements to the device. The server generates a JSON response containing the documented requirements and returns it to the device as an HTTP response.

[1413] Step 7:

[1414] The terminal displays the results to the user. The terminal parses the JSON response received from the server and displays the organized requirements in the user interface, allowing the user to see clear and organized requirements.

[1415] Step 8:

[1416] User enters a question: A user enters a question in natural language about a specific requirement or project, such as "What is the release date for the new feature?"

[1417] Step 9:

[1418] The device sends the question to the server. The device converts the entered question into JSON format and sends it to the server via an HTTP request.

[1419] Step 10:

[1420] The server receives the question, parses the HTTP request, and extracts the question information in JSON format.

[1421] Step 11:

[1422] The server generates an answer to the question. The server uses a generative AI model to generate an appropriate answer to the question. For example, it generates an answer such as "The release date for the new feature is the 1st of next month."

[1423] Step 12:

[1424] The server returns the answer to the device. The server creates a JSON response containing the answer and returns it to the device as an HTTP response.

[1425] Step 13:

[1426] The terminal displays the answer to the user. The terminal parses the JSON response received from the server and displays the generated answer in the user interface, allowing the user to check the answer to the question.

[1427] Step 14:

[1428] User enters specific domain information. The user enters information about a specific industry or domain in natural language. For example, "What are the key requirements in the financial industry?"

[1429] Step 15:

[1430] The device sends the domain information to the server. The device converts the domain information received from the user into JSON format and sends it to the server via an HTTP request.

[1431] Step 16:

[1432] The server receives the domain information. The server parses the received HTTP request and extracts the domain information in JSON format.

[1433] Step 17:

[1434] The server provides domain knowledge: Using generative AI models, the server generates knowledge about a specific domain and provides it to the user, for example explaining the importance of security and data protection in the financial industry.

[1435] Step 18:

[1436] The server returns the generated domain knowledge to the terminal. The server generates a JSON response including the generated domain knowledge and returns it to the terminal as an HTTP response.

[1437] Step 19:

[1438] The terminal displays the domain knowledge to the user. The terminal parses the JSON response received from the server and displays the generated domain knowledge in the user interface, allowing the user to check important information about a specific domain.

[1439] Step 20:

[1440] The user inputs the task they want to automate. The user inputs the task they want to automate, such as organizing, categorizing, and evaluating the importance of requirements, in natural language. For example, they might input "List new requirements and categorize them."

[1441] Step 21:

[1442] The device sends the task to the server. The device converts the task received from the user into JSON format and sends it to the server via an HTTP request.

[1443] Step 22:

[1444] The server receives the task. The server parses the received HTTP request and extracts the task information in JSON format.

[1445] Step 23:

[1446] The server automates the task: Using generative AI models, the server automates the incoming task and takes appropriate action, such as listing new requirements and classifying each requirement into the appropriate category.

[1447] Step 24:

[1448] The server returns the results of the automated task to the device. The server generates a JSON response containing the results of the automated task and returns it to the device as an HTTP response.

[1449] Step 25:

[1450] The terminal displays the automation results to the user. The terminal parses the JSON response received from the server and displays the results of the automated task in the user interface, allowing the user to check the results of the automated task and take any necessary actions.

[1451] Emotion engine integration

[1452] Step 26:

[1453] The emotion engine recognizes the user's emotions. The emotion engine analyzes the user's input and behavior on the user interface to recognize the user's emotions. For example, it infers the user's emotions based on the entered text, typing speed, click frequency, etc.

[1454] Step 27:

[1455] The device sends the emotion information to the server. The device sends the recognized emotion information of the user to the server in JSON format, which allows the server to adjust subsequent processes based on the emotion.

[1456] Step 28:

[1457] The server adjusts the process based on the emotion. The server adjusts the requirements definition and communication support processes based on the emotion information it receives. For example, if the user is feeling stressed, it will respond by providing more detailed guidance.

[1458] Through the above steps, the present invention significantly streamlines the requirements definition process and enables flexible responses to user emotions, thereby contributing to the success of the project.

[1459] Example 2

[1460] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1461] Traditional requirements definition processes are often manual and require a great deal of time and effort. Real-time communication between stakeholders is difficult, which can delay information sharing and decision-making. Furthermore, the process is often carried out without consideration of user feelings, which can result in an unsatisfactory user experience. It is necessary to resolve these issues, streamline the requirements definition process, and improve project progress speed, product quality, and customer satisfaction.

[1462] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[1463] In this invention, the server includes: [means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;] [means for documenting the organized and clarified requirements in a consistent format; and] [means for recognizing the user's emotions using an emotion engine and adjusting the requirements definition process based on the recognized emotions.] This makes it possible to improve the efficiency of the requirements definition process, realize smooth communication between stakeholders, and realize responses that correspond to the user's emotions.

[1464] "Means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology" refers to a function for receiving requirements that a user inputs to the system in natural language, systematically organizing them using natural language processing technology, and clarifying the content.

[1465] "Means for documenting organized and clarified requirements in a consistent format" refers to a function for documenting organized and clarified requirements using natural language processing technology in accordance with certain rules and formats, and for saving and displaying them in a consistent format.

[1466] "Means for providing an interface that promotes real-time communication among stakeholders" is a function that provides a user interface that helps real-time information sharing and communication among those involved in the project.

[1467] "A means of integrating knowledge bases related to specific industries or fields and enabling access to information needed during the requirements definition process" is a function that integrates a database that aggregates knowledge related to specific industries or fields, making it easy to access information needed during the requirements definition process.

[1468] "Means for recognizing user emotions using an emotion engine and adjusting the requirements definition process based on the recognized emotions" refers to a function that uses an emotion engine that analyzes emotions from user input and behavior to recognize the user's current emotional state and adjusts the requirements definition procedure and interactions according to those emotions.

[1469] "A means of learning from past projects and best practices to help improve the requirements definition process" is a function that learns from past project data and industry best practices, and uses that knowledge to help streamline and improve the requirements definition process.

[1470] "Means for automating the organization, classification, and importance evaluation of requirements" refers to a function that automates the process of properly organizing and classifying requirements and evaluating their importance. This reduces the manual workload and enables faster and more accurate requirements management.

[1471] This invention is a requirements definition support system that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This system uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions. It also features an emotion engine that recognizes user emotions. Furthermore, the requirements definition process can be dynamically adjusted based on the emotions recognized by this emotion engine.

[1472] Specifically, users input project or product requirements in natural language through a user interface. This input is converted to JSON format by the terminal and sent to the server via an HTTP request. The server then applies natural language processing techniques using generative AI models to the received requirements to organize and clarify them. The organized requirements are then documented in a consistent format.

[1473] To support real-time communication, users input questions about specific requirements or projects. The device converts the input into JSON format and sends it to the server via an HTTP request. The server then uses a generative AI model to generate answers to the questions and provides them to the user. Additionally, when users input information about a specific industry or field, the device sends it to the server, which then generates domain knowledge and provides it to the user.

[1474] With the automation and efficiency feature, when a user inputs automation tasks such as organizing and categorizing requirements and assessing their importance, the device converts the input into JSON format and sends it to the server via an HTTP request. The server then uses a generative AI model to automate the task and provides the results to the user.

[1475] The integration of an emotion engine allows the system to recognize emotions from user input and behavior and adjust subsequent processes based on those emotions. For example, if the user is feeling stressed, the system will provide detailed guidance and improve the user experience.

[1476] For example, if a user types "I want you to organize the requirements for a customer management system," the terminal sends this to the server, which then analyzes, organizes, and documents the requirements in a consistent format. It can also recognize emotions from the user's typing speed and context, and display additional help messages if the user is feeling stressed.

[1477] Furthermore, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate a quick answer, while simultaneously monitoring the user's emotions and responding even faster if they are in a hurry.

[1478] Through these processes, the present invention significantly improves the efficiency of the requirements definition process and makes it possible to respond to user emotions, thereby greatly contributing to the success of the project.

[1479] Examples of prompts include:

[1480] "I want you to clarify the requirements for a customer management system."

[1481] "When are the new features released?"

[1482] Please provide the latest domain information.

[1483] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1484] Organizing and clarifying requirements

[1485] Step 1:

[1486] User enters requirements

[1487] The user inputs specific requirements for a project or product in natural language. For example, they input specific content such as "database requirements for a new customer management system." The input data is requirement information in text format.

[1488] Step 2:

[1489] The device sends the input requirements to the server

[1490] The terminal acquires the requirements entered by the user and converts them into JSON format. For example, if the entered requirements are "Database requirements for a new customer management system," they are converted into the following JSON data:

[1491] json

[1492] {

[1493] "requirement": "Database requirements for the new customer management system"

[1494] }

[1495] This is sent to the server as an HTTP POST request.

[1496] Step 3:

[1497] The server organizes and clarifies the requirements

[1498] The server analyzes the received requirements data and applies natural language processing techniques using a generative AI model to organize and clarify the requirements. For example, if the requirement is "The database should have high availability and scalability," the server extracts keywords such as "availability" and "scalability" and generates an organized document. The results are output in document format.

[1499] Communication Support

[1500] Step 1:

[1501] The user enters a question

[1502] A user types in natural language a question about a specific requirement or project, for example, "What is the release date for the new feature?" The input data is a textual question.

[1503] Step 2:

[1504] The device sends a question to the server

[1505] The device converts the question received from the user into JSON format and sends it to the server via an HTTP request, for example:

[1506] json

[1507] {

[1508] "question": "When is the new feature release date?"

[1509] }

[1510] Step 3:

[1511] The server answers the question

[1512] The server uses a generative AI model to analyze the question and generate an appropriate answer, such as "The new feature will be released on December 15, 2023," in natural language format.

[1513] Providing domain knowledge

[1514] Step 1:

[1515] User enters specific domain information

[1516] A user inputs information about a specific industry or field in natural language. For example, "What are the latest trends in the fintech industry?" The input data is domain information in text format.

[1517] Step 2:

[1518] The device sends the domain information to the server.

[1519] The terminal converts the domain information received from the user into JSON format and sends it to the server via an HTTP request. For example, convert it as follows:

[1520] json

[1521] {

[1522] "domain_info": "What are the latest trends in the fintech industry?"

[1523] }

[1524] Step 3:

[1525] The server provides domain knowledge

[1526] The server uses the generative AI model to generate domain-specific knowledge, such as "Digital banking and smart contracts are hot topics in the latest FinTech industry" in natural language.

[1527] Automation and efficiency

[1528] Step 1:

[1529] The user enters the task they want to automate.

[1530] The user inputs the task to be automated, such as organizing and categorizing requirements, evaluating their importance, etc. in natural language. For example, the user might input "Automatically organize the list of requirements according to priority." The input data is the automation task in text format.

[1531] Step 2:

[1532] The device sends the task to the server

[1533] The device converts the task received from the user into JSON format and sends it to the server via an HTTP request, for example:

[1534] json

[1535] {

[1536] "task": "Automatically organize the requirements list by priority"

[1537] }

[1538] Step 3:

[1539] Server automates tasks

[1540] The server uses the generative AI model to automate tasks, specifically by analyzing the incoming requirements, assessing the importance of each requirement, and organizing them according to priority. The results are output as an organized list of requirements.

[1541] Emotion engine integration

[1542] Step 1:

[1543] Emotion engine recognizes user emotions

[1544] The emotion engine analyzes user input and behavior to recognize emotions. For example, it infers emotions such as "irritated" from input text, click frequency, and usage time. Input data is user behavior logs and text data.

[1545] Step 2:

[1546] The device sends emotional information to the server.

[1547] The device sends the user's recognized emotion information to the server in JSON format. For example, it can be converted as follows:

[1548] json

[1549] {

[1550] "emotion": "frustrated"

[1551] }

[1552] Step 3:

[1553] Server adjusts process based on emotion

[1554] The server adjusts the requirements definition and communication process based on the emotional information received, for example, if the user is feeling stressed, it displays additional guidance or support messages.

[1555] (Application example 2)

[1556] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1557] The requirements definition phase of a project is often complex and time-consuming, and poor communication between stakeholders and a lack of domain knowledge can affect quality and progress speed. Furthermore, in projects requiring advanced technology such as autonomous vehicles, it is particularly important to organize and clarify requirements, provide domain knowledge, support real-time communication, and adjust the process while taking user emotions into consideration. Therefore, solutions are needed to efficiently and effectively execute such a complex requirements definition phase.

[1558] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[1559] In this invention, the server includes: [means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;] [means for documenting the organized and clarified requirements in a consistent format;] [means for providing an interface that promotes real-time communication between stakeholders;] [means for integrating a knowledge base related to a specific industry or domain and making necessary information accessible during the requirements definition process;] [means for learning from past projects and best practices and supporting improvement of the requirements definition process;] [means for automating the organization, classification, and importance assessment of requirements;] [means for integrating an emotion engine, analyzing user emotions, and adjusting the process; and] [means for analyzing requirements related to autonomous vehicles and providing information on necessary sensors and machine learning models.] This enables the requirements definition phase of a project to be carried out efficiently and effectively, improving progress speed with high quality, and enabling the provision of domain knowledge and real-time communication support, especially in projects that require advanced technology such as autonomous vehicles.

[1560] Organizing and clarifying requirements using natural language processing techniques is the process of modularizing project or product needs and specifications into a consistent and easy-to-understand format.

[1561] "Documenting in a consistent format" means recording the organized and clarified requirements in a document in a standardized format so that they can be easily used in subsequent processes.

[1562] An "interface that promotes real-time communication between stakeholders" is a user interface that enables those involved in a project to share information in real time and communicate smoothly.

[1563] "Integrating a knowledge base for a specific industry or domain" means using a database that systematically compiles specialized knowledge in a specific industry or technical field, enabling quick and accurate access to the information needed when defining requirements.

[1564] "Learning from past projects and best practices" refers to techniques and methodologies for analyzing the results and success stories of previous projects and applying that knowledge to the next project.

[1565] "Automating the organization, classification, and importance evaluation of requirements" means that the machine automatically analyzes the input requirements, classifies them by item, and evaluates their importance.

[1566] "Integrating an emotion engine, analyzing user emotions, and adjusting the process" means incorporating an engine into the system that analyzes the user's emotions and stress level, and then appropriately adjusting the way the project is progressing based on the results.

[1567] "Analyzing requirements related to autonomous vehicles and providing information on necessary sensors and machine learning models" means specifically defining the functions and performance required for autonomous vehicles and providing information on the hardware and software components required for them.

[1568] This invention provides a system that integrates multiple technologies to streamline the requirements definition phase of a project and obtain high-quality results. Specifically, this system includes the following components:

[1569] First, a user inputs project or product requirements in natural language. These requirements are entered into a terminal through a designated user interface. The terminal converts the input requirements into JSON format and sends it to the server via an HTTP request. The server then applies natural language processing techniques using generative AI models to organize and clarify the requirements and document the results in a consistent format.

[1570] Next, an interface is provided to facilitate real-time communication between stakeholders. The device receives users' questions and opinions and sends them to the server, which then uses a generative AI model to generate appropriate answers. As a result, project participants can smoothly share information and make quick decisions.

[1571] Furthermore, it integrates knowledge bases related to specific industries and domains, making necessary information accessible during the requirements definition process. When a user inputs specific domain information, the device transmits the information to the server, which then uses generative AI models to provide relevant knowledge.

[1572] It also includes a means to learn from past projects and best practices to help improve the requirements definition process. The server analyzes data using machine learning models to analyze past deliverables and success stories and apply the knowledge to the next project.

[1573] Furthermore, it provides a means to automate the organization, classification, and importance evaluation of requirements. When a user inputs a task they want to automate in natural language, the device sends the task to the server, which then uses a generative AI model to automatically process the task.

[1574] It also includes a means for integrating an emotion engine, analyzing the user's emotions, and adjusting the process. The emotion engine analyzes the user's input and behavior, recognizes the user's emotions, and then the server adjusts the process based on that information. For example, if the user is feeling stressed, it provides more detailed guidance.

[1575] Finally, it includes a means for analyzing requirements related to autonomous vehicles and providing information on the necessary sensors and machine learning models. When a user inputs the requirements for an autonomous vehicle, the device sends them to the server, which then provides information on the necessary hardware and software.

[1576] For example, if a user asks, "What kind of sensors do autonomous vehicles need?", the device sends the question to the server, which uses a generative AI model to generate an answer. The answer is returned in the form of, "An autonomous vehicle needs LiDAR, RADAR, cameras, ultrasonic sensors, etc." At this time, the user's emotions are also analyzed, and if the user is in a hurry, a quick response is made.

[1577] Through the above means, the system of the present invention can streamline the requirements definition phase of a project and obtain high-quality results.

[1578] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1579] Step 1:

[1580] Users enter project or product requirements in natural language.

[1581] Input: Project or product requirements (natural language text)

[1582] Specific operation: The user inputs requirements through a device such as a smartphone, smart glasses, or head-mounted display.

[1583] Step 2:

[1584] The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[1585] Input: User-entered requirements (natural language text)

[1586] Data processing: converting natural language text into JSON format

[1587] Output: HTTP request (JSON format data)

[1588] Specific operation: The application on the device parses the text, encodes it into JSON format, and sends a POST request to the server.

[1589] Step 3:

[1590] The server applies natural language processing technology using a generative AI model to the requirements received, organizing and clarifying the requirements.

[1591] Input: HTTP request (JSON format data)

[1592] Data Computing: Analyzing natural language text using generative AI models to organize and clarify requirements

[1593] Output: Organized and clarified requirements (structured data)

[1594] What it does: A natural language processing engine running on the server parses the requirements text, categorizes and prioritizes them, and generates structured data.

[1595] Step 4:

[1596] The server documents the organized and clarified requirements in a consistent format.

[1597] Input: Organized and clarified requirements (structured data)

[1598] Data transformation: converting structured data into a consistent document format

[1599] Output: Document file (e.g. PDF or Word)

[1600] Specific operation: The server's document generation engine converts the structured data into a document format based on a template and saves or transmits it.

[1601] Step 5:

[1602] The server provides an interface that facilitates real-time communication between stakeholders.

[1603] Input: Questions and opinions from stakeholders (natural language text)

[1604] Data Computing: Parsing Questions and Generating Answers with Generative AI Models

[1605] Output: Answer text (natural language text)

[1606] Specific operation: The server provides a real-time chat function, receives inquiries from stakeholders, and generates answers using a generative AI model.

[1607] Step 6:

[1608] The user enters information about a specific industry or domain, and the device sends the information to a server.

[1609] Input: Information about a specific industry or domain (natural language text)

[1610] Data processing: converting natural language text into JSON format

[1611] Output: HTTP request (JSON format data)

[1612] Specific operation: The device converts the text into JSON format and sends it to the server.

[1613] Step 7:

[1614] The server provides knowledge about a specific industry or domain.

[1615] Input: HTTP request (JSON format data)

[1616] Data Computing: Using generative AI models to analyze relevant knowledge and generate information

[1617] Output: Domain knowledge text (natural language text)

[1618] Specific operation: The server extracts relevant information from the knowledge base, analyzes it using a generative AI model, and provides it in text format.

[1619] Step 8:

[1620] The server analyzes the user's emotions and adjusts the subsequent process.

[1621] Input: Emotional information (user behavior and input text)

[1622] Data calculation: Emotion analysis with emotion engine

[1623] Output: The adjusted process (e.g., guidance message)

[1624] Specific operation: The server's emotion engine analyzes the emotion information and adjusts the way the project proceeds as needed.

[1625] Step 9:

[1626] The user inputs the requirements for the autonomous vehicle, and the terminal sends the requirements to the server.

[1627] Input: Requirements related to autonomous vehicles (natural language text)

[1628] Data processing: converting natural language text into JSON format

[1629] Output: HTTP request (JSON format data)

[1630] Specific operation: The terminal converts the requirement text into JSON format and sends it to the server.

[1631] Step 10:

[1632] The server provides information on sensors and machine learning models required for autonomous vehicles.

[1633] Input: HTTP request (JSON format data)

[1634] Data Computing: Using generative AI models to analyze and provide relevant information

[1635] Output: Information about sensors and machine learning models (natural language text)

[1636] Specific operation: The server generates relevant technical information and provides it to the user.

[1637] Through these steps, the requirements definition phase of the project will be streamlined and produce high-quality results.

[1638] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[1639] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1640] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[1641] [Fourth embodiment]

[1642] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[1643] 7, a data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

[1644] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1645] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[1646] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[1647] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[1648] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1649] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1650] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1651] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[1652] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[1653] In the robot 414, the processor 46 performs the reception output process. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[1654] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1655] This invention relates to a requirements definition support tool that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This tool uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions.

[1656] Specific methods for carrying out the invention

[1657] Organizing and clarifying requirements

[1658] 1. User enters requirements

[1659] Users enter requirements in natural language through a user interface, which are concrete statements of needs and specifications for a project or product.

[1660] 2. The device sends the input to the server

[1661] The device receives the requirements entered by the user and sends them to the server in JSON format, which makes it easier for the server to parse the requirements.

[1662] 3. The server organizes and clarifies the requirements

[1663] The server applies natural language processing techniques using generative AI models to the requirements received, organizes and clarifies the requirements, and documents the organized requirements in a consistent format.

[1664] Communication Support

[1665] 1. User enters a question

[1666] Users enter specific requirements or project-related questions in natural language to resolve information gaps or doubts about the project.

[1667] 2. The device sends the question to the server

[1668] The device receives a question from the user and sends it in JSON format to the server, which analyzes the question and begins processing it to generate an appropriate answer.

[1669] 3. The server answers the question

[1670] The server uses a generative AI model to generate answers to questions, which are written in natural language and in a user-friendly format.

[1671] Providing domain knowledge

[1672] 1. User enters specific domain information

[1673] Users input information about a specific industry or field in natural language, allowing them to access the domain knowledge they need during the requirements definition process.

[1674] 2. The device sends the domain information to the server

[1675] The device sends the domain information received from the user in JSON format to the server, which receives this information and begins processing it to provide knowledge about the domain.

[1676] 3. The server provides domain knowledge

[1677] The server uses generative AI models to generate knowledge about a specific domain and provides it to the user.

[1678] Automation and efficiency

[1679] 1. The user enters the task they want to automate

[1680] Users input tasks they want to automate, such as organizing and categorizing requirements and evaluating their importance, in natural language, thereby improving work efficiency.

[1681] 2. The device sends the task to the server

[1682] The device receives a task from the user and sends it in JSON format to the server, which analyzes the task and starts the process for automation.

[1683] 3. Server automates tasks

[1684] The server uses the generative AI model to automate the task, which is then automatically processed and the results are provided to the user.

[1685] Specific examples

[1686] For example, if a user inputs "I want the requirements for a customer management system organized," the following steps are executed: The terminal sends the requirements to the server, which analyzes, organizes, and documents them in a consistent format. The server returns the generated document to the terminal, which displays it to the user, providing the user with clear and organized requirements.

[1687] Also, if a user asks, "When is the new feature released?", the device sends this question to the server, which uses the generative AI model to generate an answer, which is then returned to the device, which displays it to the user, allowing them to know the release date.

[1688] Through these processes, the present invention improves the efficiency and quality of the requirements definition phase, contributing to the success of the project.

[1689] The processing flow will be explained below.

[1690] Step 1:

[1691] User inputs requirements. Through a user interface, the user inputs project or product requirements in natural language. For example, "The customer management system needs the ability to add, edit, and delete customer information."

[1692] Step 2:

[1693] The terminal sends input to the server. The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[1694] Step 3:

[1695] The server receives the requirements. The server parses the received HTTP request and extracts the requirements information in JSON format.

[1696] Step 4:

[1697] The server analyzes the requirements using natural language processing technology. It then uses a generative AI model to understand the context of the requirements and organize and clarify them. For example, it clarifies the requirement as "Provide the ability to add, edit, and delete customer information."

[1698] Step 5:

[1699] The server documents the analysis results in a consistent format. The server reconstructs the organized and clarified requirements into an appropriate format and documents them in a consistent format.

[1700] Step 6:

[1701] The server sends the documented requirements back to the device, which then generates a JSON response containing the requirements organized in a consistent format and sends it back to the device as an HTTP response.

[1702] Step 7:

[1703] The terminal displays the results to the user. The terminal parses the JSON response received from the server and displays the organized requirements in the user interface, allowing the user to see clear and organized requirements.

[1704] Step 8:

[1705] The user types in a question: The user types in natural language a follow-up question about the requirement, for example, "What is the release date for the new feature?"

[1706] Step 9:

[1707] The device sends the question to the server. The device converts the user's question into JSON format and sends it to the server via an HTTP request.

[1708] Step 10:

[1709] The server receives the question, parses the HTTP request, and extracts the question information in JSON format.

[1710] Step 11:

[1711] The server generates an answer to the question. The server uses a generative AI model to generate an appropriate answer to the question it receives. For example, it generates an answer such as, "The release date for the new feature is the 1st of next month."

[1712] Step 12:

[1713] The server returns the generated answer to the device. The server creates a JSON response containing the generated answer and returns it to the device as an HTTP response.

[1714] Step 13:

[1715] The terminal displays the answer to the user. The terminal parses the JSON response received from the server and displays the generated answer in the user interface, allowing the user to check the answer to the question.

[1716] Step 14:

[1717] User enters specific domain information. The user enters information about a specific industry or domain in natural language. For example, "What are the key requirements in the financial industry?"

[1718] Step 15:

[1719] The device sends the domain information to the server. The device converts the domain information received from the user into JSON format and sends it to the server via an HTTP request.

[1720] Step 16:

[1721] The server receives the domain information. The server parses the received HTTP request and extracts the domain information in JSON format.

[1722] Step 17:

[1723] The server provides domain knowledge, which it then uses a generative AI model to generate domain-specific knowledge and translate it into a form that can be presented to the user, for example explaining the importance of security and data protection in the financial industry.

[1724] Step 18:

[1725] The server returns the generated domain knowledge to the terminal. The server generates a JSON response including the generated domain knowledge and returns it to the terminal as an HTTP response.

[1726] Step 19:

[1727] The terminal displays the domain knowledge to the user. The terminal parses the JSON response received from the server and displays the generated domain knowledge in the user interface, allowing the user to check important information about a specific domain.

[1728] Step 20:

[1729] The user inputs the task they want to automate. The user inputs the task they want to automate, such as organizing, categorizing, and evaluating the importance of requirements, in natural language. For example, they can input "List new requirements and categorize them."

[1730] Step 21:

[1731] The device sends the task to the server. The device converts the task received from the user into JSON format and sends it to the server via an HTTP request.

[1732] Step 22:

[1733] The server receives the task. The server parses the received HTTP request and extracts the task information in JSON format.

[1734] Step 23:

[1735] The server automates the task: Using a generative AI model, the server automates the incoming task and takes appropriate action, such as listing new requirements and classifying each requirement into the appropriate category.

[1736] Step 24:

[1737] The server returns the results of the automated task to the device. The server generates a JSON response containing the results of the automated task and returns it to the device as an HTTP response.

[1738] Step 25:

[1739] The terminal displays the automation results to the user. The terminal parses the JSON response received from the server and displays the results of the automated task in the user interface, allowing the user to check the results of the automated task and take any necessary actions.

[1740] Through the above steps, the present invention can significantly streamline the requirements definition process, improving the speed at which projects progress and the quality of products.

[1741] Example 1

[1742] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1743] Traditional requirements definition processes rely on manual work to organize and clarify requirements, which is inefficient and prone to errors. In addition, insufficient communication between stakeholders can delay overall project progress. Furthermore, difficulty in accessing specific domain knowledge makes it difficult to define high-quality requirements. These issues inevitably lead to a decline in project speed, product quality, and customer satisfaction.

[1744] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1745] In this invention, the server

[1746] [Means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;

[1747] [Means of using generative AI models to clarify and clarify requirements and flesh out ambiguities;

[1748] [A means of converting documents into a consistent format and presenting them to users; and

[1749] This automates the organization and clarification of requirements, improving efficiency and reducing errors. Providing consistent documentation also promotes real-time communication between stakeholders, improving project progress. Furthermore, access to specific domain knowledge leads to higher-quality requirements definition, which is expected to improve project quality and customer satisfaction.

[1750] The "means for receiving input requirements" refers to a function for transmitting requirements input by a user in natural language to a server via a terminal, and for the server to receive the requirements.

[1751] "Natural language processing technology" refers to technology that enables computers to understand, analyze, and process human language. This technology can be used to organize and clarify input requirements.

[1752] A "generative AI model" is a type of artificial intelligence technology, specifically a model trained for natural language generation and understanding. In this invention, it is used to organize and clarify requirements.

[1753] "Means for documenting in a consistent format" refers to a function that allows organized and clarified requirements to be documented in a consistent format (e.g., Markdown or PDF) to make them easier for users to understand.

[1754] "Means for converting documents" refers to the ability to take requirements generated by a generative AI model and convert them into a specific format (e.g., Markdown or PDF).

[1755] "Interfaces that promote real-time communication" refers to user interfaces that facilitate instant communication between stakeholders, allowing them to share and discuss questions and opinions about requirements in real time.

[1756] A "knowledge base for a specific industry or domain" refers to a database that stores specialized knowledge about a specific industry or field. It is possible to access the information needed during the requirements definition process.

[1757] "Means of learning from past projects and best practices" refers to the ability to learn from data and success stories of past projects and use these insights to help improve the requirements definition process.

[1758] "Means to automate the organization, classification, and importance evaluation of requirements" refers to the function that automatically organizes, classifies, and evaluates the importance of requirements based on the requirements entered by the user, thereby improving work efficiency.

[1759] This invention relates to a requirements definition support system for streamlining the requirements definition phase of a project. This system uses generative AI models and natural language processing technology to support the organization, clarification, and documentation of requirements, thereby improving project progress speed, product quality, and customer satisfaction.

[1760] The main components of the system include a terminal for users to input requirements, a server for processing the input requirements, a generative AI model (e.g., GPT-4), and natural language processing technology.

[1761] Hardware and Software

[1762] Device: A PC or mobile device that provides a user interface (such as a web form or chat window).

[1763] Server: A backend server that receives and processes requests. The server uses the Flask framework and Python.

[1764] Generative AI models: Includes generative AI techniques such as GPT-4.

[1765] Libraries: Document generation libraries such as Pandoc or ReportLab.

[1766] Program processing

[1767] The user inputs requirements in natural language and sends them to the server via the device. The device converts the input requirements into JSON format and sends it as an HTTP POST request to the server. The server receives the request and uses a generative AI model (GPT-4) to organize and clarify the requirements. The generated content is then converted into a structured document using natural language processing techniques to clarify any ambiguities.

[1768] The generated document is converted into a consistent format (such as Markdown or PDF) and sent back from the server to the device. The device receives the document and displays it to the user. This allows the user to obtain organized and clarified requirements, enabling the project to proceed efficiently.

[1769] Specific examples

[1770] A user types, "I want you to organize the requirements for my customer management system." The device sends these requirements to the server, which uses a generative AI model to organize and clarify the requirements, and then sends the documented requirements back to the device.

[1771] Or, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate an answer to the question. This answer is returned to the device and displayed to the user.

[1772] Prompt Sentence Examples

[1773] "I want you to clarify the requirements for a customer management system."

[1774] "When are the new features released?"

[1775] "Tell me about EHR systems in the medical field."

[1776] This system configuration will streamline work during the requirements definition phase and contribute to the success of the project.

[1777] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1778] Processing Steps

[1779] The processing flow of the system program will be explained in the following steps.

[1780] Step 1:

[1781] User enters requirements

[1782] explanation

[1783] A user enters project requirements in natural language using the system's user interface (e.g., a web form or chat window).

[1784] Input and Output

[1785] Input: Requirements written in natural language (e.g., "Please organize the requirements for a customer management system.")

[1786] Output: Requirement data entered into the terminal

[1787] Specific actions

[1788] The user enters the requirements in the text box and presses the submit button.

[1789] Step 2:

[1790] The device sends the input requirements to the server

[1791] explanation

[1792] The terminal receives the requirements entered by the user, converts them into JSON format, and sends them to the server.

[1793] Input and Output

[1794] Input: Requirements data written in natural language

[1795] Output: Structured requirements data in JSON format (e.g., {"type": "requirement", "content": "Please organize the requirements for a customer management system"})

[1796] Specific actions

[1797] The terminal uses JavaScript code to convert the form contents into JSON format and then uses the Axios library to send an HTTP POST request to the server.

[1798] Step 3:

[1799] The server receives and analyzes the requirements

[1800] explanation

[1801] The server analyzes the JSON formatted requirements data received from the terminal and inputs it into the generative AI model (GPT-4).

[1802] Input and Output

[1803] Input: Structured requirements data in JSON format

[1804] Output: Requirements data in natural language format that is fed into a generative AI model

[1805] Specific actions

[1806] The server uses the Flask framework to receive HTTP requests, parses the JSON data using Python code, and then sends the requirements data to the generative AI model (GPT-4 API).

[1807] Step 4:

[1808] The server organizes and clarifies the requirements

[1809] explanation

[1810] The server uses generative AI models to organize and clarify requirements.

[1811] Input and Output

[1812] Input: Natural language requirements data sent to the GPT-4 API

[1813] Output: Organized and clarified requirements data (text format)

[1814] Specific actions

[1815] The results returned by the generative AI model are then used in Python code to further apply natural language processing to flesh out any ambiguities in the requirements.

[1816] Step 5:

[1817] Server documents requirements

[1818] explanation

[1819] The server converts the organized and clarified requirements into a consistent format (e.g., Markdown or PDF).

[1820] Input and Output

[1821] Input: Organized and clarified requirements data (text format)

[1822] Output: Documented requirements (e.g., Markdown or PDF)

[1823] Specific actions

[1824] The server uses libraries such as Pandoc and ReportLab to convert the generated text into Markdown or PDF format and save it as a document file.

[1825] Step 6:

[1826] The server sends the generated document back to the device

[1827] explanation

[1828] The server returns the generated document to the terminal as an HTTP response.

[1829] Input and Output

[1830] Input: Documented requirements (e.g., Markdown or PDF)

[1831] Output: JSON response containing the document URL (e.g., {"status": "success", "document_url": "https: / / example.com / documents / requirements_12345.pdf"})

[1832] Specific actions

[1833] The server generates a JSON response containing the document's URL and uses the Flask framework to send an HTTP response to the device.

[1834] Step 7:

[1835] The device displays the document to the user.

[1836] explanation

[1837] The terminal parses the received JSON response and displays the obtained document URL to the user.

[1838] Input and Output

[1839] Input: A JSON response containing the document URL

[1840] Output: The document that is displayed to the user (e.g., a PDF displayed in a web browser)

[1841] Specific actions

[1842] The device parses the JSON response and displays the obtained URL in an iframe tag or a new browser tab. For example, the URL is set as the src attribute of the iframe tag as shown below.

[1843] html

[1844] <iframe src="https: / / example.com / documents / requirements_12345.pdf" width="100%" height="600px">< / iframe>

[1845] Through these steps, users will have clear and organized requirements, allowing the project to proceed efficiently.

[1846] (Application example 1)

[1847] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1848] Introducing or improving robots in factories requires the organization and clarification of a wide range of requirements. This process can be delayed due to a lack of communication between stakeholders or unclear requirements, which can have a negative impact on product quality and project progress. Furthermore, a lack of knowledge about a specific industrial domain makes it difficult to define optimal requirements. To solve these problems, a support system is needed that can streamline and clarify requirements definition, facilitate communication, and provide specialized knowledge.

[1849] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1850] In this invention, the server includes means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology, means for documenting the organized and clarified requirements in a consistent format, and means for providing an interface that promotes real-time communication between stakeholders. This allows users to analyze input requirements and document them in a unified format, and also provides industrial domain knowledge and task automation functions, thereby improving the progress speed and quality of projects.

[1851] "Requirements organization" is the process of clarifying the needs and specifications for a project or product and organizing them in a consistent format.

[1852] "Natural language processing technology" is a technology that enables computers to understand, analyze, and generate human language.

[1853] Documentation is the process of organizing information and data, converting it into a consistent format, and recording it as a document.

[1854] "Real-time communication" is a means of communication that allows stakeholders to exchange information without any time lag.

[1855] An "interface" is a means of providing a screen or method of operation for a user to interact with a system or application.

[1856] "Domain knowledge" is specialized knowledge about a particular industry or field.

[1857] "JSON format" is an abbreviation for JavaScript Object Notation, and is a lightweight format for structuring and representing data.

[1858] A "generative AI model" is a type of artificial intelligence, an advanced machine learning model for generating and editing text.

[1859] Documentation is the process of consistently recording information such as requirements, specifications, and project status.

[1860] "Task automation" is a system that automatically processes specified tasks without human intervention.

[1861] "Industrial domain knowledge" refers to specialized knowledge and know-how in the manufacturing and industrial fields.

[1862] To realize this invention, it is important to build a system that uses a generative AI model, natural language processing technology, and JSON format data transmission and analysis means. This system includes the following steps.

[1863] First, the user inputs requirements for introducing or improving a factory robot in natural language. The device used by the user (smartphone, tablet, computer, etc.) sends the input requirements to the server. At this time, the data is sent in JSON format.

[1864] The server then analyzes the received requirements using a generative AI model (e.g., the T5 model) to organize and clarify the requirements. The generative AI model is implemented using Hugging Face's transformers library. As a result of this analysis, the requirements are documented in a unified format. The documented requirements are then sent back from the server to the device and presented to the user.

[1865] Similarly, when a user inputs a question about a requirement, the device sends the question in JSON format to the server, which uses a generative AI model to generate an answer in real time, which is also displayed to the user on the device.

[1866] In addition, when a user inputs information about a specific industry or domain, the server uses a generative AI model to generate domain knowledge and provides it to the user. Also, when the user inputs the tasks they want to automate (organizing and classifying requirements, assessing importance, etc.), the server analyzes them and automates them.

[1867] The above process will streamline requirements definition and facilitate communication between stakeholders when introducing or improving factory robots. Furthermore, the provision of industrial domain knowledge and task automation functions are expected to improve the speed and quality of project progress.

[1868] As a concrete example, a project manager might input, "Please organize the requirements for a new assembly line for factory robots." That input is sent in JSON format to a server, which parses it using a generative AI model and documents the organized and clarified requirements in a unified format. The server then sends the document back to the terminal, which displays it to the user (project manager). Similarly, when a user asks, "When is the next product update?" the server uses the generative AI model to generate an answer and displays it to the user.

[1869] An example of a prompt is as follows:

[1870] "Organize the requirements for a new assembly line for factory robots."

[1871] "Automate the classification of quality control data."

[1872] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1873] Step 1:

[1874] The user inputs requirements for the introduction and improvement of factory robots in natural language using the device they use (smartphone, tablet, computer, etc.). The input requirements are converted into JSON format and sent to the server.

[1875] Step 2:

[1876] The device sends the user-entered requirements in JSON format to the server, which makes the data easier to parse.

[1877] Step 3:

[1878] The server analyzes the received requirements using a generative AI model (e.g., the T5 model) to organize and clarify the requirements. The generative AI model is implemented using Hugging Face's transformers library. As a result of this analysis, the requirements are organized in a consistent format.

[1879] Step 4:

[1880] The server documents the organized and clarified requirements and structures them in JSON format, which is then sent back to the device.

[1881] Step 5:

[1882] The terminal receives the documented requirements in JSON format returned from the server and displays them to the user, who can then review the organized requirements.

[1883] Step 6:

[1884] The user enters a question about the requirements in natural language, which is also converted to JSON format by the device and sent to the server.

[1885] Step 7:

[1886] The device receives questions from users and sends them in JSON format to the server, which analyzes the questions and generates answers in real time using a generative AI model.

[1887] Step 8:

[1888] The server uses a generative AI model to generate answers to questions, which are also written in natural language.

[1889] Step 9:

[1890] The server returns the generated answer to the terminal, which then displays the answer to the user, allowing the user to obtain the answer to their question.

[1891] Step 10:

[1892] When a user inputs information about a specific industry or domain, the device converts it into JSON format and sends it to the server, which uses generative AI models to generate domain knowledge and provide it to the user.

[1893] Step 11:

[1894] When a user wants to automate a task, they input the task in natural language and send it to the device. The device then sends the task in JSON format to the server, which then processes it for automation.

[1895] Step 12:

[1896] The server uses the generative AI model to automate the task and returns the results in JSON format to the device, which then displays the results to the user, allowing them to obtain the results of the automated task.

[1897] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1898] This invention relates to a requirements definition support tool that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This tool uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions. It also has an emotion engine that recognizes user emotions and adds a function to adjust the requirements definition process based on the recognized emotions.

[1899] Specific methods for carrying out the invention

[1900] Organizing and clarifying requirements

[1901] 1. User enters requirements

[1902] Users enter requirements in natural language through a user interface, which are concrete statements of needs and specifications for a project or product.

[1903] 2. The device sends the input to the server

[1904] The terminal converts the requirements entered by the user into JSON format and sends it to the server through an HTTP request, making it easier for the server to parse the requirements.

[1905] 3. The server organizes and clarifies the requirements

[1906] The server applies natural language processing techniques using generative AI models to the requirements received, organizes and clarifies the requirements, and documents the organized requirements in a consistent format.

[1907] Communication Support

[1908] 1. User enters a question

[1909] Users enter specific requirements or project-related questions in natural language to resolve information gaps or doubts about the project.

[1910] 2. The device sends the question to the server

[1911] The device receives a question from the user and sends it in JSON format to the server, which analyzes the question and begins processing it to generate an appropriate answer.

[1912] 3. The server answers the question

[1913] The server uses a generative AI model to generate answers to questions, which are written in natural language and in a user-friendly format.

[1914] Providing domain knowledge

[1915] 1. User enters specific domain information

[1916] Users input information about a specific industry or field in natural language, allowing them to access the domain knowledge they need during the requirements definition process.

[1917] 2. The device sends the domain information to the server

[1918] The device sends the domain information received from the user in JSON format to the server, which receives this information and begins processing it to provide knowledge about the domain.

[1919] 3. The server provides domain knowledge

[1920] The server uses generative AI models to generate knowledge about a specific domain and provides it to the user.

[1921] Automation and efficiency

[1922] 1. The user enters the task they want to automate

[1923] Users input tasks they want to automate, such as organizing and categorizing requirements and evaluating their importance, in natural language, thereby improving work efficiency.

[1924] 2. The device sends the task to the server

[1925] The device converts the task received from the user into JSON format and sends it to the server via an HTTP request. The server analyzes the task and starts the process for automation.

[1926] 3. Server automates tasks

[1927] The server uses the generative AI model to automate the task, which is then automatically processed and the results are provided to the user.

[1928] Emotion engine integration

[1929] 1. Recognize user emotions

[1930] The emotion engine analyzes user input and user interface behavior to recognize user emotions, for example, by inferring emotions based on input text and click frequency.

[1931] 2. The device sends emotional information to the server

[1932] The device sends the recognized user emotion information to the server in JSON format, allowing the server to adjust subsequent processes based on the emotion.

[1933] 3. The server adjusts the process based on emotions

[1934] The server then adjusts the requirements definition and communication support processes based on the received emotional information. For example, if the user is feeling stressed, it will provide more detailed guidance.

[1935] Specific examples

[1936] For example, if a user types "I want you to organize the requirements for a customer management system," the terminal sends this to the server, which then analyzes, organizes, and documents the requirements in a consistent format. At the same time, the system recognizes the user's emotions based on the user's typing speed and context, and displays additional help messages if the user is feeling stressed.

[1937] Furthermore, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate an answer. At the same time, it monitors the user's emotions and responds quickly if the user is in a hurry.

[1938] Through these processes, the present invention contributes to the success of projects by significantly streamlining the requirements definition process and enabling flexible responses to user emotions.

[1939] The processing flow will be explained below.

[1940] Step 1:

[1941] The user enters requirements. Through a user interface, the user enters project or product requirements in natural language. For example, the user might enter, "The customer management system needs the ability to add, edit, and delete customer information."

[1942] Step 2:

[1943] The terminal sends input to the server. The terminal converts the requirements entered by the user into JSON format and sends it to the server via an HTTP request.

[1944] Step 3:

[1945] The server receives the requirements. The server parses the received HTTP request and extracts the requirements information in JSON format.

[1946] Step 4:

[1947] The server analyzes the requirements using natural language processing technology. It then uses a generative AI model to understand the context of the requirements and organize and clarify them. For example, it clarifies the requirement as "Provide the ability to add, edit, and delete customer information."

[1948] Step 5:

[1949] The server documents the organized requirements. The server documents the organized and clarified requirements in a consistent format.

[1950] Step 6:

[1951] The server returns the documented requirements to the device. The server generates a JSON response containing the documented requirements and returns it to the device as an HTTP response.

[1952] Step 7:

[1953] The terminal displays the results to the user. The terminal parses the JSON response received from the server and displays the organized requirements in the user interface, allowing the user to see clear and organized requirements.

[1954] Step 8:

[1955] User enters a question: A user enters a question in natural language about a specific requirement or project, such as "What is the release date for the new feature?"

[1956] Step 9:

[1957] The device sends the question to the server. The device converts the entered question into JSON format and sends it to the server via an HTTP request.

[1958] Step 10:

[1959] The server receives the question, parses the HTTP request, and extracts the question information in JSON format.

[1960] Step 11:

[1961] The server generates an answer to the question. The server uses a generative AI model to generate an appropriate answer to the question. For example, it generates an answer such as "The release date for the new feature is the 1st of next month."

[1962] Step 12:

[1963] The server returns the answer to the device. The server creates a JSON response containing the answer and returns it to the device as an HTTP response.

[1964] Step 13:

[1965] The terminal displays the answer to the user. The terminal parses the JSON response received from the server and displays the generated answer in the user interface, allowing the user to check the answer to the question.

[1966] Step 14:

[1967] User enters specific domain information. The user enters information about a specific industry or domain in natural language. For example, "What are the key requirements in the financial industry?"

[1968] Step 15:

[1969] The device sends the domain information to the server. The device converts the domain information received from the user into JSON format and sends it to the server via an HTTP request.

[1970] Step 16:

[1971] The server receives the domain information. The server parses the received HTTP request and extracts the domain information in JSON format.

[1972] Step 17:

[1973] The server provides domain knowledge: Using generative AI models, the server generates knowledge about a specific domain and provides it to the user, for example explaining the importance of security and data protection in the financial industry.

[1974] Step 18:

[1975] The server returns the generated domain knowledge to the terminal. The server generates a JSON response including the generated domain knowledge and returns it to the terminal as an HTTP response.

[1976] Step 19:

[1977] The terminal displays the domain knowledge to the user. The terminal parses the JSON response received from the server and displays the generated domain knowledge in the user interface, allowing the user to check important information about a specific domain.

[1978] Step 20:

[1979] The user inputs the task they want to automate. The user inputs the task they want to automate, such as organizing and categorizing requirements, and assessing their importance, in natural language. For example, they might input "List new requirements and categorize them."

[1980] Step 21:

[1981] The device sends the task to the server. The device converts the task received from the user into JSON format and sends it to the server via an HTTP request.

[1982] Step 22:

[1983] The server receives the task. The server parses the received HTTP request and extracts the task information in JSON format.

[1984] Step 23:

[1985] The server automates the task: Using a generative AI model, the server automates the incoming task and takes appropriate action, such as listing new requirements and classifying each requirement into the appropriate category.

[1986] Step 24:

[1987] The server returns the results of the automated task to the device. The server generates a JSON response containing the results of the automated task and returns it to the device as an HTTP response.

[1988] Step 25:

[1989] The terminal displays the automation results to the user. The terminal parses the JSON response received from the server and displays the results of the automated task in the user interface, allowing the user to check the results of the automated task and take any necessary actions.

[1990] Emotion engine integration

[1991] Step 26:

[1992] The emotion engine recognizes the user's emotions. The emotion engine analyzes the user's input and behavior on the user interface to recognize the user's emotions. For example, it infers the user's emotions based on the entered text, typing speed, click frequency, etc.

[1993] Step 27:

[1994] The device sends the emotion information to the server. The device sends the recognized emotion information of the user to the server in JSON format, which allows the server to adjust subsequent processes based on the emotion.

[1995] Step 28:

[1996] The server adjusts the process based on the emotion. The server adjusts the requirements definition and communication support processes based on the emotion information it receives. For example, if the user is feeling stressed, it will respond by providing more detailed guidance.

[1997] Through the above steps, the present invention significantly improves the efficiency of the requirements definition process and enables flexible responses to user emotions, thereby contributing to the success of the project.

[1998] Example 2

[1999] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[2000] Traditional requirements definition processes are often manual and require a great deal of time and effort. Real-time communication between stakeholders is difficult, which can delay information sharing and decision-making. Furthermore, the process is often carried out without consideration of user feelings, which can result in an unsatisfactory user experience. It is necessary to resolve these issues, streamline the requirements definition process, and improve project progress speed, product quality, and customer satisfaction.

[2001] The specific processing by the specific processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means.

[2002] In this invention, the server includes: [means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;] [means for documenting the organized and clarified requirements in a consistent format; and] [means for recognizing the user's emotions using an emotion engine and adjusting the requirements definition process based on the recognized emotions.] This makes it possible to improve the efficiency of the requirements definition process, realize smooth communication between stakeholders, and realize responses that correspond to the user's emotions.

[2003] "Means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology" refers to a function for receiving requirements that a user inputs to the system in natural language, systematically organizing them using natural language processing technology, and clarifying the content.

[2004] "Means for documenting organized and clarified requirements in a consistent format" refers to a function for documenting organized and clarified requirements using natural language processing technology in accordance with certain rules and formats, and for saving and displaying them in a consistent format.

[2005] "Means for providing an interface that promotes real-time communication among stakeholders" is a function that provides a user interface that helps real-time information sharing and communication among those involved in the project.

[2006] "A means of integrating knowledge bases related to specific industries or fields and enabling access to information needed during the requirements definition process" is a function that integrates a database that aggregates knowledge related to specific industries or fields, making it easy to access information needed during the requirements definition process.

[2007] "Means for recognizing user emotions using an emotion engine and adjusting the requirements definition process based on the recognized emotions" refers to a function that uses an emotion engine that analyzes emotions from user input and behavior to recognize the user's current emotional state and adjusts the requirements definition procedure and interactions according to those emotions.

[2008] "A means of learning from past projects and best practices to help improve the requirements definition process" is a function that learns from past project data and industry best practices, and uses that knowledge to help streamline and improve the requirements definition process.

[2009] "Means for automating the organization, classification, and importance evaluation of requirements" refers to a function that automates the process of properly organizing and classifying requirements and evaluating their importance. This reduces the manual workload and enables faster and more accurate requirements management.

[2010] This invention is a requirements definition support system that streamlines the requirements definition phase of a project and improves project progress speed, product quality, and customer satisfaction. This system uses generative AI models and natural language processing technology to organize, clarify, and document requirements, support real-time communication, provide domain knowledge, and provide automation and efficiency functions. It also features an emotion engine that recognizes user emotions. Furthermore, the requirements definition process can be dynamically adjusted based on the emotions recognized by this emotion engine.

[2011] Specifically, users input project or product requirements in natural language through a user interface. This input is converted to JSON format by the terminal and sent to the server via an HTTP request. The server then applies natural language processing techniques using generative AI models to the received requirements to organize and clarify them. The organized requirements are then documented in a consistent format.

[2012] To support real-time communication, users input questions about specific requirements or projects. The device converts the input into JSON format and sends it to the server via an HTTP request. The server then uses a generative AI model to generate answers to the questions and provides them to the user. Additionally, when users input information about a specific industry or field, the device sends it to the server, which then generates domain knowledge and provides it to the user.

[2013] With the automation and efficiency feature, when a user inputs automation tasks such as organizing and categorizing requirements and assessing their importance, the device converts the input into JSON format and sends it to the server via an HTTP request. The server then uses a generative AI model to automate the task and provides the results to the user.

[2014] The integration of an emotion engine allows the system to recognize emotions from user input and behavior and adjust subsequent processes based on those emotions. For example, if the user is feeling stressed, the system will provide detailed guidance and improve the user experience.

[2015] For example, if a user types "I want you to organize the requirements for a customer management system," the terminal sends this to the server, which then analyzes, organizes, and documents the requirements in a consistent format. It can also recognize emotions from the user's typing speed and context, and display additional help messages if the user is feeling stressed.

[2016] Furthermore, if a user asks, "When is the new feature release date?", the device sends the question to the server, which uses a generative AI model to generate a quick answer, while simultaneously monitoring the user's emotions and responding even faster if they are in a hurry.

[2017] Through these processes, the present invention significantly improves the efficiency of the requirements definition process and makes it possible to respond to user emotions, thereby greatly contributing to the success of the project.

[2018] Examples of prompts include:

[2019] "I want you to clarify the requirements for a customer management system."

[2020] "When are the new features released?"

[2021] Please provide the latest domain information.

[2022] The flow of the identification process in the second embodiment will be described with reference to FIG.

[2023] Organizing and clarifying requirements

[2024] Step 1:

[2025] User enters requirements

[2026] The user inputs specific requirements for a project or product in natural language. For example, they input specific content such as "database requirements for a new customer management system." The input data is requirement information in text format.

[2027] Step 2:

[2028] The device sends the input requirements to the server

[2029] The terminal acquires the requirements entered by the user and converts them into JSON format. For example, if the entered requirements are "Database requirements for a new customer management system," they are converted into the following JSON data:

[2030] json

[2031] {

[2032] "requirement": "Database requirements for the new customer management system"

[2033] }

[2034] This is sent to the server as an HTTP POST request.

[2035] Step 3:

[2036] The server organizes and clarifies the requirements

[2037] The server analyzes the received requirements data and applies natural language processing techniques using a generative AI model to organize and clarify the requirements. For example, if the requirement is "The database should have high availability and scalability," the server extracts keywords such as "availability" and "scalability" and generates an organized document. The results are output in document format.

[2038] Communication Support

[2039] Step 1:

[2040] The user enters a question

[2041] A user types in natural language a question about a specific requirement or project, for example, "What is the release date for the new feature?" The input data is a textual question.

[2042] Step 2:

[2043] The device sends a question to the server

[2044] The device converts the question received from the user into JSON format and sends it to the server via an HTTP request, for example:

[2045] json

[2046] {

[2047] "question": "When is the new feature release date?"

[2048] }

[2049] Step 3:

[2050] The server answers the question

[2051] The server uses a generative AI model to analyze the question and generate an appropriate answer, such as "The new feature will be released on December 15, 2023," in natural language format.

[2052] Providing domain knowledge

[2053] Step 1:

[2054] User enters specific domain information

[2055] A user inputs information about a specific industry or field in natural language. For example, they might input, "What are the latest trends in the fintech industry?" The input data is domain information in text format.

[2056] Step 2:

[2057] The device sends the domain information to the server.

[2058] The terminal converts the domain information received from the user into JSON format and sends it to the server via an HTTP request. For example, convert it as follows:

[2059] json

[2060] {

[2061] "domain_info": "What are the latest trends in the fintech industry?"

[2062] }

[2063] Step 3:

[2064] The server provides domain knowledge

[2065] The server uses the generative AI model to generate domain-specific knowledge, such as "Digital banking and smart contracts are hot topics in the modern fintech industry," in natural language.

[2066] Automation and efficiency

[2067] Step 1:

[2068] The user enters the task they want to automate.

[2069] The user inputs the task to be automated, such as organizing and categorizing requirements, evaluating their importance, etc. in natural language. For example, the user might input "Automatically organize the list of requirements according to priority." The input data is the automation task in text format.

[2070] Step 2:

[2071] The device sends the task to the server

[2072] The device converts the task received from the user into JSON format and sends it to the server via an HTTP request, for example:

[2073] json

[2074] {

[2075] "task": "Automatically organize the requirements list by priority"

[2076] }

[2077] Step 3:

[2078] Server automates tasks

[2079] The server uses the generative AI model to automate tasks, specifically by analyzing the incoming requirements, assessing the importance of each requirement, and organizing them according to priority. The results are output as an organized list of requirements.

[2080] Emotion engine integration

[2081] Step 1:

[2082] Emotion engine recognizes user emotions

[2083] The emotion engine analyzes user input and behavior to recognize emotions. For example, it infers emotions such as "irritated" from input text, click frequency, and usage time. Input data is user behavior logs and text data.

[2084] Step 2:

[2085] The device sends emotional information to the server.

[2086] The device sends the user's recognized emotion information to the server in JSON format. For example, it can be converted as follows:

[2087] json

[2088] {

[2089] "emotion": "frustrated"

[2090] }

[2091] Step 3:

[2092] Server adjusts process based on emotion

[2093] The server adjusts the requirements definition and communication process based on the emotional information received, for example, if the user is feeling stressed, it displays additional guidance or support messages.

[2094] (Application example 2)

[2095] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[2096] The requirements definition phase of a project is often complex and time-consuming, and poor communication between stakeholders and a lack of domain knowledge can affect quality and progress speed. Furthermore, in projects requiring advanced technology such as autonomous vehicles, it is particularly important to organize and clarify requirements, provide domain knowledge, support real-time communication, and adjust the process while taking user emotions into consideration. Therefore, solutions are needed to efficiently and effectively execute such a complex requirements definition phase.

[2097] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[2098] In this invention, the server includes: [means for receiving input requirements and organizing and clarifying the requirements using natural language processing technology;] [means for documenting the organized and clarified requirements in a consistent format;] [means for providing an interface that promotes real-time communication between stakeholders;] [means for integrating a knowledge base related to a specific industry or domain and making necessary information accessible during the requirements definit...

Claims

1. means for receiving input requirements and organizing and clarifying the requirements using natural language processing techniques; A means of documenting the organized and clarified requirements in a consistent format; a means for providing an interface that facilitates real-time communication between stakeholders; A means to integrate knowledge bases for specific industries or domains and provide access to the information needed during the requirements definition process; A means to learn from past projects and best practices to help improve the requirements definition process; A means to automate the organization, classification, and importance evaluation of requirements, A system including:

2. The system of claim 1 , further comprising means for providing a chat-based interface between stakeholders to share and discuss questions and opinions regarding requirements in real time.

3. 10. The system of claim 1, further comprising means for integrating machine learning models to automate the requirements organization and clarification and materiality assessment tasks.

Images