A large model-based dynamic knowledge graph intelligent construction method and system

Abstract

The application discloses a kind of dynamic knowledge graph intelligent construction method and system based on large model, it is related to artificial intelligence technical field, the method includes: based on the construction of dynamic knowledge graph structure of double time data model, obtain knowledge graph framework;Entity, entity relationship and the time attribute information corresponding to entity relationship between entities are extracted from input data using large model;The extracted entity is matched, fused and deduplicated with the existing entity in dynamic knowledge graph, and the updated entity node set and the corresponding relationship edge are obtained;Based on the time attribute information extracted, identify time conflict, update time attribute information to obtain the relationship edge set with time sequence consistency;The updated entity node set and the relationship edge set with time sequence consistency are persisted in graph database by batch operation;In response to the query request, time-aware retrieval is carried out in dynamic knowledge graph based on the time attribute information of relationship edge.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, specifically a method and system for intelligent construction of dynamic knowledge graphs based on large models. Background Technology

[0002] With the deep integration of big data and artificial intelligence technologies, knowledge graphs, as an effective representation of structured knowledge, play a core role in fields such as intelligent search, recommendation systems, and decision support. While current mainstream knowledge graph technologies based on retrieval enhancement can integrate multi-source heterogeneous data, they still face significant limitations. Their batch update model cannot efficiently support real-time, incremental data integration, making it difficult to cope with dynamic scenarios where information evolves rapidly. Traditional graphs can only record the current state, lacking the ability to explicitly track and model the lifecycle of knowledge itself (when it takes effect and when it expires). This results in an inability to accurately respond to temporally sensitive queries such as "what was the real situation at a certain historical moment," limiting their value in applications requiring precise historical backtracking and analysis. Summary of the Invention

[0003] The purpose of this invention is to provide a method and system for intelligent construction of dynamic knowledge graphs based on large models, so as to solve the problems raised in the prior art.

[0004] To achieve the above objectives, the present invention provides the following technical solution: a method for intelligent construction of dynamic knowledge graphs based on large models, the method comprising:

[0005] S100. Construct a dynamic knowledge graph structure based on a dual-temporal data model to obtain a knowledge graph framework that includes entity nodes and relation edges with temporal attribute information. S200: Obtain input data, and use a large model to extract entities, relationships between entities, and time attribute information corresponding to the relationships between entities from the input data; S300. The extracted entities are matched, merged and deduplicated with the existing entities in the dynamic knowledge graph to obtain an updated set of entity nodes and corresponding relation edges. S400. Based on the extracted time attribute information, identify the temporal conflict between the extracted relationship and the existing relationship in the dynamic knowledge graph, update the time attribute information, coordinate the temporal conflict, and obtain a set of relationship edges with temporal consistency. S500. The updated set of entity nodes and the set of relation edges with temporal consistency are persisted to the graph database through batch operations. S600: In response to the query request, perform temporal-aware retrieval in the dynamic knowledge graph based on the temporal attribute information of the relation edges.

[0006] According to the above scheme, step S100 includes: S110. Construct a dual-temporal data model, wherein the dual-temporal data model tracks the transaction time and the effective time respectively; wherein, the transaction time is used to record the time when the information is recorded by the system, and the effective time is used to record the time when the information is actually established in the objective scenario; S120. Define a node structure based on the dual-temporal data model. The nodes include entity nodes, plot nodes, and community nodes. Entity nodes represent specific entity objects in the knowledge graph and include name, embedding vector, and attribute information. Plot nodes represent discrete events or data fragments on a time series and include source description, content, and effective time information. Community nodes represent entity clusters grouped according to semantic similarity and include semantic similarity cluster association information and summary information. S130. Define an edge structure based on the dual-temporal data model. The edge structure includes entity edges, plot edges, and community edges. The entity edge is used to connect two entity nodes, representing the relationship between entities, and includes a relationship name, fact description, and embedding vector. The plot edge is used to connect plot nodes and entity nodes, indicating that a specific entity is mentioned in a specific plot. The community edge is used to connect community nodes and entity nodes or community nodes, indicating that an entity or sub-community belongs to a certain community. S140. Configure a time attribute field for the edge structure. The time attribute field includes a creation timestamp, an effective timestamp, an invalidation timestamp, and an expiration timestamp. The creation timestamp is the timestamp that records the time when a node or edge is created in the system. The effective timestamp is the timestamp that records the time when the relationship between entities represented by the edge begins to be effective. The invalidation timestamp is the timestamp that records the time when the relationship between entities represented by the edge stops being effective. The expiration timestamp is the timestamp that records the time when a node or edge is marked as expired in the system. The time attribute fields work together to support a dual-temporal data model, synchronously tracking the validity time VT and transaction time TT. The validity time is defined by the effective timestamp and the expiration timestamp, corresponding to the establishment interval of the fact in the objective scenario [valid_at, invalid_at). Here, valid_at represents the effective timestamp, marking the moment when the fact begins to be established in the objective scenario, and invalid_at represents the expiration timestamp, marking the moment when the fact stops being established in the objective scenario. The transaction time is defined by the creation timestamp and the expiration timestamp, corresponding to the recording interval of the fact in the system [created_at, expired_at]. Here, created_at represents the creation timestamp, marking the moment when the fact is first recorded by the system, and expired_at represents the expiration timestamp, marking the moment when the fact is marked as historical or expired in the system records. Only when both the validity time interval and the transaction time interval are in a valid state are the relation edges considered as queryable temporal facts. When an old fact is replaced by a new fact, its current state is terminated by updating the expiration timestamp and the expiration timestamp of the old fact, while its historical records are fully preserved. S150. Construct the dynamic knowledge graph framework using the node structure, edge structure, and time attribute field.

[0007] According to the above scheme, step S200 includes: S210. Utilize a large model to parse the input data, identify and extract multiple entities contained in the input data; perform entity recognition on the input unstructured text or structured data using a large language model; S220. Based on the multiple entities, use a large model to parse the semantic relationships between the multiple entities from the input data; extract the relationships between entities by calling a parallelized large language model; S230. The large model analyzes the historical context information of the input data and extracts the time attribute information associated with the semantic relationship. The time attribute information includes the start and end times when the semantic relationship is considered valid. Dynamic prompt word engineering combined with multi-stage parsing rules is adopted to ensure that the large model can extract time attribute information with high accuracy and robustness. Dynamic prompt words are constructed based on the current system state and input data, and dynamic information such as system time context and relevant historical facts are injected to enhance temporal reasoning ability. The large model outputs a structured result containing timestamps and confidence scores. After receiving the result, parsing and calibration rules for relative time, fuzzy time, and implicit termination are executed, and different processing methods such as direct acceptance, secondary verification, or initiation of backoff strategy are adopted according to the confidence score. Time attribute extraction includes: using dynamic prompt word engineering combined with multi-stage parsing rules to extract time attribute information; dynamic prompt words are dynamically constructed based on the current system state and input data, including role settings, system time context, input data and relationships, historical context and Few-shot examples, and outputting a structured format containing timestamps and confidence scores; after receiving the output, the system executes parsing and calibration rules including relative time conversion, fuzzy time alignment, granular completion, implicit termination recognition and open time processing; at the same time, based on the output confidence score, a quality control strategy including direct adoption for high confidence, secondary verification for medium confidence, and backoff for low confidence.

[0008] According to the above scheme, step S300 includes: S310. Match the extracted entities with the entity nodes already stored in the dynamic knowledge graph. The matching includes determining whether the extracted entities and the entity nodes already stored in the dynamic knowledge graph represent the same object. Perform multimodal similarity calculation based on literal features, semantic features, and structural features, and obtain the comprehensive similarity S_total=w_lex×S_lex+w_sem×S_sem+w_str×S_str by weighted summation, where S_total represents the comprehensive similarity, S_lex represents the literal features, S_sem represents the semantic features, S_str represents the structural features, w_lex, w_sem, and w_str represent the weight coefficients, and w_lex+w_sem+w_str=1. A hierarchical, progressive screening logic is adopted. In the first stage, the literal similarity and semantic similarity between the entity to be matched and the existing entity nodes in the graph are calculated respectively. Only when both similarities reach the preset high-precision threshold are they directly determined to represent the same object, ensuring high accuracy of the matching results. In the second stage, for entity pairs that failed to match in the first stage, a multi-feature weighted fusion logic is introduced. Literal features, semantic features, and structural features are comprehensively considered, and preset weights are assigned to the three types of features and a weighted comprehensive similarity is calculated. When the comprehensive similarity reaches the set comprehensive threshold, the two are determined to be the same entity node, and the comprehensive similarity is recorded as the confidence level of the matching result. In the third stage, for entity pairs that failed to match in the first and second stages but whose comprehensive similarity reaches the minimum verification threshold, the name, attributes, and source text of the entity to be matched, along with the attributes, historical relationships, and similarity scores of the most similar entity node in the graph, are structured and input into the large model. The large model combines the contextual logic to infer whether the two refer to the same object and outputs a clear judgment result and reasoning basis.

[0009] The threshold and feature weight acquisition methods for the matching mechanism include: In the initial stage, on the pre-labeled entity pair dataset, the preset threshold and weight combinations are traversed through grid search or Bayesian optimization algorithms to determine the initial parameters with the goal of maximizing the F1 score of the matching results. These parameters include literal high-precision threshold, semantic high-precision threshold, comprehensive similarity threshold, minimum threshold for large model-assisted verification, and initial weights for three types of features. K-fold cross-validation is used to ensure the robustness of the initial parameters on different data subsets. During system operation, the results of manual review of entity merging or rejection are used as feedback signals. The comprehensive similarity threshold and feature weights are dynamically adjusted using simplified perceptron update rules or reinforcement learning. If the system predicts no match but the manual judgment is to merge, the weights of the corresponding features are adjusted positively. If the system predicts a match but the manual judgment is to reject, the weights of the corresponding features are adjusted negatively. At the same time, the comprehensive threshold is dynamically optimized based on the mean and variance of the comprehensive similarity to ensure that the matching mechanism continuously adapts as the knowledge graph evolves. S320. If the entity extracted based on the matching judgment represents the same object as the entity node already stored in the dynamic knowledge graph, then the two are merged into the same entity node. S330. If the entity extracted according to the matching determination does not represent the same object as any entity node already stored in the dynamic knowledge graph, then a new entity node is created for the extracted entity. S340. After entity nodes are merged, the relationship edges connecting the same entity pairs in the dynamic knowledge graph are deduplicated. The deduplication process includes: after entity merging, deduplication is triggered only for relation edges with the same relation type and overlapping validity periods; the dominant edge is determined based on confidence ranking, and the expiration timestamps and invalidation timestamps of subordinate edges are adjusted so that they become invalid and marked as historical records when the dominant edge takes effect; for edges with highly consistent attributes, high-confidence edges are retained after fusing fact descriptions and embedding vectors.

[0010] According to the above scheme, step S400 includes: S410. Search the dynamic knowledge graph for existing relationships that connect the same entity pairs as the extracted relationships; S420. Based on the extracted time attribute information and the existing relationship time attribute information, determine whether there is a temporal conflict between the extracted time attribute information and the existing relationship time attribute information; Temporal conflicts include temporal conflicts and semantic conflicts. A temporal conflict is determined by the following conditions: the entity pairs are identical, the relation types are identical, and the valid time intervals [NF.valid_at, NF.invalid_at) of the newly extracted relational fact intersect with the valid time intervals [EF.valid_at, EF.invalid_at) of the existing relational fact. The judgment condition is: max(NF.valid_at, EF.valid_at) < min(NF.invalid_at, EF.invalid_at). Here, NF and EF represent the corresponding attributes of the newly extracted relational fact and the existing relational fact, respectively, and valid_at and invalid_at are the effective and invalid timestamps, respectively. For candidate pairs with temporal conflicts, structured prompts guide the large model to perform semantic conflict detection, identifying attribute value contradictions, state contradictions, and negation relation contradictions. Based on the detection results, the conflict level is divided into no conflict, weak conflict, and strong conflict. S430. If a temporal conflict exists, update the temporal attribute information of the existing relationship so that the existing relationship becomes invalid when the extracted relationship takes effect; this is achieved by updating the invalidation timestamp of the existing relationship, rather than by physical deletion, in order to preserve historical records. S440. Output the extracted relations and the updated existing relations as a set of relation edges with temporal consistency.

[0011] According to the above scheme, step S500 includes: S510. Assemble the updated set of entity nodes and the set of relation edges with temporal consistency into a batch data unit; The batch data unit is divided into a node list and a relation list; the elements in the node list include the node's unique identifier, label, attributes, and embedding vector; the elements in the relation list include the relation type, source node ID, target node ID, and bitemporal attributes. S520. The batch data units are persistently stored in the graph database through the database batch operation interface; By using the batch operation interface provided by the database, the node list is traversed, matching is performed based on the node identifier, and the attributes of existing nodes are updated or new nodes are created based on the matching results. At the same time, the relationship list is traversed, and relationship edges with complete attributes are created between the matched or created corresponding nodes based on the specified source node and target node identifiers. This reduces the number of database I / O interactions and improves storage efficiency. S530. During persistent storage, the association reference relationship between the entity node and the relation edge is maintained; and the batch data units are processed sequentially according to the group identifier of the knowledge graph; by maintaining a dedicated processing queue for each group identifier, the update order within the same group is ensured, and different groups can be processed concurrently to ensure data consistency and improve throughput.

[0012] According to the above scheme, step S600 includes: S610. Receive a query request and parse the query conditions and time constraints contained in the query request. The time constraints in the query request are decomposed into valid time constraints and transaction time constraints. Valid time constraints correspond to the time when the query facts are true in the objective scenario, while transaction time constraints correspond to the time when the query facts are recorded in the system. S620. Based on the query conditions and time constraints, perform a hybrid retrieval in the dynamic knowledge graph. The hybrid retrieval process satisfies the time constraints based on the time attribute information of the relation edges. The hybrid retrieval combines semantic search, keyword full-text search, and graph traversal search. Semantic search is based on embedding vector similarity, keyword search is based on the BM25 algorithm, and graph traversal search is based on breadth-first search. During retrieval, the time attributes of relation edges are filtered according to the time constraints. When filtering relation edges, the effective time filtering requires that valid_at ≤ VT_Constraint_Point and invalid_at > VT_Constraint_Point (or invalid_at is empty); the transaction time filtering requires that created_at ≤ TT_Constraint_Point and expired_at > TT_Constraint_Point (or expired_at is empty); only relation edges that simultaneously meet both of the above filtering conditions are included in the search results; where valid_at is the effective timestamp of the relation edge, invalid_at is the invalid timestamp of the relation edge, created_at is the creation timestamp of the relation edge, and expired_at is the expiration timestamp of the relation edge; VT_Constraint_Point is the effective time constraint point parsed from the query request, and TT_Constraint_Point is the transaction time constraint point parsed from the query request; S630. The search result set obtained by the hybrid search is reordered, and the reordered search results are output as a response. The reordering process adopts a variety of strategies, including inverse rank fusion, maximum marginal relevance, cross encoder reordering and node distance reordering. The re-ranking process employs a two-stage concatenated strategy of coarse ranking and fine ranking. The coarse ranking stage combines node distance re-ranking with inverse rank fusion, where the inverse rank fusion score is calculated as: S_RRF=Σ(1 / (k+rank_i)), where rank_i is the rank of the search result in the i-th ranked list, and k is a smoothing constant. The fine ranking stage combines cross-encoder re-ranking with the maximum marginal relevance algorithm, where the maximum marginal relevance score is calculated as: MMR=argmax[λ×S_Cross(D_i,Q)-(1-λ)×maxS_Redundancy(D_i,D_j)], where S_RRF is the inverse rank fusion score used to fuse different... The results of the sorted list; k is the smoothing constant; rank_i is the rank of the result to be evaluated in the single sorted list; MMR is the maximum marginal relevance score; λ is the weight parameter used to balance the relevance score and the redundancy score; S_Cross(D_i,Q) is the deep semantic relevance score between the candidate document D_i calculated by the cross encoder and the query Q; S_Redundancy(D_i,D_j) is the content redundancy or similarity between the candidate document D_i and the document D_j in the selected result set S; argmax[·] indicates that the candidate document D_i with the largest value of the expression in parentheses is selected; the smoothing constant k and the weight parameter λ are optimized and adjusted through offline evaluation or online feedback.

[0013] A dynamic knowledge graph intelligent construction system based on a large model, comprising: a graph storage module, a large model processing module, a temporal fusion module, and a knowledge update module; The graph storage module is used to store dynamic knowledge graphs, which include entity nodes and relation edges associated with time attribute information. The large model processing module is connected to the graph storage module and is used to receive input data and call the large model to extract entities, relationships between entities, and time attribute information corresponding to the relationships from the input data. The temporal fusion module is connected to the large model processing module and the graph storage module respectively. It is used to receive the extracted entity, relation and temporal attribute information, match and fuse the extracted entities with the existing entities in the graph storage module, and coordinate the temporal conflict between the extracted relations and the existing relations based on the temporal attribute information, and output the fusion update instruction. The knowledge update module is connected to the temporal fusion module and the graph storage module, and is used to receive the fusion update instruction and persist the updated content to the graph storage module through batch operations.

[0014] According to the above scheme, the temporal fusion module includes an entity fusion module and a temporal coordination module; the entity fusion module is used to match the extracted entities with existing entities in the dynamic knowledge graph, and merge or create entity nodes according to the matching results; the temporal coordination module is used to identify temporal conflicts between the extracted relationships and existing relationships based on the extracted time attribute information, and coordinate the temporal conflicts by updating the time attribute information.

[0015] According to the above scheme, the system also includes: a temporal awareness query module, which is connected to the graph storage module, for receiving query requests containing time constraints, performing a hybrid search in the graph storage module based on the time attribute information of the relation edges, and returning the search results after reordering them.

[0016] Compared with the prior art, the beneficial effects of the present invention are: 1. This invention clearly distinguishes between transaction time and effective time through a dual-temporal data model, and combines a temporal conflict coordination mechanism to achieve complete tracking of the evolution of knowledge time sequence. It can accurately respond to historical time point queries and accurately handle contradictory information. 2. This invention integrates new data in real time and updates entities and relationships synchronously by combining incremental updates and batch persistence, adapting to dynamic application scenarios where data changes frequently. 3. This invention flexibly adapts to the knowledge representation needs of different fields by customizing entity nodes, plot nodes, community nodes and corresponding edge structures, combined with an entity fusion and deduplication mechanism. Attached Figure Description

[0017] Figure 1 This is a flowchart illustrating the steps of a dynamic knowledge graph intelligent construction method based on a large model according to the present invention. Figure 2 This is a schematic diagram of the structure of a dynamic knowledge graph intelligent construction system based on a large model according to the present invention. Detailed Implementation

[0018] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0019] Example: Figures 1-2 As shown, this invention provides a technical solution: an intelligent construction method for dynamic knowledge graphs based on large models, the method comprising: S100. Construct a dynamic knowledge graph structure based on a dual-temporal data model to obtain a knowledge graph framework that includes entity nodes and relation edges with temporal attribute information. Specifically, step S100 includes: S110. Construct a dual-temporal data model, which tracks transaction time and validity time respectively; where transaction time is used to record the time when information is recorded by the system, and validity time is used to record the time when information actually occurs in the objective scenario. For example: Track transaction time: Creation time created_at: January 1, 2024, 10:00:00; Valid time valid_at: December 1, 2023, 00:00:00; Expiration time invalid_at: December 31, 2023, 23:59:59; S120. Based on a dual-temporal data model, a node structure is defined, including entity nodes, plot nodes, and community nodes. Entity nodes represent specific entity objects in the knowledge graph, containing name, embedding vector, and attribute information. Plot nodes represent discrete events or data fragments in a time series, containing source description, content, and effective time information. Community nodes represent entity clusters grouped according to semantic similarity, containing semantic similarity cluster association information and summary information. Plot nodes are used to anchor information sources, and their effective time represents the objective time of the event or state described by the information source. During queries, the original source of information can be traced through plot edges. Community nodes are generated and updated through real-time or periodically running clustering algorithms, such as K-means or hierarchical clustering based on entity embedding vectors, to represent the grouping of entities in the semantic space. During queries, semantically similar entity sets can be quickly found through community nodes, supporting exploratory analysis. For example: Define an entity node: EntityNode: ID: 1, Name: Product A, Embedding: [0.1, 0.2, ...], Attributes: {Type: Software}; Define an Episode Node: Identifier id: 101, Source: User feedback document, Content: User report that product A has an interface lag issue in version 2.0, Effective date valid_at: January 15, 2024; Define a community node: CommunityNode: Identifier id: 201, Summary: entities related to performance issues, Member ID list member_ids: [1,2,…]; This is just an example and is not a limitation. S130. Define an edge structure based on a dual-temporal data model. The edge structure includes entity edges, plot edges, and community edges. Entity edges are used to connect two entity nodes, representing the relationship between entities, and include the relationship name, fact description, and embedding vector. Plot edges are used to connect plot nodes and entity nodes, indicating that a specific entity is mentioned in a specific plot. Community edges are used to connect community nodes and entity nodes or community nodes, indicating that an entity or sub-community belongs to a certain community. For example: Define an entity edge: EntityEdge: Identifier id: 1001, Starting node identifier from_node_id: 1, Target node identifier to_node_id: 2, Relation: Defect exists, Fact description: Product A has a UI lag defect in version 2.0; Define a plot edge: EpisodicalEdge: ID id: 2001, plot ID episode_id: 101, entity ID entity_id: 1, indicating that entity 1 product A is mentioned in plot 101; Define a community edge: CommunityEdge: ID: 3001, community ID: 201, member ID: 1; This is just an example and no restrictions are imposed. S140. Configure time attribute fields for the edge structure. The time attribute fields include creation timestamp, effective timestamp, invalid timestamp, and expiration timestamp. The creation timestamp is the timestamp when the record node or edge is created in the system. The effective timestamp is the timestamp when the relationship between entities represented by the record edge begins to be effective. The invalid timestamp is the timestamp when the relationship between entities represented by the record edge stops being effective. The expiration timestamp is the timestamp when the record node or edge is marked as expired in the system. For example: Configure time attribute fields for entity edges. For example, set the following for edge 1001: Creation time created_at: January 16, 2024, 09:30:00 (system record time), Effective time valid_at: January 15, 2024 (defect becomes effective), Expiration time invalid_at: null (currently valid), Expiration time expired_at: null (not expired). Furthermore, the time attribute fields work together to support a dual-temporal data model, synchronously tracking the valid time VT and transaction time TT. The valid time is defined by the effective timestamp and the invalid timestamp, corresponding to the establishment interval of the fact in the objective scenario [valid_at, invalid_at), where valid_at represents the effective timestamp, that is, the moment that marks the fact starting to be established in the objective scenario, and invalid_at represents the invalid timestamp, that is, the moment that marks the fact stopping being established in the objective scenario. The transaction time is defined by the creation timestamp and the expiration timestamp, corresponding to the recording interval of the fact in the system [created_at, expired_at), where created_at represents the creation timestamp, that is, the moment that marks the fact being first recorded by the system, and expired_at represents the expiration timestamp, that is, the moment that marks the fact being marked as historical or expired in the system record. The relation edge is considered a queryable temporal fact only when both the valid time interval and the transaction time interval are in a valid state. When an old fact is replaced by a new fact, its current state is terminated by updating the invalid timestamp and the expired timestamp of the old fact, while its historical record is fully preserved. For example: For edge 1001, its valid time interval is [2024-01-15, empty), and its transaction time interval is [2024-01-16 09:30:00, empty); when a new relation edge indicating product A defect repair appears later, the system will update edge 1001's invalid_at to the new relation's valid_at, and update its expired_at to the new relation's created_at, thereby terminating edge 1001's current state, while fully preserving its historical records for traceability; this is only an example and is not a limitation. S150. Construct a dynamic knowledge graph framework using node structure, edge structure, and time attribute fields.

[0020] S200. Obtain input data and use the large model to extract entities, relationships between entities, and time attribute information corresponding to relationships between entities from the input data. Specifically, step S200 includes: S210. Utilize a large model to parse input data, identify and extract multiple entities contained within the input data; perform entity recognition on unstructured text or structured data using a large language model; the large model is a general-purpose or domain-specifically fine-tuned large language model, such as the GPT series and LLaMA series; through API calls or loading a local model, construct the input data, including text and structured data, into prompts containing task instructions, context, and examples, and input them into the large model; the output of the large model is structured text, which is parsed to obtain entity, relation, and time attribute information; for example: obtain a technical report text: Product A has fixed the interface lag issue in version 2.1 and was released on February 1, 2024; use a large language model to parse this text, identify and extract entities: Product A, Version 2.1; S220. Based on multiple entities, use a large model to parse the semantic relationships between multiple entities from the input data; extract the relationships between entities by calling a parallelized large language model; for example, the large model identifies a fixed relationship between product A and version 2.1 and generates a relationship description: the interface lag issue of product A has been fixed in version 2.1. S230. By analyzing the historical context information of the input data through a large model, extract the time attribute information associated with the semantic relationship. The time attribute information includes the start time and end time when the semantic relationship is considered valid. For example, the large language model analyzes the input text: "Published on February 1, 2024". Combined with the context, which may refer to the effective time of the repair, extract the time attribute information associated with the repaired relationship. The large model infers that the repair takes effect from the publication time, extracts the effective time valid_at as February 1, 2024, and the invalid time invalid_at is empty, indicating that the relationship remains valid. Furthermore, the time attribute extraction includes: using dynamic prompt word engineering combined with multi-stage parsing rules to extract time attribute information; the dynamic prompt words are dynamically constructed based on the current system state and input data. This template is structured text, containing role settings, system time, relevant historical facts, task instructions, input data, and output format specifications. The system dynamically fills the corresponding parts of the template with the current transaction time, relevant entity historical relationships, and the relationship types to be extracted, generating the final prompt words, and requires the large model to output in JSON format, including valid time start and end points and confidence scores. After receiving the output, the system executes parsing and calibration rules, including relative time conversion, fuzzy time alignment, granular completion, implicit termination recognition, and open time processing. Simultaneously, based on the output confidence score, it implements quality control strategies including direct adoption for high confidence, secondary verification for medium confidence, and backoff for low confidence. For example, a dynamic prompt word is constructed based on the mechanism, injecting the current system transaction time, such as 2024-02-01, and historical context, such as a lag defect in product A version 2.0. The large model outputs a structured result like: {"valid_at": "2024-02-01 00:00:00", "invalid_at": "null", "confidence_score": 0.92}. The time granularity is completed according to the parsing rules, and the result is directly adopted because the confidence score is >0.8. If the confidence score is in the medium confidence range, secondary verification is triggered, and the extracted result is input into the large model again for cross-validation with the original text. This is only an example and is not a limitation. S300. The extracted entities are matched, merged and deduplicated with existing entities in the dynamic knowledge graph to obtain an updated set of entity nodes and corresponding relation edges. Specifically, step S300 includes: S310. Match the extracted entities with the entity nodes already stored in the dynamic knowledge graph. The matching includes determining whether the extracted entities and the entity nodes already stored in the dynamic knowledge graph represent the same object. For example, match the extracted entity product A with the existing entity nodes in the graph. By comparing the semantic consistency of the entity name and analyzing the closeness of its vectorized representation in the semantic space, it is found that it is highly similar to the existing node entity node EntityNode: ID id: 1, name: product A. Furthermore, multimodal similarity is calculated based on literal features, semantic features, and structural features, and the comprehensive similarity S_total = w_lex × S_lex + w_sem × S_sem + w_str × S_str is obtained by weighted summation, where S_total represents the comprehensive similarity, S_lex represents the literal features, S_sem represents the semantic features, S_str represents the structural features, w_lex, w_sem, and w_str represent the weight coefficients, and w_lex + w_sem + w_str = 1; A hierarchical, progressive screening logic is adopted. In the first stage, the literal similarity and semantic similarity between the entity to be matched and the existing entity nodes in the graph are calculated respectively. Only when both similarities reach the preset high-precision threshold are they directly determined to represent the same object, ensuring high accuracy of the matching results. In the second stage, for entity pairs that failed to match in the first stage, a multi-feature weighted fusion logic is introduced. Literal features, semantic features, and structural features are comprehensively considered, and preset weights are assigned to the three types of features and a weighted comprehensive similarity is calculated. When the comprehensive similarity reaches the set comprehensive threshold, the two are determined to be the same entity node, and the comprehensive similarity is recorded as the confidence level of the matching result. In the third stage, for entity pairs that failed to match in the first and second stages but whose comprehensive similarity reaches the minimum verification threshold, the name, attributes, and source text of the entity to be matched, along with the attributes, historical relationships, and similarity scores of the most similar entity node in the graph, are structured and input into the large model. The large model combines the contextual logic to infer whether the two refer to the same object and outputs a clear judgment result and reasoning basis.

[0021] The threshold and feature weight acquisition methods for the matching mechanism include: In the initial stage, on the pre-labeled entity pair dataset, the preset threshold and weight combinations are traversed through grid search or Bayesian optimization algorithms to determine the initial parameters with the goal of maximizing the F1 score of the matching results. These parameters include literal high-precision threshold, semantic high-precision threshold, comprehensive similarity threshold, minimum threshold for large model-assisted verification, and initial weights for three types of features. K-fold cross-validation is used to ensure the robustness of the initial parameters on different data subsets. During system operation, the results of manual review of entity merging or rejection are used as feedback signals. The comprehensive similarity threshold and feature weights are dynamically adjusted using simplified perceptron update rules or reinforcement learning. If the system predicts no match but the manual judgment is to merge, the weights of the corresponding features are adjusted positively. If the system predicts a match but the manual judgment is to reject, the weights of the corresponding features are adjusted negatively. At the same time, the comprehensive threshold is dynamically optimized based on the mean and variance of the comprehensive similarity to ensure that the matching mechanism continuously adapts as the knowledge graph evolves. For example: Calculate the similarity between the new entity A and existing entity nodes, obtaining a literal similarity S_lex = 0.95, a semantic similarity S_sem = 0.93, and a structural similarity S_str = 0.90; set feature weights w_lex = 0.3, w_sem = 0.5, and w_str = 0.2 respectively, and calculate the comprehensive similarity S_total = 0.93 according to the formula; since both S_lex and S_sem reach the preset high-precision threshold, according to the hierarchical strategy, they are directly determined to be the same object in the precise matching stage; if the comprehensive similarity is 0.75 and reaches the weighted matching threshold, they are determined to be the same object through weighted matching; if the comprehensive similarity is 0.65 and reaches the minimum threshold for large model auxiliary verification, the entity information and similarity score are input into the large model for final verification; S320. If the entity extracted based on the matching judgment represents the same object as the entity node already stored in the dynamic knowledge graph, then the two will be merged into the same entity node; for example: if they are determined to be the same object, then the newly extracted product A information will be merged into the existing entity node with the identifier 1, instead of creating a new node. S330. If the entity extracted based on the matching judgment does not represent the same object as any entity node already stored in the dynamic knowledge graph, then a new entity node is created for the extracted entity; for example: no matching item is found for the extracted entity version 2.1 in the existing graph, so a new entity node is created for it. EntityNode: ID: 3, Name: version 2.1, Embedding: [...]; S340. After entity nodes are merged, the relation edges connecting the same entity pairs in the dynamic knowledge graph are deduplicated. Furthermore, the deduplication process includes: after entity merging, deduplication is triggered only for relation edges with the same relation type and overlapping validity periods; the dominant edge is determined based on confidence ranking, and the expiration and invalidation timestamps of subordinate edges are adjusted so that they become invalid and marked as historical records when the dominant edge takes effect; for edges with highly consistent attributes, high-confidence edges are retained after fusing fact descriptions and embedding vectors; for example, after entity merging, if there are two edges with relation types both being related versions and connecting the same entity pair, their validity period intervals are [2024- Edges [01-01, 2024-01-31] ​​and [2024-01-15, 2024-02-15] are deduplicated due to their identical relation types and overlapping times. Sorted by confidence level, the edge with a confidence level of 0.9 is identified as the dominant edge. The invalid_at value of another edge with a confidence level of 0.7 is adjusted to 2024-01-15, and its expired_at value is adjusted to the current system time, thus achieving logical deduplication while preserving historical records. This is merely an example and is not intended to impose any limitations.

[0022] S400. Based on the extracted time attribute information, identify the temporal conflict between the extracted relationship and the existing relationship in the dynamic knowledge graph, update the time attribute information, coordinate the temporal conflict, and obtain a set of relationship edges with temporal consistency. Specifically, step S400 includes: S410. Find and extract existing relationships in the dynamic knowledge graph that connect the same entity pairs; for example: find the newly extracted relationship in the dynamic knowledge graph: Product A - Fixed - Version 2.1, connect the same entity pair, that is, the existing relationship between Product A and a certain version; find the existing relationship edge 1001: Product A - Defective - Version 2.0; S420. Based on the extracted time attribute information and the time attribute information of existing relationships, determine whether there is a temporal conflict between the extracted time attribute information and the time attribute information of existing relationships; for example: the effective start time of the new relationship is February 1, 2024, and it remains valid, with an invalid time invalid_at: null; the existing relationship, i.e., the defective relationship, has an effective time valid_at: January 15, 2024, and an invalid time invalid_at: null. This overlaps with the time of the new relationship, and the factual description of the repair and the existence of the defect logically constitute an update to the same problem state. Therefore, it is determined that there is a temporal conflict. Furthermore, temporal conflicts include time conflicts and semantic conflicts. The determination of a time conflict requires that the entity pairs are identical, the relationship types are identical, and the valid time intervals [NF.valid_at, NF.invalid_at) of the newly extracted relationship fact intersect with the valid time intervals [EF.valid_at, EF.invalid_at) of the existing relationship fact. The judgment condition is: max(NF.valid_at, EF.valid_at) < min(NF.invalid_at, EF.invalid_at). Here, NF and EF represent the corresponding attributes of the newly extracted relationship fact and the existing relationship fact, respectively, and valid_at and invalid_at are the effective timestamp and invalid timestamp, respectively. For candidate pairs with time conflicts, the large model is guided by structured prompts to perform semantic conflict detection, identifying attribute value contradictions, state contradictions, and negation relation contradictions. Based on the detection results, the conflict level is divided into no conflict, weak conflict, and strong conflict. The output of the conflict detection is structured data, containing at least conflict level and conflict type fields. The criteria for determining the conflict level are as follows: if the new and old relationship states are mutually exclusive, it is a strong conflict; if it is only an attribute value update or can coexist, it is a weak conflict; if there is no logical contradiction, it is a no-conflict. Corresponding temporal coordination strategies are triggered based on the conflict level. For example, based on the time conflict determination criteria, the intersection of the effective time interval of the new relationship [2024-02-01, empty) and the existing relationship interval [2024-01-15, empty) is determined as follows: max(2024-02-01, 2024-01-15) = 2024-02-01, min(empty, empty) = empty, satisfying 2024-02-01 < empty, therefore a time conflict is determined. Through structured prompts guiding the large model to perform semantic analysis, the interface lag defect in version 2.0 of product A and the interface lag issue fixed in version 2.1 of product A are identified as a state contradiction, thus determining a strong conflict. This is only an example and is not a limitation.

[0023] S430. If a temporal conflict exists, update the temporal attribute information of the existing relationship so that the existing relationship becomes invalid when the extracted relationship takes effect. This is achieved by updating the expiration timestamp of the existing relationship, rather than physically deleting it, in order to preserve historical records. For example, update the temporal attribute information of edge 1001 of the existing relationship, and update the invalid_at field of edge 1001 to: February 1, 2024, 00:00:00, which is the time when the new repair takes effect, indicating that the defective relationship becomes invalid when the repair takes effect. S440. Output the extracted relationships and updated existing relationships as a set of relationship edges with temporal consistency. For example, output the newly extracted fixed relationship together with the updated defective relationship edge 1001 as a coordinated set of relationship edges with temporal consistency. In this case, the relationship between product A and version is defective from January 15, 2024 to February 1, 2024, and becomes fixed from February 1, 2024. This is just an example and is not a limitation.

[0024] S500: Persist the updated set of entity nodes and the set of relation edges with temporal consistency to the graph database through batch operations; Specifically, step S500 includes: S510. Assemble the updated set of entity nodes and the set of relation edges with temporal consistency into a batch data unit; Furthermore, the batch data unit is divided into a node list and a relationship list; the elements in the node list include the node's unique identifier, label, attributes, and embedding vector; the elements in the relationship list include the relationship type, source node ID, target node ID, and bitemporal attributes; for example, assembling the node list and relationship list; the node list includes the updated attributes of entity node 1, the newly created ID, label, attributes, and embedding vector of entity node 3; the relationship list includes the updated time attribute of edge 1001, the type of the newly created repaired relationship edge, the source node ID, the target node ID, and bitemporal attributes, ensuring that the data format conforms to the batch interface requirements; S520: Persistently store batch data units to the graph database through the database batch operation interface; Furthermore, the database employs a batch operation interface. Specifically, it utilizes the batch processing instructions of the graph database, passing the node list and relationship list as parameters. These instructions execute sequentially: matching and updating existing nodes or creating new nodes based on node identifiers; and batch creating or updating relationship edges with dual temporal attributes between located nodes based on node identifiers in the relationship list. All these operations are completed within a single transaction, achieving efficient persistence. By traversing the node list, performing matching based on node identifiers, and updating the attributes of existing nodes or creating new nodes according to the matching results, the database also traverses the relationship list, creating relationship edges with complete attributes between matched or created corresponding nodes based on their specified source and target node identifiers. This reduces the number of database I / O interactions and improves storage efficiency. S530. During persistent storage, maintain the association and reference relationship between entity nodes and relation edges; and process batch data units sequentially according to the group identifier of the knowledge graph; by maintaining a dedicated processing queue for each group identifier, ensure that updates within the same group are executed sequentially, and different groups can be processed concurrently to ensure data consistency and improve throughput; for example, if the system sets a group identifier for product A entity, this update will be placed in the corresponding dedicated processing queue to ensure that updates to product A are executed in order; this is only an example and is not a limitation.

[0025] S600: Respond to query requests and perform temporally-aware retrieval in the dynamic knowledge graph based on the temporal attribute information of relation edges; Specifically, step S600 includes: S610. Receive the query request and parse the query conditions and time constraints contained in the query request. Furthermore, the time constraints in the query request are decomposed into valid time constraints and transaction time constraints. The valid time constraint corresponds to the time when the queried fact is established in the objective scenario, and the transaction time constraint corresponds to the time when the queried fact is recorded in the system. For example, a query request is received: query for known problems of product A that exist on January 20, 2024; the query conditions are parsed to be product A and known problems, and the time constraint is that it exists on January 20, 2024; the time constraints in the query request are decomposed into the valid time constraint VT_Constraint_Point = 2024-01-20 and the transaction time constraint TT_Constraint_Point = 2024-01-30.

[0026] S620. Based on query conditions and time constraints, a hybrid retrieval is performed in a dynamic knowledge graph. The hybrid retrieval employs a strategy of parallel execution and result fusion. Semantic search, keyword search, and graph traversal search are executed in parallel based on the same temporal filtering conditions, each generating a preliminary result list. The inverse rank fusion method is used to coarsely merge these three lists, ensuring the complementary advantages of different retrieval types. The hybrid retrieval process relies on the temporal attribute information of relation edges to satisfy time constraints. The hybrid retrieval combines semantic search, keyword full-text search, and graph traversal search. Semantic search is based on embedding vector similarity, and keyword search is based on the BM25 algorithm. The graph traversal search method is based on breadth-first search. During retrieval, the time attributes of relation edges are filtered according to time constraints. For example: Semantic search: Calculate the embedding vector of the known question, and search the graph for nodes and edges with similar relation descriptions or entity attributes and whose time attributes meet the conditions; Keyword search: Retrieve keywords such as product A and question from text fields such as node name, relation name of edge, and fact description, and filter by time; Graph traversal search: Starting from the product A entity node, traverse its connecting edges, find paths with relation types or neighboring nodes related to the question, and check whether the time attributes on the edges cover January 20, 2024; This is only an example and is not a limitation. Furthermore, when filtering relation edges, the effective time filtering requires that valid_at ≤ VT_Constraint_Point and invalid_at > VT_Constraint_Point (or invalid_at is empty); the transaction time filtering requires that created_at ≤ TT_Constraint_Point and expired_at > TT_Constraint_Point (or expired_at is empty); only relation edges that simultaneously meet both of the above filtering conditions are included in the search results; where valid_at is the effective timestamp of the relation edge, invalid_at is the invalid timestamp of the relation edge, created_at is the creation timestamp of the relation edge, and expired_at is the expiration timestamp of the relation edge; VT_Constraint_Point is the effective time constraint point parsed from the query request, and TT_Constraint_Point is the transaction time constraint point parsed from the query request; S630. The search result set obtained by the mixed search is reordered, and the reordered search results are output as the response. The reordering process adopts a variety of strategies, including inverse rank fusion, maximum marginal relevance, cross encoder reordering and node distance reordering. Furthermore, the re-ranking process employs a two-stage concatenated strategy of coarse ranking and fine ranking. The coarse ranking stage combines node distance re-ranking with inverse rank fusion, with the inverse rank fusion score calculated as: S_RRF=Σ(1 / (k+rank_i)), where rank_i is the rank of the search result in the i-th ranked list, and k is a smoothing constant. The fine ranking stage combines cross-encoder re-ranking with the maximum marginal relevance algorithm, with the maximum marginal relevance score calculated as: MMR=argmax[λ×S_Cross(D_i,Q)-(1-λ)×maxS_Redundancy(D_i,D_j)], where S_RRF is the inverse rank fusion score used for fusion. Results from different sorting lists; k is the smoothing constant; rank_i is the rank of the result to be evaluated in a single sorting list; MMR is the maximum marginal relevance score; λ is a weight parameter used to balance the relevance score and the redundancy score; S_Cross(D_i,Q) is the deep semantic relevance score between the candidate document D_i calculated by the cross encoder and the query Q; S_Redundancy(D_i,D_j) is the content redundancy or similarity between the candidate document D_i and the document D_j in the selected result set S; argmax[·] indicates selecting the candidate document D_i that maximizes the value of the expression within the parentheses; the smoothing constant k and the weight parameter λ are optimized and adjusted through offline evaluation or online feedback.

[0027] This invention provides another technical solution: a dynamic knowledge graph intelligent construction system based on a large model, which includes: a graph storage module, a large model processing module, a temporal fusion module, and a knowledge update module. The graph storage module is used to store dynamic knowledge graphs, which contain entity nodes and relation edges with time attribute information. The large model processing module, connected to the graph storage module, is used to receive input data and call the large model to extract entities, relationships between entities, and time attribute information corresponding to the relationships from the input data. The temporal fusion module is connected to the large model processing module and the graph storage module respectively. It is used to receive the extracted entity, relation and temporal attribute information, match and fuse the extracted entities with the existing entities in the graph storage module, and coordinate the temporal conflicts between the extracted relations and the existing relations based on the temporal attribute information, and output the fusion update instruction. The knowledge update module, connected to the temporal fusion module and the graph storage module, is used to receive fusion update instructions and persist the updated content to the graph storage module through batch operations.

[0028] The temporal fusion module includes an entity fusion module and a temporal coordination module. The entity fusion module is used to match the extracted entities with existing entities in the dynamic knowledge graph, and merge or create entity nodes based on the matching results. The temporal coordination module is used to identify temporal conflicts between the extracted relationships and existing relationships based on the extracted temporal attribute information, and coordinate the temporal conflicts by updating the temporal attribute information.

[0029] The system also includes a temporal-aware query module, which is connected to the graph storage module. It receives query requests containing time constraints, performs a hybrid search in the graph storage module based on the temporal attribute information of the relation edges, and returns the search results after reordering them.

[0030] It will be apparent to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above, and that the invention can be implemented in other specific forms without departing from its spirit or essential characteristics. Therefore, the embodiments should be considered in all respects as exemplary and non-limiting, and the scope of the invention is defined by the appended claims rather than the foregoing description. Thus, all variations falling within the meaning and scope of equivalents of the claims are intended to be included within the present invention. No reference numerals in the claims should be construed as limiting the scope of the claims.

Claims

1. A method for intelligent construction of dynamic knowledge graphs based on large models, characterized in that: The method includes: S100. Construct a dynamic knowledge graph structure based on a dual-temporal data model to obtain a knowledge graph framework that includes entity nodes and relation edges with temporal attribute information. S200: Obtain input data, and use a large model to extract entities, relationships between entities, and time attribute information corresponding to the relationships between entities from the input data; S300. The extracted entities are matched, merged and deduplicated with the existing entities in the dynamic knowledge graph to obtain an updated set of entity nodes and corresponding relation edges. S400. Based on the extracted time attribute information, identify the temporal conflict between the extracted relationship and the existing relationship in the dynamic knowledge graph, update the time attribute information, coordinate the temporal conflict, and obtain a set of relationship edges with temporal consistency. S500. The updated set of entity nodes and the set of relation edges with temporal consistency are persisted to the graph database through batch operations. Step S500 includes: S510, the batch data unit is divided into a node list and a relation list; the elements in the node list include the node's unique identifier, label, attributes, and embedding vector; the elements in the relation list include the relation type, source node ID, target node ID, and bitemporal attributes. S520. The batch data units are persistently stored in the graph database through the database batch operation interface. Using the batch operation interface provided by the database, the node list is traversed, matching is performed based on the node identifier, and the attributes of existing nodes are updated or new nodes are created based on the matching results. At the same time, the relationship list is traversed, and relationship edges with complete attributes are created between the matched or created corresponding nodes based on the specified source node and target node identifiers. S530. During persistent storage, the association reference relationship between the entity node and the relation edge is maintained; and the batch data units are processed sequentially according to the group identifier of the knowledge graph; by maintaining a dedicated processing queue for each group identifier, the update order within the same group is ensured, and different groups can be processed concurrently. S600: In response to the query request, perform temporal-aware retrieval in the dynamic knowledge graph based on the temporal attribute information of the relation edges.

2. The method for intelligent construction of dynamic knowledge graphs based on large models according to claim 1, characterized in that: Step S100 includes: S110. Construct a dual-temporal data model, wherein the dual-temporal data model tracks the transaction time and the effective time respectively; S120. Define a node structure based on the dual-temporal data model. The nodes include entity nodes, plot nodes, and community nodes. The entity nodes contain name, embedding vector, and attribute information. The plot nodes contain source description, content, and effective time information. The community nodes contain semantic similarity clustering association information and summary information. S130. Define an edge structure based on the dual-temporal data model. The edge structure includes entity edges, plot edges, and community edges. The entity edges are used to connect two entity nodes. The plot edges are used to connect plot nodes and entity nodes. The community edges are used to connect community nodes and entity nodes or community nodes. S140. Configure a time attribute field for the edge structure, wherein the time attribute field includes a creation timestamp, an effective timestamp, an invalid timestamp, and an expiration timestamp; S150. Construct the dynamic knowledge graph framework using the node structure, edge structure, and time attribute field.

3. The method for intelligent construction of dynamic knowledge graphs based on large models according to claim 1, characterized in that: Step S200 includes: S210. Use a large model to parse the input data, identify and extract multiple entities contained in the input data; S220. Based on the multiple entities, use a large model to parse the semantic relationships between the multiple entities from the input data; S230. Analyze the historical context information of the input data through the large model, and extract the time attribute information associated with the semantic relationship. The time attribute information includes the start time and end time when the semantic relationship is considered valid.

4. The method for intelligent construction of dynamic knowledge graphs based on large models according to claim 1, characterized in that: Step S300 includes: S310. Match the extracted entities with the entity nodes already stored in the dynamic knowledge graph. The matching includes determining whether the extracted entities and the entity nodes already stored in the dynamic knowledge graph represent the same object. S320. If the entity extracted based on the matching judgment represents the same object as the entity node already stored in the dynamic knowledge graph, then the two are merged into the same entity node. S330. If the entity extracted according to the matching determination does not represent the same object as any entity node already stored in the dynamic knowledge graph, then a new entity node is created for the extracted entity. S340. After entity nodes are merged, the relationship edges connecting the same entity pairs in the dynamic knowledge graph are deduplicated.

5. The method for intelligent construction of dynamic knowledge graphs based on large models according to claim 1, characterized in that: Step S400 includes: S410. Search the dynamic knowledge graph for existing relationships that connect the same entity pairs as the extracted relationships; S420. Based on the extracted time attribute information and the existing relationship time attribute information, determine whether there is a temporal conflict between the extracted time attribute information and the existing relationship time attribute information; S430. If a temporal conflict exists, update the temporal attribute information of the existing relationship so that the existing relationship becomes invalid when the extracted relationship takes effect. S440. Output the extracted relations and the updated existing relations as a set of relation edges with temporal consistency.

6. The method for intelligent construction of dynamic knowledge graphs based on large models according to claim 1, characterized in that: Step S600 includes: S610. Receive a query request and parse the query conditions and time constraints contained in the query request. S620. Based on the query conditions and time constraints, perform a hybrid retrieval in the dynamic knowledge graph. The hybrid retrieval process satisfies the time constraints based on the time attribute information of the relation edges. S630. The search result set obtained by the hybrid search is reordered, and the reordered search results are output as a response.

7. A dynamic knowledge graph intelligent construction system based on a large model, characterized in that: The system includes: a graph storage module, a large model processing module, a temporal fusion module, and a knowledge update module; The graph storage module is used to store dynamic knowledge graphs, which include entity nodes and relation edges associated with time attribute information. The large model processing module is connected to the graph storage module and is used to receive input data and call the large model to extract entities, relationships between entities, and time attribute information corresponding to the relationships from the input data. The temporal fusion module is connected to the large model processing module and the graph storage module respectively. It is used to receive the extracted entity, relation and temporal attribute information, match and fuse the extracted entities with the existing entities in the graph storage module, and coordinate the temporal conflict between the extracted relations and the existing relations based on the temporal attribute information, and output the fusion update instruction. The knowledge update module is connected to the temporal fusion module and the graph storage module. It is used to receive the fusion update instruction, assemble the updated set of entity nodes and the set of relation edges with temporal consistency into a batch data unit, and persistently store the batch data unit in the graph database through the database batch operation interface.

8. The intelligent construction system for dynamic knowledge graphs based on large models according to claim 7, characterized in that: The temporal fusion module includes an entity fusion module and a temporal coordination module; the entity fusion module is used to match the extracted entities with existing entities in the dynamic knowledge graph, and to merge or create entity nodes based on the matching results. The temporal coordination module is used to identify temporal conflicts between the extracted relationships and existing relationships based on the extracted temporal attribute information, and to coordinate the temporal conflicts by updating the temporal attribute information.

9. The intelligent construction system for dynamic knowledge graphs based on large models according to claim 7, characterized in that: The system also includes: The temporal awareness query module, connected to the graph storage module, is used to receive query requests containing time constraints, perform hybrid retrieval in the graph storage module based on the time attribute information of the relation edges, and return the retrieval results after reordering them.

Images