Intelligent schedule management system and method based on large language model

Abstract

The invention provides an intelligent schedule management system and method based on a large language model, and belongs to the field of artificial intelligence. The system provided by the invention comprises a client and a server, the client is provided with a trigger module, and the trigger module is used for responding to interception of any interface, containing schedule information, of the client to generate a source image, extracting text information in the source image and sending the text information to the server; an analysis engine and a business logic unit are deployed on the server side; the analysis engine outputs structured schedule data corresponding to the text information based on the large language model; the business logic unit is used for evaluating the emergency degree based on the schedule data and generating a schedule task based on the emergency degree; the client further comprises a schedule management unit used for displaying schedule tasks; and generating a prompt according to the schedule task. According to the intelligent schedule management system and method based on the large language model, automatic collection, analysis and intelligent management of multi-source fragmented schedule information can be achieved.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to an intelligent schedule management system and method based on a large language model. Background Technology

[0002] In today's information explosion era, personal and work schedule information exhibits significant characteristics such as diversified sources, fragmented carriers, and unstructured formats. Users' to-do items, meeting arrangements, and life plans are no longer solely recorded in dedicated calendars but are widely distributed across non-standardized information sources such as WeChat chats, emails, SMS notifications, and various images and screenshots. This necessitates users performing a significant amount of information filtering, extraction, and integration work. Traditional centralized and manual schedule management models are no longer sufficient to cope with this dispersed and high-frequency information input scenario, leaving users facing a huge information management burden and efficiency bottlenecks.

[0003] Currently, schedule management tools on the market mainly fall into two categories: one is basic calendar and to-do list applications integrated into operating systems or office suites; the other is independent third-party time management software. The core functionality of these tools generally focuses on providing structured time grids or task lists, allowing users to manually add and edit tasks, and set fixed reminders based on preset absolute times. They primarily rely on local data storage and simple notification triggering mechanisms, with some advanced applications supporting cross-device cloud synchronization. Although some tools attempt to integrate natural language processing to simplify input, overall, existing technological solutions still rely on the premise that users actively and accurately input structured information.

[0004] Therefore, existing technologies, when dealing with the aforementioned multi-source and fragmented real-world scenarios, firstly suffer from low input efficiency and high error rates, relying entirely on users manually extracting and transcribing information from various platforms—a cumbersome and time-consuming process, prone to errors or omissions during peak periods. Secondly, they suffer from severely insufficient intelligence and poor adaptability; the system completely lacks the ability to automatically understand unstructured information such as images, handwriting, and chat context, and cannot parse ambiguous time expressions like "tomorrow afternoon," resulting in a severe disconnect between technical capabilities and the user's actual information sources. Furthermore, their reminder mechanisms are rigid and lack personalization; the reminder function is mechanically bound to a single task deadline, without considering the importance of the task itself or the user's overall workload, thus failing to provide intelligent reminders. Finally, although Optical Character Recognition (OCR) and Large Language Modeling (LLM) are mature supporting technologies, existing schedule management tools have failed to deeply integrate them, thus failing to build an end-to-end automated closed loop from automatic multi-source information collection to semantic understanding and structuring, and then to intelligent decision-making and reminders. Therefore, a new generation of schedule management solutions capable of achieving full-process automation and intelligence is urgently needed. Summary of the Invention

[0005] In view of this, this application provides an intelligent schedule management system and method based on a large language model to solve the problems of low input efficiency and easy errors caused by users' schedule information being scattered across various platforms and in various formats, as well as the lack of intelligence of existing schedule management tools, which cannot automatically parse unstructured information and provide personalized reminders.

[0006] Specifically, this application is implemented through the following technical solution:

[0007] The first aspect of this application provides an intelligent schedule management system based on a large language model, the system including a client and a server;

[0008] The client is equipped with a triggering module, which is used to generate a source image in response to capturing any interface of the client containing schedule information, extract text information from the source image, and send the text information to the server.

[0009] The server-side is equipped with a parsing engine and business logic units.

[0010] The parsing engine outputs structured schedule data corresponding to the text information based on a large language model;

[0011] The business logic unit is used to evaluate the urgency based on the schedule data and generate schedule tasks based on the urgency. The urgency is a comprehensive urgency that integrates event urgency and time urgency. The event urgency is the relevance between the schedule topic in the schedule data and the global identity tag of the corresponding user on the client. The time urgency represents the time difference between the current time and the deadline in the schedule data.

[0012] The client also includes a schedule management unit for displaying the scheduled tasks, with different display effects for different levels of urgency; and generating reminders based on the scheduled tasks.

[0013] A second aspect of this application provides an intelligent schedule management method based on a large language model, the method comprising:

[0014] In response to a triggering event, the system obtains a source image of the interface containing schedule information from the client and extracts text information from the source image.

[0015] Send the text information to the server;

[0016] On the server side, the text information is processed by a parsing engine based on a large language model to generate structured schedule data;

[0017] Based on the structured schedule data, the event urgency and time urgency are evaluated and integrated to obtain a comprehensive urgency, and a schedule task is generated based on the comprehensive urgency; wherein, the event urgency is determined based on the relevance between the schedule topic and the user's global identity tag, and the time urgency is determined based on the time difference between the deadline in the schedule data and the current system time;

[0018] Synchronize the schedule tasks and their corresponding overall urgency to the client;

[0019] On the client side, the scheduled tasks are displayed, with different display effects for scheduled tasks of different overall urgency levels, and reminders are triggered based on the overall urgency level.

[0020] The intelligent schedule management system and method based on a large language model provided in this application do not require the installation of any third-party applications. From the backend perspective, multiple schedules are automatically generated by artificial intelligence directly through the monitored screen content and the mobile phone's built-in communication functions. The urgency of the schedules is assessed based on their actual content, and then they are sorted accordingly, achieving intelligent management of multiple schedules. From the user perspective, when text, images, or other information that requires schedule generation appears, no operation is required. The client automatically completes information acquisition, structuring, and intelligent schedule generation in the background, greatly simplifying schedule creation and management. Specifically, firstly, the trigger module deployed on the client automatically captures the interface containing schedule information and generates the source image, achieving seamless and automated collection of schedule information scattered across various applications, eliminating the tedious manual input operation for users from the source. Secondly, the parsing engine deployed on the server side processes text information based on a dedicated model, capable of understanding and extracting elements such as tasks and times from the text information, outputting structured schedule data, thereby solving the problem of insufficient understanding of unstructured information by traditional tools. Furthermore, the business logic unit integrates event urgency based on the relevance of the schedule topic to the user's identity, as well as time urgency based on time constraints, to generate a comprehensive urgency score and create schedule tasks accordingly. This ensures that task priority assessment balances individual concerns with overall time planning, achieving personalized and intelligent reminders. Finally, the client-side schedule management unit differentiates the display of schedule tasks based on the comprehensive urgency score and triggers reminders, allowing users to intuitively identify task priorities and receive timely reminders that match the actual urgency of the tasks, thus improving the efficiency of schedule management and the user experience. Attached Figure Description

[0021] Figure 1 A structural diagram of an embodiment of the intelligent schedule management system based on a large language model provided in this application;

[0022] Figure 2The flowchart is for Embodiment 2 of the intelligent schedule management method based on a large language model provided in this application. Detailed Implementation

[0023] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings represent the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application.

[0024] The terminology used in this application is for the purpose of describing particular embodiments only and is not intended to be limiting of the application. The singular forms “a,” “the,” and “the” used herein are also intended to include the plural forms unless the context clearly indicates otherwise. It should also be understood that the term “and / or” as used herein refers to and includes any and all possible combinations of one or more of the associated listed items.

[0025] It should be understood that although the terms first, second, third, etc., may be used in this application to describe various information, such information should not be limited to these terms. These terms are only used to distinguish information of the same type from one another. For example, without departing from the scope of this application, first information may also be referred to as second information, and similarly, second information may also be referred to as first information. Depending on the context, the word "if" as used herein may be interpreted as "when," "when," or "in response to determination."

[0026] The following specific embodiments are given to illustrate the technical solution of this application in detail.

[0027] Example 1

[0028] Figure 1 This is a structural diagram of an embodiment of the intelligent schedule management system based on a large language model provided in this application. Please refer to... Figure 1 The system provided in this embodiment includes a client and a server;

[0029] The client is equipped with a triggering module, which is used to generate a source image in response to capturing any interface of the client containing schedule information, extract text information from the source image, and send the source image to the server.

[0030] The server-side is equipped with a parsing engine and business logic units.

[0031] The parsing engine outputs structured schedule data corresponding to the text information based on a large language model;

[0032] The business logic unit is used to evaluate the urgency based on the schedule data and generate schedule tasks based on the urgency. The urgency is a comprehensive urgency that integrates event urgency and time urgency. The event urgency is the relevance between the schedule topic in the schedule data and the global identity tag of the corresponding user on the client. The time urgency represents the time difference between the current time and the deadline in the schedule data.

[0033] The client also includes a schedule management unit for displaying the scheduled tasks, with different display effects for different levels of urgency; and generating reminders based on the scheduled tasks.

[0034] It should be noted that the system provided in this embodiment adopts a client-server (C / S) layered collaborative architecture. The client is mainly deployed on the user's mobile terminal (such as a smartphone or tablet), responsible for interacting with the user, collecting information, and performing local management and reminders; the server is deployed in the cloud or server cluster, responsible for core data processing, intelligent analysis, and storage. The two interact via the network, together forming a closed-loop process from information collection, intelligent parsing, task generation to final reminders.

[0035] Please refer to Figure 1 The client-side application deploys a trigger module and a schedule management unit. The trigger module generates a source image in response to capturing any interface containing schedule information on the client, extracts text information from the source image, and sends the text information to the server. It should be noted that, in an optional approach, the trigger module can also directly send the source image to the server, where the server will uniformly perform text extraction and semantic parsing. However, this approach has some drawbacks. First, the original image data volume is large, consuming significant network bandwidth during transmission, resulting in significant latency in weak network environments. Second, the server needs to perform unified text extraction processing on a large number of images, increasing the server's computational load and resource consumption. Therefore, the solution adopted in this application is to complete the extraction of text information from the source image locally on the client side. Specifically, after generating the source image, the trigger module can call integrated optical character recognition (OCR) and other text extraction components to recognize and extract the text content from the image. In this way, the extracted text data is much smaller than the original image, saving network transmission resources and improving data transmission efficiency and stability. At the same time, this process offloads the image processing load on the server, allowing it to focus more on core tasks such as semantic parsing and intelligent decision-making. Furthermore, the rapid transmission and processing of text information also reduces overall system latency, resulting in a smoother user experience. In addition, this mechanism enhances system robustness. In the event of poor network conditions or offline status, the client can complete text extraction and local storage first, and then synchronize it after the network is restored, ensuring the continuity and reliability of schedule information collection.

[0036] It should also be noted that the triggering module may include a manual triggering unit and an automatic triggering unit. The manual triggering unit is used to respond to a preset operation performed by the user on the client's screen and capture the current client display interface to generate the source image. The automatic triggering unit is used to monitor the content of the client's display interface in real time and generate the source image of the display interface in the background based on the semantics of the display interface content and its relevance to the schedule. As a specific implementation of manual triggering, the manual triggering unit can also be configured to display a floating control (floating window) on the client interface. When the user browses to an interface containing schedule information, they can actively click on the floating control to trigger the capture of the current display interface to generate the source image. This method provides the user with a persistent and convenient visual triggering entry point, further enriching the interactive form of manual triggering.

[0037] This application provides two mechanisms: manual triggering and automatic triggering. These mechanisms cover different user habits and application scenarios, complementing each other. Manual triggering gives users complete control, ensuring that the intention of information collection is clear and there is no continuous background running burden, thus saving device resources to the greatest extent. It is suitable for scenarios that are sensitive to privacy and power consumption, or where schedule information appears infrequently. Automatic triggering, on the other hand, focuses on convenience with user permission. It can capture schedule prompts that users may ignore or do not have time to handle manually, and is suitable for scenarios with dense schedule information and where users want convenient management (such as when processing work emails or group chats in a concentrated manner).

[0038] It is important to note that the automatic triggering in this application does not refer to uninterrupted, 24 / 7 screen content monitoring in the device background. To avoid unnecessary resource consumption, the system allows users to finely configure and manage the automatic triggering function. For example, users can set automatic triggering to only take effect during specific time periods (such as 9:00 AM to 6:00 PM on weekdays), or only activate when specific applications (such as email clients or instant messaging tools) are in the foreground. Furthermore, the system can employ intermittent wake-ups or lightweight monitoring strategies based on device status (such as during charging). This configurable, conditional, and non-continuous automatic triggering mechanism effectively ensures device battery life and performance while maintaining convenience.

[0039] The schedule management unit is used to display schedule tasks issued by the server, with different display effects for schedule tasks of different urgency levels. It can also generate reminders based on these schedule tasks. This schedule management unit includes a display module and a reminder module. The display module visually differentiates and displays schedule tasks of different urgency levels, and responds to clicks on any of the schedule tasks by displaying the task's details page. The reminder module triggers reminders based on the schedule task and its corresponding urgency level.

[0040] Furthermore, the client is also configured with a first communication unit, which is used to segment the text information extracted by the triggering module and send it to the second communication unit of the server. At the same time, it can receive schedule task data from the second communication unit. For updates to schedule task data, the first communication unit can send the changed data relative to the stored version to the second communication unit, thereby reducing the bandwidth consumption of data transmission and improving synchronization efficiency.

[0041] The system employs a dual-protection strategy for data synchronization: real-time triggering and timed backup. When the client is online, user edits and completions will trigger incremental data synchronization in real time. Simultaneously, the system will perform timed synchronization at preset intervals (e.g., 30 minutes) as a backup in case of network instability. When the client is offline, all local operation records will be temporarily stored in a local task queue managed according to the first-in, first-out (FIFO) principle. Once the network connection is restored, the system will automatically synchronize these batch operations to the server in queue order.

[0042] It should be noted that "responding to capturing any interface of the client containing schedule information" means that the triggering module can react to any application interface that the user is browsing on the mobile device, such as a WeChat chat window, email body, web page notification, or even a screenshot of a handwritten memo application, as long as the interface contains text or image information related to the schedule. The capture operation involves calling the screen capture interface of the mobile operating system to obtain a complete bitmap of the currently displayed content. The image generated through this capture operation is the source image.

[0043] The function of extracting text information from the source image and sending it to the server is mainly accomplished by the first communication unit integrated within the client. This first communication unit is actually a software communication module that follows a specific network protocol, implemented based on an HTTP / HTTPS client library. When the trigger module generates the source image and extracts the corresponding text information, it calls the interface of the first communication unit, which is responsible for packaging the data corresponding to the text information and uploading it to the server's preset network address via the device's network interface.

[0044] It should be noted that the triggering module responds to user requests through two complementary mechanisms. The manual triggering unit responds to a pre-defined user action, which can be defined as a specific gesture performed by the user on the touchscreen, such as swiping down with three fingers simultaneously. When the system touch event listener captures this gesture, which conforms to the pre-defined trajectory and number of fingers, it determines that the user has issued a clear screenshot command. The manual triggering unit then calls the screen capture API (Application Programming Interface) provided by the operating system to immediately take a snapshot of the entire current client display, generating the source image. This approach gives the user complete control and is suitable for scenarios where users actively discover valuable schedule information.

[0045] The purpose of the automatic triggering unit is intelligent monitoring and decision-making. Real-time monitoring of the client's display interface content means that this unit operates as a background service, continuously acquiring activity information and screen content of the current foreground application. Specifically, the automatic triggering unit operates as a background service, continuously acquiring the text information of the currently displayed foreground application through the legitimate interface content access mechanism provided by the operating system.

[0046] The semantic relevance of the displayed content to the schedule is used to determine whether to execute automatic triggering. Specifically, the automatic triggering unit maintains a predefined library of schedule keywords, such as "meeting," "deadline," "registration," "reminder," and "appointment," and integrates a lightweight local semantic analysis model. This model quickly analyzes the text extracted from the current screen, calculating the density of schedule keywords, their context, and their co-occurrence with time expressions, ultimately outputting a relevance score. When this score exceeds a preset threshold, the automatic triggering unit automatically performs a screenshot in the background, generating the source image without any user intervention. This method achieves seamless information collection, greatly improving convenience.

[0047] As an optional embodiment, after the client obtains the source image, the method further includes: obtaining the application identifier corresponding to the source image; obtaining the operation history associated with the source image based on the application identifier; the operation history can be any one or more of the conventional client usage behaviors such as click history, text chat content, and file sending records; packaging the operation history and the text information extracted from the source image and sending them to the server; the server identifies the operation intent corresponding to the text information based on the operation history and the application identifier; inputting the operation intent and the text information content into the large language model; generating a semantic recognition environment based on the operation intent; identifying candidate schedule information in the text information in the semantic recognition environment; and generating structured schedule data based on the candidate schedule information. During the text information extraction process, simply identifying structured schedule data from the text information is prone to misidentification due to insufficient contextual data. Therefore, on the one hand, the operation intent corresponding to the relevant operation history of the application that generated the source image is identified in advance and used as input to the large language model, intervening in the structured data extraction process of the large language model, thereby improving the accuracy of schedule data extraction. For example, during a WeChat chat, when a schedule reminder is detected in the chat window, the system first identifies that the application displaying the source image on the current screen belongs to WeChat. Then, it retrieves other chat content or file sending / receiving content within that chat window in WeChat, determining the current chat intent as "work report delivery." Based on this topic, the intent for extracting structured data from the current text information is further defined. For example, the time information could be extracted as "tomorrow." However, if the current text information doesn't display enough content, the intent can be accurately described as "to whom to submit which work report," making the final generated schedule information more realistic and user-friendly, conforming to everyday communication habits. Furthermore, in addition to obtaining the application corresponding to the current source image, the initial intent of the text information is identified. At this stage, only preliminary intent recognition is performed based on semantic understanding. Based on this initial intent, the associated application is identified; for example, for a travel intent, the associated application is a railway ticketing app or a flight ticketing app. The server retrieves associated information from related applications. It integrates the operation history, application identifier, and associated information to jointly identify the operation intent corresponding to the text information. The associated information can be existing but not actually fulfilled orders, or other search behaviors, etc. When a chat message about travel arrangements occurs, it can only be said that the user has a real intention to travel if there are any unfulfilled ticket orders. At this time, a schedule reminder is generated.

[0048] It's important to note that the different display effects for tasks with varying urgency levels refer to the fact that the display module within the schedule management unit uses differentiated visual styles to render each task based on its overall urgency value issued by the server. This allows users to clearly identify task priorities. Specifically, the display module presets corresponding visual style templates for different urgency value ranges. For example, tasks with an urgency value above 80 can be designated as high urgency, 60-80 as medium urgency, and below 60 as low urgency. These different urgency levels are then displayed visually. In practice, this can be achieved through color coding, graphical icons, and layout / sorting. Color coding is the most intuitive method; for instance, in the task list or calendar view, high-urgency tasks might be displayed with a red background or text, medium-urgency tasks with orange, and low-urgency tasks with green. Graphical icons are added next to each task entry, such as a red exclamation mark for high urgency, a yellow clock for medium urgency, and a green checkmark for low urgency. Layout / sorting refers to the automatic sorting of tasks in the list view according to their urgency from highest to lowest. In the calendar view, you can add color blocks or scale bars of different colors to the date cells. For example, a five-color scale bar component can visually display the proportion of various urgent tasks in a day by using the length of different colored segments, thus providing an overall display.

[0049] The display module utilizes various view organization formats to support the aforementioned differentiated visual presentations. Specifically, the calendar view supports free switching between three time granularities: month, week, and day, to adapt to planning needs in different scenarios; the list view supports automatic categorization and sorting of tasks by time levels such as "today," "tomorrow," and "future," allowing users to quickly focus on recent tasks.

[0050] It's important to note that when a user clicks on any task item, the display module will respond to the click and navigate to the task's details page. This page will display all the structured information about the task, typically including: task title, detailed description, precise start and end times, location, participants, a thumbnail of the original source, and the urgency score and category calculated by the system. Furthermore, this details page allows users to edit, mark, or delete tasks.

[0051] It's also worth noting that the reminder module is responsible for triggering reminders based on the task and its urgency. The reminder methods integrate the mobile device's full-scene notification capabilities, including persistent notification bar display for continuously visible alerts; lock screen pop-up notifications for immediate reach; and strong reminders combining sound and vibration. Furthermore, the reminder module includes an independent local reminder engine that does not rely on a network connection, allowing it to accurately trigger reminders based on locally stored schedules and time information even when the client is offline.

[0052] Specifically, the timing, frequency, and intensity of reminders are dynamically adjusted. In practice, reminders are progressively stronger. For example, for a high-urgency task, a mild notification might appear 24 hours before the deadline; another reminder with a slight vibration 8 hours before; and a full-screen pop-up and strong vibration triggered 1 hour before the deadline. For low-urgency tasks, a simple notification might appear only 2 hours before the deadline. This differentiated reminder strategy ensures that important tasks are not missed while minimizing unnecessary disruption to the user.

[0053] Furthermore, the first communication unit is a management module responsible for all external network communications of the client. It encapsulates the logic of data encoding, encryption, transmission, reception, and decoding. Since the extracted text information may contain a lot of content, and in some implementations, considering the alternative of directly sending the source image, the data size is large (e.g., a screenshot of several MB), direct upload is inefficient and unstable. Therefore, the first communication unit optimizes the data according to its data type. For text information, it typically performs compression and packetization directly; for image data, it first uses a combination of lossy and lossless compression algorithms to compress the image to less than 1 MB while ensuring the accuracy of text recognition in the image, thus optimizing transmission efficiency. Then, the data to be sent (text or compressed image) is fragmented according to a preset specification (e.g., 500KB per fragment). Each fragment is further compressed using the gzip algorithm and sent sequentially to the second communication unit on the server through an encrypted channel established by the HTTPS protocol. This fragmentation and compression strategy optimizes transmission efficiency and success rate. In addition, when users perform schedule editing operations on the client, the system will immediately initiate a data push process to the server while triggering a local cache update, thereby ensuring the consistency of data between the client and the server.

[0054] It's important to note that the first communication unit also handles downlink communication. When the server-side business logic unit generates or updates a schedule task, it sends the data to the client via the second communication unit. At this point, the first communication unit listens for and receives this data, verifies its integrity, and then passes it to the local storage module for storage. It also notifies the schedule management unit to update the interface. Specifically, the client has a local storage module that uses an SQLite database for persistent local storage of schedule data. This module supports core operations such as querying, editing, and setting reminders for schedules even when the user is offline. When the network connection is restored, the system automatically detects data changes in the local storage and, through an incremental synchronization mechanism, only pushes the changed data to the server, thus avoiding resource waste caused by full data transmission.

[0055] It's also important to note that, relative to the stored version, "changed data" refers to the situation where, when a user modifies a schedule task locally on the client (e.g., changing the time or marking it as complete), the first communication unit does not re-upload the entire task data. Instead, it compares the locally modified data with the data in the previous synchronized version, extracts only the changed fields, and then packages and sends these differing fields. This significantly reduces the amount of data transmitted over the network, lowers bandwidth consumption, and improves the real-time performance and efficiency of data synchronization between multiple devices, especially under poor network conditions.

[0056] Please continue to refer to Figure 1 The server-side deployment includes a parsing engine and a business logic unit. The parsing engine outputs structured schedule data corresponding to the text information based on a large language model. The large language model deployed in the parsing engine is a dedicated model. The training process of this dedicated model specifically includes: first, acquiring multi-source heterogeneous schedule-related data collected by the client; then, semantically labeling and correcting the multi-source heterogeneous data to construct a training sample set; and finally, incrementally fine-tuning the basic large language model based on the training sample set to obtain the dedicated model. The dedicated model can receive unstructured schedule information as input and output structured schedule data containing key information such as the schedule subject, time nodes, and task requirements.

[0057] The business logic unit is used to assess the urgency based on the structured schedule data and generate schedule tasks based on the urgency. The urgency is a comprehensive urgency that combines event urgency and time urgency. The event urgency is the relevance between the schedule topic in the schedule data and the global identity tag of the corresponding user on the client. The time urgency represents the time difference between the current time and the deadline in the schedule data.

[0058] It's important to note that the system automatically constructs dynamic user profiles, or global user identity tags, based on local user historical behavior data on the client side. Specifically, by continuously analyzing user behavior logs, including the content, type, application, active time period, and operation frequency of past created, completed, followed, and canceled schedule tasks, the system automatically summarizes multiple semantically representative identity sub-tags using natural language processing and behavioral clustering algorithms. These sub-tags can be categorized according to task domain, such as "work-technology research and development" or "study-qualification exams." Each sub-tag is dynamically assigned an initial weight based on its frequency, duration, and intensity of operation in the user's historical behavior, and this weight is continuously adjusted in subsequent behavior analysis.

[0059] These identity sub-labels are not static but dynamically updated as user behavior data accumulates and patterns change. The system periodically re-runs clustering and classification algorithms, adding, deleting, merging, or re-evaluating the label set based on recent behavior, ensuring that the label system adapts to the evolution of user interests and responsibilities.

[0060] When a new scheduled task is parsed, the business logic unit calculates the semantic relevance between the scheduled topic and each of the user's sub-tags. This is typically achieved by calculating the cosine similarity between the topic text and the tag name or historical task text under the tag in the semantic vector space. Then, the system selects the sub-tag with the highest semantic relevance and multiplies this highest relevance value by the weight of that sub-tag to obtain the event urgency. In this way, an event highly relevant to the user's core identity tags will have a high urgency level even if it is not time-sensitive.

[0061] Specifically, the user global identity tag includes multiple sub-tags generated based on the user's local historical behavior data on the client, and each sub-tag has an associated weight. When the business logic unit calculates the event urgency, it first calculates the semantic relevance between the schedule topic in the schedule data and each sub-tag, and then multiplies the highest semantic relevance by the weight of the sub-tag corresponding to the highest semantic relevance to finally obtain the event urgency. The time urgency is calculated as follows: first, obtain the first time difference between the deadline in the schedule data and the current system time; then, obtain the second time difference between the estimated deadline of all schedule tasks in the current schedule queue of the client and the current system time, and calculate the average of the second time differences; finally, divide the first time difference by the average of the second time differences to obtain the time urgency.

[0062] Furthermore, the server is also equipped with a second communication unit, which is used to receive fragmented data from the first communication unit and reassemble fragments belonging to the same text information. At the same time, it can send schedule task data to the first communication unit to realize bidirectional data interaction between the client and the server.

[0063] It's important to note that the parsing engine's function is to transform text information containing schedule details uploaded by the client into machine-readable and processable structured schedule data. Therefore, the parsing engine deploys a dedicated model. This dedicated model is not a general chat or text generation model, but rather one specifically customized and optimized for the task of extracting schedule elements from unstructured text. Specifically, this dedicated model is trained through a targeted process, using data sourced from real-world user scenarios—that is, heterogeneous, multi-source schedule-related data collected by the client. This ensures that the patterns learned by the model are highly consistent with the final application scenario. This data covers various forms of schedule information, such as WeChat group chat text, email messages, SMS notifications, and list images containing handwritten or printed text, reflecting its multi-source and heterogeneous characteristics.

[0064] It should be noted that the raw data cannot be used directly for training; it needs to be semantically labeled and corrected. Specifically, labelers or semi-automatic tools should accurately label the main events (e.g., "project review meeting"), time nodes (e.g., "next Monday 14:00," and identify whether they are absolute, relative, or ambiguous times), task requirements, locations, participants, and other entities and their types in the text. At the same time, ambiguous, contradictory, or erroneous information should be manually corrected to form a high-quality training sample set.

[0065] Furthermore, an incremental fine-tuning strategy is adopted, starting with a powerful general-purpose large language model. Using the aforementioned training sample set, this large language model is subjected to supervised fine-tuning training. During training, the model is guided to learn how to accurately predict and output structured data formats (e.g., {"task":"Submit Report","deadline":"2023-10-27 23:59:59","priority":"high"}) based on unstructured input text (e.g., "Don't forget to send me the report by next Friday"). This incremental fine-tuning approach inherits the powerful language understanding capabilities of the large language model while enabling it to quickly adapt to domain-specific tasks at a lower cost, balancing effectiveness and efficiency.

[0066] After training the dedicated model through the above process, it is deployed in the parsing engine. When the parsing engine receives text information from the client, its workflow includes taking this text information (i.e. unstructured schedule information) as input and sending it directly into the dedicated model. The dedicated model automatically identifies and extracts key information such as schedule subject, time node, and task requirements through deep semantic analysis, and outputs it in standard formats such as JSON and XML to form the final structured schedule data.

[0067] Based on the preceding description, in another implementation (directly transmitting the source image to the server), the triggering module can also be configured to directly send the captured source image to the server. Correspondingly, the workflow of the parsing engine is adjusted as follows: first, the received source image is preprocessed (e.g., including grayscale conversion, noise reduction, contrast adjustment, and tilt correction based on Hough transform); then, the optical character recognition component is invoked to extract text information from the preprocessed image; finally, the extracted text is fed into a dedicated large language model for semantic parsing and structuring. This implementation concentrates the image processing load on the server side, suitable for scenarios where client computing resources are limited or where client design needs to be simplified. However, compared to the aforementioned preferred implementation, this method increases the amount of data transmitted over the network and places higher demands on the server's image processing capabilities.

[0068] It should be noted that the business logic unit is responsible for processing the parsed structured schedule data. Specifically, this is achieved by calculating a multi-dimensional comprehensive urgency. This comprehensive urgency is not a single time metric, but a composite index that integrates event urgency and time urgency, used to simulate the comprehensive considerations humans make when judging task priorities.

[0069] It's important to note that time urgency measures the urgency of a current task within the current time context. It's a personalized, dynamic relative value, not an absolute time difference. Specifically, the calculation of time urgency involves: calculating the first time difference for the task itself, i.e., the difference between the deadline and the current system time (in hours or days); then obtaining the estimated deadline for each task in the user's current schedule queue (i.e., all unfinished tasks), and calculating the difference between each of these deadlines and the current time, resulting in a second set of time differences; finally, calculating the average of these second time differences, where the average represents the user's overall task load and average urgency level. Finally, the time urgency is calculated as: Time urgency = First Time Difference / Average Second Time Difference. For example, a task with 3 days remaining might have a low time urgency (0.3) for a user with a light schedule (high average, e.g., 10 days), but a high time urgency (3.0) for a user with a heavy schedule (low average, e.g., 1 day). This allows the system to understand that the same 3 days represent different levels of pressure for users with varying levels of busyness.

[0070] Finally, the overall urgency is derived by combining the event urgency and time urgency according to a preset formula (such as weighted summation). Based on this overall urgency, the business logic unit assigns priority tags to the schedule data and generates complete schedule task entities containing intelligent evaluation results for subsequent synchronization and reminders.

[0071] It should be noted that the second communication unit collaborates symmetrically with the first communication unit on the client side, ensuring the reliability and efficiency of bidirectional data flow. Specifically, the second communication unit listens on a specific network port and receives fragmented and encrypted text information data packets uploaded from the first communication unit. It is responsible for decrypting, verifying, and sorting these data packets, recombining all fragments of text information belonging to the same source image to restore the complete text information corresponding to the image, and then delivering it to the subsequent data access layer for processing. The data access layer receives this data through an interface that follows the RESTful API design specifications. This layer first verifies the format and field integrity of the data. After successful verification, it generates a unique request ID for this request. This request ID is associated with the original request data and the access timestamp and stored for subsequent data traceability, performance monitoring, and troubleshooting. After processing, the data is sent to the next stage.

[0072] The next step is the parsing engine. This engine uses its dedicated model to perform deep semantic analysis on the input text data, outputting preliminary structured schedule data. To improve the accuracy of this data, the system deploys a semantic parsing verification and error correction system, employing a three-level error correction framework: the first level assesses the confidence level and removes duplicates from the model's parsing results; the second level performs format verification, converting all parsed date and time expressions into the standard format "YYYY-MM-DD HH:MM"; and the third level performs logical verification, checking and correcting obvious logical contradictions, such as past deadlines marked as not started. Through multi-level verification, the system ensures that the output schedule data is reasonable and usable.

[0073] After processing by the parsing engine and business logic unit, the system generates structured schedule tasks. This task data is persistently stored by the server-side data storage layer. The data storage layer uses a MySQL relational database to store all schedule data. To ensure high-concurrency read / write capabilities, database connection pooling technology is used to manage resources, and a read / write separation architecture can be deployed. To enhance data traceability, this layer records changes through database transaction logs and can further design version number fields in the data tables to achieve historical version tracking of schedule data. When the business logic unit generates or updates a schedule task, the second communication unit encapsulates this task data into a network response packet and sends it back to the client's first communication unit via HTTPS connection, either by actively pushing or responding to client requests for retrieval, thus realizing the distribution of schedule data. Through this upload and download mechanism, the second and first communication units together form a full-duplex communication channel, ensuring stable and real-time bidirectional flow of instructions and data between the client and server.

[0074] It's also worth noting that the system has undergone multi-dimensional optimization in resource scheduling to ensure a smooth user experience. The client-side, through code and algorithm optimization, strictly controls the hardware resource consumption of core operations such as screenshotting and OCR recognition, ensuring execution efficiency and minimizing the impact on user device performance (for example, when performing core operations such as screenshotting and OCR recognition, CPU usage can be controlled below 15%, and the memory usage of persistent components in the notification bar does not exceed 20MB). The server-side is deployed on a cloud server, responsible for core data processing and intelligent analysis. The server-side architecture is designed to be stateless or horizontally scalable, allowing for seamless scaling from a single server deployment to a distributed cluster deployment based on user scale and performance requirements, ensuring high availability and high concurrency processing capabilities. Furthermore, the system is designed with a load-aware degradation strategy. When the server-side cluster load is too high, non-core functions such as data statistics and report generation are automatically suspended, prioritizing the stable operation of core services such as schedule parsing and reminders.

[0075] The system provided in this embodiment, based on a client-server collaborative architecture and dedicated model parsing capabilities, realizes a complete technical closed loop from automatic collection of multi-source, unstructured schedule information to personalized intelligent reminders. First, through the client's intelligent triggering module (including manual and automatic triggering), the system can capture schedule information from any interface such as chat history, emails, and images, overcoming the shortcomings of traditional manual entry methods and solving the problems of low information collection efficiency and easy omissions. Second, the dedicated model integrated into the server-side parsing engine, combined with image preprocessing and a three-level error correction system, can accurately understand and extract elements such as task content and complex time expressions from unstructured information, outputting high-quality structured schedule data, thus solving the problem of insufficient processing of non-textual and ambiguous information by traditional tools. In addition, the business logic unit generates a comprehensive urgency level that reflects the true priority by integrating the event urgency based on user profiles and the time urgency based on individual task load, making the reminder strategy more in line with the actual needs of users. Finally, the client-side schedule management unit, through differentiated visual display and dynamic reminder mechanisms, combined with local storage and a real-time + timed dual-guarantee synchronization strategy, ensures that users can manage their schedules efficiently and stably in different scenarios, improving the intelligence level, reliability, and user experience of schedule management.

[0076] Example 2

[0077] Corresponding to the aforementioned embodiment of an intelligent schedule management system based on a large language model, this application also provides an embodiment of an intelligent schedule management method based on a large language model.

[0078] Figure 2 The flowchart for Embodiment 2 of the intelligent schedule management method based on a large language model provided in this application is shown below. Please refer to... Figure 2The method provided in this embodiment may include:

[0079] S201. In response to the triggering event, obtain the interface source image containing schedule information through the client, and extract the text information from the source image.

[0080] It should be noted that this step corresponds to the function execution of the client trigger module in Embodiment 1. Specifically, the triggering mechanism includes manual triggering, which actively takes a screenshot in response to the user's preset operation instructions (such as specific gestures, clicking on a floating window, etc.); and automatic triggering, which monitors the semantics of the current interface text through a background service and automatically takes a screenshot when it recognizes keywords related to the schedule. Regardless of the method, the purpose is to obtain a source image containing the schedule information to be processed, and then extract the text information from the source image.

[0081] S202. Send the text information to the server.

[0082] After obtaining the text information, the data transmission phase begins, which is carried out by the client's first communication unit. To ensure transmission efficiency and reliability, the first communication unit first compresses and optimizes the text information (such as combining lossy and lossless compression to within 1MB), then performs fragmentation, encryption, and other processing, and finally sends the data to the server's preset interface through a channel established by the HTTPS protocol. In this way, the first transfer of schedule information from the user terminal to the cloud processing center is completed.

[0083] S203. On the server side, the text information is processed by the parsing engine based on a large language model to generate structured schedule data.

[0084] First, the server-side data access layer verifies and receives the uploaded data. Then, the parsing process officially begins. The parsing engine takes the received text information as input and directly feeds it into a dedicated model based on a large language model for deep semantic analysis. This dedicated model, fine-tuned with domain data, can accurately identify and extract key elements such as task content and deadlines. To ensure output quality, the parsing results also undergo a three-level error correction system, including format and logical checks. Finally, a structured schedule data is output.

[0085] S204. Based on the structured schedule data, evaluate and integrate the event urgency and time urgency to obtain a comprehensive urgency, and generate a schedule task based on the comprehensive urgency; wherein, the event urgency is determined based on the relevance between the schedule topic and the user's global identity tag, and the time urgency is determined based on the time difference between the deadline in the schedule data and the current system time.

[0086] It should be noted that the input for this step is the structured schedule data obtained in the previous step. The evaluation process consists of two parallel dimensions: first, calculating the event urgency by analyzing the semantic relevance between the schedule topic and the user's personal global identity tag, reflecting the matching degree between the task and the user's personal concerns; second, calculating the time urgency using a personalized relative value algorithm, comparing the task's deadline with the average urgency level of all the user's current tasks, reflecting the urgency of the task in the current time context. Subsequently, the urgency of these two dimensions is merged according to preset rules to obtain a comprehensive overall urgency score. Finally, the business logic unit generates a schedule task entity containing all key information and priority tags based on this comprehensive urgency score.

[0087] S205. Synchronize the schedule tasks and their corresponding overall urgency to the client.

[0088] First, the newly generated schedule task is persistently stored in the MySQL database of the data storage layer. This layer uses connection pooling and read / write separation technologies to ensure high concurrency and reliability, and supports data version rollback. Then, the second communication unit encapsulates this schedule task data and sends it to the first communication unit on the client via a network connection, completing the process of parsing information from the cloud to the terminal application.

[0089] S206. On the client side, the scheduled tasks are displayed, wherein scheduled tasks with different overall urgency levels have different display effects, and reminders are triggered according to the overall urgency level.

[0090] Specifically, this step is executed by the client's schedule management unit. The display module receives and displays the synchronized schedule tasks. To intuitively convey priority, the display module uses differentiated visual schemes based on the overall urgency of the tasks. For example, in the calendar view (supporting month / week / day switching) or list view (supporting categorization by "today / tomorrow / future"), different colors, icons, or sorting methods are used to distinguish high, medium, and low urgency tasks. Simultaneously, the reminder module dynamically plans and executes reminder strategies based on the overall urgency and deadline of the tasks, sending reminders to the user at appropriate times through various methods such as notification bars and lock screen pop-ups. Furthermore, all schedule tasks are stored in a local SQLite database, supporting offline editing and querying by users, and maintaining data consistency with the server through a real-time trigger + scheduled fallback synchronization strategy.

[0091] The method provided in this embodiment achieves a unified framework for end-to-end automated processing of fragmented schedule information by defining a complete standardized process from information triggering, intelligent parsing, decision generation to terminal reminders. First, by responding to triggering events and acquiring source images of the interface, the method establishes the entry point for automated information collection, eliminating the reliance on manual initiation and input in traditional processes. Then, by extracting text information from the source images and sending it to the server for processing by the parsing engine based on a dedicated model, a reliable transformation path for converting unstructured information into structured data is constructed. Furthermore, by evaluating and integrating the urgency of events and time to generate schedule tasks, a replicable personalized priority calculation logic is provided. Finally, by synchronizing tasks to the client and providing differentiated display and reminders, a closed loop of result delivery and user interaction is formed.

[0092] The above description is merely a preferred embodiment of this application and is not intended to limit this application. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of protection of this application.

Claims

1. An intelligent schedule management system based on a large language model, characterized in that, Including client and server sides; The client is equipped with a triggering module, which is used to generate a source image in response to capturing any interface of the client containing schedule information, extract text information from the source image, and send the text information to the server. The server-side is equipped with a parsing engine and business logic units. The parsing engine outputs structured schedule data corresponding to the text information based on a large language model; The business logic unit is used to evaluate the urgency based on the schedule data and generate schedule tasks based on the urgency. The urgency is a comprehensive urgency that integrates event urgency and time urgency. The event urgency is the relevance between the schedule topic in the schedule data and the global identity tag of the corresponding user on the client. The time urgency represents the time difference between the current time and the deadline in the schedule data. The client also includes a schedule management unit for displaying the scheduled tasks, with different display effects for different levels of urgency; and generating reminders based on the scheduled tasks.

2. The system according to claim 1, characterized in that, The triggering module includes a manual triggering unit, which is used to respond to a preset operation performed by the user on the client's screen and capture the current client display interface to generate the source image.

3. The system according to claim 1, characterized in that, The triggering module further includes an automatic triggering unit; the automatic triggering unit is used to monitor the display interface content of the client in real time, and generate the source image of the display interface in the background according to the semantics of the display interface content and the relevance of the schedule.

4. The system according to claim 1, characterized in that, The large language model deployed in the parsing engine is a dedicated model; the training process of the dedicated model includes: Acquire multi-source heterogeneous data related to the schedule collected by the client; Semantic annotation and correction are performed on the multi-source heterogeneous data to construct a training sample set; The basic large language model is incrementally fine-tuned based on the training sample set to obtain the special model; the special model receives unstructured schedule information as input and outputs structured schedule data.

5. The system according to claim 1, characterized in that, The user global identity tag includes multiple sub-tags generated based on the user's local historical behavior data on the client, and each sub-tag has an associated weight; The business logic unit is specifically used to: calculate the semantic relevance between the schedule topic in the schedule data and each of the sub-tags; multiply the calculated highest semantic relevance by the weight of the sub-tag corresponding to the highest semantic relevance to obtain the event urgency.

6. The system according to claim 1, characterized in that, The calculation method for the time urgency includes: Obtain the first time difference between the deadline in the schedule data and the current system time; Obtain the second time difference between the estimated due time of all scheduled tasks in the current schedule queue of the client and the current system time, and calculate the average of the second time difference; The time urgency is obtained by dividing the first time difference by the mean of the second time difference.

7. The system according to claim 1, characterized in that, The client further includes a first communication unit, and the server further includes a second communication unit; The first communication unit is used to segment the text information acquired by the triggering module and send it to the second communication unit, and to receive schedule task data from the second communication unit; The second communication unit is used to receive fragmented data from the first communication unit and reassemble fragments belonging to the same text information, and to send schedule task data to the first communication unit. Specifically, for updating schedule task data, the first communication unit is used to send the changed data relative to the stored version to the second communication unit.

8. The system according to claim 1, characterized in that, The schedule management unit includes a display module; The display module is used to visually differentiate and display schedule tasks of different urgency levels. The display module responds to a click on any of the scheduled tasks by displaying the details page of the scheduled task.

9. The system according to claim 1, characterized in that, The schedule management unit also includes a reminder module; The reminder module is used to trigger reminders based on the scheduled tasks and their corresponding urgency.

10. An intelligent schedule management method based on a large language model, characterized in that, The method is applied to the system as described in any one of claims 1-9, the method comprising: In response to a triggering event, the system obtains a source image of the interface containing schedule information from the client and extracts text information from the source image. Send the text information to the server; On the server side, the text information is processed by a parsing engine based on a large language model to generate structured schedule data; Based on the structured schedule data, the event urgency and time urgency are evaluated and integrated to obtain a comprehensive urgency, and a schedule task is generated based on the comprehensive urgency; wherein, the event urgency is determined based on the relevance between the schedule topic and the user's global identity tag, and the time urgency is determined based on the time difference between the deadline in the schedule data and the current system time; Synchronize the schedule tasks and their corresponding overall urgency to the client; On the client side, the scheduled tasks are displayed, with different display effects for scheduled tasks of different overall urgency levels, and reminders are triggered based on the overall urgency level.

Images