Bioinformatics task execution method, device and medium based on task priority architecture

Abstract

The application aims to provide a bioinformatics task execution method, device and medium based on a task priority architecture, which decouples the analysis task itself from the user's network session. By decoupling, the task execution no longer depends on the continuous connection of the user session, solving the problem of long task failure due to network or client interruption. Moreover, by creating an independent task entity, a stable and queryable task state tracking capability is provided, allowing users to obtain progress at any time.

Description

Technical Field

[0001] This invention relates to the interdisciplinary field of artificial intelligence and bioinformatics, specifically to the optimization of persistence and stability during the execution of bioinformatics analysis tasks. Background Technology

[0002] Bioinformatics analysis is an interdisciplinary field. Its core is the use of computational tools and methods to acquire, store, manage, analyze, and interpret large-scale biological data in order to reveal biological laws. Its analytical objects cover multi-omics data, including genomics, transcriptomics, proteomics, and metabolomics. Typical tasks include gene sequence alignment, variant detection, gene expression quantification, differential expression analysis, and functional enrichment.

[0003] In existing technologies, bioinformatics analysis tasks are performed based on a general AI dialogue model using HTTP request-response. In this model, users initiate requests to general-purpose large language models, such as ChatGPT and DeepSeek, using natural language. The technology is essentially a synchronous, short-duration session. Each time a user sends a question, the model generates a text response within tens of seconds, after which the connection is closed. If continued is desired, a new round of question-response is initiated.

[0004] However, this technical solution has certain technical drawbacks, namely, the process lifecycle of the analysis task is deeply bound to the user terminal session that initiated the task. Once the user actively disconnects, such as by closing the terminal or webpage, or by experiencing passive interruptions such as network fluctuations or client hibernation, the long-running computing task is usually terminated or enters an uncontrollable orphan process state, leading to task failure and loss of progress. In practical applications, tasks such as single-cell RNA sequencing and genome-wide association studies can take hours to days, and the traditional HTTP request-response model is difficult to support such long-term tasks. Summary of the Invention

[0005] The purpose of this invention is to provide a bioinformatics task execution method, device, and medium based on a task-first architecture, which decouples the analysis task itself from the user's network session. This decoupling eliminates the dependence of task execution on a persistent connection to the user's client session, solving the problem of long-running tasks failing due to network or client interruptions. Furthermore, by creating independent task entities, it provides stable and queryable task status tracking capabilities, allowing users to obtain progress information at any time.

[0006] In a first aspect, the present invention provides a bioinformatics task execution method based on a task-first architecture, comprising the following steps:

[0007] Receive user bioinformatics task requests, assign task identifiers to the bioinformatics task, and create workspaces for the bioinformatics task;

[0008] Establish an SSE connection for this bioinformatics task;

[0009] The bioinformatics task is executed in the background, and the intermediate states during the execution process are encapsulated as events and pushed to the user terminal through the SSE connection.

[0010] After the background bioinformatics task completes and generates analysis results, these results are pushed to the user terminal as a final event via the SSE connection. In a second aspect, the present invention provides an electronic device, including a processor and a memory; the processor is connected to the memory; the memory is used to store executable program code; the processor reads the executable program code stored in the memory to run a program corresponding to the executable program code, for executing the method described.

[0011] In a third aspect, the present invention provides a computer-readable storage medium for storing a computer program that, when executed by a processor, can perform the method described thereon.

[0012] In summary, the present invention has the following beneficial effects:

[0013] 1. By adopting a task-first architecture, bioinformatics task execution is decoupled from user network connections, ensuring that long-running tasks are not interrupted due to client disconnection or network fluctuations. Simultaneously, by establishing SSE connections and pushing events in real time, users are provided with stable and queryable task status tracking capabilities, achieving a unified approach to asynchronous execution and synchronous awareness.

[0014] 2. Authentication using task identifiers during connection establishment ensures the exclusivity and security of the event stream channel, preventing unauthorized access. After server verification, the connection remains open, establishing a reliable technical foundation for subsequent accurate and targeted event pushes.

[0015] 3. By periodically sending heartbeat events on established SSE connections, network intermediary devices such as proxies and load balancers are effectively prevented from disconnecting due to idle timeouts. This mechanism significantly improves the stability of long-lived connections, ensuring the continuous push of progress for long-running tasks.

[0016] 4. By monitoring the SSE connection status and automatically downgrading to polling mode upon failure, the eventual reachability of the status update channel is ensured in complex network environments. This enhances the system's connection resilience and guarantees that users can obtain task progress under any circumstances.

[0017] 5. By integrating external bioinformatics tools through the MCP protocol, the intelligent agent can directly call dozens of professional analysis tools through standardized interfaces. This endows the system with substantial professional computing capabilities, realizing a leap from domain knowledge question answering to actual tool operation execution.

[0018] 6. The ReAct inference planner is introduced, enabling the system to autonomously plan, execute step-by-step, and dynamically observe complex bioinformatics tasks. The agent can iteratively advance based on result feedback until the task is completed.

[0019] 7. The design of the multi-layered memory system addresses the problem of limited context for agents in long tasks. Short-term memory maintains dialogue coherence, vector memory supports knowledge retrieval to aid planning, and long-term memory enables cross-conversation experience accumulation, thereby significantly improving the coherence and professionalism of the analysis.

[0020] 8. By automatically populating the analysis results into a predefined report template, this method achieves standardized and structured output of analytical conclusions. This design solves the problem of scattered results and can generate compliant, deliverable reports with a single click according to different application scenarios, greatly improving the readability and usability of the results. Attached Figure Description

[0021] Figure 1 Flowcharts illustrating several embodiments of a bioinformatics task execution method based on a task-first architecture, as shown in this specification, are provided.

[0022] Figure 2 Schematic diagrams of the structure of electronic devices according to various embodiments of this specification are shown. Detailed Implementation

[0023] The present invention will be further described in detail below with reference to the accompanying drawings.

[0024] The technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings.

[0025] The terms "first," "second," "third," etc., in the description, claims, and accompanying drawings are used to distinguish different objects, not to describe a particular order. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion.

[0026] The following description provides examples and does not limit the scope, applicability, or examples set forth in the claims. Changes may be made to the function and arrangement of the described elements without departing from the scope of this specification. Various processes or components may be appropriately omitted, substituted, or added to the examples. For example, the described methods may be performed in a different order than described, and various steps may be added, omitted, or combined. Furthermore, features described with respect to some examples may be combined into other examples.

[0027] Figure 1 This is a flowchart of several bioinformatics task execution methods 100 based on a task-first architecture disclosed in this specification.

[0028] The main body executing this method 100, often referred to as the "system" below, is an integrated software platform. Its architecture typically includes a front-end interaction layer, a back-end service layer, a core intelligent agent layer, a data and storage layer, and an infrastructure layer. Specifically, the front-end interaction layer provides the user interface, responsible for receiving user requests, uploading files, displaying task status, and visualizing results. The back-end service layer is an API gateway built on frameworks such as FastAPI. The core intelligent agent layer contains the ReAct inference planner, code executor, tool registry, and multi-level memory system, serving as the main body for the system's logical operations. The data and storage layer includes a workspace for storing temporary files, a permanent result archive directory, a vector database for memory retrieval, and a relational database for storing metadata. The infrastructure layer involves containerized deployment, load balancing, and computing environment management.

[0029] The system is typically implemented as a distributed web application based on a client-server model. The server is deployed in the cloud or on a local server cluster. It is an application composed of multiple microservices or modules. The client is the user accessing a specific web application through a browser.

[0030] In box 101, the task creation and event subscription of method 100 are implemented.

[0031] Phase 101 is the initial phase of the task-first architecture. Its core is to transform the user's analytical intent into a task entity that persists in the system backend and can be managed independently, and to establish a one-way communication channel for the user to perceive the status of this task in real time.

[0032] First, task creation is performed. Users submit analysis requests and related data files through the graphical interface or API provided by the front-end interaction layer. The analysis request is the analysis objective described by the user in natural language or structured instructions; the data file is the bioinformatics data uploaded by the user to be analyzed.

[0033] For example, in the front-end interface, a user drags a single-cell RNA sequencing data file, such as sc_data.h5ad, to the upload area and types in the text input box: "Please perform standard quality control, dimensionality reduction and cluster analysis on this single-cell data, and identify the main cell types."

[0034] Subsequently, the API gateway in the backend service layer receives this HTTP request. The gateway performs user authentication, such as JWT token verification, and basic validation of the request parameters. After successful authentication, the request is routed to the task manager.

[0035] The Task Manager then begins generating task records. A new task record is created in the `tasks` table of the relational database. This record contains an automatically generated globally unique task identifier, a Task ID (e.g., `task_20240320_001`), and metadata extracted from the request, including the user ID, original query statement, task status, and creation timestamp. The task status is initially set to "pending".

[0036] The Task Manager then invokes the Path Manager to create a separate workspace directory for the task. The directory name is typically associated with the task identifier, such as ` / workspace / task_20240320_001 / `. This directory will be used to store the user-uploaded raw input files, all intermediate files generated during task execution, and the final output. The user-uploaded data file, such as `sc_data.h5ad` in the previous example, is persistently stored in a specified subdirectory within this workspace.

[0037] After the task is created, the system outputs a task identifier as a response to the front-end interaction layer. The front-end interface will display "Task submitted, Task ID: task_20240320_001" to the user. Furthermore, in the system backend, a task entity with a defined status, attributes, and a dedicated storage location has been created.

[0038] Box 101 is also used to execute the event stream subscription of method 100. The task identifier (task_20240320_001) obtained by the front-end interaction layer above initiates an event stream subscription to the back-end service layer.

[0039] Specifically, the frontend initiates an HTTP request to a specific SSE endpoint via JavaScript's EventSource API or similar technology. The request header includes the previously obtained task identifier for authentication and optionally includes a Last-Event-ID header to enable breakpoint resume functionality.

[0040] After receiving this subscription request, the backend service will direct it to a dedicated event stream processing module via the API gateway. This module will, on the one hand, verify task permissions, confirming that the current user is authorized to listen to events corresponding to this task identifier. On the other hand, it will establish a persistent connection, keeping the HTTP connection open, and register it with the event dispatcher associated with the task identifier. At this point, a Server-Sent Events (SSE) persistent connection channel from the server to the specific client is formally established. Furthermore, a heartbeat keep-alive timer for this connection will be started.

[0041] After box 101 is completed, a persistent HTTP connection dedicated to pushing events to user clients subscribed to task_20240320_001 has been established, and the initial status push has been completed. Once the connection is established, the server immediately pushes an initial status event to the client via this SSE connection, for example, event: status\ndata: {"task_id": "task_20240320_001", "status": "queued"}\n\n, notifying the user that the task has been queued and is awaiting execution.

[0042] In box 102, the agent used in method 100 executes autonomously. Based on the task framework and event channels established in box 101, box 102 activates the agent, enabling it to autonomously complete complex bioinformatics analyses without continuous user intervention. The entire execution process is manifested as a dynamic "think-execute-observe" cycle.

[0043] The input to Box 102 primarily originates from the output of Box 101 and the context acquired by the system. It includes the unique ID generated in Box 101. The system uses this ID to load the complete task record from the relational database. The user's original request and context refer to the user's natural language request obtained from the task record, such as "Perform quality control, dimensionality reduction, and cluster analysis on this single-cell data, and identify cell types," as well as the associated input data storage path, such as / workspace / task_20240320_001 / input / sc_data.h5ad.

[0044] The background scheduler starts a dedicated Worker thread based on the task identifier, which activates the core agent layer to begin working. The agent's execution is driven by a ReAct inference planner and follows a loop:

[0045] Loop Iteration 1:

[0046] Think: The ReAct inference planner receives and parses the user request. It identifies this as a "standard single-cell RNA-seq analysis" and plans the first key sub-step. During planning, the planner may query multi-level memory systems. For example, it may retrieve historical knowledge fragments related to "single-cell quality control indicators" from vector memory to aid decision-making.

[0047] Output plan: "Step 1: Use the Scanpy tool to load data and perform basic quality control, and calculate cell and gene count indicators."

[0048] Execution (Act): Based on the plan, the planner invokes the appropriate tool through the tool registry. The tool registry locates and invokes the MCP server configured for the scanpy tool.

[0049] The MCP server receives instructions (such as read_h5ad and qc_metrics), and within the task's workspace, actually executes the corresponding code from the Scanpy library to read the sc_data.h5ad file and calculate the quality metrics.

[0050] Observe: After code execution is complete, the core agent layer captures the execution result, which includes a success status, the generated quality control data frame, or possible error messages. The agent determines that this step was successful and stores a summary of the execution context as a memory fragment in the long-term memory of the multi-level memory system. Simultaneously, an event containing the "quality control complete" status and a summary of key metrics is generated.

[0051] Loop Iteration 2:

[0052] Think: Based on the observations from the previous round of "quality control completed," the ReAct inference planner plans the next step. It determines that data filtering and standardization are needed.

[0053] Output plan: "Step 2: Filter low-quality cells and genes according to quality control indicators, and standardize and logarithmically transform the expression data."

[0054] Execution (Act): Again, through the tool registry and the MCP protocol, it calls functions such as filter_cells in the scanpy toolchain.

[0055] Observe: Confirm that the filtering and standardization operations were successful, and record the number of cells / genes after filtering. Update the memory and generate an event.

[0056] Loop Iteration N: This "think-execute-observe" loop will continue dynamically.

[0057] Throughout the loop, the ReAct inference planner determines whether the user-requested analysis goal has been achieved after each "observation." If not, it initiates the next round of "thinking" based on the latest state. If an "execution" step fails, such as due to incorrect tool parameters, the planner enters "thinking" to correct the error or select an alternative solution. A multi-level memory system provides knowledge retrieval support for "thinking" throughout the loop and stores valuable context. If successful, it generates a final analysis report, which will be described later.

[0058] At this point, the final output of box 102 is a series of analysis result files generated iteratively and then summarized. These analysis result files contain all the intermediate and final result files generated by the tools and code during execution and output to the task workspace managed by the path manager.

[0059] Box 103 encapsulates the results of method 100. After box 102 completes all the "think-execute-observe" cycles and produces scattered intermediate results, box 103 integrates, interprets, and refines all the information by the core intelligent agent layer to generate a final analysis conclusion that is user-oriented, directly understandable, and usable.

[0060] Specifically, the complete output of box 102 above includes the analysis result file and process logs and context. At this point, the core agent layer is triggered to attempt to generate a solution. Specifically, the agent reads and parses the key result file, extracting core data. For example, it counts the number of cell populations from the clustering results and identifies characteristic expressed genes for each population from the list of differentially expressed genes. Furthermore, the agent associates the extracted data with biological knowledge. In some embodiments, this process utilizes multi-level memory systems, especially vector memory, to store marker gene information to perform functional annotation or type inference of cell populations. For example, it identifies populations with high expression of CD3D and CD8A as T cells. Based on the above induction and reasoning, the agent automatically generates a coherent, structured text summary. This summary directly responds to the user's original request, clearly stating the core findings and key conclusions.

[0061] It should be noted that during the execution of boxes 102 and 103, the system will push the intermediate processes and results of the entire process to the subscribed user's front end through the established Server-Sent Events (SSE) connection. This enables transparent monitoring of long-running tasks by the user within a "task-first" asynchronous architecture.

[0062] Furthermore, in some preferred embodiments, the system sends heartbeats periodically to maintain connection stability. For example, a note-type heartbeat event is automatically pushed every 2 seconds to prevent the connection from being closed due to timeout. When multiple consecutive SSE connection failures are detected, the system automatically downgrades from SSE mode to polling mode. The frontend will proactively send requests to the API at predetermined intervals, such as every 3 seconds, to retrieve the latest task status, ensuring that status information can still be delivered in complex network environments.

[0063] In summary, this process outputs a continuous, client-perceptible stream of information. The user frontend continuously receives and displays task progress details, intermediate result chart links, and final conclusions in the form of a real-time event stream. Through heartbeat and degradation mechanisms, the availability and reliability of the status feedback channel are ensured throughout the task cycle, which can last for several hours. Even in the event of network fluctuations, users can still track task progress.

[0064] Box 104 is used to implement the result archiving and report generation of method 100.

[0065] Box 104 is the final stage of task execution, automatically triggered after Box 103 is completed. Its core function is to systematically archive all data results generated during task execution and automatically generate structured analysis reports that meet the needs of different application scenarios, thereby ensuring the traceability, reproducibility, and direct availability of the analysis results.

[0066] The system obtains the final analysis conclusions and a complete set of results files after the work is completed. The final analysis conclusions come from the structured conclusion text generated in box 103. The complete set of results files includes all files in the task workspace uniformly managed by the path manager, including the raw data uploaded by the user, intermediate result files generated by all tool calls in box 102, and the final output charts, tables, and log files.

[0067] The system calls the relevant modules in the data and storage layer to perform unified archiving sequentially. The path manager automatically packages and compresses all files in the task workspace according to predefined directory structure rules, and transfers them to a permanent results archive storage system. This process generates a uniquely identified archive package for each task, such as task_20240320_001_results.zip.

[0068] The report generation module is activated. This module uses the final conclusions generated in box 103 as the core narrative, automatically integrating key charts and data from the archive and populating them into a predefined report template. The system supports multiple templates to suit different scenarios, such as a detailed version for internal research, a concise version for clinical use, or a publication format version for academic publishing.

[0069] Finally, a data package containing the complete analysis process and results is stored permanently in the system's results archive, allowing for easy review and download at any time. Furthermore, an analysis report, including a brief description of the methods, core results, visualizations, and interpretations of the conclusions, is also generated and stored.

[0070] In the technical solution of this invention, the task lifecycle is decoupled from the user's network connection. The task record is an independent and complete logical entity, with its state and all metadata stored in a relational database, independent of whether the user is online. This means that even if the user closes the browser immediately after submitting a request or experiences a network disconnection, the task entity and its associated analysis targets and input data are completely saved on the server side and will not be lost due to the termination of the front-end session.

[0071] Furthermore, in this technical solution, the analysis and execution are carried out asynchronously in the background. The specific execution of the task is independently completed by the background Worker thread scheduling core intelligent agent layer. The entire lengthy analysis process runs autonomously in the server background, and its execution progress does not depend on maintaining a front-end HTTP request-response session. Therefore, temporary fluctuations in network connectivity or active closure by the client will not interrupt the computing tasks already running in the background process, fundamentally ensuring the continuity and reliability of long-term task execution.

[0072] Furthermore, state tracking is achieved through persistent entities and a resilient communication channel. To address the issue of how users obtain progress, the system provides dual safeguards: First, users can query the authoritative source of task status stored in the database at any time using a unique task identifier. Second, the system establishes a dedicated event stream based on Server-Sent Events (SSE). This communication channel is equipped with a resilient mechanism including heartbeat keep-alive, breakpoint resumption, and failure degradation to polling, ensuring that task status updates, intermediate results, and final conclusions are stably and in real-time pushed to the user's front end over periods lasting several hours. Even if the user reconnects after network recovery, they can resubscribe to the event stream using the task identifier or directly query the final status to seamlessly obtain complete progress and results.

[0073] In summary, this technical solution, through a three-pronged design of "creating persistent task entities," "background asynchronous execution," and "establishing resilient state channels," transforms easily disrupted synchronous interactions into robust asynchronous task processing, thereby achieving the technical effect of supporting uninterrupted execution of long-term tasks and reliable state tracking.

[0074] In some preferred embodiments, there is also a design for MCP tool integration. The core of MCP tool integration is to achieve unified invocation of external bioinformatics professional tools through the Model Context Protocol (MCP), thereby giving the agent the ability to directly execute domain-specific operations.

[0075] For example, the system configures a separate MCP server in the tool registry center for each type of external tool that needs to be integrated. This server runs as a local process or a remote service, responsible for receiving standardized JSON-RPC requests and translating them into specific calls to the underlying bioinformatics tools. Each MCP server explicitly defines its list of exposed "tools" and parameter patterns in its configuration, such as defining a series of callable functions like read_h5ad, qc_metrics, pca, umap, and leiden for the scanpy tool.

[0076] In box 102 mentioned above, during the "Act" phase, the agent invokes the corresponding analysis tools through the tool registry. To achieve unified scheduling of the vast and specialized bioinformatics toolchain, the system adopts an MCP-based integration scheme, which acts like equipping the agent with a unified toolbox, enabling the AI ​​to easily command external specialized software as if calling internal functions.

[0077] Specifically, the system configures an independent MCP server for each type of bioinformatics tool, such as Scanpy and Salmon. This server runs as a local process or a remote service, defining the function interface and parameter specifications that can be called by standard protocols. The tool registry acts as a central coordinator, managing the registration and addressing of all MCP servers. When the ReAct inference planner determines the tool operation to be performed, it sends a request to the tool registry. The registry then routes the request to the corresponding MCP server, which drives the underlying bioinformatics tool to perform the actual calculations and finally returns the standardized results. In this embodiment, when the planning step decides to perform single-cell clustering, the agent calls the MCP server configured for the Scanpy tool through the tool registry to execute its Leiden function, thereby completing the specific clustering analysis calculations in the background and returning the clustering label results to the agent for subsequent observation.

[0078] In some preferred embodiments, a multi-level memory system is also designed. The multi-level memory system consists of three levels: short-term memory, long-term memory, and vector memory.

[0079] Specifically, in box 102 above, this multi-level memory system incorporates the "Think" and "Observe" stages to support the agent's autonomous planning and learning.

[0080] During the "Think" phase, when the agent's reasoning planner is analyzing user needs and formulating analysis plans, it can proactively retrieve historical knowledge fragments related to the current problem from vector memory. For example, it can retrieve "T cell marker genes" to assist in cell type annotation, thereby achieving retrieval-enhanced planning.

[0081] During the "Observe" phase, after analyzing the results of the tool's execution, the agent will summarize the key context and findings of this execution (such as "quality control pass rate 95%" or "clustering resolution set to 0.8") as valuable experience and store them in long-term memory for future task reference.

[0082] Meanwhile, the dialogue and state throughout the loop are maintained in real time by short-term memory, ensuring the coherence of logical reasoning within a single task. Through this design, the agent can not only maintain consistent working memory in a single long task, but also accumulate and utilize experiential knowledge in multiple interactions, significantly improving the coherence, personalization, and specialization of its analysis.

[0083] Figure 2 A block diagram of an electronic device 300 that can implement various embodiments of the present disclosure is shown. For example... Figure 2 As shown, device 300 includes a processor 301, which can perform various appropriate actions and processes based on computer program instructions loaded into random access memory (RAM) 303 according to computer program instructions stored in read-only memory (ROM) 302. RAM 303 may also store various programs and data required for the operation of device 300. The processor 301, ROM 302, and RAM 303 are interconnected via bus 304. Input / output (I / O) interface 305 is also connected to bus 304.

[0084] The various processes and procedures described above, such as method 100, can be executed by processor 301. For example, in some embodiments, method 100 may be implemented as a software program tangibly contained in a machine-readable medium. In some embodiments, part or all of the software program may be loaded and / or installed on device 300 via ROM 302. When the software program is loaded into RAM 303 and executed by processor 301, one or more actions of method 300 described above may be performed.

[0085] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0086] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. Machine-readable media can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing. Furthermore, although operations are depicted in a specific order, this should be understood as requiring that such operations be performed in the specific order shown or in sequential order, or requiring that all illustrated operations be performed to achieve the desired result. In certain environments, multitasking and parallel processing may be advantageous. Similarly, while several specific implementation details are included in the foregoing discussion, these should not be construed as limiting the scope of this disclosure. Certain features described in the context of individual embodiments may also be implemented in combination in a single implementation. Conversely, various features described in the context of a single implementation may also be implemented individually or in any suitable sub-combination in multiple implementations.

[0087] Although the subject matter has been described using language specific to structural features and / or methodological logic, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are merely illustrative examples of implementing the claims.

Claims

1. A bioinformatics task execution method based on a task-first architecture, characterized in that, It includes the following steps: Receive user bioinformatics task requests, assign task identifiers to the bioinformatics task, and create workspaces for the bioinformatics task; Establish an SSE connection for this bioinformatics task; The bioinformatics task is executed in the background, and the intermediate states during the execution process are encapsulated as events and pushed to the user terminal through the SSE connection. Once the background bioinformatics task is completed and the analysis results are generated, these results are pushed to the user terminal as the final event via the SSE connection.

2. The bioinformatics task execution method based on a task-priority architecture according to claim 1, characterized in that: During the process of establishing the SSE connection for the bioinformatics task, the client sends an HTTP request to the specified endpoint of the server. The request header carries the task identifier for authentication. After the server verifies the permissions, it puts the connection into long polling mode and keeps it open.

3. The bioinformatics task execution method based on a task-priority architecture according to claim 1, characterized in that: After the SSE connection is established, the background periodically sends heartbeat events of type annotation to prevent the SSE connection from closing due to timeout.

4. The bioinformatics task execution method based on a task-priority architecture according to claim 3, characterized in that: When the number of SSE connection failures exceeds a threshold, the SSE mode is downgraded to polling mode. In polling mode, the client periodically sends HTTP requests to the backend at preset time intervals to query the events of the bioinformatics task.

5. The bioinformatics task execution method based on a task-priority architecture according to claim 1, characterized in that: During the execution of the bioinformatics task in the background, external bioinformatics analysis tools are integrated through the MCP protocol. These bioinformatics analysis tools include at least one or more of the following: sequence alignment tools, quality control tools, quantitative analysis tools, variant detection tools, single-cell analysis tools, differential expression analysis tools, and functional enrichment analysis tools.

6. The bioinformatics task execution method based on a task-priority architecture according to claim 1, characterized in that: During the execution of the bioinformatics task in the background, the ReAct inference planner is used to drive the process and follows the execution sequence of thinking-execution-observation to determine whether the task has been completed. If it has been completed, the analysis results are generated. If it has not been completed, the process returns to thinking and starts the next cycle.

7. The bioinformatics task execution method based on a task-first architecture according to claim 6, characterized in that: The background includes a multi-layered memory system, which includes short-term memory, long-term memory, and vector memory. During the bioinformatics task performed using ReAct, historical knowledge fragments are retrieved from the vector memory during the thinking phase, and valuable experiences are stored in long-term memory during the observation phase.

8. The bioinformatics task execution method based on a task-priority architecture according to claim 1, characterized in that: The analysis results are populated into predefined report templates, which include clinical, research, and publication templates.

9. An electronic device, comprising a processor and a memory; the processor being connected to the memory; the memory being used to store executable program code; characterized in that, The processor runs a program corresponding to the executable program code stored in the memory to perform the method as described in any one of claims 1-8.

10. A computer-readable storage medium for storing a computer program, characterized in that, When the computer program is executed by a processor, it is capable of performing the method as described in any one of claims 1-8.

Images