System

Abstract

A system is provided.SOLUTION: A system comprising: means for providing an option to establish a thread for a particular message; means for receiving a request to create a thread and generating and storing a unique thread ID in a database; and means for generating and transmitting screen data for the thread to a terminal.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] Traditional messaging applications face the challenge of overloading important information and multiple topics. This makes it difficult to efficiently share and manage information on specific topics, such as adjusting travel itineraries, choosing restaurants, or even planning menus. Furthermore, they lack the ability to "like" messages or the ability to generate AI responses and summaries, forcing users to spend a lot of time manually compiling the necessary information. [Means for solving the problem]

[0005] The present invention provides a system that provides an option to create a thread for a specific message, receives a thread creation request, generates a unique thread ID, and stores it in a database. It also includes a means for generating screen data for the thread and sending it to a terminal. It also has the functionality to receive messages posted by users in a thread, store them in a database, and notify other participants in the thread of the posted message.

[0006] In particular, it includes functionality for the generative AI to analyze new messages, generate appropriate responses, and notify all participants in the thread of the generated responses. It also includes functionality for providing an option to archive threads, accepting archive requests, and storing archived threads in a database for searching and displaying them.

[0007] The present invention also includes a means for adding "likes" to a specific message and a means for saving the number of "likes" added in a database and notifying other participants.The system allows users to efficiently obtain the information they need by providing a means for the generation AI to generate a summary of the entire thread and send and display that summary to a terminal, as well as a means for the generation AI to analyze detailed questions from users and generate search links.

[0008] A "specific message" is an individual message that a user selects as the starting point of a thread.

[0009] "Threads" is a feature that aggregates conversations on a specific topic and displays them independently.

[0010] A "thread creation option" is a user interface option for creating a new thread for a particular message.

[0011] A "request" is a request sent to a server based on an operation or input from a user.

[0012] A "unique thread ID" is a number or string that is unique within the system to identify a thread.

[0013] A "database" is a system for storing data such as threads and messages in an organized and efficient manner.

[0014] "Screen data" refers to information and layout data to be displayed on the user interface.

[0015] A "terminal" is an electronic device, such as a computer, smartphone, or tablet, through which a user operates a messaging application.

[0016] "Generative AI" is a system that uses artificial intelligence (AI) technology to analyze users' messages and generate appropriate answers or summaries.

[0017] An "answer" is the response information that the generation AI outputs based on the user's message or question.

[0018] "Notifications" is a system feature that notifies participants in a thread that a message or reply has been posted.

[0019] "Archive" is a storage function that saves threads and messages so that they can be searched and referenced later.

[0020] "Like" is a system feature that allows users to indicate a positive rating for a particular message.

[0021] A "summary" is a document in which the generating AI analyzes all messages in a thread and compactly summarizes the important information.

[0022] "Search Link" is a direct link to an external search engine that the generating AI provides in response to a detailed question. [Brief explanation of the drawings]

[0023] [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

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

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

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

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

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

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

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

[0031] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0044] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation between multiple people, including the AI ​​generator, takes place on a separate screen. This system is realized by the following specific programs and their processing:

[0045] Creating and Managing Threads

[0046] Users: Select the "Start a thread" option for a specific message in a conversation.

[0047] Terminal: Sends a thread creation request to the server.

[0048] Server: Generates a unique thread ID for the new thread and saves it in the database. At the same time, it generates screen data and sends it to the device.

[0049] Terminal: Shows the new thread screen to the user.

[0050] Conversations in threads

[0051] User: Post a message in a thread.

[0052] Terminal: Sends posted messages to the server.

[0053] Server: Saves the message in a database and notifies all participants in the thread.

[0054] Generative AI: Analyzes new messages and generates appropriate responses.

[0055] Server: Saves the generated AI's answers in a database and notifies all participants in the thread.

[0056] Device: Display the generated AI's answer on the thread screen.

[0057] Information archiving and retrieval

[0058] Users: Select the option to archive the thread.

[0059] Terminal: Sends an archive request to the server.

[0060] Server: Save the thread as an archive in the database.

[0061] Users: Enter search keywords to search archived threads.

[0062] Device: Sends a search request to the server.

[0063] Server: Searches the database to find the appropriate archive.

[0064] Server: Returns search results to the device.

[0065] Terminal: Show archived threads to the user.

[0066] Reactions to messages

[0067] User: Likes a specific message.

[0068] Device: Sends a "like" request to the server.

[0069] Server: Stores the number of likes in a database and notifies all participants of the new number of likes.

[0070] On your device: See the updated number of likes on the thread view.

[0071] Generative AI summary creation

[0072] User: Request a summary of the entire thread.

[0073] Terminal: Sends a summary request to the server.

[0074] Server: Passes all messages in the thread to the generated AI for analysis.

[0075] Generative AI: Generates a summary based on the message content.

[0076] Server: Stores the summary in a database and sends it to the device.

[0077] Terminal: Display the summary in the thread view.

[0078] Search link provided by AI generation

[0079] User: Asks detailed questions to the generating AI.

[0080] Terminal: Sends the question to the server.

[0081] Server: Passes the question content to the generation AI for analysis.

[0082] Generative AI: Generates search links based on the question.

[0083] Server: Stores the generated link in a database and sends it to the device.

[0084] On your device: View the link in the thread view.

[0085] Specific examples

[0086] Create and manage itinerary coordination threads

[0087] 1. User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[0088] 2. The device sends a thread creation request to the server.

[0089] 3. The server generates a new thread ID and saves it in the database. At the same time, it generates screen data and sends it to the device.

[0090] 4. The device displays the new thread screen to User A.

[0091] 5. User B posts a message saying, "Maybe the end of August would be good."

[0092] 6. The device sends the message to the server.

[0093] 7. The server saves the message in the database and notifies all participants.

[0094] 8. The AI ​​analyzes the message and generates a reply: "Since it's the end of August, what date exactly is it scheduled for?"

[0095] 9. The server stores the generated AI's answers in a database and notifies all participants.

[0096] 10. The device will display the AI's answer.

[0097] Generate a thread summary

[0098] 1. User A requests a summary of the entire thread.

[0099] 2. The terminal sends a summary request to the server.

[0100] 3. The server passes all messages in the thread to the generated AI for analysis.

[0101] 4. The generation AI generates a summary such as "The travel dates have been decided as August 28th to 30th."

[0102] 5. The server stores the summary in a database and sends it to the terminal.

[0103] 6. The terminal displays the summary to User A.

[0104] These features allow users to create threads based on their own purposes and needs, and efficiently organize and share information with the support of generative AI.

[0105] The processing flow will be explained below.

[0106] Creating and Managing Threads

[0107] Step 1:

[0108] A user selects the "Create a thread" option for a specific message in a conversation.

[0109] Step 2:

[0110] The terminal sends a thread creation request to the server.

[0111] Step 3:

[0112] The server generates a unique thread ID for the new thread and stores it in the database.

[0113] Step 4:

[0114] The server generates screen data for the thread and sends it to the terminal.

[0115] Step 5:

[0116] The terminal displays the new thread screen to the user.

[0117] Conversations in threads

[0118] Step 1:

[0119] A user posts a message in a thread.

[0120] Step 2:

[0121] The device sends the posted message to the server.

[0122] Step 3:

[0123] The server stores the message in a database.

[0124] Step 4:

[0125] The server notifies all participants in the thread of the new message.

[0126] Step 5:

[0127] Generative AI analyzes new messages and generates appropriate responses.

[0128] Step 6:

[0129] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[0130] Step 7:

[0131] The device will display the generated AI's answer on the thread screen.

[0132] Information archiving and retrieval

[0133] Step 1:

[0134] The user selects the option to archive the thread.

[0135] Step 2:

[0136] The device sends an archive request to the server.

[0137] Step 3:

[0138] The server saves the thread as an archive in the database.

[0139] Step 4:

[0140] A user enters search keywords to search archived threads.

[0141] Step 5:

[0142] The device sends a search request to the server.

[0143] Step 6:

[0144] The server searches the database to find the appropriate archive.

[0145] Step 7:

[0146] The server returns the search results to the terminal.

[0147] Step 8:

[0148] The device displays the archived thread to the user.

[0149] Reactions to messages

[0150] Step 1:

[0151] A user "likes" a particular message.

[0152] Step 2:

[0153] The device sends a "like" request to the server.

[0154] Step 3:

[0155] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[0156] Step 4:

[0157] The device will display the updated number of likes on the thread screen.

[0158] Generative AI summary creation

[0159] Step 1:

[0160] The user requests a summary of the entire thread.

[0161] Step 2:

[0162] The terminal sends a summary request to the server.

[0163] Step 3:

[0164] The server passes all messages in the thread to the generated AI for analysis.

[0165] Step 4:

[0166] The generative AI generates a summary based on the message content.

[0167] Step 5:

[0168] The server stores the summary in a database and sends it to the terminal.

[0169] Step 6:

[0170] The device displays a summary on the thread screen.

[0171] Search link provided by AI generation

[0172] Step 1:

[0173] The user asks detailed questions to the generating AI.

[0174] Step 2:

[0175] The device sends the question to the server.

[0176] Step 3:

[0177] The server passes the question content to the generation AI for analysis.

[0178] Step 4:

[0179] The generation AI generates a search link based on the question.

[0180] Step 5:

[0181] The server stores the generated link in a database and sends it to the device.

[0182] Step 6:

[0183] Your device will display the link in the thread screen.

[0184] Example 1

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

[0186] Conventional messaging systems have limited functionality for creating threads for specific messages, making it difficult to hold efficient conversations with multiple people. They also lacked effective ways to manage, summarize, and search information within threads, particularly with advanced support using generative AI. This made it difficult for users to smoothly organize and share information.

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

[0188] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a request to create a thread and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for receiving messages in the thread, saving it in a database, and notifying all participants, means for generating a new message, means for saving the generated message in a database and notifying all participants, means for generating and displaying a summary of the entire thread, and means for generating and displaying a link when a user asks a detailed question. This makes it possible to easily create a thread for a specific message, efficiently advance conversations among multiple people, provide advanced support using generation AI, and smoothly organize and share information.

[0189] "Thread" means an independent stream of conversation associated with a particular message.

[0190] "Thread ID" refers to an identification code generated to uniquely identify a new thread.

[0191] "Database" refers to a system designed to efficiently store, retrieve, and manage data.

[0192] "Terminal" refers to the electronic device, such as a smartphone or computer, that a user uses to access the system.

[0193] "Generative AI" refers to a system that uses artificial intelligence technology to analyze messages and generate responses.

[0194] "Summary" means information that briefly summarizes the main message content in a thread.

[0195] "Link" refers to a URL that provides access to related information generated when a user asks a detailed question.

[0196] A "request" refers to a communication requesting a specific operation or information from a server.

[0197] "Notification" refers to a message sent from the system to convey information to the user.

[0198] A "message" refers to text, images, or other data that a user sends within a thread.

[0199] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation between multiple people, including the AI ​​generator, takes place on a separate screen. Detailed embodiments of this system are described below.

[0200] Creating and Managing Threads

[0201] First, a user selects the "start a thread" option for a particular message within a messaging application by clicking a specific button within the application.

[0202] The device then sends a thread creation request to the server, which is sent as an HTTP POST request to the server's specified endpoint.

[0203] The server generates a unique thread ID for the new thread and saves this ID in a database. The server generates a UUID and saves the information in a database (e.g., MongoDB). At the same time, the server generates screen data for the new thread and returns it to the device in JSON format.

[0204] Finally, the terminal displays the new thread screen to the user. The terminal uses the received JSON data to render HTML in the browser and displays the new thread screen.

[0205] Conversations in threads

[0206] Users post messages in threads. When a user enters text into the input box and clicks the "Send" button, the device sends the message data to the server.

[0207] The server stores the received message in a database and notifies all participants in the thread by storing the message in a "messages" collection in the database and sending notifications to all participants using WebSocket or push notifications.

[0208] When a generative AI receives a new message, it analyzes its content and generates an appropriate response. This analysis and generation process uses natural language processing (NLP) algorithms. For example, GPT-4 can be used as a response generation model.

[0209] The generated answer is sent back to the server and stored in a database. At the same time, the server sends a notification to all participants. The device displays the received answer from the AI ​​on the thread screen.

[0210] Information archiving and retrieval

[0211] When a user selects the option to archive a thread, the device sends an archive request to the server, which updates the status of the thread in the "threads" collection to "archived" and stores it in the database.

[0212] To search for archived threads, a user inputs search keywords and sends a search request from their device to the server. The server queries the database, searches for the relevant archives, and returns the results to the device. The device then displays the search results to the user.

[0213] Reactions to messages

[0214] When a user clicks "like" on a particular message, the device sends a "like" request to the server. The server updates the "likes" field of the message in the database and sends a notification to all participants via WebSocket. The device then displays the updated number of "likes" on the thread screen.

[0215] Generative AI summary creation

[0216] When a user requests a summary of an entire thread, the device sends a summary request to the server. The server passes all messages in the thread to the generation AI, which analyzes them. The generation AI generates a summary and stores it in a database. The server sends the summary to the device, which displays it on the thread screen.

[0217] As a concrete example, the following prompt sentence can be input to a generative AI model:

[0218] "Generate an appropriate response to the message 'Late August might be good'. Include specific questions to help us adjust our travel dates."

[0219] Search link provided by AI generation

[0220] When a user asks a detailed question to the AI, the device sends the question to the server. The server passes the question to the AI, which analyzes it and generates an appropriate search link. The generated link is sent via the server to the device, which then displays it to the user.

[0221] This will result in a system that can effectively manage threads within messaging applications, support conversations with generative AI, archive and search information, react to messages, and provide summaries and search links.

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

[0223] Creating and Managing Threads

[0224] Step 1:

[0225] Subject: User

[0226] A user selects the "Create a thread" option for a particular message within a messaging application, which in turn results in the user clicking the "Create a thread" button.

[0227] Input: User clicks "Start a thread" button

[0228] Output: Create a "thread" request

[0229] Step 2:

[0230] Subject: Terminal

[0231] The device sends a thread creation request to the server, and sends data to the specified endpoint on the server using an HTTP POST request.

[0232] Input: "Start a thread" request

[0233] Output: HTTP POST request to the server

[0234] Step 3:

[0235] Subject: Server

[0236] The server generates a new thread ID and stores it in the database. It generates a UUID and stores it in the "threads" collection in the MongoDB database.

[0237] Input: Thread creation request via HTTP POST request

[0238] Output: Generate a new thread ID and save it to the database

[0239] Step 4:

[0240] Subject: Server

[0241] The server generates screen data for a new thread and sends it to the terminal in JSON format. It then uses a template engine to generate HTML and passes it to the terminal.

[0242] Input: The newly generated thread ID

[0243] Output: Generate and send the new thread's screen data in JSON format.

[0244] Step 5:

[0245] Subject: Terminal

[0246] The device displays the new thread screen to the user. The received JSON data is rendered in the browser and the new thread screen is displayed.

[0247] Input: Screen data sent from the server

[0248] Output: The new thread screen as seen by the user

[0249] Conversations in threads

[0250] Step 1:

[0251] Subject: User

[0252] A user posts a message in a thread by entering text into the input box and clicking the "Send" button.

[0253] Input: The user types into an input box and clicks the "Submit" button

[0254] Output: Generate a request to send a message

[0255] Step 2:

[0256] Subject: Terminal

[0257] The device sends the posted message to the server by sending an HTTP POST request to the server.

[0258] Input: Message data entered by the user

[0259] Output: HTTP POST request to the server

[0260] Step 3:

[0261] Subject: Server

[0262] The server saves the message in a database and notifies all participants in the thread. The server saves the message in a "messages" collection in the database and sends notifications to all participants using WebSocket or push notifications.

[0263] Input: Message data sent in the HTTP POST request

[0264] Output: Save the message to the database and send a notification

[0265] Step 4:

[0266] Subject: Generation AI

[0267] Generative AI analyzes new messages and generates appropriate responses. It uses NLP algorithms to analyze the message content and generates responses using response generation models (e.g., GPT-4).

[0268] Input: A new message posted to a thread

[0269] Output: Answer by generative AI

[0270] Step 5:

[0271] Subject: Server

[0272] The server saves the generated AI's answer in a database and notifies all participants.The server saves the generated answer in a database and notifies all participants via WebSocket or push notification.

[0273] Input: Answer by generative AI

[0274] Output: Save to database and send notification

[0275] Step 6:

[0276] Subject: Terminal

[0277] The device displays the generated AI's answer on the thread screen. The device renders the received answer data and displays it on the thread screen.

[0278] Input: The generated AI's answer data sent from the server

[0279] Output: Display on thread screen

[0280] Information archiving and retrieval

[0281] Step 1:

[0282] Subject: User

[0283] The user selects the option to archive the thread: Clicks the Archive button.

[0284] Input: User clicks the archive button

[0285] Output: Archive request generated

[0286] Step 2:

[0287] Subject: Terminal

[0288] The device sends an archive request to the server using an HTTP POST request.

[0289] Input: User-generated archive request

[0290] Output: HTTP POST request to the server

[0291] Step 3:

[0292] Subject: Server

[0293] The server archives the thread in the database and updates the status of the "threads" collection in the database to "archived."

[0294] Input: Archive Request

[0295] Output: Archive of threads in a database

[0296] Step 4:

[0297] Subject: User

[0298] Users can enter search keywords to search archived threads by entering keywords in the search box and clicking the "Search" button.

[0299] Input: Search keyword

[0300] Output: Generate a search request

[0301] Step 5:

[0302] Subject: Terminal

[0303] The device sends a search request to the server, sending a search query via an HTTP GET request.

[0304] Input: A search request containing the search keyword

[0305] Output: HTTP GET request to the server

[0306] Step 6:

[0307] Subject: Server

[0308] The server searches the database to find the relevant archive. Based on the search query, it queries the database to retrieve the results.

[0309] Input: Search request

[0310] Output: Search results for matching archives

[0311] Step 7:

[0312] Subject: Server

[0313] The server returns the search results to the device. The search results are sent to the device in JSON format.

[0314] Input: Search results

[0315] Output: Send search results to your device

[0316] Step 8:

[0317] Subject: Terminal

[0318] The device displays the archived threads to the user. The device renders the search results and displays the archived threads to the user.

[0319] Input: Search results sent from the server

[0320] Output: Archived threads as seen by the user

[0321] Reactions to messages

[0322] Step 1:

[0323] Subject: User

[0324] A user "likes" a particular message by clicking the "like" icon next to the message.

[0325] Input: User clicks the "Like" icon

[0326] Output: Generate a "Like" request

[0327] Step 2:

[0328] Subject: Terminal

[0329] The device sends a "Like" request to the server. The "Like" data is sent to the server via an HTTP POST request.

[0330] Input: "Like" request

[0331] Output: HTTP POST request to the server

[0332] Step 3:

[0333] Subject: Server

[0334] The server saves the number of "likes" in a database and notifies all participants of the new number of "likes." It updates the "likes" field of the corresponding message in the database and sends a notification to all participants via WebSocket.

[0335] Input: "Like" request

[0336] Output: Update the like count and send a notification

[0337] Step 4:

[0338] Subject: Terminal

[0339] Your device will display the updated number of likes on the thread screen and update the displayed message list to reflect the new number of likes.

[0340] Input: New number of likes sent from the server

[0341] Output: Updated number of likes displayed to the user

[0342] Generative AI summary creation

[0343] Step 1:

[0344] Subject: User

[0345] A user requests a summary of the entire thread by clicking the "Summary" button on the thread screen.

[0346] Input: User clicks "Summary" button

[0347] Output: Generate summary request

[0348] Step 2:

[0349] Subject: Terminal

[0350] The terminal sends a summary request to the server using an HTTP POST request.

[0351] Input: A user-generated summary request

[0352] Output: HTTP POST request to the server

[0353] Step 3:

[0354] Subject: Server

[0355] The server passes all messages in the thread to the AI ​​generator for analysis. All messages in the thread are input into the AI ​​model, and a natural language processing algorithm generates a summary.

[0356] Input: All messages

[0357] Output: Generated summary

[0358] Step 4:

[0359] Subject: Generation AI

[0360] The generative AI generates a summary and stores it in a database.

[0361] Input: All messages in the thread

[0362] Output: Summary data

[0363] Step 5:

[0364] Subject: Server

[0365] The server sends the summary to the terminal, and returns the summary data to the terminal as an HTTP response.

[0366] Input: Generative AI summary

[0367] Output: Send summary data to terminal

[0368] Step 6:

[0369] Subject: Terminal

[0370] The device displays a summary on the thread screen.

[0371] Input: Summary data sent from the server

[0372] Output: A summary that is displayed to the user

[0373] Search link provided by AI generation

[0374] Step 1:

[0375] Subject: User

[0376] The user asks the AI ​​a detailed question, enters the question, and clicks the "Submit" button.

[0377] Input: User's question

[0378] Output: Generate a question request

[0379] Step 2:

[0380] Subject: Terminal

[0381] The device sends the question to the server using an HTTP POST request.

[0382] Input: The question typed by the user

[0383] Output: HTTP POST request to the server

[0384] Step 3:

[0385] Subject: Server

[0386] The server passes the question to the AI ​​generator for analysis, inputs the question into the AI ​​model, and generates an appropriate search link.

[0387] Input: User's question

[0388] Output: Generated search link

[0389] Step 4:

[0390] Subject: Generation AI

[0391] The generation AI generates the appropriate search link and returns it to the server.

[0392] Input: User's question

[0393] Output: Generated search link

[0394] Step 5:

[0395] Subject: Server

[0396] The server sends the generated link to the device.

[0397] Input: Search link generated by AI

[0398] Output: Sending link data to the terminal

[0399] Step 6:

[0400] Subject: Terminal

[0401] Your device will display the link in the thread screen.

[0402] Input: Search link sent from the server

[0403] Output: The link that is displayed to the user

[0404] The above are the specific processing steps of this system. By explaining the process from input to output in detail, the processing flow can be clearly understood.

[0405] (Application example 1)

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

[0407] In manufacturing processes, efficient and effective communication is required when workers and engineers identify problems in the manufacturing process and discuss improvement measures. Conventional methods can delay discussions to quickly resolve problems in the manufacturing process, potentially resulting in a decline in overall productivity. The present invention aims to provide a system that enables workers, engineers, and generative AI to work together to identify problems in the manufacturing process and quickly propose improvement measures to address these issues.

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

[0409] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a request to create a thread and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for managing threads for discussions about the manufacturing process, and means for using a generation AI that identifies problems in the manufacturing process and proposes improvement measures. This makes it possible to efficiently discuss problems in the manufacturing process through threads and quickly take improvement measures based on suggestions from the generation AI.

[0410] A "thread" is a unit for separating and managing a series of messages or conversations on a particular topic.

[0411] A "thread ID" is an identifier generated by the system to uniquely identify an individual thread.

[0412] A "database" is a data structure that stores information in an organized manner and allows it to be efficiently searched and updated.

[0413] "Generative AI" is a system that uses artificial intelligence technology to generate responses and suggestions in the form of text or voice.

[0414] A "terminal" is a device that allows a user to access and operate the system. Examples include smartphones and computers.

[0415] A "manufacturing process" is a series of operations and treatments that are carried out to create a product from raw materials.

[0416] A "message" is data such as text, audio, or images used to convey information between users or systems.

[0417] "Archiving" is the process of storing data or information that is no longer in use so that it can be retrieved later when needed.

[0418] "Notification" is a function that allows the system to notify the user when a specific event or information occurs.

[0419] A "summary" is a short sentence that concisely summarizes a longer text or multiple messages.

[0420] This invention relates to a "manufacturing process improvement thread management application" for efficiently improving manufacturing processes. This system creates threads for specific messages, and workers, engineers, and generation AI work together to identify problems in the manufacturing process and propose improvement measures.

[0421] Explanation of program processing

[0422] Creating a Thread

[0423] The user selects the "Create a thread" option for a specific message related to the manufacturing process. The device sends the request to the server, which generates a unique thread ID and stores it in the database. At the same time, it also generates screen data for the thread and sends it to the device.

[0424] Posting and parsing messages

[0425] When a user posts a message in a thread, the device sends the message to the server, which stores the message in a database and notifies all participants in the thread. The generative AI also analyzes the new message and generates an appropriate response or suggestion. The server stores the generated response in a database and notifies all participants in the thread.

[0426] Archive and search threads

[0427] A user selects the option to archive a thread and submits an archive request. The server stores the thread as an archive in its database, making it available for future retrieval. When a user searches the archives by entering specific keywords, the server searches the database and returns the results.

[0428] Generate a summary

[0429] A user can request a summary of an entire thread. The server passes all messages in the thread to the AI ​​generator, which generates a summary. The server stores the summary in a database and sends it to the device.

[0430] Hardware and software used

[0431] Hardware: Robot terminals used in factories, servers (computers that process the database and generative AI)

[0432] Software: Python language, AI response generation model (e.g., GPT-4), SQL database (e.g., PostgreSQL)

[0433] Specific example explanation

[0434] Example 1: Improving bottlenecks on a production line

[0435] Worker A sends a message saying, "I want to discuss the bottleneck on the production line," creating a new thread. Engineer B posts, "The bottleneck is caused by Machine X stopping frequently." The AI ​​generator responds, "To reduce the frequency of Machine X stopping, we need to change the routine maintenance schedule."

[0436] Example 2: Summary of progress for a long-term project

[0437] User A requests a summary of the entire thread. The server sends the summary request to the generation AI. The generation AI generates a summary saying, "The project is 60% complete, and the next step is to adjust equipment Y."

[0438] Prompt Sentence Examples

[0439] Message response generation:

[0440] Message: "Machine X is experiencing frequent downtime"

[0441] Prompt: "From a manufacturing process perspective, what suggestions can you make to reduce the downtime of machine X?"

[0442] Thread summary generation:

[0443] Prompt: "Summarize the following messages: [message 1, message 2, message 3, ...]"

[0444] In this way, this system makes it possible to efficiently discuss problems in the manufacturing process through threads and quickly take improvement measures based on suggestions from the generative AI.

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

[0446] Step 1:

[0447] (Step 1) The user selects the "Create a thread" option for a specific message related to the manufacturing process.

[0448] (Input) The message for which the user selected the "start a thread" option.

[0449] (Output) A thread creation request is sent from the terminal to the server.

[0450] (Specific operation) The user selects a specific message on the device screen and clicks the "Create a thread" button. This generates a thread creation request, which is sent from the device to the server as an HTTP request.

[0451] Step 2:

[0452] (Step 2) The server generates a unique thread ID and stores it in the database.

[0453] (Input) A thread creation request.

[0454] (Output) The generated thread ID and screen data for the thread are sent to the terminal.

[0455] (Specific operation) After the server receives a thread creation request, it generates a unique identifier (thread ID) and stores it in the database. It then generates screen data for the thread and notifies the terminal.

[0456] Step 3:

[0457] (Step 3) A user posts a message in the thread.

[0458] (Input) The message posted by the user.

[0459] (Output) A message is sent from the terminal to the server.

[0460] (Specific operation) The user enters a message in the input field of the terminal and clicks the send button, which sends the message data from the terminal to the server as an HTTP request.

[0461] Step 4:

[0462] (Step 4) The server saves the message in a database and notifies all participants in the thread.

[0463] (Input) The message posted by the user.

[0464] (Output) The message is saved in the database and notified to all participants.

[0465] (Specific operation) The server stores the received message in a database and sends a notification to the terminals of other users participating in the thread.

[0466] Step 5:

[0467] (Step 5) Generative AI analyzes the new message and generates an appropriate response or suggestion.

[0468] (Input) The message posted by the user.

[0469] (Output) The answer or suggestion from the generative AI.

[0470] (Specific operation) The server sends message data to the generation AI, which analyzes the prompt and generates an appropriate answer or suggestion. Example: "From the perspective of improving the manufacturing process, please make a suggestion to reduce the frequency of machine X's stoppages."

[0471] Step 6:

[0472] (Step 6) The server saves the answer generated by the generated AI in a database and notifies all participants in the thread.

[0473] (Input) Answers or suggestions from the generative AI.

[0474] (Output) The answers are stored in a database and notified to all participants.

[0475] (Specific operation) The server stores the answer received from the generation AI in a database and sends a notification to the devices of all users participating in the thread.

[0476] Step 7:

[0477] (Step 7) The user selects the option to archive the thread and submits the archive request.

[0478] (Input) A request to archive a thread selected by the user.

[0479] (Output) An archive request is sent from the terminal to the server.

[0480] (Specific operation) The user selects the "Archive" option on the terminal screen, generating a request to archive the thread.

[0481] Step 8:

[0482] (Step 8) The server saves the thread as an archive in the database.

[0483] (Input) Archive request.

[0484] (Output) The thread is saved as an archive in the database.

[0485] (Specific operation) The server receives the archive request and saves the corresponding thread as an archive in the database.

[0486] Step 9:

[0487] (Step 9) The user submits a request to search the archive by entering a specific keyword.

[0488] (Input) Search keywords specified by the user.

[0489] (Output) A search request is sent from the device to the server.

[0490] (Specific operation) The user enters a specific keyword into the search bar of the device and clicks the search button.

[0491] Step 10:

[0492] (Step 10) The server searches the database and finds the appropriate archive.

[0493] (Input) Search keywords.

[0494] (Output) Corresponding archive data.

[0495] (Specific operation) The server searches the database, finds archive data that matches the specified keywords, and generates search results.

[0496] Step 11:

[0497] (Step 11) The server sends the search results to the terminal and displays them to the user.

[0498] (Input) Applicable archive data.

[0499] (Output) The search results are displayed on the terminal.

[0500] (Specific operation) The search results generated by the server are sent to the terminal, which then displays them to the user.

[0501] Step 12:

[0502] (Step 12) The user sends a request for a summary of the entire thread.

[0503] (Input) A summary of the user's request.

[0504] (Output) A summary request is sent from the terminal to the server.

[0505] (Specific operation) The user selects a summary option on the terminal screen and sends a request.

[0506] Step 13:

[0507] (Step 13) The server passes all messages in the thread to the generation AI, which generates a summary.

[0508] (Input) All message data for the thread.

[0509] (Output) Generative AI summary.

[0510] (Specific operation) The server retrieves all messages in the thread and has the generation AI analyze them. The generation AI generates a summary based on the message data.

[0511] Step 14:

[0512] (Step 14) The server stores the generated summary in a database and transmits it to the terminal.

[0513] (Input) Summary by generative AI.

[0514] (Output) The summary is stored in the database and displayed on the terminal.

[0515] (Specific operation) The server stores the summary received from the generation AI in a database and sends it to the user's device.

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

[0517] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation can be held on a separate screen with multiple people, including a generation AI. It also has the function of generating a response according to the user's emotions by combining it with an emotion engine that analyzes the user's message and recognizes their emotions. This system is realized by the following specific programs and their processing:

[0518] Creating and Managing Threads

[0519] A user selects the "Create a thread" option for a specific message in a conversation.

[0520] The terminal sends a thread creation request to the server.

[0521] The server generates a unique thread ID for the new thread and stores it in the database. At the same time, it generates screen data and sends it to the device.

[0522] The terminal displays the new thread screen to the user.

[0523] Conversations in threads

[0524] A user posts a message in a thread.

[0525] The device sends the posted message to the server.

[0526] The server saves the message in a database and notifies all participants in the thread of the new message.

[0527] The emotion engine analyzes the message and recognizes the user's emotions.

[0528] The generative AI analyzes new messages based on the analysis results of the emotion engine and generates appropriate responses.

[0529] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[0530] The device will display the generated AI's answer on the thread screen.

[0531] Information archiving and retrieval

[0532] The user selects the option to archive the thread.

[0533] The device sends an archive request to the server.

[0534] The server stores the relevant thread and emotion data in a database as an archive.

[0535] A user enters search keywords to search archived threads.

[0536] The device sends a search request to the server.

[0537] The server searches the database to find the appropriate archive.

[0538] The server returns the search results to the terminal.

[0539] The device displays the archived thread to the user.

[0540] Reactions to messages

[0541] A user "likes" a particular message.

[0542] The device sends a "like" request to the server.

[0543] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[0544] The device will display the updated number of likes on the thread screen.

[0545] Generative AI summary creation

[0546] The user requests a summary of the entire thread.

[0547] The terminal sends a summary request to the server.

[0548] The server passes all messages in the thread to the generated AI for analysis.

[0549] The generative AI generates a summary based on the message content.

[0550] The server stores the summary in a database and sends it to the terminal.

[0551] The device displays a summary on the thread screen.

[0552] Search link provided by AI generation

[0553] The user asks detailed questions to the generating AI.

[0554] The device sends the question to the server.

[0555] The server passes the question content to the generation AI for analysis.

[0556] The generation AI generates a search link based on the question.

[0557] The server stores the generated link in a database and sends it to the device.

[0558] Your device will display the link in the thread screen.

[0559] Use of emotion engine

[0560] The emotion engine analyzes messages from users and recognizes their emotions.

[0561] The emotion engine provides the recognition results to the generative AI.

[0562] The generative AI adjusts the response based on the user's emotions, responding faster if the emotion is positive and more politely if the emotion is negative.

[0563] The server stores the emotion data in a database and uses it to track changes in emotion.

[0564] Specific examples

[0565] Create and manage itinerary coordination threads

[0566] 1. User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[0567] 2. The device sends a thread creation request to the server.

[0568] 3. The server generates a new thread ID and stores it in the database.

[0569] 4. The device displays the new thread screen to User A.

[0570] 5. User B posts a message saying, "Maybe the end of August would be good."

[0571] 6. The device sends the message to the server.

[0572] 7. The server saves the message in the database and notifies all participants.

[0573] 8. The emotion engine analyzes the message and recognizes that User B has a positive emotion.

[0574] 9. The generative AI quickly generates a response: "Since it's the end of August, what date exactly is it scheduled for?"

[0575] 10. The server stores the generated AI's response in a database and notifies all participants.

[0576] 11. The device will display the generated AI's response.

[0577] Generate a thread summary

[0578] 1. User A requests a summary of the entire thread.

[0579] 2. The terminal sends a summary request to the server.

[0580] 3. The server passes all messages in the thread to the generated AI for analysis.

[0581] 4. The generation AI generates a summary such as "The travel dates have been decided as August 28th to 30th."

[0582] 5. The server stores the summary in a database and sends it to the terminal.

[0583] 6. The terminal displays the summary to User A.

[0584] These features allow users to create threads based on their own purposes and needs, and efficiently organize and share information with the support of generative AI and an emotion engine.

[0585] The processing flow will be explained below.

[0586] Creating and Managing Threads

[0587] Step 1:

[0588] A user selects the "Create a thread" option for a specific message in a conversation.

[0589] Step 2:

[0590] The terminal sends a thread creation request to the server.

[0591] Step 3:

[0592] The server generates a unique thread ID for the new thread and stores it in the database.

[0593] Step 4:

[0594] The server generates screen data for the thread and sends it to the terminal.

[0595] Step 5:

[0596] The terminal displays the new thread screen to the user.

[0597] Conversations in threads

[0598] Step 1:

[0599] A user posts a message in a thread.

[0600] Step 2:

[0601] The device sends the posted message to the server.

[0602] Step 3:

[0603] The server stores the message in a database.

[0604] Step 4:

[0605] The server notifies all participants in the thread of the new message.

[0606] Step 5:

[0607] The emotion engine analyzes new messages and recognizes the user's emotions.

[0608] Step 6:

[0609] The generative AI analyzes new messages based on the analysis results of the emotion engine and generates appropriate responses.

[0610] Step 7:

[0611] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[0612] Step 8:

[0613] The device will display the generated AI's answer on the thread screen.

[0614] Information archiving and retrieval

[0615] Step 1:

[0616] The user selects the option to archive the thread.

[0617] Step 2:

[0618] The device sends an archive request to the server.

[0619] Step 3:

[0620] The server stores the relevant thread and emotion data in a database as an archive.

[0621] Step 4:

[0622] A user enters search keywords to search archived threads.

[0623] Step 5:

[0624] The device sends a search request to the server.

[0625] Step 6:

[0626] The server searches the database to find the appropriate archive.

[0627] Step 7:

[0628] The server returns the search results to the terminal.

[0629] Step 8:

[0630] The device displays the archived thread to the user.

[0631] Reactions to messages

[0632] Step 1:

[0633] A user "likes" a particular message.

[0634] Step 2:

[0635] The device sends a "like" request to the server.

[0636] Step 3:

[0637] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[0638] Step 4:

[0639] The device will display the updated number of likes on the thread screen.

[0640] Generative AI summary creation

[0641] Step 1:

[0642] The user requests a summary of the entire thread.

[0643] Step 2:

[0644] The terminal sends a summary request to the server.

[0645] Step 3:

[0646] The server passes all messages in the thread to the generated AI for analysis.

[0647] Step 4:

[0648] The generative AI generates a summary based on the message content.

[0649] Step 5:

[0650] The server stores the generated summary in a database and transmits it to the terminal.

[0651] Step 6:

[0652] The device displays a summary on the thread screen.

[0653] Search link provided by AI generation

[0654] Step 1:

[0655] The user asks detailed questions to the generating AI.

[0656] Step 2:

[0657] The device sends the question to the server.

[0658] Step 3:

[0659] The server passes the question content to the generation AI for analysis.

[0660] Step 4:

[0661] The generation AI generates a search link based on the question.

[0662] Step 5:

[0663] The server stores the generated link in a database and sends it to the device.

[0664] Step 6:

[0665] Your device will display the link in the thread screen.

[0666] Use of emotion engine

[0667] Step 1:

[0668] The emotion engine analyzes messages from users and recognizes their emotions.

[0669] Step 2:

[0670] The emotion engine provides the recognition results to the generative AI.

[0671] Step 3:

[0672] The generative AI adjusts the response based on the user's emotions, responding faster if the emotion is positive and more politely if the emotion is negative.

[0673] Step 4:

[0674] The server stores the emotion data in a database and uses it to track changes in emotion.

[0675] Specific examples

[0676] Create and manage itinerary coordination threads

[0677] Step 1:

[0678] User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[0679] Step 2:

[0680] The terminal sends a thread creation request to the server.

[0681] Step 3:

[0682] The server generates a new thread ID and stores it in the database.

[0683] Step 4:

[0684] The device displays the new thread screen to User A.

[0685] Step 5:

[0686] User B posts a message saying, "Maybe the end of August would be good."

[0687] Step 6:

[0688] The device sends a message to the server.

[0689] Step 7:

[0690] The server stores the message in a database and notifies all participants.

[0691] Step 8:

[0692] The emotion engine analyzes the message and recognizes that User B has a positive emotion.

[0693] Step 9:

[0694] The generative AI quickly generates a response such as, "Since it's the end of August, what date exactly is it scheduled for?"

[0695] Step 10:

[0696] The server stores the generated AI's response in a database and notifies all participants.

[0697] Step 11:

[0698] The terminal will display the generated AI's response.

[0699] Generate a thread summary

[0700] Step 1:

[0701] User A requests a summary of the entire thread.

[0702] Step 2:

[0703] The terminal sends a summary request to the server.

[0704] Step 3:

[0705] The server passes all messages in the thread to the generated AI for analysis.

[0706] Step 4:

[0707] The generative AI generates a summary such as "The travel dates have been set for August 28th to 30th."

[0708] Step 5:

[0709] The server stores the generated summary in a database and transmits it to the terminal.

[0710] Step 6:

[0711] The terminal displays the summary to User A.

[0712] Example 2

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

[0714] Conventional messaging applications lack the ability to create threads for specific messages and efficiently manage conversations on a separate screen. They also lack a mechanism for automatically generating responses based on the user's emotions, making it difficult to improve the user experience. Furthermore, they also have limited functionality for archiving past threads and quickly searching for necessary information. To address these issues, an efficient and user-friendly communication system is needed.

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

[0716] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a thread creation request and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for a user to post a message in the created thread, means for saving the posted message in a database and notifying all participants, means for analyzing the message using a generative AI model and generating an appropriate response, and means for analyzing the emotion of the message using an emotion analysis engine and providing the analysis result to the generative AI model. This allows users to efficiently manage conversations, enables the generative AI and the emotion engine to work together to automatically generate responses according to the user's emotions, and provides a system for efficiently archiving and searching thread information.

[0717] A "thread" is an independent unit of communication for centrally managing a series of conversations or exchanges related to a particular message.

[0718] A "thread ID" is an identification code generated by the server to uniquely identify a thread.

[0719] "Terminal" is a general term for electronic devices used by users, such as computers, smartphones, and tablets.

[0720] A "server" is a central computer system that processes, manages, and stores data.

[0721] A "database" is an information system for systematically storing and managing data such as threads, messages, and user information.

[0722] A "generative AI model" is a program that uses artificial intelligence algorithms to analyze a user's message and generate an appropriate response.

[0723] An "emotion analysis engine" is a system that analyzes a user's message and recognizes their emotional state (positive, negative, neutral, etc.).

[0724] "Archiving" refers to the process of saving threads or messages so that they can be retrieved later, or the saved data.

[0725] A "notification" is information sent by a server to a terminal or user to notify them of a new message or event.

[0726] A "reaction" refers to an evaluation action such as a "like" that a user takes on a particular message.

[0727] A "search link" is an access link to related information generated by the generative AI model in response to a user's detailed question.

[0728] A "summary" is a sentence or piece of information that analyzes all messages in a thread and succinctly summarizes their contents.

[0729] This invention is a system that allows users to create threads for specific messages and use generative AI models and sentiment analysis engines to communicate efficiently and effectively. This system consists of a server, a terminal, and software that links them.

[0730] Hardware and software used

[0731] Server: A central computer system that processes, manages, and stores data.

[0732] Device: The electronic device used by the user, such as a computer, smartphone, or tablet.

[0733] Generative AI model: A program that uses artificial intelligence algorithms to analyze a user's message and generate an appropriate response (e.g., GPT-4).

[0734] Sentiment Analysis Engine: A system for analyzing users' messages and recognizing their emotional state.

[0735] Overall system operation

[0736] 1. Creating and Managing Threads

[0737] When a user creates a thread for a specific message in a messaging app, the device sends a thread creation request to the server.

[0738] The server generates a unique thread ID and stores it in the database. At the same time, it generates screen data for the thread and sends it to the device.

[0739] The terminal will display the new thread screen to the user.

[0740] Conversations in threads

[0741] A user posts a message in a thread and sends it to the server from their device.

[0742] The server stores the message in a database and notifies all participants.

[0743] The sentiment analysis engine analyzes the message and recognizes the user's sentiment.

[0744] The generative AI model generates an appropriate response based on the results of the emotion analysis.

[0745] The server stores the responses from the generative AI model in a database and notifies all participants.

[0746] The device displays the response of the generated AI model on the thread screen.

[0747] Information archiving and retrieval

[0748] The user selects the option to archive the thread, and the terminal sends an archive request to the server.

[0749] The server stores the relevant thread and emotion data in a database.

[0750] A user inputs a search keyword to search an archived thread, and the terminal sends a search request to the server.

[0751] The server searches the database, finds the relevant archive, and sends it to the terminal.

[0752] The device displays archived threads.

[0753] Reactions to messages

[0754] When a user presses the "Like" button for a particular message, the device sends a "Like" request to the server.

[0755] The server stores the number of "likes" in a database and notifies all participants.

[0756] The device will display the updated number of likes on the thread screen.

[0757] Generative AI summary creation

[0758] A user requests a summary of an entire thread, and the terminal sends a summary request to the server.

[0759] The server passes all messages in the thread to the generative AI model for analysis.

[0760] The generative AI model generates a summary, which the server stores in a database and sends to the device.

[0761] The terminal displays the summary to the user.

[0762] Search link provided by AI generation

[0763] When a user asks a detailed question to the generative AI model, the device sends the question to the server.

[0764] The server passes the question to the generative AI model for analysis.

[0765] A generative AI model generates search links based on the question.

[0766] The server stores the generated link in a database and sends it to the device.

[0767] The device will display the generated link on the thread screen.

[0768] Use of sentiment analysis engine

[0769] The sentiment analysis engine analyzes messages from users and recognizes their emotional state.

[0770] The emotion analysis engine provides the recognition results to the generative AI model, which then adjusts the response content based on the user's emotions.

[0771] The server stores the emotion data in a database and uses it to track changes in emotion.

[0772] Specific example explanation

[0773] Consider the example of a thread for coordinating travel itineraries. When user A creates a thread in response to the message "Let's decide on this year's travel dates," the device sends a thread creation request to the server. The server generates a new thread ID and saves it in the database. The device displays the new thread screen to user A. When user B posts the message "The end of August might be good," the device sends the message to the server. The server saves the message in the database and notifies all participants. The sentiment analysis engine analyzes the message and recognizes that user B has positive emotions. The generation AI quickly generates a response: "Since the end of August, what date exactly is it planned for?" The server saves the generation AI's response in the database and notifies all participants. The device displays the generation AI's response.

[0774] Example prompt sentence:

[0775] "In this thread about deciding travel dates, please gather everyone's opinions and suggest the best travel dates."

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

[0777] Step 1:

[0778] A user selects the "Create a thread" option for a specific message in a messaging app.

[0779] Input: The "start a thread" option that the user controls.

[0780] What happens: The user clicks the thread creation button in the app.

[0781] Output: A thread creation request is generated.

[0782] Step 2:

[0783] The terminal sends a thread creation request to the server.

[0784] Input: A thread creation request initiated by a user.

[0785] Operation: The device sends request data to the server.

[0786] Output: The server receives the thread creation request.

[0787] Step 3:

[0788] The server generates a unique thread ID and stores it in the database.

[0789] Input: The thread creation request received by the server.

[0790] How it works: The server generates a unique thread ID using a UUID (Universally Unique ID) generation algorithm, and stores the generated thread ID and associated data in a database.

[0791] Output: A unique thread ID is generated and stored in the database.

[0792] Step 4:

[0793] The server generates screen data for the thread and sends it to the terminal.

[0794] Input: The generated thread ID.

[0795] Operation: The server generates the initial screen data for the thread and sends it to the terminal.

[0796] Output: Screen data is generated and sent to the device.

[0797] Step 5:

[0798] The device displays the new thread screen to the user.

[0799] Input: Screen data sent from the server.

[0800] Behavior: Updates the user interface based on the data received by the device.

[0801] Output: The new thread screen is displayed to the user.

[0802] Step 6:

[0803] A user posts a message in a thread.

[0804] Input: The message entered by the user.

[0805] What happens: The user enters text into the message input field and clicks the send button.

[0806] Output: The message is sent.

[0807] Step 7:

[0808] The device sends the posted message to the server.

[0809] Input: The message entered by the user.

[0810] Operation: The device sends message data to the server.

[0811] Output: The server receives the message data.

[0812] Step 8:

[0813] The server saves the message in a database and notifies all participants in the thread of the new message.

[0814] Input: Message data sent from the terminal.

[0815] What it does: The server stores the received message in a database. The notification module notifies all participants that a new message has been posted.

[0816] Output: The message is saved in the database and all participants are notified.

[0817] Step 9:

[0818] The sentiment analysis engine analyzes the message and recognizes the user's emotions.

[0819] Input: The message data received by the server.

[0820] How it works: The sentiment analysis engine uses natural language processing algorithms to analyze messages and assign sentiment labels (e.g., positive, negative, neutral).

[0821] Output: The sentiment analysis results are generated.

[0822] Step 10:

[0823] The generative AI model analyzes new messages based on the sentiment analysis results and generates appropriate responses.

[0824] Input: Sentiment analysis results from the sentiment analysis engine and messages posted by users.

[0825] How it works: A generative AI model (e.g., GPT-4) generates an appropriate answer based on the prompt.

[0826] Output: A generated response message is generated.

[0827] Step 11:

[0828] The server stores the response from the generated AI model in a database and notifies all participants in the thread.

[0829] Input: The generated response message.

[0830] How it works: The server stores the generated response in a database and the notification module notifies all participants.

[0831] Output: The response message is saved in the database and notified to all participants.

[0832] Step 12:

[0833] The device displays the response of the generated AI model on the thread screen.

[0834] Input: The response message sent by the server.

[0835] Behavior: The response message received by the device is displayed on the thread screen.

[0836] Output: A response message is displayed to the user.

[0837] These processing steps allow users to communicate efficiently and receive appropriate responses leveraging the collaboration of generative AI and sentiment analysis engines.

[0838] (Application example 2)

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

[0840] Traditional messaging systems lacked the ability to create threads for specific messages and generate responses based on user sentiment. They also faced challenges in effectively managing information within threads and providing user reactions and archiving functions. This resulted in a poor user experience and hindered efficient communication.

[0841] The specific processing by the specific 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 providing an option to create a thread for a specific message, means for receiving a thread creation request and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to the terminal, means for analyzing the message using an emotion engine and recognizing the user's emotion, and means for the generation AI to generate an appropriate response based on the recognized emotion. This allows the user to create a thread for a specific message and receive a response based on the emotion, thereby realizing efficient communication.

[0842] The "threading option" is a feature that allows users to create a new conversation flow for a particular message.

[0843] The "thread ID" is an identifier for uniquely identifying a created thread.

[0844] "Screen data" is a data set that contains visual information of a thread for display on a user terminal.

[0845] An "emotion engine" is software or algorithms that analyze a user's message and recognize its emotion.

[0846] "Generative AI" is an artificial intelligence system that automatically generates appropriate responses based on the results of analysis by the emotion engine.

[0847] A "reaction" is an action taken by a user to indicate a positive or negative evaluation of a particular message or response.

[0848] "Archiving" is the process of saving specific threads or conversations so that they can be searched or referenced later.

[0849] A "summary" is information that briefly summarizes the contents of the entire thread.

[0850] A "database" is a system for systematically storing and managing information such as threads, messages, and sentiment analysis results.

[0851] A "notification" is a means of informing a user that a particular event or message has occurred.

[0852] The system based on this invention mainly utilizes a server, a terminal, an emotion engine, a generation AI, and a database to provide messaging between users and a response function based on emotion recognition.

[0853] Hardware and software used

[0854] Hardware: Smartphone or computer

[0855] Software: Messaging application, emotion engine (EmotionAPI), generative AI (ChatGPT), database (PostgreSQL)

[0856] Program processing

[0857] Thread creation

[0858] When a user selects the "Create a thread" option for a particular message, the device sends this thread creation request to the server, which generates a new thread ID and stores it in the database. It also generates screen data for the thread and sends it to the device for display.

[0859] Sentiment Analysis and Response Generation

[0860] When a user posts a message in a thread, the device sends this message to the server. The server saves the posted message in a database and notifies all participants in the thread. The emotion engine analyzes the message and recognizes the user's emotion. The recognition result is provided to the generation AI, which generates an appropriate response. The server saves the response from the generation AI in a database and notifies all participants.

[0861] Reactions and Feedback

[0862] When a user clicks "like" or "rating" on a particular message, the device sends this reaction request to the server, which stores the reaction count in a database and notifies all participants of the new reaction count.

[0863] Thread archives and summaries

[0864] When a user selects the option to archive a thread, the device sends an archive request to the server, which stores the thread in a database and makes it available for future searches. Additionally, if the user requests a summary of the entire thread, the server passes the request to a generation AI, which generates the summary. The generated summary is stored in a database and sent to the device.

[0865] Specific examples

[0866] For example, consider the case where User A asks a question in a live chat, "Please tell me how to use Product A." This message is recognized as positive by the emotion engine. In response, the generation AI immediately responds, "I'll explain in detail how to use Product A!" If, as the conversation progresses, a request to "know more" arises, it is possible to create a thread summarizing the content and provide more information on a separate screen.

[0867] Prompt Sentence Examples

[0868] "A user is asking about how to use Product A. The sentiment engine recognized a positive sentiment. Generate an appropriate response."

[0869] This system allows users to receive appropriate support that corresponds to their emotions, enabling efficient communication.

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

[0871] Step 1:

[0872] When a user selects the "Create a thread" option for a particular message, the device sends this thread creation request to the server.

[0873] Input: User thread creation request

[0874] Data processing: Converting thread creation requests into data format

[0875] Output: Thread creation request data

[0876] Step 2:

[0877] The server generates a new thread ID and saves it in the database. At the same time, it generates screen data for the thread and sends it to the device.

[0878] Input: Thread creation request data

[0879] Data calculation: Generate a unique thread ID and save it in the database. Generate screen data for the thread.

[0880] Output: Thread ID and screen data

[0881] Step 3:

[0882] The device displays the new thread screen to the user.

[0883] Input: Thread ID and screen data

[0884] Data processing: Convert screen data into display format

[0885] Output: Thread screen displayed

[0886] Step 4:

[0887] A user posts a message in a thread, and the device sends this message to the server.

[0888] Input: User's message

[0889] Data processing: converting messages into data format

[0890] Output: Message data

[0891] Step 5:

[0892] The server stores the posted message in a database and notifies all participants in the thread.

[0893] Input: Message data

[0894] Data calculation: Message storage in the database and generation of notification data

[0895] Output: Stored message and notification data

[0896] Step 6:

[0897] The emotion engine analyzes the message and recognizes the user's emotions.

[0898] Input: Posted message data

[0899] Data calculation: Emotion data generation by applying emotion analysis algorithms

[0900] Output: Emotion analysis results

[0901] Step 7:

[0902] The recognition results are provided to the generation AI, which generates an appropriate response.

[0903] Input: Sentiment analysis results

[0904] Data Computation: Using generative AI models to generate appropriate responses based on emotional data

[0905] Output: The generated response

[0906] Step 8:

[0907] The server stores the generated AI's response in a database and notifies all participants.

[0908] Input: The generated response

[0909] Data calculation: Save response data and generate notification data

[0910] Output: Response notification data

[0911] Step 9:

[0912] The device displays the generated AI's response on the thread screen.

[0913] Input: Response notification data

[0914] Data processing: Convert response data into a display format

[0915] Output: Response data displayed in the thread view

[0916] Step 10:

[0917] When a user clicks "like" or rates a particular message, the device sends this reaction request to the server.

[0918] Input: User reaction data

[0919] Data processing: Converting reaction data into a transmission format

[0920] Output: Reaction request data

[0921] Step 11:

[0922] The server saves the number of reactions in a database and notifies all participants of the new number of reactions.

[0923] Input: Reaction request data

[0924] Data calculation: Update the number of reactions and generate notification data

[0925] Output: Updated reaction count and notification data

[0926] Step 12:

[0927] When a user selects the option to archive a thread, the terminal sends an archive request to the server.

[0928] Input: User's archive request

[0929] Data processing: Converting archive request data

[0930] Output: Archive request data

[0931] Step 13:

[0932] The server stores the thread in a database, making it available for later retrieval.

[0933] Input: Archive request data

[0934] Data operation: Save the corresponding thread in the database and set it to searchable

[0935] Output: Archived thread data

[0936] Step 14:

[0937] When a user requests a summary for an entire thread, the server passes the request to the generation AI, which generates the summary.

[0938] Input: Summary request data

[0939] Data Computation: Message Summarization by Generative AI

[0940] Output: Generated summary data

[0941] Step 15:

[0942] The generated summary is stored in a database and transmitted to the terminal.

[0943] Input: Summary data

[0944] Data calculation: saving summary data and sending it to the terminal

[0945] Output: Summary data displayed on the terminal

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

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

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

[0949] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0962] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation between multiple people, including the AI ​​generator, takes place on a separate screen. This system is realized by the following specific programs and their processing:

[0963] Creating and Managing Threads

[0964] Users: Select the "Start a thread" option for a specific message in a conversation.

[0965] Terminal: Sends a thread creation request to the server.

[0966] Server: Generates a unique thread ID for the new thread and saves it in the database. At the same time, it generates screen data and sends it to the device.

[0967] Terminal: Shows the new thread screen to the user.

[0968] Conversations in threads

[0969] User: Post a message in a thread.

[0970] Terminal: Sends posted messages to the server.

[0971] Server: Saves the message in a database and notifies all participants in the thread.

[0972] Generative AI: Analyzes new messages and generates appropriate responses.

[0973] Server: Saves the generated AI's answers in a database and notifies all participants in the thread.

[0974] Device: Display the generated AI's answer on the thread screen.

[0975] Information archiving and retrieval

[0976] Users: Select the option to archive the thread.

[0977] Terminal: Sends an archive request to the server.

[0978] Server: Save the thread as an archive in the database.

[0979] Users: Enter search keywords to search archived threads.

[0980] Device: Sends a search request to the server.

[0981] Server: Searches the database to find the appropriate archive.

[0982] Server: Returns search results to the device.

[0983] Terminal: Show archived threads to the user.

[0984] Reactions to messages

[0985] User: Likes a specific message.

[0986] Device: Sends a "like" request to the server.

[0987] Server: Stores the number of likes in a database and notifies all participants of the new number of likes.

[0988] On your device: See the updated number of likes on the thread view.

[0989] Generative AI summary creation

[0990] User: Request a summary of the entire thread.

[0991] Terminal: Sends a summary request to the server.

[0992] Server: Passes all messages in the thread to the generated AI for analysis.

[0993] Generative AI: Generates a summary based on the message content.

[0994] Server: Stores the summary in a database and sends it to the device.

[0995] Terminal: Display the summary in the thread view.

[0996] Search link provided by AI generation

[0997] User: Asks detailed questions to the generating AI.

[0998] Terminal: Sends the question to the server.

[0999] Server: Passes the question content to the generation AI for analysis.

[1000] Generative AI: Generates search links based on the question.

[1001] Server: Stores the generated link in a database and sends it to the device.

[1002] On your device: View the link in the thread view.

[1003] Specific examples

[1004] Create and manage itinerary coordination threads

[1005] 1. User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[1006] 2. The device sends a thread creation request to the server.

[1007] 3. The server generates a new thread ID and saves it in the database. At the same time, it generates screen data and sends it to the device.

[1008] 4. The device displays the new thread screen to User A.

[1009] 5. User B posts a message saying, "Maybe the end of August would be good."

[1010] 6. The device sends the message to the server.

[1011] 7. The server saves the message in the database and notifies all participants.

[1012] 8. The AI ​​analyzes the message and generates a reply: "Since it's the end of August, what date exactly is it scheduled for?"

[1013] 9. The server stores the generated AI's answers in a database and notifies all participants.

[1014] 10. The device will display the AI's answer.

[1015] Generate a thread summary

[1016] 1. User A requests a summary of the entire thread.

[1017] 2. The terminal sends a summary request to the server.

[1018] 3. The server passes all messages in the thread to the generated AI for analysis.

[1019] 4. The generation AI generates a summary such as "The travel dates have been decided as August 28th to 30th."

[1020] 5. The server stores the summary in a database and sends it to the terminal.

[1021] 6. The terminal displays the summary to User A.

[1022] These features allow users to create threads based on their own purposes and needs, and efficiently organize and share information with the support of generative AI.

[1023] The processing flow will be explained below.

[1024] Creating and Managing Threads

[1025] Step 1:

[1026] A user selects the "Create a thread" option for a specific message in a conversation.

[1027] Step 2:

[1028] The terminal sends a thread creation request to the server.

[1029] Step 3:

[1030] The server generates a unique thread ID for the new thread and stores it in the database.

[1031] Step 4:

[1032] The server generates screen data for the thread and sends it to the terminal.

[1033] Step 5:

[1034] The terminal displays the new thread screen to the user.

[1035] Conversations in threads

[1036] Step 1:

[1037] A user posts a message in a thread.

[1038] Step 2:

[1039] The device sends the posted message to the server.

[1040] Step 3:

[1041] The server stores the message in a database.

[1042] Step 4:

[1043] The server notifies all participants in the thread of the new message.

[1044] Step 5:

[1045] Generative AI analyzes new messages and generates appropriate responses.

[1046] Step 6:

[1047] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[1048] Step 7:

[1049] The device will display the generated AI's answer on the thread screen.

[1050] Information archiving and retrieval

[1051] Step 1:

[1052] The user selects the option to archive the thread.

[1053] Step 2:

[1054] The device sends an archive request to the server.

[1055] Step 3:

[1056] The server saves the thread as an archive in the database.

[1057] Step 4:

[1058] A user enters search keywords to search archived threads.

[1059] Step 5:

[1060] The device sends a search request to the server.

[1061] Step 6:

[1062] The server searches the database to find the appropriate archive.

[1063] Step 7:

[1064] The server returns the search results to the terminal.

[1065] Step 8:

[1066] The device displays the archived thread to the user.

[1067] Reactions to messages

[1068] Step 1:

[1069] A user "likes" a particular message.

[1070] Step 2:

[1071] The device sends a "like" request to the server.

[1072] Step 3:

[1073] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[1074] Step 4:

[1075] The device will display the updated number of likes on the thread screen.

[1076] Generative AI summary creation

[1077] Step 1:

[1078] The user requests a summary of the entire thread.

[1079] Step 2:

[1080] The terminal sends a summary request to the server.

[1081] Step 3:

[1082] The server passes all messages in the thread to the generated AI for analysis.

[1083] Step 4:

[1084] The generative AI generates a summary based on the message content.

[1085] Step 5:

[1086] The server stores the summary in a database and sends it to the terminal.

[1087] Step 6:

[1088] The device displays a summary on the thread screen.

[1089] Search link provided by AI generation

[1090] Step 1:

[1091] The user asks detailed questions to the generating AI.

[1092] Step 2:

[1093] The device sends the question to the server.

[1094] Step 3:

[1095] The server passes the question content to the generation AI for analysis.

[1096] Step 4:

[1097] The generation AI generates a search link based on the question.

[1098] Step 5:

[1099] The server stores the generated link in a database and sends it to the device.

[1100] Step 6:

[1101] Your device will display the link in the thread screen.

[1102] Example 1

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

[1104] Conventional messaging systems have limited functionality for creating threads for specific messages, making it difficult to hold efficient conversations with multiple people. They also lacked effective ways to manage, summarize, and search information within threads, particularly with advanced support using generative AI. This made it difficult for users to smoothly organize and share information.

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

[1106] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a request to create a thread and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for receiving messages in the thread, saving it in a database, and notifying all participants, means for generating a new message, means for saving the generated message in a database and notifying all participants, means for generating and displaying a summary of the entire thread, and means for generating and displaying a link when a user asks a detailed question. This makes it possible to easily create a thread for a specific message, efficiently advance conversations among multiple people, provide advanced support using generation AI, and smoothly organize and share information.

[1107] "Thread" means an independent stream of conversation associated with a particular message.

[1108] "Thread ID" refers to an identification code generated to uniquely identify a new thread.

[1109] "Database" refers to a system designed to efficiently store, retrieve, and manage data.

[1110] "Terminal" refers to the electronic device, such as a smartphone or computer, that a user uses to access the system.

[1111] "Generative AI" refers to a system that uses artificial intelligence technology to analyze messages and generate responses.

[1112] "Summary" means information that briefly summarizes the main message content in a thread.

[1113] "Link" refers to a URL that provides access to related information generated when a user asks a detailed question.

[1114] A "request" refers to a communication requesting a specific operation or information from a server.

[1115] "Notification" refers to a message sent from the system to convey information to the user.

[1116] A "message" refers to text, images, or other data that a user sends within a thread.

[1117] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation between multiple people, including the AI ​​generator, takes place on a separate screen. Detailed embodiments of this system are described below.

[1118] Creating and Managing Threads

[1119] First, a user selects the "start a thread" option for a particular message within a messaging application by clicking a specific button within the application.

[1120] The device then sends a thread creation request to the server, which is sent as an HTTP POST request to the server's specified endpoint.

[1121] The server generates a unique thread ID for the new thread and saves this ID in a database. The server generates a UUID and saves the information in a database (e.g., MongoDB). At the same time, the server generates screen data for the new thread and returns it to the device in JSON format.

[1122] Finally, the terminal displays the new thread screen to the user. The terminal uses the received JSON data to render HTML in the browser and displays the new thread screen.

[1123] Conversations in threads

[1124] Users post messages in threads. When a user enters text into the input box and clicks the "Send" button, the device sends the message data to the server.

[1125] The server stores the received message in a database and notifies all participants in the thread by storing the message in a "messages" collection in the database and sending notifications to all participants using WebSocket or push notifications.

[1126] When a generative AI receives a new message, it analyzes its content and generates an appropriate response. This analysis and generation process uses natural language processing (NLP) algorithms. For example, GPT-4 can be used as a response generation model.

[1127] The generated answer is sent back to the server and stored in a database. At the same time, the server sends a notification to all participants. The device displays the received answer from the AI ​​on the thread screen.

[1128] Information archiving and retrieval

[1129] When a user selects the option to archive a thread, the device sends an archive request to the server, which updates the status of the thread in the "threads" collection to "archived" and stores it in the database.

[1130] To search for archived threads, a user inputs search keywords and sends a search request from their device to the server. The server queries the database, searches for the relevant archives, and returns the results to the device. The device then displays the search results to the user.

[1131] Reactions to messages

[1132] When a user clicks "like" on a particular message, the device sends a "like" request to the server. The server updates the "likes" field of the message in the database and sends a notification to all participants via WebSocket. The device then displays the updated number of "likes" on the thread screen.

[1133] Generative AI summary creation

[1134] When a user requests a summary of an entire thread, the device sends a summary request to the server. The server passes all messages in the thread to the generation AI, which analyzes them. The generation AI generates a summary and stores it in a database. The server sends the summary to the device, which displays it on the thread screen.

[1135] As a concrete example, the following prompt sentence can be input to a generative AI model:

[1136] "Generate an appropriate response to the message 'Late August might be good'. Include specific questions to help us adjust our travel dates."

[1137] Search link provided by AI generation

[1138] When a user asks a detailed question to the AI, the device sends the question to the server. The server passes the question to the AI, which analyzes it and generates an appropriate search link. The generated link is sent via the server to the device, which then displays it to the user.

[1139] This will result in a system that can effectively manage threads within messaging applications, support conversations with generative AI, archive and search information, react to messages, and provide summaries and search links.

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

[1141] Creating and Managing Threads

[1142] Step 1:

[1143] Subject: User

[1144] A user selects the "Create a thread" option for a particular message within a messaging application, which in turn results in the user clicking the "Create a thread" button.

[1145] Input: User clicks "Start a thread" button

[1146] Output: Create a "thread" request

[1147] Step 2:

[1148] Subject: Terminal

[1149] The device sends a thread creation request to the server, and sends data to the specified endpoint on the server using an HTTP POST request.

[1150] Input: "Start a thread" request

[1151] Output: HTTP POST request to the server

[1152] Step 3:

[1153] Subject: Server

[1154] The server generates a new thread ID and stores it in the database. It generates a UUID and stores it in the "threads" collection in the MongoDB database.

[1155] Input: Thread creation request via HTTP POST request

[1156] Output: Generate a new thread ID and save it to the database

[1157] Step 4:

[1158] Subject: Server

[1159] The server generates screen data for a new thread and sends it to the terminal in JSON format. It then uses a template engine to generate HTML and passes it to the terminal.

[1160] Input: The newly generated thread ID

[1161] Output: Generate and send the new thread's screen data in JSON format.

[1162] Step 5:

[1163] Subject: Terminal

[1164] The device displays the new thread screen to the user. The received JSON data is rendered in the browser and the new thread screen is displayed.

[1165] Input: Screen data sent from the server

[1166] Output: The new thread screen as seen by the user

[1167] Conversations in threads

[1168] Step 1:

[1169] Subject: User

[1170] A user posts a message in a thread by entering text into the input box and clicking the "Send" button.

[1171] Input: The user types into an input box and clicks the "Submit" button

[1172] Output: Generate a request to send a message

[1173] Step 2:

[1174] Subject: Terminal

[1175] The device sends the posted message to the server by sending an HTTP POST request to the server.

[1176] Input: Message data entered by the user

[1177] Output: HTTP POST request to the server

[1178] Step 3:

[1179] Subject: Server

[1180] The server saves the message in a database and notifies all participants in the thread. The server saves the message in a "messages" collection in the database and sends notifications to all participants using WebSocket or push notifications.

[1181] Input: Message data sent in the HTTP POST request

[1182] Output: Save the message to the database and send a notification

[1183] Step 4:

[1184] Subject: Generation AI

[1185] Generative AI analyzes new messages and generates appropriate responses. It uses NLP algorithms to analyze the message content and generates responses using response generation models (e.g., GPT-4).

[1186] Input: A new message posted to a thread

[1187] Output: Answer by generative AI

[1188] Step 5:

[1189] Subject: Server

[1190] The server saves the generated AI's answer in a database and notifies all participants.The server saves the generated answer in a database and notifies all participants via WebSocket or push notification.

[1191] Input: Answer by generative AI

[1192] Output: Save to database and send notification

[1193] Step 6:

[1194] Subject: Terminal

[1195] The device displays the generated AI's answer on the thread screen. The device renders the received answer data and displays it on the thread screen.

[1196] Input: The generated AI's answer data sent from the server

[1197] Output: Display on thread screen

[1198] Information archiving and retrieval

[1199] Step 1:

[1200] Subject: User

[1201] The user selects the option to archive the thread: Clicks the Archive button.

[1202] Input: User clicks the archive button

[1203] Output: Archive request generated

[1204] Step 2:

[1205] Subject: Terminal

[1206] The device sends an archive request to the server using an HTTP POST request.

[1207] Input: User-generated archive request

[1208] Output: HTTP POST request to the server

[1209] Step 3:

[1210] Subject: Server

[1211] The server archives the thread in the database and updates the status of the "threads" collection in the database to "archived."

[1212] Input: Archive Request

[1213] Output: Archive of threads in a database

[1214] Step 4:

[1215] Subject: User

[1216] Users can enter search keywords to search archived threads by entering keywords in the search box and clicking the "Search" button.

[1217] Input: Search keyword

[1218] Output: Generate a search request

[1219] Step 5:

[1220] Subject: Terminal

[1221] The device sends a search request to the server, sending a search query via an HTTP GET request.

[1222] Input: A search request containing the search keyword

[1223] Output: HTTP GET request to the server

[1224] Step 6:

[1225] Subject: Server

[1226] The server searches the database to find the relevant archive. Based on the search query, it queries the database to retrieve the results.

[1227] Input: Search request

[1228] Output: Search results for matching archives

[1229] Step 7:

[1230] Subject: Server

[1231] The server returns the search results to the device. The search results are sent to the device in JSON format.

[1232] Input: Search results

[1233] Output: Send search results to your device

[1234] Step 8:

[1235] Subject: Terminal

[1236] The device displays the archived threads to the user. The device renders the search results and displays the archived threads to the user.

[1237] Input: Search results sent from the server

[1238] Output: Archived threads as seen by the user

[1239] Reactions to messages

[1240] Step 1:

[1241] Subject: User

[1242] A user "likes" a particular message by clicking the "like" icon next to the message.

[1243] Input: User clicks the "Like" icon

[1244] Output: Generate a "Like" request

[1245] Step 2:

[1246] Subject: Terminal

[1247] The device sends a "Like" request to the server. The "Like" data is sent to the server via an HTTP POST request.

[1248] Input: "Like" request

[1249] Output: HTTP POST request to the server

[1250] Step 3:

[1251] Subject: Server

[1252] The server saves the number of "likes" in a database and notifies all participants of the new number of "likes." It updates the "likes" field of the corresponding message in the database and sends a notification to all participants via WebSocket.

[1253] Input: "Like" request

[1254] Output: Update the like count and send a notification

[1255] Step 4:

[1256] Subject: Terminal

[1257] Your device will display the updated number of likes on the thread screen and update the displayed message list to reflect the new number of likes.

[1258] Input: New number of likes sent from the server

[1259] Output: Updated number of likes displayed to the user

[1260] Generative AI summary creation

[1261] Step 1:

[1262] Subject: User

[1263] A user requests a summary of the entire thread by clicking the "Summary" button on the thread screen.

[1264] Input: User clicks "Summary" button

[1265] Output: Generate summary request

[1266] Step 2:

[1267] Subject: Terminal

[1268] The terminal sends a summary request to the server using an HTTP POST request.

[1269] Input: A user-generated summary request

[1270] Output: HTTP POST request to the server

[1271] Step 3:

[1272] Subject: Server

[1273] The server passes all messages in the thread to the AI ​​generator for analysis. All messages in the thread are input into the AI ​​model, and a natural language processing algorithm generates a summary.

[1274] Input: All messages

[1275] Output: Generated summary

[1276] Step 4:

[1277] Subject: Generation AI

[1278] The generative AI generates a summary and stores it in a database.

[1279] Input: All messages in the thread

[1280] Output: Summary data

[1281] Step 5:

[1282] Subject: Server

[1283] The server sends the summary to the terminal, and returns the summary data to the terminal as an HTTP response.

[1284] Input: Generative AI summary

[1285] Output: Send summary data to terminal

[1286] Step 6:

[1287] Subject: Terminal

[1288] The device displays a summary on the thread screen.

[1289] Input: Summary data sent from the server

[1290] Output: A summary that is displayed to the user

[1291] Search link provided by AI generation

[1292] Step 1:

[1293] Subject: User

[1294] The user asks the AI ​​a detailed question, enters the question, and clicks the "Submit" button.

[1295] Input: User's question

[1296] Output: Generate a question request

[1297] Step 2:

[1298] Subject: Terminal

[1299] The device sends the question to the server using an HTTP POST request.

[1300] Input: The question typed by the user

[1301] Output: HTTP POST request to the server

[1302] Step 3:

[1303] Subject: Server

[1304] The server passes the question to the AI ​​generator for analysis, inputs the question into the AI ​​model, and generates an appropriate search link.

[1305] Input: User's question

[1306] Output: Generated search link

[1307] Step 4:

[1308] Subject: Generation AI

[1309] The generation AI generates the appropriate search link and returns it to the server.

[1310] Input: User's question

[1311] Output: Generated search link

[1312] Step 5:

[1313] Subject: Server

[1314] The server sends the generated link to the device.

[1315] Input: Search link generated by AI

[1316] Output: Sending link data to the terminal

[1317] Step 6:

[1318] Subject: Terminal

[1319] Your device will display the link in the thread screen.

[1320] Input: Search link sent from the server

[1321] Output: The link that is displayed to the user

[1322] The above are the specific processing steps of this system. By explaining the process from input to output in detail, the processing flow can be clearly understood.

[1323] (Application example 1)

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

[1325] In manufacturing processes, efficient and effective communication is required when workers and engineers identify problems in the manufacturing process and discuss improvement measures. Conventional methods can delay discussions to quickly resolve problems in the manufacturing process, potentially resulting in a decline in overall productivity. The present invention aims to provide a system that enables workers, engineers, and generative AI to work together to identify problems in the manufacturing process and quickly propose improvement measures to address these issues.

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

[1327] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a request to create a thread and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for managing threads for discussions about the manufacturing process, and means for using a generation AI that identifies problems in the manufacturing process and proposes improvement measures. This makes it possible to efficiently discuss problems in the manufacturing process through threads and quickly take improvement measures based on suggestions from the generation AI.

[1328] A "thread" is a unit for separating and managing a series of messages or conversations on a particular topic.

[1329] A "thread ID" is an identifier generated by the system to uniquely identify an individual thread.

[1330] A "database" is a data structure that stores information in an organized manner and allows it to be efficiently searched and updated.

[1331] "Generative AI" is a system that uses artificial intelligence technology to generate responses and suggestions in the form of text or voice.

[1332] A "terminal" is a device that allows a user to access and operate the system. Examples include smartphones and computers.

[1333] A "manufacturing process" is a series of operations and treatments that are carried out to create a product from raw materials.

[1334] A "message" is data such as text, audio, or images used to convey information between users or systems.

[1335] "Archiving" is the process of storing data or information that is no longer in use so that it can be retrieved later when needed.

[1336] "Notification" is a function that allows the system to notify the user when a specific event or information occurs.

[1337] A "summary" is a short sentence that concisely summarizes a longer text or multiple messages.

[1338] This invention relates to a "manufacturing process improvement thread management application" for efficiently improving manufacturing processes. This system creates threads for specific messages, and workers, engineers, and generation AI work together to identify problems in the manufacturing process and propose improvement measures.

[1339] Explanation of program processing

[1340] Creating a Thread

[1341] The user selects the "Create a thread" option for a specific message related to the manufacturing process. The device sends the request to the server, which generates a unique thread ID and stores it in the database. At the same time, it also generates screen data for the thread and sends it to the device.

[1342] Posting and parsing messages

[1343] When a user posts a message in a thread, the device sends the message to the server, which stores the message in a database and notifies all participants in the thread. The generative AI also analyzes the new message and generates an appropriate response or suggestion. The server stores the generated response in a database and notifies all participants in the thread.

[1344] Archive and search threads

[1345] A user selects the option to archive a thread and submits an archive request. The server stores the thread as an archive in its database, making it available for future retrieval. When a user searches the archives by entering specific keywords, the server searches the database and returns the results.

[1346] Generate a summary

[1347] A user can request a summary of an entire thread. The server passes all messages in the thread to the AI ​​generator, which generates a summary. The server stores the summary in a database and sends it to the device.

[1348] Hardware and software used

[1349] Hardware: Robot terminals used in factories, servers (computers that process the database and generative AI)

[1350] Software: Python language, AI response generation model (e.g., GPT-4), SQL database (e.g., PostgreSQL)

[1351] Specific example explanation

[1352] Example 1: Improving bottlenecks on a production line

[1353] Worker A sends a message saying, "I want to discuss the bottleneck on the production line," creating a new thread. Engineer B posts, "The bottleneck is caused by Machine X stopping frequently." The AI ​​generator responds, "To reduce the frequency of Machine X stopping, we need to change the routine maintenance schedule."

[1354] Example 2: Summary of progress for a long-term project

[1355] User A requests a summary of the entire thread. The server sends the summary request to the generation AI. The generation AI generates a summary saying, "The project is 60% complete, and the next step is to adjust equipment Y."

[1356] Prompt Sentence Examples

[1357] Message response generation:

[1358] Message: "Machine X is experiencing frequent downtime"

[1359] Prompt: "From a manufacturing process perspective, what suggestions can you make to reduce the downtime of machine X?"

[1360] Thread summary generation:

[1361] Prompt: "Summarize the following messages: [message 1, message 2, message 3, ...]"

[1362] In this way, this system makes it possible to efficiently discuss problems in the manufacturing process through threads and quickly take improvement measures based on suggestions from the generative AI.

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

[1364] Step 1:

[1365] (Step 1) The user selects the "Create a thread" option for a specific message related to the manufacturing process.

[1366] (Input) The message for which the user selected the "start a thread" option.

[1367] (Output) A thread creation request is sent from the terminal to the server.

[1368] (Specific operation) The user selects a specific message on the device screen and clicks the "Create a thread" button. This generates a thread creation request, which is sent from the device to the server as an HTTP request.

[1369] Step 2:

[1370] (Step 2) The server generates a unique thread ID and stores it in the database.

[1371] (Input) A thread creation request.

[1372] (Output) The generated thread ID and screen data for the thread are sent to the terminal.

[1373] (Specific operation) After the server receives a thread creation request, it generates a unique identifier (thread ID) and stores it in the database. It then generates screen data for the thread and notifies the terminal.

[1374] Step 3:

[1375] (Step 3) A user posts a message in the thread.

[1376] (Input) The message posted by the user.

[1377] (Output) A message is sent from the terminal to the server.

[1378] (Specific operation) The user enters a message in the input field of the terminal and clicks the send button, which sends the message data from the terminal to the server as an HTTP request.

[1379] Step 4:

[1380] (Step 4) The server saves the message in a database and notifies all participants in the thread.

[1381] (Input) The message posted by the user.

[1382] (Output) The message is saved in the database and notified to all participants.

[1383] (Specific operation) The server stores the received message in a database and sends a notification to the terminals of other users participating in the thread.

[1384] Step 5:

[1385] (Step 5) Generative AI analyzes the new message and generates an appropriate response or suggestion.

[1386] (Input) The message posted by the user.

[1387] (Output) The answer or suggestion from the generative AI.

[1388] (Specific operation) The server sends message data to the generation AI, which analyzes the prompt and generates an appropriate answer or suggestion. Example: "From the perspective of improving the manufacturing process, please make a suggestion to reduce the frequency of machine X's stoppages."

[1389] Step 6:

[1390] (Step 6) The server saves the answer generated by the generated AI in a database and notifies all participants in the thread.

[1391] (Input) Answers or suggestions from the generative AI.

[1392] (Output) The answers are stored in a database and notified to all participants.

[1393] (Specific operation) The server stores the answer received from the generation AI in a database and sends a notification to the devices of all users participating in the thread.

[1394] Step 7:

[1395] (Step 7) The user selects the option to archive the thread and submits the archive request.

[1396] (Input) A request to archive a thread selected by the user.

[1397] (Output) An archive request is sent from the terminal to the server.

[1398] (Specific operation) The user selects the "Archive" option on the terminal screen, generating a request to archive the thread.

[1399] Step 8:

[1400] (Step 8) The server saves the thread as an archive in the database.

[1401] (Input) Archive request.

[1402] (Output) The thread is saved as an archive in the database.

[1403] (Specific operation) The server receives the archive request and saves the corresponding thread as an archive in the database.

[1404] Step 9:

[1405] (Step 9) The user submits a request to search the archive by entering a specific keyword.

[1406] (Input) Search keywords specified by the user.

[1407] (Output) A search request is sent from the device to the server.

[1408] (Specific operation) The user enters a specific keyword into the search bar of the device and clicks the search button.

[1409] Step 10:

[1410] (Step 10) The server searches the database and finds the appropriate archive.

[1411] (Input) Search keywords.

[1412] (Output) Corresponding archive data.

[1413] (Specific operation) The server searches the database, finds archive data that matches the specified keywords, and generates search results.

[1414] Step 11:

[1415] (Step 11) The server sends the search results to the terminal and displays them to the user.

[1416] (Input) Applicable archive data.

[1417] (Output) The search results are displayed on the terminal.

[1418] (Specific operation) The search results generated by the server are sent to the terminal, which then displays them to the user.

[1419] Step 12:

[1420] (Step 12) The user sends a request for a summary of the entire thread.

[1421] (Input) A summary of the user's request.

[1422] (Output) A summary request is sent from the terminal to the server.

[1423] (Specific operation) The user selects a summary option on the terminal screen and sends a request.

[1424] Step 13:

[1425] (Step 13) The server passes all messages in the thread to the generation AI, which generates a summary.

[1426] (Input) All message data for the thread.

[1427] (Output) Generative AI summary.

[1428] (Specific operation) The server retrieves all messages in the thread and has the generation AI analyze them. The generation AI generates a summary based on the message data.

[1429] Step 14:

[1430] (Step 14) The server stores the generated summary in a database and transmits it to the terminal.

[1431] (Input) Summary by generative AI.

[1432] (Output) The summary is stored in the database and displayed on the terminal.

[1433] (Specific operation) The server stores the summary received from the generation AI in a database and sends it to the user's device.

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

[1435] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation can be held on a separate screen with multiple people, including a generation AI. It also has the function of generating a response according to the user's emotions by combining it with an emotion engine that analyzes the user's message and recognizes their emotions. This system is realized by the following specific programs and their processing:

[1436] Creating and Managing Threads

[1437] A user selects the "Create a thread" option for a specific message in a conversation.

[1438] The terminal sends a thread creation request to the server.

[1439] The server generates a unique thread ID for the new thread and stores it in the database. At the same time, it generates screen data and sends it to the device.

[1440] The terminal displays the new thread screen to the user.

[1441] Conversations in threads

[1442] A user posts a message in a thread.

[1443] The device sends the posted message to the server.

[1444] The server saves the message in a database and notifies all participants in the thread of the new message.

[1445] The emotion engine analyzes the message and recognizes the user's emotions.

[1446] The generative AI analyzes new messages based on the analysis results of the emotion engine and generates appropriate responses.

[1447] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[1448] The device will display the generated AI's answer on the thread screen.

[1449] Information archiving and retrieval

[1450] The user selects the option to archive the thread.

[1451] The device sends an archive request to the server.

[1452] The server stores the relevant thread and emotion data in a database as an archive.

[1453] A user enters search keywords to search archived threads.

[1454] The device sends a search request to the server.

[1455] The server searches the database to find the appropriate archive.

[1456] The server returns the search results to the terminal.

[1457] The device displays the archived thread to the user.

[1458] Reactions to messages

[1459] A user "likes" a particular message.

[1460] The device sends a "like" request to the server.

[1461] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[1462] The device will display the updated number of likes on the thread screen.

[1463] Generative AI summary creation

[1464] The user requests a summary of the entire thread.

[1465] The terminal sends a summary request to the server.

[1466] The server passes all messages in the thread to the generated AI for analysis.

[1467] The generative AI generates a summary based on the message content.

[1468] The server stores the summary in a database and sends it to the terminal.

[1469] The device displays a summary on the thread screen.

[1470] Search link provided by AI generation

[1471] The user asks detailed questions to the generating AI.

[1472] The device sends the question to the server.

[1473] The server passes the question content to the generation AI for analysis.

[1474] The generation AI generates a search link based on the question.

[1475] The server stores the generated link in a database and sends it to the device.

[1476] Your device will display the link in the thread screen.

[1477] Use of emotion engine

[1478] The emotion engine analyzes messages from users and recognizes their emotions.

[1479] The emotion engine provides the recognition results to the generative AI.

[1480] The generative AI adjusts the response based on the user's emotions, responding faster if the emotion is positive and more politely if the emotion is negative.

[1481] The server stores the emotion data in a database and uses it to track changes in emotion.

[1482] Specific examples

[1483] Create and manage itinerary coordination threads

[1484] 1. User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[1485] 2. The device sends a thread creation request to the server.

[1486] 3. The server generates a new thread ID and stores it in the database.

[1487] 4. The device displays the new thread screen to User A.

[1488] 5. User B posts a message saying, "Maybe the end of August would be good."

[1489] 6. The device sends the message to the server.

[1490] 7. The server saves the message in the database and notifies all participants.

[1491] 8. The emotion engine analyzes the message and recognizes that User B has a positive emotion.

[1492] 9. The generative AI quickly generates a response: "Since it's the end of August, what date exactly is it scheduled for?"

[1493] 10. The server stores the generated AI's response in a database and notifies all participants.

[1494] 11. The device will display the generated AI's response.

[1495] Generate a thread summary

[1496] 1. User A requests a summary of the entire thread.

[1497] 2. The terminal sends a summary request to the server.

[1498] 3. The server passes all messages in the thread to the generated AI for analysis.

[1499] 4. The generation AI generates a summary such as "The travel dates have been decided as August 28th to 30th."

[1500] 5. The server stores the summary in a database and sends it to the terminal.

[1501] 6. The terminal displays the summary to User A.

[1502] These features allow users to create threads based on their own purposes and needs, and efficiently organize and share information with the support of generative AI and an emotion engine.

[1503] The processing flow will be explained below.

[1504] Creating and Managing Threads

[1505] Step 1:

[1506] A user selects the "Create a thread" option for a specific message in a conversation.

[1507] Step 2:

[1508] The terminal sends a thread creation request to the server.

[1509] Step 3:

[1510] The server generates a unique thread ID for the new thread and stores it in the database.

[1511] Step 4:

[1512] The server generates screen data for the thread and sends it to the terminal.

[1513] Step 5:

[1514] The terminal displays the new thread screen to the user.

[1515] Conversations in threads

[1516] Step 1:

[1517] A user posts a message in a thread.

[1518] Step 2:

[1519] The device sends the posted message to the server.

[1520] Step 3:

[1521] The server stores the message in a database.

[1522] Step 4:

[1523] The server notifies all participants in the thread of the new message.

[1524] Step 5:

[1525] The emotion engine analyzes new messages and recognizes the user's emotions.

[1526] Step 6:

[1527] The generative AI analyzes new messages based on the analysis results of the emotion engine and generates appropriate responses.

[1528] Step 7:

[1529] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[1530] Step 8:

[1531] The device will display the generated AI's answer on the thread screen.

[1532] Information archiving and retrieval

[1533] Step 1:

[1534] The user selects the option to archive the thread.

[1535] Step 2:

[1536] The device sends an archive request to the server.

[1537] Step 3:

[1538] The server stores the relevant thread and emotion data in a database as an archive.

[1539] Step 4:

[1540] A user enters search keywords to search archived threads.

[1541] Step 5:

[1542] The device sends a search request to the server.

[1543] Step 6:

[1544] The server searches the database to find the appropriate archive.

[1545] Step 7:

[1546] The server returns the search results to the terminal.

[1547] Step 8:

[1548] The device displays the archived thread to the user.

[1549] Reactions to messages

[1550] Step 1:

[1551] A user "likes" a particular message.

[1552] Step 2:

[1553] The device sends a "like" request to the server.

[1554] Step 3:

[1555] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[1556] Step 4:

[1557] The device will display the updated number of likes on the thread screen.

[1558] Generative AI summary creation

[1559] Step 1:

[1560] The user requests a summary of the entire thread.

[1561] Step 2:

[1562] The terminal sends a summary request to the server.

[1563] Step 3:

[1564] The server passes all messages in the thread to the generated AI for analysis.

[1565] Step 4:

[1566] The generative AI generates a summary based on the message content.

[1567] Step 5:

[1568] The server stores the generated summary in a database and transmits it to the terminal.

[1569] Step 6:

[1570] The device displays a summary on the thread screen.

[1571] Search link provided by AI generation

[1572] Step 1:

[1573] The user asks detailed questions to the generating AI.

[1574] Step 2:

[1575] The device sends the question to the server.

[1576] Step 3:

[1577] The server passes the question content to the generation AI for analysis.

[1578] Step 4:

[1579] The generation AI generates a search link based on the question.

[1580] Step 5:

[1581] The server stores the generated link in a database and sends it to the device.

[1582] Step 6:

[1583] Your device will display the link in the thread screen.

[1584] Use of emotion engine

[1585] Step 1:

[1586] The emotion engine analyzes messages from users and recognizes their emotions.

[1587] Step 2:

[1588] The emotion engine provides the recognition results to the generative AI.

[1589] Step 3:

[1590] The generative AI adjusts the response based on the user's emotions, responding faster if the emotion is positive and more politely if the emotion is negative.

[1591] Step 4:

[1592] The server stores the emotion data in a database and uses it to track changes in emotion.

[1593] Specific examples

[1594] Create and manage itinerary coordination threads

[1595] Step 1:

[1596] User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[1597] Step 2:

[1598] The terminal sends a thread creation request to the server.

[1599] Step 3:

[1600] The server generates a new thread ID and stores it in the database.

[1601] Step 4:

[1602] The device displays the new thread screen to User A.

[1603] Step 5:

[1604] User B posts a message saying, "Maybe the end of August would be good."

[1605] Step 6:

[1606] The device sends a message to the server.

[1607] Step 7:

[1608] The server stores the message in a database and notifies all participants.

[1609] Step 8:

[1610] The emotion engine analyzes the message and recognizes that User B has a positive emotion.

[1611] Step 9:

[1612] The generative AI quickly generates a response such as, "Since it's the end of August, what date exactly is it scheduled for?"

[1613] Step 10:

[1614] The server stores the generated AI's response in a database and notifies all participants.

[1615] Step 11:

[1616] The terminal will display the generated AI's response.

[1617] Generate a thread summary

[1618] Step 1:

[1619] User A requests a summary of the entire thread.

[1620] Step 2:

[1621] The terminal sends a summary request to the server.

[1622] Step 3:

[1623] The server passes all messages in the thread to the generated AI for analysis.

[1624] Step 4:

[1625] The generative AI generates a summary such as "The travel dates have been set for August 28th to 30th."

[1626] Step 5:

[1627] The server stores the generated summary in a database and transmits it to the terminal.

[1628] Step 6:

[1629] The terminal displays the summary to User A.

[1630] Example 2

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

[1632] Conventional messaging applications lack the ability to create threads for specific messages and efficiently manage conversations on a separate screen. They also lack a mechanism for automatically generating responses based on the user's emotions, making it difficult to improve the user experience. Furthermore, they also have limited functionality for archiving past threads and quickly searching for necessary information. To address these issues, an efficient and user-friendly communication system is needed.

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

[1634] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a thread creation request and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for a user to post a message in the created thread, means for saving the posted message in a database and notifying all participants, means for analyzing the message using a generative AI model and generating an appropriate response, and means for analyzing the emotion of the message using an emotion analysis engine and providing the analysis result to the generative AI model. This allows users to efficiently manage conversations, enables the generative AI and the emotion engine to work together to automatically generate responses according to the user's emotions, and provides a system for efficiently archiving and searching thread information.

[1635] A "thread" is an independent unit of communication for centrally managing a series of conversations or exchanges related to a particular message.

[1636] A "thread ID" is an identification code generated by the server to uniquely identify a thread.

[1637] "Terminal" is a general term for electronic devices used by users, such as computers, smartphones, and tablets.

[1638] A "server" is a central computer system that processes, manages, and stores data.

[1639] A "database" is an information system for systematically storing and managing data such as threads, messages, and user information.

[1640] A "generative AI model" is a program that uses artificial intelligence algorithms to analyze a user's message and generate an appropriate response.

[1641] An "emotion analysis engine" is a system that analyzes a user's message and recognizes their emotional state (positive, negative, neutral, etc.).

[1642] "Archiving" refers to the process of saving threads or messages so that they can be retrieved later, or the saved data.

[1643] A "notification" is information sent by a server to a terminal or user to notify them of a new message or event.

[1644] A "reaction" refers to an evaluation action such as a "like" that a user takes on a particular message.

[1645] A "search link" is an access link to related information generated by the generative AI model in response to a user's detailed question.

[1646] A "summary" is a sentence or piece of information that analyzes all messages in a thread and succinctly summarizes their contents.

[1647] This invention is a system that allows users to create threads for specific messages and use generative AI models and sentiment analysis engines to communicate efficiently and effectively. This system consists of a server, a terminal, and software that links them.

[1648] Hardware and software used

[1649] Server: A central computer system that processes, manages, and stores data.

[1650] Device: The electronic device used by the user, such as a computer, smartphone, or tablet.

[1651] Generative AI model: A program that uses artificial intelligence algorithms to analyze a user's message and generate an appropriate response (e.g., GPT-4).

[1652] Sentiment Analysis Engine: A system for analyzing users' messages and recognizing their emotional state.

[1653] Overall system operation

[1654] 1. Creating and Managing Threads

[1655] When a user creates a thread for a specific message in a messaging app, the device sends a thread creation request to the server.

[1656] The server generates a unique thread ID and stores it in the database. At the same time, it generates screen data for the thread and sends it to the device.

[1657] The terminal will display the new thread screen to the user.

[1658] Conversations in threads

[1659] A user posts a message in a thread and sends it to the server from their device.

[1660] The server stores the message in a database and notifies all participants.

[1661] The sentiment analysis engine analyzes the message and recognizes the user's sentiment.

[1662] The generative AI model generates an appropriate response based on the results of the emotion analysis.

[1663] The server stores the responses from the generative AI model in a database and notifies all participants.

[1664] The device displays the response of the generated AI model on the thread screen.

[1665] Information archiving and retrieval

[1666] The user selects the option to archive the thread, and the terminal sends an archive request to the server.

[1667] The server stores the relevant thread and emotion data in a database.

[1668] A user inputs a search keyword to search an archived thread, and the terminal sends a search request to the server.

[1669] The server searches the database, finds the relevant archive, and sends it to the terminal.

[1670] The device displays archived threads.

[1671] Reactions to messages

[1672] When a user presses the "Like" button for a particular message, the device sends a "Like" request to the server.

[1673] The server stores the number of "likes" in a database and notifies all participants.

[1674] The device will display the updated number of likes on the thread screen.

[1675] Generative AI summary creation

[1676] A user requests a summary of an entire thread, and the terminal sends a summary request to the server.

[1677] The server passes all messages in the thread to the generative AI model for analysis.

[1678] The generative AI model generates a summary, which the server stores in a database and sends to the device.

[1679] The terminal displays the summary to the user.

[1680] Search link provided by AI generation

[1681] When a user asks a detailed question to the generative AI model, the device sends the question to the server.

[1682] The server passes the question to the generative AI model for analysis.

[1683] A generative AI model generates search links based on the question.

[1684] The server stores the generated link in a database and sends it to the device.

[1685] The device will display the generated link on the thread screen.

[1686] Use of sentiment analysis engine

[1687] The sentiment analysis engine analyzes messages from users and recognizes their emotional state.

[1688] The emotion analysis engine provides the recognition results to the generative AI model, which then adjusts the response content based on the user's emotions.

[1689] The server stores the emotion data in a database and uses it to track changes in emotion.

[1690] Specific example explanation

[1691] Consider the example of a thread for coordinating travel itineraries. When user A creates a thread in response to the message "Let's decide on this year's travel dates," the device sends a thread creation request to the server. The server generates a new thread ID and saves it in the database. The device displays the new thread screen to user A. When user B posts the message "The end of August might be good," the device sends the message to the server. The server saves the message in the database and notifies all participants. The sentiment analysis engine analyzes the message and recognizes that user B has positive emotions. The generation AI quickly generates a response: "Since the end of August, what date exactly is it planned for?" The server saves the generation AI's response in the database and notifies all participants. The device displays the generation AI's response.

[1692] Example prompt sentence:

[1693] "In this thread about deciding travel dates, please gather everyone's opinions and suggest the best travel dates."

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

[1695] Step 1:

[1696] A user selects the "Create a thread" option for a specific message in a messaging app.

[1697] Input: The "start a thread" option that the user controls.

[1698] What happens: The user clicks the thread creation button in the app.

[1699] Output: A thread creation request is generated.

[1700] Step 2:

[1701] The terminal sends a thread creation request to the server.

[1702] Input: A thread creation request initiated by a user.

[1703] Operation: The device sends request data to the server.

[1704] Output: The server receives the thread creation request.

[1705] Step 3:

[1706] The server generates a unique thread ID and stores it in the database.

[1707] Input: The thread creation request received by the server.

[1708] How it works: The server generates a unique thread ID using a UUID (Universally Unique ID) generation algorithm, and stores the generated thread ID and associated data in a database.

[1709] Output: A unique thread ID is generated and stored in the database.

[1710] Step 4:

[1711] The server generates screen data for the thread and sends it to the terminal.

[1712] Input: The generated thread ID.

[1713] Operation: The server generates the initial screen data for the thread and sends it to the terminal.

[1714] Output: Screen data is generated and sent to the device.

[1715] Step 5:

[1716] The device displays the new thread screen to the user.

[1717] Input: Screen data sent from the server.

[1718] Behavior: Updates the user interface based on the data received by the device.

[1719] Output: The new thread screen is displayed to the user.

[1720] Step 6:

[1721] A user posts a message in a thread.

[1722] Input: The message entered by the user.

[1723] What happens: The user enters text into the message input field and clicks the send button.

[1724] Output: The message is sent.

[1725] Step 7:

[1726] The device sends the posted message to the server.

[1727] Input: The message entered by the user.

[1728] Operation: The device sends message data to the server.

[1729] Output: The server receives the message data.

[1730] Step 8:

[1731] The server saves the message in a database and notifies all participants in the thread of the new message.

[1732] Input: Message data sent from the terminal.

[1733] What it does: The server stores the received message in a database. The notification module notifies all participants that a new message has been posted.

[1734] Output: The message is saved in the database and all participants are notified.

[1735] Step 9:

[1736] The sentiment analysis engine analyzes the message and recognizes the user's emotions.

[1737] Input: The message data received by the server.

[1738] How it works: The sentiment analysis engine uses natural language processing algorithms to analyze messages and assign sentiment labels (e.g., positive, negative, neutral).

[1739] Output: The sentiment analysis results are generated.

[1740] Step 10:

[1741] The generative AI model analyzes new messages based on the sentiment analysis results and generates appropriate responses.

[1742] Input: Sentiment analysis results from the sentiment analysis engine and messages posted by users.

[1743] How it works: A generative AI model (e.g., GPT-4) generates an appropriate answer based on the prompt.

[1744] Output: A generated response message is generated.

[1745] Step 11:

[1746] The server stores the response from the generated AI model in a database and notifies all participants in the thread.

[1747] Input: The generated response message.

[1748] How it works: The server stores the generated response in a database and the notification module notifies all participants.

[1749] Output: The response message is saved in the database and notified to all participants.

[1750] Step 12:

[1751] The device displays the response of the generated AI model on the thread screen.

[1752] Input: The response message sent by the server.

[1753] Behavior: The response message received by the device is displayed on the thread screen.

[1754] Output: A response message is displayed to the user.

[1755] These processing steps allow users to communicate efficiently and receive appropriate responses leveraging the collaboration of generative AI and sentiment analysis engines.

[1756] (Application example 2)

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

[1758] Traditional messaging systems lacked the ability to create threads for specific messages and generate responses based on user sentiment. They also faced challenges in effectively managing information within threads and providing user reactions and archiving functions. This resulted in a poor user experience and hindered efficient communication.

[1759] The specific processing by the specific 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 providing an option to create a thread for a specific message, means for receiving a thread creation request and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to the terminal, means for analyzing the message using an emotion engine and recognizing the user's emotion, and means for the generation AI to generate an appropriate response based on the recognized emotion. This allows the user to create a thread for a specific message and receive a response based on the emotion, thereby realizing efficient communication.

[1760] The "threading option" is a feature that allows users to create a new conversation flow for a particular message.

[1761] The "thread ID" is an identifier for uniquely identifying a created thread.

[1762] "Screen data" is a data set that contains visual information of a thread for display on a user terminal.

[1763] An "emotion engine" is software or algorithms that analyze a user's message and recognize its emotion.

[1764] "Generative AI" is an artificial intelligence system that automatically generates appropriate responses based on the results of analysis by the emotion engine.

[1765] A "reaction" is an action taken by a user to indicate a positive or negative evaluation of a particular message or response.

[1766] "Archiving" is the process of saving specific threads or conversations so that they can be searched or referenced later.

[1767] A "summary" is information that briefly summarizes the contents of the entire thread.

[1768] A "database" is a system for systematically storing and managing information such as threads, messages, and sentiment analysis results.

[1769] A "notification" is a means of informing a user that a particular event or message has occurred.

[1770] The system based on this invention mainly utilizes a server, a terminal, an emotion engine, a generation AI, and a database to provide messaging between users and a response function based on emotion recognition.

[1771] Hardware and software used

[1772] Hardware: Smartphone or computer

[1773] Software: Messaging application, emotion engine (EmotionAPI), generative AI (ChatGPT), database (PostgreSQL)

[1774] Program processing

[1775] Thread creation

[1776] When a user selects the "Create a thread" option for a particular message, the device sends this thread creation request to the server, which generates a new thread ID and stores it in the database. It also generates screen data for the thread and sends it to the device for display.

[1777] Sentiment Analysis and Response Generation

[1778] When a user posts a message in a thread, the device sends this message to the server. The server saves the posted message in a database and notifies all participants in the thread. The emotion engine analyzes the message and recognizes the user's emotion. The recognition result is provided to the generation AI, which generates an appropriate response. The server saves the response from the generation AI in a database and notifies all participants.

[1779] Reactions and Feedback

[1780] When a user clicks "like" or "rating" on a particular message, the device sends this reaction request to the server, which stores the reaction count in a database and notifies all participants of the new reaction count.

[1781] Thread archives and summaries

[1782] When a user selects the option to archive a thread, the device sends an archive request to the server, which stores the thread in a database and makes it available for future searches. Additionally, if the user requests a summary of the entire thread, the server passes the request to a generation AI, which generates the summary. The generated summary is stored in a database and sent to the device.

[1783] Specific examples

[1784] For example, consider the case where User A asks a question in a live chat, "Please tell me how to use Product A." This message is recognized as positive by the emotion engine. In response, the generation AI immediately responds, "I'll explain in detail how to use Product A!" If, as the conversation progresses, a request to "know more" arises, it is possible to create a thread summarizing the content and provide more information on a separate screen.

[1785] Prompt Sentence Examples

[1786] "A user is asking about how to use Product A. The sentiment engine recognized a positive sentiment. Generate an appropriate response."

[1787] This system allows users to receive appropriate support that corresponds to their emotions, enabling efficient communication.

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

[1789] Step 1:

[1790] When a user selects the "Create a thread" option for a particular message, the device sends this thread creation request to the server.

[1791] Input: User thread creation request

[1792] Data processing: Converting thread creation requests into data format

[1793] Output: Thread creation request data

[1794] Step 2:

[1795] The server generates a new thread ID and saves it in the database. At the same time, it generates screen data for the thread and sends it to the device.

[1796] Input: Thread creation request data

[1797] Data calculation: Generate a unique thread ID and save it in the database. Generate screen data for the thread.

[1798] Output: Thread ID and screen data

[1799] Step 3:

[1800] The device displays the new thread screen to the user.

[1801] Input: Thread ID and screen data

[1802] Data processing: Convert screen data into display format

[1803] Output: Thread screen displayed

[1804] Step 4:

[1805] A user posts a message in a thread, and the device sends this message to the server.

[1806] Input: User's message

[1807] Data processing: converting messages into data format

[1808] Output: Message data

[1809] Step 5:

[1810] The server stores the posted message in a database and notifies all participants in the thread.

[1811] Input: Message data

[1812] Data calculation: Message storage in the database and generation of notification data

[1813] Output: Stored message and notification data

[1814] Step 6:

[1815] The emotion engine analyzes the message and recognizes the user's emotions.

[1816] Input: Posted message data

[1817] Data calculation: Emotion data generation by applying emotion analysis algorithms

[1818] Output: Emotion analysis results

[1819] Step 7:

[1820] The recognition results are provided to the generation AI, which generates an appropriate response.

[1821] Input: Sentiment analysis results

[1822] Data Computation: Using generative AI models to generate appropriate responses based on emotional data

[1823] Output: The generated response

[1824] Step 8:

[1825] The server stores the generated AI's response in a database and notifies all participants.

[1826] Input: The generated response

[1827] Data calculation: Save response data and generate notification data

[1828] Output: Response notification data

[1829] Step 9:

[1830] The device displays the generated AI's response on the thread screen.

[1831] Input: Response notification data

[1832] Data processing: Convert response data into a display format

[1833] Output: Response data displayed in the thread view

[1834] Step 10:

[1835] When a user clicks "like" or rates a particular message, the device sends this reaction request to the server.

[1836] Input: User reaction data

[1837] Data processing: Converting reaction data into a transmission format

[1838] Output: Reaction request data

[1839] Step 11:

[1840] The server saves the number of reactions in a database and notifies all participants of the new number of reactions.

[1841] Input: Reaction request data

[1842] Data calculation: Update the number of reactions and generate notification data

[1843] Output: Updated reaction count and notification data

[1844] Step 12:

[1845] When a user selects the option to archive a thread, the terminal sends an archive request to the server.

[1846] Input: User's archive request

[1847] Data processing: Converting archive request data

[1848] Output: Archive request data

[1849] Step 13:

[1850] The server stores the thread in a database, making it available for later retrieval.

[1851] Input: Archive request data

[1852] Data operation: Save the corresponding thread in the database and set it to searchable

[1853] Output: Archived thread data

[1854] Step 14:

[1855] When a user requests a summary for an entire thread, the server passes the request to the generation AI, which generates the summary.

[1856] Input: Summary request data

[1857] Data Computation: Message Summarization by Generative AI

[1858] Output: Generated summary data

[1859] Step 15:

[1860] The generated summary is stored in a database and transmitted to the terminal.

[1861] Input: Summary data

[1862] Data calculation: saving summary data and sending it to the terminal

[1863] Output: Summary data displayed on the terminal

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

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

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

[1867] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1880] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation between multiple people, including the AI ​​generator, takes place on a separate screen. This system is realized by the following specific programs and their processing:

[1881] Creating and Managing Threads

[1882] Users: Select the "Start a thread" option for a specific message in a conversation.

[1883] Terminal: Sends a thread creation request to the server.

[1884] Server: Generates a unique thread ID for the new thread and saves it in the database. At the same time, it generates screen data and sends it to the device.

[1885] Terminal: Shows the new thread screen to the user.

[1886] Conversations in threads

[1887] User: Post a message in a thread.

[1888] Terminal: Sends posted messages to the server.

[1889] Server: Saves the message in a database and notifies all participants in the thread.

[1890] Generative AI: Analyzes new messages and generates appropriate responses.

[1891] Server: Saves the generated AI's answers in a database and notifies all participants in the thread.

[1892] Device: Display the generated AI's answer on the thread screen.

[1893] Information archiving and retrieval

[1894] Users: Select the option to archive the thread.

[1895] Terminal: Sends an archive request to the server.

[1896] Server: Save the thread as an archive in the database.

[1897] Users: Enter search keywords to search archived threads.

[1898] Device: Sends a search request to the server.

[1899] Server: Searches the database to find the appropriate archive.

[1900] Server: Returns search results to the device.

[1901] Terminal: Show archived threads to the user.

[1902] Reactions to messages

[1903] User: Likes a specific message.

[1904] Device: Sends a "like" request to the server.

[1905] Server: Stores the number of likes in a database and notifies all participants of the new number of likes.

[1906] On your device: See the updated number of likes on the thread view.

[1907] Generative AI summary creation

[1908] User: Request a summary of the entire thread.

[1909] Terminal: Sends a summary request to the server.

[1910] Server: Passes all messages in the thread to the generated AI for analysis.

[1911] Generative AI: Generates a summary based on the message content.

[1912] Server: Stores the summary in a database and sends it to the device.

[1913] Terminal: Display the summary in the thread view.

[1914] Search link provided by AI generation

[1915] User: Asks detailed questions to the generating AI.

[1916] Terminal: Sends the question to the server.

[1917] Server: Passes the question content to the generation AI for analysis.

[1918] Generative AI: Generates search links based on the question.

[1919] Server: Stores the generated link in a database and sends it to the device.

[1920] On your device: View the link in the thread view.

[1921] Specific examples

[1922] Create and manage itinerary coordination threads

[1923] 1. User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[1924] 2. The device sends a thread creation request to the server.

[1925] 3. The server generates a new thread ID and saves it in the database. At the same time, it generates screen data and sends it to the device.

[1926] 4. The device displays the new thread screen to User A.

[1927] 5. User B posts a message saying, "Maybe the end of August would be good."

[1928] 6. The device sends the message to the server.

[1929] 7. The server saves the message in the database and notifies all participants.

[1930] 8. The AI ​​analyzes the message and generates a reply: "Since it's the end of August, what date exactly is it scheduled for?"

[1931] 9. The server stores the generated AI's answers in a database and notifies all participants.

[1932] 10. The device will display the AI's answer.

[1933] Generate a thread summary

[1934] 1. User A requests a summary of the entire thread.

[1935] 2. The terminal sends a summary request to the server.

[1936] 3. The server passes all messages in the thread to the generated AI for analysis.

[1937] 4. The generation AI generates a summary such as "The travel dates have been decided as August 28th to 30th."

[1938] 5. The server stores the summary in a database and sends it to the terminal.

[1939] 6. The terminal displays the summary to User A.

[1940] These features allow users to create threads based on their own purposes and needs, and efficiently organize and share information with the support of generative AI.

[1941] The processing flow will be explained below.

[1942] Creating and Managing Threads

[1943] Step 1:

[1944] A user selects the "Create a thread" option for a specific message in a conversation.

[1945] Step 2:

[1946] The terminal sends a thread creation request to the server.

[1947] Step 3:

[1948] The server generates a unique thread ID for the new thread and stores it in the database.

[1949] Step 4:

[1950] The server generates screen data for the thread and sends it to the terminal.

[1951] Step 5:

[1952] The terminal displays the new thread screen to the user.

[1953] Conversations in threads

[1954] Step 1:

[1955] A user posts a message in a thread.

[1956] Step 2:

[1957] The device sends the posted message to the server.

[1958] Step 3:

[1959] The server stores the message in a database.

[1960] Step 4:

[1961] The server notifies all participants in the thread of the new message.

[1962] Step 5:

[1963] Generative AI analyzes new messages and generates appropriate responses.

[1964] Step 6:

[1965] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[1966] Step 7:

[1967] The device will display the generated AI's answer on the thread screen.

[1968] Information archiving and retrieval

[1969] Step 1:

[1970] The user selects the option to archive the thread.

[1971] Step 2:

[1972] The device sends an archive request to the server.

[1973] Step 3:

[1974] The server saves the thread as an archive in the database.

[1975] Step 4:

[1976] A user enters search keywords to search archived threads.

[1977] Step 5:

[1978] The device sends a search request to the server.

[1979] Step 6:

[1980] The server searches the database to find the appropriate archive.

[1981] Step 7:

[1982] The server returns the search results to the terminal.

[1983] Step 8:

[1984] The device displays the archived thread to the user.

[1985] Reactions to messages

[1986] Step 1:

[1987] A user "likes" a particular message.

[1988] Step 2:

[1989] The device sends a "like" request to the server.

[1990] Step 3:

[1991] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[1992] Step 4:

[1993] The device will display the updated number of likes on the thread screen.

[1994] Generative AI summary creation

[1995] Step 1:

[1996] The user requests a summary of the entire thread.

[1997] Step 2:

[1998] The terminal sends a summary request to the server.

[1999] Step 3:

[2000] The server passes all messages in the thread to the generated AI for analysis.

[2001] Step 4:

[2002] The generative AI generates a summary based on the message content.

[2003] Step 5:

[2004] The server stores the summary in a database and sends it to the terminal.

[2005] Step 6:

[2006] The device displays a summary on the thread screen.

[2007] Search link provided by AI generation

[2008] Step 1:

[2009] The user asks detailed questions to the generating AI.

[2010] Step 2:

[2011] The device sends the question to the server.

[2012] Step 3:

[2013] The server passes the question content to the generation AI for analysis.

[2014] Step 4:

[2015] The generation AI generates a search link based on the question.

[2016] Step 5:

[2017] The server stores the generated link in a database and sends it to the device.

[2018] Step 6:

[2019] Your device will display the link in the thread screen.

[2020] Example 1

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

[2022] Conventional messaging systems have limited functionality for creating threads for specific messages, making it difficult to hold efficient conversations with multiple people. They also lacked effective ways to manage, summarize, and search information within threads, particularly with advanced support using generative AI. This made it difficult for users to smoothly organize and share information.

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

[2024] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a request to create a thread and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for receiving messages in the thread, saving it in a database, and notifying all participants, means for generating a new message, means for saving the generated message in a database and notifying all participants, means for generating and displaying a summary of the entire thread, and means for generating and displaying a link when a user asks a detailed question. This makes it possible to easily create a thread for a specific message, efficiently advance conversations among multiple people, provide advanced support using generation AI, and smoothly organize and share information.

[2025] "Thread" means an independent stream of conversation associated with a particular message.

[2026] "Thread ID" refers to an identification code generated to uniquely identify a new thread.

[2027] "Database" refers to a system designed to efficiently store, retrieve, and manage data.

[2028] "Terminal" refers to the electronic device, such as a smartphone or computer, that a user uses to access the system.

[2029] "Generative AI" refers to a system that uses artificial intelligence technology to analyze messages and generate responses.

[2030] "Summary" means information that briefly summarizes the main message content in a thread.

[2031] "Link" refers to a URL that provides access to related information generated when a user asks a detailed question.

[2032] A "request" refers to a communication requesting a specific operation or information from a server.

[2033] "Notification" refers to a message sent from the system to convey information to the user.

[2034] A "message" refers to text, images, or other data that a user sends within a thread.

[2035] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation between multiple people, including the AI ​​generator, takes place on a separate screen. Detailed embodiments of this system are described below.

[2036] Creating and Managing Threads

[2037] First, a user selects the "start a thread" option for a particular message within a messaging application by clicking a specific button within the application.

[2038] The device then sends a thread creation request to the server, which is sent as an HTTP POST request to the server's specified endpoint.

[2039] The server generates a unique thread ID for the new thread and saves this ID in a database. The server generates a UUID and saves the information in a database (e.g., MongoDB). At the same time, the server generates screen data for the new thread and returns it to the device in JSON format.

[2040] Finally, the terminal displays the new thread screen to the user. The terminal uses the received JSON data to render HTML in the browser and displays the new thread screen.

[2041] Conversations in threads

[2042] Users post messages in threads. When a user enters text into the input box and clicks the "Send" button, the device sends the message data to the server.

[2043] The server stores the received message in a database and notifies all participants in the thread by storing the message in a "messages" collection in the database and sending notifications to all participants using WebSocket or push notifications.

[2044] When a generative AI receives a new message, it analyzes its content and generates an appropriate response. This analysis and generation process uses natural language processing (NLP) algorithms. For example, GPT-4 can be used as a response generation model.

[2045] The generated answer is sent back to the server and stored in a database. At the same time, the server sends a notification to all participants. The device displays the received answer from the AI ​​on the thread screen.

[2046] Information archiving and retrieval

[2047] When a user selects the option to archive a thread, the device sends an archive request to the server, which updates the status of the thread in the "threads" collection to "archived" and stores it in the database.

[2048] To search for archived threads, a user inputs search keywords and sends a search request from their device to the server. The server queries the database, searches for the relevant archives, and returns the results to the device. The device then displays the search results to the user.

[2049] Reactions to messages

[2050] When a user clicks "like" on a particular message, the device sends a "like" request to the server. The server updates the "likes" field of the message in the database and sends a notification to all participants via WebSocket. The device then displays the updated number of "likes" on the thread screen.

[2051] Generative AI summary creation

[2052] When a user requests a summary of an entire thread, the device sends a summary request to the server. The server passes all messages in the thread to the generation AI, which analyzes them. The generation AI generates a summary and stores it in a database. The server sends the summary to the device, which displays it on the thread screen.

[2053] As a concrete example, the following prompt sentence can be input to a generative AI model:

[2054] "Generate an appropriate response to the message 'Late August might be good'. Include specific questions to help us adjust our travel dates."

[2055] Search link provided by AI generation

[2056] When a user asks a detailed question to the AI, the device sends the question to the server. The server passes the question to the AI, which analyzes it and generates an appropriate search link. The generated link is sent via the server to the device, which then displays it to the user.

[2057] This will result in a system that can effectively manage threads within messaging applications, support conversations with generative AI, archive and search information, react to messages, and provide summaries and search links.

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

[2059] Creating and Managing Threads

[2060] Step 1:

[2061] Subject: User

[2062] A user selects the "Create a thread" option for a particular message within a messaging application, which in turn results in the user clicking the "Create a thread" button.

[2063] Input: User clicks "Start a thread" button

[2064] Output: Create a "thread" request

[2065] Step 2:

[2066] Subject: Terminal

[2067] The device sends a thread creation request to the server, and sends data to the specified endpoint on the server using an HTTP POST request.

[2068] Input: "Start a thread" request

[2069] Output: HTTP POST request to the server

[2070] Step 3:

[2071] Subject: Server

[2072] The server generates a new thread ID and stores it in the database. It generates a UUID and stores it in the "threads" collection in the MongoDB database.

[2073] Input: Thread creation request via HTTP POST request

[2074] Output: Generate a new thread ID and save it to the database

[2075] Step 4:

[2076] Subject: Server

[2077] The server generates screen data for a new thread and sends it to the terminal in JSON format. It then uses a template engine to generate HTML and passes it to the terminal.

[2078] Input: The newly generated thread ID

[2079] Output: Generate and send the new thread's screen data in JSON format.

[2080] Step 5:

[2081] Subject: Terminal

[2082] The device displays the new thread screen to the user. The received JSON data is rendered in the browser and the new thread screen is displayed.

[2083] Input: Screen data sent from the server

[2084] Output: The new thread screen as seen by the user

[2085] Conversations in threads

[2086] Step 1:

[2087] Subject: User

[2088] A user posts a message in a thread by entering text into the input box and clicking the "Send" button.

[2089] Input: The user types into an input box and clicks the "Submit" button

[2090] Output: Generate a request to send a message

[2091] Step 2:

[2092] Subject: Terminal

[2093] The device sends the posted message to the server by sending an HTTP POST request to the server.

[2094] Input: Message data entered by the user

[2095] Output: HTTP POST request to the server

[2096] Step 3:

[2097] Subject: Server

[2098] The server saves the message in a database and notifies all participants in the thread. The server saves the message in a "messages" collection in the database and sends notifications to all participants using WebSocket or push notifications.

[2099] Input: Message data sent in the HTTP POST request

[2100] Output: Save the message to the database and send a notification

[2101] Step 4:

[2102] Subject: Generation AI

[2103] Generative AI analyzes new messages and generates appropriate responses. It uses NLP algorithms to analyze the message content and generates responses using response generation models (e.g., GPT-4).

[2104] Input: A new message posted to a thread

[2105] Output: Answer by generative AI

[2106] Step 5:

[2107] Subject: Server

[2108] The server saves the generated AI's answer in a database and notifies all participants.The server saves the generated answer in a database and notifies all participants via WebSocket or push notification.

[2109] Input: Answer by generative AI

[2110] Output: Save to database and send notification

[2111] Step 6:

[2112] Subject: Terminal

[2113] The device displays the generated AI's answer on the thread screen. The device renders the received answer data and displays it on the thread screen.

[2114] Input: The generated AI's answer data sent from the server

[2115] Output: Display on thread screen

[2116] Information archiving and retrieval

[2117] Step 1:

[2118] Subject: User

[2119] The user selects the option to archive the thread: Clicks the Archive button.

[2120] Input: User clicks the archive button

[2121] Output: Archive request generated

[2122] Step 2:

[2123] Subject: Terminal

[2124] The device sends an archive request to the server using an HTTP POST request.

[2125] Input: User-generated archive request

[2126] Output: HTTP POST request to the server

[2127] Step 3:

[2128] Subject: Server

[2129] The server archives the thread in the database and updates the status of the "threads" collection in the database to "archived."

[2130] Input: Archive Request

[2131] Output: Archive of threads in a database

[2132] Step 4:

[2133] Subject: User

[2134] Users can enter search keywords to search archived threads by entering keywords in the search box and clicking the "Search" button.

[2135] Input: Search keyword

[2136] Output: Generate a search request

[2137] Step 5:

[2138] Subject: Terminal

[2139] The device sends a search request to the server, sending a search query via an HTTP GET request.

[2140] Input: A search request containing the search keyword

[2141] Output: HTTP GET request to the server

[2142] Step 6:

[2143] Subject: Server

[2144] The server searches the database to find the relevant archive. Based on the search query, it queries the database to retrieve the results.

[2145] Input: Search request

[2146] Output: Search results for matching archives

[2147] Step 7:

[2148] Subject: Server

[2149] The server returns the search results to the device. The search results are sent to the device in JSON format.

[2150] Input: Search results

[2151] Output: Send search results to your device

[2152] Step 8:

[2153] Subject: Terminal

[2154] The device displays the archived threads to the user. The device renders the search results and displays the archived threads to the user.

[2155] Input: Search results sent from the server

[2156] Output: Archived threads as seen by the user

[2157] Reactions to messages

[2158] Step 1:

[2159] Subject: User

[2160] A user "likes" a particular message by clicking the "like" icon next to the message.

[2161] Input: User clicks the "Like" icon

[2162] Output: Generate a "Like" request

[2163] Step 2:

[2164] Subject: Terminal

[2165] The device sends a "Like" request to the server. The "Like" data is sent to the server via an HTTP POST request.

[2166] Input: "Like" request

[2167] Output: HTTP POST request to the server

[2168] Step 3:

[2169] Subject: Server

[2170] The server saves the number of "likes" in a database and notifies all participants of the new number of "likes." It updates the "likes" field of the corresponding message in the database and sends a notification to all participants via WebSocket.

[2171] Input: "Like" request

[2172] Output: Update the like count and send a notification

[2173] Step 4:

[2174] Subject: Terminal

[2175] Your device will display the updated number of likes on the thread screen and update the displayed message list to reflect the new number of likes.

[2176] Input: New number of likes sent from the server

[2177] Output: Updated number of likes displayed to the user

[2178] Generative AI summary creation

[2179] Step 1:

[2180] Subject: User

[2181] A user requests a summary of the entire thread by clicking the "Summary" button on the thread screen.

[2182] Input: User clicks "Summary" button

[2183] Output: Generate summary request

[2184] Step 2:

[2185] Subject: Terminal

[2186] The terminal sends a summary request to the server using an HTTP POST request.

[2187] Input: A user-generated summary request

[2188] Output: HTTP POST request to the server

[2189] Step 3:

[2190] Subject: Server

[2191] The server passes all messages in the thread to the AI ​​generator for analysis. All messages in the thread are input into the AI ​​model, and a natural language processing algorithm generates a summary.

[2192] Input: All messages

[2193] Output: Generated summary

[2194] Step 4:

[2195] Subject: Generation AI

[2196] The generative AI generates a summary and stores it in a database.

[2197] Input: All messages in the thread

[2198] Output: Summary data

[2199] Step 5:

[2200] Subject: Server

[2201] The server sends the summary to the terminal, and returns the summary data to the terminal as an HTTP response.

[2202] Input: Generative AI summary

[2203] Output: Send summary data to terminal

[2204] Step 6:

[2205] Subject: Terminal

[2206] The device displays a summary on the thread screen.

[2207] Input: Summary data sent from the server

[2208] Output: A summary that is displayed to the user

[2209] Search link provided by AI generation

[2210] Step 1:

[2211] Subject: User

[2212] The user asks the AI ​​a detailed question, enters the question, and clicks the "Submit" button.

[2213] Input: User's question

[2214] Output: Generate a question request

[2215] Step 2:

[2216] Subject: Terminal

[2217] The device sends the question to the server using an HTTP POST request.

[2218] Input: The question typed by the user

[2219] Output: HTTP POST request to the server

[2220] Step 3:

[2221] Subject: Server

[2222] The server passes the question to the AI ​​generator for analysis, inputs the question into the AI ​​model, and generates an appropriate search link.

[2223] Input: User's question

[2224] Output: Generated search link

[2225] Step 4:

[2226] Subject: Generation AI

[2227] The generation AI generates the appropriate search link and returns it to the server.

[2228] Input: User's question

[2229] Output: Generated search link

[2230] Step 5:

[2231] Subject: Server

[2232] The server sends the generated link to the device.

[2233] Input: Search link generated by AI

[2234] Output: Sending link data to the terminal

[2235] Step 6:

[2236] Subject: Terminal

[2237] Your device will display the link in the thread screen.

[2238] Input: Search link sent from the server

[2239] Output: The link that is displayed to the user

[2240] The above are the specific processing steps of this system. By explaining the process from input to output in detail, the processing flow can be clearly understood.

[2241] (Application example 1)

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

[2243] In manufacturing processes, efficient and effective communication is required when workers and engineers identify problems in the manufacturing process and discuss improvement measures. Conventional methods can delay discussions to quickly resolve problems in the manufacturing process, potentially resulting in a decline in overall productivity. The present invention aims to provide a system that enables workers, engineers, and generative AI to work together to identify problems in the manufacturing process and quickly propose improvement measures to address these issues.

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

[2245] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a request to create a thread and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for managing threads for discussions about the manufacturing process, and means for using a generation AI that identifies problems in the manufacturing process and proposes improvement measures. This makes it possible to efficiently discuss problems in the manufacturing process through threads and quickly take improvement measures based on suggestions from the generation AI.

[2246] A "thread" is a unit for separating and managing a series of messages or conversations on a particular topic.

[2247] A "thread ID" is an identifier generated by the system to uniquely identify an individual thread.

[2248] A "database" is a data structure that stores information in an organized manner and allows it to be efficiently searched and updated.

[2249] "Generative AI" is a system that uses artificial intelligence technology to generate responses and suggestions in the form of text or voice.

[2250] A "terminal" is a device that allows a user to access and operate the system. Examples include smartphones and computers.

[2251] A "manufacturing process" is a series of operations and treatments that are carried out to create a product from raw materials.

[2252] A "message" is data such as text, audio, or images used to convey information between users or systems.

[2253] "Archiving" is the process of storing data or information that is no longer in use so that it can be retrieved later when needed.

[2254] "Notification" is a function that allows the system to notify the user when a specific event or information occurs.

[2255] A "summary" is a short sentence that concisely summarizes a longer text or multiple messages.

[2256] This invention relates to a "manufacturing process improvement thread management application" for efficiently improving manufacturing processes. This system creates threads for specific messages, and workers, engineers, and generation AI work together to identify problems in the manufacturing process and propose improvement measures.

[2257] Explanation of program processing

[2258] Creating a Thread

[2259] The user selects the "Create a thread" option for a specific message related to the manufacturing process. The device sends the request to the server, which generates a unique thread ID and stores it in the database. At the same time, it also generates screen data for the thread and sends it to the device.

[2260] Posting and parsing messages

[2261] When a user posts a message in a thread, the device sends the message to the server, which stores the message in a database and notifies all participants in the thread. The generative AI also analyzes the new message and generates an appropriate response or suggestion. The server stores the generated response in a database and notifies all participants in the thread.

[2262] Archive and search threads

[2263] A user selects the option to archive a thread and submits an archive request. The server stores the thread as an archive in its database, making it available for future retrieval. When a user searches the archives by entering specific keywords, the server searches the database and returns the results.

[2264] Generate a summary

[2265] A user can request a summary of an entire thread. The server passes all messages in the thread to the AI ​​generator, which generates a summary. The server stores the summary in a database and sends it to the device.

[2266] Hardware and software used

[2267] Hardware: Robot terminals used in factories, servers (computers that process the database and generative AI)

[2268] Software: Python language, AI response generation model (e.g., GPT-4), SQL database (e.g., PostgreSQL)

[2269] Specific example explanation

[2270] Example 1: Improving bottlenecks on a production line

[2271] Worker A sends a message saying, "I want to discuss the bottleneck on the production line," creating a new thread. Engineer B posts, "The bottleneck is caused by Machine X stopping frequently." The AI ​​generator responds, "To reduce the frequency of Machine X stopping, we need to change the routine maintenance schedule."

[2272] Example 2: Summary of progress for a long-term project

[2273] User A requests a summary of the entire thread. The server sends the summary request to the generation AI. The generation AI generates a summary saying, "The project is 60% complete, and the next step is to adjust equipment Y."

[2274] Prompt Sentence Examples

[2275] Message response generation:

[2276] Message: "Machine X is experiencing frequent downtime"

[2277] Prompt: "From a manufacturing process perspective, what suggestions can you make to reduce the downtime of machine X?"

[2278] Thread summary generation:

[2279] Prompt: "Summarize the following messages: [message 1, message 2, message 3, ...]"

[2280] In this way, this system makes it possible to efficiently discuss problems in the manufacturing process through threads and quickly take improvement measures based on suggestions from the generative AI.

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

[2282] Step 1:

[2283] (Step 1) The user selects the "Create a thread" option for a specific message related to the manufacturing process.

[2284] (Input) The message for which the user selected the "start a thread" option.

[2285] (Output) A thread creation request is sent from the terminal to the server.

[2286] (Specific operation) The user selects a specific message on the device screen and clicks the "Create a thread" button. This generates a thread creation request, which is sent from the device to the server as an HTTP request.

[2287] Step 2:

[2288] (Step 2) The server generates a unique thread ID and stores it in the database.

[2289] (Input) A thread creation request.

[2290] (Output) The generated thread ID and screen data for the thread are sent to the terminal.

[2291] (Specific operation) After the server receives a thread creation request, it generates a unique identifier (thread ID) and stores it in the database. It then generates screen data for the thread and notifies the terminal.

[2292] Step 3:

[2293] (Step 3) A user posts a message in the thread.

[2294] (Input) The message posted by the user.

[2295] (Output) A message is sent from the terminal to the server.

[2296] (Specific operation) The user enters a message in the input field of the terminal and clicks the send button, which sends the message data from the terminal to the server as an HTTP request.

[2297] Step 4:

[2298] (Step 4) The server saves the message in a database and notifies all participants in the thread.

[2299] (Input) The message posted by the user.

[2300] (Output) The message is saved in the database and notified to all participants.

[2301] (Specific operation) The server stores the received message in a database and sends a notification to the terminals of other users participating in the thread.

[2302] Step 5:

[2303] (Step 5) Generative AI analyzes the new message and generates an appropriate response or suggestion.

[2304] (Input) The message posted by the user.

[2305] (Output) The answer or suggestion from the generative AI.

[2306] (Specific operation) The server sends message data to the generation AI, which analyzes the prompt and generates an appropriate answer or suggestion. Example: "From the perspective of improving the manufacturing process, please make a suggestion to reduce the frequency of machine X's stoppages."

[2307] Step 6:

[2308] (Step 6) The server saves the answer generated by the generated AI in a database and notifies all participants in the thread.

[2309] (Input) Answers or suggestions from the generative AI.

[2310] (Output) The answers are stored in a database and notified to all participants.

[2311] (Specific operation) The server stores the answer received from the generation AI in a database and sends a notification to the devices of all users participating in the thread.

[2312] Step 7:

[2313] (Step 7) The user selects the option to archive the thread and submits the archive request.

[2314] (Input) A request to archive a thread selected by the user.

[2315] (Output) An archive request is sent from the terminal to the server.

[2316] (Specific operation) The user selects the "Archive" option on the terminal screen, generating a request to archive the thread.

[2317] Step 8:

[2318] (Step 8) The server saves the thread as an archive in the database.

[2319] (Input) Archive request.

[2320] (Output) The thread is saved as an archive in the database.

[2321] (Specific operation) The server receives the archive request and saves the corresponding thread as an archive in the database.

[2322] Step 9:

[2323] (Step 9) The user submits a request to search the archive by entering a specific keyword.

[2324] (Input) Search keywords specified by the user.

[2325] (Output) A search request is sent from the device to the server.

[2326] (Specific operation) The user enters a specific keyword into the search bar of the device and clicks the search button.

[2327] Step 10:

[2328] (Step 10) The server searches the database and finds the appropriate archive.

[2329] (Input) Search keywords.

[2330] (Output) Corresponding archive data.

[2331] (Specific operation) The server searches the database, finds archive data that matches the specified keywords, and generates search results.

[2332] Step 11:

[2333] (Step 11) The server sends the search results to the terminal and displays them to the user.

[2334] (Input) Applicable archive data.

[2335] (Output) The search results are displayed on the terminal.

[2336] (Specific operation) The search results generated by the server are sent to the terminal, which then displays them to the user.

[2337] Step 12:

[2338] (Step 12) The user sends a request for a summary of the entire thread.

[2339] (Input) A summary of the user's request.

[2340] (Output) A summary request is sent from the terminal to the server.

[2341] (Specific operation) The user selects a summary option on the terminal screen and sends a request.

[2342] Step 13:

[2343] (Step 13) The server passes all messages in the thread to the generation AI, which generates a summary.

[2344] (Input) All message data for the thread.

[2345] (Output) Generative AI summary.

[2346] (Specific operation) The server retrieves all messages in the thread and has the generation AI analyze them. The generation AI generates a summary based on the message data.

[2347] Step 14:

[2348] (Step 14) The server stores the generated summary in a database and transmits it to the terminal.

[2349] (Input) Summary by generative AI.

[2350] (Output) The summary is stored in the database and displayed on the terminal.

[2351] (Specific operation) The server stores the summary received from the generation AI in a database and sends it to the user's device.

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

[2353] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation can be held on a separate screen with multiple people, including a generation AI. It also has the function of generating a response according to the user's emotions by combining it with an emotion engine that analyzes the user's message and recognizes their emotions. This system is realized by the following specific programs and their processing:

[2354] Creating and Managing Threads

[2355] A user selects the "Create a thread" option for a specific message in a conversation.

[2356] The terminal sends a thread creation request to the server.

[2357] The server generates a unique thread ID for the new thread and stores it in the database. At the same time, it generates screen data and sends it to the device.

[2358] The terminal displays the new thread screen to the user.

[2359] Conversations in threads

[2360] A user posts a message in a thread.

[2361] The device sends the posted message to the server.

[2362] The server saves the message in a database and notifies all participants in the thread of the new message.

[2363] The emotion engine analyzes the message and recognizes the user's emotions.

[2364] The generative AI analyzes new messages based on the analysis results of the emotion engine and generates appropriate responses.

[2365] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[2366] The device will display the generated AI's answer on the thread screen.

[2367] Information archiving and retrieval

[2368] The user selects the option to archive the thread.

[2369] The device sends an archive request to the server.

[2370] The server stores the relevant thread and emotion data in a database as an archive.

[2371] A user enters search keywords to search archived threads.

[2372] The device sends a search request to the server.

[2373] The server searches the database to find the appropriate archive.

[2374] The server returns the search results to the terminal.

[2375] The device displays the archived thread to the user.

[2376] Reactions to messages

[2377] A user "likes" a particular message.

[2378] The device sends a "like" request to the server.

[2379] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[2380] The device will display the updated number of likes on the thread screen.

[2381] Generative AI summary creation

[2382] The user requests a summary of the entire thread.

[2383] The terminal sends a summary request to the server.

[2384] The server passes all messages in the thread to the generated AI for analysis.

[2385] The generative AI generates a summary based on the message content.

[2386] The server stores the summary in a database and sends it to the terminal.

[2387] The device displays a summary on the thread screen.

[2388] Search link provided by AI generation

[2389] The user asks detailed questions to the generating AI.

[2390] The device sends the question to the server.

[2391] The server passes the question content to the generation AI for analysis.

[2392] The generation AI generates a search link based on the question.

[2393] The server stores the generated link in a database and sends it to the device.

[2394] Your device will display the link in the thread screen.

[2395] Use of emotion engine

[2396] The emotion engine analyzes messages from users and recognizes their emotions.

[2397] The emotion engine provides the recognition results to the generative AI.

[2398] The generative AI adjusts the response based on the user's emotions, responding faster if the emotion is positive and more politely if the emotion is negative.

[2399] The server stores the emotion data in a database and uses it to track changes in emotion.

[2400] Specific examples

[2401] Create and manage itinerary coordination threads

[2402] 1. User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[2403] 2. The device sends a thread creation request to the server.

[2404] 3. The server generates a new thread ID and stores it in the database.

[2405] 4. The device displays the new thread screen to User A.

[2406] 5. User B posts a message saying, "Maybe the end of August would be good."

[2407] 6. The device sends the message to the server.

[2408] 7. The server saves the message in the database and notifies all participants.

[2409] 8. The emotion engine analyzes the message and recognizes that User B has a positive emotion.

[2410] 9. The generative AI quickly generates a response: "Since it's the end of August, what date exactly is it scheduled for?"

[2411] 10. The server stores the generated AI's response in a database and notifies all participants.

[2412] 11. The device will display the generated AI's response.

[2413] Generate a thread summary

[2414] 1. User A requests a summary of the entire thread.

[2415] 2. The terminal sends a summary request to the server.

[2416] 3. The server passes all messages in the thread to the generated AI for analysis.

[2417] 4. The generation AI generates a summary such as "The travel dates have been decided as August 28th to 30th."

[2418] 5. The server stores the summary in a database and sends it to the terminal.

[2419] 6. The terminal displays the summary to User A.

[2420] These features allow users to create threads based on their own purposes and needs, and efficiently organize and share information with the support of generative AI and an emotion engine.

[2421] The processing flow will be explained below.

[2422] Creating and Managing Threads

[2423] Step 1:

[2424] A user selects the "Create a thread" option for a specific message in a conversation.

[2425] Step 2:

[2426] The terminal sends a thread creation request to the server.

[2427] Step 3:

[2428] The server generates a unique thread ID for the new thread and stores it in the database.

[2429] Step 4:

[2430] The server generates screen data for the thread and sends it to the terminal.

[2431] Step 5:

[2432] The terminal displays the new thread screen to the user.

[2433] Conversations in threads

[2434] Step 1:

[2435] A user posts a message in a thread.

[2436] Step 2:

[2437] The device sends the posted message to the server.

[2438] Step 3:

[2439] The server stores the message in a database.

[2440] Step 4:

[2441] The server notifies all participants in the thread of the new message.

[2442] Step 5:

[2443] The emotion engine analyzes new messages and recognizes the user's emotions.

[2444] Step 6:

[2445] The generative AI analyzes new messages based on the analysis results of the emotion engine and generates appropriate responses.

[2446] Step 7:

[2447] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[2448] Step 8:

[2449] The device will display the generated AI's answer on the thread screen.

[2450] Information archiving and retrieval

[2451] Step 1:

[2452] The user selects the option to archive the thread.

[2453] Step 2:

[2454] The device sends an archive request to the server.

[2455] Step 3:

[2456] The server stores the relevant thread and emotion data in a database as an archive.

[2457] Step 4:

[2458] A user enters search keywords to search archived threads.

[2459] Step 5:

[2460] The device sends a search request to the server.

[2461] Step 6:

[2462] The server searches the database to find the appropriate archive.

[2463] Step 7:

[2464] The server returns the search results to the terminal.

[2465] Step 8:

[2466] The device displays the archived thread to the user.

[2467] Reactions to messages

[2468] Step 1:

[2469] A user "likes" a particular message.

[2470] Step 2:

[2471] The device sends a "like" request to the server.

[2472] Step 3:

[2473] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[2474] Step 4:

[2475] The device will display the updated number of likes on the thread screen.

[2476] Generative AI summary creation

[2477] Step 1:

[2478] The user requests a summary of the entire thread.

[2479] Step 2:

[2480] The terminal sends a summary request to the server.

[2481] Step 3:

[2482] The server passes all messages in the thread to the generated AI for analysis.

[2483] Step 4:

[2484] The generative AI generates a summary based on the message content.

[2485] Step 5:

[2486] The server stores the generated summary in a database and transmits it to the terminal.

[2487] Step 6:

[2488] The device displays a summary on the thread screen.

[2489] Search link provided by AI generation

[2490] Step 1:

[2491] The user asks detailed questions to the generating AI.

[2492] Step 2:

[2493] The device sends the question to the server.

[2494] Step 3:

[2495] The server passes the question content to the generation AI for analysis.

[2496] Step 4:

[2497] The generation AI generates a search link based on the question.

[2498] Step 5:

[2499] The server stores the generated link in a database and sends it to the device.

[2500] Step 6:

[2501] Your device will display the link in the thread screen.

[2502] Use of emotion engine

[2503] Step 1:

[2504] The emotion engine analyzes messages from users and recognizes their emotions.

[2505] Step 2:

[2506] The emotion engine provides the recognition results to the generative AI.

[2507] Step 3:

[2508] The generative AI adjusts the response based on the user's emotions, responding faster if the emotion is positive and more politely if the emotion is negative.

[2509] Step 4:

[2510] The server stores the emotion data in a database and uses it to track changes in emotion.

[2511] Specific examples

[2512] Create and manage itinerary coordination threads

[2513] Step 1:

[2514] User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[2515] Step 2:

[2516] The terminal sends a thread creation request to the server.

[2517] Step 3:

[2518] The server generates a new thread ID and stores it in the database.

[2519] Step 4:

[2520] The device displays the new thread screen to User A.

[2521] Step 5:

[2522] User B posts a message saying, "Maybe the end of August would be good."

[2523] Step 6:

[2524] The device sends a message to the server.

[2525] Step 7:

[2526] The server stores the message in a database and notifies all participants.

[2527] Step 8:

[2528] The emotion engine analyzes the message and recognizes that User B has a positive emotion.

[2529] Step 9:

[2530] The generative AI quickly generates a response such as, "Since it's the end of August, what date exactly is it scheduled for?"

[2531] Step 10:

[2532] The server stores the generated AI's response in a database and notifies all participants.

[2533] Step 11:

[2534] The terminal will display the generated AI's response.

[2535] Generate a thread summary

[2536] Step 1:

[2537] User A requests a summary of the entire thread.

[2538] Step 2:

[2539] The terminal sends a summary request to the server.

[2540] Step 3:

[2541] The server passes all messages in the thread to the generated AI for analysis.

[2542] Step 4:

[2543] The generative AI generates a summary such as "The travel dates have been set for August 28th to 30th."

[2544] Step 5:

[2545] The server stores the generated summary in a database and transmits it to the terminal.

[2546] Step 6:

[2547] The terminal displays the summary to User A.

[2548] Example 2

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

[2550] Conventional messaging applications lack the ability to create threads for specific messages and efficiently manage conversations on a separate screen. They also lack a mechanism for automatically generating responses based on the user's emotions, making it difficult to improve the user experience. Furthermore, they also have limited functionality for archiving past threads and quickly searching for necessary information. To address these issues, an efficient and user-friendly communication system is needed.

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

[2552] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a thread creation request and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for a user to post a message in the created thread, means for saving the posted message in a database and notifying all participants, means for analyzing the message using a generative AI model and generating an appropriate response, and means for analyzing the emotion of the message using an emotion analysis engine and providing the analysis result to the generative AI model. This allows users to efficiently manage conversations, enables the generative AI and the emotion engine to work together to automatically generate responses according to the user's emotions, and provides a system for efficiently archiving and searching thread information.

[2553] A "thread" is an independent unit of communication for centrally managing a series of conversations or exchanges related to a particular message.

[2554] A "thread ID" is an identification code generated by the server to uniquely identify a thread.

[2555] "Terminal" is a general term for electronic devices used by users, such as computers, smartphones, and tablets.

[2556] A "server" is a central computer system that processes, manages, and stores data.

[2557] A "database" is an information system for systematically storing and managing data such as threads, messages, and user information.

[2558] A "generative AI model" is a program that uses artificial intelligence algorithms to analyze a user's message and generate an appropriate response.

[2559] An "emotion analysis engine" is a system that analyzes a user's message and recognizes their emotional state (positive, negative, neutral, etc.).

[2560] "Archiving" refers to the process of saving threads or messages so that they can be retrieved later, or the saved data.

[2561] A "notification" is information sent by a server to a terminal or user to notify them of a new message or event.

[2562] A "reaction" refers to an evaluation action such as a "like" that a user takes on a particular message.

[2563] A "search link" is an access link to related information generated by the generative AI model in response to a user's detailed question.

[2564] A "summary" is a sentence or piece of information that analyzes all messages in a thread and succinctly summarizes their contents.

[2565] This invention is a system that allows users to create threads for specific messages and use generative AI models and sentiment analysis engines to communicate efficiently and effectively. This system consists of a server, a terminal, and software that links them.

[2566] Hardware and software used

[2567] Server: A central computer system that processes, manages, and stores data.

[2568] Device: The electronic device used by the user, such as a computer, smartphone, or tablet.

[2569] Generative AI model: A program that uses artificial intelligence algorithms to analyze a user's message and generate an appropriate response (e.g., GPT-4).

[2570] Sentiment Analysis Engine: A system for analyzing users' messages and recognizing their emotional state.

[2571] Overall system operation

[2572] 1. Creating and Managing Threads

[2573] When a user creates a thread for a specific message in a messaging app, the device sends a thread creation request to the server.

[2574] The server generates a unique thread ID and stores it in the database. At the same time, it generates screen data for the thread and sends it to the device.

[2575] The terminal will display the new thread screen to the user.

[2576] Conversations in threads

[2577] A user posts a message in a thread and sends it to the server from their device.

[2578] The server stores the message in a database and notifies all participants.

[2579] The sentiment analysis engine analyzes the message and recognizes the user's sentiment.

[2580] The generative AI model generates an appropriate response based on the results of the emotion analysis.

[2581] The server stores the responses from the generative AI model in a database and notifies all participants.

[2582] The device displays the response of the generated AI model on the thread screen.

[2583] Information archiving and retrieval

[2584] The user selects the option to archive the thread, and the terminal sends an archive request to the server.

[2585] The server stores the relevant thread and emotion data in a database.

[2586] A user inputs a search keyword to search an archived thread, and the terminal sends a search request to the server.

[2587] The server searches the database, finds the relevant archive, and sends it to the terminal.

[2588] The device displays archived threads.

[2589] Reactions to messages

[2590] When a user presses the "Like" button for a particular message, the device sends a "Like" request to the server.

[2591] The server stores the number of "likes" in a database and notifies all participants.

[2592] The device will display the updated number of likes on the thread screen.

[2593] Generative AI summary creation

[2594] A user requests a summary of an entire thread, and the terminal sends a summary request to the server.

[2595] The server passes all messages in the thread to the generative AI model for analysis.

[2596] The generative AI model generates a summary, which the server stores in a database and sends to the device.

[2597] The terminal displays the summary to the user.

[2598] Search link provided by AI generation

[2599] When a user asks a detailed question to the generative AI model, the device sends the question to the server.

[2600] The server passes the question to the generative AI model for analysis.

[2601] A generative AI model generates search links based on the question.

[2602] The server stores the generated link in a database and sends it to the device.

[2603] The device will display the generated link on the thread screen.

[2604] Use of sentiment analysis engine

[2605] The sentiment analysis engine analyzes messages from users and recognizes their emotional state.

[2606] The emotion analysis engine provides the recognition results to the generative AI model, which then adjusts the response content based on the user's emotions.

[2607] The server stores the emotion data in a database and uses it to track changes in emotion.

[2608] Specific example explanation

[2609] Consider the example of a thread for coordinating travel itineraries. When user A creates a thread in response to the message "Let's decide on this year's travel dates," the device sends a thread creation request to the server. The server generates a new thread ID and saves it in the database. The device displays the new thread screen to user A. When user B posts the message "The end of August might be good," the device sends the message to the server. The server saves the message in the database and notifies all participants. The sentiment analysis engine analyzes the message and recognizes that user B has positive emotions. The generation AI quickly generates a response: "Since the end of August, what date exactly is it planned for?" The server saves the generation AI's response in the database and notifies all participants. The device displays the generation AI's response.

[2610] Example prompt sentence:

[2611] "In this thread about deciding travel dates, please gather everyone's opinions and suggest the best travel dates."

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

[2613] Step 1:

[2614] A user selects the "Create a thread" option for a specific message in a messaging app.

[2615] Input: The "start a thread" option that the user controls.

[2616] What happens: The user clicks the thread creation button in the app.

[2617] Output: A thread creation request is generated.

[2618] Step 2:

[2619] The terminal sends a thread creation request to the server.

[2620] Input: A thread creation request initiated by a user.

[2621] Operation: The device sends request data to the server.

[2622] Output: The server receives the thread creation request.

[2623] Step 3:

[2624] The server generates a unique thread ID and stores it in the database.

[2625] Input: The thread creation request received by the server.

[2626] How it works: The server generates a unique thread ID using a UUID (Universally Unique ID) generation algorithm, and stores the generated thread ID and associated data in a database.

[2627] Output: A unique thread ID is generated and stored in the database.

[2628] Step 4:

[2629] The server generates screen data for the thread and sends it to the terminal.

[2630] Input: The generated thread ID.

[2631] Operation: The server generates the initial screen data for the thread and sends it to the terminal.

[2632] Output: Screen data is generated and sent to the device.

[2633] Step 5:

[2634] The device displays the new thread screen to the user.

[2635] Input: Screen data sent from the server.

[2636] Behavior: Updates the user interface based on the data received by the device.

[2637] Output: The new thread screen is displayed to the user.

[2638] Step 6:

[2639] A user posts a message in a thread.

[2640] Input: The message entered by the user.

[2641] What happens: The user enters text into the message input field and clicks the send button.

[2642] Output: The message is sent.

[2643] Step 7:

[2644] The device sends the posted message to the server.

[2645] Input: The message entered by the user.

[2646] Operation: The device sends message data to the server.

[2647] Output: The server receives the message data.

[2648] Step 8:

[2649] The server saves the message in a database and notifies all participants in the thread of the new message.

[2650] Input: Message data sent from the terminal.

[2651] What it does: The server stores the received message in a database. The notification module notifies all participants that a new message has been posted.

[2652] Output: The message is saved in the database and all participants are notified.

[2653] Step 9:

[2654] The sentiment analysis engine analyzes the message and recognizes the user's emotions.

[2655] Input: The message data received by the server.

[2656] How it works: The sentiment analysis engine uses natural language processing algorithms to analyze messages and assign sentiment labels (e.g., positive, negative, neutral).

[2657] Output: The sentiment analysis results are generated.

[2658] Step 10:

[2659] The generative AI model analyzes new messages based on the sentiment analysis results and generates appropriate responses.

[2660] Input: Sentiment analysis results from the sentiment analysis engine and messages posted by users.

[2661] How it works: A generative AI model (e.g., GPT-4) generates an appropriate answer based on the prompt.

[2662] Output: A generated response message is generated.

[2663] Step 11:

[2664] The server stores the response from the generated AI model in a database and notifies all participants in the thread.

[2665] Input: The generated response message.

[2666] How it works: The server stores the generated response in a database and the notification module notifies all participants.

[2667] Output: The response message is saved in the database and notified to all participants.

[2668] Step 12:

[2669] The device displays the response of the generated AI model on the thread screen.

[2670] Input: The response message sent by the server.

[2671] Behavior: The response message received by the device is displayed on the thread screen.

[2672] Output: A response message is displayed to the user.

[2673] These processing steps allow users to communicate efficiently and receive appropriate responses leveraging the collaboration of generative AI and sentiment analysis engines.

[2674] (Application example 2)

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

[2676] Traditional messaging systems lacked the ability to create threads for specific messages and generate responses based on user sentiment. They also faced challenges in effectively managing information within threads and providing user reactions and archiving functions. This resulted in a poor user experience and hindered efficient communication.

[2677] The specific processing by the specific 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 providing an option to create a thread for a specific message, means for receiving a thread creation request and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to the terminal, means for analyzing the message using an emotion engine and recognizing the user's emotion, and means for the generation AI to generate an appropriate response based on the recognized emotion. This allows the user to create a thread for a specific message and receive a response based on the emotion, thereby realizing efficient communication.

[2678] The "threading option" is a feature that allows users to create a new conversation flow for a particular message.

[2679] The "thread ID" is an identifier for uniquely identifying a created thread.

[2680] "Screen data" is a data set that contains visual information of a thread for display on a user terminal.

[2681] An "emotion engine" is software or algorithms that analyze a user's message and recognize its emotion.

[2682] "Generative AI" is an artificial intelligence system that automatically generates appropriate responses based on the results of analysis by the emotion engine.

[2683] A "reaction" is an action taken by a user to indicate a positive or negative evaluation of a particular message or response.

[2684] "Archiving" is the process of saving specific threads or conversations so that they can be searched or referenced later.

[2685] A "summary" is information that briefly summarizes the contents of the entire thread.

[2686] A "database" is a system for systematically storing and managing information such as threads, messages, and sentiment analysis results.

[2687] A "notification" is a means of informing a user that a particular event or message has occurred.

[2688] The system based on this invention mainly utilizes a server, a terminal, an emotion engine, a generation AI, and a database to provide messaging between users and a response function based on emotion recognition.

[2689] Hardware and software used

[2690] Hardware: Smartphone or computer

[2691] Software: Messaging application, emotion engine (EmotionAPI), generative AI (ChatGPT), database (PostgreSQL)

[2692] Program processing

[2693] Thread creation

[2694] When a user selects the "Create a thread" option for a particular message, the device sends this thread creation request to the server, which generates a new thread ID and stores it in the database. It also generates screen data for the thread and sends it to the device for display.

[2695] Sentiment Analysis and Response Generation

[2696] When a user posts a message in a thread, the device sends this message to the server. The server saves the posted message in a database and notifies all participants in the thread. The emotion engine analyzes the message and recognizes the user's emotion. The recognition result is provided to the generation AI, which generates an appropriate response. The server saves the response from the generation AI in a database and notifies all participants.

[2697] Reactions and Feedback

[2698] When a user clicks "like" or "rating" on a particular message, the device sends this reaction request to the server, which stores the reaction count in a database and notifies all participants of the new reaction count.

[2699] Thread archives and summaries

[2700] When a user selects the option to archive a thread, the device sends an archive request to the server, which stores the thread in a database and makes it available for future searches. Additionally, if the user requests a summary of the entire thread, the server passes the request to a generation AI, which generates the summary. The generated summary is stored in a database and sent to the device.

[2701] Specific examples

[2702] For example, consider the case where User A asks a question in a live chat, "Please tell me how to use Product A." This message is recognized as positive by the emotion engine. In response, the generation AI immediately responds, "I'll explain in detail how to use Product A!" If, as the conversation progresses, a request to "know more" arises, it is possible to create a thread summarizing the content and provide more information on a separate screen.

[2703] Prompt Sentence Examples

[2704] "A user is asking about how to use Product A. The sentiment engine recognized a positive sentiment. Generate an appropriate response."

[2705] This system allows users to receive appropriate support that corresponds to their emotions, enabling efficient communication.

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

[2707] Step 1:

[2708] When a user selects the "Create a thread" option for a particular message, the device sends this thread creation request to the server.

[2709] Input: User thread creation request

[2710] Data processing: Converting thread creation requests into data format

[2711] Output: Thread creation request data

[2712] Step 2:

[2713] The server generates a new thread ID and saves it in the database. At the same time, it generates screen data for the thread and sends it to the device.

[2714] Input: Thread creation request data

[2715] Data calculation: Generate a unique thread ID and save it in the database. Generate screen data for the thread.

[2716] Output: Thread ID and screen data

[2717] Step 3:

[2718] The device displays the new thread screen to the user.

[2719] Input: Thread ID and screen data

[2720] Data processing: Convert screen data into display format

[2721] Output: Thread screen displayed

[2722] Step 4:

[2723] A user posts a message in a thread, and the device sends this message to the server.

[2724] Input: User's message

[2725] Data processing: converting messages into data format

[2726] Output: Message data

[2727] Step 5:

[2728] The server stores the posted message in a database and notifies all participants in the thread.

[2729] Input: Message data

[2730] Data calculation: Message storage in the database and generation of notification data

[2731] Output: Stored message and notification data

[2732] Step 6:

[2733] The emotion engine analyzes the message and recognizes the user's emotions.

[2734] Input: Posted message data

[2735] Data calculation: Emotion data generation by applying emotion analysis algorithms

[2736] Output: Emotion analysis results

[2737] Step 7:

[2738] The recognition results are provided to the generation AI, which generates an appropriate response.

[2739] Input: Sentiment analysis results

[2740] Data Computation: Using generative AI models to generate appropriate responses based on emotional data

[2741] Output: The generated response

[2742] Step 8:

[2743] The server stores the generated AI's response in a database and notifies all participants.

[2744] Input: The generated response

[2745] Data calculation: Save response data and generate notification data

[2746] Output: Response notification data

[2747] Step 9:

[2748] The device displays the generated AI's response on the thread screen.

[2749] Input: Response notification data

[2750] Data processing: Convert response data into a display format

[2751] Output: Response data displayed in the thread view

[2752] Step 10:

[2753] When a user clicks "like" or rates a particular message, the device sends this reaction request to the server.

[2754] Input: User reaction data

[2755] Data processing: Converting reaction data into a transmission format

[2756] Output: Reaction request data

[2757] Step 11:

[2758] The server saves the number of reactions in a database and notifies all participants of the new number of reactions.

[2759] Input: Reaction request data

[2760] Data calculation: Update the number of reactions and generate notification data

[2761] Output: Updated reaction count and notification data

[2762] Step 12:

[2763] When a user selects the option to archive a thread, the terminal sends an archive request to the server.

[2764] Input: User's archive request

[2765] Data processing: Converting archive request data

[2766] Output: Archive request data

[2767] Step 13:

[2768] The server stores the thread in a database, making it available for later retrieval.

[2769] Input: Archive request data

[2770] Data operation: Save the corresponding thread in the database and set it to searchable

[2771] Output: Archived thread data

[2772] Step 14:

[2773] When a user requests a summary for an entire thread, the server passes the request to the generation AI, which generates the summary.

[2774] Input: Summary request data

[2775] Data Computation: Message Summarization by Generative AI

[2776] Output: Generated summary data

[2777] Step 15:

[2778] The generated summary is stored in a database and transmitted to the terminal.

[2779] Input: Summary data

[2780] Data calculation: saving summary data and sending it to the terminal

[2781] Output: Summary data displayed on the terminal

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

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

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

[2785] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[2799] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation between multiple people, including the AI ​​generator, takes place on a separate screen. This system is realized by the following specific programs and their processing:

[2800] Creating and Managing Threads

[2801] Users: Select the "Start a thread" option for a specific message in a conversation.

[2802] Terminal: Sends a thread creation request to the server.

[2803] Server: Generates a unique thread ID for the new thread and saves it in the database. At the same time, it generates screen data and sends it to the device.

[2804] Terminal: Shows the new thread screen to the user.

[2805] Conversations in threads

[2806] User: Post a message in a thread.

[2807] Terminal: Sends posted messages to the server.

[2808] Server: Saves the message in a database and notifies all participants in the thread.

[2809] Generative AI: Analyzes new messages and generates appropriate responses.

[2810] Server: Saves the generated AI's answers in a database and notifies all participants in the thread.

[2811] Device: Display the generated AI's answer on the thread screen.

[2812] Information archiving and retrieval

[2813] Users: Select the option to archive the thread.

[2814] Terminal: Sends an archive request to the server.

[2815] Server: Save the thread as an archive in the database.

[2816] Users: Enter search keywords to search archived threads.

[2817] Device: Sends a search request to the server.

[2818] Server: Searches the database to find the appropriate archive.

[2819] Server: Returns search results to the device.

[2820] Terminal: Show archived threads to the user.

[2821] Reactions to messages

[2822] User: Likes a specific message.

[2823] Device: Sends a "like" request to the server.

[2824] Server: Stores the number of likes in a database and notifies all participants of the new number of likes.

[2825] On your device: See the updated number of likes on the thread view.

[2826] Generative AI summary creation

[2827] User: Request a summary of the entire thread.

[2828] Terminal: Sends a summary request to the server.

[2829] Server: Passes all messages in the thread to the generated AI for analysis.

[2830] Generative AI: Generates a summary based on the message content.

[2831] Server: Stores the summary in a database and sends it to the device.

[2832] Terminal: Display the summary in the thread view.

[2833] Search link provided by AI generation

[2834] User: Asks detailed questions to the generating AI.

[2835] Terminal: Sends the question to the server.

[2836] Server: Passes the question content to the generation AI for analysis.

[2837] Generative AI: Generates search links based on the question.

[2838] Server: Stores the generated link in a database and sends it to the device.

[2839] On your device: View the link in the thread view.

[2840] Specific examples

[2841] Create and manage itinerary coordination threads

[2842] 1. User A selects the "Create a thread" option in a messaging application for the message "Let's decide on travel dates this year."

[2843] 2. The device sends a thread creation request to the server.

[2844] 3. The server generates a new thread ID and saves it in the database. At the same time, it generates screen data and sends it to the device.

[2845] 4. The device displays the new thread screen to User A.

[2846] 5. User B posts a message saying, "Maybe the end of August would be good."

[2847] 6. The device sends the message to the server.

[2848] 7. The server saves the message in the database and notifies all participants.

[2849] 8. The AI ​​analyzes the message and generates a reply: "Since it's the end of August, what date exactly is it scheduled for?"

[2850] 9. The server stores the generated AI's answers in a database and notifies all participants.

[2851] 10. The device will display the AI's answer.

[2852] Generate a thread summary

[2853] 1. User A requests a summary of the entire thread.

[2854] 2. The terminal sends a summary request to the server.

[2855] 3. The server passes all messages in the thread to the generated AI for analysis.

[2856] 4. The generation AI generates a summary such as "The travel dates have been decided as August 28th to 30th."

[2857] 5. The server stores the summary in a database and sends it to the terminal.

[2858] 6. The terminal displays the summary to User A.

[2859] These features allow users to create threads based on their own purposes and needs, and efficiently organize and share information with the support of generative AI.

[2860] The processing flow will be explained below.

[2861] Creating and Managing Threads

[2862] Step 1:

[2863] A user selects the "Create a thread" option for a specific message in a conversation.

[2864] Step 2:

[2865] The terminal sends a thread creation request to the server.

[2866] Step 3:

[2867] The server generates a unique thread ID for the new thread and stores it in the database.

[2868] Step 4:

[2869] The server generates screen data for the thread and sends it to the terminal.

[2870] Step 5:

[2871] The terminal displays the new thread screen to the user.

[2872] Conversations in threads

[2873] Step 1:

[2874] A user posts a message in a thread.

[2875] Step 2:

[2876] The device sends the posted message to the server.

[2877] Step 3:

[2878] The server stores the message in a database.

[2879] Step 4:

[2880] The server notifies all participants in the thread of the new message.

[2881] Step 5:

[2882] Generative AI analyzes new messages and generates appropriate responses.

[2883] Step 6:

[2884] The server stores the generated AI's answer in a database and notifies all participants in the thread.

[2885] Step 7:

[2886] The device will display the generated AI's answer on the thread screen.

[2887] Information archiving and retrieval

[2888] Step 1:

[2889] The user selects the option to archive the thread.

[2890] Step 2:

[2891] The device sends an archive request to the server.

[2892] Step 3:

[2893] The server saves the thread as an archive in the database.

[2894] Step 4:

[2895] A user enters search keywords to search archived threads.

[2896] Step 5:

[2897] The device sends a search request to the server.

[2898] Step 6:

[2899] The server searches the database to find the appropriate archive.

[2900] Step 7:

[2901] The server returns the search results to the terminal.

[2902] Step 8:

[2903] The device displays the archived thread to the user.

[2904] Reactions to messages

[2905] Step 1:

[2906] A user "likes" a particular message.

[2907] Step 2:

[2908] The device sends a "like" request to the server.

[2909] Step 3:

[2910] The server stores the number of "likes" in a database and notifies all participants of the new number of "likes."

[2911] Step 4:

[2912] The device will display the updated number of likes on the thread screen.

[2913] Generative AI summary creation

[2914] Step 1:

[2915] The user requests a summary of the entire thread.

[2916] Step 2:

[2917] The terminal sends a summary request to the server.

[2918] Step 3:

[2919] The server passes all messages in the thread to the generated AI for analysis.

[2920] Step 4:

[2921] The generative AI generates a summary based on the message content.

[2922] Step 5:

[2923] The server stores the summary in a database and sends it to the terminal.

[2924] Step 6:

[2925] The device displays a summary on the thread screen.

[2926] Search link provided by AI generation

[2927] Step 1:

[2928] The user asks detailed questions to the generating AI.

[2929] Step 2:

[2930] The device sends the question to the server.

[2931] Step 3:

[2932] The server passes the question content to the generation AI for analysis.

[2933] Step 4:

[2934] The generation AI generates a search link based on the question.

[2935] Step 5:

[2936] The server stores the generated link in a database and sends it to the device.

[2937] Step 6:

[2938] Your device will display the link in the thread screen.

[2939] Example 1

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

[2941] Conventional messaging systems have limited functionality for creating threads for specific messages, making it difficult to hold efficient conversations with multiple people. They also lacked effective ways to manage, summarize, and search information within threads, particularly with advanced support using generative AI. This made it difficult for users to smoothly organize and share information.

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

[2943] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a request to create a thread and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for receiving messages in the thread, saving it in a database, and notifying all participants, means for generating a new message, means for saving the generated message in a database and notifying all participants, means for generating and displaying a summary of the entire thread, and means for generating and displaying a link when a user asks a detailed question. This makes it possible to easily create a thread for a specific message, efficiently advance conversations among multiple people, provide advanced support using generation AI, and smoothly organize and share information.

[2944] "Thread" means an independent stream of conversation associated with a particular message.

[2945] "Thread ID" refers to an identification code generated to uniquely identify a new thread.

[2946] "Database" refers to a system designed to efficiently store, retrieve, and manage data.

[2947] "Terminal" refers to the electronic device, such as a smartphone or computer, that a user uses to access the system.

[2948] "Generative AI" refers to a system that uses artificial intelligence technology to analyze messages and generate responses.

[2949] "Summary" means information that briefly summarizes the main message content in a thread.

[2950] "Link" refers to a URL that provides access to related information generated when a user asks a detailed question.

[2951] A "request" refers to a communication requesting a specific operation or information from a server.

[2952] "Notification" refers to a message sent from the system to convey information to the user.

[2953] A "message" refers to text, images, or other data that a user sends within a thread.

[2954] The system according to the present invention creates a thread for a specific message within a messaging application, and a conversation between multiple people, including the AI ​​generator, takes place on a separate screen. Detailed embodiments of this system are described below.

[2955] Creating and Managing Threads

[2956] First, a user selects the "start a thread" option for a particular message within a messaging application by clicking a specific button within the application.

[2957] The device then sends a thread creation request to the server, which is sent as an HTTP POST request to the server's specified endpoint.

[2958] The server generates a unique thread ID for the new thread and saves this ID in a database. The server generates a UUID and saves the information in a database (e.g., MongoDB). At the same time, the server generates screen data for the new thread and returns it to the device in JSON format.

[2959] Finally, the terminal displays the new thread screen to the user. The terminal uses the received JSON data to render HTML in the browser and displays the new thread screen.

[2960] Conversations in threads

[2961] Users post messages in threads. When a user enters text into the input box and clicks the "Send" button, the device sends the message data to the server.

[2962] The server stores the received message in a database and notifies all participants in the thread by storing the message in a "messages" collection in the database and sending notifications to all participants using WebSocket or push notifications.

[2963] When a generative AI receives a new message, it analyzes its content and generates an appropriate response. This analysis and generation process uses natural language processing (NLP) algorithms. For example, GPT-4 can be used as a response generation model.

[2964] The generated answer is sent back to the server and stored in a database. At the same time, the server sends a notification to all participants. The device displays the received answer from the AI ​​on the thread screen.

[2965] Information archiving and retrieval

[2966] When a user selects the option to archive a thread, the device sends an archive request to the server, which updates the status of the thread in the "threads" collection to "archived" and stores it in the database.

[2967] To search for archived threads, a user inputs search keywords and sends a search request from their device to the server. The server queries the database, searches for the relevant archives, and returns the results to the device. The device then displays the search results to the user.

[2968] Reactions to messages

[2969] When a user clicks "like" on a particular message, the device sends a "like" request to the server. The server updates the "likes" field of the message in the database and sends a notification to all participants via WebSocket. The device then displays the updated number of "likes" on the thread screen.

[2970] Generative AI summary creation

[2971] When a user requests a summary of an entire thread, the device sends a summary request to the server. The server passes all messages in the thread to the generation AI, which analyzes them. The generation AI generates a summary and stores it in a database. The server sends the summary to the device, which displays it on the thread screen.

[2972] As a concrete example, the following prompt sentence can be input to a generative AI model:

[2973] "Generate an appropriate response to the message 'Late August might be good'. Include specific questions to help us adjust our travel dates."

[2974] Search link provided by AI generation

[2975] When a user asks a detailed question to the AI, the device sends the question to the server. The server passes the question to the AI, which analyzes it and generates an appropriate search link. The generated link is sent via the server to the device, which then displays it to the user.

[2976] This will result in a system that can effectively manage threads within messaging applications, support conversations with generative AI, archive and search information, react to messages, and provide summaries and search links.

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

[2978] Creating and Managing Threads

[2979] Step 1:

[2980] Subject: User

[2981] A user selects the "Create a thread" option for a particular message within a messaging application, which in turn results in the user clicking the "Create a thread" button.

[2982] Input: User clicks "Start a thread" button

[2983] Output: Create a "thread" request

[2984] Step 2:

[2985] Subject: Terminal

[2986] The device sends a thread creation request to the server, and sends data to the specified endpoint on the server using an HTTP POST request.

[2987] Input: "Start a thread" request

[2988] Output: HTTP POST request to the server

[2989] Step 3:

[2990] Subject: Server

[2991] The server generates a new thread ID and stores it in the database. It generates a UUID and stores it in the "threads" collection in the MongoDB database.

[2992] Input: Thread creation request via HTTP POST request

[2993] Output: Generate a new thread ID and save it to the database

[2994] Step 4:

[2995] Subject: Server

[2996] The server generates screen data for a new thread and sends it to the terminal in JSON format. It then uses a template engine to generate HTML and passes it to the terminal.

[2997] Input: The newly generated thread ID

[2998] Output: Generate and send the new thread's screen data in JSON format.

[2999] Step 5:

[3000] Subject: Terminal

[3001] The device displays the new thread screen to the user. The received JSON data is rendered in the browser and the new thread screen is displayed.

[3002] Input: Screen data sent from the server

[3003] Output: The new thread screen as seen by the user

[3004] Conversations in threads

[3005] Step 1:

[3006] Subject: User

[3007] A user posts a message in a thread by entering text into the input box and clicking the "Send" button.

[3008] Input: The user types into an input box and clicks the "Submit" button

[3009] Output: Generate a request to send a message

[3010] Step 2:

[3011] Subject: Terminal

[3012] The device sends the posted message to the server by sending an HTTP POST request to the server.

[3013] Input: Message data entered by the user

[3014] Output: HTTP POST request to the server

[3015] Step 3:

[3016] Subject: Server

[3017] The server saves the message in a database and notifies all participants in the thread. The server saves the message in a "messages" collection in the database and sends notifications to all participants using WebSocket or push notifications.

[3018] Input: Message data sent in the HTTP POST request

[3019] Output: Save the message to the database and send a notification

[3020] Step 4:

[3021] Subject: Generation AI

[3022] Generative AI analyzes new messages and generates appropriate responses. It uses NLP algorithms to analyze the message content and generates responses using response generation models (e.g., GPT-4).

[3023] Input: A new message posted to a thread

[3024] Output: Answer by generative AI

[3025] Step 5:

[3026] Subject: Server

[3027] The server saves the generated AI's answer in a database and notifies all participants.The server saves the generated answer in a database and notifies all participants via WebSocket or push notification.

[3028] Input: Answer by generative AI

[3029] Output: Save to database and send notification

[3030] Step 6:

[3031] Subject: Terminal

[3032] The device displays the generated AI's answer on the thread screen. The device renders the received answer data and displays it on the thread screen.

[3033] Input: The generated AI's answer data sent from the server

[3034] Output: Display on thread screen

[3035] Information archiving and retrieval

[3036] Step 1:

[3037] Subject: User

[3038] The user selects the option to archive the thread: Clicks the Archive button.

[3039] Input: User clicks the archive button

[3040] Output: Archive request generated

[3041] Step 2:

[3042] Subject: Terminal

[3043] The device sends an archive request to the server using an HTTP POST request.

[3044] Input: User-generated archive request

[3045] Output: HTTP POST request to the server

[3046] Step 3:

[3047] Subject: Server

[3048] The server archives the thread in the database and updates the status of the "threads" collection in the database to "archived."

[3049] Input: Archive Request

[3050] Output: Archive of threads in a database

[3051] Step 4:

[3052] Subject: User

[3053] Users can enter search keywords to search archived threads by entering keywords in the search box and clicking the "Search" button.

[3054] Input: Search keyword

[3055] Output: Generate a search request

[3056] Step 5:

[3057] Subject: Terminal

[3058] The device sends a search request to the server, sending a search query via an HTTP GET request.

[3059] Input: A search request containing the search keyword

[3060] Output: HTTP GET request to the server

[3061] Step 6:

[3062] Subject: Server

[3063] The server searches the database to find the relevant archive. Based on the search query, it queries the database to retrieve the results.

[3064] Input: Search request

[3065] Output: Search results for matching archives

[3066] Step 7:

[3067] Subject: Server

[3068] The server returns the search results to the device. The search results are sent to the device in JSON format.

[3069] Input: Search results

[3070] Output: Send search results to your device

[3071] Step 8:

[3072] Subject: Terminal

[3073] The device displays the archived threads to the user. The device renders the search results and displays the archived threads to the user.

[3074] Input: Search results sent from the server

[3075] Output: Archived threads as seen by the user

[3076] Reactions to messages

[3077] Step 1:

[3078] Subject: User

[3079] A user "likes" a particular message by clicking the "like" icon next to the message.

[3080] Input: User clicks the "Like" icon

[3081] Output: Generate a "Like" request

[3082] Step 2:

[3083] Subject: Terminal

[3084] The device sends a "Like" request to the server. The "Like" data is sent to the server via an HTTP POST request.

[3085] Input: "Like" request

[3086] Output: HTTP POST request to the server

[3087] Step 3:

[3088] Subject: Server

[3089] The server saves the number of "likes" in a database and notifies all participants of the new number of "likes." It updates the "likes" field of the corresponding message in the database and sends a notification to all participants via WebSocket.

[3090] Input: "Like" request

[3091] Output: Update the like count and send a notification

[3092] Step 4:

[3093] Subject: Terminal

[3094] Your device will display the updated number of likes on the thread screen and update the displayed message list to reflect the new number of likes.

[3095] Input: New number of likes sent from the server

[3096] Output: Updated number of likes displayed to the user

[3097] Generative AI summary creation

[3098] Step 1:

[3099] Subject: User

[3100] A user requests a summary of the entire thread by clicking the "Summary" button on the thread screen.

[3101] Input: User clicks "Summary" button

[3102] Output: Generate summary request

[3103] Step 2:

[3104] Subject: Terminal

[3105] The terminal sends a summary request to the server using an HTTP POST request.

[3106] Input: A user-generated summary request

[3107] Output: HTTP POST request to the server

[3108] Step 3:

[3109] Subject: Server

[3110] The server passes all messages in the thread to the AI ​​generator for analysis. All messages in the thread are input into the AI ​​model, and a natural language processing algorithm generates a summary.

[3111] Input: All messages

[3112] Output: Generated summary

[3113] Step 4:

[3114] Subject: Generation AI

[3115] The generative AI generates a summary and stores it in a database.

[3116] Input: All messages in the thread

[3117] Output: Summary data

[3118] Step 5:

[3119] Subject: Server

[3120] The server sends the summary to the terminal, and returns the summary data to the terminal as an HTTP response.

[3121] Input: Generative AI summary

[3122] Output: Send summary data to terminal

[3123] Step 6:

[3124] Subject: Terminal

[3125] The device displays a summary on the thread screen.

[3126] Input: Summary data sent from the server

[3127] Output: A summary that is displayed to the user

[3128] Search link provided by AI generation

[3129] Step 1:

[3130] Subject: User

[3131] The user asks the AI ​​a detailed question, enters the question, and clicks the "Submit" button.

[3132] Input: User's question

[3133] Output: Generate a question request

[3134] Step 2:

[3135] Subject: Terminal

[3136] The device sends the question to the server using an HTTP POST request.

[3137] Input: The question typed by the user

[3138] Output: HTTP POST request to the server

[3139] Step 3:

[3140] Subject: Server

[3141] The server passes the question to the AI ​​generator for analysis, inputs the question into the AI ​​model, and generates an appropriate search link.

[3142] Input: User's question

[3143] Output: Generated search link

[3144] Step 4:

[3145] Subject: Generation AI

[3146] The generation AI generates the appropriate search link and returns it to the server.

[3147] Input: User's question

[3148] Output: Generated search link

[3149] Step 5:

[3150] Subject: Server

[3151] The server sends the generated link to the device.

[3152] Input: Search link generated by AI

[3153] Output: Sending link data to the terminal

[3154] Step 6:

[3155] Subject: Terminal

[3156] Your device will display the link in the thread screen.

[3157] Input: Search link sent from the server

[3158] Output: The link that is displayed to the user

[3159] The above are the specific processing steps of this system. By explaining the process from input to output in detail, the processing flow can be clearly understood.

[3160] (Application example 1)

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

[3162] In manufacturing processes, efficient and effective communication is required when workers and engineers identify problems in the manufacturing process and discuss improvement measures. Conventional methods can delay discussions to quickly resolve problems in the manufacturing process, potentially resulting in a decline in overall productivity. The present invention aims to provide a system that enables workers, engineers, and generative AI to work together to identify problems in the manufacturing process and quickly propose improvement measures to address these issues.

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

[3164] In this invention, the server includes means for providing an option to create a thread for a specific message, means for receiving a request to create a thread and generating a unique thread ID and saving it in a database, means for generating screen data for the thread and sending it to a terminal, means for managing threads for discussions about the manufacturing process, and means for using a generation AI that identifies problems in the manufacturing process and proposes improvement measures. This makes it possible to efficiently discuss problems in the manufacturing process through threads and quickly take improvement measures based on suggestions from the generation AI.

[3165] A "thread" is a unit for separating and managing a series of messages or conversations on a particular topic.

[3166] A "thread ID" is an identifier generated by the system to uniquely identify an individual thread.

[3167] A "database" is a data structure that stores information in an organized manner and allows it to be efficiently searched and updated.

[3168] "Generative AI" is a system that uses artificial intelligence technology to generate responses and suggestions in the form of text or voice.

[3169] A "terminal" is a device that allows a user to access and operate the system. Examples include smartphones and computers.

[3170] A "manufacturing process" is a series of operations and treatments that are carried out to create a product from raw materials.

[3171] A "message" is data such as text, audio, or images used to convey information between users or systems.

[3172] "Archiving" is the process of storing data or information that is no longer in use so that it can be retrieved later when needed.

[3173] "Notification" is a function that allows the system to notify the user when a specific event or information occurs.

[3174] A "summary" is a short sentence that concisely summarizes a longer text or multiple messages.

[3175] This invention relates to a "manufacturing process improvement thread management application" for efficiently improving manufacturing processes. This system creates threads for specific messages, and workers, engineers, and generation AI work together to identify problems in the manufacturing process and propose improvement measures.

[3176] Explanation of program processing

[3177] Creating a Thread

[3178] The user selects the "Create a thread" option for a specific message related to the manufacturing process. The device sends the request to the server, which generates a unique thread ID and stores it in the database. At the same time, it also generates screen data for the thread and sends it to the device.

[3179] Posting and parsing messages

[3180] When a user posts a message in a thread, the device sends the message to the server, which stores the message in a database and notifies all participants in the thread. The generative AI also analyzes the new message and generates an appropriate response or suggestion. The server stores the generated response in a database and notifies all participants in the thread.

[3181] Archive and search threads

[3182] A user selects the option to archive a thread and submits an archive request. The server stores the thread as an archive in its database, making it available for future retrieval. When a user searches the archives by entering specific keywords, the server searches the database and returns the results.

[3183] Generate a summary

[3184] A user can request a summary of an entire thread. The server passes all messages in the thread to the AI ​​generator, which generates a summary. The server stores the summary in a database and sends it to the device.

[3185] Hardware and software used

[3186] Hardware: Robot terminals used in factories, servers (computers that process the database and generative AI)

[3187] Software: Python language, AI response generation model (e.g., GPT-4), SQL database (e.g., PostgreSQL)

[3188] Specific example explanation

[3189] Example 1: Improving bottlenecks on a production line

[3190] Worker A sends a message saying, "I want to discuss the bottleneck on the production line," creating a new thread. Engineer B posts, "The bottleneck is caused by Machine X stopping frequently." The AI ​​generator responds, "To reduce the frequency of Machine X stopping, we need to change the routine maintenance schedule."

[3191] Example 2: Summary of progress for a long-term project

[3192] User A requests a summary of the entire thread. The server sends the summary request to the generation AI. The generation AI generates a summary saying, "The project is 60% complete, and the next step is to adjust equipment Y."

[3193] Prompt Sentence Examples

[3194] Message response generation:

[3195] Message: "Machine X is experiencing frequent downtime"

[3196] Prompt: "From a manufacturing process perspective, what suggestions can you make to reduce the downtime of machine X?"

[3197] Thread summary generation:

[3198] Prompt: "Summarize the following messages: [message 1, message 2, message 3, ...]"

[3199] In this way, this system makes it possible to efficiently discuss problems in the manufacturing process through threads and quickly take improvement measures based on suggestions from the generative AI.

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

[3201] Step 1:

[3202] (Step 1) The user selects the "Create a thread" option for a specific message related to the manufacturing process.

[3203] (Input) The message for which the user selected the "start a thread" option.

[3204] (Output) A thread creation request is sent from the terminal to the server.

[3205] (Specific operation) The user selects a specific message on the device screen and clicks the "Create a thread" button. This generates a thread creation request, which is sent from the device to the server as an HTTP request.

[3206] Step 2:

[3207] (Step 2) The server generates a unique thread ID and stores it in the database.

[3208] (Input) A thread creation request.

[3209] (Output) The generated thread ID and screen data for the thread are sent to the terminal.

[3210] (Specific operation) After the server receives a thread creation request, it generates a unique identifier (thread ID) and stores it in the database. It then generates screen data for the thread and notifies the terminal.

[3211] Step 3:

[3212] (Step 3) A user posts a message in the thread.

[3213] (Input) The message posted by the user.

[3214] (Output) A message is sent from the terminal to the server.

[3215] (Specific operation) The user enters a message in the input field of the terminal and clicks the send button, which sends the message data from the terminal to the server as an HTTP request.

[3216] Step 4:

[3217] (Step 4) The server saves the message in a database and notifies all participants in the thread.

[3218] (Input) The message posted by the user.

[3219] (Output) The message is saved in the database and notified to all participants.

[3220] (Specific operation) The server stores the received message in a database and sends a notification to the terminals of other users participating in the thread.

[3221] Step 5:

[3222] (Step 5) Generative AI analyzes the new message and generates an appropriate response or suggestion.

[3223] (Input) The message posted by the user.

[3224] (Output) The answer or suggestion from the generative AI.

[3225] (Specific operation) The server sends message data to the generation AI, which analyzes the prompt and generates an appropriate answer or suggestion. Example: "From the perspective of improving the manufacturing process, please make a suggestion to reduce the frequency of machine X's stoppages."

[3226] Step 6:

[3227] (Step 6) The server saves the answer generated by the ...

Claims

1. A means to provide the option to create a thread for a particular message; A means for receiving a thread creation request, generating a unique thread ID, and storing it in a database; A means for generating screen data for a thread and transmitting the data to a terminal; A system including:

2. A means for receiving messages posted by users in a thread and storing them in a database; A means of notifying other participants in the thread of the posted message; A means for the generative AI to analyze new messages and generate responses; A means of notifying all participants in the thread of the generated answer; The system of claim 1 , comprising:

3. Providing the option to archive threads and a means to accept archive requests; A means of storing archived threads in a database; A means to search archived threads and display search results; The system of claim 1 , comprising:

4. A way to add a "like" to a specific message, A means to store the number of added "likes" in a database and notify other participants; The system of claim 1 , comprising:

5. A means for the Generative AI to accept requests to generate summaries of entire threads; and a means for parsing all messages in a thread and generating a summary; means for transmitting the generated summary to a terminal and displaying the summary to a user; The system of claim 1 , comprising:

6. A means for the AI ​​to analyze detailed user questions and generate search links; A means for storing the generated link in a database and transmitting it to a terminal; The system of claim 1 , comprising:

Images