System

Abstract

A system is provided.SOLUTION: A system comprising: means for receiving data input from a user; means for passing the received data to a natural language processing engine for analysis; means for generating personalized feedback using user-specific information based on the analysis; and means for providing the generated feedback to the user.SELECTED DRAWING: Figure 1

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] In today's business environment, employees need specialized knowledge and feedback to efficiently create documents and proposals. However, it is difficult to receive prompt and accurate feedback from superiors and colleagues, which can result in a decline in work efficiency. Furthermore, while employee stress management and career guidance are important factors, there is a lack of appropriate support methods for these. A system to solve these issues is needed. [Means for solving the problem]

[0005] The present invention provides a system that receives data entered by a user and passes the received data to a natural language processing engine for analysis. The system includes a means for generating personalized feedback using user-specific information based on the analysis results. Specifically, the feedback includes a grammar check of the text, suggestions for content improvement, and praise comments. The level of personalization can be further enhanced by referencing the user's past request history and user profile data. The system also includes a means for providing a user interface that allows users to easily input and submit data, and a means for providing stress management techniques and career guidance. This enables efficient support for document creation and improved work efficiency, as well as stress reduction and career support for employees.

[0006] "User" refers to any individual or entity that uses the System.

[0007] "Input data" refers to the text or information a user provides to a system.

[0008] "Natural language processing engine" refers to programs and algorithms that analyze input data and understand its grammar, structure, and meaning.

[0009] "Analysis" refers to a series of processes performed by a natural language processing engine, including grammar checks of input data, key phrase extraction, and verification of logical structure.

[0010] "Feedback" refers to information that the system generates based on the analysis results, including opinions, advice, suggestions, praise, etc., for the user.

[0011] "Personalization" refers to using user-specific information to individually optimize the feedback provided by the system.

[0012] "User-specific information" refers to information specific to an individual user, such as the user's past request history and user profile data.

[0013] "Grammar checking" refers to the process of detecting and correcting grammatical errors and inappropriate expressions in input data.

[0014] "Content improvement suggestions" refers to providing specific advice and correction points to improve the quality of input data.

[0015] "Praise comments" refer to positive comments that acknowledge the merits of the input data and encourage the user.

[0016] "User interface" refers to the screen configuration and operation means that allow a user to interact with a system.

[0017] "Stress management techniques" refers to methods and advice to help employees reduce the stress they experience at work.

[0018] "Career guidance" refers to information and advice that supports users in choosing a career and advancing their career. [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 conversational AI system that efficiently provides support when a user requests improvements to documents or proposals. This system interacts between a terminal, a server, and the user, and provides personalized feedback to the user.

[0041] System Overview

[0042] 1. User Input

[0043] Users request the system to review documents and proposals via the user interface of their terminal.

[0044] Specifically, the user enters the required information into the text input field and presses the send button to send the request to the terminal.

[0045] 2. Data transmission

[0046] The device sends the user's input data to the server as an API request, which includes the user ID, the input text, and the type of request.

[0047] 3. Receiving and parsing the request

[0048] The server analyzes the received request and passes the text data to a natural language processing engine.

[0049] The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure.

[0050] 4. Personalized processing

[0051] The server looks up the user's profile data and past request history and personalizes the feedback accordingly.

[0052] Generate feedback based on user-specific information, including praise and specific suggestions for improvement.

[0053] 5. Generating and Providing Feedback

[0054] The server compiles the generated feedback and sends it to the device as an API response.

[0055] The terminal displays the received feedback on the user interface so that the user can check it.

[0056] Specific examples

[0057] Consider a case where a user creates a new product proposal, enters "Please review my new product proposal," and presses the submit button.

[0058] 1. User Input

[0059] The user enters "Please review our new product proposal" into the input field on the terminal, and then presses the send button.

[0060] 2. Data transmission

[0061] The terminal sends the input data to the server. The transmitted data includes the user ID, input text, and request type (review request).

[0062] 3. Receiving and parsing the request

[0063] The server receives the request and passes the text data to a natural language processing engine.

[0064] The natural language processing engine performs a grammar check and returns the analysis results to the server, such as, "That's a great suggestion, but it would be even better if you improved the following points."

[0065] 4. Personalized processing

[0066] The server refers to the user's past proposal history and profile data to create optimized feedback for the user.

[0067] 5. Generating and Providing Feedback

[0068] The server generates feedback and sends it to the device, such as: "Great suggestion! I especially like how you highlight the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[0069] The device receives this feedback and displays it in the user interface, where the user can review it and use it to revise the proposal.

[0070] As a result, this system supports users in efficiently improving their documents and proposals, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also helps to increase user motivation.

[0071] The processing flow will be explained below.

[0072] Specific processing of the program

[0073] Step 1: Submitting a request

[0074] 1. A user inputs text through the terminal's user interface to request a review of a document or proposal.

[0075] 2. The user presses the send button, which sends the input data to the terminal.

[0076] Step 2: Prepare your data

[0077] 1. The terminal receives the data entered by the user and checks the format and content of the data.

[0078] 2. The device converts the received data into an API request format and prepares it to be sent to the server.

[0079] Step 3: Sending data

[0080] 1. The device sends a prepared API request to the server, which includes the user ID, input text, and request type.

[0081] Step 4: Receiving the request

[0082] 1. The server receives a request from the device at an API endpoint.

[0083] 2. The server extracts the user ID, input text, and request type from the request and proceeds to the next step.

[0084] Step 5: Performing Natural Language Processing

[0085] 1. The server passes the extracted input text to the natural language processing engine.

[0086] 2. The natural language processing engine checks the text for grammar, analyzes its structure, and tests the logic of its content, and returns the results to the server.

[0087] Step 6: Personalization

[0088] 1. The server retrieves the user's profile data and past request history from the database.

[0089] 2. The server personalizes the analysis results obtained from the natural language processing engine based on the user-specific information obtained.

[0090] Step 7: Feedback Generation

[0091] 1. The server generates personalized feedback, including praise, suggestions for improvement, and specific instructions for correction.

[0092] Step 8: Generate and Send a Response

[0093] 1. The server prepares the generated feedback as a JSON API response.

[0094] 2. The server sends this API response to the device.

[0095] Step 9: Receiving the response

[0096] 1. The device receives the API response from the server.

[0097] 2. The device parses the received data and converts it into a format for display on the user interface.

[0098] Step 10: View feedback

[0099] 1. The device displays the received feedback in the user interface.

[0100] 2. Feedback is presented as praise and specific suggestions for improvement in a format that is easy for users to review.

[0101] Step 11: Review and implement feedback

[0102] 1. The user checks the feedback displayed on the device.

[0103] 2. The user will revise the materials and proposals based on the feedback.

[0104] 3. If necessary, the user can request another review.

[0105] Through the above steps, the "Praise Boss" system provides efficient and personalized feedback to users, helping them improve the quality and efficiency of their work.

[0106] Example 1

[0107] 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."

[0108] Conventional document and proposal review systems have struggled to provide users with personalized feedback quickly and efficiently. Furthermore, general feedback fails to provide specific improvement suggestions that take into account the user's specific needs and past request history, making it insufficient to motivate users or improve their work efficiency. Furthermore, feedback can sometimes be slow to appear, potentially hindering the user's work speed.

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

[0110] In this invention, the server includes means for receiving data input by a user, means for transmitting the received data as an API request, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis result, means for transmitting the generated feedback as an API response, and means for displaying the feedback on a user interface, thereby enabling personalized feedback to be provided to the user quickly and efficiently.

[0111] "User" means an individual or legal entity that uses the system and requests a review.

[0112] "Entered data" refers to textual information and other relevant data that a user sends to the system via a terminal.

[0113] A "terminal" is a device that a user uses to access the system, and is a general communication device including a PC, smartphone, etc.

[0114] An "API request" is a standardized communication procedure for sending data from a terminal to a server, and specifically refers to an HTTP request.

[0115] A "server" is a computer system that handles the back-end processing of the system, receiving input data, analyzing it, and generating feedback.

[0116] A "natural language processing engine" is software used to check the grammar of input data, improve its content, and verify its logical structure, such as a generative AI model.

[0117] "Personalized feedback" is feedback that includes specific and customized suggestions for improvement and praise based on the user's unique information and past request history.

[0118] An "API response" is data sent from a server to a terminal, and is in the form of response data that includes feedback.

[0119] "User interface" refers to an interface for communication between a user and a terminal, and refers to the screen display and operation means by which a user sends input data and checks feedback.

[0120] The present invention relates to a conversational AI system that efficiently provides support when a user requests improvements to documents or proposals. This system interacts between a terminal, a server, and the user, and provides personalized feedback to the user.

[0121] Hardware and software used

[0122] Hardware: Device (PC or smartphone)

[0123] Software: Servers, APIs, natural language processing engines (e.g. GPT-3, BERT)

[0124] System Operation

[0125] The user requests the system to review documents or proposals via the device's user interface. Specifically, the user enters "Please review my new product proposal" in the text input field and presses the submit button. This causes the browser's JavaScript to capture the input data and prepare it to be sent to the API endpoint.

[0126] The device sends the user input data to the server using AJAX. For example, data is sent in the form of axios.post(' / api / review', { userId: '123', text: 'Please review the new product proposal', requestType: 'review'}).

[0127] The server receives the data using the Flask framework and passes the input text data to a natural language processing engine. The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure, and returns the results to the server. For example, it may make suggestions such as, "Make this sentence more concise."

[0128] The server refers to the user's profile data and past request history and provides personalized feedback based on that. Specifically, it retrieves the user's past request history from a database (e.g., PostgreSQL) and generates feedback such as, "Compared to your previous proposal, this one has a clearer logical structure. However, it would be even better if you added a few more concrete examples."

[0129] The server returns the generated feedback to the device in JSON format. For example, a response is generated in the form of return jsonify({'feedback': feedback_text}). The device parses the received data and displays it in the user interface. Using the browser's JavaScript (e.g., React.js), the feedback content is rendered into HTML and displayed to the user as "That's a great suggestion! I especially like how you emphasize the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[0130] This system helps users improve their documents and proposals efficiently, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also motivates users.

[0131] Specific examples

[0132] Consider the case where a user types "Please review our new product proposal" and presses the submit button.

[0133] Example prompt: "Please review this new product proposal. Check for grammar, suggest content improvements, verify logical structure, and provide feedback."

[0134] Requests from users are sent via the server to a natural language processing engine, which returns suggestions for improving grammar and content to the server. The server then references the user's past request history to generate personalized feedback and send it to the device. The device displays this on the user interface, and after the user has confirmed it, they can use it to revise their proposal. This series of operations improves the quality of documents and proposals, as well as business efficiency.

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

[0136] Step 1:

[0137] The user uses the user interface of the terminal to request a review of a document or proposal. Specifically, the user enters "Please review my new product proposal" in the text input field and presses the send button. This operation prepares the input data, including the user ID, text, and request type.

[0138] Input: Text data entered through the user interface

[0139] Output: API request data ready to be sent

[0140] Step 2:

[0141] The device sends the user input data to the server using an AJAX request. This request is sent in the following format: axios.post(' / api / review', { userId: '123', text: 'Please review the new product proposal', requestType: 'review'}). The data is sent as an HTTP POST request.

[0142] Input: API request data from the user ready to be sent

[0143] Output: API request sent to the server

[0144] Step 3:

[0145] The server receives the API request using the Flask framework and parses the input data, which includes the user ID, text, and request type. The server then prepares this data for further processing by the natural language processing engine.

[0146] Input: The API request sent to the server

[0147] Output: Text data that can be sent to a natural language processing engine

[0148] Step 4:

[0149] The server sends a request to the natural language processing engine using the Python library requests. For example, a request is sent as follows: response = requests.post('https: / / api.openai.com / v1 / engines / gpt-3 / completions', data={'text': input_text}). The natural language processing engine performs grammar checks, suggests content improvements, and validates the logical structure, and returns the results to the server.

[0150] Input: Text data sent to the natural language processing engine

[0151] Output: Analysis results returned by the natural language processing engine

[0152] Step 5:

[0153] The server generates personalized feedback based on the analysis results returned by the natural language processing engine, referencing the user's profile data and past request history. It retrieves the user's history from a database (e.g., PostgreSQL) and customizes the feedback. As a result, it generates feedback such as, "Compared to your previous proposal, the logical structure is clearer this time. However, adding a few more concrete examples would be even better."

[0154] Input: Analysis results returned by the natural language processing engine, user profile data, and past request history

[0155] Output: Personalized feedback

[0156] Step 6:

[0157] The server sends the generated feedback to the device in JSON format. For example, feedback is sent in the format return jsonify({'feedback': feedback_text}).

[0158] Input: Personalized Feedback

[0159] Output: JSON-formatted feedback sent to the device

[0160] Step 7:

[0161] The device analyzes the received feedback and displays it in the user interface. Using the browser's JavaScript (e.g., React.js), the feedback is rendered into HTML and displayed in a user-friendly format. The user can view this feedback and use it to revise documents and proposals.

[0162] Input: JSON feedback sent from the server

[0163] Output: Feedback displayed in the user interface

[0164] (Application example 1)

[0165] 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."

[0166] Conventional review systems for documents and proposals often fail to provide optimal feedback to users. Furthermore, they lack the ability to provide real-time feedback, which hinders the efficiency of the content creation process. This makes it difficult to improve the quality of user-created content, and motivating users is also an issue.

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

[0168] In this invention, the server includes means for receiving data input by a user, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis result, means for providing the generated feedback to the user, and means for displaying the feedback in real time, thereby improving the quality of content created by users and making the content creation process more efficient by providing feedback in real time.

[0169] "User-input data" refers to text or information that a user sends to the system via a terminal.

[0170] "Means for receiving" refers to the functions and processes by which the system receives data input by the user.

[0171] A "natural language processing engine" refers to a computer system that analyzes input text data, checks grammar, and suggests content improvements.

[0172] "Means for analysis" refers to the functions and processes for passing received data to a natural language processing engine for analysis.

[0173] "User-specific information" refers to information specific to a user, such as the user's profile data and past request history.

[0174] "Personalized feedback" refers to feedback that is customized based on analysis results and takes into account user-specific information.

[0175] "Means for generating" refers to the functions and processes for creating feedback based on the analysis results and user-specific information.

[0176] "Means of delivery" refers to the functions and processes for delivering the generated feedback to the user.

[0177] "Means for displaying feedback in real time" refers to the functionality or process for displaying generated feedback to the user immediately.

[0178] The present invention is an interactive AI system that allows users to receive reviews of documents and proposals in real time and efficiently improve them. The system includes the following components:

[0179] System configuration

[0180] 1. User Interface

[0181] The device (smartphone or head-mounted display) is the means for receiving data input from the user. The user inputs the contents of documents and proposals through this interface.

[0182] 2. Data Transfer

[0183] The terminal transmits the text data entered by the user to the server. This transmitted data includes the user ID, the entered content, and the type of request (e.g., a review request).

[0184] 3. Natural Language Processing Engine

[0185] The server uses a natural language processing engine to analyze the received text data. This engine checks grammar, suggests content improvements, and analyzes logical structure. The software used includes Python, HTTP requests, and API services.

[0186] 4. Personalized processing

[0187] The server looks at the user's profile data and past request history, and generates personalized feedback based on the analysis, including grammar checks, suggestions for content improvement, and praise comments.

[0188] 5. Providing Feedback

[0189] The generated feedback is sent in real time to the terminal, which displays the feedback on the user interface for the user to review.

[0190] Specific examples

[0191] For example, consider the case where a user creates a new product proposal and sends it by entering "Please review my new product proposal."

[0192] 1. User Input

[0193] The user enters "Please review our new product proposal" into the input field on the terminal, and then presses the send button.

[0194] 2. Data transmission

[0195] The terminal sends the input data to the server. The transmitted data includes the user ID, input text, and request type (review request).

[0196] 3. Receiving and parsing the request

[0197] The server receives the request and passes the text data to a natural language processing engine, which checks grammar, suggests content improvements, verifies logical structure, and returns the analysis results to the server.

[0198] 4. Personalized processing

[0199] The server references past proposal history and profile data to generate tailored feedback for the user, such as, "I particularly like how you emphasized the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[0200] 5. Generating and Providing Feedback

[0201] The server generates feedback and sends it to the device, which displays it in real time on the user interface. The user can then review the feedback and use it to revise their proposal.

[0202] Prompt Sentence Examples

[0203] Below are some example prompts to input to the generative AI model:

[0204] Content Review Request:

[0205] I would like you to review our new product proposal. Please let me know what specific improvements and grammatical errors we should make.

[0206] As described above, this system supports users in efficiently improving their documents and proposals, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also helps to increase user motivation.

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

[0208] Step 1:

[0209] The user enters the content of the document or proposal they wish to evaluate via the device's user interface. Specifically, they enter the required text in the text input field and press the submit button. This generates input data. The input data includes the user ID, the entered content, and the type of request (e.g., a review request).

[0210] Step 2:

[0211] The device sends the text data entered by the user to the server. Specifically, it sends data to an API endpoint using an HTTP request. At this time, the sent data includes the user ID, input text, and request type. Input: Data entered by the user into the device. Output: Data sent to the server.

[0212] Step 3:

[0213] The server passes the received data to the natural language processing engine for analysis. Here, the server generates an API request to analyze the text data and sends it to the natural language processing engine. The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure. Input: Data sent to the server. Output: Data containing the analysis results.

[0214] Step 4:

[0215] The server uses the analysis results received from the natural language processing engine to personalize feedback using user-specific information. Specifically, it references the user's profile data and past request history to generate praise comments and specific improvement measures based on the analysis results. Input: Analysis results from the natural language processing engine and user profile data. Output: Personalized feedback.

[0216] Step 5:

[0217] The server compiles the generated personalized feedback and sends it to the device. Specifically, it returns the feedback data to the device via the API as an HTTP response. Input: Personalized feedback. Output: Feedback data displayed in the user interface.

[0218] Step 6:

[0219] The terminal displays the received feedback data in the user interface in real time. Specifically, it allows the user to check the feedback and use it to revise documents and proposals. Input: Feedback data sent from the server. Output: Feedback displayed on the user interface.

[0220] Through the above processing steps, users can receive personalized feedback in real time, enabling them to efficiently improve their materials and proposals.

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

[0222] This invention relates to a conversational AI system that provides efficient and personalized feedback when users request improvements to documents or proposals. This system provides more appropriate feedback by incorporating an emotion engine that analyzes the user's emotions.

[0223] System Overview

[0224] 1. User Input

[0225] Users can request a review of documents or proposals from the system via the user interface on their device. At this time, the emotion engine also performs emotion analysis based on the user's input data.

[0226] 2. Data transmission

[0227] The device converts the user's input data and the emotion analysis results from the emotion engine into an API request format and sends it to the server. The transmitted data includes the user ID, input text, emotion analysis results, and the type of request.

[0228] 3. Receiving and parsing the request

[0229] The server receives requests from the device at the API endpoint and extracts the user ID, input text, sentiment analysis results, and request type from the request.

[0230] The server passes the received input text to a natural language processing engine for grammar checking, content analysis, and structural analysis.

[0231] 4. Personalized processing

[0232] The server retrieves the user's profile data and past request history from a database, and also incorporates the results of sentiment analysis into the process.

[0233] Based on the acquired information, the server personalizes the analysis results obtained from the natural language processing engine and generates feedback that is adapted to the user's current emotions.

[0234] 5. Generating and Providing Feedback

[0235] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[0236] It sends API responses to the device and displays the received feedback in the user interface.

[0237] Specific examples

[0238] Consider a case where a user creates a new product proposal, enters "Please review my new product proposal," and presses the send button. Here we will explain in detail what happens if the emotion engine detects that the user is feeling stressed.

[0239] 1. User Input

[0240] The user enters "Please review our new product proposal" into the text input field on the terminal and presses the send button.

[0241] The emotion engine analyzes the user's emotions based on the input content, input speed, and text, and detects "stress."

[0242] 2. Data transmission

[0243] The device sends the input text and the emotion analysis results to the server. The transmitted data includes the user ID, input text, stress emotion, and request type.

[0244] 3. Receiving and parsing the request

[0245] The server receives the request and passes the input text to a natural language processing engine, which performs grammar checks, content enrichment, and structural analysis.

[0246] 4. Personalized processing

[0247] The server references the user's profile data, past request history, and sentiment analysis results, and uses this information to personalize feedback.

[0248] If the user is stressed, tailor your feedback to emphasize praise comments and offer suggestions for improvement in a gentle tone.

[0249] 5. Generating and Providing Feedback

[0250] The server generates feedback like this and sends it to the device: "This new product proposal is excellent! It really highlights the specific benefits. However, it could be even better if you were a bit more specific in some sections. Good luck, we're really looking forward to your proposal."

[0251] The device receives this feedback and displays it in the user interface, where the user can review it and use it to revise the proposal.

[0252] As a result, by combining this system with an emotion engine, it is possible to provide appropriate and personalized feedback according to the user's emotional state, which not only improves work efficiency but also contributes to maintaining the user's mental health.

[0253] The processing flow will be explained below.

[0254] Specific processing of the program

[0255] Step 1: Submitting a request

[0256] 1. A user inputs text through the terminal's user interface to request a review of a document or proposal.

[0257] 2. When the user has finished entering data, they press the send button, which sends the data to the terminal.

[0258] 3. At the same time, the emotion engine analyzes the user's input data and determines the emotional state (e.g., stress, joy, sadness, etc.).

[0259] Step 2: Prepare your data

[0260] 1. The device receives data entered by the user and the analysis results of the emotion engine.

[0261] 2. The device converts the received data into an API request format and prepares it to be sent to the server.

[0262] 3. The converted data includes the user ID, input text, sentiment analysis results, and request type.

[0263] Step 3: Sending data

[0264] 1. The device sends a prepared API request to the server, which includes the user ID, input text, sentiment analysis results, and request type.

[0265] Step 4: Receiving the request

[0266] 1. The server receives a request from the device at an API endpoint.

[0267] 2. The server extracts the user ID, input text, sentiment analysis results, and request type from the request and retrieves the necessary data.

[0268] Step 5: Performing Natural Language Processing

[0269] 1. The server passes the extracted input text to the natural language processing engine.

[0270] 2. The natural language processing engine checks the text for grammar, analyzes its structure, and tests the logic of its content, and returns the analysis results to the server.

[0271] Step 6: Personalization

[0272] 1. The server retrieves the user's profile data and past request history from the database.

[0273] 2. The server also refers to the emotion analysis results and personalizes the feedback based on the user's current emotional state.

[0274] 3. Based on the acquired information, the server integrates the analysis results obtained from the natural language processing engine and generates optimized feedback for the user.

[0275] Step 7: Feedback Generation

[0276] 1. The server generates personalized feedback, including praise, suggestions for improvement, and specific instructions for correction.

[0277] 2. Based on the results of the emotion analysis, the tone and content of the feedback are adjusted to suit the user's emotional state.

[0278] Step 8: Generate and Send a Response

[0279] 1. The server prepares the generated feedback as a JSON API response.

[0280] 2. The server sends this API response to the device, which includes grammar check results, suggestions for content improvement, praise comments, and emotional feedback.

[0281] Step 9: Receiving the response

[0282] 1. The device receives the API response from the server.

[0283] 2. The device parses the received data and converts it into a format for display on the user interface.

[0284] Step 10: View feedback

[0285] 1. The device displays the received feedback in the user interface.

[0286] 2. Feedback is presented as praise and specific suggestions for improvement in a format that is easy for users to review.

[0287] 3. Emotion-responsive feedback is also displayed, providing content that corresponds to the user's emotional state.

[0288] Step 11: Review and implement feedback

[0289] 1. The user checks the feedback displayed on the device.

[0290] 2. The user will revise the materials and proposals based on the feedback.

[0291] 3. If necessary, the user can request another review.

[0292] Through the above steps, the "Praise Boss" system, combined with the emotion engine, provides efficient and personalized feedback that adapts to the user's emotional state, not only improving the quality and efficiency of work but also contributing to maintaining the user's mental health.

[0293] Example 2

[0294] 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."

[0295] In modern document creation and proposal writing, systems that can provide efficient and personalized feedback are required. However, existing systems cannot take into account the user's emotional state, making it difficult to provide appropriate feedback that reduces the user's stress and anxiety.

[0296] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving data input by a user, a means for passing the received data to a natural language processing engine for analysis, a means for generating personalized feedback using user-specific information based on the analysis result and the emotion analysis result, and a means for providing the generated feedback to the user. This makes it possible to provide appropriate and personalized feedback according to the user's emotional state.

[0297] "User" refers to a person who uses this system to request a review of materials or proposals.

[0298] "Input data" refers to text information provided by a user to the system via a terminal.

[0299] A "natural language processing engine" refers to software or algorithms that analyze received text data and check its grammar and improve its content.

[0300] "Analysis results" are the results of analyzing text data generated by a natural language processing engine, and include information on grammar checks and suggestions for content improvement.

[0301] "Emotion analysis results" refers to information about the emotional state extracted from the user's input data by the emotion engine.

[0302] "User-specific information" refers to data related to an individual user, including past request history, user profile data, sentiment analysis results, and the like.

[0303] "Personalized feedback" refers to responses or advice that are customized based on the user's unique information and emotional state.

[0304] "Means of providing" refers to the functions and processes for communicating the generated feedback to the user.

[0305] "System" is a collective term for a set of devices and software that analyzes user input data and provides personalized feedback.

[0306] This invention relates to a conversational AI system that provides efficient and personalized feedback when users request improvements to documents or proposals. This system provides more appropriate feedback by incorporating an emotion engine that analyzes the user's emotions.

[0307] The system is configured as follows:

[0308] 1. User Input

[0309] A user requests a review of a document or proposal from the system via the device's user interface. In practice, the user enters "Please review my new product proposal" into the device's text input field and presses the send button. At this time, the emotion engine analyzes the user's emotional state (e.g., stress, anxiety) in real time based on the input content, input speed, and selected words.

[0310] 2. Data transmission

[0311] The device converts the user's input text and the emotion analysis results from the emotion engine into an API request format and sends it to the server. The transmitted data includes the user ID, input text, emotion analysis results (e.g., stress), and the type of request. The API request is in JSON format and is sent to the server via the device's communication module over the Internet.

[0312] 3. Receiving and parsing the request

[0313] The server receives requests sent from the device via the API endpoint. It analyzes the received request and extracts the user ID, input text, sentiment analysis results, and request type. The server then passes the input text to a natural language processing engine (e.g., GPT-3) for grammar check, content analysis, and structure analysis.

[0314] 4. Personalized processing

[0315] The server retrieves the user's profile data and past request history from the database. Based on all of this information, including the results of sentiment analysis, the analysis results obtained from the natural language processing engine are personalized. Specifically, feedback is generated that adapts to the user's emotional state. For example, if the user is feeling stressed, the feedback is adjusted to emphasize praise comments and provide suggestions for improvement in a gentler tone.

[0316] 5. Generating and Providing Feedback

[0317] The server prepares the generated feedback as a JSON-formatted API response and sends it to the device. The feedback includes grammar check results, suggestions for content improvement, praise comments, and adjustments to tone and content to take into account emotions. The device receives the API response and displays it on the user interface. The user can review the feedback and use it to revise their materials or proposals.

[0318] Specific examples

[0319] A specific example will be described in which a user creates a new product proposal, enters "Please review my new product proposal," and presses the send button.

[0320] Example prompt: "Please review our new product proposal. Please provide feedback in a friendly tone on the overall flow and structure of the content."

[0321] By combining this with an emotion engine, the system provides appropriate and personalized feedback based on the user's emotional state, thereby improving work efficiency and contributing to maintaining the user's mental health.

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

[0323] Step 1:

[0324] The user enters text into the device's text input field and presses the send button. The emotion engine analyzes the user's emotions in real time based on their input content, speed, and selected words.

[0325] Input: User input text, such as "Please review our new product proposal."

[0326] Output: Input text and parsed emotional state (e.g., stress)

[0327] Step 2:

[0328] The device receives the user's input text and the emotion analysis results from the emotion engine, and converts them into an API request format, which includes the user ID, input text, emotion analysis results, and request type.

[0329] Input: Input text and sentiment analysis results obtained in Step 1

[0330] Output: API request (JSON format)

[0331] Step 3:

[0332] The device sends an API request to the server, which then communicates to confirm that the request has been sent.

[0333] Input: API request

[0334] Output: Sending status (success / failure)

[0335] Step 4:

[0336] The server receives the request sent from the device at the API endpoint, analyzes the request content, and extracts the user ID, input text, sentiment analysis results, and request type.

[0337] Input: The API request received

[0338] Output: Extracted data (user ID, input text, sentiment analysis results, request type)

[0339] Step 5:

[0340] The server passes the extracted input text to a natural language processing engine to perform grammar checks, content analysis, and structure analysis. The natural language processing engine (e.g., GPT-3) analyzes the received text data and generates grammar check results and content improvement suggestions.

[0341] Input: Data (input text)

[0342] Output: Analysis results (grammar check results, content improvement suggestions)

[0343] Step 6:

[0344] The server retrieves user profile data and past request history from the database, and also takes into account sentiment analysis results to personalize feedback.

[0345] Input: Analysis results, user ID, emotion analysis results

[0346] Output: personalized feedback data

[0347] Step 7:

[0348] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[0349] Input: Personalized feedback data

[0350] Output: API response (JSON format)

[0351] Step 8:

[0352] The server sends the API response to the device, which receives the response and displays the feedback in the user interface.

[0353] Input: API response

[0354] Output: Feedback displayed in the user interface

[0355] (Application example 2)

[0356] 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."

[0357] In conventional content distribution services, when users request feedback on content such as articles or videos they have entered, the content of the feedback is often inappropriate for the user's situation or emotions because the user's emotional state is not taken into consideration.In addition, the feedback content is often too general and does not address the individual user's requests or emotions, leaving users dissatisfied.

[0358] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving data input by a user, emotion analysis means for analyzing emotions from the user's input data, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis results and emotion analysis results, and means for providing the generated feedback to the user. This makes it possible to generate and provide feedback tailored to the user's emotional state in real time.

[0359] "User-input data" refers to information that a user provides to the system as text or content.

[0360] "Emotion analysis means" is a function that detects and analyzes the user's emotional state from the input data and behavior of the user.

[0361] A "natural language processing engine" is an engine that analyzes input text and performs processes such as grammar checks and content improvement.

[0362] "User-specific information" is information that is individually associated with a user, such as the user's profile data and past request history.

[0363] "Personalized feedback" is feedback that is adapted to an individual user based on analysis results and user-specific information.

[0364] The "means for providing feedback to the user" is a function for displaying or notifying the user of the generated feedback.

[0365] "Grammar checking" is the process of detecting grammatical errors in text and providing suggested corrections.

[0366] "Content Improvement Suggestions" are specific advice or suggestions for improving the quality of text or content.

[0367] A "praise comment" is a comment that recognizes a user's efforts and achievements and provides positive feedback.

[0368] "Adjusting tone and content to take emotions into account" refers to adjusting the tone and content of feedback depending on the user's emotional state.

[0369] This invention relates to an interactive AI system that combines sentiment analysis when requesting feedback on user-provided content (articles, videos, etc.). This system is implemented using the following hardware and software.

[0370] Hardware and software used

[0371] 1. Hardware

[0372] Server: Receives and processes API requests

[0373] User's device: smartphone, tablet, or PC

[0374] 2. Software

[0375] Natural language processing engine: performs grammar checks, content analysis, and structural analysis of input text

[0376] Sentiment Analysis Engine: Analyzes emotions from user input data

[0377] Database: Stores user profile data and past request history

[0378] Processing flow

[0379] User input:

[0380] The user enters text into the device's input field and presses the send button, for example, "Please review the new article."

[0381] Emotion analysis:

[0382] The emotion analysis engine analyzes the emotion from the user's input data. For example, if the user is feeling stressed, the system will obtain the analysis result as "stress."

[0383] Sending data:

[0384] The user's device sends the input text and the emotion analysis results to the server. The sent data includes the user ID, input text, emotion analysis results, and request type.

[0385] Receiving and parsing the request:

[0386] The server receives the request and passes the input text to a natural language processing engine, which performs grammar checks, content enrichment, and structural analysis.

[0387] Personalization process:

[0388] The server retrieves the user's profile data and past request history from a database and incorporates the results of sentiment analysis into the process. Based on this, the server personalizes the feedback and generates feedback that adapts to the user's emotional state. For example, if the user is feeling stressed, the server will emphasize praise comments and provide feedback with suggestions for improvement in a gentler tone.

[0389] Generate and provide feedback:

[0390] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, praise comments, and emotionally sensitive tone and content adjustments. The device displays the received feedback in its user interface.

[0391] Specific examples

[0392] A user types "Please review a new article" into a content distribution service and uploads the article content. If the emotion engine detects tension, the server generates feedback like this: "This article is very interesting! However, it would be even better if you organized the paragraphs a bit more. Keep up the good work, your efforts are truly impressive."

[0393] Prompt Sentence Examples

[0394] "A user types, 'Please review a new article.' The sentiment analysis engine detects the user's nervousness. It takes into account past review history and provides feedback in a gentle tone. The prompt is:

[0395] "This article is very interesting! However, it could be improved if you organize the paragraphs a bit more. Keep it up, your efforts are truly impressive."

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

[0397] Step 1:

[0398] The user enters text into the input field of the terminal and presses the send button. An example of input text is "Please review the new article." Based on this input, the terminal prepares the input data.

[0399] Step 2:

[0400] Once the user's input data is prepared, the emotion analysis means is activated and analyzes the user's emotions. Here, an emotion analysis engine is used to detect emotions from the text and input speed, and the analysis result is "stress," for example.

[0401] Step 3:

[0402] The device sends the input text and the sentiment analysis results to the server. The data sent includes the user ID, input text, sentiment analysis results, and request type. This data is sent to the server in JSON format.

[0403] Step 4:

[0404] The server parses the incoming request. The server receives the request at the API endpoint and extracts the input text. The input text is passed to a natural language processing engine where grammar checks and structural analysis are performed.

[0405] Step 5:

[0406] The server combines the results of the natural language processing engine and the sentiment analysis to obtain user-specific information, and retrieves the user's profile data and past request history from the database.

[0407] Step 6:

[0408] The server generates personalized feedback based on all data. Depending on the results of sentiment analysis, for example, if the user is feeling "stressed," it will emphasize praise comments and rewrite improvement suggestions in a gentler tone. Feedback sentences are generated using a generative AI model.

[0409] Step 7:

[0410] The server prepares the generated feedback as an API response and sends it to the device, which can include grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[0411] Step 8:

[0412] The device analyzes the received feedback and displays it on the user interface, allowing the user to confirm the feedback and make corrections to the input content.

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

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

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

[0416] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

[0428] 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."

[0429] This invention relates to a conversational AI system that efficiently provides support when a user requests improvements to documents or proposals. This system interacts between a terminal, a server, and the user, and provides personalized feedback to the user.

[0430] System Overview

[0431] 1. User Input

[0432] Users request the system to review documents and proposals via the user interface of their terminal.

[0433] Specifically, the user enters the required information into the text input field and presses the send button to send the request to the terminal.

[0434] 2. Data transmission

[0435] The device sends the user's input data to the server as an API request, which includes the user ID, the input text, and the type of request.

[0436] 3. Receiving and parsing the request

[0437] The server analyzes the received request and passes the text data to a natural language processing engine.

[0438] The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure.

[0439] 4. Personalized processing

[0440] The server looks up the user's profile data and past request history and personalizes the feedback accordingly.

[0441] Generate feedback based on user-specific information, including praise and specific suggestions for improvement.

[0442] 5. Generating and Providing Feedback

[0443] The server compiles the generated feedback and sends it to the device as an API response.

[0444] The terminal displays the received feedback on the user interface so that the user can check it.

[0445] Specific examples

[0446] Consider a case where a user creates a new product proposal, enters "Please review my new product proposal," and presses the submit button.

[0447] 1. User Input

[0448] The user enters "Please review our new product proposal" into the input field on the terminal, and then presses the send button.

[0449] 2. Data transmission

[0450] The terminal sends the input data to the server. The transmitted data includes the user ID, input text, and request type (review request).

[0451] 3. Receiving and parsing the request

[0452] The server receives the request and passes the text data to a natural language processing engine.

[0453] The natural language processing engine performs a grammar check and returns the analysis results to the server, such as, "That's a great suggestion, but it would be even better if you improved the following points."

[0454] 4. Personalized processing

[0455] The server refers to the user's past proposal history and profile data to create optimized feedback for the user.

[0456] 5. Generating and Providing Feedback

[0457] The server generates feedback and sends it to the device, such as: "Great suggestion! I especially like how you highlight the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[0458] The device receives this feedback and displays it in the user interface, where the user can review it and use it to revise the proposal.

[0459] As a result, this system supports users in efficiently improving their documents and proposals, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also helps to increase user motivation.

[0460] The processing flow will be explained below.

[0461] Specific processing of the program

[0462] Step 1: Submitting a request

[0463] 1. A user inputs text through the terminal's user interface to request a review of a document or proposal.

[0464] 2. The user presses the send button, which sends the input data to the terminal.

[0465] Step 2: Prepare your data

[0466] 1. The terminal receives the data entered by the user and checks the format and content of the data.

[0467] 2. The device converts the received data into an API request format and prepares it to be sent to the server.

[0468] Step 3: Sending data

[0469] 1. The device sends a prepared API request to the server, which includes the user ID, input text, and request type.

[0470] Step 4: Receiving the request

[0471] 1. The server receives a request from the device at an API endpoint.

[0472] 2. The server extracts the user ID, input text, and request type from the request and proceeds to the next step.

[0473] Step 5: Performing Natural Language Processing

[0474] 1. The server passes the extracted input text to the natural language processing engine.

[0475] 2. The natural language processing engine checks the text for grammar, analyzes its structure, and tests the logic of its content, and returns the results to the server.

[0476] Step 6: Personalization

[0477] 1. The server retrieves the user's profile data and past request history from the database.

[0478] 2. The server personalizes the analysis results obtained from the natural language processing engine based on the user-specific information obtained.

[0479] Step 7: Feedback Generation

[0480] 1. The server generates personalized feedback, including praise, suggestions for improvement, and specific instructions for correction.

[0481] Step 8: Generate and Send a Response

[0482] 1. The server prepares the generated feedback as a JSON API response.

[0483] 2. The server sends this API response to the device.

[0484] Step 9: Receiving the response

[0485] 1. The device receives the API response from the server.

[0486] 2. The device parses the received data and converts it into a format for display on the user interface.

[0487] Step 10: View feedback

[0488] 1. The device displays the received feedback in the user interface.

[0489] 2. Feedback is presented as praise and specific suggestions for improvement in a format that is easy for users to review.

[0490] Step 11: Review and implement feedback

[0491] 1. The user checks the feedback displayed on the device.

[0492] 2. The user will revise the materials and proposals based on the feedback.

[0493] 3. If necessary, the user can request another review.

[0494] Through the above steps, the "Praise Boss" system provides efficient and personalized feedback to users, helping them improve the quality and efficiency of their work.

[0495] Example 1

[0496] 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."

[0497] Conventional document and proposal review systems have struggled to provide users with personalized feedback quickly and efficiently. Furthermore, general feedback fails to provide specific improvement suggestions that take into account the user's specific needs and past request history, making it insufficient to motivate users or improve their work efficiency. Furthermore, feedback can sometimes be slow to appear, potentially hindering the user's work speed.

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

[0499] In this invention, the server includes means for receiving data input by a user, means for transmitting the received data as an API request, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis result, means for transmitting the generated feedback as an API response, and means for displaying the feedback on a user interface, thereby enabling personalized feedback to be provided to the user quickly and efficiently.

[0500] "User" means an individual or legal entity that uses the system and requests a review.

[0501] "Entered data" refers to textual information and other relevant data that a user sends to the system via a terminal.

[0502] A "terminal" is a device that a user uses to access the system, and is a general communication device including a PC, smartphone, etc.

[0503] An "API request" is a standardized communication procedure for sending data from a terminal to a server, and specifically refers to an HTTP request.

[0504] A "server" is a computer system that handles the back-end processing of the system, receiving input data, analyzing it, and generating feedback.

[0505] A "natural language processing engine" is software used to check the grammar of input data, improve its content, and verify its logical structure, such as a generative AI model.

[0506] "Personalized feedback" is feedback that includes specific and customized suggestions for improvement and praise based on the user's unique information and past request history.

[0507] An "API response" is data sent from a server to a terminal, and is in the form of response data that includes feedback.

[0508] "User interface" refers to an interface for communication between a user and a terminal, and refers to the screen display and operation means by which a user sends input data and checks feedback.

[0509] The present invention relates to a conversational AI system that efficiently provides support when a user requests improvements to documents or proposals. This system interacts between a terminal, a server, and the user, and provides personalized feedback to the user.

[0510] Hardware and software used

[0511] Hardware: Device (PC or smartphone)

[0512] Software: Servers, APIs, natural language processing engines (e.g. GPT-3, BERT)

[0513] System Operation

[0514] The user requests the system to review documents or proposals via the device's user interface. Specifically, the user enters "Please review my new product proposal" in the text input field and presses the submit button. This causes the browser's JavaScript to capture the input data and prepare it to be sent to the API endpoint.

[0515] The device sends the user input data to the server using AJAX. For example, data is sent in the form of axios.post(' / api / review', { userId: '123', text: 'Please review the new product proposal', requestType: 'review'}).

[0516] The server receives the data using the Flask framework and passes the input text data to a natural language processing engine. The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure, and returns the results to the server. For example, it may make suggestions such as, "Make this sentence more concise."

[0517] The server refers to the user's profile data and past request history and provides personalized feedback based on that. Specifically, it retrieves the user's past request history from a database (e.g., PostgreSQL) and generates feedback such as, "Compared to your previous proposal, this one has a clearer logical structure. However, it would be even better if you added a few more concrete examples."

[0518] The server returns the generated feedback to the device in JSON format. For example, a response is generated in the form of return jsonify({'feedback': feedback_text}). The device parses the received data and displays it in the user interface. Using the browser's JavaScript (e.g., React.js), the feedback content is rendered into HTML and displayed to the user as "That's a great suggestion! I especially like how you emphasize the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[0519] This system helps users improve their documents and proposals efficiently, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also motivates users.

[0520] Specific examples

[0521] Consider the case where a user types "Please review our new product proposal" and presses the submit button.

[0522] Example prompt: "Please review this new product proposal. Check for grammar, suggest content improvements, verify logical structure, and provide feedback."

[0523] Requests from users are sent via the server to a natural language processing engine, which returns suggestions for improving grammar and content to the server. The server then references the user's past request history to generate personalized feedback and send it to the device. The device displays this on the user interface, and after the user has confirmed it, they can use it to revise their proposal. This series of operations improves the quality of documents and proposals, as well as business efficiency.

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

[0525] Step 1:

[0526] The user uses the user interface of the terminal to request a review of a document or proposal. Specifically, the user enters "Please review my new product proposal" in the text input field and presses the send button. This operation prepares the input data, including the user ID, text, and request type.

[0527] Input: Text data entered through the user interface

[0528] Output: API request data ready to be sent

[0529] Step 2:

[0530] The device sends the user input data to the server using an AJAX request. This request is sent in the following format: axios.post(' / api / review', { userId: '123', text: 'Please review the new product proposal', requestType: 'review'}). The data is sent as an HTTP POST request.

[0531] Input: API request data from the user ready to be sent

[0532] Output: API request sent to the server

[0533] Step 3:

[0534] The server receives the API request using the Flask framework and parses the input data, which includes the user ID, text, and request type. The server then prepares this data for further processing by the natural language processing engine.

[0535] Input: The API request sent to the server

[0536] Output: Text data that can be sent to a natural language processing engine

[0537] Step 4:

[0538] The server sends a request to the natural language processing engine using the Python library requests. For example, a request is sent as follows: response = requests.post('https: / / api.openai.com / v1 / engines / gpt-3 / completions', data={'text': input_text}). The natural language processing engine performs grammar checks, suggests content improvements, and validates the logical structure, and returns the results to the server.

[0539] Input: Text data sent to the natural language processing engine

[0540] Output: Analysis results returned by the natural language processing engine

[0541] Step 5:

[0542] The server generates personalized feedback based on the analysis results returned by the natural language processing engine, referencing the user's profile data and past request history. It retrieves the user's history from a database (e.g., PostgreSQL) and customizes the feedback. As a result, it generates feedback such as, "Compared to your previous proposal, the logical structure is clearer this time. However, adding a few more concrete examples would be even better."

[0543] Input: Analysis results returned by the natural language processing engine, user profile data, and past request history

[0544] Output: Personalized feedback

[0545] Step 6:

[0546] The server sends the generated feedback to the device in JSON format. For example, feedback is sent in the format return jsonify({'feedback': feedback_text}).

[0547] Input: Personalized Feedback

[0548] Output: JSON-formatted feedback sent to the device

[0549] Step 7:

[0550] The device analyzes the received feedback and displays it in the user interface. Using the browser's JavaScript (e.g., React.js), the feedback is rendered into HTML and displayed in a user-friendly format. The user can view this feedback and use it to revise documents and proposals.

[0551] Input: JSON feedback sent from the server

[0552] Output: Feedback displayed in the user interface

[0553] (Application example 1)

[0554] 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."

[0555] Conventional review systems for documents and proposals often fail to provide optimal feedback to users. Furthermore, they lack the ability to provide real-time feedback, which hinders the efficiency of the content creation process. This makes it difficult to improve the quality of user-created content, and motivating users is also an issue.

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

[0557] In this invention, the server includes means for receiving data input by a user, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis result, means for providing the generated feedback to the user, and means for displaying the feedback in real time, thereby improving the quality of content created by users and making the content creation process more efficient by providing feedback in real time.

[0558] "User-input data" refers to text or information that a user sends to the system via a terminal.

[0559] "Means for receiving" refers to the functions and processes by which the system receives data input by the user.

[0560] A "natural language processing engine" refers to a computer system that analyzes input text data, checks grammar, and suggests content improvements.

[0561] "Means for analysis" refers to the functions and processes for passing received data to a natural language processing engine for analysis.

[0562] "User-specific information" refers to information specific to a user, such as the user's profile data and past request history.

[0563] "Personalized feedback" refers to feedback that is customized based on analysis results and takes into account user-specific information.

[0564] "Means for generating" refers to the functions and processes for creating feedback based on the analysis results and user-specific information.

[0565] "Means of delivery" refers to the functions and processes for delivering the generated feedback to the user.

[0566] "Means for displaying feedback in real time" refers to the functionality or process for displaying generated feedback to the user immediately.

[0567] The present invention is an interactive AI system that allows users to receive reviews of documents and proposals in real time and efficiently improve them. The system includes the following components:

[0568] System configuration

[0569] 1. User Interface

[0570] The device (smartphone or head-mounted display) is the means for receiving data input from the user. The user inputs the contents of documents and proposals through this interface.

[0571] 2. Data Transfer

[0572] The terminal transmits the text data entered by the user to the server. This transmitted data includes the user ID, the entered content, and the type of request (e.g., a review request).

[0573] 3. Natural Language Processing Engine

[0574] The server uses a natural language processing engine to analyze the received text data. This engine checks grammar, suggests content improvements, and analyzes logical structure. The software used includes Python, HTTP requests, and API services.

[0575] 4. Personalized processing

[0576] The server looks at the user's profile data and past request history, and generates personalized feedback based on the analysis, including grammar checks, suggestions for content improvement, and praise comments.

[0577] 5. Providing Feedback

[0578] The generated feedback is sent in real time to the terminal, which displays the feedback on the user interface for the user to review.

[0579] Specific examples

[0580] For example, consider the case where a user creates a new product proposal and sends it by entering "Please review my new product proposal."

[0581] 1. User Input

[0582] The user enters "Please review our new product proposal" into the input field on the terminal, and then presses the send button.

[0583] 2. Data transmission

[0584] The terminal sends the input data to the server. The transmitted data includes the user ID, input text, and request type (review request).

[0585] 3. Receiving and parsing the request

[0586] The server receives the request and passes the text data to a natural language processing engine, which checks grammar, suggests content improvements, verifies logical structure, and returns the analysis results to the server.

[0587] 4. Personalized processing

[0588] The server references past proposal history and profile data to generate tailored feedback for the user, such as, "I particularly like how you emphasized the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[0589] 5. Generating and Providing Feedback

[0590] The server generates feedback and sends it to the device, which displays it in real time on the user interface. The user can then review the feedback and use it to revise their proposal.

[0591] Prompt Sentence Examples

[0592] Below are some example prompts to input to the generative AI model:

[0593] Content Review Request:

[0594] I would like you to review our new product proposal. Please let me know what specific improvements and grammatical errors we should make.

[0595] As described above, this system supports users in efficiently improving their documents and proposals, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also helps to increase user motivation.

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

[0597] Step 1:

[0598] The user enters the content of the document or proposal they wish to evaluate via the device's user interface. Specifically, they enter the required text in the text input field and press the submit button. This generates input data. The input data includes the user ID, the entered content, and the type of request (e.g., a review request).

[0599] Step 2:

[0600] The device sends the text data entered by the user to the server. Specifically, it sends data to an API endpoint using an HTTP request. At this time, the sent data includes the user ID, input text, and request type. Input: Data entered by the user into the device. Output: Data sent to the server.

[0601] Step 3:

[0602] The server passes the received data to the natural language processing engine for analysis. Here, the server generates an API request to analyze the text data and sends it to the natural language processing engine. The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure. Input: Data sent to the server. Output: Data containing the analysis results.

[0603] Step 4:

[0604] The server uses the analysis results received from the natural language processing engine to personalize feedback using user-specific information. Specifically, it references the user's profile data and past request history to generate praise comments and specific improvement measures based on the analysis results. Input: Analysis results from the natural language processing engine and user profile data. Output: Personalized feedback.

[0605] Step 5:

[0606] The server compiles the generated personalized feedback and sends it to the device. Specifically, it returns the feedback data to the device via the API as an HTTP response. Input: Personalized feedback. Output: Feedback data displayed in the user interface.

[0607] Step 6:

[0608] The terminal displays the received feedback data in the user interface in real time. Specifically, it allows the user to check the feedback and use it to revise documents and proposals. Input: Feedback data sent from the server. Output: Feedback displayed on the user interface.

[0609] Through the above processing steps, users can receive personalized feedback in real time, enabling them to efficiently improve their materials and proposals.

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

[0611] This invention relates to a conversational AI system that provides efficient and personalized feedback when users request improvements to documents or proposals. This system provides more appropriate feedback by incorporating an emotion engine that analyzes the user's emotions.

[0612] System Overview

[0613] 1. User Input

[0614] Users can request a review of documents or proposals from the system via the user interface on their device. At this time, the emotion engine also performs emotion analysis based on the user's input data.

[0615] 2. Data transmission

[0616] The device converts the user's input data and the emotion analysis results from the emotion engine into an API request format and sends it to the server. The transmitted data includes the user ID, input text, emotion analysis results, and the type of request.

[0617] 3. Receiving and parsing the request

[0618] The server receives requests from the device at the API endpoint and extracts the user ID, input text, sentiment analysis results, and request type from the request.

[0619] The server passes the received input text to a natural language processing engine for grammar checking, content analysis, and structural analysis.

[0620] 4. Personalized processing

[0621] The server retrieves the user's profile data and past request history from a database, and also incorporates the results of sentiment analysis into the process.

[0622] Based on the acquired information, the server personalizes the analysis results obtained from the natural language processing engine and generates feedback that is adapted to the user's current emotions.

[0623] 5. Generating and Providing Feedback

[0624] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[0625] It sends API responses to the device and displays the received feedback in the user interface.

[0626] Specific examples

[0627] Consider a case where a user creates a new product proposal, enters "Please review my new product proposal," and presses the send button. Here we will explain in detail what happens if the emotion engine detects that the user is feeling stressed.

[0628] 1. User Input

[0629] The user enters "Please review our new product proposal" into the text input field on the terminal and presses the send button.

[0630] The emotion engine analyzes the user's emotions based on the input content, input speed, and text, and detects "stress."

[0631] 2. Data transmission

[0632] The device sends the input text and the emotion analysis results to the server. The transmitted data includes the user ID, input text, stress emotion, and request type.

[0633] 3. Receiving and parsing the request

[0634] The server receives the request and passes the input text to a natural language processing engine, which performs grammar checks, content enrichment, and structural analysis.

[0635] 4. Personalized processing

[0636] The server references the user's profile data, past request history, and sentiment analysis results, and uses this information to personalize feedback.

[0637] If the user is stressed, tailor your feedback to emphasize praise comments and offer suggestions for improvement in a gentle tone.

[0638] 5. Generating and Providing Feedback

[0639] The server generates feedback like this and sends it to the device: "This new product proposal is excellent! It really highlights the specific benefits. However, it could be even better if you were a bit more specific in some sections. Good luck, we're really looking forward to your proposal."

[0640] The device receives this feedback and displays it in the user interface, where the user can review it and use it to revise the proposal.

[0641] As a result, by combining this system with an emotion engine, it is possible to provide appropriate and personalized feedback according to the user's emotional state, which not only improves work efficiency but also contributes to maintaining the user's mental health.

[0642] The processing flow will be explained below.

[0643] Specific processing of the program

[0644] Step 1: Submitting a request

[0645] 1. A user inputs text through the terminal's user interface to request a review of a document or proposal.

[0646] 2. When the user has finished entering data, they press the send button, which sends the data to the terminal.

[0647] 3. At the same time, the emotion engine analyzes the user's input data and determines the emotional state (e.g., stress, joy, sadness, etc.).

[0648] Step 2: Prepare your data

[0649] 1. The device receives data entered by the user and the analysis results of the emotion engine.

[0650] 2. The device converts the received data into an API request format and prepares it to be sent to the server.

[0651] 3. The converted data includes the user ID, input text, sentiment analysis results, and request type.

[0652] Step 3: Sending data

[0653] 1. The device sends a prepared API request to the server, which includes the user ID, input text, sentiment analysis results, and request type.

[0654] Step 4: Receiving the request

[0655] 1. The server receives a request from the device at an API endpoint.

[0656] 2. The server extracts the user ID, input text, sentiment analysis results, and request type from the request and retrieves the necessary data.

[0657] Step 5: Performing Natural Language Processing

[0658] 1. The server passes the extracted input text to the natural language processing engine.

[0659] 2. The natural language processing engine checks the text for grammar, analyzes its structure, and tests the logic of its content, and returns the analysis results to the server.

[0660] Step 6: Personalization

[0661] 1. The server retrieves the user's profile data and past request history from the database.

[0662] 2. The server also refers to the emotion analysis results and personalizes the feedback based on the user's current emotional state.

[0663] 3. Based on the acquired information, the server integrates the analysis results obtained from the natural language processing engine and generates optimized feedback for the user.

[0664] Step 7: Feedback Generation

[0665] 1. The server generates personalized feedback, including praise, suggestions for improvement, and specific instructions for correction.

[0666] 2. Based on the results of the emotion analysis, the tone and content of the feedback are adjusted to suit the user's emotional state.

[0667] Step 8: Generate and Send a Response

[0668] 1. The server prepares the generated feedback as a JSON API response.

[0669] 2. The server sends this API response to the device, which includes grammar check results, suggestions for content improvement, praise comments, and emotional feedback.

[0670] Step 9: Receiving the response

[0671] 1. The device receives the API response from the server.

[0672] 2. The device parses the received data and converts it into a format for display on the user interface.

[0673] Step 10: View feedback

[0674] 1. The device displays the received feedback in the user interface.

[0675] 2. Feedback is presented as praise and specific suggestions for improvement in a format that is easy for users to review.

[0676] 3. Emotion-responsive feedback is also displayed, providing content that corresponds to the user's emotional state.

[0677] Step 11: Review and implement feedback

[0678] 1. The user checks the feedback displayed on the device.

[0679] 2. The user will revise the materials and proposals based on the feedback.

[0680] 3. If necessary, the user can request another review.

[0681] Through the above steps, the "Praise Boss" system, combined with the emotion engine, provides efficient and personalized feedback that adapts to the user's emotional state, not only improving the quality and efficiency of work but also contributing to maintaining the user's mental health.

[0682] Example 2

[0683] 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."

[0684] In modern document creation and proposal writing, systems that can provide efficient and personalized feedback are required. However, existing systems cannot take into account the user's emotional state, making it difficult to provide appropriate feedback that reduces the user's stress and anxiety.

[0685] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving data input by a user, a means for passing the received data to a natural language processing engine for analysis, a means for generating personalized feedback using user-specific information based on the analysis result and the emotion analysis result, and a means for providing the generated feedback to the user. This makes it possible to provide appropriate and personalized feedback according to the user's emotional state.

[0686] "User" refers to a person who uses this system to request a review of materials or proposals.

[0687] "Input data" refers to text information provided by a user to the system via a terminal.

[0688] A "natural language processing engine" refers to software or algorithms that analyze received text data and check its grammar and improve its content.

[0689] "Analysis results" are the results of analyzing text data generated by a natural language processing engine, and include information on grammar checks and suggestions for content improvement.

[0690] "Emotion analysis results" refers to information about the emotional state extracted from the user's input data by the emotion engine.

[0691] "User-specific information" refers to data related to an individual user, including past request history, user profile data, sentiment analysis results, and the like.

[0692] "Personalized feedback" refers to responses or advice that are customized based on the user's unique information and emotional state.

[0693] "Means of providing" refers to the functions and processes for communicating the generated feedback to the user.

[0694] "System" is a collective term for a set of devices and software that analyzes user input data and provides personalized feedback.

[0695] This invention relates to a conversational AI system that provides efficient and personalized feedback when users request improvements to documents or proposals. This system provides more appropriate feedback by incorporating an emotion engine that analyzes the user's emotions.

[0696] The system is configured as follows:

[0697] 1. User Input

[0698] A user requests a review of a document or proposal from the system via the device's user interface. In practice, the user enters "Please review my new product proposal" into the device's text input field and presses the send button. At this time, the emotion engine analyzes the user's emotional state (e.g., stress, anxiety) in real time based on the input content, input speed, and selected words.

[0699] 2. Data transmission

[0700] The device converts the user's input text and the emotion analysis results from the emotion engine into an API request format and sends it to the server. The transmitted data includes the user ID, input text, emotion analysis results (e.g., stress), and the type of request. The API request is in JSON format and is sent to the server via the device's communication module over the Internet.

[0701] 3. Receiving and parsing the request

[0702] The server receives requests sent from the device via the API endpoint. It analyzes the received request and extracts the user ID, input text, sentiment analysis results, and request type. The server then passes the input text to a natural language processing engine (e.g., GPT-3) for grammar check, content analysis, and structure analysis.

[0703] 4. Personalized processing

[0704] The server retrieves the user's profile data and past request history from the database. Based on all of this information, including the results of sentiment analysis, the analysis results obtained from the natural language processing engine are personalized. Specifically, feedback is generated that adapts to the user's emotional state. For example, if the user is feeling stressed, the feedback is adjusted to emphasize praise comments and provide suggestions for improvement in a gentler tone.

[0705] 5. Generating and Providing Feedback

[0706] The server prepares the generated feedback as a JSON-formatted API response and sends it to the device. The feedback includes grammar check results, suggestions for content improvement, praise comments, and adjustments to tone and content to take into account emotions. The device receives the API response and displays it on the user interface. The user can review the feedback and use it to revise their materials or proposals.

[0707] Specific examples

[0708] A specific example will be described in which a user creates a new product proposal, enters "Please review my new product proposal," and presses the send button.

[0709] Example prompt: "Please review our new product proposal. Please provide feedback in a friendly tone on the overall flow and structure of the content."

[0710] By combining this with an emotion engine, the system provides appropriate and personalized feedback based on the user's emotional state, thereby improving work efficiency and contributing to maintaining the user's mental health.

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

[0712] Step 1:

[0713] The user enters text into the device's text input field and presses the send button. The emotion engine analyzes the user's emotions in real time based on their input content, speed, and selected words.

[0714] Input: User input text, such as "Please review our new product proposal."

[0715] Output: Input text and parsed emotional state (e.g., stress)

[0716] Step 2:

[0717] The device receives the user's input text and the emotion analysis results from the emotion engine, and converts them into an API request format, which includes the user ID, input text, emotion analysis results, and request type.

[0718] Input: Input text and sentiment analysis results obtained in Step 1

[0719] Output: API request (JSON format)

[0720] Step 3:

[0721] The device sends an API request to the server, which then communicates to confirm that the request has been sent.

[0722] Input: API request

[0723] Output: Sending status (success / failure)

[0724] Step 4:

[0725] The server receives the request sent from the device at the API endpoint, analyzes the request content, and extracts the user ID, input text, sentiment analysis results, and request type.

[0726] Input: The API request received

[0727] Output: Extracted data (user ID, input text, sentiment analysis results, request type)

[0728] Step 5:

[0729] The server passes the extracted input text to a natural language processing engine to perform grammar checks, content analysis, and structure analysis. The natural language processing engine (e.g., GPT-3) analyzes the received text data and generates grammar check results and content improvement suggestions.

[0730] Input: Data (input text)

[0731] Output: Analysis results (grammar check results, content improvement suggestions)

[0732] Step 6:

[0733] The server retrieves user profile data and past request history from the database, and also takes into account sentiment analysis results to personalize feedback.

[0734] Input: Analysis results, user ID, emotion analysis results

[0735] Output: personalized feedback data

[0736] Step 7:

[0737] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[0738] Input: Personalized feedback data

[0739] Output: API response (JSON format)

[0740] Step 8:

[0741] The server sends the API response to the device, which receives the response and displays the feedback in the user interface.

[0742] Input: API response

[0743] Output: Feedback displayed in the user interface

[0744] (Application example 2)

[0745] 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."

[0746] In conventional content distribution services, when users request feedback on content such as articles or videos they have entered, the content of the feedback is often inappropriate for the user's situation or emotions because the user's emotional state is not taken into consideration.In addition, the feedback content is often too general and does not address the individual user's requests or emotions, leaving users dissatisfied.

[0747] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving data input by a user, emotion analysis means for analyzing emotions from the user's input data, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis results and emotion analysis results, and means for providing the generated feedback to the user. This makes it possible to generate and provide feedback tailored to the user's emotional state in real time.

[0748] "User-input data" refers to information that a user provides to the system as text or content.

[0749] "Emotion analysis means" is a function that detects and analyzes the user's emotional state from the input data and behavior of the user.

[0750] A "natural language processing engine" is an engine that analyzes input text and performs processes such as grammar checks and content improvement.

[0751] "User-specific information" is information that is individually associated with a user, such as the user's profile data and past request history.

[0752] "Personalized feedback" is feedback that is adapted to an individual user based on analysis results and user-specific information.

[0753] The "means for providing feedback to the user" is a function for displaying or notifying the user of the generated feedback.

[0754] "Grammar checking" is the process of detecting grammatical errors in text and providing suggested corrections.

[0755] "Content Improvement Suggestions" are specific advice or suggestions for improving the quality of text or content.

[0756] A "praise comment" is a comment that recognizes a user's efforts and achievements and provides positive feedback.

[0757] "Adjusting tone and content to take emotions into account" refers to adjusting the tone and content of feedback depending on the user's emotional state.

[0758] This invention relates to an interactive AI system that combines sentiment analysis when requesting feedback on user-provided content (articles, videos, etc.). This system is implemented using the following hardware and software.

[0759] Hardware and software used

[0760] 1. Hardware

[0761] Server: Receives and processes API requests

[0762] User's device: smartphone, tablet, or PC

[0763] 2. Software

[0764] Natural language processing engine: performs grammar checks, content analysis, and structural analysis of input text

[0765] Sentiment Analysis Engine: Analyzes emotions from user input data

[0766] Database: Stores user profile data and past request history

[0767] Processing flow

[0768] User input:

[0769] The user enters text into the device's input field and presses the send button, for example, "Please review the new article."

[0770] Emotion analysis:

[0771] The emotion analysis engine analyzes the emotion from the user's input data. For example, if the user is feeling stressed, the system will obtain the analysis result as "stress."

[0772] Sending data:

[0773] The user's device sends the input text and the emotion analysis results to the server. The sent data includes the user ID, input text, emotion analysis results, and request type.

[0774] Receiving and parsing the request:

[0775] The server receives the request and passes the input text to a natural language processing engine, which performs grammar checks, content enrichment, and structural analysis.

[0776] Personalization process:

[0777] The server retrieves the user's profile data and past request history from a database and incorporates the results of sentiment analysis into the process. Based on this, the server personalizes the feedback and generates feedback that adapts to the user's emotional state. For example, if the user is feeling stressed, the server will emphasize praise comments and provide feedback with suggestions for improvement in a gentler tone.

[0778] Generate and provide feedback:

[0779] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, praise comments, and emotionally sensitive tone and content adjustments. The device displays the received feedback in its user interface.

[0780] Specific examples

[0781] A user types "Please review a new article" into a content distribution service and uploads the article content. If the emotion engine detects tension, the server generates feedback like this: "This article is very interesting! However, it would be even better if you organized the paragraphs a bit more. Keep up the good work, your efforts are truly impressive."

[0782] Prompt Sentence Examples

[0783] "A user types, 'Please review a new article.' The sentiment analysis engine detects the user's nervousness. It takes into account past review history and provides feedback in a gentle tone. The prompt is:

[0784] "This article is very interesting! However, it could be improved if you organize the paragraphs a bit more. Keep it up, your efforts are truly impressive."

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

[0786] Step 1:

[0787] The user enters text into the input field of the terminal and presses the send button. An example of input text is "Please review the new article." Based on this input, the terminal prepares the input data.

[0788] Step 2:

[0789] Once the user's input data is prepared, the emotion analysis means is activated and analyzes the user's emotions. Here, an emotion analysis engine is used to detect emotions from the text and input speed, and the analysis result is "stress," for example.

[0790] Step 3:

[0791] The device sends the input text and the sentiment analysis results to the server. The data sent includes the user ID, input text, sentiment analysis results, and request type. This data is sent to the server in JSON format.

[0792] Step 4:

[0793] The server parses the incoming request. The server receives the request at the API endpoint and extracts the input text. The input text is passed to a natural language processing engine where grammar checks and structural analysis are performed.

[0794] Step 5:

[0795] The server combines the results of the natural language processing engine and the sentiment analysis to obtain user-specific information, and retrieves the user's profile data and past request history from the database.

[0796] Step 6:

[0797] The server generates personalized feedback based on all data. Depending on the results of sentiment analysis, for example, if the user is feeling "stressed," it will emphasize praise comments and rewrite improvement suggestions in a gentler tone. Feedback sentences are generated using a generative AI model.

[0798] Step 7:

[0799] The server prepares the generated feedback as an API response and sends it to the device, which can include grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[0800] Step 8:

[0801] The device analyzes the received feedback and displays it on the user interface, allowing the user to confirm the feedback and make corrections to the input content.

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

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

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

[0805] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

[0817] 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."

[0818] This invention relates to a conversational AI system that efficiently provides support when a user requests improvements to documents or proposals. This system interacts between a terminal, a server, and the user, and provides personalized feedback to the user.

[0819] System Overview

[0820] 1. User Input

[0821] Users request the system to review documents and proposals via the user interface of their terminal.

[0822] Specifically, the user enters the required information into the text input field and presses the send button to send the request to the terminal.

[0823] 2. Data transmission

[0824] The device sends the user's input data to the server as an API request, which includes the user ID, the input text, and the type of request.

[0825] 3. Receiving and parsing the request

[0826] The server analyzes the received request and passes the text data to a natural language processing engine.

[0827] The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure.

[0828] 4. Personalized processing

[0829] The server looks up the user's profile data and past request history and personalizes the feedback accordingly.

[0830] Generate feedback based on user-specific information, including praise and specific suggestions for improvement.

[0831] 5. Generating and Providing Feedback

[0832] The server compiles the generated feedback and sends it to the device as an API response.

[0833] The terminal displays the received feedback on the user interface so that the user can check it.

[0834] Specific examples

[0835] Consider a case where a user creates a new product proposal, enters "Please review my new product proposal," and presses the submit button.

[0836] 1. User Input

[0837] The user enters "Please review our new product proposal" into the input field on the terminal, and then presses the send button.

[0838] 2. Data transmission

[0839] The terminal sends the input data to the server. The transmitted data includes the user ID, input text, and request type (review request).

[0840] 3. Receiving and parsing the request

[0841] The server receives the request and passes the text data to a natural language processing engine.

[0842] The natural language processing engine performs a grammar check and returns the analysis results to the server, such as, "That's a great suggestion, but it would be even better if you improved the following points."

[0843] 4. Personalized processing

[0844] The server refers to the user's past proposal history and profile data to create optimized feedback for the user.

[0845] 5. Generating and Providing Feedback

[0846] The server generates feedback and sends it to the device, such as: "Great suggestion! I especially like how you highlight the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[0847] The device receives this feedback and displays it in the user interface, where the user can review it and use it to revise the proposal.

[0848] As a result, this system supports users in efficiently improving their documents and proposals, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also helps to increase user motivation.

[0849] The processing flow will be explained below.

[0850] Specific processing of the program

[0851] Step 1: Submitting a request

[0852] 1. A user inputs text through the terminal's user interface to request a review of a document or proposal.

[0853] 2. The user presses the send button, which sends the input data to the terminal.

[0854] Step 2: Prepare your data

[0855] 1. The terminal receives the data entered by the user and checks the format and content of the data.

[0856] 2. The device converts the received data into an API request format and prepares it to be sent to the server.

[0857] Step 3: Sending data

[0858] 1. The device sends a prepared API request to the server, which includes the user ID, input text, and request type.

[0859] Step 4: Receiving the request

[0860] 1. The server receives a request from the device at an API endpoint.

[0861] 2. The server extracts the user ID, input text, and request type from the request and proceeds to the next step.

[0862] Step 5: Performing Natural Language Processing

[0863] 1. The server passes the extracted input text to the natural language processing engine.

[0864] 2. The natural language processing engine checks the text for grammar, analyzes its structure, and tests the logic of its content, and returns the results to the server.

[0865] Step 6: Personalization

[0866] 1. The server retrieves the user's profile data and past request history from the database.

[0867] 2. The server personalizes the analysis results obtained from the natural language processing engine based on the user-specific information obtained.

[0868] Step 7: Feedback Generation

[0869] 1. The server generates personalized feedback, including praise, suggestions for improvement, and specific instructions for correction.

[0870] Step 8: Generate and Send a Response

[0871] 1. The server prepares the generated feedback as a JSON API response.

[0872] 2. The server sends this API response to the device.

[0873] Step 9: Receiving the response

[0874] 1. The device receives the API response from the server.

[0875] 2. The device parses the received data and converts it into a format for display on the user interface.

[0876] Step 10: View feedback

[0877] 1. The device displays the received feedback in the user interface.

[0878] 2. Feedback is presented as praise and specific suggestions for improvement in a format that is easy for users to review.

[0879] Step 11: Review and implement feedback

[0880] 1. The user checks the feedback displayed on the device.

[0881] 2. The user will revise the materials and proposals based on the feedback.

[0882] 3. If necessary, the user can request another review.

[0883] Through the above steps, the "Praise Boss" system provides efficient and personalized feedback to users, helping them improve the quality and efficiency of their work.

[0884] Example 1

[0885] 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."

[0886] Conventional document and proposal review systems have struggled to provide users with personalized feedback quickly and efficiently. Furthermore, general feedback fails to provide specific improvement suggestions that take into account the user's specific needs and past request history, making it insufficient to motivate users or improve their work efficiency. Furthermore, feedback can sometimes be slow to appear, potentially hindering the user's work speed.

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

[0888] In this invention, the server includes means for receiving data input by a user, means for transmitting the received data as an API request, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis result, means for transmitting the generated feedback as an API response, and means for displaying the feedback on a user interface, thereby enabling personalized feedback to be provided to the user quickly and efficiently.

[0889] "User" means an individual or legal entity that uses the system and requests a review.

[0890] "Entered data" refers to textual information and other relevant data that a user sends to the system via a terminal.

[0891] A "terminal" is a device that a user uses to access the system, and is a general communication device including a PC, smartphone, etc.

[0892] An "API request" is a standardized communication procedure for sending data from a terminal to a server, and specifically refers to an HTTP request.

[0893] A "server" is a computer system that handles the back-end processing of the system, receiving input data, analyzing it, and generating feedback.

[0894] A "natural language processing engine" is software used to check the grammar of input data, improve its content, and verify its logical structure, such as a generative AI model.

[0895] "Personalized feedback" is feedback that includes specific and customized suggestions for improvement and praise based on the user's unique information and past request history.

[0896] An "API response" is data sent from a server to a terminal, and is in the form of response data that includes feedback.

[0897] "User interface" refers to an interface for communication between a user and a terminal, and refers to the screen display and operation means by which a user sends input data and checks feedback.

[0898] The present invention relates to a conversational AI system that efficiently provides support when a user requests improvements to documents or proposals. This system interacts between a terminal, a server, and the user, and provides personalized feedback to the user.

[0899] Hardware and software used

[0900] Hardware: Device (PC or smartphone)

[0901] Software: Servers, APIs, natural language processing engines (e.g. GPT-3, BERT)

[0902] System Operation

[0903] The user requests the system to review documents or proposals via the device's user interface. Specifically, the user enters "Please review my new product proposal" in the text input field and presses the submit button. This causes the browser's JavaScript to capture the input data and prepare it to be sent to the API endpoint.

[0904] The device sends the user input data to the server using AJAX. For example, data is sent in the form of axios.post(' / api / review', { userId: '123', text: 'Please review the new product proposal', requestType: 'review'}).

[0905] The server receives the data using the Flask framework and passes the input text data to a natural language processing engine. The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure, and returns the results to the server. For example, it may make suggestions such as, "Make this sentence more concise."

[0906] The server refers to the user's profile data and past request history and provides personalized feedback based on that. Specifically, it retrieves the user's past request history from a database (e.g., PostgreSQL) and generates feedback such as, "Compared to your previous proposal, this one has a clearer logical structure. However, it would be even better if you added a few more concrete examples."

[0907] The server returns the generated feedback to the device in JSON format. For example, a response is generated in the form of return jsonify({'feedback': feedback_text}). The device parses the received data and displays it in the user interface. Using the browser's JavaScript (e.g., React.js), the feedback content is rendered into HTML and displayed to the user as "That's a great suggestion! I especially like how you emphasize the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[0908] This system helps users improve their documents and proposals efficiently, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also motivates users.

[0909] Specific examples

[0910] Consider the case where a user types "Please review our new product proposal" and presses the submit button.

[0911] Example prompt: "Please review this new product proposal. Check for grammar, suggest content improvements, verify logical structure, and provide feedback."

[0912] Requests from users are sent via the server to a natural language processing engine, which returns suggestions for improving grammar and content to the server. The server then references the user's past request history to generate personalized feedback and send it to the device. The device displays this on the user interface, and after the user has confirmed it, they can use it to revise their proposal. This series of operations improves the quality of documents and proposals, as well as business efficiency.

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

[0914] Step 1:

[0915] The user uses the user interface of the terminal to request a review of a document or proposal. Specifically, the user enters "Please review my new product proposal" in the text input field and presses the send button. This operation prepares the input data, including the user ID, text, and request type.

[0916] Input: Text data entered through the user interface

[0917] Output: API request data ready to be sent

[0918] Step 2:

[0919] The device sends the user input data to the server using an AJAX request. This request is sent in the following format: axios.post(' / api / review', { userId: '123', text: 'Please review the new product proposal', requestType: 'review'}). The data is sent as an HTTP POST request.

[0920] Input: API request data from the user ready to be sent

[0921] Output: API request sent to the server

[0922] Step 3:

[0923] The server receives the API request using the Flask framework and parses the input data, which includes the user ID, text, and request type. The server then prepares this data for further processing by the natural language processing engine.

[0924] Input: The API request sent to the server

[0925] Output: Text data that can be sent to a natural language processing engine

[0926] Step 4:

[0927] The server sends a request to the natural language processing engine using the Python library requests. For example, a request is sent as follows: response = requests.post('https: / / api.openai.com / v1 / engines / gpt-3 / completions', data={'text': input_text}). The natural language processing engine performs grammar checks, suggests content improvements, and validates the logical structure, and returns the results to the server.

[0928] Input: Text data sent to the natural language processing engine

[0929] Output: Analysis results returned by the natural language processing engine

[0930] Step 5:

[0931] The server generates personalized feedback based on the analysis results returned by the natural language processing engine, referencing the user's profile data and past request history. It retrieves the user's history from a database (e.g., PostgreSQL) and customizes the feedback. As a result, it generates feedback such as, "Compared to your previous proposal, the logical structure is clearer this time. However, adding a few more concrete examples would be even better."

[0932] Input: Analysis results returned by the natural language processing engine, user profile data, and past request history

[0933] Output: Personalized feedback

[0934] Step 6:

[0935] The server sends the generated feedback to the device in JSON format. For example, feedback is sent in the format return jsonify({'feedback': feedback_text}).

[0936] Input: Personalized Feedback

[0937] Output: JSON-formatted feedback sent to the device

[0938] Step 7:

[0939] The device analyzes the received feedback and displays it in the user interface. Using the browser's JavaScript (e.g., React.js), the feedback is rendered into HTML and displayed in a user-friendly format. The user can view this feedback and use it to revise documents and proposals.

[0940] Input: JSON feedback sent from the server

[0941] Output: Feedback displayed in the user interface

[0942] (Application example 1)

[0943] 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."

[0944] Conventional review systems for documents and proposals often fail to provide optimal feedback to users. Furthermore, they lack the ability to provide real-time feedback, which hinders the efficiency of the content creation process. This makes it difficult to improve the quality of user-created content, and motivating users is also an issue.

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

[0946] In this invention, the server includes means for receiving data input by a user, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis result, means for providing the generated feedback to the user, and means for displaying the feedback in real time, thereby improving the quality of content created by users and making the content creation process more efficient by providing feedback in real time.

[0947] "User-input data" refers to text or information that a user sends to the system via a terminal.

[0948] "Means for receiving" refers to the functions and processes by which the system receives data input by the user.

[0949] A "natural language processing engine" refers to a computer system that analyzes input text data, checks grammar, and suggests content improvements.

[0950] "Means for analysis" refers to the functions and processes for passing received data to a natural language processing engine for analysis.

[0951] "User-specific information" refers to information specific to a user, such as the user's profile data and past request history.

[0952] "Personalized feedback" refers to feedback that is customized based on analysis results and takes into account user-specific information.

[0953] "Means for generating" refers to the functions and processes for creating feedback based on the analysis results and user-specific information.

[0954] "Means of delivery" refers to the functions and processes for delivering the generated feedback to the user.

[0955] "Means for displaying feedback in real time" refers to the functionality or process for displaying generated feedback to the user immediately.

[0956] The present invention is an interactive AI system that allows users to receive reviews of documents and proposals in real time and efficiently improve them. The system includes the following components:

[0957] System configuration

[0958] 1. User Interface

[0959] The device (smartphone or head-mounted display) is the means for receiving data input from the user. The user inputs the contents of documents and proposals through this interface.

[0960] 2. Data Transfer

[0961] The terminal transmits the text data entered by the user to the server. This transmitted data includes the user ID, the entered content, and the type of request (e.g., a review request).

[0962] 3. Natural Language Processing Engine

[0963] The server uses a natural language processing engine to analyze the received text data. This engine checks grammar, suggests content improvements, and analyzes logical structure. The software used includes Python, HTTP requests, and API services.

[0964] 4. Personalized processing

[0965] The server looks at the user's profile data and past request history, and generates personalized feedback based on the analysis, including grammar checks, suggestions for content improvement, and praise comments.

[0966] 5. Providing Feedback

[0967] The generated feedback is sent in real time to the terminal, which displays the feedback on the user interface for the user to review.

[0968] Specific examples

[0969] For example, consider the case where a user creates a new product proposal and sends it by entering "Please review my new product proposal."

[0970] 1. User Input

[0971] The user enters "Please review our new product proposal" into the input field on the terminal, and then presses the send button.

[0972] 2. Data transmission

[0973] The terminal sends the input data to the server. The transmitted data includes the user ID, input text, and request type (review request).

[0974] 3. Receiving and parsing the request

[0975] The server receives the request and passes the text data to a natural language processing engine, which checks grammar, suggests content improvements, verifies logical structure, and returns the analysis results to the server.

[0976] 4. Personalized processing

[0977] The server references past proposal history and profile data to generate tailored feedback for the user, such as, "I particularly like how you emphasized the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[0978] 5. Generating and Providing Feedback

[0979] The server generates feedback and sends it to the device, which displays it in real time on the user interface. The user can then review the feedback and use it to revise their proposal.

[0980] Prompt Sentence Examples

[0981] Below are some example prompts to input to the generative AI model:

[0982] Content Review Request:

[0983] I would like you to review our new product proposal. Please let me know what specific improvements and grammatical errors we should make.

[0984] As described above, this system supports users in efficiently improving their documents and proposals, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also helps to increase user motivation.

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

[0986] Step 1:

[0987] The user enters the content of the document or proposal they wish to evaluate via the device's user interface. Specifically, they enter the required text in the text input field and press the submit button. This generates input data. The input data includes the user ID, the entered content, and the type of request (e.g., a review request).

[0988] Step 2:

[0989] The device sends the text data entered by the user to the server. Specifically, it sends data to an API endpoint using an HTTP request. At this time, the sent data includes the user ID, input text, and request type. Input: Data entered by the user into the device. Output: Data sent to the server.

[0990] Step 3:

[0991] The server passes the received data to the natural language processing engine for analysis. Here, the server generates an API request to analyze the text data and sends it to the natural language processing engine. The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure. Input: Data sent to the server. Output: Data containing the analysis results.

[0992] Step 4:

[0993] The server uses the analysis results received from the natural language processing engine to personalize feedback using user-specific information. Specifically, it references the user's profile data and past request history to generate praise comments and specific improvement measures based on the analysis results. Input: Analysis results from the natural language processing engine and user profile data. Output: Personalized feedback.

[0994] Step 5:

[0995] The server compiles the generated personalized feedback and sends it to the device. Specifically, it returns the feedback data to the device via the API as an HTTP response. Input: Personalized feedback. Output: Feedback data displayed in the user interface.

[0996] Step 6:

[0997] The terminal displays the received feedback data in the user interface in real time. Specifically, it allows the user to check the feedback and use it to revise documents and proposals. Input: Feedback data sent from the server. Output: Feedback displayed on the user interface.

[0998] Through the above processing steps, users can receive personalized feedback in real time, enabling them to efficiently improve their materials and proposals.

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

[1000] This invention relates to a conversational AI system that provides efficient and personalized feedback when users request improvements to documents or proposals. This system provides more appropriate feedback by incorporating an emotion engine that analyzes the user's emotions.

[1001] System Overview

[1002] 1. User Input

[1003] Users can request a review of documents or proposals from the system via the user interface on their device. At this time, the emotion engine also performs emotion analysis based on the user's input data.

[1004] 2. Data transmission

[1005] The device converts the user's input data and the emotion analysis results from the emotion engine into an API request format and sends it to the server. The transmitted data includes the user ID, input text, emotion analysis results, and the type of request.

[1006] 3. Receiving and parsing the request

[1007] The server receives requests from the device at the API endpoint and extracts the user ID, input text, sentiment analysis results, and request type from the request.

[1008] The server passes the received input text to a natural language processing engine for grammar checking, content analysis, and structural analysis.

[1009] 4. Personalized processing

[1010] The server retrieves the user's profile data and past request history from a database, and also incorporates the results of sentiment analysis into the process.

[1011] Based on the acquired information, the server personalizes the analysis results obtained from the natural language processing engine and generates feedback that is adapted to the user's current emotions.

[1012] 5. Generating and Providing Feedback

[1013] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[1014] It sends API responses to the device and displays the received feedback in the user interface.

[1015] Specific examples

[1016] Consider a case where a user creates a new product proposal, enters "Please review my new product proposal," and presses the send button. Here we will explain in detail what happens if the emotion engine detects that the user is feeling stressed.

[1017] 1. User Input

[1018] The user enters "Please review our new product proposal" into the text input field on the terminal and presses the send button.

[1019] The emotion engine analyzes the user's emotions based on the input content, input speed, and text, and detects "stress."

[1020] 2. Data transmission

[1021] The device sends the input text and the emotion analysis results to the server. The transmitted data includes the user ID, input text, stress emotion, and request type.

[1022] 3. Receiving and parsing the request

[1023] The server receives the request and passes the input text to a natural language processing engine, which performs grammar checks, content enrichment, and structural analysis.

[1024] 4. Personalized processing

[1025] The server references the user's profile data, past request history, and sentiment analysis results, and uses this information to personalize feedback.

[1026] If the user is stressed, tailor your feedback to emphasize praise comments and offer suggestions for improvement in a gentle tone.

[1027] 5. Generating and Providing Feedback

[1028] The server generates feedback like this and sends it to the device: "This new product proposal is excellent! It really highlights the specific benefits. However, it could be even better if you were a bit more specific in some sections. Good luck, we're really looking forward to your proposal."

[1029] The device receives this feedback and displays it in the user interface, where the user can review it and use it to revise the proposal.

[1030] As a result, by combining this system with an emotion engine, it is possible to provide appropriate and personalized feedback according to the user's emotional state, which not only improves work efficiency but also contributes to maintaining the user's mental health.

[1031] The processing flow will be explained below.

[1032] Specific processing of the program

[1033] Step 1: Submitting a request

[1034] 1. A user inputs text through the terminal's user interface to request a review of a document or proposal.

[1035] 2. When the user has finished entering data, they press the send button, which sends the data to the terminal.

[1036] 3. At the same time, the emotion engine analyzes the user's input data and determines the emotional state (e.g., stress, joy, sadness, etc.).

[1037] Step 2: Prepare your data

[1038] 1. The device receives data entered by the user and the analysis results of the emotion engine.

[1039] 2. The device converts the received data into an API request format and prepares it to be sent to the server.

[1040] 3. The converted data includes the user ID, input text, sentiment analysis results, and request type.

[1041] Step 3: Sending data

[1042] 1. The device sends a prepared API request to the server, which includes the user ID, input text, sentiment analysis results, and request type.

[1043] Step 4: Receiving the request

[1044] 1. The server receives a request from the device at an API endpoint.

[1045] 2. The server extracts the user ID, input text, sentiment analysis results, and request type from the request and retrieves the necessary data.

[1046] Step 5: Performing Natural Language Processing

[1047] 1. The server passes the extracted input text to the natural language processing engine.

[1048] 2. The natural language processing engine checks the text for grammar, analyzes its structure, and tests the logic of its content, and returns the analysis results to the server.

[1049] Step 6: Personalization

[1050] 1. The server retrieves the user's profile data and past request history from the database.

[1051] 2. The server also refers to the emotion analysis results and personalizes the feedback based on the user's current emotional state.

[1052] 3. Based on the acquired information, the server integrates the analysis results obtained from the natural language processing engine and generates optimized feedback for the user.

[1053] Step 7: Feedback Generation

[1054] 1. The server generates personalized feedback, including praise, suggestions for improvement, and specific instructions for correction.

[1055] 2. Based on the results of the emotion analysis, the tone and content of the feedback are adjusted to suit the user's emotional state.

[1056] Step 8: Generate and Send a Response

[1057] 1. The server prepares the generated feedback as a JSON API response.

[1058] 2. The server sends this API response to the device, which includes grammar check results, suggestions for content improvement, praise comments, and emotional feedback.

[1059] Step 9: Receiving the response

[1060] 1. The device receives the API response from the server.

[1061] 2. The device parses the received data and converts it into a format for display on the user interface.

[1062] Step 10: View feedback

[1063] 1. The device displays the received feedback in the user interface.

[1064] 2. Feedback is presented as praise and specific suggestions for improvement in a format that is easy for users to review.

[1065] 3. Emotion-responsive feedback is also displayed, providing content that corresponds to the user's emotional state.

[1066] Step 11: Review and implement feedback

[1067] 1. The user checks the feedback displayed on the device.

[1068] 2. The user will revise the materials and proposals based on the feedback.

[1069] 3. If necessary, the user can request another review.

[1070] Through the above steps, the "Praise Boss" system, combined with the emotion engine, provides efficient and personalized feedback that adapts to the user's emotional state, not only improving the quality and efficiency of work but also contributing to maintaining the user's mental health.

[1071] Example 2

[1072] 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."

[1073] In modern document creation and proposal writing, systems that can provide efficient and personalized feedback are required. However, existing systems cannot take into account the user's emotional state, making it difficult to provide appropriate feedback that reduces the user's stress and anxiety.

[1074] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving data input by a user, a means for passing the received data to a natural language processing engine for analysis, a means for generating personalized feedback using user-specific information based on the analysis result and the emotion analysis result, and a means for providing the generated feedback to the user. This makes it possible to provide appropriate and personalized feedback according to the user's emotional state.

[1075] "User" refers to a person who uses this system to request a review of materials or proposals.

[1076] "Input data" refers to text information provided by a user to the system via a terminal.

[1077] A "natural language processing engine" refers to software or algorithms that analyze received text data and check its grammar and improve its content.

[1078] "Analysis results" are the results of analyzing text data generated by a natural language processing engine, and include information on grammar checks and suggestions for content improvement.

[1079] "Emotion analysis results" refers to information about the emotional state extracted from the user's input data by the emotion engine.

[1080] "User-specific information" refers to data related to an individual user, including past request history, user profile data, sentiment analysis results, and the like.

[1081] "Personalized feedback" refers to responses or advice that are customized based on the user's unique information and emotional state.

[1082] "Means of providing" refers to the functions and processes for communicating the generated feedback to the user.

[1083] "System" is a collective term for a set of devices and software that analyzes user input data and provides personalized feedback.

[1084] This invention relates to a conversational AI system that provides efficient and personalized feedback when users request improvements to documents or proposals. This system provides more appropriate feedback by incorporating an emotion engine that analyzes the user's emotions.

[1085] The system is configured as follows:

[1086] 1. User Input

[1087] A user requests a review of a document or proposal from the system via the device's user interface. In practice, the user enters "Please review my new product proposal" into the device's text input field and presses the send button. At this time, the emotion engine analyzes the user's emotional state (e.g., stress, anxiety) in real time based on the input content, input speed, and selected words.

[1088] 2. Data transmission

[1089] The device converts the user's input text and the emotion analysis results from the emotion engine into an API request format and sends it to the server. The transmitted data includes the user ID, input text, emotion analysis results (e.g., stress), and the type of request. The API request is in JSON format and is sent to the server via the device's communication module over the Internet.

[1090] 3. Receiving and parsing the request

[1091] The server receives requests sent from the device via the API endpoint. It analyzes the received request and extracts the user ID, input text, sentiment analysis results, and request type. The server then passes the input text to a natural language processing engine (e.g., GPT-3) for grammar check, content analysis, and structure analysis.

[1092] 4. Personalized processing

[1093] The server retrieves the user's profile data and past request history from the database. Based on all of this information, including the results of sentiment analysis, the analysis results obtained from the natural language processing engine are personalized. Specifically, feedback is generated that adapts to the user's emotional state. For example, if the user is feeling stressed, the feedback is adjusted to emphasize praise comments and provide suggestions for improvement in a gentler tone.

[1094] 5. Generating and Providing Feedback

[1095] The server prepares the generated feedback as a JSON-formatted API response and sends it to the device. The feedback includes grammar check results, suggestions for content improvement, praise comments, and adjustments to tone and content to take into account emotions. The device receives the API response and displays it on the user interface. The user can review the feedback and use it to revise their materials or proposals.

[1096] Specific examples

[1097] A specific example will be described in which a user creates a new product proposal, enters "Please review my new product proposal," and presses the send button.

[1098] Example prompt: "Please review our new product proposal. Please provide feedback in a friendly tone on the overall flow and structure of the content."

[1099] By combining this with an emotion engine, the system provides appropriate and personalized feedback based on the user's emotional state, thereby improving work efficiency and contributing to maintaining the user's mental health.

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

[1101] Step 1:

[1102] The user enters text into the device's text input field and presses the send button. The emotion engine analyzes the user's emotions in real time based on their input content, speed, and selected words.

[1103] Input: User input text, such as "Please review our new product proposal."

[1104] Output: Input text and parsed emotional state (e.g., stress)

[1105] Step 2:

[1106] The device receives the user's input text and the emotion analysis results from the emotion engine, and converts them into an API request format, which includes the user ID, input text, emotion analysis results, and request type.

[1107] Input: Input text and sentiment analysis results obtained in Step 1

[1108] Output: API request (JSON format)

[1109] Step 3:

[1110] The device sends an API request to the server, which then communicates to confirm that the request has been sent.

[1111] Input: API request

[1112] Output: Sending status (success / failure)

[1113] Step 4:

[1114] The server receives the request sent from the device at the API endpoint, analyzes the request content, and extracts the user ID, input text, sentiment analysis results, and request type.

[1115] Input: The API request received

[1116] Output: Extracted data (user ID, input text, sentiment analysis results, request type)

[1117] Step 5:

[1118] The server passes the extracted input text to a natural language processing engine to perform grammar checks, content analysis, and structure analysis. The natural language processing engine (e.g., GPT-3) analyzes the received text data and generates grammar check results and content improvement suggestions.

[1119] Input: Data (input text)

[1120] Output: Analysis results (grammar check results, content improvement suggestions)

[1121] Step 6:

[1122] The server retrieves user profile data and past request history from the database, and also takes into account sentiment analysis results to personalize feedback.

[1123] Input: Analysis results, user ID, emotion analysis results

[1124] Output: personalized feedback data

[1125] Step 7:

[1126] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[1127] Input: Personalized feedback data

[1128] Output: API response (JSON format)

[1129] Step 8:

[1130] The server sends the API response to the device, which receives the response and displays the feedback in the user interface.

[1131] Input: API response

[1132] Output: Feedback displayed in the user interface

[1133] (Application example 2)

[1134] 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."

[1135] In conventional content distribution services, when users request feedback on content such as articles or videos they have entered, the content of the feedback is often inappropriate for the user's situation or emotions because the user's emotional state is not taken into consideration.In addition, the feedback content is often too general and does not address the individual user's requests or emotions, leaving users dissatisfied.

[1136] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving data input by a user, emotion analysis means for analyzing emotions from the user's input data, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis results and emotion analysis results, and means for providing the generated feedback to the user. This makes it possible to generate and provide feedback tailored to the user's emotional state in real time.

[1137] "User-input data" refers to information that a user provides to the system as text or content.

[1138] "Emotion analysis means" is a function that detects and analyzes the user's emotional state from the input data and behavior of the user.

[1139] A "natural language processing engine" is an engine that analyzes input text and performs processes such as grammar checks and content improvement.

[1140] "User-specific information" is information that is individually associated with a user, such as the user's profile data and past request history.

[1141] "Personalized feedback" is feedback that is adapted to an individual user based on analysis results and user-specific information.

[1142] The "means for providing feedback to the user" is a function for displaying or notifying the user of the generated feedback.

[1143] "Grammar checking" is the process of detecting grammatical errors in text and providing suggested corrections.

[1144] "Content Improvement Suggestions" are specific advice or suggestions for improving the quality of text or content.

[1145] A "praise comment" is a comment that recognizes a user's efforts and achievements and provides positive feedback.

[1146] "Adjusting tone and content to take emotions into account" refers to adjusting the tone and content of feedback depending on the user's emotional state.

[1147] This invention relates to an interactive AI system that combines sentiment analysis when requesting feedback on user-provided content (articles, videos, etc.). This system is implemented using the following hardware and software.

[1148] Hardware and software used

[1149] 1. Hardware

[1150] Server: Receives and processes API requests

[1151] User's device: smartphone, tablet, or PC

[1152] 2. Software

[1153] Natural language processing engine: performs grammar checks, content analysis, and structural analysis of input text

[1154] Sentiment Analysis Engine: Analyzes emotions from user input data

[1155] Database: Stores user profile data and past request history

[1156] Processing flow

[1157] User input:

[1158] The user enters text into the device's input field and presses the send button, for example, "Please review the new article."

[1159] Emotion analysis:

[1160] The emotion analysis engine analyzes the emotion from the user's input data. For example, if the user is feeling stressed, the system will obtain the analysis result as "stress."

[1161] Sending data:

[1162] The user's device sends the input text and the emotion analysis results to the server. The sent data includes the user ID, input text, emotion analysis results, and request type.

[1163] Receiving and parsing the request:

[1164] The server receives the request and passes the input text to a natural language processing engine, which performs grammar checks, content enrichment, and structural analysis.

[1165] Personalization process:

[1166] The server retrieves the user's profile data and past request history from a database and incorporates the results of sentiment analysis into the process. Based on this, the server personalizes the feedback and generates feedback that adapts to the user's emotional state. For example, if the user is feeling stressed, the server will emphasize praise comments and provide feedback with suggestions for improvement in a gentler tone.

[1167] Generate and provide feedback:

[1168] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, praise comments, and emotionally sensitive tone and content adjustments. The device displays the received feedback in its user interface.

[1169] Specific examples

[1170] A user types "Please review a new article" into a content distribution service and uploads the article content. If the emotion engine detects tension, the server generates feedback like this: "This article is very interesting! However, it would be even better if you organized the paragraphs a bit more. Keep up the good work, your efforts are truly impressive."

[1171] Prompt Sentence Examples

[1172] "A user types, 'Please review a new article.' The sentiment analysis engine detects the user's nervousness. It takes into account past review history and provides feedback in a gentle tone. The prompt is:

[1173] "This article is very interesting! However, it could be improved if you organize the paragraphs a bit more. Keep it up, your efforts are truly impressive."

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

[1175] Step 1:

[1176] The user enters text into the input field of the terminal and presses the send button. An example of input text is "Please review the new article." Based on this input, the terminal prepares the input data.

[1177] Step 2:

[1178] Once the user's input data is prepared, the emotion analysis means is activated and analyzes the user's emotions. Here, an emotion analysis engine is used to detect emotions from the text and input speed, and the analysis result is "stress," for example.

[1179] Step 3:

[1180] The device sends the input text and the sentiment analysis results to the server. The data sent includes the user ID, input text, sentiment analysis results, and request type. This data is sent to the server in JSON format.

[1181] Step 4:

[1182] The server parses the incoming request. The server receives the request at the API endpoint and extracts the input text. The input text is passed to a natural language processing engine where grammar checks and structural analysis are performed.

[1183] Step 5:

[1184] The server combines the results of the natural language processing engine and the sentiment analysis to obtain user-specific information, and retrieves the user's profile data and past request history from the database.

[1185] Step 6:

[1186] The server generates personalized feedback based on all data. Depending on the results of sentiment analysis, for example, if the user is feeling "stressed," it will emphasize praise comments and rewrite improvement suggestions in a gentler tone. Feedback sentences are generated using a generative AI model.

[1187] Step 7:

[1188] The server prepares the generated feedback as an API response and sends it to the device, which can include grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[1189] Step 8:

[1190] The device analyzes the received feedback and displays it on the user interface, allowing the user to confirm the feedback and make corrections to the input content.

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

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

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

[1194] [Fourth embodiment]

[1195] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

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

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

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

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

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

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

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

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

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

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

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

[1207] 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."

[1208] This invention relates to a conversational AI system that efficiently provides support when a user requests improvements to documents or proposals. This system interacts between a terminal, a server, and the user, and provides personalized feedback to the user.

[1209] System Overview

[1210] 1. User Input

[1211] Users request the system to review documents and proposals via the user interface of their terminal.

[1212] Specifically, the user enters the required information into the text input field and presses the send button to send the request to the terminal.

[1213] 2. Data transmission

[1214] The device sends the user's input data to the server as an API request, which includes the user ID, the input text, and the type of request.

[1215] 3. Receiving and parsing the request

[1216] The server analyzes the received request and passes the text data to a natural language processing engine.

[1217] The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure.

[1218] 4. Personalized processing

[1219] The server looks up the user's profile data and past request history and personalizes the feedback accordingly.

[1220] Generate feedback based on user-specific information, including praise and specific suggestions for improvement.

[1221] 5. Generating and Providing Feedback

[1222] The server compiles the generated feedback and sends it to the device as an API response.

[1223] The terminal displays the received feedback on the user interface so that the user can check it.

[1224] Specific examples

[1225] Consider a case where a user creates a new product proposal, enters "Please review my new product proposal," and presses the submit button.

[1226] 1. User Input

[1227] The user enters "Please review our new product proposal" into the input field on the terminal, and then presses the send button.

[1228] 2. Data transmission

[1229] The terminal sends the input data to the server. The transmitted data includes the user ID, input text, and request type (review request).

[1230] 3. Receiving and parsing the request

[1231] The server receives the request and passes the text data to a natural language processing engine.

[1232] The natural language processing engine performs a grammar check and returns the analysis results to the server, such as, "That's a great suggestion, but it would be even better if you improved the following points."

[1233] 4. Personalized processing

[1234] The server refers to the user's past proposal history and profile data to create optimized feedback for the user.

[1235] 5. Generating and Providing Feedback

[1236] The server generates feedback and sends it to the device, such as: "Great suggestion! I especially like how you highlight the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[1237] The device receives this feedback and displays it in the user interface, where the user can review it and use it to revise the proposal.

[1238] As a result, this system supports users in efficiently improving their documents and proposals, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also helps to increase user motivation.

[1239] The processing flow will be explained below.

[1240] Specific processing of the program

[1241] Step 1: Submitting a request

[1242] 1. A user inputs text through the terminal's user interface to request a review of a document or proposal.

[1243] 2. The user presses the send button, which sends the input data to the terminal.

[1244] Step 2: Prepare your data

[1245] 1. The terminal receives the data entered by the user and checks the format and content of the data.

[1246] 2. The device converts the received data into an API request format and prepares it to be sent to the server.

[1247] Step 3: Sending data

[1248] 1. The device sends a prepared API request to the server, which includes the user ID, input text, and request type.

[1249] Step 4: Receiving the request

[1250] 1. The server receives a request from the device at an API endpoint.

[1251] 2. The server extracts the user ID, input text, and request type from the request and proceeds to the next step.

[1252] Step 5: Performing Natural Language Processing

[1253] 1. The server passes the extracted input text to the natural language processing engine.

[1254] 2. The natural language processing engine checks the text for grammar, analyzes its structure, and tests the logic of its content, and returns the results to the server.

[1255] Step 6: Personalization

[1256] 1. The server retrieves the user's profile data and past request history from the database.

[1257] 2. The server personalizes the analysis results obtained from the natural language processing engine based on the user-specific information obtained.

[1258] Step 7: Feedback Generation

[1259] 1. The server generates personalized feedback, including praise, suggestions for improvement, and specific instructions for correction.

[1260] Step 8: Generate and Send a Response

[1261] 1. The server prepares the generated feedback as a JSON API response.

[1262] 2. The server sends this API response to the device.

[1263] Step 9: Receiving the response

[1264] 1. The device receives the API response from the server.

[1265] 2. The device parses the received data and converts it into a format for display on the user interface.

[1266] Step 10: View feedback

[1267] 1. The device displays the received feedback in the user interface.

[1268] 2. Feedback is presented as praise and specific suggestions for improvement in a format that is easy for users to review.

[1269] Step 11: Review and implement feedback

[1270] 1. The user checks the feedback displayed on the device.

[1271] 2. The user will revise the materials and proposals based on the feedback.

[1272] 3. If necessary, the user can request another review.

[1273] Through the above steps, the "Praise Boss" system provides efficient and personalized feedback to users, helping them improve the quality and efficiency of their work.

[1274] Example 1

[1275] 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."

[1276] Conventional document and proposal review systems have struggled to provide users with personalized feedback quickly and efficiently. Furthermore, general feedback fails to provide specific improvement suggestions that take into account the user's specific needs and past request history, making it insufficient to motivate users or improve their work efficiency. Furthermore, feedback can sometimes be slow to appear, potentially hindering the user's work speed.

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

[1278] In this invention, the server includes means for receiving data input by a user, means for transmitting the received data as an API request, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis result, means for transmitting the generated feedback as an API response, and means for displaying the feedback on a user interface, thereby enabling personalized feedback to be provided to the user quickly and efficiently.

[1279] "User" means an individual or legal entity that uses the system and requests a review.

[1280] "Entered data" refers to textual information and other relevant data that a user sends to the system via a terminal.

[1281] A "terminal" is a device that a user uses to access the system, and is a general communication device including a PC, smartphone, etc.

[1282] An "API request" is a standardized communication procedure for sending data from a terminal to a server, and specifically refers to an HTTP request.

[1283] A "server" is a computer system that handles the back-end processing of the system, receiving input data, analyzing it, and generating feedback.

[1284] A "natural language processing engine" is software used to check the grammar of input data, improve its content, and verify its logical structure, such as a generative AI model.

[1285] "Personalized feedback" is feedback that includes specific and customized suggestions for improvement and praise based on the user's unique information and past request history.

[1286] An "API response" is data sent from a server to a terminal, and is in the form of response data that includes feedback.

[1287] "User interface" refers to an interface for communication between a user and a terminal, and refers to the screen display and operation means by which a user sends input data and checks feedback.

[1288] The present invention relates to a conversational AI system that efficiently provides support when a user requests improvements to documents or proposals. This system interacts between a terminal, a server, and the user, and provides personalized feedback to the user.

[1289] Hardware and software used

[1290] Hardware: Device (PC or smartphone)

[1291] Software: Servers, APIs, natural language processing engines (e.g. GPT-3, BERT)

[1292] System Operation

[1293] The user requests the system to review documents or proposals via the device's user interface. Specifically, the user enters "Please review my new product proposal" in the text input field and presses the submit button. This causes the browser's JavaScript to capture the input data and prepare it to be sent to the API endpoint.

[1294] The device sends the user input data to the server using AJAX. For example, data is sent in the form of axios.post(' / api / review', { userId: '123', text: 'Please review the new product proposal', requestType: 'review'}).

[1295] The server receives the data using the Flask framework and passes the input text data to a natural language processing engine. The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure, and returns the results to the server. For example, it may make suggestions such as, "Make this sentence more concise."

[1296] The server refers to the user's profile data and past request history and provides personalized feedback based on that. Specifically, it retrieves the user's past request history from a database (e.g., PostgreSQL) and generates feedback such as, "Compared to your previous proposal, this one has a clearer logical structure. However, it would be even better if you added a few more concrete examples."

[1297] The server returns the generated feedback to the device in JSON format. For example, a response is generated in the form of return jsonify({'feedback': feedback_text}). The device parses the received data and displays it in the user interface. Using the browser's JavaScript (e.g., React.js), the feedback content is rendered into HTML and displayed to the user as "That's a great suggestion! I especially like how you emphasize the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[1298] This system helps users improve their documents and proposals efficiently, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also motivates users.

[1299] Specific examples

[1300] Consider the case where a user types "Please review our new product proposal" and presses the submit button.

[1301] Example prompt: "Please review this new product proposal. Check for grammar, suggest content improvements, verify logical structure, and provide feedback."

[1302] Requests from users are sent via the server to a natural language processing engine, which returns suggestions for improving grammar and content to the server. The server then references the user's past request history to generate personalized feedback and send it to the device. The device displays this on the user interface, and after the user has confirmed it, they can use it to revise their proposal. This series of operations improves the quality of documents and proposals, as well as business efficiency.

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

[1304] Step 1:

[1305] The user uses the user interface of the terminal to request a review of a document or proposal. Specifically, the user enters "Please review my new product proposal" in the text input field and presses the send button. This operation prepares the input data, including the user ID, text, and request type.

[1306] Input: Text data entered through the user interface

[1307] Output: API request data ready to be sent

[1308] Step 2:

[1309] The device sends the user input data to the server using an AJAX request. This request is sent in the following format: axios.post(' / api / review', { userId: '123', text: 'Please review the new product proposal', requestType: 'review'}). The data is sent as an HTTP POST request.

[1310] Input: API request data from the user ready to be sent

[1311] Output: API request sent to the server

[1312] Step 3:

[1313] The server receives the API request using the Flask framework and parses the input data, which includes the user ID, text, and request type. The server then prepares this data for further processing by the natural language processing engine.

[1314] Input: The API request sent to the server

[1315] Output: Text data that can be sent to a natural language processing engine

[1316] Step 4:

[1317] The server sends a request to the natural language processing engine using the Python library requests. For example, a request is sent as follows: response = requests.post('https: / / api.openai.com / v1 / engines / gpt-3 / completions', data={'text': input_text}). The natural language processing engine performs grammar checks, suggests content improvements, and validates the logical structure, and returns the results to the server.

[1318] Input: Text data sent to the natural language processing engine

[1319] Output: Analysis results returned by the natural language processing engine

[1320] Step 5:

[1321] The server generates personalized feedback based on the analysis results returned by the natural language processing engine, referencing the user's profile data and past request history. It retrieves the user's history from a database (e.g., PostgreSQL) and customizes the feedback. As a result, it generates feedback such as, "Compared to your previous proposal, the logical structure is clearer this time. However, adding a few more concrete examples would be even better."

[1322] Input: Analysis results returned by the natural language processing engine, user profile data, and past request history

[1323] Output: Personalized feedback

[1324] Step 6:

[1325] The server sends the generated feedback to the device in JSON format. For example, feedback is sent in the format return jsonify({'feedback': feedback_text}).

[1326] Input: Personalized Feedback

[1327] Output: JSON-formatted feedback sent to the device

[1328] Step 7:

[1329] The device analyzes the received feedback and displays it in the user interface. Using the browser's JavaScript (e.g., React.js), the feedback is rendered into HTML and displayed in a user-friendly format. The user can view this feedback and use it to revise documents and proposals.

[1330] Input: JSON feedback sent from the server

[1331] Output: Feedback displayed in the user interface

[1332] (Application example 1)

[1333] 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."

[1334] Conventional review systems for documents and proposals often fail to provide optimal feedback to users. Furthermore, they lack the ability to provide real-time feedback, which hinders the efficiency of the content creation process. This makes it difficult to improve the quality of user-created content, and motivating users is also an issue.

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

[1336] In this invention, the server includes means for receiving data input by a user, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis result, means for providing the generated feedback to the user, and means for displaying the feedback in real time, thereby improving the quality of content created by users and making the content creation process more efficient by providing feedback in real time.

[1337] "User-input data" refers to text or information that a user sends to the system via a terminal.

[1338] "Means for receiving" refers to the functions and processes by which the system receives data input by the user.

[1339] A "natural language processing engine" refers to a computer system that analyzes input text data, checks grammar, and suggests content improvements.

[1340] "Means for analysis" refers to the functions and processes for passing received data to a natural language processing engine for analysis.

[1341] "User-specific information" refers to information specific to a user, such as the user's profile data and past request history.

[1342] "Personalized feedback" refers to feedback that is customized based on analysis results and takes into account user-specific information.

[1343] "Means for generating" refers to the functions and processes for creating feedback based on the analysis results and user-specific information.

[1344] "Means of delivery" refers to the functions and processes for delivering the generated feedback to the user.

[1345] "Means for displaying feedback in real time" refers to the functionality or process for displaying generated feedback to the user immediately.

[1346] The present invention is an interactive AI system that allows users to receive reviews of documents and proposals in real time and efficiently improve them. The system includes the following components:

[1347] System configuration

[1348] 1. User Interface

[1349] The device (smartphone or head-mounted display) is the means for receiving data input from the user. The user inputs the contents of documents and proposals through this interface.

[1350] 2. Data Transfer

[1351] The terminal transmits the text data entered by the user to the server. This transmitted data includes the user ID, the entered content, and the type of request (e.g., a review request).

[1352] 3. Natural Language Processing Engine

[1353] The server uses a natural language processing engine to analyze the received text data. This engine checks grammar, suggests content improvements, and analyzes logical structure. The software used includes Python, HTTP requests, and API services.

[1354] 4. Personalized processing

[1355] The server looks at the user's profile data and past request history, and generates personalized feedback based on the analysis, including grammar checks, suggestions for content improvement, and praise comments.

[1356] 5. Providing Feedback

[1357] The generated feedback is sent in real time to the terminal, which displays the feedback on the user interface for the user to review.

[1358] Specific examples

[1359] For example, consider the case where a user creates a new product proposal and sends it by entering "Please review my new product proposal."

[1360] 1. User Input

[1361] The user enters "Please review our new product proposal" into the input field on the terminal, and then presses the send button.

[1362] 2. Data transmission

[1363] The terminal sends the input data to the server. The transmitted data includes the user ID, input text, and request type (review request).

[1364] 3. Receiving and parsing the request

[1365] The server receives the request and passes the text data to a natural language processing engine, which checks grammar, suggests content improvements, verifies logical structure, and returns the analysis results to the server.

[1366] 4. Personalized processing

[1367] The server references past proposal history and profile data to generate tailored feedback for the user, such as, "I particularly like how you emphasized the specific benefits. However, it would be even better if you were a bit more specific in the second paragraph."

[1368] 5. Generating and Providing Feedback

[1369] The server generates feedback and sends it to the device, which displays it in real time on the user interface. The user can then review the feedback and use it to revise their proposal.

[1370] Prompt Sentence Examples

[1371] Below are some example prompts to input to the generative AI model:

[1372] Content Review Request:

[1373] I would like you to review our new product proposal. Please let me know what specific improvements and grammatical errors we should make.

[1374] As described above, this system supports users in efficiently improving their documents and proposals, contributing to increased work efficiency. In addition, the feedback includes praise and specific suggestions for improvement, which also helps to increase user motivation.

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

[1376] Step 1:

[1377] The user enters the content of the document or proposal they wish to evaluate via the device's user interface. Specifically, they enter the required text in the text input field and press the submit button. This generates input data. The input data includes the user ID, the entered content, and the type of request (e.g., a review request).

[1378] Step 2:

[1379] The device sends the text data entered by the user to the server. Specifically, it sends data to an API endpoint using an HTTP request. At this time, the sent data includes the user ID, input text, and request type. Input: Data entered by the user into the device. Output: Data sent to the server.

[1380] Step 3:

[1381] The server passes the received data to the natural language processing engine for analysis. Here, the server generates an API request to analyze the text data and sends it to the natural language processing engine. The natural language processing engine checks grammar, suggests content improvements, and verifies logical structure. Input: Data sent to the server. Output: Data containing the analysis results.

[1382] Step 4:

[1383] The server uses the analysis results received from the natural language processing engine to personalize feedback using user-specific information. Specifically, it references the user's profile data and past request history to generate praise comments and specific improvement measures based on the analysis results. Input: Analysis results from the natural language processing engine and user profile data. Output: Personalized feedback.

[1384] Step 5:

[1385] The server compiles the generated personalized feedback and sends it to the device. Specifically, it returns the feedback data to the device via the API as an HTTP response. Input: Personalized feedback. Output: Feedback data displayed in the user interface.

[1386] Step 6:

[1387] The terminal displays the received feedback data in the user interface in real time. Specifically, it allows the user to check the feedback and use it to revise documents and proposals. Input: Feedback data sent from the server. Output: Feedback displayed on the user interface.

[1388] Through the above processing steps, users can receive personalized feedback in real time, enabling them to efficiently improve their materials and proposals.

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

[1390] This invention relates to a conversational AI system that provides efficient and personalized feedback when users request improvements to documents or proposals. This system provides more appropriate feedback by incorporating an emotion engine that analyzes the user's emotions.

[1391] System Overview

[1392] 1. User Input

[1393] Users can request a review of documents or proposals from the system via the user interface on their device. At this time, the emotion engine also performs emotion analysis based on the user's input data.

[1394] 2. Data transmission

[1395] The device converts the user's input data and the emotion analysis results from the emotion engine into an API request format and sends it to the server. The transmitted data includes the user ID, input text, emotion analysis results, and the type of request.

[1396] 3. Receiving and parsing the request

[1397] The server receives requests from the device at the API endpoint and extracts the user ID, input text, sentiment analysis results, and request type from the request.

[1398] The server passes the received input text to a natural language processing engine for grammar checking, content analysis, and structural analysis.

[1399] 4. Personalized processing

[1400] The server retrieves the user's profile data and past request history from a database, and also incorporates the results of sentiment analysis into the process.

[1401] Based on the acquired information, the server personalizes the analysis results obtained from the natural language processing engine and generates feedback that is adapted to the user's current emotions.

[1402] 5. Generating and Providing Feedback

[1403] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[1404] It sends API responses to the device and displays the received feedback in the user interface.

[1405] Specific examples

[1406] Consider a case where a user creates a new product proposal, enters "Please review my new product proposal," and presses the send button. Here we will explain in detail what happens if the emotion engine detects that the user is feeling stressed.

[1407] 1. User Input

[1408] The user enters "Please review our new product proposal" into the text input field on the terminal and presses the send button.

[1409] The emotion engine analyzes the user's emotions based on the input content, input speed, and text, and detects "stress."

[1410] 2. Data transmission

[1411] The device sends the input text and the emotion analysis results to the server. The transmitted data includes the user ID, input text, stress emotion, and request type.

[1412] 3. Receiving and parsing the request

[1413] The server receives the request and passes the input text to a natural language processing engine, which performs grammar checks, content enrichment, and structural analysis.

[1414] 4. Personalized processing

[1415] The server references the user's profile data, past request history, and sentiment analysis results, and uses this information to personalize feedback.

[1416] If the user is stressed, tailor your feedback to emphasize praise comments and offer suggestions for improvement in a gentle tone.

[1417] 5. Generating and Providing Feedback

[1418] The server generates feedback like this and sends it to the device: "This new product proposal is excellent! It really highlights the specific benefits. However, it could be even better if you were a bit more specific in some sections. Good luck, we're really looking forward to your proposal."

[1419] The device receives this feedback and displays it in the user interface, where the user can review it and use it to revise the proposal.

[1420] As a result, by combining this system with an emotion engine, it is possible to provide appropriate and personalized feedback according to the user's emotional state, which not only improves work efficiency but also contributes to maintaining the user's mental health.

[1421] The processing flow will be explained below.

[1422] Specific processing of the program

[1423] Step 1: Submitting a request

[1424] 1. A user inputs text through the terminal's user interface to request a review of a document or proposal.

[1425] 2. When the user has finished entering data, they press the send button, which sends the data to the terminal.

[1426] 3. At the same time, the emotion engine analyzes the user's input data and determines the emotional state (e.g., stress, joy, sadness, etc.).

[1427] Step 2: Prepare your data

[1428] 1. The device receives data entered by the user and the analysis results of the emotion engine.

[1429] 2. The device converts the received data into an API request format and prepares it to be sent to the server.

[1430] 3. The converted data includes the user ID, input text, sentiment analysis results, and request type.

[1431] Step 3: Sending data

[1432] 1. The device sends a prepared API request to the server, which includes the user ID, input text, sentiment analysis results, and request type.

[1433] Step 4: Receiving the request

[1434] 1. The server receives a request from the device at an API endpoint.

[1435] 2. The server extracts the user ID, input text, sentiment analysis results, and request type from the request and retrieves the necessary data.

[1436] Step 5: Performing Natural Language Processing

[1437] 1. The server passes the extracted input text to the natural language processing engine.

[1438] 2. The natural language processing engine checks the text for grammar, analyzes its structure, and tests the logic of its content, and returns the analysis results to the server.

[1439] Step 6: Personalization

[1440] 1. The server retrieves the user's profile data and past request history from the database.

[1441] 2. The server also refers to the emotion analysis results and personalizes the feedback based on the user's current emotional state.

[1442] 3. Based on the acquired information, the server integrates the analysis results obtained from the natural language processing engine and generates optimized feedback for the user.

[1443] Step 7: Feedback Generation

[1444] 1. The server generates personalized feedback, including praise, suggestions for improvement, and specific instructions for correction.

[1445] 2. Based on the results of the emotion analysis, the tone and content of the feedback are adjusted to suit the user's emotional state.

[1446] Step 8: Generate and Send a Response

[1447] 1. The server prepares the generated feedback as a JSON API response.

[1448] 2. The server sends this API response to the device, which includes grammar check results, suggestions for content improvement, praise comments, and emotional feedback.

[1449] Step 9: Receiving the response

[1450] 1. The device receives the API response from the server.

[1451] 2. The device parses the received data and converts it into a format for display on the user interface.

[1452] Step 10: View feedback

[1453] 1. The device displays the received feedback in the user interface.

[1454] 2. Feedback is presented as praise and specific suggestions for improvement in a format that is easy for users to review.

[1455] 3. Emotion-responsive feedback is also displayed, providing content that corresponds to the user's emotional state.

[1456] Step 11: Review and implement feedback

[1457] 1. The user checks the feedback displayed on the device.

[1458] 2. The user will revise the materials and proposals based on the feedback.

[1459] 3. If necessary, the user can request another review.

[1460] Through the above steps, the "Praise Boss" system, combined with the emotion engine, provides efficient and personalized feedback that adapts to the user's emotional state, not only improving the quality and efficiency of work but also contributing to maintaining the user's mental health.

[1461] Example 2

[1462] 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."

[1463] In modern document creation and proposal writing, systems that can provide efficient and personalized feedback are required. However, existing systems cannot take into account the user's emotional state, making it difficult to provide appropriate feedback that reduces the user's stress and anxiety.

[1464] The identification process by the identification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for receiving data input by a user, a means for passing the received data to a natural language processing engine for analysis, a means for generating personalized feedback using user-specific information based on the analysis result and the emotion analysis result, and a means for providing the generated feedback to the user. This makes it possible to provide appropriate and personalized feedback according to the user's emotional state.

[1465] "User" refers to a person who uses this system to request a review of materials or proposals.

[1466] "Input data" refers to text information provided by a user to the system via a terminal.

[1467] A "natural language processing engine" refers to software or algorithms that analyze received text data and check its grammar and improve its content.

[1468] "Analysis results" are the results of analyzing text data generated by a natural language processing engine, and include information on grammar checks and suggestions for content improvement.

[1469] "Emotion analysis results" refers to information about the emotional state extracted from the user's input data by the emotion engine.

[1470] "User-specific information" refers to data related to an individual user, including past request history, user profile data, sentiment analysis results, and the like.

[1471] "Personalized feedback" refers to responses or advice that are customized based on the user's unique information and emotional state.

[1472] "Means of providing" refers to the functions and processes for communicating the generated feedback to the user.

[1473] "System" is a collective term for a set of devices and software that analyzes user input data and provides personalized feedback.

[1474] This invention relates to a conversational AI system that provides efficient and personalized feedback when users request improvements to documents or proposals. This system provides more appropriate feedback by incorporating an emotion engine that analyzes the user's emotions.

[1475] The system is configured as follows:

[1476] 1. User Input

[1477] A user requests a review of a document or proposal from the system via the device's user interface. In practice, the user enters "Please review my new product proposal" into the device's text input field and presses the send button. At this time, the emotion engine analyzes the user's emotional state (e.g., stress, anxiety) in real time based on the input content, input speed, and selected words.

[1478] 2. Data transmission

[1479] The device converts the user's input text and the emotion analysis results from the emotion engine into an API request format and sends it to the server. The transmitted data includes the user ID, input text, emotion analysis results (e.g., stress), and the type of request. The API request is in JSON format and is sent to the server via the device's communication module over the Internet.

[1480] 3. Receiving and parsing the request

[1481] The server receives requests sent from the device via the API endpoint. It analyzes the received request and extracts the user ID, input text, sentiment analysis results, and request type. The server then passes the input text to a natural language processing engine (e.g., GPT-3) for grammar check, content analysis, and structure analysis.

[1482] 4. Personalized processing

[1483] The server retrieves the user's profile data and past request history from the database. Based on all of this information, including the results of sentiment analysis, the analysis results obtained from the natural language processing engine are personalized. Specifically, feedback is generated that adapts to the user's emotional state. For example, if the user is feeling stressed, the feedback is adjusted to emphasize praise comments and provide suggestions for improvement in a gentler tone.

[1484] 5. Generating and Providing Feedback

[1485] The server prepares the generated feedback as a JSON-formatted API response and sends it to the device. The feedback includes grammar check results, suggestions for content improvement, praise comments, and adjustments to tone and content to take into account emotions. The device receives the API response and displays it on the user interface. The user can review the feedback and use it to revise their materials or proposals.

[1486] Specific examples

[1487] A specific example will be described in which a user creates a new product proposal, enters "Please review my new product proposal," and presses the send button.

[1488] Example prompt: "Please review our new product proposal. Please provide feedback in a friendly tone on the overall flow and structure of the content."

[1489] By combining this with an emotion engine, the system provides appropriate and personalized feedback based on the user's emotional state, thereby improving work efficiency and contributing to maintaining the user's mental health.

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

[1491] Step 1:

[1492] The user enters text into the device's text input field and presses the send button. The emotion engine analyzes the user's emotions in real time based on their input content, speed, and selected words.

[1493] Input: User input text, such as "Please review our new product proposal."

[1494] Output: Input text and parsed emotional state (e.g., stress)

[1495] Step 2:

[1496] The device receives the user's input text and the emotion analysis results from the emotion engine, and converts them into an API request format, which includes the user ID, input text, emotion analysis results, and request type.

[1497] Input: Input text and sentiment analysis results obtained in Step 1

[1498] Output: API request (JSON format)

[1499] Step 3:

[1500] The device sends an API request to the server, which then communicates to confirm that the request has been sent.

[1501] Input: API request

[1502] Output: Sending status (success / failure)

[1503] Step 4:

[1504] The server receives the request sent from the device at the API endpoint, analyzes the request content, and extracts the user ID, input text, sentiment analysis results, and request type.

[1505] Input: The API request received

[1506] Output: Extracted data (user ID, input text, sentiment analysis results, request type)

[1507] Step 5:

[1508] The server passes the extracted input text to a natural language processing engine to perform grammar checks, content analysis, and structure analysis. The natural language processing engine (e.g., GPT-3) analyzes the received text data and generates grammar check results and content improvement suggestions.

[1509] Input: Data (input text)

[1510] Output: Analysis results (grammar check results, content improvement suggestions)

[1511] Step 6:

[1512] The server retrieves user profile data and past request history from the database, and also takes into account sentiment analysis results to personalize feedback.

[1513] Input: Analysis results, user ID, emotion analysis results

[1514] Output: personalized feedback data

[1515] Step 7:

[1516] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[1517] Input: Personalized feedback data

[1518] Output: API response (JSON format)

[1519] Step 8:

[1520] The server sends the API response to the device, which receives the response and displays the feedback in the user interface.

[1521] Input: API response

[1522] Output: Feedback displayed in the user interface

[1523] (Application example 2)

[1524] 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."

[1525] In conventional content distribution services, when users request feedback on content such as articles or videos they have entered, the content of the feedback is often inappropriate for the user's situation or emotions because the user's emotional state is not taken into consideration.In addition, the feedback content is often too general and does not address the individual user's requests or emotions, leaving users dissatisfied.

[1526] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for receiving data input by a user, emotion analysis means for analyzing emotions from the user's input data, means for passing the received data to a natural language processing engine for analysis, means for generating personalized feedback using user-specific information based on the analysis results and emotion analysis results, and means for providing the generated feedback to the user. This makes it possible to generate and provide feedback tailored to the user's emotional state in real time.

[1527] "User-input data" refers to information that a user provides to the system as text or content.

[1528] "Emotion analysis means" is a function that detects and analyzes the user's emotional state from the input data and behavior of the user.

[1529] A "natural language processing engine" is an engine that analyzes input text and performs processes such as grammar checks and content improvement.

[1530] "User-specific information" is information that is individually associated with a user, such as the user's profile data and past request history.

[1531] "Personalized feedback" is feedback that is adapted to an individual user based on analysis results and user-specific information.

[1532] The "means for providing feedback to the user" is a function for displaying or notifying the user of the generated feedback.

[1533] "Grammar checking" is the process of detecting grammatical errors in text and providing suggested corrections.

[1534] "Content Improvement Suggestions" are specific advice or suggestions for improving the quality of text or content.

[1535] A "praise comment" is a comment that recognizes a user's efforts and achievements and provides positive feedback.

[1536] "Adjusting tone and content to take emotions into account" refers to adjusting the tone and content of feedback depending on the user's emotional state.

[1537] This invention relates to an interactive AI system that combines sentiment analysis when requesting feedback on user-provided content (articles, videos, etc.). This system is implemented using the following hardware and software.

[1538] Hardware and software used

[1539] 1. Hardware

[1540] Server: Receives and processes API requests

[1541] User's device: smartphone, tablet, or PC

[1542] 2. Software

[1543] Natural language processing engine: performs grammar checks, content analysis, and structural analysis of input text

[1544] Sentiment Analysis Engine: Analyzes emotions from user input data

[1545] Database: Stores user profile data and past request history

[1546] Processing flow

[1547] User input:

[1548] The user enters text into the device's input field and presses the send button, for example, "Please review the new article."

[1549] Emotion analysis:

[1550] The emotion analysis engine analyzes the emotion from the user's input data. For example, if the user is feeling stressed, the system will obtain the analysis result as "stress."

[1551] Sending data:

[1552] The user's device sends the input text and the emotion analysis results to the server. The sent data includes the user ID, input text, emotion analysis results, and request type.

[1553] Receiving and parsing the request:

[1554] The server receives the request and passes the input text to a natural language processing engine, which performs grammar checks, content enrichment, and structural analysis.

[1555] Personalization process:

[1556] The server retrieves the user's profile data and past request history from a database and incorporates the results of sentiment analysis into the process. Based on this, the server personalizes the feedback and generates feedback that adapts to the user's emotional state. For example, if the user is feeling stressed, the server will emphasize praise comments and provide feedback with suggestions for improvement in a gentler tone.

[1557] Generate and provide feedback:

[1558] The server prepares the generated feedback as a JSON API response, which includes grammar checks, suggestions for content improvement, praise comments, and emotionally sensitive tone and content adjustments. The device displays the received feedback in its user interface.

[1559] Specific examples

[1560] A user types "Please review a new article" into a content distribution service and uploads the article content. If the emotion engine detects tension, the server generates feedback like this: "This article is very interesting! However, it would be even better if you organized the paragraphs a bit more. Keep up the good work, your efforts are truly impressive."

[1561] Prompt Sentence Examples

[1562] "A user types, 'Please review a new article.' The sentiment analysis engine detects the user's nervousness. It takes into account past review history and provides feedback in a gentle tone. The prompt is:

[1563] "This article is very interesting! However, it could be improved if you organize the paragraphs a bit more. Keep it up, your efforts are truly impressive."

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

[1565] Step 1:

[1566] The user enters text into the input field of the terminal and presses the send button. An example of input text is "Please review the new article." Based on this input, the terminal prepares the input data.

[1567] Step 2:

[1568] Once the user's input data is prepared, the emotion analysis means is activated and analyzes the user's emotions. Here, an emotion analysis engine is used to detect emotions from the text and input speed, and the analysis result is "stress," for example.

[1569] Step 3:

[1570] The device sends the input text and the sentiment analysis results to the server. The data sent includes the user ID, input text, sentiment analysis results, and request type. This data is sent to the server in JSON format.

[1571] Step 4:

[1572] The server parses the incoming request. The server receives the request at the API endpoint and extracts the input text. The input text is passed to a natural language processing engine where grammar checks and structural analysis are performed.

[1573] Step 5:

[1574] The server combines the results of the natural language processing engine and the sentiment analysis to obtain user-specific information, and retrieves the user's profile data and past request history from the database.

[1575] Step 6:

[1576] The server generates personalized feedback based on all data. Depending on the results of sentiment analysis, for example, if the user is feeling "stressed," it will emphasize praise comments and rewrite improvement suggestions in a gentler tone. Feedback sentences are generated using a generative AI model.

[1577] Step 7:

[1578] The server prepares the generated feedback as an API response and sends it to the device, which can include grammar checks, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[1579] Step 8:

[1580] The device analyzes the received feedback and displays it on the user interface, allowing the user to confirm the feedback and make corrections to the input content.

[1581] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice 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 voice data.

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

[1583] 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 robot 414.

[1584] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1585] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1586] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1587] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1588] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1589] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1590] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1591] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1592] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1593] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1594] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1595] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1596] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1597] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1598] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1599] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1600] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1601] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1602] The following is further disclosed regarding the above embodiment.

[1603] (Claim 1)

[1604] means for receiving data input from a user;

[1605] A means for passing the received data to a natural language processing engine for analysis;

[1606] means for generating personalized feedback using user-specific information based on the analysis results;

[1607] means for providing the generated feedback to a user;

[1608] A system including:

[1609] (Claim 2)

[1610] 10. The system of claim 1, wherein the personalized feedback includes grammar checks of the text, suggestions for improving the content, and complimentary comments.

[1611] (Claim 3)

[1612] 2. The system of claim 1, wherein the user-specific information includes past request history and user profile data.

[1613] (Claim 4)

[1614] 10. The system of claim 1, further comprising means for providing a user interface and facilitating user submission of input data.

[1615] (Claim 5)

[1616] 10. The system of claim 1, further comprising: stress management techniques and career guidance.

[1617] (Claim 6)

[1618] 10. The system of claim 1, which also provides task and project management support.

[1619] "Example 1"

[1620] (Claim 1)

[1621] means for receiving data input from a user;

[1622] A means of sending the received data as an API request;

[1623] A means for passing the received data to a natural language processing engine for analysis;

[1624] means for generating personalized feedback using user-specific information based on the analysis results;

[1625] A means for sending the generated feedback as an API response; and

[1626] means for displaying the feedback in a user interface;

[1627] A system including:

[1628] (Claim 2)

[1629] 10. The system of claim 1, wherein the personalized feedback includes grammar checks of the text, suggestions for improving the content, and complimentary comments.

[1630] (Claim 3)

[1631] 2. The system of claim 1, wherein the user-specific information includes past request history and user profile data.

[1632] "Application Example 1"

[1633] (Claim 1)

[1634] means for receiving data input from a user;

[1635] A means for passing the received data to a natural language processing engine for analysis;

[1636] means for generating personalized feedback using user-specific information based on the analysis results;

[1637] means for providing the generated feedback to a user;

[1638] a means of displaying feedback in real time;

[1639] A system including:

[1640] (Claim 2)

[1641] 10. The system of claim 1, wherein the personalized feedback includes grammar checks of the text, suggestions for improving the content, and complimentary comments.

[1642] (Claim 3)

[1643] 2. The system of claim 1, wherein the user-specific information includes past request history and user profile data.

[1644] "Example 2: Combining Emotion Engines"

[1645] (Claim 1)

[1646] means for receiving data input from a user;

[1647] A means for passing the received data to a natural language processing engine for analysis;

[1648] means for generating personalized feedback using user-specific information based on the analysis results and the sentiment analysis results;

[1649] means for providing the generated feedback to a user;

[1650] A system including:

[1651] (Claim 2)

[1652] 10. The system of claim 1, wherein the personalized feedback includes grammar checks of the text, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[1653] (Claim 3)

[1654] 10. The system of claim 1, wherein the user-specific information includes past request history, user profile data, and sentiment analysis results.

[1655] "Application example 2 when combining emotion engines"

[1656] (Claim 1)

[1657] means for receiving data input from a user;

[1658] emotion analysis means for analyzing emotions from user input data;

[1659] A means for passing the received data to a natural language processing engine for analysis;

[1660] means for generating personalized feedback using user-specific information based on the analysis results and the sentiment analysis results;

[1661] means for providing the generated feedback to a user;

[1662] A system including:

[1663] (Claim 2)

[1664] 10. The system of claim 1, wherein the personalized feedback includes grammar checks of the text, suggestions for content improvement, complimentary comments, and emotionally sensitive adjustments to tone and content.

[1665] (Claim 3)

[1666] 2. The system of claim 1, wherein the user-specific information includes past request history and user profile data. [Explanation of symbols]

[1667] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. means for receiving data input from a user; A means for passing the received data to a natural language processing engine for analysis; means for generating personalized feedback using user-specific information based on the analysis results; means for providing the generated feedback to a user; A system including:

2. 10. The system of claim 1, wherein the personalized feedback includes checking the text for grammar, suggesting improvements, and providing complimentary comments.

3. 10. The system of claim 1, wherein the user-specific information includes past request history and user profile data.

4. 10. The system of claim 1, further comprising means for providing a user interface to facilitate user submission of input data.

5. 10. The system of claim 1, further comprising: stress management techniques and career guidance.

6. The system of claim 1, further providing task and project management support.

Images