system

Abstract

We provide the system. [Solution] A means for users to input their own information, A server provides means for receiving input information from the user and storing it in a database, A means for a user to send a request to obtain information about other users, The server has means for retrieving information about other users from the database based on the aforementioned request and returning it to the user, The server utilizes natural language processing techniques to generate conversation topics, Means for saving the generated conversation topic and returning it to the user, A system that includes this.

Description

Technical Field

[0004] ,

[0006] , , , , , ,

[0005] , , ,

[0003] , , , ,

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

Background Art

[0002] Patent Document 1 discloses a method for controlling a persona chatbot, which is performed by at least one processor, and includes steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to an explanation of a 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

Summary of the Invention

Problems to be Solved by the Invention

[0004] <于 “Problems to be Solved by the Invention” and “Means for Solving the Problems” are shown.

[0005] In modern enterprises, communication between employees in different departments or different specialized fields is important. However, due to the lack of common topics or interests, it may be difficult to start a meaningful conversation. Especially in meetings or lunchtimes between employees who meet for the first time, it is required to promote ice-breaking or smooth communication. Against this background, there is a need for a means for employees to easily find common topics and enliven conversations.

Means for Solving the Problems

[0006] To solve the above problems, the present invention provides the following system: It provides a means for the user to input their own information (name, department, hobbies, etc.), and the server receives this information and stores it in a database. It also provides a means for the user to send a request to obtain information about other users, and based on this request, the server retrieves the information of other users from the database and sends it back to the user. Furthermore, the server uses natural language processing technology to generate conversation topics, stores these generated conversation topics, and sends them back to the user. As a result, the user can easily find common topics with other employees, and communication during meetings and lunch breaks will be smoother.

[0007] Understood. Below are definitions of key terms included in the claims.

[0008] A "user" is an individual who uses the system to input their own information and retrieve information and conversation topics from other users.

[0009] "Information" refers to data about the user, including name, department, hobbies, etc.

[0010] A "server" is a computer that receives requests from users, performs the necessary processing, and returns the results to the client.

[0011] A "database" is an information storage system that stores user information and conversation topics in a structured format, and allows for searching and updating as needed.

[0012] A "request" is a processing request sent by a user to a server, intended to retrieve information about other users or generate conversation topics.

[0013] "Natural language processing technology" refers to technology that enables computers to understand and generate natural language, and in this invention, it is used to generate conversation topics.

[0014] A "conversation topic" is a theme or topic generated to facilitate conversations between users.

[0015] An "external API" is an interface for using functions provided by an external service provider and is used as a natural language processing technology in the present invention.

[0016] "Participants" are the users considered in the generation of conversation topics.

[0017] With these definitions, the technical scope of the invention can be clearly understood.

Brief Description of the Drawings

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

Mode for Carrying Out the Invention

[0019] Hereinafter, an example of an embodiment of a system according to the technology of the present disclosure will be described with reference to the accompanying drawings.

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

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

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

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

[0024] In the following embodiments, the signed communication interface (I / F) is an interface that includes a communication processor and an antenna, etc. The communication interface manages communication between multiple computers. Examples of communication standards applicable to the communication interface include wireless communication standards such as 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), or Bluetooth (registered trademark).

[0025] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." That is, "A and / or B" means that it may be A alone, or B alone, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" applies when expressing three or more things linked by "and / or."

[0026] [First Embodiment]

[0027] Figure 1 shows an example of the configuration of the data processing system 10 according to the first embodiment.

[0028] As shown in Figure 1, the 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.

[0029] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0031] The reception device 38 is equipped with a touch panel 38A and a microphone 38B, etc., and receives user input. The touch panel 38A receives user input by detecting contact with an object (e.g., a pen or finger). The microphone 38B receives user input by detecting the user's voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and 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.

[0032] 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 perceptible to the user 20 (e.g., audio and / or text). The display 40A displays visible information such as text and images according to instructions from the processor 46. The speaker 40B outputs audio according to instructions from the processor 46. The camera 42 is a small digital camera equipped with an optical system such as a lens, aperture, and shutter, and an image sensor such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0033] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various types of information between processor 46 and processor 28 via network 54.

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

[0035] As shown in Figure 2, in the data processing device 12, a specific processing 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" related to the technology of this 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 according to the specific processing program 56 executed on the RAM 30.

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

[0037] In the smart device 14, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. The reception output program 60 is used in conjunction with a 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

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

[0039] This invention is a system in which a user inputs their own information, retrieves information from other users, and generates conversation topics. This system performs user information registration, retrieves other users' profiles, and generates conversation topics using natural language processing technology.

[0040] 1. User information registration

[0041] The server provides an interface for the user to enter their information (name, department, hobbies, etc.). When the terminal enters this information and presses the "Register" button, the terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[0042] The server receives this request and extracts the name, department, and hobby information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. After saving, the server notifies the terminal that the user registration was successful.

[0043] 2. Obtaining other users' information

[0044] A user sends a request from their device to retrieve information about other users. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device uses JSON format for this request.

[0045] The server receives this request and extracts the user ID from the JSON format. The server connects to the database and executes a query to retrieve all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the terminal as a JSON response. This allows the user to retrieve the profile information of other employees.

[0046] 3. Generating conversation topics

[0047] To generate a conversation topic, the user enters the names of other employees and presses the "Generate Topic" button. The terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint.

[0048] The server receives this request and extracts a list of participant names from the JSON format. Next, the server uses natural language processing techniques to call the GPT API to generate a conversation topic. This API call generates a conversation topic based on the participant attribute information.

[0049] The generated conversation topics are stored in a database by the server and then sent back to the terminal. The terminal displays the received conversation topics to the user, allowing the user to easily start a conversation.

[0050] Specific example

[0051] For example, suppose User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, User A wants to talk to other employees and presses the profile generation button to send a request. The server retrieves information about other employees from the database and sends it back to User A.

[0052] Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to user A.

[0053] In this way, the present invention promotes communication among employees from different departments and makes meetings and lunch breaks more meaningful.

[0054] The following describes the processing flow.

[0055] Understood. Below, I will explain the program's processing in detail, step by step.

[0056] 1. User information registration

[0057] Step 1:

[0058] The user enters their information (name, department, hobbies) into the input form and presses the "Register" button.

[0059] Step 2:

[0060] The terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[0061] Step 3:

[0062] The server receives the request and extracts information such as name, department, and hobbies from the JSON format.

[0063] Step 4:

[0064] The server connects to the database and saves the extracted user information to the Users table.

[0065] Step 5:

[0066] The server sends a message to the terminal in JSON format confirming that the user registration was successful.

[0067] Step 6:

[0068] The terminal receives a response from the server and displays a registration completion message to the user.

[0069] 2. Obtaining other users' information

[0070] Step 1:

[0071] The user presses the "Generate Profile" or "View Other Employees" button, specifies their user ID, and sends a request from their device.

[0072] Step 2:

[0073] The device sends a request in JSON format containing the user ID as a POST request to the server's / api / generate_profile endpoint.

[0074] Step 3:

[0075] The server receives the request and extracts the user ID from the JSON format.

[0076] Step 4:

[0077] The server connects to the database and executes a query to retrieve all other user information from the Users table.

[0078] Step 5:

[0079] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response.

[0080] Step 6:

[0081] The terminal receives a response from the server and displays other users' information on the screen.

[0082] 3. Generating conversation topics

[0083] Step 1:

[0084] The user enters the name of another employee and presses the "Generate Topic" button.

[0085] Step 2:

[0086] The device sends a JSON-formatted request containing a list of participant names as a POST request to the server's / api / generate_topics endpoint.

[0087] Step 3:

[0088] The server receives the request and extracts a list of participant names from the JSON format.

[0089] Step 4:

[0090] The server uses natural language processing technology to call an external natural language processing API and generate conversation topics based on the specified participants.

[0091] Step 5:

[0092] The server saves the generated conversation topics to the Conversations table in the database.

[0093] Step 6:

[0094] The server returns the generated conversation topic to the terminal in JSON format.

[0095] Step 7:

[0096] The terminal receives a response from the server and displays the generated conversation topic to the user.

[0097] This processing flow allows users to easily input their own information, retrieve information about other employees, and find common topics of conversation. This system is a concrete implementation aimed at promoting communication between employees from different departments and making meetings and lunch breaks more productive.

[0098] (Example 1)

[0099] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0100] In conventional communication support systems, it has been difficult for employees from different departments to efficiently share information and find common conversation topics. This has reduced opportunities to build new relationships and hindered information sharing and the establishment of collaborative relationships within companies. The present invention aims to solve these problems and provide a system that facilitates communication within companies.

[0101] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0102] In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the user to input the names of other users and send a request to generate a conversation topic, means for the server to utilize natural language processing technology to generate a conversation topic, means for storing the generated conversation topic and returning it to the user, and means for a terminal to display the generated conversation topic. This makes it possible for employees from different departments to efficiently find common conversation topics and communicate smoothly with each other.

[0103] A "user" refers to an end-user who inputs their own information into the system, retrieves information from other users, and generates conversation topics.

[0104] A "server" refers to a central computer system that receives information from users, stores it in a database, processes the data in response to requests, and generates and sends back conversation topics.

[0105] A "terminal" refers to a computer device (such as a PC or smartphone) that a user uses to input information, send requests, and receive responses.

[0106] A "database" refers to a data storage system used to store user information and generated conversation topics.

[0107] A "request" refers to a communication message from a user or device that requests information from a server for processing or acquisition.

[0108] "API" stands for Application Programming Interface, and refers to a set of protocols and tools for accessing external services and databases.

[0109] "Natural language processing technology" refers to all technologies used to understand and process human language using computers, including technologies such as text generation and topic extraction.

[0110] A "conversation topic" refers to a subject or theme that helps users to start a conversation smoothly with each other.

[0111] "Attribute information" refers to basic information about the user (such as name, department, and hobbies).

[0112] "Generation" refers to the process by which a system creates new data or information.

[0113] This invention is a system in which a user inputs their own information, retrieves information from other users, and generates conversation topics. This system performs user information registration, retrieves other users' profiles, and generates conversation topics using natural language processing technology. Specifically, it is implemented as follows:

[0114] Hardware and software used

[0115] The server functions as a central processing unit, handling all data processing and information storage / retrieval described later. The server is equipped with a database (selectable between SQL and NoSQL databases) and APIs for implementing natural language processing technologies (e.g., the GPT API).

[0116] The device is the interface with the user and is designed as a web application or mobile application.

[0117] The user operates the terminal to input and retrieve information and sends a conversation topic generation request.

[0118] User information registration

[0119] The server provides an interface for users to enter their information (e.g., name, department, hobbies, etc.). The user enters the information into a form on the terminal and presses the "Register" button. The terminal converts this information into JSON format and sends a POST request to the server's / api / register_user endpoint. The server receives this request and extracts the name, department, and hobbies from the received data. The server then connects to the database and saves this information to the Users table. Once the saving is complete, the server sends a message back to the terminal indicating successful registration.

[0120] Retrieving other user information

[0121] When a user wants to retrieve information about other users, they send a request from their device. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device structures this request in JSON format. The server receives the request and extracts the user ID. The server connects to the database and retrieves all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the device as a JSON response. This allows the user to retrieve the profile information of other employees.

[0122] Generating conversation topics

[0123] The user generates a conversation topic to find common ground for talking with other employees. When the user enters the names of other employees and presses the "Generate Topic" button, the terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint. The server receives this request and extracts the list of participants' names. The server then uses natural language processing techniques (e.g., the GPT API) to generate a conversation topic. This API call generates a conversation topic based on the participants' attribute information. The generated conversation topic is saved to a database by the server and then sent back to the terminal. The terminal displays this information to the user.

[0124] Specific example

[0125] For example, User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, if User A wants to talk to another employee, they press the profile generation button to send a request. The server retrieves information about the other employee from the database and sends it back to User A. Furthermore, if User A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to User A. In this way, communication between employees from different departments is facilitated, making meetings and lunch breaks more meaningful.

[0126] Example of a prompt

[0127] The following are examples of prompts to input into a generative AI model to generate conversation topics:

[0128] User Information: Name: Taro Yamada, Department: Sales Department, Hobbies: Reading

[0129] Contact information: Name: Hanako Sato, Department: Planning Department, Hobby: Calligraphy

[0130] Please create a topic that will be a common subject of discussion among these users.

[0131] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0132] User information registration

[0133] Step 1:

[0134] Summary: The user enters their own information.

[0135] Specific actions:

[0136] The user enters their "name," "department," and "hobbies" into the input form on their device.

[0137] Input: Information entered by the user in the input form (e.g., Name = Taro Yamada, Department = Sales Department, Hobby = Reading)

[0138] Output: User information displayed in the input form

[0139] Step 2:

[0140] Summary: The terminal converts the input information into JSON format and sends it to the server.

[0141] Specific actions:

[0142] The user presses the "Register" button. The device creates JSON data like the following and sends a POST request to the server's / api / register_user endpoint.

[0143] json

[0144] {

[0145] "Name": "Yamada Taro",

[0146] " [": "Sales Department"

[0147] "Hobbies": "Reading"

[0148] }

[0149] Input: User presses the "Register" button.

[0150] Output: Request data in JSON format

[0151] Step 3:

[0152] Summary: The server processes the received JSON data and saves the information to the database.

[0153] Specific actions:

[0154] The server receives the POST request and extracts the name, department, and hobbies from the JSON data. Using the extracted data, it executes the following SQL query on the database.

[0155] SQL

[0156] INSERT INTO Users (Name, Department, Hobby) VALUES ('Taro Yamada', 'Sales Department', 'Reading');

[0157] Input: User information in JSON format

[0158] Output: User information stored in the database

[0159] Step 4:

[0160] Summary: The server notifies the terminal that the information registration was successful.

[0161] Specific actions:

[0162] The server sends the following JSON response back to the terminal.

[0163] json

[0164] {

[0165] "status": "success",

[0166] "message": "User information has been registered."

[0167] }

[0168] Input: The result of the information being correctly saved in the database.

[0169] Output: JSON response of success message

[0170] Retrieving other user information

[0171] Step 1:

[0172] Summary: A user sends a request from their device to retrieve information about other users.

[0173] Specific actions:

[0174] The user clicks the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint.

[0175] json

[0176] {

[0177] "user_id": "1"

[0178] }

[0179] Input: User clicks the "Generate Profile" button and enters the user ID.

[0180] Output: Request data in JSON format

[0181] Step 2:

[0182] Summary: The server receives a request and retrieves other user information based on the user ID.

[0183] Specific actions:

[0184] The server receives the POST request and extracts the user ID from the JSON data. The server then executes the following SQL query on the database.

[0185] SQL

[0186] SELECT FROM Users WHERE user_id != '1';

[0187] Input: Request data in JSON format and User ID

[0188] Output: Other user information retrieved from the database

[0189] Step 3:

[0190] Summary: The server processes the acquired user information into a list format and sends it back to the terminal.

[0191] Specific actions:

[0192] The server converts the user information it has retrieved into response data in JSON format.

[0193] json

[0194] [

[0195] {

[0196] "Name": "Hanako Sato",

[0197] "Department": "Planning Department",

[0198] "Hobbies": "Calligraphy"

[0199] },

[0200] / / Other user information

[0201] ]

[0202] Input: User information retrieved from the database

[0203] Output: Response data in JSON format

[0204] Generating conversation topics

[0205] Step 1:

[0206] Summary: The user sends a request from their device to generate a conversation topic.

[0207] Specific actions:

[0208] The user enters the names of other employees to generate a conversation topic and presses the "Generate Topic" button. The terminal sends JSON data like the following as a POST request to the server's / api / generate_topics endpoint.

[0209] json

[0210] {

[0211] "Participants": ["Taro Yamada", "Hanako Sato"]

[0212] }

[0213] Input: User presses the "Generate Topic" button and enters a list of participant names.

[0214] Output: Request data in JSON format

[0215] Step 2:

[0216] Summary: The server receives the request and generates a conversation topic from the participants' names.

[0217] Specific actions:

[0218] The server receives the POST request and extracts a list of participant names from the JSON data. The server then sends the generated prompt to the GPT API.

[0219] User Information: Name: Taro Yamada, Department: Sales Department, Hobbies: Reading

[0220] Contact information: Name: Hanako Sato, Department: Planning Department, Hobby: Calligraphy

[0221] Please create a topic that will be a common subject of discussion among these users.

[0222] Input: Request data in JSON format and a list of participant names.

[0223] Output: Prompt message to the GPT API

[0224] Step 3:

[0225] Summary: The server receives the generated conversation topic and saves it to the database.

[0226] Specific actions:

[0227] The server receives a conversation topic generated from the GPT API and saves it to the database by executing an SQL query like the following:

[0228] SQL

[0229] INSERT INTO Topics (topic) VALUES ('About a book I recently read');

[0230] Input: Conversation topic generated from the GPT API

[0231] Output: Conversation topics stored in the database

[0232] Step 4:

[0233] Summary: The server sends the generated conversation topic back to the terminal and displays it to the user.

[0234] Specific actions:

[0235] The server sends the following JSON response back to the terminal.

[0236] json

[0237] {

[0238] "topics": ["About books I've recently read"]

[0239] }

[0240] The device displays the conversation topics it has received on the screen, allowing the user to review them.

[0241] Input: Conversation topics stored in the database

[0242] Output: Response data in JSON format and screen display

[0243] The above describes the specific processing steps, the inputs and outputs of each step, and the specific operations.

[0244] (Application Example 1)

[0245] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0246] In modern brick-and-mortar stores, a lack of communication among employees and between employees and customers is a cause of decreased customer satisfaction and reduced operational efficiency. Finding common ground is particularly difficult for employees from different departments, and for staff and customers meeting for the first time, making smooth conversation challenging. Furthermore, manually gathering common topics and profile information is time-consuming, highlighting the need for automated systems.

[0247] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0248] In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the server to use natural language processing technology and a generative AI model to generate conversation topics, and means for the server to store the generated conversation topics and return them to the user. This facilitates communication between employees and customers, enabling improvements in work efficiency and customer satisfaction.

[0249] A "user" is an individual who uses the system to input their own information and retrieve information and conversation topics from other users.

[0250] A "server" is a device or system that receives user input information, stores it in a database, retrieves and returns information from other users, and uses natural language processing technology to generate conversation topics.

[0251] A "database" is a digital storage system used to store and manage system-related information, such as user input and generated conversation topics.

[0252] A "request" is an instruction that a user sends to a server to ask the system to retrieve other users' information or to generate conversation topics.

[0253] Natural language processing (NLP) is a computer technology used to understand and generate human language. Its primary applications include text analysis, language modeling, and dialogue generation.

[0254] A "generative AI model" is an artificial intelligence model used to generate conversation topics based on user attribute information.

[0255] A "prompt sentence" is a text sentence that a generative AI model uses as input when generating conversation topics.

[0256] To implement this invention, it is necessary to build a system in which a user inputs their own information using a smartphone app, retrieves other users' profiles, and generates conversation topics. In this system, a server, a database, and a generative AI model using natural language processing technology play important roles. A specific example is shown below.

[0257] 1. User information registration

[0258] First, the user enters their information (name, department, hobbies, etc.) through the smartphone app interface. The entered information is converted to JSON format and sent from the device as a POST request to the server's / api / register_user endpoint. The server receives this request and extracts the information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. This registers the user information in the database.

[0259] 2. Obtaining other users' information

[0260] To retrieve information about other users, users send requests using a smartphone app. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. This request is also in JSON format. The server receives the request and extracts the user ID. The server connects to the database and executes a query to retrieve all other user information from the Users table. The retrieved user information is then processed into a list format and sent back to the device as a JSON response. This allows the user to retrieve the profile information of other employees.

[0261] 3. Generating conversation topics

[0262] Users request the generation of conversation topics to create common topics to talk about with other users within the app. For example, if a user wants to talk to "Hanako Sato," they enter the name and press the "Generate Topic" button. The device sends a POST request to the server's / api / generate_topics endpoint containing a JSON request with a list of participants' names. The server receives this request and extracts the list of participants' names from the JSON. Next, the server uses natural language processing technology to call a generative AI model (e.g., GPT-3®) to generate a conversation topic. This API call generates a conversation topic based on the participants' attribute information. The generated conversation topic is saved to a database by the server and then sent back to the device. Users can view the received conversation topic through the app and easily start a conversation.

[0263] Hardware and software to be used

[0264] Hardware:

[0265] Smartphone: Provides a user interface and is used for inputting and displaying information.

[0266] Server: Used for receiving and processing requests, managing data, and calling generated AI models.

[0267] software:

[0268] Flask: A server-side web framework used for defining endpoints and processing requests.

[0269] SQLite: Used as a database management system to store user information and generated conversation topics.

[0270] OpenAI® API: Used for generating conversation topics using natural language processing technology.

[0271] Examples of specific cases and prompt statements

[0272] For example, suppose user A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, if user A wants to talk to another employee, they press the profile generation button to send a request. The server retrieves information about the other employee from the database and sends it back to user A. Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate common topics with "Hanako Sato." As a result, topics such as "Recent topics related to cooking and travel" are returned to user A.

[0273] Example of a prompt:

[0274] Please generate conversation topics about the following people: Taro Yamada, Hanako Sato

[0275] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0276] Step 1:

[0277] The user opens the smartphone app and enters their personal information (name, department, hobbies, etc.). The entered information is converted to JSON format on the device and sent as a POST request to the server's / api / register_user endpoint. In this process, the input is the user's information, and the output is data in JSON format.

[0278] Step 2:

[0279] The server receives the aforementioned request. It extracts name, department, and hobby information from the received data and connects to the database. It executes an SQL query to save the extracted information to the Users table. The input to this process is user information in JSON format, and the output is the user information stored in the database.

[0280] Step 3:

[0281] To retrieve information about other users, the user presses the "Generate Profile" button within the smartphone app. This causes the device to POST a JSON-formatted request containing the user ID to the server's / api / generate_profile endpoint. The input is the user ID, and the output is the corresponding JSON-formatted request.

[0282] Step 4:

[0283] The server receives the request and extracts the user ID. Next, the server connects to the database and executes a query to retrieve all other user information from the Users table. The retrieved user information is processed into a list format in a JSON response and sent back to the terminal. The input to this process is a request containing the user ID, and the output is a JSON response containing the retrieved other user information.

[0284] Step 5:

[0285] To generate a common topic for the user to talk to other users within the app, request the generation of conversation topics. The user presses the "Topic Generation" button to enter a list of participant names, and the terminal POSTs a JSON-formatted request containing this list to the / api / generate_topics endpoint of the server. The input is a list of participant names, and the output is a JSON-formatted request sent to the server.

[0286] Step 6:

[0287] The server receives the request and extracts the list of participant names from the JSON format. Next, the server calls a generation AI model (e.g., GPT-3) using natural language processing technology and generates conversation topics using a prompt sentence. The input in this process is a prompt sentence containing the list of participant names, and the output is the generated conversation topics.

[0288] [[ID=1十七]] Step 7:

[0289] The server saves the generated conversation topics in the database. The saved conversation topics are processed back into JSON format and returned to the terminal. The user checks the conversation topics generated through the smartphone app. The input of this process is the generated conversation topics, and the output is the conversation topics returned to the terminal as a JSON-formatted response.

[0290] Furthermore, an emotion engine for estimating the user's emotion may be combined. That is, the specific processing unit 290 may estimate the user's emotion using the emotion identification model 59 and perform specific processing using the user's emotion.

[0291] This invention is a system in which a user inputs their own information, retrieves information from other users, generates conversation topics, and further recognizes the user's emotions using an emotion engine, adjusting responses accordingly. This system involves registering user information, retrieving profiles of other users, generating conversation topics using natural language processing technology, and performing emotion recognition using an emotion engine.

[0292] 1. User information registration

[0293] The server provides an interface for the user to enter their information (name, department, hobbies, etc.). When the terminal enters this information and presses the "Register" button, the terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[0294] The server receives this request and extracts the name, department, and hobby information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. After saving, the server notifies the terminal that the user registration was successful.

[0295] 2. Obtaining other users' information

[0296] A user sends a request from their device to retrieve information about other users. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device uses JSON format for this request.

[0297] The server receives this request and extracts the user ID from the JSON format. The server connects to the database and executes a query to retrieve all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the terminal as a JSON response. This allows the user to retrieve the profile information of other employees.

[0298] 3. Generating conversation topics

[0299] To generate a conversation topic, the user enters the names of other employees and presses the "Generate Topic" button. The terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint.

[0300] The server receives this request and extracts a list of participant names from the JSON format. Next, the server uses natural language processing techniques to call an external natural language processing API to generate a conversation topic based on the specified participants. This API call generates a conversation topic based on the participants' attribute information.

[0301] The generated conversation topics are saved by the server to the Conversations table in the database and then sent back to the terminal. The terminal displays the received conversation topics to the user, allowing the user to easily start a conversation.

[0302] 4. Combination of emotional engines

[0303] The present invention further incorporates an emotion engine to recognize the user's emotions. The server receives text and voice data entered by the user and transmits this data to the emotion recognition engine. The server receives a response from the emotion recognition engine and analyzes the user's emotions.

[0304] Based on the analyzed emotions, the server adjusts its responses to the user and the conversation topics. For example, if the emotion engine detects that the user is stressed, the server can suggest topics related to relaxation.

[0305] Specific example

[0306] For example, suppose user A inputs information such as "Yamada Taro", "Sales Department", and "Reading", and then presses the registration button. This information is sent to the server and saved in the database. Next, when user A wants to talk to other employees and presses the profile generation button to send a request, the server retrieves the information of other employees from the database and returns it to user A.

[0307] Furthermore, when user A wants to talk to "Satou Hanako", they input that name and press the topic generation button. The server receives this information and uses the GPT API to generate common topics with "Satou Hanako". As a result, for example, topics such as "Topics about recently read books" are returned to user A.

[0308] Also, if the sentiment engine recognizes from the text input by user A that user A is relaxed, the server proposes more in-depth conversation topics based on this.

[0309] In this way, the present invention promotes communication between employees in different departments, not only making meetings and lunchtimes meaningful, but also providing a more personalized experience through the emotion recognition function.

[0310] The following explains the processing flow.

[0311] Understood. The following specifically explains the processing flow of the invention combined with the sentiment engine step by step.

[0312] 1. Registration of user information

[0313] Step 1:

[0314] The user inputs their own information (name, department, hobby) into the input form and presses the "Register" button.

[0315] Step 2:

[0316] The terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[0317] Step 3:

[0318] The server receives the request and extracts information such as name, department, and hobbies from the JSON format.

[0319] Step 4:

[0320] The server connects to the database and saves the extracted user information to the Users table.

[0321] Step 5:

[0322] The server sends a message to the terminal in JSON format confirming that the user registration was successful.

[0323] Step 6:

[0324] The terminal receives a response from the server and displays a registration completion message to the user.

[0325] 2. Obtaining other users' information

[0326] Step 1:

[0327] The user presses the "Generate Profile" or "View Other Employees" button, specifies their user ID, and sends a request from their device.

[0328] Step 2:

[0329] The device sends a request in JSON format containing the user ID as a POST request to the server's / api / generate_profile endpoint.

[0330] Step 3:

[0331] The server receives the request and extracts the user ID from the JSON format.

[0332] Step 4:

[0333] The server connects to the database and executes a query to retrieve all other user information from the Users table.

[0334] Step 5:

[0335] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response.

[0336] Step 6:

[0337] The terminal receives a response from the server and displays other users' information on the screen.

[0338] 3. Generating conversation topics

[0339] Step 1:

[0340] The user enters the name of another employee and presses the "Generate Topic" button.

[0341] Step 2:

[0342] The device sends a JSON-formatted request containing a list of participant names as a POST request to the server's / api / generate_topics endpoint.

[0343] Step 3:

[0344] The server receives the request and extracts a list of participant names from the JSON format.

[0345] Step 4:

[0346] The server uses natural language processing technology to call an external natural language processing API and generate conversation topics based on the specified participants.

[0347] Step 5:

[0348] The server saves the generated conversation topics to the Conversations table in the database.

[0349] Step 6:

[0350] The server returns the generated conversation topic to the terminal in JSON format.

[0351] Step 7:

[0352] The terminal receives a response from the server and displays the generated conversation topic to the user.

[0353] 4. Emotion recognition by an emotion engine

[0354] Step 1:

[0355] The user enters their information via text or voice.

[0356] Step 2:

[0357] The device sends the entered text or voice data to the server.

[0358] Step 3:

[0359] The server sends the received data to the emotion engine for emotion recognition.

[0360] Step 4:

[0361] The emotion engine analyzes the user's emotions from the input data and sends the analysis results back to the server.

[0362] Step 5:

[0363] The server adjusts its responses to the user and conversation topics based on the sentiment information it receives from the sentiment engine.

[0364] Step 6:

[0365] For example, if the server detects that a user is feeling stressed, it will suggest topics related to relaxation.

[0366] Step 7:

[0367] The server returns the adjusted response and conversation topic to the terminal in JSON format.

[0368] Step 8:

[0369] The terminal receives a response from the server and displays appropriate information to the user.

[0370] This processing flow allows users to easily input their own information, retrieve information about other employees, and find common topics of conversation. Furthermore, by utilizing the emotion engine, personalized responses and conversation topics are provided that are tailored to the user's emotions, making communication even smoother.

[0371] (Example 2)

[0372] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the smart device 14 as the "terminal".

[0373] Traditional communication support systems lacked the functionality to efficiently retrieve information about other users and generate appropriate conversation topics. Furthermore, they struggled to provide personalized conversation topics that took users' emotions into account. As a result, communication between employees in different departments was not smooth, leading to a decline in the quality of communication within the company.

[0374] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for the user to input their own information, means for the user to send a request to obtain information of other users, means for generating conversation topics using natural language processing technology, means for analyzing the user's emotions using an emotion recognition engine, and means for adjusting conversation topics and responses based on the analyzed emotions. As a result, the user can efficiently obtain information of other users, generate appropriate conversation topics, and further enable personalized communication that takes emotions into consideration.

[0375] A "user" refers to an individual who uses a system to input or retrieve information.

[0376] A "server" refers to a computer system that receives requests from users, processes the data, and sends it back.

[0377] A "database" refers to a system that systematically stores and manages data such as user information and generated conversation topics.

[0378] A "request" refers to a request made by a user to a server for the retrieval or processing of information.

[0379] "Natural language processing technology" refers to algorithms and models that enable computers to understand and generate human language.

[0380] An "external API" refers to a programmatic interface used to retrieve and manipulate data in conjunction with other systems and services.

[0381] An "emotion recognition engine" refers to software that analyzes and recognizes emotions from user input data.

[0382] A "conversation topic" refers to a topic generated by the system to facilitate communication between users.

[0383] "Attribute information" refers to information specific to a user, such as their name, department, and hobbies.

[0384] "Analysis results" refer to the data obtained as a result of the emotion recognition engine analyzing the user's emotions.

[0385] "Response" refers to the reply from the server to the user, and specifically includes notifications of generated conversation topics and information.

[0386] The present invention is a system that supports communication between users via a communication network, and provides user information registration, acquisition of information on other users, generation of conversation topics, sentiment analysis by an sentiment recognition engine, and personalized responses. Specific embodiments of the present invention are described below.

[0387] 1. User information registration

[0388] The server provides an interface on a web browser or mobile application for users to enter their personal information (name, department, hobbies, etc.). When a user enters this information using a device (PC, smartphone, tablet, etc.) and presses the "Register" button, the device converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint. The server receives this request, parses the JSON data, and extracts the name, department, and hobbies information. This information is stored in a database (e.g., MySQL® or PostgreSQL) and the server notifies the user that registration was successful.

[0389] 2. Obtaining other users' information

[0390] To retrieve information about other users, a user sends a request from their device to the server. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. This request is in JSON format. The server receives the request and extracts the user ID from the JSON data. The server then connects to the database, retrieves all other user information from the Users table, processes it into a list format, and sends it back to the device as a JSON response. For example, if user A wants to retrieve information about other employees, the retrieved information will include the names and departments of employees B and C.

[0391] 3. Generating conversation topics

[0392] Users can generate conversation topics by entering the names of conversation participants into their device and pressing the "Generate Topic" button. The device sends a POST request to the server's / api / generate_topics endpoint containing a JSON request with a list of participant names. The server receives the request and extracts the list of participant names from the JSON data. Next, the server uses natural language processing techniques to call an external API (e.g., OpenAI's GPT-3) to generate conversation topics based on the specified participants. The generated topics are stored in a database by the server and then sent back to the device for display to the user. For example, if the name "Hanako Sato" is entered, relevant conversation topics such as "Recently Read Books" and "Recommended Travel Destinations" will be generated.

[0393] 4. Combination of emotional engines

[0394] The present invention further utilizes an emotion recognition engine to recognize the user's emotions and provide personalized responses based on them. When the user inputs text or voice data into a terminal, the terminal sends it to a server. The server sends this data to an emotion recognition engine (e.g., IBM Watson® Tone Analyzer) to analyze the user's emotions. Based on the analyzed emotion information, the server adjusts the conversation topics and responses. For example, if the user inputs "I'm a little tired," topics and advice related to relaxation will be suggested.

[0395] Examples of prompt statements

[0396] The following are specific examples of prompt statements to be input to a generative AI model:

[0397] Please register your user information. This information should include your name, department, and hobbies. For example, please use the following format:

[0398] Name: Taro Yamada

[0399] [Sales Department]

[0400] Hobbies: Reading

[0401] Please use the information above to create and register your profile.

[0402] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0403] User information registration

[0404] Step 1:

[0405] The user enters their name, department, and hobbies into a registration form on a browser or application using their device. Specifically, the user enters "Taro Yamada," "Sales Department," and "Reading" into a text box and then presses the register button.

[0406] Step 2:

[0407] The terminal converts the entered information into JSON format. Input includes the user's name, department, and hobbies (e.g., "Taro Yamada", "Sales Department", "Reading"), and the output generates JSON data like the following:

[0408] json

[0409] {

[0410] "name": "Yamada Taro",

[0411] "department": "Sales Department",

[0412] "hobby": "reading"

[0413] }

[0414] Step 3:

[0415] The device sends the generated JSON data as a POST request to the server's / api / register_user endpoint. Specifically, the device's HTTP client sends the request.

[0416] Step 4:

[0417] The server receives a POST request and extracts user information from the JSON data. The input is data in JSON format, and the output is the user's name, department, and hobbies, which are stored in a table.

[0418] Step 5:

[0419] The server connects to the database and saves user information to the Users table. Specifically, it executes SQL queries to insert the data.

[0420] Step 6:

[0421] The server notifies the terminal that user information registration was successful. The output includes a "Registration successful" message, which the terminal displays to the user.

[0422] Retrieving other user information

[0423] Step 1:

[0424] The user presses the "Generate Profile" button on their device. This action specifically involves the user clicking the button.

[0425] Step 2:

[0426] The terminal generates a JSON request containing the user ID and sends it as a POST request to the server's / api / generate_profile endpoint. The input includes the user ID (e.g., "12345"), and the output generates JSON data similar to the following:

[0427] json

[0428] {

[0429] "user_id": "12345"

[0430] }

[0431] Step 3:

[0432] The server receives a POST request and extracts the user ID from the JSON data. The input is JSON data, and the output is the user ID.

[0433] Step 4:

[0434] The server connects to the database and executes a query to retrieve all other user information from the Users table. Specifically, it executes a SELECT statement to retrieve the data.

[0435] Step 5:

[0436] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response. The output will be JSON data like the following:

[0437] json

[0438] [

[0439] {

[0440] "name": "Hanako Sato",

[0441] "department": "Development Department",

[0442] "hobby": "cooking"

[0443] },

[0444] {

[0445] "name": "Ichiro Suzuki",

[0446] "department": "Sales Department",

[0447] "hobby": "golf"

[0448] }

[0449] ]

[0450] Step 6:

[0451] The terminal receives a response from the server and displays user information in list format. Specifically, it displays the data on the user interface.

[0452] Generating conversation topics

[0453] Step 1:

[0454] The user enters the names of the conversation participants into their device and presses the "Generate Topic" button. Specifically, this involves typing "Hanako Sato" into the text box and clicking the button.

[0455] Step 2:

[0456] The terminal generates a JSON request containing a list of participant names and sends it as a POST request to the server's / api / generate_topics endpoint. The input includes participant names (e.g., "Hanako Sato"), and the output generates JSON data similar to the following:

[0457] json

[0458] {

[0459] "participants": ["Hanako Sato"]

[0460] }

[0461] Step 3:

[0462] The server receives a POST request and extracts a list of participant names from the JSON data. The input is data in JSON format, and the output is a list of participant names.

[0463] Step 4:

[0464] The server uses natural language processing techniques to call an external API (e.g., OpenAI's GPT-3) and generates a conversation topic based on the specified participants. Specifically, this involves making an API call and receiving the generated topic.

[0465] Step 5:

[0466] The server saves the generated conversation topic to the database and sends it back to the terminal. The output will be JSON data like the following:

[0467] json

[0468] {

[0469] "Topics": ["Recently read books", "Recommended travel destinations"]

[0470] }

[0471] Step 6:

[0472] The terminal receives a response from the server and displays the generated conversation topic to the user. Specifically, it displays the topic in the user interface.

[0473] Combination of emotional engines

[0474] Step 1:

[0475] The user inputs text or voice data into the device. Specifically, this might involve typing text such as "I'm a little tired" or using voice input.

[0476] Step 2:

[0477] The device sends input data to the server's / api / analyze_emotion endpoint. Input can include text or audio data, and output is data sent to the server.

[0478] Step 3:

[0479] The server sends data to the emotion recognition engine, which analyzes the user's emotions. Specifically, it calls an emotion recognition API (e.g., IBM Watson's Tone Analyzer) to receive the analysis results.

[0480] Step 4:

[0481] The server adjusts the conversation topics and responses based on the analysis results. The output includes topics and advice related to relaxation, resulting in JSON data like this:

[0482] json

[0483] {

[0484] "adjusted_topics": ["My most relaxing place", "About my recent hobbies"]

[0485] }

[0486] Step 5:

[0487] The terminal receives a response from the server and displays it to the user. Specifically, it displays topics and advice tailored to the user interface.

[0488] (Application Example 2)

[0489] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart device 14 will be referred to as the "terminal."

[0490] Existing systems lack the functionality to facilitate smooth communication between users, and in particular, face-to-face customer service, they have difficulty appropriately recognizing user emotions and suggesting conversation topics based on those emotions. Furthermore, two-way communication that is attentive to user emotions is essential for improving customer satisfaction and achieving efficient service. Especially in customer service at physical stores, it is necessary for customer service staff to instantly grasp the emotional state of customers and respond appropriately accordingly.

[0491] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the server to utilize natural language processing technology to generate a conversation topic, means for storing the generated conversation topic and returning it to the user, means for analyzing the user's emotions using an emotion recognition engine, and means for adjusting conversation topics and responses based on the emotion analysis results and providing them to the user. This makes it possible to provide appropriate conversation topics based on the user's emotional state and realize more personalized communication.

[0492] "User information" refers to information about a user's personal attributes, such as their name, department, and hobbies, that they have registered about themselves.

[0493] A "server" is a computing system that receives information from users via a network, stores it in a database, and processes the information in cooperation with other services.

[0494] A "database" is a system for efficiently managing, storing, and retrieving data such as user information and conversation topics.

[0495] A "request" is a communication message in which a user asks a server to retrieve or process information.

[0496] "Natural language processing technology" refers to a set of techniques that enable computers to understand and generate human language, utilizing machine learning and data analysis.

[0497] A "conversation topic" is a topic generated to facilitate communication between users.

[0498] An "emotion recognition engine" is software or hardware that analyzes emotions from user input text or voice and recognizes that emotional state.

[0499] "Emotional analysis results" refer to data indicating the user's emotional state, obtained by the emotion recognition engine.

[0500] A "response" is a message that a server provides in response to a user's request, and it includes the conversation topic and other information.

[0501] "Personalized communication" refers to communication delivered in a format optimized for a specific user, based on their individual emotions and attribute information.

[0502] Modes for carrying out the invention

[0503] This invention relates to a system in which a user inputs their own information, a server receives that information, stores it in a database, retrieves information from other users, recognizes the user's emotions, and generates conversation topics based on that. The system has the following main functions: user information registration, retrieval of other users' information, generation of conversation topics, and use of an emotion recognition engine.

[0504] The server first provides an interface for users to enter their information. When a user enters information such as their name, department, and hobbies on their terminal and presses the registration button, the information is converted to JSON format and sent as a POST request to the server endpoint. The server receives the request, extracts the necessary information from the JSON format, and saves it to the "Users" table in the database. If the save is successful, the server sends a registration success message to the user.

[0505] Next, the user sends a request to retrieve information about other users. Specifically, when the user specifies their own ID and sends a request to the server, the server retrieves all other user information from the database, processes it into a list format, and sends it back to the user. This allows the user to easily obtain the profile information of other users.

[0506] Next, when a user creates a conversation topic, they enter the names of other users they wish to talk to, designating them as participants. Based on the specified participants, the server generates a conversation topic using natural language processing techniques. The generated conversation topic is stored in a database and returned to the user. This natural language processing technique can utilize external natural language processing APIs.

[0507] Furthermore, the present invention integrates an emotion recognition engine to analyze emotions from user input text and voice data. The server receives this data and transmits it to the emotion recognition engine. Upon receiving a response from the emotion recognition engine, the server adjusts its response to the user and conversation topics based on the analyzed emotions. For example, if the user is feeling stressed, topics related to relaxation can be suggested.

[0508] As a concrete example, if user A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the registration button, this information is sent to the server and stored in the database. Next, if user A wants to talk to another employee and presses the profile generation button to send a request, the server retrieves information about the other employee from the database and sends it back to user A. Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses a natural language processing API to generate a common topic with "Hanako Sato." As a result, a topic such as "A book you've recently read" is returned to user A. Also, if the sentiment engine recognizes from the text entered by user A that user A is relaxed, the server will suggest a more in-depth conversation topic based on that.

[0509] An example of a prompt to input into the generating AI model could be: "Generate a sample dialogue for a customer service application in a store within a shopping mall."

[0510] In this way, the present invention facilitates communication between employees in different departments and can also be applied to customer service in physical stores. The emotion recognition function provides an even more personalized experience.

[0511] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[0512] Step 1:

[0513] It provides an interface for users to enter their own information. Users enter information such as their name, department, and hobbies, and then press the register button. The entered information is sent from the terminal to the server as a POST request in JSON format.

[0514] Input: User information such as name, department, and hobbies.

[0515] Output: POST request in JSON format

[0516] Step 2:

[0517] The server receives the input information from the user. The server extracts the necessary information (name, department, hobbies, etc.) from the received JSON data and saves it to the "Users" table in the database. If the saving is successful, the server sends a registration success message to the user in JSON format.

[0518] Input: User information in JSON format

[0519] Output: Successful message for saving to database and registration.

[0520] Step 3:

[0521] The user presses a button to send a request to retrieve information about another user. The user specifies their own ID and sends the request. The terminal sends a POST request in JSON format containing this information to the server endpoint.

[0522] Input: Your User ID

[0523] Output: POST request in JSON format

[0524] Step 4:

[0525] The server receives the aforementioned request. The server retrieves all other user information from the database and processes it into a list format. Then, it sends the retrieved user information back to the user as a JSON response.

[0526] Input: Request in JSON format, User ID

[0527] Output: List of other user information, response in JSON format

[0528] Step 5:

[0529] The user interacts with the interface for generating conversation topics. They enter the names of other users who will be participating in the conversation and designate them as participants. The terminal sends a POST request in JSON format containing the list of participant names to the server endpoint.

[0530] Input: List of participant names

[0531] Output: POST request in JSON format

[0532] Step 6:

[0533] The server receives the aforementioned request. The server calls an external API to generate a conversation topic using natural language processing technology. This API call generates a conversation topic based on the specified participants. The generated conversation topic is stored in the "Conversations" table in the database and returned to the user as a JSON response.

[0534] Input: Participant information in JSON format

[0535] Output: Save to database, JSON response of the generated conversation topic

[0536] Step 7:

[0537] The system performs emotion recognition using user-input text or audio data. The device sends the input text or audio data to the server as a POST request in JSON format.

[0538] Input: Text or audio data

[0539] Output: POST request in JSON format

[0540] Step 8:

[0541] The server receives the text and audio data. The server sends the data to the emotion recognition engine and receives the analysis results. Based on the emotion recognition results, the server adjusts the conversation topics and responses to be appropriate and provides them to the user.

[0542] Input: Text or audio data in JSON format

[0543] Output: Emotion recognition results, adjusted response

[0544] In this way, each step of the present invention realizes a series of processes from user information registration to emotion recognition, and then generating and providing an appropriate response.

[0545] 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 user input for the result of the specific processing. The control unit 46A transmits the audio data indicating 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.

[0546] Data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of data generation model 58 is ChatGPT (registered trademark) (Internet search).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0547] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart device 14.

[0548] [Second Embodiment]

[0549] Figure 3 shows an example of the configuration of the data processing system 210 according to the second embodiment.

[0550] As shown in Figure 3, the data processing system 210 includes a data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0551] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[0553] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

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

[0555] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[0556] Figure 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Figure 4, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[0557] The specific processing program 56 is an example of a "program" relating to the technology of this 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.

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

[0559] In the smart glasses 214, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[0560] Next, the identification processing performed by the identification processing unit 290 of the data processing device 12 will be described. 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".

[0561] This invention is a system in which a user inputs their own information, retrieves information from other users, and generates conversation topics. This system performs user information registration, retrieves other users' profiles, and generates conversation topics using natural language processing technology.

[0562] 1. User information registration

[0563] The server provides an interface for the user to enter their information (name, department, hobbies, etc.). When the terminal enters this information and presses the "Register" button, the terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[0564] The server receives this request and extracts the name, department, and hobby information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. After saving, the server notifies the terminal that the user registration was successful.

[0565] 2. Obtaining other users' information

[0566] A user sends a request from their device to retrieve information about other users. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device uses JSON format for this request.

[0567] The server receives this request and extracts the user ID from the JSON format. The server connects to the database and executes a query to retrieve all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the terminal as a JSON response. This allows the user to retrieve the profile information of other employees.

[0568] 3. Generating conversation topics

[0569] To generate a conversation topic, the user enters the names of other employees and presses the "Generate Topic" button. The terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint.

[0570] The server receives this request and extracts a list of participant names from the JSON format. Next, the server uses natural language processing techniques to call the GPT API to generate a conversation topic. This API call generates a conversation topic based on the participant attribute information.

[0571] The generated conversation topics are stored in a database by the server and then sent back to the terminal. The terminal displays the received conversation topics to the user, allowing the user to easily start a conversation.

[0572] Specific example

[0573] For example, suppose User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, User A wants to talk to other employees and presses the profile generation button to send a request. The server retrieves information about other employees from the database and sends it back to User A.

[0574] Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to user A.

[0575] In this way, the present invention promotes communication among employees from different departments and makes meetings and lunch breaks more meaningful.

[0576] The following describes the processing flow.

[0577] Understood. Below, I will explain the program's processing in detail, step by step.

[0578] 1. User information registration

[0579] Step 1:

[0580] The user enters their information (name, department, hobbies) into the input form and presses the "Register" button.

[0581] Step 2:

[0582] The terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[0583] Step 3:

[0584] The server receives the request and extracts information such as name, department, and hobbies from the JSON format.

[0585] Step 4:

[0586] The server connects to the database and saves the extracted user information to the Users table.

[0587] Step 5:

[0588] The server sends a message to the terminal in JSON format confirming that the user registration was successful.

[0589] Step 6:

[0590] The terminal receives a response from the server and displays a registration completion message to the user.

[0591] 2. Obtaining other users' information

[0592] Step 1:

[0593] The user presses the "Generate Profile" or "View Other Employees" button, specifies their user ID, and sends a request from their device.

[0594] Step 2:

[0595] The device sends a request in JSON format containing the user ID as a POST request to the server's / api / generate_profile endpoint.

[0596] Step 3:

[0597] The server receives the request and extracts the user ID from the JSON format.

[0598] Step 4:

[0599] The server connects to the database and executes a query to retrieve all other user information from the Users table.

[0600] Step 5:

[0601] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response.

[0602] Step 6:

[0603] The terminal receives a response from the server and displays other users' information on the screen.

[0604] 3. Generating conversation topics

[0605] Step 1:

[0606] The user enters the name of another employee and presses the "Generate Topic" button.

[0607] Step 2:

[0608] The device sends a JSON-formatted request containing a list of participant names as a POST request to the server's / api / generate_topics endpoint.

[0609] Step 3:

[0610] The server receives the request and extracts a list of participant names from the JSON format.

[0611] Step 4:

[0612] The server uses natural language processing technology to call an external natural language processing API and generate conversation topics based on the specified participants.

[0613] Step 5:

[0614] The server saves the generated conversation topics to the Conversations table in the database.

[0615] Step 6:

[0616] The server returns the generated conversation topic to the terminal in JSON format.

[0617] Step 7:

[0618] The terminal receives a response from the server and displays the generated conversation topic to the user.

[0619] This processing flow allows users to easily input their own information, retrieve information about other employees, and find common topics of conversation. This system is a concrete implementation aimed at promoting communication between employees from different departments and making meetings and lunch breaks more productive.

[0620] (Example 1)

[0621] Next, we will describe Example 1. 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."

[0622] In conventional communication support systems, it has been difficult for employees from different departments to efficiently share information and find common conversation topics. This has reduced opportunities to build new relationships and hindered information sharing and the establishment of collaborative relationships within companies. The present invention aims to solve these problems and provide a system that facilitates communication within companies.

[0623] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[0624] In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the user to input the names of other users and send a request to generate a conversation topic, means for the server to utilize natural language processing technology to generate a conversation topic, means for storing the generated conversation topic and returning it to the user, and means for a terminal to display the generated conversation topic. This makes it possible for employees from different departments to efficiently find common conversation topics and communicate smoothly with each other.

[0625] A "user" refers to an end-user who inputs their own information into the system, retrieves information from other users, and generates conversation topics.

[0626] A "server" refers to a central computer system that receives information from users, stores it in a database, processes the data in response to requests, and generates and sends back conversation topics.

[0627] A "terminal" refers to a computer device (such as a PC or smartphone) that a user uses to input information, send requests, and receive responses.

[0628] A "database" refers to a data storage system used to store user information and generated conversation topics.

[0629] A "request" refers to a communication message from a user or device that requests information from a server for processing or acquisition.

[0630] "API" stands for Application Programming Interface, and refers to a set of protocols and tools for accessing external services and databases.

[0631] "Natural language processing technology" refers to all technologies used to understand and process human language using computers, including technologies such as text generation and topic extraction.

[0632] A "conversation topic" refers to a subject or theme that helps users to start a conversation smoothly with each other.

[0633] "Attribute information" refers to basic information about the user (such as name, department, and hobbies).

[0634] "Generation" refers to the process by which a system creates new data or information.

[0635] This invention is a system in which a user inputs their own information, retrieves information from other users, and generates conversation topics. This system performs user information registration, retrieves other users' profiles, and generates conversation topics using natural language processing technology. Specifically, it is implemented as follows:

[0636] Hardware and software used

[0637] The server functions as a central processing unit, handling all data processing and information storage / retrieval described later. The server is equipped with a database (selectable between SQL and NoSQL databases) and APIs for implementing natural language processing technologies (e.g., the GPT API).

[0638] The device is the interface with the user and is designed as a web application or mobile application.

[0639] The user operates the terminal to input and retrieve information and sends a conversation topic generation request.

[0640] User information registration

[0641] The server provides an interface for users to enter their information (e.g., name, department, hobbies, etc.). The user enters the information into a form on the terminal and presses the "Register" button. The terminal converts this information into JSON format and sends a POST request to the server's / api / register_user endpoint. The server receives this request and extracts the name, department, and hobbies from the received data. The server then connects to the database and saves this information to the Users table. Once the saving is complete, the server sends a message back to the terminal indicating successful registration.

[0642] Retrieving other user information

[0643] When a user wants to retrieve information about other users, they send a request from their device. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device structures this request in JSON format. The server receives the request and extracts the user ID. The server connects to the database and retrieves all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the device as a JSON response. This allows the user to retrieve the profile information of other employees.

[0644] Generating conversation topics

[0645] The user generates a conversation topic to find common ground for talking with other employees. When the user enters the names of other employees and presses the "Generate Topic" button, the terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint. The server receives this request and extracts the list of participants' names. The server then uses natural language processing techniques (e.g., the GPT API) to generate a conversation topic. This API call generates a conversation topic based on the participants' attribute information. The generated conversation topic is saved to a database by the server and then sent back to the terminal. The terminal displays this information to the user.

[0646] Specific example

[0647] For example, User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, if User A wants to talk to another employee, they press the profile generation button to send a request. The server retrieves information about the other employee from the database and sends it back to User A. Furthermore, if User A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to User A. In this way, communication between employees from different departments is facilitated, making meetings and lunch breaks more meaningful.

[0648] Example of a prompt

[0649] The following are examples of prompts to input into a generative AI model to generate conversation topics:

[0650] User Information: Name: Taro Yamada, Department: Sales Department, Hobbies: Reading

[0651] Contact information: Name: Hanako Sato, Department: Planning Department, Hobby: Calligraphy

[0652] Please create a topic that will be a common subject of discussion among these users.

[0653] The flow of the specific processing in Example 1 will be explained using Figure 11.

[0654] User information registration

[0655] Step 1:

[0656] Summary: The user enters their own information.

[0657] Specific actions:

[0658] The user enters their "name," "department," and "hobbies" into the input form on their device.

[0659] Input: Information entered by the user in the input form (e.g., Name = Taro Yamada, Department = Sales Department, Hobby = Reading)

[0660] Output: User information displayed in the input form

[0661] Step 2:

[0662] Summary: The terminal converts the input information into JSON format and sends it to the server.

[0663] Specific actions:

[0664] The user presses the "Register" button. The device creates JSON data like the following and sends a POST request to the server's / api / register_user endpoint.

[0665] json

[0666] {

[0667] "Name": "Yamada Taro",

[0668] " [": "Sales Department"

[0669] "Hobbies": "Reading"

[0670] }

[0671] Input: User presses the "Register" button.

[0672] Output: Request data in JSON format

[0673] Step 3:

[0674] Summary: The server processes the received JSON data and saves the information to the database.

[0675] Specific actions:

[0676] The server receives the POST request and extracts the name, department, and hobbies from the JSON data. Using the extracted data, it executes the following SQL query on the database.

[0677] SQL

[0678] INSERT INTO Users (Name, Department, Hobby) VALUES ('Taro Yamada', 'Sales Department', 'Reading');

[0679] Input: User information in JSON format

[0680] Output: User information stored in the database

[0681] Step 4:

[0682] Summary: The server notifies the terminal that the information registration was successful.

[0683] Specific actions:

[0684] The server sends the following JSON response back to the terminal.

[0685] json

[0686] {

[0687] "status": "success",

[0688] "message": "User information has been registered."

[0689] }

[0690] Input: The result of the information being correctly saved in the database.

[0691] Output: JSON response of success message

[0692] Retrieving other user information

[0693] Step 1:

[0694] Summary: A user sends a request from their device to retrieve information about other users.

[0695] Specific actions:

[0696] The user clicks the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint.

[0697] json

[0698] {

[0699] "user_id": "1"

[0700] }

[0701] Input: User clicks the "Generate Profile" button and enters the user ID.

[0702] Output: Request data in JSON format

[0703] Step 2:

[0704] Summary: The server receives a request and retrieves other user information based on the user ID.

[0705] Specific actions:

[0706] The server receives the POST request and extracts the user ID from the JSON data. The server then executes the following SQL query on the database.

[0707] SQL

[0708] SELECT FROM Users WHERE user_id != '1';

[0709] Input: Request data in JSON format and User ID

[0710] Output: Other user information retrieved from the database

[0711] Step 3:

[0712] Summary: The server processes the acquired user information into a list format and sends it back to the terminal.

[0713] Specific actions:

[0714] The server converts the user information it has retrieved into response data in JSON format.

[0715] json

[0716] [

[0717] {

[0718] "Name": "Hanako Sato",

[0719] "Department": "Planning Department",

[0720] "Hobbies": "Calligraphy"

[0721] },

[0722] / / Other user information

[0723] ]

[0724] Input: User information retrieved from the database

[0725] Output: Response data in JSON format

[0726] Generating conversation topics

[0727] Step 1:

[0728] Summary: The user sends a request from their device to generate a conversation topic.

[0729] Specific actions:

[0730] The user enters the names of other employees to generate a conversation topic and presses the "Generate Topic" button. The terminal sends JSON data like the following as a POST request to the server's / api / generate_topics endpoint.

[0731] json

[0732] {

[0733] "Participants": ["Taro Yamada", "Hanako Sato"]

[0734] }

[0735] Input: User presses the "Generate Topic" button and enters a list of participant names.

[0736] Output: Request data in JSON format

[0737] Step 2:

[0738] Summary: The server receives the request and generates a conversation topic from the participants' names.

[0739] Specific actions:

[0740] The server receives the POST request and extracts a list of participant names from the JSON data. The server then sends the generated prompt to the GPT API.

[0741] User Information: Name: Taro Yamada, Department: Sales Department, Hobbies: Reading

[0742] Contact information: Name: Hanako Sato, Department: Planning Department, Hobby: Calligraphy

[0743] Please create a topic that will be a common subject of discussion among these users.

[0744] Input: Request data in JSON format and a list of participant names.

[0745] Output: Prompt message to the GPT API

[0746] Step 3:

[0747] Summary: The server receives the generated conversation topic and saves it to the database.

[0748] Specific actions:

[0749] The server receives a conversation topic generated from the GPT API and saves it to the database by executing an SQL query like the following:

[0750] SQL

[0751] INSERT INTO Topics (topic) VALUES ('About a book I recently read');

[0752] Input: Conversation topic generated from the GPT API

[0753] Output: Conversation topics stored in the database

[0754] Step 4:

[0755] Summary: The server sends the generated conversation topic back to the terminal and displays it to the user.

[0756] Specific actions:

[0757] The server sends the following JSON response back to the terminal.

[0758] json

[0759] {

[0760] "topics": ["About books I've recently read"]

[0761] }

[0762] The device displays the conversation topics it has received on the screen, allowing the user to review them.

[0763] Input: Conversation topics stored in the database

[0764] Output: Response data in JSON format and screen display

[0765] The above describes the specific processing steps, the inputs and outputs of each step, and the specific operations.

[0766] (Application Example 1)

[0767] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[0768] In modern brick-and-mortar stores, a lack of communication among employees and between employees and customers is a cause of decreased customer satisfaction and reduced operational efficiency. Finding common ground is particularly difficult for employees from different departments, and for staff and customers meeting for the first time, making smooth conversation challenging. Furthermore, manually gathering common topics and profile information is time-consuming, highlighting the need for automated systems.

[0769] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[0770] In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the server to use natural language processing technology and a generative AI model to generate conversation topics, and means for the server to store the generated conversation topics and return them to the user. This facilitates communication between employees and customers, enabling improvements in work efficiency and customer satisfaction.

[0771] A "user" is an individual who uses the system to input their own information and retrieve information and conversation topics from other users.

[0772] A "server" is a device or system that receives user input information, stores it in a database, retrieves and returns information from other users, and uses natural language processing technology to generate conversation topics.

[0773] A "database" is a digital storage system used to store and manage system-related information, such as user input and generated conversation topics.

[0774] A "request" is an instruction that a user sends to a server to ask the system to retrieve other users' information or to generate conversation topics.

[0775] Natural language processing (NLP) is a computer technology used to understand and generate human language. Its primary applications include text analysis, language modeling, and dialogue generation.

[0776] A "generative AI model" is an artificial intelligence model used to generate conversation topics based on user attribute information.

[0777] A "prompt sentence" is a text sentence that a generative AI model uses as input when generating conversation topics.

[0778] To implement this invention, it is necessary to build a system in which a user inputs their own information using a smartphone app, retrieves other users' profiles, and generates conversation topics. In this system, a server, a database, and a generative AI model using natural language processing technology play important roles. A specific example is shown below.

[0779] 1. User information registration

[0780] First, the user enters their information (name, department, hobbies, etc.) through the smartphone app interface. The entered information is converted to JSON format and sent from the device as a POST request to the server's / api / register_user endpoint. The server receives this request and extracts the information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. This registers the user information in the database.

[0781] 2. Obtaining other users' information

[0782] To retrieve information about other users, users send requests using a smartphone app. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. This request is also in JSON format. The server receives the request and extracts the user ID. The server connects to the database and executes a query to retrieve all other user information from the Users table. The retrieved user information is then processed into a list format and sent back to the device as a JSON response. This allows the user to retrieve the profile information of other employees.

[0783] 3. Generating conversation topics

[0784] Users request the generation of conversation topics to create common topics to talk about with other users within the app. For example, if a user wants to talk to "Hanako Sato," they enter the name and press the "Generate Topic" button. The device sends a POST request to the server's / api / generate_topics endpoint containing a JSON request with a list of participants' names. The server receives this request and extracts the list of participants' names from the JSON. Next, the server uses natural language processing techniques to call a generative AI model (e.g., GPT-3) to generate a conversation topic. This API call generates a conversation topic based on the participants' attribute information. The generated conversation topic is saved to a database by the server and then sent back to the device. Users can view the received conversation topic through the app and easily start a conversation.

[0785] Hardware and software to be used

[0786] Hardware:

[0787] Smartphone: Provides a user interface and is used for inputting and displaying information.

[0788] Server: Used for receiving and processing requests, managing data, and calling generated AI models.

[0789] software:

[0790] Flask: A server-side web framework used for defining endpoints and processing requests.

[0791] SQLite: Used as a database management system to store user information and generated conversation topics.

[0792] OpenAI API: Used for generating conversation topics using natural language processing technology.

[0793] Examples of specific cases and prompt statements

[0794] For example, suppose user A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, if user A wants to talk to another employee, they press the profile generation button to send a request. The server retrieves information about the other employee from the database and sends it back to user A. Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate common topics with "Hanako Sato." As a result, topics such as "Recent topics related to cooking and travel" are returned to user A.

[0795] Example of a prompt:

[0796] Please generate conversation topics about the following people: Taro Yamada, Hanako Sato

[0797] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[0798] Step 1:

[0799] The user opens the smartphone app and enters their personal information (name, department, hobbies, etc.). The entered information is converted to JSON format on the device and sent as a POST request to the server's / api / register_user endpoint. In this process, the input is the user's information, and the output is data in JSON format.

[0800] Step 2:

[0801] The server receives the aforementioned request. It extracts name, department, and hobby information from the received data and connects to the database. It executes an SQL query to save the extracted information to the Users table. The input to this process is user information in JSON format, and the output is the user information stored in the database.

[0802] Step 3:

[0803] To retrieve information about other users, the user presses the "Generate Profile" button within the smartphone app. This causes the device to POST a JSON-formatted request containing the user ID to the server's / api / generate_profile endpoint. The input is the user ID, and the output is the corresponding JSON-formatted request.

[0804] Step 4:

[0805] The server receives the request and extracts the user ID. Next, the server connects to the database and executes a query to retrieve all other user information from the Users table. The retrieved user information is processed into a list format in a JSON response and sent back to the terminal. The input to this process is a request containing the user ID, and the output is a JSON response containing the retrieved other user information.

[0806] Step 5:

[0807] To generate common topics for conversation with other users within the app, the user requests the generation of a conversation topic. The user presses the "Generate Topic" button and enters a list of participants' names. The device then POSTs a JSON request containing this list to the server's / api / generate_topics endpoint. The input is a list of participants' names, and the output is a JSON request sent to the server.

[0808] Step 6:

[0809] The server receives the request and extracts a list of participants' names from the JSON format. Next, the server uses natural language processing techniques to call a generative AI model (e.g., GPT-3) and generates a conversation topic using prompt sentences. The input to this process is prompt sentences containing the list of participants' names, and the output is the generated conversation topic.

[0810] Step 7:

[0811] The server saves the generated conversation topic to a database. The saved conversation topic is then processed again into JSON format and sent back to the device. The user checks the generated conversation topic through a smartphone app. The input to this process is the generated conversation topic, and the output is the conversation topic sent back to the device as a JSON response.

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

[0813] This invention is a system in which a user inputs their own information, retrieves information from other users, generates conversation topics, and further recognizes the user's emotions using an emotion engine, adjusting responses accordingly. This system involves registering user information, retrieving profiles of other users, generating conversation topics using natural language processing technology, and performing emotion recognition using an emotion engine.

[0814] 1. User information registration

[0815] The server provides an interface for the user to enter their information (name, department, hobbies, etc.). When the terminal enters this information and presses the "Register" button, the terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[0816] The server receives this request and extracts the name, department, and hobby information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. After saving, the server notifies the terminal that the user registration was successful.

[0817] 2. Obtaining other users' information

[0818] A user sends a request from their device to retrieve information about other users. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device uses JSON format for this request.

[0819] The server receives this request and extracts the user ID from the JSON format. The server connects to the database and executes a query to retrieve all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the terminal as a JSON response. This allows the user to retrieve the profile information of other employees.

[0820] 3. Generating conversation topics

[0821] To generate a conversation topic, the user enters the names of other employees and presses the "Generate Topic" button. The terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint.

[0822] The server receives this request and extracts a list of participant names from the JSON format. Next, the server uses natural language processing techniques to call an external natural language processing API to generate a conversation topic based on the specified participants. This API call generates a conversation topic based on the participants' attribute information.

[0823] The generated conversation topics are saved by the server to the Conversations table in the database and then sent back to the terminal. The terminal displays the received conversation topics to the user, allowing the user to easily start a conversation.

[0824] 4. Combination of emotional engines

[0825] The present invention further incorporates an emotion engine to recognize the user's emotions. The server receives text and voice data entered by the user and transmits this data to the emotion recognition engine. The server receives a response from the emotion recognition engine and analyzes the user's emotions.

[0826] Based on the analyzed emotions, the server adjusts its responses to the user and the conversation topics. For example, if the emotion engine detects that the user is stressed, the server can suggest topics related to relaxation.

[0827] Specific example

[0828] For example, suppose User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, User A wants to talk to other employees and presses the profile generation button to send a request. The server retrieves information about other employees from the database and sends it back to User A.

[0829] Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to user A.

[0830] Furthermore, if the emotion engine recognizes from the text entered by User A that User A is relaxed, the server will suggest more in-depth conversation topics based on that.

[0831] In this way, the present invention not only facilitates communication between employees from different departments and makes meetings and lunch breaks more meaningful, but also provides a more personalized experience through its emotion recognition function.

[0832] The following describes the processing flow.

[0833] Understood. Below, I will explain the processing flow of the invention that incorporates the emotion engine, broken down into specific steps.

[0834] 1. User information registration

[0835] Step 1:

[0836] The user enters their information (name, department, hobbies) into the input form and presses the "Register" button.

[0837] Step 2:

[0838] The terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[0839] Step 3:

[0840] The server receives the request and extracts information such as name, department, and hobbies from the JSON format.

[0841] Step 4:

[0842] The server connects to the database and saves the extracted user information to the Users table.

[0843] Step 5:

[0844] The server sends a message to the terminal in JSON format confirming that the user registration was successful.

[0845] Step 6:

[0846] The terminal receives a response from the server and displays a registration completion message to the user.

[0847] 2. Obtaining other users' information

[0848] Step 1:

[0849] The user presses the "Generate Profile" or "View Other Employees" button, specifies their user ID, and sends a request from their device.

[0850] Step 2:

[0851] The device sends a request in JSON format containing the user ID as a POST request to the server's / api / generate_profile endpoint.

[0852] Step 3:

[0853] The server receives the request and extracts the user ID from the JSON format.

[0854] Step 4:

[0855] The server connects to the database and executes a query to retrieve all other user information from the Users table.

[0856] Step 5:

[0857] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response.

[0858] Step 6:

[0859] The terminal receives a response from the server and displays other users' information on the screen.

[0860] 3. Generating conversation topics

[0861] Step 1:

[0862] The user enters the name of another employee and presses the "Generate Topic" button.

[0863] Step 2:

[0864] The device sends a JSON-formatted request containing a list of participant names as a POST request to the server's / api / generate_topics endpoint.

[0865] Step 3:

[0866] The server receives the request and extracts a list of participant names from the JSON format.

[0867] Step 4:

[0868] The server uses natural language processing technology to call an external natural language processing API and generate conversation topics based on the specified participants.

[0869] Step 5:

[0870] The server saves the generated conversation topics to the Conversations table in the database.

[0871] Step 6:

[0872] The server returns the generated conversation topic to the terminal in JSON format.

[0873] Step 7:

[0874] The terminal receives a response from the server and displays the generated conversation topic to the user.

[0875] 4. Emotion recognition by an emotion engine

[0876] Step 1:

[0877] The user enters their information via text or voice.

[0878] Step 2:

[0879] The device sends the entered text or voice data to the server.

[0880] Step 3:

[0881] The server sends the received data to the emotion engine for emotion recognition.

[0882] Step 4:

[0883] The emotion engine analyzes the user's emotions from the input data and sends the analysis results back to the server.

[0884] Step 5:

[0885] The server adjusts its responses to the user and conversation topics based on the sentiment information it receives from the sentiment engine.

[0886] Step 6:

[0887] For example, if the server detects that a user is feeling stressed, it will suggest topics related to relaxation.

[0888] Step 7:

[0889] The server returns the adjusted response and conversation topic to the terminal in JSON format.

[0890] Step 8:

[0891] The terminal receives a response from the server and displays appropriate information to the user.

[0892] This processing flow allows users to easily input their own information, retrieve information about other employees, and find common topics of conversation. Furthermore, by utilizing the emotion engine, personalized responses and conversation topics are provided that are tailored to the user's emotions, making communication even smoother.

[0893] (Example 2)

[0894] Next, we will describe Example 2. 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".

[0895] Traditional communication support systems lacked the functionality to efficiently retrieve information about other users and generate appropriate conversation topics. Furthermore, they struggled to provide personalized conversation topics that took users' emotions into account. As a result, communication between employees in different departments was not smooth, leading to a decline in the quality of communication within the company.

[0896] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for the user to input their own information, means for the user to send a request to obtain information of other users, means for generating conversation topics using natural language processing technology, means for analyzing the user's emotions using an emotion recognition engine, and means for adjusting conversation topics and responses based on the analyzed emotions. As a result, the user can efficiently obtain information of other users, generate appropriate conversation topics, and further enable personalized communication that takes emotions into consideration.

[0897] A "user" refers to an individual who uses a system to input or retrieve information.

[0898] A "server" refers to a computer system that receives requests from users, processes the data, and sends it back.

[0899] A "database" refers to a system that systematically stores and manages data such as user information and generated conversation topics.

[0900] A "request" refers to a request made by a user to a server for the retrieval or processing of information.

[0901] "Natural language processing technology" refers to algorithms and models that enable computers to understand and generate human language.

[0902] An "external API" refers to a programmatic interface used to retrieve and manipulate data in conjunction with other systems and services.

[0903] An "emotion recognition engine" refers to software that analyzes and recognizes emotions from user input data.

[0904] A "conversation topic" refers to a topic generated by the system to facilitate communication between users.

[0905] "Attribute information" refers to information specific to a user, such as their name, department, and hobbies.

[0906] "Analysis results" refer to the data obtained as a result of the emotion recognition engine analyzing the user's emotions.

[0907] "Response" refers to the reply from the server to the user, and specifically includes notifications of generated conversation topics and information.

[0908] The present invention is a system that supports communication between users via a communication network, and provides user information registration, acquisition of information on other users, generation of conversation topics, sentiment analysis by an sentiment recognition engine, and personalized responses. Specific embodiments of the present invention are described below.

[0909] 1. User information registration

[0910] The server provides an interface on a web browser or mobile application for users to enter their personal information (name, department, hobbies, etc.). When a user enters this information using a device (PC, smartphone, tablet, etc.) and presses the "Register" button, the device converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint. The server receives this request, parses the JSON data, and extracts the name, department, and hobbies information. This information is stored in a database (e.g., MySQL or PostgreSQL) and the server notifies the user that registration was successful.

[0911] 2. Obtaining other users' information

[0912] To retrieve information about other users, a user sends a request from their device to the server. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. This request is in JSON format. The server receives the request and extracts the user ID from the JSON data. The server then connects to the database, retrieves all other user information from the Users table, processes it into a list format, and sends it back to the device as a JSON response. For example, if user A wants to retrieve information about other employees, the retrieved information will include the names and departments of employees B and C.

[0913] 3. Generating conversation topics

[0914] Users can generate conversation topics by entering the names of conversation participants into their device and pressing the "Generate Topic" button. The device sends a POST request to the server's / api / generate_topics endpoint containing a JSON request with a list of participant names. The server receives the request and extracts the list of participant names from the JSON data. Next, the server uses natural language processing techniques to call an external API (e.g., OpenAI's GPT-3) to generate conversation topics based on the specified participants. The generated topics are stored in a database by the server and then sent back to the device for display to the user. For example, if the name "Hanako Sato" is entered, relevant conversation topics such as "Recently Read Books" and "Recommended Travel Destinations" will be generated.

[0915] 4. Combination of emotional engines

[0916] The present invention further utilizes an emotion recognition engine to recognize the user's emotions and provide personalized responses based on them. When the user inputs text or voice data into a terminal, the terminal sends it to a server. The server sends this data to an emotion recognition engine (e.g., IBM Watson's Tone Analyzer) to analyze the user's emotions. Based on the analyzed emotion information, the server adjusts the conversation topics and responses. For example, if the user inputs "I'm a little tired," topics and advice related to relaxation will be suggested.

[0917] Examples of prompt statements

[0918] The following are specific examples of prompt statements to be input to a generative AI model:

[0919] Please register your user information. This information should include your name, department, and hobbies. For example, please use the following format:

[0920] Name: Taro Yamada

[0921] [Sales Department]

[0922] Hobbies: Reading

[0923] Please use the information above to create and register your profile.

[0924] The flow of the specific processing in Example 2 will be explained using Figure 13.

[0925] User information registration

[0926] Step 1:

[0927] The user enters their name, department, and hobbies into a registration form on a browser or application using their device. Specifically, the user enters "Taro Yamada," "Sales Department," and "Reading" into a text box and then presses the register button.

[0928] Step 2:

[0929] The terminal converts the entered information into JSON format. Input includes the user's name, department, and hobbies (e.g., "Taro Yamada", "Sales Department", "Reading"), and the output generates JSON data like the following:

[0930] json

[0931] {

[0932] "name": "Yamada Taro",

[0933] "department": "Sales Department",

[0934] "hobby": "reading"

[0935] }

[0936] Step 3:

[0937] The device sends the generated JSON data as a POST request to the server's / api / register_user endpoint. Specifically, the device's HTTP client sends the request.

[0938] Step 4:

[0939] The server receives a POST request and extracts user information from the JSON data. The input is data in JSON format, and the output is the user's name, department, and hobbies, which are stored in a table.

[0940] Step 5:

[0941] The server connects to the database and saves user information to the Users table. Specifically, it executes SQL queries to insert the data.

[0942] Step 6:

[0943] The server notifies the terminal that user information registration was successful. The output includes a "Registration successful" message, which the terminal displays to the user.

[0944] Retrieving other user information

[0945] Step 1:

[0946] The user presses the "Generate Profile" button on their device. This action specifically involves the user clicking the button.

[0947] Step 2:

[0948] The terminal generates a JSON request containing the user ID and sends it as a POST request to the server's / api / generate_profile endpoint. The input includes the user ID (e.g., "12345"), and the output generates JSON data similar to the following:

[0949] json

[0950] {

[0951] "user_id": "12345"

[0952] }

[0953] Step 3:

[0954] The server receives a POST request and extracts the user ID from the JSON data. The input is data in JSON format, and the output is the user ID.

[0955] Step 4:

[0956] The server connects to the database and executes a query to retrieve all other user information from the Users table. Specifically, it executes a SELECT statement to retrieve the data.

[0957] Step 5:

[0958] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response. The output will be JSON data like the following:

[0959] json

[0960] [

[0961] {

[0962] "name": "Hanako Sato",

[0963] "department": "Development Department",

[0964] "hobby": "cooking"

[0965] },

[0966] {

[0967] "name": "Ichiro Suzuki",

[0968] "department": "Sales Department",

[0969] "hobby": "golf"

[0970] }

[0971] ]

[0972] Step 6:

[0973] The terminal receives a response from the server and displays user information in list format. Specifically, it displays the data on the user interface.

[0974] Generating conversation topics

[0975] Step 1:

[0976] The user enters the names of the conversation participants into their device and presses the "Generate Topic" button. Specifically, this involves typing "Hanako Sato" into the text box and clicking the button.

[0977] Step 2:

[0978] The terminal generates a JSON request containing a list of participant names and sends it as a POST request to the server's / api / generate_topics endpoint. The input includes participant names (e.g., "Hanako Sato"), and the output generates JSON data similar to the following:

[0979] json

[0980] {

[0981] "participants": ["Hanako Sato"]

[0982] }

[0983] Step 3:

[0984] The server receives a POST request and extracts a list of participant names from the JSON data. The input is data in JSON format, and the output is a list of participant names.

[0985] Step 4:

[0986] The server uses natural language processing techniques to call an external API (e.g., OpenAI's GPT-3) and generates a conversation topic based on the specified participants. Specifically, this involves making an API call and receiving the generated topic.

[0987] Step 5:

[0988] The server saves the generated conversation topic to the database and sends it back to the terminal. The output will be JSON data like the following:

[0989] json

[0990] {

[0991] "Topics": ["Recently read books", "Recommended travel destinations"]

[0992] }

[0993] Step 6:

[0994] The terminal receives a response from the server and displays the generated conversation topic to the user. Specifically, it displays the topic in the user interface.

[0995] Combination of emotional engines

[0996] Step 1:

[0997] The user inputs text or voice data into the device. Specifically, this might involve typing text such as "I'm a little tired" or using voice input.

[0998] Step 2:

[0999] The device sends input data to the server's / api / analyze_emotion endpoint. Input can include text or audio data, and output is data sent to the server.

[1000] Step 3:

[1001] The server sends data to the emotion recognition engine, which analyzes the user's emotions. Specifically, it calls an emotion recognition API (e.g., IBM Watson's Tone Analyzer) to receive the analysis results.

[1002] Step 4:

[1003] The server adjusts the conversation topics and responses based on the analysis results. The output includes topics and advice related to relaxation, resulting in JSON data like the following:

[1004] json

[1005] {

[1006] "adjusted_topics": ["My most relaxing place", "About my recent hobbies"]

[1007] }

[1008] Step 5:

[1009] The terminal receives a response from the server and displays it to the user. Specifically, it displays topics and advice tailored to the user interface.

[1010] (Application Example 2)

[1011] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server," and the smart glasses 214 will be referred to as the "terminal."

[1012] Existing systems lack the functionality to facilitate smooth communication between users, and in particular, face-to-face customer service, they have difficulty appropriately recognizing user emotions and suggesting conversation topics based on those emotions. Furthermore, two-way communication that is attentive to user emotions is essential for improving customer satisfaction and achieving efficient service. Especially in customer service at physical stores, it is necessary for customer service staff to instantly grasp the emotional state of customers and respond appropriately accordingly.

[1013] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the server to utilize natural language processing technology to generate a conversation topic, means for storing the generated conversation topic and returning it to the user, means for analyzing the user's emotions using an emotion recognition engine, and means for adjusting conversation topics and responses based on the emotion analysis results and providing them to the user. This makes it possible to provide appropriate conversation topics based on the user's emotional state and realize more personalized communication.

[1014] "User information" refers to information about a user's personal attributes, such as their name, department, and hobbies, that they have registered about themselves.

[1015] A "server" is a computing system that receives information from users via a network, stores it in a database, and processes the information in cooperation with other services.

[1016] A "database" is a system for efficiently managing, storing, and retrieving data such as user information and conversation topics.

[1017] A "request" is a communication message in which a user asks a server to retrieve or process information.

[1018] "Natural language processing technology" refers to a set of techniques that enable computers to understand and generate human language, utilizing machine learning and data analysis.

[1019] A "conversation topic" is a topic generated to facilitate communication between users.

[1020] An "emotion recognition engine" is software or hardware that analyzes emotions from user input text or voice and recognizes that emotional state.

[1021] "Emotional analysis results" refer to data indicating the user's emotional state, obtained by the emotion recognition engine.

[1022] A "response" is a message that a server provides in response to a user's request, and it includes the conversation topic and other information.

[1023] "Personalized communication" refers to communication delivered in a format optimized for a specific user, based on their individual emotions and attribute information.

[1024] Modes for carrying out the invention

[1025] This invention relates to a system in which a user inputs their own information, a server receives that information, stores it in a database, retrieves information from other users, recognizes the user's emotions, and generates conversation topics based on that. The system has the following main functions: user information registration, retrieval of other users' information, generation of conversation topics, and use of an emotion recognition engine.

[1026] The server first provides an interface for users to enter their information. When a user enters information such as their name, department, and hobbies on their terminal and presses the registration button, the information is converted to JSON format and sent as a POST request to the server endpoint. The server receives the request, extracts the necessary information from the JSON format, and saves it to the "Users" table in the database. If the save is successful, the server sends a registration success message to the user.

[1027] Next, the user sends a request to retrieve information about other users. Specifically, when the user specifies their own ID and sends a request to the server, the server retrieves all other user information from the database, processes it into a list format, and sends it back to the user. This allows the user to easily obtain the profile information of other users.

[1028] Next, when a user creates a conversation topic, they enter the names of other users they wish to talk to, designating them as participants. Based on the specified participants, the server generates a conversation topic using natural language processing techniques. The generated conversation topic is stored in a database and returned to the user. This natural language processing technique can utilize external natural language processing APIs.

[1029] Furthermore, the present invention integrates an emotion recognition engine to analyze emotions from user input text and voice data. The server receives this data and transmits it to the emotion recognition engine. Upon receiving a response from the emotion recognition engine, the server adjusts its response to the user and conversation topics based on the analyzed emotions. For example, if the user is feeling stressed, topics related to relaxation can be suggested.

[1030] As a concrete example, if user A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the registration button, this information is sent to the server and stored in the database. Next, if user A wants to talk to another employee and presses the profile generation button to send a request, the server retrieves information about the other employee from the database and sends it back to user A. Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses a natural language processing API to generate a common topic with "Hanako Sato." As a result, a topic such as "A book you've recently read" is returned to user A. Also, if the sentiment engine recognizes from the text entered by user A that user A is relaxed, the server will suggest a more in-depth conversation topic based on that.

[1031] An example of a prompt to input into the generating AI model could be: "Generate a sample dialogue for a customer service application in a store within a shopping mall."

[1032] In this way, the present invention facilitates communication between employees from different departments and can also be applied to customer service in physical stores. The emotion recognition function provides an even more personalized experience.

[1033] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[1034] Step 1:

[1035] It provides an interface for users to enter their own information. Users enter information such as their name, department, and hobbies, and then press the register button. The entered information is sent from the terminal to the server as a POST request in JSON format.

[1036] Input: User information such as name, department, and hobbies.

[1037] Output: POST request in JSON format

[1038] Step 2:

[1039] The server receives the input information from the user. The server extracts the necessary information (name, department, hobbies, etc.) from the received JSON data and saves it to the "Users" table in the database. If the saving is successful, the server sends a registration success message to the user in JSON format.

[1040] Input: User information in JSON format

[1041] Output: Successful message for saving to database and registration.

[1042] Step 3:

[1043] The user presses a button to send a request to retrieve information about another user. The user specifies their own ID and sends the request. The terminal sends a POST request in JSON format containing this information to the server endpoint.

[1044] Input: Your User ID

[1045] Output: POST request in JSON format

[1046] Step 4:

[1047] The server receives the aforementioned request. The server retrieves all other user information from the database and processes it into a list format. Then, it sends the retrieved user information back to the user as a JSON response.

[1048] Input: Request in JSON format, User ID

[1049] Output: List of other user information, response in JSON format

[1050] Step 5:

[1051] The user interacts with the interface for generating conversation topics. They enter the names of other users who will be participating in the conversation and designate them as participants. The terminal sends a POST request in JSON format containing the list of participant names to the server endpoint.

[1052] Input: List of participant names

[1053] Output: POST request in JSON format

[1054] Step 6:

[1055] The server receives the aforementioned request. The server calls an external API to generate a conversation topic using natural language processing technology. This API call generates a conversation topic based on the specified participants. The generated conversation topic is stored in the "Conversations" table in the database and returned to the user as a JSON response.

[1056] Input: Participant information in JSON format

[1057] Output: Save to database, JSON response of the generated conversation topic

[1058] Step 7:

[1059] The system performs emotion recognition using user-input text or audio data. The device sends the input text or audio data to the server as a POST request in JSON format.

[1060] Input: Text or audio data

[1061] Output: POST request in JSON format

[1062] Step 8:

[1063] The server receives the text and audio data. The server sends the data to the emotion recognition engine and receives the analysis results. Based on the emotion recognition results, the server adjusts the conversation topics and responses to be appropriate and provides them to the user.

[1064] Input: Text or audio data in JSON format

[1065] Output: Emotion recognition results, adjusted response

[1066] In this way, each step of the present invention realizes a series of processes from user information registration to emotion recognition, and then generating and providing an appropriate response.

[1067] 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 user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[1068] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1069] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the smart glasses 214.

[1070] [Third Embodiment]

[1071] Figure 5 shows an example of the configuration of the data processing system 310 according to the third embodiment.

[1072] As shown in Figure 5, the data processing system 310 includes a data processing device 12 and a headset terminal 314. An example of the data processing device 12 is a server.

[1073] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

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

[1075] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

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

[1077] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[1078] Figure 6 shows an example of the main functions of the data processing device 12 and the headset terminal 314. As shown in Figure 6, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[1079] The specific processing program 56 is an example of a "program" relating to the technology of this 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.

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

[1081] In the headset terminal 314, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[1082] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the headset terminal 314 will be referred to as the "terminal".

[1083] This invention is a system in which a user inputs their own information, retrieves information from other users, and generates conversation topics. This system performs user information registration, retrieves other users' profiles, and generates conversation topics using natural language processing technology.

[1084] 1. User information registration

[1085] The server provides an interface for the user to enter their information (name, department, hobbies, etc.). When the terminal enters this information and presses the "Register" button, the terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[1086] The server receives this request and extracts the name, department, and hobby information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. After saving, the server notifies the terminal that the user registration was successful.

[1087] 2. Obtaining other users' information

[1088] A user sends a request from their device to retrieve information about other users. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device uses JSON format for this request.

[1089] The server receives this request and extracts the user ID from the JSON format. The server connects to the database and executes a query to retrieve all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the terminal as a JSON response. This allows the user to retrieve the profile information of other employees.

[1090] 3. Generating conversation topics

[1091] To generate a conversation topic, the user enters the names of other employees and presses the "Generate Topic" button. The terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint.

[1092] The server receives this request and extracts a list of participant names from the JSON format. Next, the server uses natural language processing techniques to call the GPT API to generate a conversation topic. This API call generates a conversation topic based on the participant attribute information.

[1093] The generated conversation topics are stored in a database by the server and then sent back to the terminal. The terminal displays the received conversation topics to the user, allowing the user to easily start a conversation.

[1094] Specific example

[1095] For example, suppose User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, User A wants to talk to other employees and presses the profile generation button to send a request. The server retrieves information about other employees from the database and sends it back to User A.

[1096] Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to user A.

[1097] In this way, the present invention promotes communication among employees from different departments and makes meetings and lunch breaks more meaningful.

[1098] The following describes the processing flow.

[1099] Understood. Below, I will explain the program's processing in detail, step by step.

[1100] 1. User information registration

[1101] Step 1:

[1102] The user enters their information (name, department, hobbies) into the input form and presses the "Register" button.

[1103] Step 2:

[1104] The terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[1105] Step 3:

[1106] The server receives the request and extracts information such as name, department, and hobbies from the JSON format.

[1107] Step 4:

[1108] The server connects to the database and saves the extracted user information to the Users table.

[1109] Step 5:

[1110] The server sends a message to the terminal in JSON format confirming that the user registration was successful.

[1111] Step 6:

[1112] The terminal receives a response from the server and displays a registration completion message to the user.

[1113] 2. Obtaining other users' information

[1114] Step 1:

[1115] The user presses the "Generate Profile" or "View Other Employees" button, specifies their user ID, and sends a request from their device.

[1116] Step 2:

[1117] The device sends a request in JSON format containing the user ID as a POST request to the server's / api / generate_profile endpoint.

[1118] Step 3:

[1119] The server receives the request and extracts the user ID from the JSON format.

[1120] Step 4:

[1121] The server connects to the database and executes a query to retrieve all other user information from the Users table.

[1122] Step 5:

[1123] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response.

[1124] Step 6:

[1125] The terminal receives a response from the server and displays other users' information on the screen.

[1126] 3. Generating conversation topics

[1127] Step 1:

[1128] The user enters the name of another employee and presses the "Generate Topic" button.

[1129] Step 2:

[1130] The device sends a JSON-formatted request containing a list of participant names as a POST request to the server's / api / generate_topics endpoint.

[1131] Step 3:

[1132] The server receives the request and extracts a list of participant names from the JSON format.

[1133] Step 4:

[1134] The server uses natural language processing technology to call an external natural language processing API and generate conversation topics based on the specified participants.

[1135] Step 5:

[1136] The server saves the generated conversation topics to the Conversations table in the database.

[1137] Step 6:

[1138] The server returns the generated conversation topic to the terminal in JSON format.

[1139] Step 7:

[1140] The terminal receives a response from the server and displays the generated conversation topic to the user.

[1141] This processing flow allows users to easily input their own information, retrieve information about other employees, and find common topics of conversation. This system is a concrete implementation aimed at promoting communication between employees from different departments and making meetings and lunch breaks more productive.

[1142] (Example 1)

[1143] Next, we will describe Example 1. 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."

[1144] In conventional communication support systems, it has been difficult for employees from different departments to efficiently share information and find common conversation topics. This has reduced opportunities to build new relationships and hindered information sharing and the establishment of collaborative relationships within companies. The present invention aims to solve these problems and provide a system that facilitates communication within companies.

[1145] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[1146] In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the user to input the names of other users and send a request to generate a conversation topic, means for the server to utilize natural language processing technology to generate a conversation topic, means for storing the generated conversation topic and returning it to the user, and means for a terminal to display the generated conversation topic. This makes it possible for employees from different departments to efficiently find common conversation topics and communicate smoothly with each other.

[1147] A "user" refers to an end-user who inputs their own information into the system, retrieves information from other users, and generates conversation topics.

[1148] A "server" refers to a central computer system that receives information from users, stores it in a database, processes the data in response to requests, and generates and sends back conversation topics.

[1149] A "terminal" refers to a computer device (such as a PC or smartphone) that a user uses to input information, send requests, and receive responses.

[1150] A "database" refers to a data storage system used to store user information and generated conversation topics.

[1151] A "request" refers to a communication message from a user or device that requests information from a server for processing or acquisition.

[1152] "API" stands for Application Programming Interface, and refers to a set of protocols and tools for accessing external services and databases.

[1153] "Natural language processing technology" refers to all technologies used to understand and process human language using computers, including technologies such as text generation and topic extraction.

[1154] A "conversation topic" refers to a subject or theme that helps users to start a conversation smoothly with each other.

[1155] "Attribute information" refers to basic information about the user (such as name, department, and hobbies).

[1156] "Generation" refers to the process by which a system creates new data or information.

[1157] This invention is a system in which a user inputs their own information, retrieves information from other users, and generates conversation topics. This system performs user information registration, retrieves other users' profiles, and generates conversation topics using natural language processing technology. Specifically, it is implemented as follows:

[1158] Hardware and software used

[1159] The server functions as a central processing unit, handling all data processing and information storage / retrieval described later. The server is equipped with a database (selectable between SQL and NoSQL databases) and APIs for implementing natural language processing technologies (e.g., the GPT API).

[1160] The device is the interface with the user and is designed as a web application or mobile application.

[1161] The user operates the terminal to input and retrieve information and sends a conversation topic generation request.

[1162] User information registration

[1163] The server provides an interface for users to enter their information (e.g., name, department, hobbies, etc.). The user enters the information into a form on the terminal and presses the "Register" button. The terminal converts this information into JSON format and sends a POST request to the server's / api / register_user endpoint. The server receives this request and extracts the name, department, and hobbies from the received data. The server then connects to the database and saves this information to the Users table. Once the saving is complete, the server sends a message back to the terminal indicating successful registration.

[1164] Retrieving other user information

[1165] When a user wants to retrieve information about other users, they send a request from their device. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device structures this request in JSON format. The server receives the request and extracts the user ID. The server connects to the database and retrieves all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the device as a JSON response. This allows the user to retrieve the profile information of other employees.

[1166] Generating conversation topics

[1167] The user generates a conversation topic to find common ground for talking with other employees. When the user enters the names of other employees and presses the "Generate Topic" button, the terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint. The server receives this request and extracts the list of participants' names. The server then uses natural language processing techniques (e.g., the GPT API) to generate a conversation topic. This API call generates a conversation topic based on the participants' attribute information. The generated conversation topic is saved to a database by the server and then sent back to the terminal. The terminal displays this information to the user.

[1168] Specific example

[1169] For example, User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, if User A wants to talk to another employee, they press the profile generation button to send a request. The server retrieves information about the other employee from the database and sends it back to User A. Furthermore, if User A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to User A. In this way, communication between employees from different departments is facilitated, making meetings and lunch breaks more meaningful.

[1170] Example of a prompt

[1171] The following are examples of prompts to input into a generative AI model to generate conversation topics:

[1172] User Information: Name: Taro Yamada, Department: Sales Department, Hobbies: Reading

[1173] Contact information: Name: Hanako Sato, Department: Planning Department, Hobby: Calligraphy

[1174] Please create a topic that will be a common subject of discussion among these users.

[1175] The flow of the specific processing in Example 1 will be explained using Figure 11.

[1176] User information registration

[1177] Step 1:

[1178] Summary: The user enters their own information.

[1179] Specific actions:

[1180] The user enters their "name," "department," and "hobbies" into the input form on their device.

[1181] Input: Information entered by the user in the input form (e.g., Name = Taro Yamada, Department = Sales Department, Hobby = Reading)

[1182] Output: User information displayed in the input form

[1183] Step 2:

[1184] Summary: The terminal converts the input information into JSON format and sends it to the server.

[1185] Specific actions:

[1186] The user presses the "Register" button. The device creates JSON data like the following and sends a POST request to the server's / api / register_user endpoint.

[1187] json

[1188] {

[1189] "Name": "Yamada Taro",

[1190] " [": "Sales Department"

[1191] "Hobbies": "Reading"

[1192] }

[1193] Input: User presses the "Register" button.

[1194] Output: Request data in JSON format

[1195] Step 3:

[1196] Summary: The server processes the received JSON data and saves the information to the database.

[1197] Specific actions:

[1198] The server receives the POST request and extracts the name, department, and hobbies from the JSON data. Using the extracted data, it executes the following SQL query on the database.

[1199] SQL

[1200] INSERT INTO Users (Name, Department, Hobby) VALUES ('Taro Yamada', 'Sales Department', 'Reading');

[1201] Input: User information in JSON format

[1202] Output: User information stored in the database

[1203] Step 4:

[1204] Summary: The server notifies the terminal that the information registration was successful.

[1205] Specific actions:

[1206] The server sends the following JSON response back to the terminal.

[1207] json

[1208] {

[1209] "status": "success",

[1210] "message": "User information has been registered."

[1211] }

[1212] Input: The result of the information being correctly saved in the database.

[1213] Output: JSON response of success message

[1214] Retrieving other user information

[1215] Step 1:

[1216] Summary: A user sends a request from their device to retrieve information about other users.

[1217] Specific actions:

[1218] The user clicks the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint.

[1219] json

[1220] {

[1221] "user_id": "1"

[1222] }

[1223] Input: User clicks the "Generate Profile" button and enters the user ID.

[1224] Output: Request data in JSON format

[1225] Step 2:

[1226] Summary: The server receives a request and retrieves other user information based on the user ID.

[1227] Specific actions:

[1228] The server receives the POST request and extracts the user ID from the JSON data. The server then executes the following SQL query on the database.

[1229] SQL

[1230] SELECT FROM Users WHERE user_id != '1';

[1231] Input: Request data in JSON format and User ID

[1232] Output: Other user information retrieved from the database

[1233] Step 3:

[1234] Summary: The server processes the acquired user information into a list format and sends it back to the terminal.

[1235] Specific actions:

[1236] The server converts the user information it has retrieved into response data in JSON format.

[1237] json

[1238] [

[1239] {

[1240] "Name": "Hanako Sato",

[1241] "Department": "Planning Department",

[1242] "Hobbies": "Calligraphy"

[1243] },

[1244] / / Other user information

[1245] ]

[1246] Input: User information retrieved from the database

[1247] Output: Response data in JSON format

[1248] Generating conversation topics

[1249] Step 1:

[1250] Summary: The user sends a request from their device to generate a conversation topic.

[1251] Specific actions:

[1252] The user enters the names of other employees to generate a conversation topic and presses the "Generate Topic" button. The terminal sends JSON data like the following as a POST request to the server's / api / generate_topics endpoint.

[1253] json

[1254] {

[1255] "Participants": ["Taro Yamada", "Hanako Sato"]

[1256] }

[1257] Input: User presses the "Generate Topic" button and enters a list of participant names.

[1258] Output: Request data in JSON format

[1259] Step 2:

[1260] Summary: The server receives the request and generates a conversation topic from the participants' names.

[1261] Specific actions:

[1262] The server receives the POST request and extracts a list of participant names from the JSON data. The server then sends the generated prompt to the GPT API.

[1263] User Information: Name: Taro Yamada, Department: Sales Department, Hobbies: Reading

[1264] Contact information: Name: Hanako Sato, Department: Planning Department, Hobby: Calligraphy

[1265] Please create a topic that will be a common subject of discussion among these users.

[1266] Input: Request data in JSON format and a list of participant names.

[1267] Output: Prompt message to the GPT API

[1268] Step 3:

[1269] Summary: The server receives the generated conversation topic and saves it to the database.

[1270] Specific actions:

[1271] The server receives a conversation topic generated from the GPT API and saves it to the database by executing an SQL query like the following:

[1272] SQL

[1273] INSERT INTO Topics (topic) VALUES ('About a book I recently read');

[1274] Input: Conversation topic generated from the GPT API

[1275] Output: Conversation topics stored in the database

[1276] Step 4:

[1277] Summary: The server sends the generated conversation topic back to the terminal and displays it to the user.

[1278] Specific actions:

[1279] The server sends the following JSON response back to the terminal.

[1280] json

[1281] {

[1282] "topics": ["About books I've recently read"]

[1283] }

[1284] The device displays the conversation topics it has received on the screen, allowing the user to review them.

[1285] Input: Conversation topics stored in the database

[1286] Output: Response data in JSON format and screen display

[1287] The above describes the specific processing steps, the inputs and outputs of each step, and the specific operations.

[1288] (Application Example 1)

[1289] Next, we will explain Application Example 1. In the following explanation, 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."

[1290] In modern brick-and-mortar stores, a lack of communication among employees and between employees and customers is a cause of decreased customer satisfaction and reduced operational efficiency. Finding common ground is particularly difficult for employees from different departments, and for staff and customers meeting for the first time, making smooth conversation challenging. Furthermore, manually gathering common topics and profile information is time-consuming, highlighting the need for automated systems.

[1291] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[1292] In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the server to use natural language processing technology and a generative AI model to generate conversation topics, and means for the server to store the generated conversation topics and return them to the user. This facilitates communication between employees and customers, enabling improvements in work efficiency and customer satisfaction.

[1293] A "user" is an individual who uses the system to input their own information and retrieve information and conversation topics from other users.

[1294] A "server" is a device or system that receives user input information, stores it in a database, retrieves and returns information from other users, and uses natural language processing technology to generate conversation topics.

[1295] A "database" is a digital storage system used to store and manage system-related information, such as user input and generated conversation topics.

[1296] A "request" is an instruction that a user sends to a server to ask the system to retrieve other users' information or to generate conversation topics.

[1297] Natural language processing (NLP) is a computer technology used to understand and generate human language. Its primary applications include text analysis, language modeling, and dialogue generation.

[1298] A "generative AI model" is an artificial intelligence model used to generate conversation topics based on user attribute information.

[1299] A "prompt sentence" is a text sentence that a generative AI model uses as input when generating conversation topics.

[1300] To implement this invention, it is necessary to build a system in which a user inputs their own information using a smartphone app, retrieves other users' profiles, and generates conversation topics. In this system, a server, a database, and a generative AI model using natural language processing technology play important roles. A specific example is shown below.

[1301] 1. User information registration

[1302] First, the user enters their information (name, department, hobbies, etc.) through the smartphone app interface. The entered information is converted to JSON format and sent from the device as a POST request to the server's / api / register_user endpoint. The server receives this request and extracts the information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. This registers the user information in the database.

[1303] 2. Obtaining other users' information

[1304] To retrieve information about other users, users send requests using a smartphone app. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. This request is also in JSON format. The server receives the request and extracts the user ID. The server connects to the database and executes a query to retrieve all other user information from the Users table. The retrieved user information is then processed into a list format and sent back to the device as a JSON response. This allows the user to retrieve the profile information of other employees.

[1305] 3. Generating conversation topics

[1306] Users request the generation of conversation topics to create common topics to talk about with other users within the app. For example, if a user wants to talk to "Hanako Sato," they enter the name and press the "Generate Topic" button. The device sends a POST request to the server's / api / generate_topics endpoint containing a JSON request with a list of participants' names. The server receives this request and extracts the list of participants' names from the JSON. Next, the server uses natural language processing techniques to call a generative AI model (e.g., GPT-3) to generate a conversation topic. This API call generates a conversation topic based on the participants' attribute information. The generated conversation topic is saved to a database by the server and then sent back to the device. Users can view the received conversation topic through the app and easily start a conversation.

[1307] Hardware and software to be used

[1308] Hardware:

[1309] Smartphone: Provides a user interface and is used for inputting and displaying information.

[1310] Server: Used for receiving and processing requests, managing data, and calling generated AI models.

[1311] software:

[1312] Flask: A server-side web framework used for defining endpoints and processing requests.

[1313] SQLite: Used as a database management system to store user information and generated conversation topics.

[1314] OpenAI API: Used for generating conversation topics using natural language processing technology.

[1315] Examples of specific cases and prompt statements

[1316] For example, suppose user A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, if user A wants to talk to another employee, they press the profile generation button to send a request. The server retrieves information about the other employee from the database and sends it back to user A. Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate common topics with "Hanako Sato." As a result, topics such as "Recent topics related to cooking and travel" are returned to user A.

[1317] Example of a prompt:

[1318] Please generate conversation topics about the following people: Taro Yamada, Hanako Sato

[1319] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[1320] Step 1:

[1321] The user opens the smartphone app and enters their personal information (name, department, hobbies, etc.). The entered information is converted to JSON format on the device and sent as a POST request to the server's / api / register_user endpoint. In this process, the input is the user's information, and the output is data in JSON format.

[1322] Step 2:

[1323] The server receives the aforementioned request. It extracts name, department, and hobby information from the received data and connects to the database. It executes an SQL query to save the extracted information to the Users table. The input to this process is user information in JSON format, and the output is the user information stored in the database.

[1324] Step 3:

[1325] To retrieve information about other users, the user presses the "Generate Profile" button within the smartphone app. This causes the device to POST a JSON-formatted request containing the user ID to the server's / api / generate_profile endpoint. The input is the user ID, and the output is the corresponding JSON-formatted request.

[1326] Step 4:

[1327] The server receives the request and extracts the user ID. Next, the server connects to the database and executes a query to retrieve all other user information from the Users table. The retrieved user information is processed into a list format in a JSON response and sent back to the terminal. The input to this process is a request containing the user ID, and the output is a JSON response containing the retrieved other user information.

[1328] Step 5:

[1329] To generate common topics for conversation with other users within the app, the user requests the generation of a conversation topic. The user presses the "Generate Topic" button and enters a list of participants' names. The device then POSTs a JSON request containing this list to the server's / api / generate_topics endpoint. The input is a list of participants' names, and the output is a JSON request sent to the server.

[1330] Step 6:

[1331] The server receives the request and extracts a list of participants' names from the JSON format. Next, the server uses natural language processing techniques to call a generative AI model (e.g., GPT-3) and generates a conversation topic using prompt sentences. The input to this process is prompt sentences containing the list of participants' names, and the output is the generated conversation topic.

[1332] Step 7:

[1333] The server saves the generated conversation topic to a database. The saved conversation topic is then processed again into JSON format and sent back to the device. The user checks the generated conversation topic through a smartphone app. The input to this process is the generated conversation topic, and the output is the conversation topic sent back to the device as a JSON response.

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

[1335] This invention is a system in which a user inputs their own information, retrieves information from other users, generates conversation topics, and further recognizes the user's emotions using an emotion engine, adjusting responses accordingly. This system involves registering user information, retrieving profiles of other users, generating conversation topics using natural language processing technology, and performing emotion recognition using an emotion engine.

[1336] 1. User information registration

[1337] The server provides an interface for the user to enter their information (name, department, hobbies, etc.). When the terminal enters this information and presses the "Register" button, the terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[1338] The server receives this request and extracts the name, department, and hobby information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. After saving, the server notifies the terminal that the user registration was successful.

[1339] 2. Obtaining other users' information

[1340] A user sends a request from their device to retrieve information about other users. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device uses JSON format for this request.

[1341] The server receives this request and extracts the user ID from the JSON format. The server connects to the database and executes a query to retrieve all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the terminal as a JSON response. This allows the user to retrieve the profile information of other employees.

[1342] 3. Generating conversation topics

[1343] To generate a conversation topic, the user enters the names of other employees and presses the "Generate Topic" button. The terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint.

[1344] The server receives this request and extracts a list of participant names from the JSON format. Next, the server uses natural language processing techniques to call an external natural language processing API to generate a conversation topic based on the specified participants. This API call generates a conversation topic based on the participants' attribute information.

[1345] The generated conversation topics are saved by the server to the Conversations table in the database and then sent back to the terminal. The terminal displays the received conversation topics to the user, allowing the user to easily start a conversation.

[1346] 4. Combination of emotional engines

[1347] The present invention further incorporates an emotion engine to recognize the user's emotions. The server receives text and voice data entered by the user and transmits this data to the emotion recognition engine. The server receives a response from the emotion recognition engine and analyzes the user's emotions.

[1348] Based on the analyzed emotions, the server adjusts its responses to the user and the conversation topics. For example, if the emotion engine detects that the user is stressed, the server can suggest topics related to relaxation.

[1349] Specific example

[1350] For example, suppose User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, User A wants to talk to other employees and presses the profile generation button to send a request. The server retrieves information about other employees from the database and sends it back to User A.

[1351] Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to user A.

[1352] Furthermore, if the emotion engine recognizes from the text entered by User A that User A is relaxed, the server will suggest more in-depth conversation topics based on that.

[1353] In this way, the present invention not only facilitates communication between employees from different departments and makes meetings and lunch breaks more meaningful, but also provides a more personalized experience through its emotion recognition function.

[1354] The following describes the processing flow.

[1355] Understood. Below, I will explain the processing flow of the invention that incorporates the emotion engine, broken down into specific steps.

[1356] 1. User information registration

[1357] Step 1:

[1358] The user enters their information (name, department, hobbies) into the input form and presses the "Register" button.

[1359] Step 2:

[1360] The terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[1361] Step 3:

[1362] The server receives the request and extracts information such as name, department, and hobbies from the JSON format.

[1363] Step 4:

[1364] The server connects to the database and saves the extracted user information to the Users table.

[1365] Step 5:

[1366] The server sends a message to the terminal in JSON format confirming that the user registration was successful.

[1367] Step 6:

[1368] The terminal receives a response from the server and displays a registration completion message to the user.

[1369] 2. Obtaining other users' information

[1370] Step 1:

[1371] The user presses the "Generate Profile" or "View Other Employees" button, specifies their user ID, and sends a request from their device.

[1372] Step 2:

[1373] The device sends a request in JSON format containing the user ID as a POST request to the server's / api / generate_profile endpoint.

[1374] Step 3:

[1375] The server receives the request and extracts the user ID from the JSON format.

[1376] Step 4:

[1377] The server connects to the database and executes a query to retrieve all other user information from the Users table.

[1378] Step 5:

[1379] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response.

[1380] Step 6:

[1381] The terminal receives a response from the server and displays other users' information on the screen.

[1382] 3. Generating conversation topics

[1383] Step 1:

[1384] The user enters the name of another employee and presses the "Generate Topic" button.

[1385] Step 2:

[1386] The device sends a JSON-formatted request containing a list of participant names as a POST request to the server's / api / generate_topics endpoint.

[1387] Step 3:

[1388] The server receives the request and extracts a list of participant names from the JSON format.

[1389] Step 4:

[1390] The server uses natural language processing technology to call an external natural language processing API and generate conversation topics based on the specified participants.

[1391] Step 5:

[1392] The server saves the generated conversation topics to the Conversations table in the database.

[1393] Step 6:

[1394] The server returns the generated conversation topic to the terminal in JSON format.

[1395] Step 7:

[1396] The terminal receives a response from the server and displays the generated conversation topic to the user.

[1397] 4. Emotion recognition by an emotion engine

[1398] Step 1:

[1399] The user enters their information via text or voice.

[1400] Step 2:

[1401] The device sends the entered text or voice data to the server.

[1402] Step 3:

[1403] The server sends the received data to the emotion engine for emotion recognition.

[1404] Step 4:

[1405] The emotion engine analyzes the user's emotions from the input data and sends the analysis results back to the server.

[1406] Step 5:

[1407] The server adjusts its responses to the user and conversation topics based on the sentiment information it receives from the sentiment engine.

[1408] Step 6:

[1409] For example, if the server detects that a user is feeling stressed, it will suggest topics related to relaxation.

[1410] Step 7:

[1411] The server returns the adjusted response and conversation topic to the terminal in JSON format.

[1412] Step 8:

[1413] The terminal receives a response from the server and displays appropriate information to the user.

[1414] This processing flow allows users to easily input their own information, retrieve information about other employees, and find common topics of conversation. Furthermore, by utilizing the emotion engine, personalized responses and conversation topics are provided that are tailored to the user's emotions, making communication even smoother.

[1415] (Example 2)

[1416] Next, we will describe Example 2. 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."

[1417] Traditional communication support systems lacked the functionality to efficiently retrieve information about other users and generate appropriate conversation topics. Furthermore, they struggled to provide personalized conversation topics that took users' emotions into account. As a result, communication between employees in different departments was not smooth, leading to a decline in the quality of communication within the company.

[1418] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for the user to input their own information, means for the user to send a request to obtain information of other users, means for generating conversation topics using natural language processing technology, means for analyzing the user's emotions using an emotion recognition engine, and means for adjusting conversation topics and responses based on the analyzed emotions. As a result, the user can efficiently obtain information of other users, generate appropriate conversation topics, and further enable personalized communication that takes emotions into consideration.

[1419] A "user" refers to an individual who uses a system to input or retrieve information.

[1420] A "server" refers to a computer system that receives requests from users, processes the data, and sends it back.

[1421] A "database" refers to a system that systematically stores and manages data such as user information and generated conversation topics.

[1422] A "request" refers to a request made by a user to a server for the retrieval or processing of information.

[1423] "Natural language processing technology" refers to algorithms and models that enable computers to understand and generate human language.

[1424] An "external API" refers to a programmatic interface used to retrieve and manipulate data in conjunction with other systems and services.

[1425] An "emotion recognition engine" refers to software that analyzes and recognizes emotions from user input data.

[1426] A "conversation topic" refers to a topic generated by the system to facilitate communication between users.

[1427] "Attribute information" refers to information specific to a user, such as their name, department, and hobbies.

[1428] "Analysis results" refer to the data obtained as a result of the emotion recognition engine analyzing the user's emotions.

[1429] "Response" refers to the reply from the server to the user, and specifically includes notifications of generated conversation topics and information.

[1430] The present invention is a system that supports communication between users via a communication network, and provides user information registration, acquisition of information on other users, generation of conversation topics, sentiment analysis by an sentiment recognition engine, and personalized responses. Specific embodiments of the present invention are described below.

[1431] 1. User information registration

[1432] The server provides an interface on a web browser or mobile application for users to enter their personal information (name, department, hobbies, etc.). When a user enters this information using a device (PC, smartphone, tablet, etc.) and presses the "Register" button, the device converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint. The server receives this request, parses the JSON data, and extracts the name, department, and hobbies information. This information is stored in a database (e.g., MySQL or PostgreSQL) and the server notifies the user that registration was successful.

[1433] 2. Obtaining other users' information

[1434] To retrieve information about other users, a user sends a request from their device to the server. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. This request is in JSON format. The server receives the request and extracts the user ID from the JSON data. The server then connects to the database, retrieves all other user information from the Users table, processes it into a list format, and sends it back to the device as a JSON response. For example, if user A wants to retrieve information about other employees, the retrieved information will include the names and departments of employees B and C.

[1435] 3. Generating conversation topics

[1436] Users can generate conversation topics by entering the names of conversation participants into their device and pressing the "Generate Topic" button. The device sends a POST request to the server's / api / generate_topics endpoint containing a JSON request with a list of participant names. The server receives the request and extracts the list of participant names from the JSON data. Next, the server uses natural language processing techniques to call an external API (e.g., OpenAI's GPT-3) to generate conversation topics based on the specified participants. The generated topics are stored in a database by the server and then sent back to the device for display to the user. For example, if the name "Hanako Sato" is entered, relevant conversation topics such as "Recently Read Books" and "Recommended Travel Destinations" will be generated.

[1437] 4. Combination of emotional engines

[1438] The present invention further utilizes an emotion recognition engine to recognize the user's emotions and provide personalized responses based on them. When the user inputs text or voice data into a terminal, the terminal sends it to a server. The server sends this data to an emotion recognition engine (e.g., IBM Watson's Tone Analyzer) to analyze the user's emotions. Based on the analyzed emotion information, the server adjusts the conversation topics and responses. For example, if the user inputs "I'm a little tired," topics and advice related to relaxation will be suggested.

[1439] Examples of prompt statements

[1440] The following are specific examples of prompt statements to be input to a generative AI model:

[1441] Please register your user information. This information should include your name, department, and hobbies. For example, please use the following format:

[1442] Name: Taro Yamada

[1443] [Sales Department]

[1444] Hobbies: Reading

[1445] Please use the information above to create and register your profile.

[1446] The flow of the specific processing in Example 2 will be explained using Figure 13.

[1447] User information registration

[1448] Step 1:

[1449] The user enters their name, department, and hobbies into a registration form on a browser or application using their device. Specifically, the user enters "Taro Yamada," "Sales Department," and "Reading" into a text box and then presses the register button.

[1450] Step 2:

[1451] The terminal converts the entered information into JSON format. Input includes the user's name, department, and hobbies (e.g., "Taro Yamada", "Sales Department", "Reading"), and the output generates JSON data like the following:

[1452] json

[1453] {

[1454] "name": "Yamada Taro",

[1455] "department": "Sales Department",

[1456] "hobby": "reading"

[1457] }

[1458] Step 3:

[1459] The device sends the generated JSON data as a POST request to the server's / api / register_user endpoint. Specifically, the device's HTTP client sends the request.

[1460] Step 4:

[1461] The server receives a POST request and extracts user information from the JSON data. The input is data in JSON format, and the output is the user's name, department, and hobbies, which are stored in a table.

[1462] Step 5:

[1463] The server connects to the database and saves user information to the Users table. Specifically, it executes SQL queries to insert the data.

[1464] Step 6:

[1465] The server notifies the terminal that user information registration was successful. The output includes a "Registration successful" message, which the terminal displays to the user.

[1466] Retrieving other user information

[1467] Step 1:

[1468] The user presses the "Generate Profile" button on their device. This action specifically involves the user clicking the button.

[1469] Step 2:

[1470] The terminal generates a JSON request containing the user ID and sends it as a POST request to the server's / api / generate_profile endpoint. The input includes the user ID (e.g., "12345"), and the output generates JSON data similar to the following:

[1471] json

[1472] {

[1473] "user_id": "12345"

[1474] }

[1475] Step 3:

[1476] The server receives a POST request and extracts the user ID from the JSON data. The input is data in JSON format, and the output is the user ID.

[1477] Step 4:

[1478] The server connects to the database and executes a query to retrieve all other user information from the Users table. Specifically, it executes a SELECT statement to retrieve the data.

[1479] Step 5:

[1480] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response. The output will be JSON data like the following:

[1481] json

[1482] [

[1483] {

[1484] "name": "Hanako Sato",

[1485] "department": "Development Department",

[1486] "hobby": "cooking"

[1487] },

[1488] {

[1489] "name": "Ichiro Suzuki",

[1490] "department": "Sales Department",

[1491] "hobby": "golf"

[1492] }

[1493] ]

[1494] Step 6:

[1495] The terminal receives a response from the server and displays user information in list format. Specifically, it displays the data on the user interface.

[1496] Generating conversation topics

[1497] Step 1:

[1498] The user enters the names of the conversation participants into their device and presses the "Generate Topic" button. Specifically, this involves typing "Hanako Sato" into the text box and clicking the button.

[1499] Step 2:

[1500] The terminal generates a JSON request containing a list of participant names and sends it as a POST request to the server's / api / generate_topics endpoint. The input includes participant names (e.g., "Hanako Sato"), and the output generates JSON data similar to the following:

[1501] json

[1502] {

[1503] "participants": ["Hanako Sato"]

[1504] }

[1505] Step 3:

[1506] The server receives a POST request and extracts a list of participant names from the JSON data. The input is data in JSON format, and the output is a list of participant names.

[1507] Step 4:

[1508] The server uses natural language processing techniques to call an external API (e.g., OpenAI's GPT-3) and generates a conversation topic based on the specified participants. Specifically, this involves making an API call and receiving the generated topic.

[1509] Step 5:

[1510] The server saves the generated conversation topic to the database and sends it back to the terminal. The output will be JSON data like the following:

[1511] json

[1512] {

[1513] "Topics": ["Recently read books", "Recommended travel destinations"]

[1514] }

[1515] Step 6:

[1516] The terminal receives a response from the server and displays the generated conversation topic to the user. Specifically, it displays the topic in the user interface.

[1517] Combination of emotional engines

[1518] Step 1:

[1519] The user inputs text or voice data into the device. Specifically, this might involve typing text such as "I'm a little tired" or using voice input.

[1520] Step 2:

[1521] The device sends input data to the server's / api / analyze_emotion endpoint. Input can include text or audio data, and output is data sent to the server.

[1522] Step 3:

[1523] The server sends data to the emotion recognition engine, which analyzes the user's emotions. Specifically, it calls an emotion recognition API (e.g., IBM Watson's Tone Analyzer) to receive the analysis results.

[1524] Step 4:

[1525] The server adjusts the conversation topics and responses based on the analysis results. The output includes topics and advice related to relaxation, resulting in JSON data like the following:

[1526] json

[1527] {

[1528] "adjusted_topics": ["My most relaxing place", "About my recent hobbies"]

[1529] }

[1530] Step 5:

[1531] The terminal receives a response from the server and displays it to the user. Specifically, it displays topics and advice tailored to the user interface.

[1532] (Application Example 2)

[1533] Next, we will explain application example 2. In the following explanation, 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."

[1534] Existing systems lack the functionality to facilitate smooth communication between users, and in particular, face-to-face customer service, they have difficulty appropriately recognizing user emotions and suggesting conversation topics based on those emotions. Furthermore, two-way communication that is attentive to user emotions is essential for improving customer satisfaction and achieving efficient service. Especially in customer service at physical stores, it is necessary for customer service staff to instantly grasp the emotional state of customers and respond appropriately accordingly.

[1535] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the server to utilize natural language processing technology to generate a conversation topic, means for storing the generated conversation topic and returning it to the user, means for analyzing the user's emotions using an emotion recognition engine, and means for adjusting conversation topics and responses based on the emotion analysis results and providing them to the user. This makes it possible to provide appropriate conversation topics based on the user's emotional state and realize more personalized communication.

[1536] "User information" refers to information about a user's personal attributes, such as their name, department, and hobbies, that they have registered about themselves.

[1537] A "server" is a computing system that receives information from users via a network, stores it in a database, and processes the information in cooperation with other services.

[1538] A "database" is a system for efficiently managing, storing, and retrieving data such as user information and conversation topics.

[1539] A "request" is a communication message in which a user asks a server to retrieve or process information.

[1540] "Natural language processing technology" refers to a set of techniques that enable computers to understand and generate human language, utilizing machine learning and data analysis.

[1541] A "conversation topic" is a topic generated to facilitate communication between users.

[1542] An "emotion recognition engine" is software or hardware that analyzes emotions from user input text or voice and recognizes that emotional state.

[1543] "Emotional analysis results" refer to data indicating the user's emotional state, obtained by the emotion recognition engine.

[1544] A "response" is a message that a server provides in response to a user's request, and it includes the conversation topic and other information.

[1545] "Personalized communication" refers to communication delivered in a format optimized for a specific user, based on their individual emotions and attribute information.

[1546] Modes for carrying out the invention

[1547] This invention relates to a system in which a user inputs their own information, a server receives that information, stores it in a database, retrieves information from other users, recognizes the user's emotions, and generates conversation topics based on that. The system has the following main functions: user information registration, retrieval of other users' information, generation of conversation topics, and use of an emotion recognition engine.

[1548] The server first provides an interface for users to enter their information. When a user enters information such as their name, department, and hobbies on their terminal and presses the registration button, the information is converted to JSON format and sent as a POST request to the server endpoint. The server receives the request, extracts the necessary information from the JSON format, and saves it to the "Users" table in the database. If the save is successful, the server sends a registration success message to the user.

[1549] Next, the user sends a request to retrieve information about other users. Specifically, when the user specifies their own ID and sends a request to the server, the server retrieves all other user information from the database, processes it into a list format, and sends it back to the user. This allows the user to easily obtain the profile information of other users.

[1550] Next, when a user creates a conversation topic, they enter the names of other users they wish to talk to, designating them as participants. Based on the specified participants, the server generates a conversation topic using natural language processing techniques. The generated conversation topic is stored in a database and returned to the user. This natural language processing technique can utilize external natural language processing APIs.

[1551] Furthermore, the present invention integrates an emotion recognition engine to analyze emotions from user input text and voice data. The server receives this data and transmits it to the emotion recognition engine. Upon receiving a response from the emotion recognition engine, the server adjusts its response to the user and conversation topics based on the analyzed emotions. For example, if the user is feeling stressed, topics related to relaxation can be suggested.

[1552] As a concrete example, if user A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the registration button, this information is sent to the server and stored in the database. Next, if user A wants to talk to another employee and presses the profile generation button to send a request, the server retrieves information about the other employee from the database and sends it back to user A. Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses a natural language processing API to generate a common topic with "Hanako Sato." As a result, a topic such as "A book you've recently read" is returned to user A. Also, if the sentiment engine recognizes from the text entered by user A that user A is relaxed, the server will suggest a more in-depth conversation topic based on that.

[1553] An example of a prompt to input into the generating AI model could be: "Generate a sample dialogue for a customer service application in a store within a shopping mall."

[1554] In this way, the present invention facilitates communication between employees from different departments and can also be applied to customer service in physical stores. The emotion recognition function provides an even more personalized experience.

[1555] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[1556] Step 1:

[1557] It provides an interface for users to enter their own information. Users enter information such as their name, department, and hobbies, and then press the register button. The entered information is sent from the terminal to the server as a POST request in JSON format.

[1558] Input: User information such as name, department, and hobbies.

[1559] Output: POST request in JSON format

[1560] Step 2:

[1561] The server receives the input information from the user. The server extracts the necessary information (name, department, hobbies, etc.) from the received JSON data and saves it to the "Users" table in the database. If the saving is successful, the server sends a registration success message to the user in JSON format.

[1562] Input: User information in JSON format

[1563] Output: Successful message for saving to database and registration.

[1564] Step 3:

[1565] The user presses a button to send a request to retrieve information about another user. The user specifies their own ID and sends the request. The terminal sends a POST request in JSON format containing this information to the server endpoint.

[1566] Input: Your User ID

[1567] Output: POST request in JSON format

[1568] Step 4:

[1569] The server receives the aforementioned request. The server retrieves all other user information from the database and processes it into a list format. Then, it sends the retrieved user information back to the user as a JSON response.

[1570] Input: Request in JSON format, User ID

[1571] Output: List of other user information, response in JSON format

[1572] Step 5:

[1573] The user interacts with the interface for generating conversation topics. They enter the names of other users who will be participating in the conversation and designate them as participants. The terminal sends a POST request in JSON format containing the list of participant names to the server endpoint.

[1574] Input: List of participant names

[1575] Output: POST request in JSON format

[1576] Step 6:

[1577] The server receives the aforementioned request. The server calls an external API to generate a conversation topic using natural language processing technology. This API call generates a conversation topic based on the specified participants. The generated conversation topic is stored in the "Conversations" table in the database and returned to the user as a JSON response.

[1578] Input: Participant information in JSON format

[1579] Output: Save to database, JSON response of the generated conversation topic

[1580] Step 7:

[1581] The system performs emotion recognition using user-input text or audio data. The device sends the input text or audio data to the server as a POST request in JSON format.

[1582] Input: Text or audio data

[1583] Output: POST request in JSON format

[1584] Step 8:

[1585] The server receives the text and audio data. The server sends the data to the emotion recognition engine and receives the analysis results. Based on the emotion recognition results, the server adjusts the conversation topics and responses to be appropriate and provides them to the user.

[1586] Input: Text or audio data in JSON format

[1587] Output: Emotion recognition results, adjusted response

[1588] In this way, each step of the present invention realizes a series of processes from user information registration to emotion recognition, and then generating and providing an appropriate response.

[1589] The specific processing unit 290 transmits the result of the specific processing to the headset terminal 314. In the headset terminal 314, the control unit 46A causes the speaker 240 and display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[1590] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1591] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and specific processing may also be performed by the headset terminal 314.

[1592] [Fourth Embodiment]

[1593] Figure 7 shows an example of the configuration of the data processing system 410 according to the fourth embodiment.

[1594] As shown in Figure 7, the 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.

[1595] The data processing device 12 comprises a computer 22, a database 24, and a communication interface 26. The computer 22 is an example of a "computer" related to the technology of this disclosure. The computer 22 comprises a processor 28, RAM 30, and storage 32. The processor 28, RAM 30, and storage 32 are connected to a bus 34. The database 24 and the communication interface 26 are also connected to the bus 34. The communication interface 26 is connected to a network 54. An example of the network 54 is a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1596] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication interface 44, and a controlled object 443. The computer 36 includes a processor 46, RAM 48, and storage 50. The processor 46, RAM 48, and storage 50 are connected to a bus 52. The microphone 238, speaker 240, camera 42, and controlled object 443 are also connected to the bus 52.

[1597] The microphone 238 receives voice signals from the user 20 and receives instructions from the user 20. The microphone 238 captures the voice signals from the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio according to the instructions from the processor 46.

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

[1599] Communication interface 44 is connected to network 54. Communication interfaces 44 and 26 are responsible for the exchange of various information between processor 46 and processor 28 via network 54. The exchange of various information between processor 46 and processor 28 using communication interfaces 44 and 26 is performed in a secure manner.

[1600] The controlled object 443 includes a display device, LEDs in the eyes, and motors that drive 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 robot 414's emotions can be expressed by controlling these motors. Furthermore, the robot 414's facial expressions can also be expressed by controlling the illumination state of the LEDs in its eyes.

[1601] Figure 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Figure 8, the data processing device 12 performs specific processing using the processor 28. The storage 32 stores the specific processing program 56.

[1602] The specific processing program 56 is an example of a "program" relating to the technology of this 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.

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

[1604] In robot 414, the processor 46 performs the reception output processing. The storage 50 stores the reception output program 60. 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 processing is realized by the processor 46 operating as a control unit 46A according to the reception output program 60 executed on the RAM 48.

[1605] Next, the specific processing performed by the specific processing unit 290 of the data processing device 12 will be described. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1606] This invention is a system in which a user inputs their own information, retrieves information from other users, and generates conversation topics. This system performs user information registration, retrieves other users' profiles, and generates conversation topics using natural language processing technology.

[1607] 1. User information registration

[1608] The server provides an interface for the user to enter their information (name, department, hobbies, etc.). When the terminal enters this information and presses the "Register" button, the terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[1609] The server receives this request and extracts the name, department, and hobby information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. After saving, the server notifies the terminal that the user registration was successful.

[1610] 2. Obtaining other users' information

[1611] A user sends a request from their device to retrieve information about other users. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device uses JSON format for this request.

[1612] The server receives this request and extracts the user ID from the JSON format. The server connects to the database and executes a query to retrieve all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the terminal as a JSON response. This allows the user to retrieve the profile information of other employees.

[1613] 3. Generating conversation topics

[1614] To generate a conversation topic, the user enters the names of other employees and presses the "Generate Topic" button. The terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint.

[1615] The server receives this request and extracts a list of participant names from the JSON format. Next, the server uses natural language processing techniques to call the GPT API to generate a conversation topic. This API call generates a conversation topic based on the participant attribute information.

[1616] The generated conversation topics are stored in a database by the server and then sent back to the terminal. The terminal displays the received conversation topics to the user, allowing the user to easily start a conversation.

[1617] Specific example

[1618] For example, suppose User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, User A wants to talk to other employees and presses the profile generation button to send a request. The server retrieves information about other employees from the database and sends it back to User A.

[1619] Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to user A.

[1620] In this way, the present invention promotes communication among employees from different departments and makes meetings and lunch breaks more meaningful.

[1621] The following describes the processing flow.

[1622] Understood. Below, I will explain the program's processing in detail, step by step.

[1623] 1. User information registration

[1624] Step 1:

[1625] The user enters their information (name, department, hobbies) into the input form and presses the "Register" button.

[1626] Step 2:

[1627] The terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[1628] Step 3:

[1629] The server receives the request and extracts information such as name, department, and hobbies from the JSON format.

[1630] Step 4:

[1631] The server connects to the database and saves the extracted user information to the Users table.

[1632] Step 5:

[1633] The server sends a message to the terminal in JSON format confirming that the user registration was successful.

[1634] Step 6:

[1635] The terminal receives a response from the server and displays a registration completion message to the user.

[1636] 2. Obtaining other users' information

[1637] Step 1:

[1638] The user presses the "Generate Profile" or "View Other Employees" button, specifies their user ID, and sends a request from their device.

[1639] Step 2:

[1640] The device sends a request in JSON format containing the user ID as a POST request to the server's / api / generate_profile endpoint.

[1641] Step 3:

[1642] The server receives the request and extracts the user ID from the JSON format.

[1643] Step 4:

[1644] The server connects to the database and executes a query to retrieve all other user information from the Users table.

[1645] Step 5:

[1646] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response.

[1647] Step 6:

[1648] The terminal receives a response from the server and displays other users' information on the screen.

[1649] 3. Generating conversation topics

[1650] Step 1:

[1651] The user enters the name of another employee and presses the "Generate Topic" button.

[1652] Step 2:

[1653] The device sends a JSON-formatted request containing a list of participant names as a POST request to the server's / api / generate_topics endpoint.

[1654] Step 3:

[1655] The server receives the request and extracts a list of participant names from the JSON format.

[1656] Step 4:

[1657] The server uses natural language processing technology to call an external natural language processing API and generate conversation topics based on the specified participants.

[1658] Step 5:

[1659] The server saves the generated conversation topics to the Conversations table in the database.

[1660] Step 6:

[1661] The server returns the generated conversation topic to the terminal in JSON format.

[1662] Step 7:

[1663] The terminal receives a response from the server and displays the generated conversation topic to the user.

[1664] This processing flow allows users to easily input their own information, retrieve information about other employees, and find common topics of conversation. This system is a concrete implementation aimed at promoting communication between employees from different departments and making meetings and lunch breaks more productive.

[1665] (Example 1)

[1666] Next, we will describe Example 1. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1667] In conventional communication support systems, it has been difficult for employees from different departments to efficiently share information and find common conversation topics. This has reduced opportunities to build new relationships and hindered information sharing and the establishment of collaborative relationships within companies. The present invention aims to solve these problems and provide a system that facilitates communication within companies.

[1668] The identification process performed by the identification processing unit 290 of the data processing device 12 in Example 1 is realized by the following means.

[1669] In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the user to input the names of other users and send a request to generate a conversation topic, means for the server to utilize natural language processing technology to generate a conversation topic, means for storing the generated conversation topic and returning it to the user, and means for a terminal to display the generated conversation topic. This makes it possible for employees from different departments to efficiently find common conversation topics and communicate smoothly with each other.

[1670] A "user" refers to an end-user who inputs their own information into the system, retrieves information from other users, and generates conversation topics.

[1671] A "server" refers to a central computer system that receives information from users, stores it in a database, processes the data in response to requests, and generates and sends back conversation topics.

[1672] A "terminal" refers to a computer device (such as a PC or smartphone) that a user uses to input information, send requests, and receive responses.

[1673] A "database" refers to a data storage system used to store user information and generated conversation topics.

[1674] A "request" refers to a communication message from a user or device that requests information from a server for processing or acquisition.

[1675] "API" stands for Application Programming Interface, and refers to a set of protocols and tools for accessing external services and databases.

[1676] "Natural language processing technology" refers to all technologies used to understand and process human language using computers, including technologies such as text generation and topic extraction.

[1677] A "conversation topic" refers to a subject or theme that helps users to start a conversation smoothly with each other.

[1678] "Attribute information" refers to basic information about the user (such as name, department, and hobbies).

[1679] "Generation" refers to the process by which a system creates new data or information.

[1680] This invention is a system in which a user inputs their own information, retrieves information from other users, and generates conversation topics. This system performs user information registration, retrieves other users' profiles, and generates conversation topics using natural language processing technology. Specifically, it is implemented as follows:

[1681] Hardware and software used

[1682] The server functions as a central processing unit, handling all data processing and information storage / retrieval described later. The server is equipped with a database (selectable between SQL and NoSQL databases) and APIs for implementing natural language processing technologies (e.g., the GPT API).

[1683] The device is the interface with the user and is designed as a web application or mobile application.

[1684] The user operates the terminal to input and retrieve information and sends a conversation topic generation request.

[1685] User information registration

[1686] The server provides an interface for users to enter their information (e.g., name, department, hobbies, etc.). The user enters the information into a form on the terminal and presses the "Register" button. The terminal converts this information into JSON format and sends a POST request to the server's / api / register_user endpoint. The server receives this request and extracts the name, department, and hobbies from the received data. The server then connects to the database and saves this information to the Users table. Once the saving is complete, the server sends a message back to the terminal indicating successful registration.

[1687] Retrieving other user information

[1688] When a user wants to retrieve information about other users, they send a request from their device. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device structures this request in JSON format. The server receives the request and extracts the user ID. The server connects to the database and retrieves all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the device as a JSON response. This allows the user to retrieve the profile information of other employees.

[1689] Generating conversation topics

[1690] The user generates a conversation topic to find common ground for talking with other employees. When the user enters the names of other employees and presses the "Generate Topic" button, the terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint. The server receives this request and extracts the list of participants' names. The server then uses natural language processing techniques (e.g., the GPT API) to generate a conversation topic. This API call generates a conversation topic based on the participants' attribute information. The generated conversation topic is saved to a database by the server and then sent back to the terminal. The terminal displays this information to the user.

[1691] Specific example

[1692] For example, User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, if User A wants to talk to another employee, they press the profile generation button to send a request. The server retrieves information about the other employee from the database and sends it back to User A. Furthermore, if User A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to User A. In this way, communication between employees from different departments is facilitated, making meetings and lunch breaks more meaningful.

[1693] Example of a prompt

[1694] The following are examples of prompts to input into a generative AI model to generate conversation topics:

[1695] User Information: Name: Taro Yamada, Department: Sales Department, Hobbies: Reading

[1696] Contact information: Name: Hanako Sato, Department: Planning Department, Hobby: Calligraphy

[1697] Please create a topic that will be a common subject of discussion among these users.

[1698] The flow of the specific processing in Example 1 will be explained using Figure 11.

[1699] User information registration

[1700] Step 1:

[1701] Summary: The user enters their own information.

[1702] Specific actions:

[1703] The user enters their "name," "department," and "hobbies" into the input form on their device.

[1704] Input: Information entered by the user in the input form (e.g., Name = Taro Yamada, Department = Sales Department, Hobby = Reading)

[1705] Output: User information displayed in the input form

[1706] Step 2:

[1707] Summary: The terminal converts the input information into JSON format and sends it to the server.

[1708] Specific actions:

[1709] The user presses the "Register" button. The device creates JSON data like the following and sends a POST request to the server's / api / register_user endpoint.

[1710] json

[1711] {

[1712] "Name": "Yamada Taro",

[1713] " [": "Sales Department"

[1714] "Hobbies": "Reading"

[1715] }

[1716] Input: User presses the "Register" button.

[1717] Output: Request data in JSON format

[1718] Step 3:

[1719] Summary: The server processes the received JSON data and saves the information to the database.

[1720] Specific actions:

[1721] The server receives the POST request and extracts the name, department, and hobbies from the JSON data. Using the extracted data, it executes the following SQL query on the database.

[1722] SQL

[1723] INSERT INTO Users (Name, Department, Hobby) VALUES ('Taro Yamada', 'Sales Department', 'Reading');

[1724] Input: User information in JSON format

[1725] Output: User information stored in the database

[1726] Step 4:

[1727] Summary: The server notifies the terminal that the information registration was successful.

[1728] Specific actions:

[1729] The server sends the following JSON response back to the terminal.

[1730] json

[1731] {

[1732] "status": "success",

[1733] "message": "User information has been registered."

[1734] }

[1735] Input: The result of the information being correctly saved in the database.

[1736] Output: JSON response of success message

[1737] Retrieving other user information

[1738] Step 1:

[1739] Summary: A user sends a request from their device to retrieve information about other users.

[1740] Specific actions:

[1741] The user clicks the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint.

[1742] json

[1743] {

[1744] "user_id": "1"

[1745] }

[1746] Input: User clicks the "Generate Profile" button and enters the user ID.

[1747] Output: Request data in JSON format

[1748] Step 2:

[1749] Summary: The server receives a request and retrieves other user information based on the user ID.

[1750] Specific actions:

[1751] The server receives the POST request and extracts the user ID from the JSON data. The server then executes the following SQL query on the database.

[1752] SQL

[1753] SELECT FROM Users WHERE user_id != '1';

[1754] Input: Request data in JSON format and User ID

[1755] Output: Other user information retrieved from the database

[1756] Step 3:

[1757] Summary: The server processes the acquired user information into a list format and sends it back to the terminal.

[1758] Specific actions:

[1759] The server converts the user information it has retrieved into response data in JSON format.

[1760] json

[1761] [

[1762] {

[1763] "Name": "Hanako Sato",

[1764] "Department": "Planning Department",

[1765] "Hobbies": "Calligraphy"

[1766] },

[1767] / / Other user information

[1768] ]

[1769] Input: User information retrieved from the database

[1770] Output: Response data in JSON format

[1771] Generating conversation topics

[1772] Step 1:

[1773] Summary: The user sends a request from their device to generate a conversation topic.

[1774] Specific actions:

[1775] The user enters the names of other employees to generate a conversation topic and presses the "Generate Topic" button. The terminal sends JSON data like the following as a POST request to the server's / api / generate_topics endpoint.

[1776] json

[1777] {

[1778] "Participants": ["Taro Yamada", "Hanako Sato"]

[1779] }

[1780] Input: User presses the "Generate Topic" button and enters a list of participant names.

[1781] Output: Request data in JSON format

[1782] Step 2:

[1783] Summary: The server receives the request and generates a conversation topic from the participants' names.

[1784] Specific actions:

[1785] The server receives the POST request and extracts a list of participant names from the JSON data. The server then sends the generated prompt to the GPT API.

[1786] User Information: Name: Taro Yamada, Department: Sales Department, Hobbies: Reading

[1787] Contact information: Name: Hanako Sato, Department: Planning Department, Hobby: Calligraphy

[1788] Please create a topic that will be a common subject of discussion among these users.

[1789] Input: Request data in JSON format and a list of participant names.

[1790] Output: Prompt message to the GPT API

[1791] Step 3:

[1792] Summary: The server receives the generated conversation topic and saves it to the database.

[1793] Specific actions:

[1794] The server receives a conversation topic generated from the GPT API and saves it to the database by executing an SQL query like the following:

[1795] SQL

[1796] INSERT INTO Topics (topic) VALUES ('About a book I recently read');

[1797] Input: Conversation topic generated from the GPT API

[1798] Output: Conversation topics stored in the database

[1799] Step 4:

[1800] Summary: The server sends the generated conversation topic back to the terminal and displays it to the user.

[1801] Specific actions:

[1802] The server sends the following JSON response back to the terminal.

[1803] json

[1804] {

[1805] "topics": ["About books I've recently read"]

[1806] }

[1807] The device displays the conversation topics it has received on the screen, allowing the user to review them.

[1808] Input: Conversation topics stored in the database

[1809] Output: Response data in JSON format and screen display

[1810] The above describes the specific processing steps, the inputs and outputs of each step, and the specific operations.

[1811] (Application Example 1)

[1812] Next, we will explain Application Example 1. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1813] In modern brick-and-mortar stores, a lack of communication among employees and between employees and customers is a cause of decreased customer satisfaction and reduced operational efficiency. Finding common ground is particularly difficult for employees from different departments, and for staff and customers meeting for the first time, making smooth conversation challenging. Furthermore, manually gathering common topics and profile information is time-consuming, highlighting the need for automated systems.

[1814] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Application Example 1 is realized by the following means.

[1815] In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the server to use natural language processing technology and a generative AI model to generate conversation topics, and means for the server to store the generated conversation topics and return them to the user. This facilitates communication between employees and customers, enabling improvements in work efficiency and customer satisfaction.

[1816] A "user" is an individual who uses the system to input their own information and retrieve information and conversation topics from other users.

[1817] A "server" is a device or system that receives user input information, stores it in a database, retrieves and returns information from other users, and uses natural language processing technology to generate conversation topics.

[1818] A "database" is a digital storage system used to store and manage system-related information, such as user input and generated conversation topics.

[1819] A "request" is an instruction that a user sends to a server to ask the system to retrieve other users' information or to generate conversation topics.

[1820] Natural language processing (NLP) is a computer technology used to understand and generate human language. Its primary applications include text analysis, language modeling, and dialogue generation.

[1821] A "generative AI model" is an artificial intelligence model used to generate conversation topics based on user attribute information.

[1822] A "prompt sentence" is a text sentence that a generative AI model uses as input when generating conversation topics.

[1823] To implement this invention, it is necessary to build a system in which a user inputs their own information using a smartphone app, retrieves other users' profiles, and generates conversation topics. In this system, a server, a database, and a generative AI model using natural language processing technology play important roles. A specific example is shown below.

[1824] 1. User information registration

[1825] First, the user enters their information (name, department, hobbies, etc.) through the smartphone app interface. The entered information is converted to JSON format and sent from the device as a POST request to the server's / api / register_user endpoint. The server receives this request and extracts the information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. This registers the user information in the database.

[1826] 2. Obtaining other users' information

[1827] To retrieve information about other users, users send requests using a smartphone app. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. This request is also in JSON format. The server receives the request and extracts the user ID. The server connects to the database and executes a query to retrieve all other user information from the Users table. The retrieved user information is then processed into a list format and sent back to the device as a JSON response. This allows the user to retrieve the profile information of other employees.

[1828] 3. Generating conversation topics

[1829] Users request the generation of conversation topics to create common topics to talk about with other users within the app. For example, if a user wants to talk to "Hanako Sato," they enter the name and press the "Generate Topic" button. The device sends a POST request to the server's / api / generate_topics endpoint containing a JSON request with a list of participants' names. The server receives this request and extracts the list of participants' names from the JSON. Next, the server uses natural language processing techniques to call a generative AI model (e.g., GPT-3) to generate a conversation topic. This API call generates a conversation topic based on the participants' attribute information. The generated conversation topic is saved to a database by the server and then sent back to the device. Users can view the received conversation topic through the app and easily start a conversation.

[1830] Hardware and software to be used

[1831] Hardware:

[1832] Smartphone: Provides a user interface and is used for inputting and displaying information.

[1833] Server: Used for receiving and processing requests, managing data, and calling generated AI models.

[1834] software:

[1835] Flask: A server-side web framework used for defining endpoints and processing requests.

[1836] SQLite: Used as a database management system to store user information and generated conversation topics.

[1837] OpenAI API: Used for generating conversation topics using natural language processing technology.

[1838] Examples of specific cases and prompt statements

[1839] For example, suppose user A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, if user A wants to talk to another employee, they press the profile generation button to send a request. The server retrieves information about the other employee from the database and sends it back to user A. Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate common topics with "Hanako Sato." As a result, topics such as "Recent topics related to cooking and travel" are returned to user A.

[1840] Example of a prompt:

[1841] Please generate conversation topics about the following people: Taro Yamada, Hanako Sato

[1842] The flow of a specific process in Application Example 1 will be explained using Figure 12.

[1843] Step 1:

[1844] The user opens the smartphone app and enters their personal information (name, department, hobbies, etc.). The entered information is converted to JSON format on the device and sent as a POST request to the server's / api / register_user endpoint. In this process, the input is the user's information, and the output is data in JSON format.

[1845] Step 2:

[1846] The server receives the aforementioned request. It extracts name, department, and hobby information from the received data and connects to the database. It executes an SQL query to save the extracted information to the Users table. The input to this process is user information in JSON format, and the output is the user information stored in the database.

[1847] Step 3:

[1848] To retrieve information about other users, the user presses the "Generate Profile" button within the smartphone app. This causes the device to POST a JSON-formatted request containing the user ID to the server's / api / generate_profile endpoint. The input is the user ID, and the output is the corresponding JSON-formatted request.

[1849] Step 4:

[1850] The server receives the request and extracts the user ID. Next, the server connects to the database and executes a query to retrieve all other user information from the Users table. The retrieved user information is processed into a list format in a JSON response and sent back to the terminal. The input to this process is a request containing the user ID, and the output is a JSON response containing the retrieved other user information.

[1851] Step 5:

[1852] To generate common topics for conversation with other users within the app, the user requests the generation of a conversation topic. The user presses the "Generate Topic" button and enters a list of participants' names. The device then POSTs a JSON request containing this list to the server's / api / generate_topics endpoint. The input is a list of participants' names, and the output is a JSON request sent to the server.

[1853] Step 6:

[1854] The server receives the request and extracts a list of participants' names from the JSON format. Next, the server uses natural language processing techniques to call a generative AI model (e.g., GPT-3) and generates a conversation topic using prompt sentences. The input to this process is prompt sentences containing the list of participants' names, and the output is the generated conversation topic.

[1855] Step 7:

[1856] The server saves the generated conversation topic to a database. The saved conversation topic is then processed again into JSON format and sent back to the device. The user checks the generated conversation topic through a smartphone app. The input to this process is the generated conversation topic, and the output is the conversation topic sent back to the device as a JSON response.

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

[1858] This invention is a system in which a user inputs their own information, retrieves information from other users, generates conversation topics, and further recognizes the user's emotions using an emotion engine, adjusting responses accordingly. This system involves registering user information, retrieving profiles of other users, generating conversation topics using natural language processing technology, and performing emotion recognition using an emotion engine.

[1859] 1. User information registration

[1860] The server provides an interface for the user to enter their information (name, department, hobbies, etc.). When the terminal enters this information and presses the "Register" button, the terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[1861] The server receives this request and extracts the name, department, and hobby information from the JSON format. Next, the server connects to the database and saves the extracted user information to the Users table. After saving, the server notifies the terminal that the user registration was successful.

[1862] 2. Obtaining other users' information

[1863] A user sends a request from their device to retrieve information about other users. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. The device uses JSON format for this request.

[1864] The server receives this request and extracts the user ID from the JSON format. The server connects to the database and executes a query to retrieve all other user information from the Users table. Then, it processes the retrieved user information into a list format and sends it back to the terminal as a JSON response. This allows the user to retrieve the profile information of other employees.

[1865] 3. Generating conversation topics

[1866] To generate a conversation topic, the user enters the names of other employees and presses the "Generate Topic" button. The terminal sends a JSON request containing the list of participants' names as a POST request to the server's / api / generate_topics endpoint.

[1867] The server receives this request and extracts a list of participant names from the JSON format. Next, the server uses natural language processing techniques to call an external natural language processing API to generate a conversation topic based on the specified participants. This API call generates a conversation topic based on the participants' attribute information.

[1868] The generated conversation topics are saved by the server to the Conversations table in the database and then sent back to the terminal. The terminal displays the received conversation topics to the user, allowing the user to easily start a conversation.

[1869] 4. Combination of emotional engines

[1870] The present invention further incorporates an emotion engine to recognize the user's emotions. The server receives text and voice data entered by the user and transmits this data to the emotion recognition engine. The server receives a response from the emotion recognition engine and analyzes the user's emotions.

[1871] Based on the analyzed emotions, the server adjusts its responses to the user and the conversation topics. For example, if the emotion engine detects that the user is stressed, the server can suggest topics related to relaxation.

[1872] Specific example

[1873] For example, suppose User A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the register button. This information is sent to the server and stored in the database. Next, User A wants to talk to other employees and presses the profile generation button to send a request. The server retrieves information about other employees from the database and sends it back to User A.

[1874] Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses the GPT API to generate a common topic with "Hanako Sato." As a result, a topic such as "Recently read books" is returned to user A.

[1875] Furthermore, if the emotion engine recognizes from the text entered by User A that User A is relaxed, the server will suggest more in-depth conversation topics based on that.

[1876] In this way, the present invention not only facilitates communication between employees from different departments and makes meetings and lunch breaks more meaningful, but also provides a more personalized experience through its emotion recognition function.

[1877] The following describes the processing flow.

[1878] Understood. Below, I will explain the processing flow of the invention that incorporates the emotion engine, broken down into specific steps.

[1879] 1. User information registration

[1880] Step 1:

[1881] The user enters their information (name, department, hobbies) into the input form and presses the "Register" button.

[1882] Step 2:

[1883] The terminal converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint.

[1884] Step 3:

[1885] The server receives the request and extracts information such as name, department, and hobbies from the JSON format.

[1886] Step 4:

[1887] The server connects to the database and saves the extracted user information to the Users table.

[1888] Step 5:

[1889] The server sends a message to the terminal in JSON format confirming that the user registration was successful.

[1890] Step 6:

[1891] The terminal receives a response from the server and displays a registration completion message to the user.

[1892] 2. Obtaining other users' information

[1893] Step 1:

[1894] The user presses the "Generate Profile" or "View Other Employees" button, specifies their user ID, and sends a request from their device.

[1895] Step 2:

[1896] The device sends a request in JSON format containing the user ID as a POST request to the server's / api / generate_profile endpoint.

[1897] Step 3:

[1898] The server receives the request and extracts the user ID from the JSON format.

[1899] Step 4:

[1900] The server connects to the database and executes a query to retrieve all other user information from the Users table.

[1901] Step 5:

[1902] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response.

[1903] Step 6:

[1904] The terminal receives a response from the server and displays other users' information on the screen.

[1905] 3. Generating conversation topics

[1906] Step 1:

[1907] The user enters the name of another employee and presses the "Generate Topic" button.

[1908] Step 2:

[1909] The device sends a JSON-formatted request containing a list of participant names as a POST request to the server's / api / generate_topics endpoint.

[1910] Step 3:

[1911] The server receives the request and extracts a list of participant names from the JSON format.

[1912] Step 4:

[1913] The server uses natural language processing technology to call an external natural language processing API and generate conversation topics based on the specified participants.

[1914] Step 5:

[1915] The server saves the generated conversation topics to the Conversations table in the database.

[1916] Step 6:

[1917] The server returns the generated conversation topic to the terminal in JSON format.

[1918] Step 7:

[1919] The terminal receives a response from the server and displays the generated conversation topic to the user.

[1920] 4. Emotion recognition by an emotion engine

[1921] Step 1:

[1922] The user enters their information via text or voice.

[1923] Step 2:

[1924] The device sends the entered text or voice data to the server.

[1925] Step 3:

[1926] The server sends the received data to the emotion engine for emotion recognition.

[1927] Step 4:

[1928] The emotion engine analyzes the user's emotions from the input data and sends the analysis results back to the server.

[1929] Step 5:

[1930] The server adjusts its responses to the user and conversation topics based on the sentiment information it receives from the sentiment engine.

[1931] Step 6:

[1932] For example, if the server detects that a user is feeling stressed, it will suggest topics related to relaxation.

[1933] Step 7:

[1934] The server returns the adjusted response and conversation topic to the terminal in JSON format.

[1935] Step 8:

[1936] The terminal receives a response from the server and displays appropriate information to the user.

[1937] This processing flow allows users to easily input their own information, retrieve information about other employees, and find common topics of conversation. Furthermore, by utilizing the emotion engine, personalized responses and conversation topics are provided that are tailored to the user's emotions, making communication even smoother.

[1938] (Example 2)

[1939] Next, we will describe Example 2. In the following description, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[1940] Traditional communication support systems lacked the functionality to efficiently retrieve information about other users and generate appropriate conversation topics. Furthermore, they struggled to provide personalized conversation topics that took users' emotions into account. As a result, communication between employees in different departments was not smooth, leading to a decline in the quality of communication within the company.

[1941] The specific processing performed by the specific processing unit 290 of the data processing device 12 in Example 2 is realized by the following means. In this invention, the server includes means for the user to input their own information, means for the user to send a request to obtain information of other users, means for generating conversation topics using natural language processing technology, means for analyzing the user's emotions using an emotion recognition engine, and means for adjusting conversation topics and responses based on the analyzed emotions. As a result, the user can efficiently obtain information of other users, generate appropriate conversation topics, and further enable personalized communication that takes emotions into consideration.

[1942] A "user" refers to an individual who uses a system to input or retrieve information.

[1943] A "server" refers to a computer system that receives requests from users, processes the data, and sends it back.

[1944] A "database" refers to a system that systematically stores and manages data such as user information and generated conversation topics.

[1945] A "request" refers to a request made by a user to a server for the retrieval or processing of information.

[1946] "Natural language processing technology" refers to algorithms and models that enable computers to understand and generate human language.

[1947] An "external API" refers to a programmatic interface used to retrieve and manipulate data in conjunction with other systems and services.

[1948] An "emotion recognition engine" refers to software that analyzes and recognizes emotions from user input data.

[1949] A "conversation topic" refers to a topic generated by the system to facilitate communication between users.

[1950] "Attribute information" refers to information specific to a user, such as their name, department, and hobbies.

[1951] "Analysis results" refer to the data obtained as a result of the emotion recognition engine analyzing the user's emotions.

[1952] "Response" refers to the reply from the server to the user, and specifically includes notifications of generated conversation topics and information.

[1953] The present invention is a system that supports communication between users via a communication network, and provides user information registration, acquisition of information on other users, generation of conversation topics, sentiment analysis by an sentiment recognition engine, and personalized responses. Specific embodiments of the present invention are described below.

[1954] 1. User information registration

[1955] The server provides an interface on a web browser or mobile application for users to enter their personal information (name, department, hobbies, etc.). When a user enters this information using a device (PC, smartphone, tablet, etc.) and presses the "Register" button, the device converts the entered information into JSON format and sends a POST request to the server's / api / register_user endpoint. The server receives this request, parses the JSON data, and extracts the name, department, and hobbies information. This information is stored in a database (e.g., MySQL or PostgreSQL) and the server notifies the user that registration was successful.

[1956] 2. Obtaining other users' information

[1957] To retrieve information about other users, a user sends a request from their device to the server. Specifically, the user presses the "Generate Profile" button, specifies their user ID, and sends a POST request to the server's / api / generate_profile endpoint. This request is in JSON format. The server receives the request and extracts the user ID from the JSON data. The server then connects to the database, retrieves all other user information from the Users table, processes it into a list format, and sends it back to the device as a JSON response. For example, if user A wants to retrieve information about other employees, the retrieved information will include the names and departments of employees B and C.

[1958] 3. Generating conversation topics

[1959] Users can generate conversation topics by entering the names of conversation participants into their device and pressing the "Generate Topic" button. The device sends a POST request to the server's / api / generate_topics endpoint containing a JSON request with a list of participant names. The server receives the request and extracts the list of participant names from the JSON data. Next, the server uses natural language processing techniques to call an external API (e.g., OpenAI's GPT-3) to generate conversation topics based on the specified participants. The generated topics are stored in a database by the server and then sent back to the device for display to the user. For example, if the name "Hanako Sato" is entered, relevant conversation topics such as "Recently Read Books" and "Recommended Travel Destinations" will be generated.

[1960] 4. Combination of emotional engines

[1961] The present invention further utilizes an emotion recognition engine to recognize the user's emotions and provide personalized responses based on them. When the user inputs text or voice data into a terminal, the terminal sends it to a server. The server sends this data to an emotion recognition engine (e.g., IBM Watson's Tone Analyzer) to analyze the user's emotions. Based on the analyzed emotion information, the server adjusts the conversation topics and responses. For example, if the user inputs "I'm a little tired," topics and advice related to relaxation will be suggested.

[1962] Examples of prompt statements

[1963] The following are specific examples of prompt statements to be input to a generative AI model:

[1964] Please register your user information. This information should include your name, department, and hobbies. For example, please use the following format:

[1965] Name: Taro Yamada

[1966] [Sales Department]

[1967] Hobbies: Reading

[1968] Please use the information above to create and register your profile.

[1969] The flow of the specific processing in Example 2 will be explained using Figure 13.

[1970] User information registration

[1971] Step 1:

[1972] The user enters their name, department, and hobbies into a registration form on a browser or application using their device. Specifically, the user enters "Taro Yamada," "Sales Department," and "Reading" into a text box and then presses the register button.

[1973] Step 2:

[1974] The terminal converts the entered information into JSON format. Input includes the user's name, department, and hobbies (e.g., "Taro Yamada", "Sales Department", "Reading"), and the output generates JSON data like the following:

[1975] json

[1976] {

[1977] "name": "Yamada Taro",

[1978] "department": "Sales Department",

[1979] "hobby": "reading"

[1980] }

[1981] Step 3:

[1982] The device sends the generated JSON data as a POST request to the server's / api / register_user endpoint. Specifically, the device's HTTP client sends the request.

[1983] Step 4:

[1984] The server receives a POST request and extracts user information from the JSON data. The input is data in JSON format, and the output is the user's name, department, and hobbies, which are stored in a table.

[1985] Step 5:

[1986] The server connects to the database and saves user information to the Users table. Specifically, it executes SQL queries to insert the data.

[1987] Step 6:

[1988] The server notifies the terminal that user information registration was successful. The output includes a "Registration successful" message, which the terminal displays to the user.

[1989] Retrieving other user information

[1990] Step 1:

[1991] The user presses the "Generate Profile" button on their device. This action specifically involves the user clicking the button.

[1992] Step 2:

[1993] The terminal generates a JSON request containing the user ID and sends it as a POST request to the server's / api / generate_profile endpoint. The input includes the user ID (e.g., "12345"), and the output generates JSON data similar to the following:

[1994] json

[1995] {

[1996] "user_id": "12345"

[1997] }

[1998] Step 3:

[1999] The server receives a POST request and extracts the user ID from the JSON data. The input is data in JSON format, and the output is the user ID.

[2000] Step 4:

[2001] The server connects to the database and executes a query to retrieve all other user information from the Users table. Specifically, it executes a SELECT statement to retrieve the data.

[2002] Step 5:

[2003] The server processes the acquired user information into a list format and sends it back to the terminal as a JSON response. The output will be JSON data like the following:

[2004] json

[2005] [

[2006] {

[2007] "name": "Hanako Sato",

[2008] "department": "Development Department",

[2009] "hobby": "cooking"

[2010] },

[2011] {

[2012] "name": "Ichiro Suzuki",

[2013] "department": "Sales Department",

[2014] "hobby": "golf"

[2015] }

[2016] ]

[2017] Step 6:

[2018] The terminal receives a response from the server and displays user information in list format. Specifically, it displays the data on the user interface.

[2019] Generating conversation topics

[2020] Step 1:

[2021] The user enters the names of the conversation participants into their device and presses the "Generate Topic" button. Specifically, this involves typing "Hanako Sato" into the text box and clicking the button.

[2022] Step 2:

[2023] The terminal generates a JSON request containing a list of participant names and sends it as a POST request to the server's / api / generate_topics endpoint. The input includes participant names (e.g., "Hanako Sato"), and the output generates JSON data similar to the following:

[2024] json

[2025] {

[2026] "participants": ["Hanako Sato"]

[2027] }

[2028] Step 3:

[2029] The server receives a POST request and extracts a list of participant names from the JSON data. The input is data in JSON format, and the output is a list of participant names.

[2030] Step 4:

[2031] The server uses natural language processing techniques to call an external API (e.g., OpenAI's GPT-3) and generates a conversation topic based on the specified participants. Specifically, this involves making an API call and receiving the generated topic.

[2032] Step 5:

[2033] The server saves the generated conversation topic to the database and sends it back to the terminal. The output will be JSON data like the following:

[2034] json

[2035] {

[2036] "Topics": ["Recently read books", "Recommended travel destinations"]

[2037] }

[2038] Step 6:

[2039] The terminal receives a response from the server and displays the generated conversation topic to the user. Specifically, it displays the topic in the user interface.

[2040] Combination of emotional engines

[2041] Step 1:

[2042] The user inputs text or voice data into the device. Specifically, this might involve typing text such as "I'm a little tired" or using voice input.

[2043] Step 2:

[2044] The device sends input data to the server's / api / analyze_emotion endpoint. Input can include text or audio data, and output is data sent to the server.

[2045] Step 3:

[2046] The server sends data to the emotion recognition engine, which analyzes the user's emotions. Specifically, it calls an emotion recognition API (e.g., IBM Watson's Tone Analyzer) to receive the analysis results.

[2047] Step 4:

[2048] The server adjusts the conversation topics and responses based on the analysis results. The output includes topics and advice related to relaxation, resulting in JSON data like the following:

[2049] json

[2050] {

[2051] "adjusted_topics": ["My most relaxing place", "About my recent hobbies"]

[2052] }

[2053] Step 5:

[2054] The terminal receives a response from the server and displays it to the user. Specifically, it displays topics and advice tailored to the user interface.

[2055] (Application Example 2)

[2056] Next, we will explain application example 2. In the following explanation, the data processing device 12 will be referred to as the "server" and the robot 414 as the "terminal".

[2057] Existing systems lack the functionality to facilitate smooth communication between users, and in particular, face-to-face customer service, they have difficulty appropriately recognizing user emotions and suggesting conversation topics based on those emotions. Furthermore, two-way communication that is attentive to user emotions is essential for improving customer satisfaction and achieving efficient service. Especially in customer service at physical stores, it is necessary for customer service staff to instantly grasp the emotional state of customers and respond appropriately accordingly.

[2058] In Application Example 2, the specific processing performed by the specific processing unit 290 of the data processing device 12 is realized by the following means. In this invention, the server includes means for a user to input their own information, means for the server to receive the input information from the user and store it in a database, means for the user to send a request to obtain information about other users, means for the server to obtain information about other users from the database based on the request and return it to the user, means for the server to utilize natural language processing technology to generate a conversation topic, means for storing the generated conversation topic and returning it to the user, means for analyzing the user's emotions using an emotion recognition engine, and means for adjusting conversation topics and responses based on the emotion analysis results and providing them to the user. This makes it possible to provide appropriate conversation topics based on the user's emotional state and realize more personalized communication.

[2059] "User information" refers to information about a user's personal attributes, such as their name, department, and hobbies, that they have registered about themselves.

[2060] A "server" is a computing system that receives information from users via a network, stores it in a database, and processes the information in cooperation with other services.

[2061] A "database" is a system for efficiently managing, storing, and retrieving data such as user information and conversation topics.

[2062] A "request" is a communication message in which a user asks a server to retrieve or process information.

[2063] "Natural language processing technology" refers to a set of techniques that enable computers to understand and generate human language, utilizing machine learning and data analysis.

[2064] A "conversation topic" is a topic generated to facilitate communication between users.

[2065] An "emotion recognition engine" is software or hardware that analyzes emotions from user input text or voice and recognizes that emotional state.

[2066] "Emotional analysis results" refer to data indicating the user's emotional state, obtained by the emotion recognition engine.

[2067] A "response" is a message that a server provides in response to a user's request, and it includes the conversation topic and other information.

[2068] "Personalized communication" refers to communication delivered in a format optimized for a specific user, based on their individual emotions and attribute information.

[2069] Modes for carrying out the invention

[2070] This invention relates to a system in which a user inputs their own information, a server receives that information, stores it in a database, retrieves information from other users, recognizes the user's emotions, and generates conversation topics based on that. The system has the following main functions: user information registration, retrieval of other users' information, generation of conversation topics, and use of an emotion recognition engine.

[2071] The server first provides an interface for users to enter their information. When a user enters information such as their name, department, and hobbies on their terminal and presses the registration button, the information is converted to JSON format and sent as a POST request to the server endpoint. The server receives the request, extracts the necessary information from the JSON format, and saves it to the "Users" table in the database. If the save is successful, the server sends a registration success message to the user.

[2072] Next, the user sends a request to retrieve information about other users. Specifically, when the user specifies their own ID and sends a request to the server, the server retrieves all other user information from the database, processes it into a list format, and sends it back to the user. This allows the user to easily obtain the profile information of other users.

[2073] Next, when a user creates a conversation topic, they enter the names of other users they wish to talk to, designating them as participants. Based on the specified participants, the server generates a conversation topic using natural language processing techniques. The generated conversation topic is stored in a database and returned to the user. This natural language processing technique can utilize external natural language processing APIs.

[2074] Furthermore, the present invention integrates an emotion recognition engine to analyze emotions from user input text and voice data. The server receives this data and transmits it to the emotion recognition engine. Upon receiving a response from the emotion recognition engine, the server adjusts its response to the user and conversation topics based on the analyzed emotions. For example, if the user is feeling stressed, topics related to relaxation can be suggested.

[2075] As a concrete example, if user A enters the information "Taro Yamada," "Sales Department," and "Reading," and presses the registration button, this information is sent to the server and stored in the database. Next, if user A wants to talk to another employee and presses the profile generation button to send a request, the server retrieves information about the other employee from the database and sends it back to user A. Furthermore, if user A wants to talk to "Hanako Sato," they enter her name and press the topic generation button. The server receives this information and uses a natural language processing API to generate a common topic with "Hanako Sato." As a result, a topic such as "A book you've recently read" is returned to user A. Also, if the sentiment engine recognizes from the text entered by user A that user A is relaxed, the server will suggest a more in-depth conversation topic based on that.

[2076] An example of a prompt to input into the generating AI model could be: "Generate a sample dialogue for a customer service application in a store within a shopping mall."

[2077] In this way, the present invention facilitates communication between employees from different departments and can also be applied to customer service in physical stores. The emotion recognition function provides an even more personalized experience.

[2078] The flow of a specific process in Application Example 2 will be explained using Figure 14.

[2079] Step 1:

[2080] It provides an interface for users to enter their own information. Users enter information such as their name, department, and hobbies, and then press the register button. The entered information is sent from the terminal to the server as a POST request in JSON format.

[2081] Input: User information such as name, department, and hobbies.

[2082] Output: POST request in JSON format

[2083] Step 2:

[2084] The server receives the input information from the user. The server extracts the necessary information (name, department, hobbies, etc.) from the received JSON data and saves it to the "Users" table in the database. If the saving is successful, the server sends a registration success message to the user in JSON format.

[2085] Input: User information in JSON format

[2086] Output: Successful message for saving to database and registration.

[2087] Step 3:

[2088] The user presses a button to send a request to retrieve information about another user. The user specifies their own ID and sends the request. The terminal sends a POST request in JSON format containing this information to the server endpoint.

[2089] Input: Your User ID

[2090] Output: POST request in JSON format

[2091] Step 4:

[2092] The server receives the aforementioned request. The server retrieves all other user information from the database and processes it into a list format. Then, it sends the retrieved user information back to the user as a JSON response.

[2093] Input: Request in JSON format, User ID

[2094] Output: List of other user information, response in JSON format

[2095] Step 5:

[2096] The user interacts with the interface for generating conversation topics. They enter the names of other users who will be participating in the conversation and designate them as participants. The terminal sends a POST request in JSON format containing the list of participant names to the server endpoint.

[2097] Input: List of participant names

[2098] Output: POST request in JSON format

[2099] Step 6:

[2100] The server receives the aforementioned request. The server calls an external API to generate a conversation topic using natural language processing technology. This API call generates a conversation topic based on the specified participants. The generated conversation topic is stored in the "Conversations" table in the database and returned to the user as a JSON response.

[2101] Input: Participant information in JSON format

[2102] Output: Save to database, JSON response of the generated conversation topic

[2103] Step 7:

[2104] The system performs emotion recognition using user-input text or audio data. The device sends the input text or audio data to the server as a POST request in JSON format.

[2105] Input: Text or audio data

[2106] Output: POST request in JSON format

[2107] Step 8:

[2108] The server receives the text and audio data. The server sends the data to the emotion recognition engine and receives the analysis results. Based on the emotion recognition results, the server adjusts the conversation topics and responses to be appropriate and provides them to the user.

[2109] Input: Text or audio data in JSON format

[2110] Output: Emotion recognition results, adjusted response

[2111] In this way, each step of the present invention realizes a series of processes from user information registration to emotion recognition, and then generating and providing an appropriate response.

[2112] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the controlled object 443 to output the result of the specific processing. The microphone 238 acquires audio indicating user input for the result of the specific processing. The control unit 46A transmits the audio data indicating user input acquired by the microphone 238 to the data processing unit 12. In the data processing unit 12, the specific processing unit 290 acquires the audio data.

[2113] Data generation model 58 is a type of so-called generative AI (Artificial Intelligence). One example of data generation model 58 is ChatGPT (Internet search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search) <url: https: gemini.google.com ?hl="ja">Examples of generative AI include the following. The data generation model 58 is obtained by performing deep learning on a neural network. The data generation model 58 is input with prompts containing instructions, and with inference data such as audio data representing speech, text data representing text, and image data representing images. The data generation model 58 infers from the input inference data according to the instructions indicated by the prompts, and outputs the inference results in data formats such as audio data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[2114] In the above embodiment, an example was given in which specific processing is performed by the data processing device 12, but the technology of this disclosure is not limited thereto, and the specific processing may also be performed by the robot 414.

[2115] Furthermore, the emotion identification model 59, acting as an emotion engine, may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to a specific mapping, which is an emotion map (see Figure 9). Similarly, the emotion identification model 59 may also determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[2116] Figure 9 shows an emotion map 400 in which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. The closer to the center of the concentric circles, the more primitive the emotions are located. Further out of the concentric circles, emotions representing states and actions arising from mental states are located. Emotion is a concept that includes feelings and mental states. On the left side of the concentric circles, emotions that are generally generated from reactions occurring in the brain are located. On the right side of the concentric circles, emotions that are generally induced by situational judgment are located. Above and below the concentric circles, emotions that are generally generated from reactions occurring in the brain and induced by situational judgment are located. In addition, the emotion of "pleasure" is located on the upper side of the concentric circles, and the emotion of "displeasure" is located on the lower side. Thus, in the emotion map 400, multiple emotions are mapped based on the structure in which emotions arise, and emotions that are likely to occur simultaneously are mapped close together.

[2117] These emotions are distributed at the 3 o'clock position on the Emotion Map 400, and usually fluctuate between feelings of security and anxiety. In the right half of the Emotion Map 400, situational awareness takes precedence over internal feelings, resulting in a calm impression.

[2118] The inside of the Emotion Map 400 represents inner thoughts, while the outside represents actions. Therefore, the further you go from th...

Claims

1. A means for users to input their own information, A server provides means for receiving input information from the user and storing it in a database, A means for a user to send a request to obtain information about other users, The server has means for retrieving information about other users from the database based on the aforementioned request and returning it to the user, The server utilizes natural language processing techniques to generate conversation topics, Means for saving the generated conversation topic and returning it to the user, A system that includes this.

2. The system according to claim 1, wherein the natural language processing technology utilizes an external API.

3. The system according to claim 1, wherein the generation of the conversation topic is performed based on the attribute information of the participants.

Images