Distributed knowledge graph construction and encrypted storage method based on large model

Abstract

The invention discloses a distributed knowledge graph construction and encrypted storage method based on a large model, and aims to solve the problems of uncontrollable knowledge graph construction quality, low automation degree and insufficient distributed storage security in the prior art. According to the method, firstly, an overall construction task is decomposed and allocated to a plurality of large model intelligent agents with different capability advantages for distributed knowledge extraction; then, through a multi-round cross validation and consensus achievement mechanism, mutual verification and arbitration are carried out on the extracted preliminary knowledge fragments, the illusion of a large model is effectively inhibited, and high-credibility knowledge is screened out; and finally, performing fine-grained dynamic encryption storage on the high-quality sub-atlas generated by fusion, namely, dynamically generating a key according to the security levels of the entities and the relationships and the structural context of the entities and the relationships in the atlas, performing management in combination with an isomorphic key atlas, and finally performing distributed storage on encrypted data blocks.

Description

Technical Field

[0001] This invention relates to the field of knowledge graph technology, and in particular to a method for constructing and encrypted storing a distributed knowledge graph based on a large model. Background Technology

[0002] Knowledge graphs, as semantic networks describing relationships between entities, are the cornerstone of key artificial intelligence applications. Traditional construction methods rely on manual expert work or rules, resulting in low automation and poor scalability. Although breakthroughs in technologies such as large language models have brought hope for automated construction, enabling the extraction of knowledge from massive amounts of text, two major challenges remain: First, the inherent "illusion" problem of large models may lead to the generation of inaccurate or fictitious knowledge, severely damaging the credibility of the graph; second, the current lack of effective collaboration mechanisms makes it impossible to coordinate multiple large model instances for distributed, verifiable collaborative construction, making it difficult to guarantee the consistency of the knowledge acquisition process and the quality of the final result. These factors constrain the large-scale production of high-quality knowledge graphs.

[0003] In terms of storage, while distributed systems can solve the scalability problem of massive knowledge data, they also introduce serious security risks. Graphs often contain sensitive information, and storing it in plaintext on distributed nodes makes it vulnerable to unauthorized access and leakage. Existing encryption schemes are often disconnected from the construction process, mostly serving as "after-the-fact" remedies; and they face a dilemma: coarse-grained encryption severely impairs query efficiency, while fine-grained encryption involves complex key management and struggles to support efficient multi-hop queries. Therefore, current technology urgently needs a solution that integrates high-quality construction with secure storage to address the end-to-end challenges from distributed collaborative construction and quality control to encrypted storage. Summary of the Invention

[0004] This invention specifically relates to a method for constructing and encrypted storing a distributed knowledge graph based on a large model, aiming to solve the problems of uncontrollable quality of knowledge graph construction, low automation, and insufficient security of distributed storage in existing technologies. To achieve the above objectives, the specific technical solution of this invention's method for constructing and encrypted storing a distributed knowledge graph based on a large model is as follows: A method for constructing and cryptographically storing a distributed knowledge graph based on a large model includes the following steps: Step S1, Task Planning and Agent Allocation: Receive the knowledge graph construction request, decompose the overall construction task into multiple knowledge extraction sub-tasks based on the predefined ontology pattern; according to the pre-built large model agent capability profile, allocate the sub-tasks to multiple large model agents with corresponding advantages in the distributed network. Step S2, Distributed Knowledge Extraction and Fragment Generation: Each of the large model agents processes the assigned sub-tasks in parallel, performing entity recognition, relation extraction, and attribute filling operations from the specified unstructured or semi-structured data sources to generate structured preliminary knowledge fragments. Step S3, Multi-round cross-validation and consensus: For the preliminary knowledge fragments, multi-round cross-validation is initiated in the distributed agent network; knowledge fragments that are related or conflicting are distributed to at least one other large model agent for verification, and consensus is reached based on the confidence and consistency of the verification results to select knowledge fragments with high credibility. Step S4, Security-enhanced Knowledge Fusion and Subgraph Generation: Logically fuse the consensus-reaching high-confidence knowledge fragments to eliminate conflicts and form a high-quality subgraph with internal consistency; Step S5, fine-grained dynamic encrypted storage: security level assessment is performed on each entity and relationship in the sub-graph, and based on the assessment results and its structural context in the graph, encryption keys are dynamically generated for fine-grained encryption. Finally, the encrypted data blocks are distributed and stored on multiple storage nodes.

[0005] Furthermore, the decomposition of the overall construction task based on the predefined ontology pattern in step S1 specifically includes: dividing the construction task vertically according to the entity type and / or horizontally according to the data source, based on the entity type and relation type defined in the ontology pattern, to form the knowledge extraction sub-task.

[0006] Furthermore, the multi-round cross-validation and consensus-building in step S3 specifically includes: setting a confidence threshold; when the average confidence of multiple validation results for the same knowledge fragment is greater than or equal to the confidence threshold and the results are consistent, consensus is reached; when the validation results are inconsistent or the average confidence is lower than the threshold, the disputed knowledge fragment is submitted to a large model agent designated as the arbitrator for final adjudication.

[0007] Furthermore, the method includes, after step S3 and before step S4, recording disputed knowledge fragments for which no consensus has been reached, as well as their adjudication process and results, and using them as feedback data to update the capability profile of the large model agent.

[0008] Furthermore, the step S5 of dynamically generating the encryption key based on the evaluation result and its structural context in the graph specifically involves: using a key derivation algorithm, taking the unique identifier of the entity or relationship, its security level label, and the identifiers of its directly associated neighbors as input parameters to derive a unique key.

[0009] Furthermore, the method also includes: constructing a key graph that is isomorphic to the knowledge graph, used to store the encryption key or key index corresponding to each entity node and relation edge, wherein the key graph itself is encrypted as a whole before storage.

[0010] Furthermore, step S5 is followed by step S6, secure query processing: receiving a query request, parsing the query intent to determine the set of entities and relationships to be accessed; locating the corresponding encryption key according to the key graph, obtaining the corresponding encrypted data block from the distributed storage node; performing decryption and graph traversal calculations in a secure environment, and returning the query result.

[0011] Furthermore, the knowledge fusion in step S4 includes conflict detection and resolution of attributes from different large model agents that point to the same entity.

[0012] Furthermore, the preliminary knowledge fragments generated in step S2 are transmitted in encrypted form when they are transmitted between distributed nodes.

[0013] Furthermore, the method also includes step S7, incremental update and key rotation: when it is necessary to incrementally add new knowledge to the encrypted knowledge graph, an encryption key is generated for the new knowledge; at the same time, the encryption key of the affected related original knowledge is rotated and updated.

[0014] Compared with existing technologies, the method described in this patent has the following significant advantages: First, at the construction level, by designing a distributed large-model collaborative framework, the construction quality and efficiency of the knowledge graph are effectively improved. This method decomposes the construction task and processes it in parallel by multiple large-model agents, which not only significantly improves the throughput of knowledge extraction from multi-source data, but more importantly, it introduces a cross-validation and consensus mechanism among agents, enabling mutual verification and correction of extraction results. This effectively suppresses the "illusion" problem of a single large model and significantly enhances the accuracy and credibility of the extracted knowledge. Simultaneously, this distributed architecture itself has good scalability, can flexibly cope with the ever-increasing data scale, and supports continuous incremental updates of the knowledge graph, forming an efficient, reliable, and quality-controllable automated construction closed loop.

[0015] Secondly, at the secure storage level, this invention innovatively achieves the integrated fusion of construction and secure storage. By designing a dynamic encryption method tightly coupled with the graph structure, fine-grained encryption can be performed based on the sensitivity level of entities and relational topology, rather than simple global encryption. This ensures that sensitive knowledge is effectively protected while maximizing the queryability of the graph. The accompanying efficient key management system supports secure multi-hop association queries on the encrypted graph, resolving the traditional contradiction between security and availability. Attached Figure Description

[0016] Figure 1 This is a flowchart of the operational steps of the present invention. Detailed Implementation

[0017] The technical solution of the present invention will now be clearly and completely described in conjunction with the preferred embodiments thereof. Obviously, the described embodiments are merely some, not all, of the embodiments of the present invention. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative effort are within the scope of protection of the present invention.

[0018] Example 1 like Figure 1 As shown, this invention provides a method for constructing and encrypting a distributed knowledge graph based on a large model. Its core idea is to deeply integrate the powerful knowledge processing capabilities of the large model, the collaborative scalability of the distributed system, and the security mechanisms of modern cryptography to achieve an integrated solution for the entire process from knowledge acquisition and quality control to secure storage.

[0019] First, at the system architecture level, the system envisioned in this implementation includes the following core components: a task scheduling center, multiple large model agent nodes, a distributed storage cluster, and a security protection module. The task scheduling center is responsible for receiving user requests, decomposing tasks, and assigning agents. Each large model agent node is an independent computing entity, carrying one or more large language model instances, possessing natural language understanding, knowledge reasoning, and code execution capabilities. The distributed storage cluster consists of multiple physically or logically distributed storage nodes used for persistent data storage. The security protection module is responsible for key management, encryption / decryption operations, and secure transmission throughout the entire process.

[0020] Regarding step S1: Task planning and agent allocation: Receive the knowledge graph construction request, decompose the overall construction task into multiple knowledge extraction sub-tasks based on the predefined ontology pattern; according to the pre-built large model agent capability profile, allocate the sub-tasks to multiple large model agents with corresponding advantages in the distributed network.

[0021] Users submit knowledge graph construction requests to the task scheduling center via an interface. These requests must include at least the target knowledge domain, a list of data sources (such as a set of URLs from specific websites, access paths to internal document repositories, etc.), and the desired output graph schema. The task scheduling center has a built-in predefined ontology schema, which defines the entity types, relation types, and their constraints in the target knowledge graph using OWL or a similar language. For example, when constructing a "healthcare" knowledge graph, the ontology schema would define entity types such as "disease," "medicine," "symptom," and "department," as well as relation types such as "has symptoms," "treatment methods," and "belongs to a department."

[0022] Task decomposition strategies are twofold. One is vertical partitioning, which involves decomposing by entity type. For example, the task of building a large medical text database can be broken down into multiple sub-tasks such as "extracting all disease entities and their attributes" and "extracting all drug entities and their attributes." The other is horizontal partitioning, which involves decomposing by data source. For example, data sources from different hospitals or journals can be assigned to different agents for processing. In practical applications, these two strategies are usually used in combination.

[0023] The resulting subtasks are assigned to the most suitable agents. The system maintains a dynamic database of large-scale model agent capability profiles. These profiles are derived from historical task performance evaluations, recording metrics such as accuracy and efficiency for each agent across different task types (e.g., medical text understanding, financial data extraction, entity disambiguation). The scheduling center optimizes task allocation by matching subtask types with agent profiles; for example, it prioritizes assigning medical text extraction tasks to agents that have performed well in medical domain evaluations.

[0024] Regarding step S2: Distributed knowledge extraction and fragment generation: Each of the large model agents processes the assigned sub-tasks in parallel, performing entity recognition, relation extraction, and attribute filling operations from the specified unstructured or semi-structured data sources to generate structured preliminary knowledge fragments.

[0025] After receiving a subtask, each agent node begins working in parallel. They access specified data sources, which may be unstructured plain text (such as academic papers or news web pages) or semi-structured data (such as HTML tables or JSON data interfaces). Each agent utilizes the capabilities of its underlying large model to perform a series of complex natural language processing operations.

[0026] First, entity recognition: the agent scans the text, identifies and extracts entity mentions within its task scope, and assigns a type label and a unique temporary identifier to each mention. Next, relation extraction: the agent analyzes the sentence structure to determine if there are relations between the identified entities that conform to the ontology pattern definition. For example, in the sentence "Drug A can be used to treat disease B," it extracts triples such as (drug A, treatment method, disease B). Finally, attribute imputation: the agent extracts attribute information of entities from the text, such as the incidence rate of the disease and the side effects of the drug.

[0027] All this extracted information is assembled by the agent into structured "preliminary knowledge fragments." A knowledge fragment may contain a core entity, several attributes of that entity, and several relationship assertions between that entity and other entities (which may not yet be fully recognized by the agent and are only referred to by identifiers). These fragments are typically transmitted within the system in structured data formats such as JSON-LD.

[0028] Regarding step S3: Multi-round cross-validation and consensus: For the preliminary knowledge fragments, multi-round cross-validation is initiated within the distributed agent network; knowledge fragments that are related or conflicting are distributed to at least one other large model agent for verification, and consensus is reached based on the confidence and consistency of the verification results, and high-confidence knowledge fragments are selected.

[0029] This step is crucial for ensuring knowledge quality and overcoming the "illusion" of a single large model. Preliminary knowledge fragments are submitted to a distributed verification network. The core of the verification logic is the introduction of third-party verification. For example, agent A generates a knowledge fragment "entity X is Y". A task scheduling center or a dedicated verification coordinator will randomly or according to a strategy (such as selecting agents with strong capabilities in the domain) distribute this fragment to agents B and C for independent verification.

[0030] Each validator agent, based on its own knowledge base and reasoning ability, outputs a verification result (such as "correct", "incorrect", or "cannot be determined") and a confidence level (a value between 0 and 1) indicating its certainty of judgment. The system presets a confidence threshold, for example, 0.7. When the verification results of agents B and C are both "correct", and their average confidence level is greater than or equal to 0.7, the system considers that consensus has been reached on the segment, and the segment is marked as high confidence.

[0031] If the verification results are inconsistent (e.g., one positive and one negative), or the average confidence level is too low, consensus is not reached. In this case, the disputed segment is submitted to a high-level large-scale model agent recognized as the most capable or specifically acting as an arbitrator for final adjudication. The arbitrator's judgment is considered the gold standard. Simultaneously, the entire verification and arbitration process, participants, and results are recorded, forming a feedback log used to subsequently update the capability profiles of relevant agents, enabling the system to self-optimize.

[0032] Regarding step S4: Security-enhanced knowledge fusion and subgraph generation: Security-enhanced knowledge fusion and subgraph generation: Logically fuse the highly reliable knowledge fragments that have reached a consensus, eliminate conflicts, and form a high-quality subgraph with internal consistency.

[0033] Verified, high-confidence knowledge fragments are fed into the fusion engine. The main challenges of fusion are resolving conflicts and achieving entity alignment. Conflict resolution primarily targets attribute conflicts within the same entity. For example, agent A extracts the side effects of entity "drug D" from source one, which include "dizziness," while agent B extracts from source two that its side effects do not include "dizziness." The fusion engine processes these based on preset strategies, such as a weighted average based on source credibility (assigning higher weight to authoritative journal sources) or prioritizing the latest value based on timestamps (adopting information from the most recently reported literature).

[0034] Entity alignment refers to identifying and merging entities from different fragments and descriptions that point to the same real-world object. For example, determining that "aspirin" and "acetylsalicylic acid" refer to the same drug entity. After conflict resolution and entity alignment, these discrete knowledge fragments are connected into a coherent, internally consistent subgraph. This subgraph is the high-quality output of this stage.

[0035] Regarding step S5: Fine-grained dynamic encrypted storage: For each entity and relation in the sub-graph, a security level assessment is performed, and based on the assessment results and its structural context in the graph, an encryption key is dynamically generated for fine-grained encryption. Finally, the encrypted data blocks are distributed and stored on multiple storage nodes.

[0036] The generated sub-graphs require robust security measures before storage. First, a security level assessment is performed on each entity and relationship within the graph. This can be done automatically based on predefined rules; for example, all "Patient Personal Information" entities are automatically marked as "Top Secret," and all "Public Drug Information" entities are marked as "Internal Public."

[0037] Next, dynamic key generation is performed. For each entity or relationship requiring encryption, a key derivation function is invoked. The input parameters of this function include: a unique identifier for the entity / relationship, its security level label, and the identifiers of its directly associated key neighbors (e.g., key generation for a "patient" entity would be associated with its "attending physician" and "disease" identifiers). This approach ensures that the key is bound to the graph structure context.

[0038] Then, the system constructs a "key graph" that is completely isomorphic to the knowledge subgraph. The nodes and edges of the key graph correspond one-to-one with those of the knowledge graph, but instead of storing plaintext data, it stores the corresponding encryption keys or indexes pointing to the key library. Finally, the key graph itself is encrypted as a whole, while the data blocks of the knowledge graph are encrypted using their respective keys and distributed across different storage nodes, achieving separate management of data and keys.

[0039] Regarding steps S6 and S7: Secure query processing: A query request is received, the query intent is parsed to determine the set of entities and relationships to be accessed; the corresponding encryption key is located according to the key graph, and the corresponding encrypted data block is obtained from the distributed storage node; decryption and graph traversal calculations are performed in a secure environment, and the query result is returned. Incremental update and key rotation: When new knowledge needs to be incrementally added to the encrypted knowledge graph, an encryption key is generated for the new knowledge; simultaneously, the encryption keys of the affected related existing knowledge are rotated and updated.

[0040] When a user initiates a query, the system first parses the query intent to determine the graph region that needs to be accessed. Then, it locates the required key through the key graph, retrieves the encrypted data block from the storage node, performs decryption and graph computation in a protected secure environment (such as a trusted execution environment or server memory with strict access control), and finally returns the result to the user, without exposing plaintext data throughout the entire process.

[0041] When incremental updates are needed, the system generates a new key for the newly added knowledge. At the same time, for forward security, the system analyzes the correlation between the new knowledge and the existing knowledge, triggering a rotation update of the keys for the affected related existing knowledge. That is, the relevant data is re-encrypted with the new key to ensure that historical data remains secure even if the old key is leaked.

[0042] The detailed working principle and operation process of this invention are as follows: Phase 1: Intelligent Task Planning and Distributed Dispatch Task Initiation and Resolution: When the system receives a knowledge graph construction request (e.g., "Construct a knowledge graph about 'AI ethics'"), the task scheduling center is activated. The scheduling center first invokes a predefined ontology schema for the "AI ethics" domain. This ontology acts as a blueprint for the project, defining the entity types to be extracted (e.g., "ethical principles", "algorithm models", "application scenarios", "potential risks"), relation types (e.g., "risky", "applicable", "violates principles"), and attribute constraints.

[0043] Task decomposition strategy: Based on this blueprint, the scheduling center performs intelligent task decomposition. It adopts a hybrid decomposition strategy: Vertical decomposition (by topic): The grand "AI ethics" map is broken down into multiple sub-tasks such as "extracting all ethical principles and related cases", "extracting well-known algorithms involving ethical risks", and "extracting ethical events that have occurred".

[0044] Horizontal decomposition (by data source): Simultaneously, massive data sources (such as different academic databases, news websites, and research reports) are allocated to different sub-task processing units to achieve data-level parallelism.

[0045] Agent matching and assignment: The decomposed subtasks are placed into a task queue. The scheduling center queries its maintained "large model agent capability profile library." This profile library records the performance of each agent in historical tasks. For example, agent Alpha may have high accuracy in extracting academic concepts, while agent Beta performs well in analyzing causal relationships in news events. Through optimal matching, the scheduling center assigns the "ethical principle" extraction task to Alpha and the "ethical event" analysis task to Beta. This on-demand allocation ensures that specialists do specialist tasks, improving quality from the outset.

[0046] Phase Two: Parallel Knowledge Extraction and Preliminary Fragmentation Distributed parallel execution: After receiving the task instructions and the specified data source, each agent node begins to work in parallel. Each agent independently invokes its internal large model to perform deep semantic analysis on the assigned unstructured text.

[0047] Information extraction and structuring: The core operations performed by an intelligent agent include: Entity Recognition and Linking: Identify entity references appearing in text and link them to standard concepts in the ontology. For example, identify "algorithmic bias" and categorize it as the "potential risk" entity type.

[0048] Relation extraction: Analyze the context of a sentence to extract the relationships between entities. For example, from "A certain recruitment algorithm is accused of gender discrimination", extract the triple (a certain recruitment algorithm, risky, gender discrimination).

[0049] Attribute population: Extract detailed information about an entity, such as the definition, proposer, and time of a certain "ethical principle".

[0050] Knowledge Fragment Generation: The extracted information is encapsulated into structured "knowledge fragments." A fragment may be centered around a core entity, containing its attributes and relationships with other entities. These fragments are "prefabs" for building the knowledge graph, temporarily stored, and prepared for quality inspection.

[0051] Phase Three: Multiple rounds of cross-validation and consensus building (core of quality control) Verification Initiation: Once the initial knowledge fragments are generated, the system's "quality control loop" is activated. The scheduling center or a dedicated verification coordination module identifies fragments with potential correlations or conflicts. For example, agent A submits the fragment "Algorithm C has a risk of insufficient transparency," while agent B submits a fragment that might imply "Algorithm C has high transparency." The system automatically marks these fragments as requiring verification.

[0052] Distributed cross-validation: The labeled fragments are distributed anonymously (or non-anonymously) to one or more other agents for independent validation. Each validator, based on its own knowledge base and reasoning ability, judges the authenticity and plausibility of the fragment and outputs a validation result with confidence.

[0053] Consensus Mechanism: The system presets a confidence threshold (e.g., 0.75). Consensus Achievement: If more than a certain number (e.g., 2 / 3) of the verifiers judge it as "true," and the average confidence level is higher than the threshold, then the fragment is adopted as high-confidence knowledge. Arbitration Mechanism: If the verification results are significantly divergent or the confidence level is insufficient, the disputed fragment is escalated and submitted to an arbitrator agent designated as the "chief expert." The arbitrator's judgment is final, ensuring that all disputes are resolved.

[0054] Feedback learning: The entire verification and arbitration process, results, and the performance of each agent are recorded. This data is used to dynamically update the capability profile of each agent. For example, an agent that makes multiple errors in verification will have its credibility score in that domain decrease, thus affecting its future task assignments. This forms a self-learning and optimization loop for the system.

[0055] Phase Four: Secure Integration and Encrypted Storage (Secure Implementation) Knowledge Fusion: Verified, highly reliable knowledge fragments are sent to the fusion center. The core task here is to resolve conflicts from different fragments (such as different descriptions of the same entity attribute) and perform entity alignment (determining whether different names point to the same entity). The system automatically completes the fusion according to preset strategies (such as prioritizing authoritative data sources and the most recent timestamp), forming a high-quality "sub-graph" with consistent internal logic.

[0056] Security Assessment and Dynamic Key Generation: Before storage, the system performs a security scan on the subgraph. Each entity and relation is assigned a security level based on its sensitivity (according to security tags in the ontology or content analysis). Subsequently, the system dynamically generates a unique encryption key for each data unit that needs encryption. A key innovation of the key generation algorithm is that its input includes not only the identifier and security level of the data unit itself, but also the identifiers of its directly related neighbors. This means that the key of a "patient" node is associated with the identifiers of its "disease" nodes and "doctor" nodes. This mechanism makes the local structure of the graph part of the key, greatly enhancing security.

[0057] Constructing a key graph and distributed storage: The system generates a "key graph" that is completely isomorphic to the knowledge subgraph. The nodes and edges of the key graph do not store plaintext data, but rather their corresponding encryption keys or key indexes. Subsequently, the plaintext data of the knowledge graph is encrypted into ciphertext data blocks, which, along with the encrypted key graph, are distributed and stored on different physical nodes. This "data-key separation" and "key-structure binding" design ensures fine-grained access control and prevents attackers from obtaining meaningful plaintext information even if a single storage node is compromised.

[0058] Phase 5: Continuous Operation and Security Inquiry Secure Query Processing: When a user submits a query, the query parser first determines the graph region that needs to be accessed. The system locates the required key through the key graph, extracts the corresponding encrypted data block from distributed storage, and completes decryption and graph traversal calculations in a controlled and secure environment (such as a memory encryption zone). Only the final query result is returned to the user, ensuring that plaintext data is not leaked during the query process.

[0059] Incremental Updates and Key Rotation: When new knowledge needs to be added, the system generates a new key and stores it encrypted. Simultaneously, for the highest level of security (forward security), the system analyzes the relationship between new and old knowledge, automatically triggering key rotation for associated old data units. This means re-encrypting the old data with the new key, ensuring that historical data is protected even if the old encryption key has been leaked.

[0060] It is understood that the present invention has been described through some embodiments, and those skilled in the art will recognize that various changes or equivalent substitutions can be made to these features and embodiments without departing from the spirit and scope of the invention. Furthermore, under the teachings of the present invention, these features and embodiments can be modified to adapt to specific situations and materials without departing from the spirit and scope of the invention. Therefore, the present invention is not limited to the specific embodiments disclosed herein, and all embodiments falling within the scope of the claims of this application are within the protection scope of the present invention.

Claims

1. A method for constructing and encrypted storing a distributed knowledge graph based on a large model, characterized in that, Includes the following steps: Step S1, Task Planning and Agent Allocation: Receive the knowledge graph construction request and decompose the overall construction task into multiple knowledge extraction sub-tasks based on the predefined ontology pattern; Based on the pre-constructed capability profiles of large model agents, the subtasks are assigned to multiple large model agents with corresponding advantages in the distributed network. Step S2, Distributed Knowledge Extraction and Fragment Generation: Each of the large model agents processes the assigned sub-tasks in parallel, performing entity recognition, relation extraction, and attribute filling operations from the specified unstructured or semi-structured data sources to generate structured preliminary knowledge fragments. Step S3, Multi-round cross-validation and consensus: For the preliminary knowledge fragments, multi-round cross-validation is initiated in the distributed agent network; knowledge fragments that are related or conflicting are distributed to at least one other large model agent for verification, and consensus is reached based on the confidence and consistency of the verification results to select knowledge fragments with high credibility. Step S4, Security-enhanced Knowledge Fusion and Subgraph Generation: Logically fuse the consensus-reaching high-confidence knowledge fragments to eliminate conflicts and form a high-quality subgraph with internal consistency; Step S5, fine-grained dynamic encrypted storage: security level assessment is performed on each entity and relationship in the sub-graph, and based on the assessment results and its structural context in the graph, encryption keys are dynamically generated for fine-grained encryption. Finally, the encrypted data blocks are distributed and stored on multiple storage nodes.

2. The method for constructing and encrypted storing a distributed knowledge graph based on a large model according to claim 1, characterized in that, The decomposition of the overall construction task based on the predefined ontology pattern in step S1 specifically includes: Based on the entity types and relation types defined in the ontology schema, the construction task is vertically divided according to entity type and / or horizontally divided according to data source to form the knowledge extraction subtask.

3. The method for constructing and encrypted storing a distributed knowledge graph based on a large model according to claim 1, characterized in that, The multi-round cross-validation and consensus-reaching process in step S3 specifically includes: Set a confidence threshold; A consensus is reached when the average confidence level of multiple verification results for the same knowledge fragment is greater than or equal to the confidence threshold and the results are consistent. When the verification results are inconsistent or the average confidence level is lower than the threshold, the disputed knowledge fragment is submitted to a large model agent designated as the arbitrator for final adjudication.

4. The method for constructing and encrypted storing a distributed knowledge graph based on a large model according to claim 3, characterized in that, The method further includes the following steps after step S3 and before step S4: Record disputed knowledge fragments where no consensus has been reached, along with their adjudication process and results, and use this as feedback data to update the capability profile of the large model agent.

5. The method for constructing and encrypted storing a distributed knowledge graph based on a large model according to claim 1, characterized in that, The step S5, which involves dynamically generating the encryption key based on the evaluation results and their structural context in the graph, specifically involves: A key derivation algorithm is used to derive a unique key by combining the unique identifier of an entity or relationship, its security level label, and the identifiers of its directly associated neighbors as input parameters.

6. The method for constructing and encrypted storing a distributed knowledge graph based on a large model according to claim 5, characterized in that, The method further includes: Construct a key graph that is isomorphic to the knowledge graph and stores the encryption key or key index corresponding to each entity node and relation edge. The key graph itself is encrypted as a whole before storage.

7. The method for constructing and encrypted storing a distributed knowledge graph based on a large model according to claim 6, characterized in that, Following step S5 is step S6, which involves secure query processing: Receive query requests, parse the query intent to determine the set of entities and relationships that need to be accessed; Based on the key map, locate the corresponding encryption key and obtain the corresponding encrypted data block from the distributed storage node; Perform decryption and graph traversal calculations in a secure environment, and return the query results.

8. The method for constructing and encrypted storing a distributed knowledge graph based on a large model according to claim 1, characterized in that, The knowledge fusion in step S4 includes conflict detection and resolution of attributes from different large model agents that point to the same entity.

9. The method for constructing and encrypted storing a distributed knowledge graph based on a large model according to claim 1, characterized in that, The method encrypts the initial knowledge fragments generated in step S2 during transmission between distributed nodes.

10. The method for constructing and encrypted storing a distributed knowledge graph based on a large model according to claim 1, characterized in that, The method further includes step S7, incremental update and key rotation: When new knowledge needs to be added incrementally to the encrypted knowledge graph, an encryption key is generated for the new knowledge; at the same time, the encryption keys of the affected existing knowledge are rotated and updated.

Images