A non-synchronous pipeline resume information processing method and system, a server and a medium

Abstract

The application relates to the technical field of information processing, and discloses a non-synchronous pipeline type resume information processing method and system, a server and a medium. The method comprises the following steps: creating a resume record and generating a unique task identifier according to a resume file and form fields of a candidate, returning the unique task identifier and triggering an asynchronous processing thread in a main request thread; extracting a candidate identity field value according to a resume file execution rule, filling an identity field of the resume record according to user filled values corresponding to the form fields and the candidate identity field value; supplementally extracting information from the identity field that is still empty in the filled resume record and writing the result into the resume record; generating a resume abstract, a multi-dimensional score and an interview question suggestion according to the resume record after the supplement extraction, and persistently storing the resume abstract, the multi-dimensional score and the interview question suggestion into a database, and updating the state of the resume record to completed. The application eliminates the synchronous waiting and request timeout risk after user submission, and improves the server concurrent carrying capacity.

Description

Technical Field

[0001] This application relates to the field of information processing technology, and in particular to a asynchronous pipeline-style resume information processing method, system, server, and medium. Background Technology

[0002] In existing online resume submission and screening systems, after candidates submit their resume files and form fields on the front-end page, the server typically performs file format parsing, text content extraction, key information extraction, and rule-based scoring or large language model analysis synchronously within the same request thread. Only after all processing steps are completed is the final result packaged into response data and returned to the front-end. Throughout the entire process, this request thread is continuously occupied until all time-consuming operations are finished.

[0003] The above synchronous processing method has the following drawbacks: the total time spent on file parsing and multiple calls to the large language model is relatively long, causing users to wait a long time for the page to respond after submission. Requests are easily interrupted due to timeouts, resulting in a poor user experience and limited server-side concurrent processing capabilities. At the same time, there is no clear priority strategy between the form fields manually filled in by the user and the results of rule parsing and large language model extraction, which can easily lead to errors where post-processing results overwrite the user's actual entries. In addition, the status of the parsing, scoring, and other stages in the resume processing is not visible to the front end, and users cannot perceive the current processing progress.

[0004] Therefore, existing technologies still need to be improved and developed. Summary of the Invention

[0005] The main purpose of this application is to provide a asynchronous pipeline-style resume information processing method, system, server and medium, which aims to solve the problem that synchronous resume processing in the prior art causes the request thread to be blocked for a long time, thereby causing user waiting timeout and reduced server concurrency.

[0006] The first aspect of this application provides a asynchronous pipeline-style resume information processing method, which includes the following steps: Receive the resume file and form fields submitted by the candidate, create a resume record based on the resume file and form fields, generate a unique task identifier based on the resume record, return the unique task identifier to the client that initiated the request, and dispatch the processing task of the resume record to the asynchronous processing thread of the server in the main request thread; In the asynchronous processing thread, the resume file is parsed into text content, and the text content is processed to extract candidate identity field values. The identity field of the resume record is then filled according to the priority relationship between the user-filled values ​​corresponding to the form fields in the resume record and the candidate identity field values. For the identity field that is still empty in the filled resume record, call the large language model to extract information to supplement the information, and write the supplementary extraction result into the resume record; Based on the supplemented and extracted resume records, a resume summary, multi-dimensional scoring, and interview question suggestions are generated. The resume summary, the multidimensional score, and the interview question suggestions are persistently stored in the database, and the status of the resume record is updated to "complete".

[0007] Optionally, in one embodiment of this application, the step of returning the unique task identifier to the client that initiated the request and dispatching the processing task of the resume record to the asynchronous processing thread of the server in the main request thread specifically includes: After the main request thread encapsulates the unique task identifier into response data and returns it to the client, it submits the processing task of the resume record to the asynchronous processing thread, so that the main request thread releases its processing of the resume record.

[0008] Optionally, in one embodiment of this application, the step of filling the identity field of the resume record according to the priority relationship between the user-filled values ​​corresponding to the form fields in the resume record and the candidate identity field values ​​specifically includes: Retrieve the user-filled values ​​corresponding to the form fields from the resume record; Determine whether the user-filled value is empty; If the user's filled value is not empty, then the user's filled value is retained as the fill value for the identity field; If the user's field value is empty, then the candidate identity field value is used as the filling value for the identity field.

[0009] Optionally, in one embodiment of this application, determining whether the user-filled value is empty specifically includes: Retrieve the string content of the user's entered value; Determine whether the string content matches a preset set of placeholders; If any placeholder in the preset placeholder set is matched, it is determined that the user has filled in an empty value; If no placeholder in the preset placeholder set is matched, it is determined that the user-filled value is not empty.

[0010] Optionally, in one embodiment of this application, the step of calling a large language model to extract information for the identity field that is still empty in the filled resume record, and writing the extracted information into the resume record, specifically includes: Check if the identity field in the resume record is still empty after being filled in; For the identity field that is still empty, construct a large language model prompt word carrying the text content; Send the prompt words to the large language model interface and receive the returned supplementary extraction results; The supplementary extraction results are written into the corresponding identity field in the resume record.

[0011] Optionally, in one embodiment of this application, the step of generating a resume summary, multi-dimensional score, and interview question suggestions based on the supplementally extracted resume records specifically includes: Generate a resume summary outlining the candidate's background based on the supplemented and extracted resume records; A multidimensional score is generated based on the supplemented resume records and the requirements of the target position. Based on the supplemented extracted resume records, suggested interview questions are generated.

[0012] Optionally, in one embodiment of this application, the step of persistently storing the resume summary, the multidimensional score, and the interview question suggestions in a database, and updating the status of the resume record to "complete," specifically includes: The resume summary, the multidimensional score, and the interview question suggestions are written into the database as the overall processing result of the resume record. Update the status field of the resume record to "Completed".

[0013] A second aspect of this application also provides a asynchronous pipelined resume information processing system, wherein the asynchronous pipelined resume information processing system is used to implement the asynchronous pipelined resume information processing method described in any of the above solutions; the asynchronous pipelined resume information processing system includes: The submission receiving and task dispatching module is used to receive the resume file and form fields submitted by the candidate, create a resume record based on the resume file and form fields, generate a unique task identifier based on the resume record, return the unique task identifier to the client that initiated the request, and dispatch the processing task of the resume record to the asynchronous processing thread of the server in the main request thread. The rule extraction and priority filling module is used in the asynchronous processing thread to parse the resume file into text content, perform rule extraction on the text content to obtain candidate identity field values, and fill the identity field of the resume record according to the priority relationship between the user-filled values ​​corresponding to the form fields in the resume record and the candidate identity field values. The AI ​​supplementation and extraction module is used to call a large language model to extract information from the identity field that is still empty in the resume record after it has been filled, and write the supplementation and extraction results into the resume record. The results generation module is used to generate resume summaries, multidimensional scores, and interview question suggestions based on the supplemented extracted resume records. The persistence and state management module is used to persistently store the resume summary, the multi-dimensional score, and the interview question suggestions in the database, and update the status of the resume record to complete.

[0014] A third aspect of this application also provides a server, wherein the server includes: a memory, a processor, and an asynchronous pipelined resume information processing program stored in the memory and executable on the processor, wherein when the asynchronous pipelined resume information processing program is executed by the processor, it implements the steps of the asynchronous pipelined resume information processing method described above.

[0015] A fourth aspect of this application also provides a computer-readable storage medium, wherein the computer-readable storage medium stores an asynchronous pipelined resume information processing program, which, when executed by a processor, implements the steps of the asynchronous pipelined resume information processing method described above.

[0016] Beneficial effects: This application provides a asynchronous pipelined method, system, server, and medium for processing resume information. By having the main request thread instantly return task identifiers and dispatch asynchronous processing, time-consuming operations such as file parsing, rule extraction, AI-assisted extraction, summary scoring generation, and persistent database storage are all executed sequentially in a background asynchronous thread. This allows the main thread to be released quickly, eliminating the risks of synchronous waiting and request timeouts after user submission and significantly improving the server's concurrency capacity. Simultaneously, by filling identity fields with the priority relationship between user-filled values ​​and rule-extracted values ​​in form fields, it ensures that manually entered content is not overwritten. AI-assisted extraction only applies to identity fields that remain empty after filling, balancing data accuracy and information completeness. Finally, the front-end can poll for record status based on task identifiers, enabling visualization of the processing process and improving the user experience. Attached Figure Description

[0017] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0018] Figure 1 A flowchart illustrating a preferred embodiment of the asynchronous pipeline-style resume information processing method of this application; Figure 2This is a flowchart illustrating the specific implementation steps of the entire execution process in a preferred embodiment of the asynchronous pipeline-style resume information processing method of this application. Figure 3 This is a schematic diagram of the three-layer information priority fusion in a preferred embodiment of the asynchronous pipeline-style resume information processing method of this application; Figure 4 This is a sequence diagram of the state synchronization of the front end based on task ID polling in a preferred embodiment of the asynchronous pipeline-style resume information processing method of this application. Figure 5 This is a structural diagram of a preferred embodiment of the asynchronous pipeline-style resume information processing system of this application; Figure 6 This is a structural diagram of a preferred embodiment of the server in this application.

[0019] Explanation of reference numerals in the attached figures: 100. Submission and Task Dispatch Module; 200. Rule Extraction and Priority Filling Module; 300. AI Supplement Extraction Module; 400. Result Generation Module; 500. Persistence and State Management Module. Detailed Implementation

[0020] To make the objectives, technical solutions, and effects of this application clearer and more explicit, the technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. The described embodiments are only possible technical implementations of this application and not all possible implementations. Based on the embodiments in this application, those skilled in the art can obtain other embodiments without creative effort, and these embodiments are also within the protection scope of this application.

[0021] First, let's introduce the terms used in the embodiments of this application: VM, Vacancy Management; LLM, Large Language Model; HR, Human Resources; AI, Artificial Intelligence; WebSocket, WebSocket Protocol, is a network socket protocol. SSE, Server-Sent Events; HTTP stands for Hypertext Transfer Protocol. REST API, Representational State Transfer Application Programming Interface. JSON, JavaScript Object Notation, is a JavaScript object representation. XML, Extensible Markup Language; HTML stands for Hypertext Markup Language. CSS stands for Cascading Style Sheets. JavaScript, JavaScript Programming Language; SQL, Structured Query Language; NoSQL, Not Only SQL / Non-relational SQL, is a non-relational database. NLP, Natural Language Processing; API, Application Programming Interface; SaaS stands for Software as a Service. JD, Job Description; KPI, Key Performance Indicator; QA stands for Quality Assurance. UI stands for User Interface. MVC (Model-View-Controller) MVP (Minimum Viable Product) CPU (Central Processing Unit) GPU (Graphics Processing Unit) RAM (Random Access Memory) ROM, Read-Only Memory; SDK, Software Development Kit; IDE, Integrated Development Environment; IP stands for Internet Protocol. DNS, Domain Name System; TCP, Transmission Control Protocol; UDP, User Datagram Protocol; FTP stands for File Transfer Protocol. SMTP, Simple Mail Transfer Protocol; POP3, Post Office Protocol version 3; IMAP, Internet Message Access Protocol; LDAP, Lightweight Directory Access Protocol; OAuth, Open Authorization; JWT, JSON Web Token; TLS, Transport Layer Security. SSL, Secure Sockets Layer; HTTPS stands for Hypertext Transfer Protocol Secure. PKI, Public Key Infrastructure; CA, Certificate Authority; CRUD, Create, Read, Update, Delete (basic database operations); DML, Data Manipulation Language; DDL, Data Definition Language; DCL, Data Control Language; ACID stands for Atomicity, Consistency, Isolation, and Durability (transaction properties). CAP stands for Consistency, Availability, and Partition Tolerance (a theorem for distributed systems). BASE stands for Basically Available, Soft State, Eventual Consistency (distributed system theory). CI / CD, Continuous Integration / Continuous Delivery (Deployment); DevOps, Development and Operations; K8s, Kubernetes, Kubernetes container orchestration platform; Docker, Docker Container Platform.

[0022] Existing online resume submission or screening systems typically complete file parsing, information extraction, AI analysis and scoring synchronously within the same request thread after a candidate submits their resume, and only return the results to the front end after all processing is complete.

[0023] The related technologies have the following shortcomings: During synchronous processing, file parsing and multiple LLM calls are time-consuming, requiring users to wait for a long time after submission, and requests are prone to timeouts, resulting in a poor user experience and weak concurrency capabilities. The information source is singular or the coverage strategy is chaotic: there is no clear priority among the three sources of user manual filling, rule parsing, and AI extraction, which can easily lead to errors such as AI results overwriting the user's actual filling. The processing process is not visible to the front end, and users cannot perceive the stage status of "parsing, scoring, or completed".

[0024] This application can be applied to scenarios such as enterprise recruitment management systems, online recruitment platforms, and human resource management systems. The system receives resume files and form fields submitted by candidates through a web browser or mobile application, and automatically parses, extracts information, performs comprehensive scoring, and generates interview suggestions.

[0025] The implementation of this solution is a server-side resume processing system, which is jointly completed by a main request thread and an asynchronous processing thread. The main request thread runs in a server-side container and is responsible for receiving client requests and providing immediate feedback; the asynchronous processing thread runs in a server-side thread pool or message queue consumer and is responsible for executing time-consuming processing tasks. The front-end client (browser or app) is only responsible for submitting requests, receiving task identifiers, and periodically checking processing status, and does not participate in any resume parsing or information extraction logic.

[0026] In this application, the main thread provides an immediate response after the candidate submits the application, while the background asynchronous thread processes the application in a pipeline of "parsing - rule extraction - AI supplementation - summary - scoring - interview suggestions - database entry". The application integrates information from multiple sources with a priority of "user input > rule extraction > AI supplementation". The front end polls the stage status based on the task identifier, thereby eliminating waiting, clarifying information priorities, and making the processing process visible.

[0027] The technical solutions of this application will be described in detail below with reference to specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments.

[0028] The asynchronous pipeline-style resume information processing method described in the preferred embodiment of this application, such as... Figure 1 As shown, the asynchronous pipeline-style resume information processing method includes the following steps: In step S10, the candidate's resume file and form fields are received, a resume record is created based on the resume file and form fields, a unique task identifier is generated based on the resume record, the unique task identifier is returned to the client that initiated the request, and the processing task of the resume record is dispatched to the asynchronous processing thread of the server in the main request thread.

[0029] In one possible implementation, returning the unique task identifier and triggering the asynchronous processing thread in the main request thread specifically involves the main request thread encapsulating the unique task identifier into response data and returning it to the client, then submitting the processing task of the resume record to the asynchronous processing thread, so that the main request thread releases its processing of the resume record.

[0030] This application's embodiments stipulate that the main request thread returns response data before submitting the task to the asynchronous processing thread. This "return first, submit later" design ensures minimal response latency. If the task is submitted first and then the response is returned, the task submission itself (such as thread pool queue operations), although extremely short, will still delay the response return. By returning first and then submitting, the response latency is compressed to only include the operation latency of record creation and identifier generation (typically in the millisecond range), achieving optimal user response speed.

[0031] Specifically, candidates fill out form fields (such as name, phone number, email, self-introduction, etc.) on the front-end page, upload their resume files, and click submit. The front-end encapsulates the resume file and form fields together into an HTTP request and sends it to the server. Upon receiving the request, the server's main request thread performs the following operations: Based on the received resume file and form fields, it creates a resume record. This record is a data entry in the database, containing a record number, candidate identity fields (name, phone number, email, etc.), education field, work experience field, skills field, resume text content, processing status field, rating field, summary field, and interview suggestion field. A unique task identifier is generated for this resume record. This identifier is a globally unique character sequence used to uniquely associate the resume record in subsequent processes. The task identifier is encapsulated into response data and immediately returned to the requesting client. At this point, the main request thread does not wait for subsequent time-consuming steps such as resume parsing, information extraction, or rating; it completes the response to the client. Subsequently, the main request thread submits the processing task of the resume record to the asynchronous processing thread pool on the server. This submission operation involves placing the resume record identifier or task identifier into the task queue of the thread pool, waiting for an idle asynchronous processing thread to retrieve it from the queue and execute it.

[0032] Through the above operations, the main request thread releases its processing power for the current request after creating the record, generating the identifier, and returning the response. This release of the main request thread means the server can continue to receive and process other client requests, significantly improving the server's concurrent processing capabilities. Simultaneously, the client receives an immediate receipt after submission, eliminating the long wait times for responses that occur in traditional synchronous processing, resulting in a significantly improved user experience.

[0033] This application achieves a zero-wait experience for resume submission through a non-blocking mechanism of "instant receipt + asynchronous dispatch". No matter how long the subsequent resume file parsing and large language model calls take (which may reach several seconds or even tens of seconds), users can receive a submission success receipt without waiting, thus eliminating the request timeout problem.

[0034] In step S20, in the asynchronous processing thread, the resume file is parsed into text content, and the candidate identity field values ​​are extracted by performing rules on the text content. The identity field of the resume record is then filled according to the priority relationship between the user-filled values ​​corresponding to the form fields in the resume record and the candidate identity field values.

[0035] In one possible implementation, the step of filling the identity field of the resume record specifically includes: obtaining the user-filled value corresponding to the form field in the resume record; determining whether the user-filled value is empty; if the user-filled value is not empty, then retaining the user-filled value as the fill value of the identity field; if the user-filled value is empty, then using the candidate identity field value as the fill value of the identity field.

[0036] In one possible implementation, the step of determining whether the user-filled value is empty specifically includes: obtaining the string content of the user-filled value; determining whether the string content matches a preset placeholder set; if it matches any placeholder in the preset placeholder set, then determining that the user-filled value is empty; if it does not match any placeholder in the preset placeholder set, then determining that the user-filled value is not empty.

[0037] Specifically, in the asynchronous processing thread, the following operations are performed in sequence: The first step is file parsing: The resume file is parsed into plain text. For PDF files, a PDF parsing library is used to extract the text; for DOC or DOCX files, a Word parsing library is used. If the candidate has filled in text such as a self-introduction in the form, the parsed text is merged with the form text to form a complete text to be processed.

[0038] The second step is rule extraction: Rule extraction is performed on the merged text content to obtain candidate identity field values. Rule extraction refers to extracting structured information from unstructured resume text using pre-defined text matching rules (such as regular expressions and keyword lists). For example: using email matching rules to extract email addresses from the text; using mobile phone number matching rules to extract phone numbers from the text; using a pre-defined education keyword list to match education information from the text; and using a pre-defined skills keyword list to match skills information from the text. The output of rule extraction is the candidate identity field values, that is, the candidate values ​​for each identity field parsed from the resume file.

[0039] The third step is priority population: Retrieve the user-filled values ​​corresponding to the form fields from the resume record, i.e., the content manually entered by the candidate in the front-end form. Then, determine if the user-filled value is empty: if it is not empty, retain it as the fill value for the identity field, without overwriting it with the candidate value extracted by the rules; if it is empty, use the candidate identity field value extracted by the rules as the fill value for the identity field. This process ensures that the information manually entered by the user has the highest priority, preventing the rule parsing results from overwriting the user's actual input.

[0040] This application resolves the multi-source information conflict problem by prioritizing user-entered data over rule-extracted data. In traditional solutions, there is a lack of clear priority strategies between user-entered fields and rule-parsed fields, potentially leading to post-processing results overwriting the actual user-entered values. This embodiment ensures the complete preservation of manually entered user information through explicit priority determination.

[0041] In step S30, the large language model is called to extract information for the identity field that is still empty in the resume record after it has been filled, and the extraction result is written into the resume record.

[0042] In one possible implementation, step S30 specifically includes: checking whether the identity field of the resume record is still empty after being filled; for the identity field that is still empty, constructing a large language model prompt word carrying the text content; sending the prompt word to the large language model interface and receiving the returned supplementary extraction result; and writing the supplementary extraction result into the corresponding identity field in the resume record.

[0043] Specifically, after completing rule extraction and priority filling, check whether each identity field in the resume record is still empty. "Empty" here includes a field value being an empty string, null, or matching a placeholder from the preset placeholder set. For each identity field that is still empty, perform the following operations: Construct a prompt word for the large language model carrying the complete resume text. This prompt word is a natural language instruction text that instructs the large language model to extract specified identity fields from the resume text. The prompt word explicitly specifies the names of the fields to be extracted (such as name, email, phone number) and limits the output to only the extracted fields. Send the constructed prompt word to the large language model interface and receive the extraction results returned by the interface. Based on its semantic understanding capabilities, the large language model can accurately identify and extract information from the specified fields from unstructured natural language text. Write the received supplementary extraction results into the corresponding identity fields in the resume record.

[0044] The key constraint of this application's embodiment is that AI supplementation extraction is only performed on identity fields that are still empty after rule extraction and priority filling, and the extraction result only fills in empty fields, without overwriting any existing values ​​(whether they are user-filled values ​​or rule-extracted values).

[0045] This application utilizes a large language model to semantically supplement identity fields that cannot be covered by rule extraction. Rule extraction relies on preset text patterns (such as regular expressions), and it often fails to effectively recognize content written in free-form natural language. The large language model, with its semantic understanding capabilities, can accurately extract information from such unstructured text, filling the coverage gaps of rule extraction. Simultaneously, the "fill in the blanks only" strategy ensures that the AI-supplemented results do not incorrectly overwrite user-filled values ​​or information already extracted by the rules.

[0046] In step S40, a resume summary, multidimensional score, and interview question suggestions are generated based on the supplemented extracted resume records.

[0047] In one possible implementation, step S40 specifically includes: generating a resume summary outlining the candidate's background based on the supplementally extracted resume records; generating a multi-dimensional score based on the supplementally extracted resume records and the target job requirements; and generating interview question suggestions based on the supplementally extracted resume records.

[0048] Specifically, after completing the AI-assisted information extraction, the following three types of results are generated based on the complete resume record after the extraction: First, the resume summary: This generates a text summary based on the resume, outlining the candidate's background. This summary is a concise description of the candidate's education, work experience, core skills, and other relevant information.

[0049] Second, multi-dimensional scoring: Based on the requirements of the target position, candidates are quantitatively evaluated from multiple dimensions. Specifically, the job description (JD) of the target position can be compared with the information in the resume, and scores can be calculated for dimensions such as education matching degree, work experience matching degree, and skills matching degree, ultimately resulting in a comprehensive score.

[0050] Third, interview question suggestions: Generate a list of key questions to be asked candidates during the interview based on their resumes. These questions can include follow-up questions addressing unclear or missing information in the resume, as well as verification questions about the candidate's strengths demonstrated in the resume.

[0051] It should be noted that the above three types of results are all based on the same input, namely the complete resume record after supplementary extraction, but they each produce different types of information and serve different subsequent application scenarios.

[0052] This application transforms structured resume records into three deliverables that can be directly used in recruitment decisions: a summary for quickly understanding a candidate's profile, multidimensional scoring for quantitative evaluation and ranking, and interview suggestions to guide subsequent interview stages. These three deliverables together form a complete data support chain from resume to interview.

[0053] In step S50, the resume summary, the multidimensional score, and the interview question suggestions are persistently stored in the database, and the status of the resume record is updated to complete.

[0054] In one possible implementation, step S50 specifically includes: writing the resume summary, the multidimensional score, and the interview question suggestions as the overall processing result of the resume record into the database at once; and updating the status field of the resume record to "complete".

[0055] Specifically, the persistence operations are executed uniformly using a database transaction mechanism: the three types of results mentioned above are treated as components of the overall resume record processing result, and written to the corresponding data table fields within the same database transaction. If any operation fails during the write process, the entire transaction is rolled back, and the database is restored to its state before the operation. Simultaneously, the resume record's status field is updated from the initial "Processing" to "Completed." The status field is an attribute column in the resume record used to indicate the current processing progress.

[0056] This application ensures that intermediate processing results are not leaked into the database. In traditional solutions, processing results at each stage may be written to the database in installments, leading to users or downstream systems being able to query incomplete intermediate states such as "parsing completed, but not yet scored." This embodiment ensures that all results are always exposed as complete and consistent by writing them all at once after all processing is complete. Furthermore, once the status is updated to "complete," front-end polling queries can detect that processing is finished, thus stopping polling or displaying the final result.

[0057] It should be noted that asynchronous processing is wrapped in transactions and written to the database all at once at the end: ensuring that intermediate states are not leaked and results are consistent; the identity field adopts a "fill in blanks only" strategy: the user-filled value is distinguished from the actual value by placeholders (such as "to be parsed / to be filled") to realize source priority determination; the front-end polling adopts a limited number of periodic queries (such as every 5 seconds, with a certain number of times as the upper limit): to achieve a balance between real-time performance and server pressure.

[0058] Understandably, asynchronous execution can be implemented using thread pools / message queues and can be horizontally scaled; polling can be replaced by WebSocket / SSE proactive push; pipeline stages can be added or removed pluggable; priority sources can be expanded (e.g., adding "HR manual correction" as the highest priority).

[0059] See Figure 2 The system in this application embodiment includes: a submission receiving and instant receipt module (701), which receives the files and form fields uploaded by the candidate, creates a resume record and generates a task identifier, and then immediately returns it to the front end, while triggering asynchronous processing; an asynchronous processing thread (702), which is separate from the main request thread (non-blocking), and drives the following in sequence: a file parsing module (703) which parses PDF / DOC / DOCX into text; a rule information extraction module (704) which extracts name, email, phone number, education, years of experience, skills, and keywords using regular expressions / vocabularies; an AI information supplementation module (705) which uses LLM extraction to supplement the still empty identity fields; a summary generation module (706), a scoring module (707), and an interview suggestion generation module (708) which produce corresponding results in sequence; and a persistence module (709) which uniformly stores the data in the database and updates the record status. Multi-source information is processed according to... Figure 3 Priority fusion. The front-end polling module (710) periodically queries records based on task identifiers to obtain the "processing / completed / failed" status and phased results, such as... Figure 4 As shown.

[0060] See Figure 2 , Figure 3 and Figure 4 The asynchronous pipeline-style resume information processing method of this application will be further described below through specific embodiments: S1: The module (701) receives the uploaded file and form fields, creates a resume record (initially in the state of "processing") and generates a task identifier. The main thread immediately sends a receipt to the front end, and then triggers asynchronous processing.

[0061] S2: The asynchronous thread (702) drives the module (703) to parse the resume file into text; if the form already includes a self-introduction, it is appended and merged.

[0062] S3: The module (704) extracts rules from the text and fills in the blanks according to the three-level priority: the fields that have been filled in by the user (not empty and not "to be parsed / to be filled") are retained and not overwritten; the blank fields are filled with the extracted rule values.

[0063] S4: The module (705) calls LLM extraction when AI is enabled, and only fills in the identity fields (name / email / phone) that are still empty after S3, without overwriting the existing values.

[0064] S5: Module (706) generates a resume summary; Module (707) calls up multi-dimensional scoring in conjunction with the target position; Module (708) generates interview question suggestions.

[0065] S6: The module (709) persists all results at once and updates the record status to "complete" (or "failed" if there is an exception).

[0066] S7: The front-end module (710) periodically polls and records the status and stage results using the task identifier until "completed / failed".

[0067] The timing relationship is as follows: S1 and S2~S6 belong to different threads (the main thread provides immediate feedback, and the background processes asynchronously, both in non-blocking parallelism); S2-S3-S4-S5-S6 are executed in a strictly sequential pipeline within the asynchronous thread; information fusion follows the priority of "user input > rule extraction > AI supplementation (only empty fields)"; S7 and S6 are synchronized by recording status fields to form a state machine (processing / completed / failed).

[0068] The embodiments of this application specifically achieve the following technical effects: First, zero-wait commit: Submissions receive an immediate receipt, eliminating long synchronous waits and request timeouts, thus improving concurrency handling. Second, information is not mistakenly covered: three levels of priority are clearly defined to prevent AI from extracting and covering the user's real information; Third, the processing process is visualized: the front end polls the stage status based on the task identifier, and users can perceive "processing / completed / failed"; Fourth, pipeline decoupling: single-point failures at each stage can be captured without interrupting the overall process (e.g., summary failure does not affect the score).

[0069] Next, referring to the accompanying drawings, a non-synchronous pipeline-style resume information processing system according to an embodiment of this application is described, used to implement the non-synchronous pipeline-style resume information processing method described in any of the above solutions.

[0070] Figure 5 This is a structural diagram of the asynchronous pipeline-type resume information processing system according to an embodiment of this application.

[0071] like Figure 5 As shown, the asynchronous pipeline-style resume information processing system includes: a submission receiving and task dispatch module 100, a rule extraction and priority filling module 200, an AI supplement extraction module 300, a result generation module 400, and a persistence and state management module 500.

[0072] Specifically, the submission receiving and task dispatching module 100 is used to receive the resume file and form fields submitted by the candidate, create a resume record based on the resume file and form fields, generate a unique task identifier based on the resume record, return the unique task identifier to the client that initiated the request, and dispatch the processing task of the resume record to the asynchronous processing thread of the server in the main request thread. The rule extraction and priority filling module 200 is used in the asynchronous processing thread to parse the resume file into text content, perform rule extraction on the text content to obtain candidate identity field values, and fill the identity field of the resume record according to the priority relationship between the user-filled values ​​corresponding to the form fields in the resume record and the candidate identity field values. AI supplementation extraction module 300 is used to call a large language model to extract information from the identity field that is still empty in the resume record after it has been filled, and write the supplementation extraction result into the resume record. The result generation module 400 is used to generate a resume summary, multi-dimensional score and interview question suggestions based on the supplemented extracted resume records. The persistence and state management module 500 is used to persistently store the resume summary, the multi-dimensional score, and the interview question suggestions in the database, and update the status of the resume record to complete.

[0073] Figure 6 A structural diagram of a server provided in an embodiment of this application. The server may include: The memory 501, the processor 502, and the computer program stored on the memory 501 and capable of running on the processor 502.

[0074] When the processor 502 executes the program, it implements the asynchronous pipelined resume information processing method provided in the above embodiments.

[0075] Furthermore, the server-side also includes: Communication interface 503 is used for communication between memory 501 and processor 502.

[0076] The memory 501 is used to store computer programs that can run on the processor 502.

[0077] Memory 501 may include high-speed RAM memory, and may also include non-volatile memory, such as at least one disk storage device.

[0078] If the memory 501, processor 502, and communication interface 503 are implemented independently, then the communication interface 503, memory 501, and processor 502 can be interconnected via a bus to complete communication between them. The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EIS) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of representation, Figure 6 The bus is represented by a single thick line, but this does not mean that there is only one bus or one type of bus.

[0079] Optionally, in a specific implementation, if the memory 501, processor 502, and communication interface 503 are integrated on a single chip, then the memory 501, processor 502, and communication interface 503 can communicate with each other through an internal interface.

[0080] Processor 502 may be a central processing unit (CPU), an application specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application.

[0081] This embodiment also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the asynchronous pipelined resume information processing method described above.

[0082] One embodiment of this application provides a computer program product, including a computer program that, when executed by a processor, implements the features described in this application. Figure 1 The asynchronous pipeline-style resume information processing method provided in any of the corresponding embodiments.

[0083] In the description of this specification, the references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this application. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of different embodiments or examples.

[0084] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of this application, "N" means at least two, such as two, three, etc., unless otherwise explicitly specified.

[0085] Any process or method described in the flowchart or otherwise herein can be understood as representing a module, segment, or portion of code comprising one or N executable instructions for implementing custom logic functions or processes, and the scope of the preferred embodiments of this application includes additional implementations in which functions may be performed not in the order shown or discussed, including substantially simultaneously or in reverse order depending on the functions involved, as should be understood by those skilled in the art to which embodiments of this application pertain.

[0086] The logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be embodied in any computer-readable storage medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-included system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this specification, "computer-readable storage medium" can be any means that can contain, store, communicate, propagate, or transmit programs for use by, or in conjunction with, an instruction execution system, apparatus, or device. More specific examples (a non-exhaustive list) of computer-readable storage media include: an electrical connection having one or more wires (electronic device), a portable computer disk drive (magnetic device), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Alternatively, the computer-readable storage medium could be paper or other suitable media on which the program can be printed, since the program can be obtained electronically by optically scanning the paper or other medium, followed by editing, interpreting, or otherwise processing as necessary, and then stored in a computer memory.

[0087] It should be understood that the various parts of this application can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiments, the N steps or methods can be implemented using software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware as in another embodiment, it can be implemented using any one or a combination of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0088] Those skilled in the art will understand that all or part of the steps of the methods described in the above embodiments can be implemented by a program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it includes one or a combination of the steps of the method embodiments.

[0089] Furthermore, the functional units in the various embodiments of this application can be integrated into a processing module, or each unit can exist physically separately, or two or more units can be integrated into a module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium.

[0090] The storage medium mentioned above can be a read-only memory, a disk, or an optical disk, etc. Although embodiments of this application have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting this application. Those skilled in the art can make changes, modifications, substitutions, and variations to the above embodiments within the scope of this application.

[0091] It should be understood that the application of this application is not limited to the examples above. Those skilled in the art can make improvements or modifications based on the above description, and all such improvements and modifications should fall within the protection scope of the appended claims.

[0092] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features therein. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of this application.

Claims

1. A asynchronous pipeline-style resume information processing method, characterized in that, The asynchronous pipeline-style resume information processing method includes: Receive the resume file and form fields submitted by the candidate, create a resume record based on the resume file and form fields, generate a unique task identifier based on the resume record, return the unique task identifier to the client that initiated the request, and dispatch the processing task of the resume record to the asynchronous processing thread of the server in the main request thread; In the asynchronous processing thread, the resume file is parsed into text content, and the text content is processed to extract candidate identity field values. The identity field of the resume record is then filled according to the priority relationship between the user-filled values ​​corresponding to the form fields in the resume record and the candidate identity field values. For the identity field that is still empty in the filled resume record, call the large language model to extract information to supplement the information, and write the supplementary extraction result into the resume record; Based on the supplemented and extracted resume records, a resume summary, multi-dimensional scoring, and interview question suggestions are generated. The resume summary, the multidimensional score, and the interview question suggestions are persistently stored in the database, and the status of the resume record is updated to complete.

2. The asynchronous pipeline-style resume information processing method according to claim 1, characterized in that, The step of returning the unique task identifier to the requesting client and dispatching the processing task recorded in the resume to the asynchronous processing thread of the server in the main request thread specifically involves: After the main request thread encapsulates the unique task identifier into response data and returns it to the client, it submits the processing task of the resume record to the asynchronous processing thread, so that the main request thread releases its processing of the resume record.

3. The asynchronous pipeline-style resume information processing method according to claim 1, characterized in that, The step of filling the identity field of the resume record according to the priority relationship between the user-filled values ​​corresponding to the form fields in the resume record and the candidate identity field values ​​specifically includes: Retrieve the user-filled values ​​corresponding to the form fields from the resume record; Determine whether the user-filled value is empty; If the user's filled value is not empty, then the user's filled value is retained as the fill value for the identity field; If the user's field value is empty, then the candidate identity field value is used as the filling value for the identity field.

4. The asynchronous pipeline-style resume information processing method according to claim 3, characterized in that, The determination of whether the user-filled value is empty specifically includes: Retrieve the string content of the user's entered value; Determine whether the string content matches a preset set of placeholders; If any placeholder in the preset placeholder set is matched, it is determined that the user has filled in an empty value; If no placeholder in the preset placeholder set is matched, it is determined that the user-filled value is not empty.

5. The asynchronous pipeline-style resume information processing method according to claim 1, characterized in that, The step of calling a large language model to extract information from the still empty identity field in the filled resume record, and writing the extracted information into the resume record, specifically includes: Check if the identity field in the resume record is still empty after being filled in; For the identity field that is still empty, construct a large language model prompt word carrying the text content; Send the prompt words to the large language model interface and receive the returned supplementary extraction results; The supplementary extraction results are written into the corresponding identity field in the resume record.

6. The asynchronous pipeline-style resume information processing method according to claim 1, characterized in that, The process of generating resume summaries, multi-dimensional scores, and interview question suggestions based on the supplemented extracted resume records specifically includes: Generate a resume summary outlining the candidate's background based on the supplemented and extracted resume records; A multi-dimensional score is generated based on the supplemented resume records and the requirements of the target position. Based on the supplemented extracted resume records, suggested interview questions are generated.

7. The asynchronous pipeline-style resume information processing method according to claim 1, characterized in that, The step of persistently storing the resume summary, the multidimensional score, and the interview question suggestions in the database, and updating the status of the resume record to "complete," specifically includes: The resume summary, the multidimensional score, and the interview question suggestions are written into the database as the overall processing result of the resume record. Update the status field of the resume record to "Completed".

8. A asynchronous pipeline-style resume information processing system, characterized in that, The asynchronous pipeline-style resume information processing system is used to implement the asynchronous pipeline-style resume information processing method according to any one of claims 1-7, wherein the asynchronous pipeline-style resume information processing system comprises: The submission receiving and task dispatching module is used to receive the resume file and form fields submitted by the candidate, create a resume record based on the resume file and form fields, generate a unique task identifier based on the resume record, return the unique task identifier to the client that initiated the request, and dispatch the processing task of the resume record to the asynchronous processing thread of the server in the main request thread. The rule extraction and priority filling module is used in the asynchronous processing thread to parse the resume file into text content, perform rule extraction on the text content to obtain candidate identity field values, and fill the identity field of the resume record according to the priority relationship between the user-filled values ​​corresponding to the form fields in the resume record and the candidate identity field values. The AI ​​supplementation and extraction module is used to call a large language model to extract information from the identity field that is still empty in the resume record after it has been filled, and write the supplementation and extraction results into the resume record. The results generation module is used to generate resume summaries, multidimensional scores, and interview question suggestions based on the supplemented extracted resume records. The persistence and state management module is used to persistently store the resume summary, the multi-dimensional score, and the interview question suggestions in the database, and update the status of the resume record to complete.

9. A server-side component, characterized in that, The server includes: a memory, a processor, and an asynchronous pipelined resume information processing program stored in the memory and executable on the processor. When the asynchronous pipelined resume information processing program is executed by the processor, it implements the steps of the asynchronous pipelined resume information processing method as described in any one of claims 1-7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores an asynchronous pipelined resume information processing program, which, when executed by a processor, implements the steps of the asynchronous pipelined resume information processing method as described in any one of claims 1-7.

Images