Metalinguistic modeling and ai agent driven knowledge empowerment system

Abstract

This invention discloses a knowledge empowerment system based on meta-language modeling and AI Agent-driven architecture, relating to the field of artificial intelligence technology. The system includes a meta-language parser, a knowledge meta-graph storage layer, a management agent module, a query agent module, an IR execution engine, and a graph storage. The meta-language parser includes M1, a meta-language expression mechanism; the management agent module includes M2, a three-state verification-closed-loop maintenance mechanism; the query agent module includes M3, a clause-by-clause generation mechanism for DSL intermediate representation and pre-verification by the meta-graph; and the IR execution engine compiles the intermediate representation output by the query agent into a native graph query language and distributes it to the graph storage. This invention can significantly suppress AI illusions, improve the reliability of natural language queries, and significantly reduce the deployment time for new business models.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, specifically to a knowledge empowerment system based on meta-language modeling and AI Agent-driven approaches. Background Technology

[0002] Existing knowledge graph construction and query solutions mainly fall into three categories: (i) manual modeling, which relies on domain experts to solidify pattern constraints in the graph database management system through its built-in data definition language; (ii) rule or machine learning extraction, which extracts triples from unstructured text and writes them directly into the graph database through predefined templates or named entity recognition / relation extraction models; and (iii) large language model question answering, which translates natural language queries into native query statements of the graph database directly through prompt word templates.

[0003] However, in practical applications, the following drawbacks exist:

[0004] (1) The schema constraint semantics are weak: The schema constraint mechanism of graph databases can only describe shallow constraints such as attribute type and uniqueness of a single entity. It is difficult to describe "cross-entity semantic predicates" and "graph-level topological constraints". For example, a certain relationship is only allowed to be established when the attributes of the two entities satisfy a certain mapping relationship, or a certain loop is not allowed to appear in the whole graph. As a result, complex business rules can only be buried in the application code, and the scope of changes is large when the schema evolves.

[0005] (2) AI extraction lacks structured constraint feedback: existing solutions only perform naive deduplication after the output triples of the large language model, lacking bidirectional verification with the pattern definition and confidence feedback, resulting in AI illusion and uncontrollable graph quality.

[0006] (3) Poor reliability of natural language to native query language: The native query statements generated directly by the large language model are prone to: syntax errors; dead loops, variable-length paths with no depth limit; intent deviation, and missed detections caused by using string fuzzy matching instead of vector recall. On the internal test set, the executable rate of the native query statements generated directly by the advanced general-purpose large language model is about 62%, and the semantic accuracy is about 48%.

[0007] (4) Lack of adjudication basis for multi-source fusion conflicts: When the attribute values ​​of entities with the same name from different business systems are inconsistent, the existing solutions lack a unified priority and merging algorithm, and attribute overwriting errors often occur.

[0008] Based on the above, this invention proposes a knowledge empowerment system based on meta-language modeling and AI Agent-driven approach. Summary of the Invention

[0009] This invention aims to overcome the above-mentioned defects and provide a knowledge empowerment system and method based on meta-language modeling and agent-driven approach. It constructs a technical closed loop from bottom-level modeling to top-level application through a three-layer technical route of meta-language blueprint, agent maintenance, and query language decoupling.

[0010] To achieve the above objectives, the present invention provides the following technical solution:

[0011] A knowledge empowerment system based on meta-language modeling and AI Agent-driven approaches includes:

[0012] Meta-language parser, knowledge meta-graph storage layer, management agent module, query agent module, IR execution engine, and graph storage;

[0013] The meta-language parser includes: M1, a meta-language expression mechanism that describes "cross-entity semantic predicates" and "graph-level topological constraints" with computable expressions, and compiles the expressions into runtime meta-graph objects that reside in memory and can be maintained and referenced by the query process.

[0014] The management intelligent agent module includes: M2, a three-state verification-closed-loop maintenance mechanism, which uses the three states of acceptance, postponement, and rejection to determine the legality of each candidate triplet based on the runtime meta-graph object, forming a traceable and idempotent knowledge maintenance closed loop;

[0015] The query agent module includes: M3, a clause-by-clause generation mechanism for DSL intermediate representation and received meta-graph pre-verification, and describes the DSL intermediate representation and clause-by-clause generation, pre-verification, and compilation;

[0016] The IR execution engine compiles the intermediate representation output by the query agent into a native graph query language and sends it to the graph storage.

[0017] Preferably, M1, the meta-language expression mechanism, includes runtime meta-graph object construction methods for meta-language descriptions:

[0018] S101, Receive a meta-language definition document, wherein the meta-language definition document describes entity types, relation types and graph-level topology rules in the form of structured data, wherein the entity type includes at least an attribute set, attribute type, required fields, primary key and attribute-level constraint expression, wherein the relation type includes at least a start and end entity type, cardinality, direction and cross-entity semantic predicate expression, and wherein the graph-level topology rules include at least a graph pattern Boolean expression carried by quantifiers;

[0019] S102, the attribute-level constraint expressions, cross-entity semantic predicate expressions and graph pattern Boolean expressions in the meta-language definition document are compiled into syntax trees that can be evaluated at runtime. The syntax trees contain field reference nodes, built-in function nodes, Boolean logic nodes and quantifier nodes.

[0020] S103 assembles the compilation artifacts into a runtime metagraph object containing entity indexes, relation start indexes, relation end indexes, a list of topological rule expressions, and version metadata;

[0021] S104, the runtime metagraph object is exposed to the subsequent maintenance and query processes as a unified reference for legality determination and semantic alignment.

[0022] Preferably, the built-in functions supported by the syntax tree in S102 include set operations, string operations, numerical comparisons, quantifiers, and graph pattern assertions; the graph pattern assertions at least include reachability determination and loop determination.

[0023] S103 includes persisting the runtime metagraph object in a versioned manner, with each version recorded by the parent version number and the field level difference, and performing backward compatibility checks when a new version is submitted. The backward compatibility checks include at least: prohibiting the deletion of existing required attributes; and prohibiting the reversal of existing relationship directions.

[0024] Preferably, the M2 three-state verification-closed-loop maintenance mechanism includes an automated knowledge base maintenance method:

[0025] S201, receive raw data from multiple data sources and produce candidate triples, wherein the production process injects the entity type, relation type and predicate in the runtime metagraph object into the prompt word context of the large language model in a closed set manner;

[0026] S202, for each candidate triplet, perform a three-state judgment in the following order: entity type existence, relation type existence, relation direction, cross-entity predicate, attribute constraint, and required attribute existence. If any of the first five items fails, output a rejection state; if only the required attribute is missing, output a deferred state; if all items pass, output an acceptance state. The judgment result includes a reason code and a location field.

[0027] S203, according to the judgment result, the candidate triples in the accept state enter the disambiguation queue; the candidate triples in the deferred state enter the completion queue, and after completion, the candidate is written back and a re-verification is triggered; the candidate triples in the reject state enter the abnormal audit storage.

[0028] Preferably, in S203, each queue performs consistent hash sharding processing using the primary key of the head entity of the candidate triple as the sharding key, and supports at least one replay semantics through message middleware;

[0029] The processing in the disambiguation queue includes: when multiple sources give different values ​​for the same attribute of the same entity, the winning value is selected according to the multi-factor weighted score, which includes at least the data source credibility, record freshness, extraction confidence and evidence length; the losing value enters the shadow branch to retain the traceability chain;

[0030] S202 includes writing the judgment result and reason code back to the training sample pool for use in the selection of prompt word samples in the subsequent extraction process.

[0031] Preferably, the knowledge base automated maintenance method also includes a topology-level inspection step: periodically traversing the list of topology rule expressions in the runtime metagraph object, evaluating the expressions of graphs that have been stored in the database, and routing violators to the repair process according to priority.

[0032] Preferably, the clause-by-clause generation mechanism of M3, DSL intermediate representation and subject graph pre-verification includes knowledge query reasoning methods:

[0033] S301, a domain-specific query language is provided as an intermediate representation. The intermediate representation consists of seven types of clauses: target, filter, path, operator, return, sort, and truncation. There are dependencies and partial orders among the seven types of clauses. The variable-length path in the path clause must explicitly declare the upper limit of the number of hops. The operators include at least a semantic recall operator and a rule filtering operator.

[0034] S302, the query agent receives the user's natural language intent and produces the intermediate representation clause by clause according to the dependent partial order;

[0035] S303, each clause generated is pre-validated against the runtime metagraph object, and if the pre-validation fails, it falls back to candidate generation;

[0036] S304, the intermediate representation is converted into a native graph query language through a compilation process and executed. The compilation process includes at least: replacing the rule filtering operator with the expression corresponding to the rule identifier in the runtime metagraph object; pushing down the semantic recall operator to the underlying similarity calculation; and inserting an optional secondary rearrangement stage on the native query result.

[0037] Preferably, clause generation in S302 employs a search process with candidate bundles, wherein when a clause fails pre-verification, the candidate bundle is backed up to the candidate set corresponding to that clause for replacement.

[0038] S303's validity pre-verification includes at least the following: the entity type exists in the runtime metagraph object; the attribute exists in the entity type; the relationship direction and start / end entity type are consistent with the runtime metagraph object; and the path pattern can be verified as reachable by the relationship index of the runtime metagraph object.

[0039] The domain-specific query language in S301 prohibits unlimited variable-length path expressions at the syntax level.

[0040] Preferably, the management agent module includes a data access submodule, a knowledge extraction submodule, a blueprint verification submodule, a conflict disambiguation submodule, a knowledge completion submodule, and a quality inspection submodule; the query agent module includes an intent recognition submodule, a semantic alignment submodule, an IR generation submodule, and a result integration submodule; the blueprint verification submodule and the IR generation submodule are both connected to the metagraph storage layer to obtain the runtime metagraph object.

[0041] This invention provides a knowledge empowerment system based on meta-language modeling and AI Agent-driven approaches. It offers the following advantages:

[0042] This invention employs three interconnected and irreplaceable mechanisms: M1 meta-language expression mechanism, M2 three-state verification-closed-loop maintenance mechanism, and M3 DSL intermediate representation and clause-by-clause generation mechanism pre-verified by the meta-graph. Computable expressions carry cross-entity semantic predicates and graph-level topological constraints, compiled into runtime meta-graph objects as a unified semantic reference for maintenance and query processes. A three-state decision function (accept, deferred, reject) diverts candidate triplets, driving disambiguation, completion backflow re-verification, and anomaly auditing queues respectively, accommodating the uncertain output of large language models. A domain-specific query language is introduced as an intermediate representation on top of the native graph query language, enforcing a variable-length path upper limit and using operators to carry semantic recall and rule referencing. The query agent generates intermediate representations clause-by-clause and pre-verifies them with the runtime meta-graph object before compiling them into the native graph query language for execution. This significantly suppresses AI illusions, improves the reliability of natural language queries, and significantly reduces the deployment time for new business models. Attached Figure Description

[0043] Figure 1 This is a diagram of the overall system architecture of the present invention;

[0044] Figure 2 This is a schematic diagram of the metadata object data structure during the runtime of this invention;

[0045] Figure 3 This is an overview diagram of the intelligent agent maintenance process of this invention;

[0046] Figure 4 This is a sequence diagram of the generation and execution of the query agent in this invention;

[0047] Figure 5 This is a comparison table of the query performance of the IR and the native query language of this invention;

[0048] Figure 6 This is the three-state verification queue flow diagram of the present invention;

[0049] Figure 7 This is a pipeline diagram for IR generation, pre-verification, and compilation in this invention.

[0050] In the diagram, 10 is the meta-language parser; 20 is the meta-graph storage layer; 30 is the management agent module; 31 is the data access; 32 is the knowledge extraction; 33 is the blueprint verification; 34 is the conflict disambiguation; 35 is the knowledge completion; 36 is the quality inspection; 40 is the query agent module; 41 is the intent recognition; 42 is the semantic alignment; 43 is the IR generation; 44 is the result integration; 50 is the IR execution engine; and 60 is the graph storage. Detailed Implementation

[0051] 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.

[0052] Example:

[0053] like Figure 1-7 As shown, this embodiment of the invention provides a knowledge empowerment system based on meta-language modeling and AI Agent-driven approach. This system can be used for knowledge graph modeling of multi-source heterogeneous data, automated maintenance, and query language generation and execution for business scenarios. The system includes:

[0054] Meta-language parser, meta-graph storage layer, management agent module, query agent module, IR execution engine, and graph storage;

[0055] The meta-language parser includes: M1, a meta-language expression mechanism that describes "cross-entity semantic predicates" and "graph-level topological constraints" with computable expressions, and compiles the expressions into runtime meta-graph objects that reside in memory and can be maintained and referenced by the query process.

[0056] The management intelligent agent module includes: M2, a three-state verification-closed-loop maintenance mechanism, which uses the three states of acceptance, postponement, and rejection to determine the legality of each candidate triplet based on the runtime meta-graph object, forming a traceable and idempotent knowledge maintenance closed loop;

[0057] The query agent module includes: M3, a clause-by-clause generation mechanism for DSL intermediate representation and received meta-graph pre-verification, and describes the DSL intermediate representation and clause-by-clause generation, pre-verification, and compilation;

[0058] The IR execution engine compiles the intermediate representation output by the query agent into a native graph query language and sends it to the graph storage.

[0059] The management agent module includes a data access submodule, a knowledge extraction submodule, a blueprint verification submodule, a conflict disambiguation submodule, a knowledge completion submodule, and a quality inspection submodule; the query agent module includes an intent recognition submodule, a semantic alignment submodule, an IR generation submodule, and a result integration submodule; the blueprint verification submodule and the IR generation submodule are both connected to the metagraph storage layer to obtain the runtime metagraph object.

[0060] In this embodiment, the modules are configured for input, processing, and output as follows:

[0061] Metalanguage Parser 10: Input: Metalanguage definition document; Processing: Lexical / syntactic analysis, expression compilation, version difference merging; Output: Runtime metagraph object.

[0062] Knowledge Metagraph Storage Layer 20: Input: Metagraph version commit event; Processing: Compatibility check, differential persistence, full snapshot archiving; Output: Versioned metagraph record.

[0063] The management agent module 30 includes a data access submodule 31, a knowledge extraction submodule 32, a blueprint verification submodule 33, a conflict disambiguation submodule 34, a knowledge completion submodule 35, and a quality inspection submodule 36. Input: Raw data; Processing: Mechanism M2 closed loop; Output: Compliance triplet written to graph storage.

[0064] The query agent module 40 includes an intent recognition submodule 41, a semantic alignment submodule 42, an IR generation submodule 43, and a result integration submodule 44. Input: User natural language; Processing: M3 pipeline mechanism; Output: IR script and rendering results.

[0065] IR Execution Engine 50: Input: IR script; Processing: rule replacement, vector operator pushdown, compilation and distribution of native query statements; Output: graph query result set.

[0066] Graph Storage 60: Stores actual knowledge triples and accepts query and write operations issued by the IR execution engine; it can be implemented by any graph database that supports native graph query languages.

[0067] In this embodiment, the meta-language parser 10 is bidirectionally connected to the knowledge meta-graph storage layer 20 for parsing / persistence; the knowledge meta-graph storage layer 20 distributes runtime meta-graph objects to the management agent module 30 and the query agent module 40; the output of the management agent module 30 is written to the graph storage 60 through the IR execution engine 50; the output of the query agent module 40 is read from the graph storage 60 through the IR execution engine 50; and the user interacts with the system through the entry point of the query agent module 40.

[0068] In this embodiment, M1, the meta-language expression mechanism, includes a runtime meta-graph object construction method described by the meta-language:

[0069] S101, Receive a meta-language definition document, wherein the meta-language definition document describes entity types, relation types and graph-level topology rules in the form of structured data, wherein the entity type includes at least an attribute set, attribute type, required fields, primary key and attribute-level constraint expression, wherein the relation type includes at least a start and end entity type, cardinality, direction and cross-entity semantic predicate expression, and wherein the graph-level topology rules include at least a graph pattern Boolean expression carried by quantifiers;

[0070] S102, the attribute-level constraint expressions, cross-entity semantic predicate expressions and graph pattern Boolean expressions in the meta-language definition document are compiled into syntax trees that can be evaluated at runtime. The syntax trees contain field reference nodes, built-in function nodes, Boolean logic nodes and quantifier nodes.

[0071] S103 assembles the compilation artifacts into a runtime metagraph object containing entity indexes, relation start indexes, relation end indexes, a list of topological rule expressions, and version metadata;

[0072] S104, the runtime metagraph object is exposed to the subsequent maintenance and query processes as a unified reference for legality determination and semantic alignment.

[0073] Furthermore, the built-in functions supported by the syntax tree in S102 include set operations, string operations, numerical comparisons, quantifiers, and graph pattern assertions; the graph pattern assertions at least include reachability determination and loop determination.

[0074] S103 includes persisting the runtime metagraph object in a versioned manner, with each version recorded by the parent version number and the field level difference, and performing backward compatibility checks when a new version is submitted. The backward compatibility checks include at least: prohibiting the deletion of existing required attributes; and prohibiting the reversal of existing relationship directions.

[0075] In this embodiment, M2, the three-state verification-closed-loop maintenance mechanism, includes an automated knowledge base maintenance method:

[0076] S201, receive raw data from multiple data sources and produce candidate triples, wherein the production process injects the entity type, relation type and predicate in the runtime metagraph object into the prompt word context of the large language model in a closed set manner;

[0077] S202, for each candidate triplet, perform a three-state judgment in the following order: entity type existence, relation type existence, relation direction, cross-entity predicate, attribute constraint, and required attribute existence. If any of the first five items fails, output a rejection state; if only the required attribute is missing, output a deferred state; if all items pass, output an acceptance state. The judgment result includes a reason code and a location field.

[0078] S203, according to the judgment result, the candidate triples in the accept state enter the disambiguation queue; the candidate triples in the deferred state enter the completion queue, and after completion, the candidate is written back and a re-verification is triggered; the candidate triples in the reject state enter the abnormal audit storage.

[0079] Furthermore, in S203, each queue performs consistent hash sharding processing using the primary key of the head entity of the candidate triple as the sharding key, and supports at least one replay semantics through message middleware;

[0080] The processing in the disambiguation queue includes: when multiple sources give different values ​​for the same attribute of the same entity, the winning value is selected according to the multi-factor weighted score, which includes at least the data source credibility, record freshness, extraction confidence and evidence length; the losing value enters the shadow branch to retain the traceability chain;

[0081] S202 includes writing the judgment result and reason code back to the training sample pool for use in the selection of prompt word samples in the subsequent extraction process.

[0082] Furthermore, the knowledge base automated maintenance method also includes a topology-level inspection step: periodically traversing the list of topology rule expressions in the runtime metagraph object, evaluating the expressions of graphs that have been stored in the database, and routing violators to the repair process according to priority.

[0083] In this embodiment, the clause-by-clause generation mechanism of M3, DSL intermediate representation and received meta-graph pre-verification includes a knowledge query reasoning method:

[0084] S301, a domain-specific query language is provided as an intermediate representation. The intermediate representation consists of seven types of clauses: target, filter, path, operator, return, sort, and truncation. There are dependencies and partial orders among the seven types of clauses. The variable-length path in the path clause must explicitly declare the upper limit of the number of hops. The operators include at least a semantic recall operator and a rule filtering operator.

[0085] S302, the query agent receives the user's natural language intent and produces the intermediate representation clause by clause according to the dependent partial order;

[0086] S303, each clause generated is pre-validated against the runtime metagraph object, and if the pre-validation fails, it falls back to candidate generation;

[0087] S304, the intermediate representation is converted into a native graph query language through a compilation process and executed. The compilation process includes at least: replacing the rule filtering operator with the expression corresponding to the rule identifier in the runtime metagraph object; pushing down the semantic recall operator to the underlying similarity calculation; and inserting an optional secondary rearrangement stage on the native query result.

[0088] Furthermore, clause generation in S302 employs a search process with candidate bundles, where the candidate bundle is replaced by the candidate set corresponding to the clause when the pre-verification of a clause fails.

[0089] S303's validity pre-verification includes at least the following: the entity type exists in the runtime metagraph object; the attribute exists in the entity type; the relationship direction and start / end entity type are consistent with the runtime metagraph object; and the path pattern can be verified as reachable by the relationship index of the runtime metagraph object.

[0090] The domain-specific query language in S301 prohibits unlimited variable-length path expressions at the syntax level.

[0091] In a further embodiment of this invention, the meta-language modeling and runtime meta-graph object are interpreted, corresponding to mechanism M1 (meta-language expression mechanism), which is used to solve the problems of existing graph database schema constraints having poor semantics, unable to describe cross-entity predicates and graph-level topological constraints; unable to retain version and rollback capabilities during schema evolution, and difficult to be maintained and referenced by the query process.

[0092] In this embodiment, a structured meta-language is defined, the formal features of which are independent of specific data serialization formats and specific storage backends, including:

[0093] (M1-a) Entity type definition clause: declares the entity type name, attribute set, attribute type, required attributes, primary key attribute set, and attribute-level constraint expression;

[0094] (M1-b) Relation type definition clause: declares the relation type name, start and end entity types, cardinality, direction, and describes the semantic conditions for the relationship to hold across entities using a computable binary predicate expression;

[0095] (M1-c) Topology rule definition clause: Describes the structural constraints that the entire graph must satisfy in a graph-level Boolean expression carried by a universal quantifier or an existential quantifier, including but not limited to no self-loops, no specified pattern cycles, and required nodes;

[0096] (M1-d) Expression compilation: The expression fields in (M1-a), (M1-b), and (M1-c) are compiled into a syntax tree that can be evaluated at runtime. The syntax tree contains field reference nodes, built-in function nodes, Boolean logic nodes, and quantifier nodes.

[0097] (M1-e) Runtime Metagraph Object: The compilation artifacts are exposed to the maintenance and query processes as a unified object containing entity indexes, relation start indexes, relation end indexes, a list of topological rule expressions, and version metadata;

[0098] (M1-f) Versioning evolution: Each meta-language change is recorded with the parent version number and field-level difference. During evolution, backward compatibility is automatically checked, and deletion of existing required attributes or reversal of existing relationship directions is prohibited.

[0099] In this embodiment: Only when (M1-a)~(M1-f) exist simultaneously can the verification basis of the maintenance process and the semantic reference system of the query process come from the same object, thereby supporting the unified constraints of subsequent mechanisms M2 (three-state verification - closed-loop maintenance mechanism) and M3 (DSL intermediate representation and clause generation mechanism of subject meta-graph pre-verification).

[0100] Implementation method of this embodiment:

[0101] In one non-limiting implementation, the meta-language can be carried on structured data formats, including but not limited to JSON, YAML, Protocol Buffers, or custom grammars.

[0102] The following is a sample document using JSON as an example:

[0103] { "version": "1.0.3", "parent": "1.0.2", "EntityTypes": [{"name":"Company","primaryKey": ["name"],"properties": [{"name":"name","type":"String","required":true},{"name":"industry","type":"String","constraint":"in(['IT','Manufacturing','Finance'])"}]},{"name": "Product","primaryKey": ["name","category"],"properties": [{"name":"name","type":"String","required":true},{"name":"category","type":"String","required":true}]} ], "RelationTypes": [{"name":"OWNS_PRODUCT","from":"Company","to":"Product","cardinality":"1-N","predicate":"to.category in domainOf(from.industry)"} ], "TopologyRules":[{"id":"NO_SELF_COMPETE","expr":"forall p:Product, not(p)-[:COMPETES_WITH]->(p)"} ]}

[0104] In this implementation, lexical / syntactic analysis can be implemented by a parser generator; the built-in functions supported by the expression syntax tree include set operations (in, subset), string operations (match, regex), numerical comparisons, quantifiers (forall, exists), and graph pattern assertions (reachable, cyclic). The runtime metagraph object can be carried by a memory object graph and supported for concurrent access with read-write locks; versions and differences can be persisted by any relational database or key-value store. The specific format, syntax generator, and storage medium are all alternative implementation details.

[0105] One implementation: mapping heterogeneous data to field objects of runtime metagraph objects.

[0106] An example of a field mapping algorithm is as follows:

[0107] Algorithm SchemaMapping(source, M)Input: source schema S, runtimeMetaGraph MOutput: mapping SM: S.field -> M.EntityType.property |M.RelationType1. for each field f in S:2.cands = M.entities[*].properties.filter(lexicalSim(f.name, p.name) > θ1 OR semanticSim(f.desc,p.desc) > θ2)3.rank cands by α*semanticSim + β*lexicalSim + γ*typeMatch4.SM[f] = top15. for each foreign-key f1->f2 in S:6.SM[FK] = first r inM.relations where r.from=SM[f1].entity and r.to=SM[f2].entity7. return SM

[0108] Where α+β+γ=1; lexicalSim, semanticSim and typeMatch can be implemented by edit distance, vector embedding cosine similarity and type compatibility scoring functions, respectively; the scoring functions and weights are all alternative implementation parameters.

[0109] In a further embodiment of this paper, the three-state verification and closed-loop maintenance are explained, corresponding to mechanism M2 (three-state verification-closed-loop maintenance mechanism), which is used to solve the problems of: "the triples extracted by the large language model have no structured feedback links, and directly rejecting some missing fields will lead to information waste, while directly accepting them will lead to quality degradation; and there is a lack of adjudication basis for merging multi-source data".

[0110] This embodiment defines and maintains a closed loop based on three-state verification, including:

[0111] (M2-a) Tri-state decision function: Takes the runtime metamap object as a parameter and returns a three-valued result for each candidate triplet—ACCEPT, DEFER, REJECT, with a reason code and location field attached to the result;

[0112] (M2-b) Priority and mutual exclusion determination: Six types of checks are performed sequentially: entity type existence, relation existence, relation direction, relation cross-entity predicate, attribute constraint expression, and required attribute existence; the first five types of violations output REJECT, and only the missing required attribute outputs DEFER; the above determination process constitutes a mutually exclusive three-state splitting;

[0113] (M2-c) Queue flow: ACCEPT records enter the disambiguation queue; DEFER records enter the completion queue, and after completion, they are written back to the candidate and trigger re-verification; REJECT records enter the exception audit storage and allow the Agent to review; This queue flow supports concurrent processing and at least one replay semantics with the primary key of the candidate triple's head entity as the sharding key;

[0114] (M2-d) Weighted disambiguation decision: When multiple sources give different values ​​for the same attribute of the same entity (located by primary key), the winning value is selected according to the configurable multi-factor weighted score, and the losing value enters the shadow branch to retain the traceability chain;

[0115] (M2-e) Extraction process constrained by metagraph: The extraction process injects the entity type, relation type and predicate of the runtime metagraph object into the context of the prompt words of the large language model in a closed set manner, so that the open generation of the large language model is converged into closed set classification.

[0116] (M2-f) Topology-level inspection: Periodically traverse the list of topology rule expressions in the runtime metagraph object, evaluate the expressions of graphs that have been stored in the database, and route violators to the repair process according to their priority.

[0117] In this embodiment, (M2-a), (M2-b), and (M2-c) are combined to upgrade the binary judgment of "whether the constraint is satisfied" to a ternary judgment of "whether it is satisfied, whether it can be supplemented, and whether it is rejected". The three states are coupled with the downstream processing path through queue flow, so as to accept the uncertain output of the large language model in an idempotent and replayable manner.

[0118] Implementation method of this embodiment:

[0119] One implementation method, a three-state determination function:

[0120] def validate(triple, M):if triple.head.type not in M.entities: returnREJECT('UNK_ENT_HEAD')if triple.tail.type not in M.entities: return REJECT('UNK_ENT_TAIL')rel = M.relations.get(triple.rel.name)if rel is None:returnREJECT('UNK_REL')if rel.from != triple.head.type or rel.to !=triple.tail.type:return REJECT('DIRECTION')if rel.predicate and not eval_expr(rel.predicate, triple):return REJECT('PREDICATE_FAIL')for p in M.entities[triple.head.type].properties:if p.constraint and p.name in triple.head.props\and not eval_expr(p.constraint, triple.head.props[p.name]):return REJECT('CONSTRAINT')for p in M.entities[triple.head.type].properties:if p.requiredand p.name not in triple.head.props:return DEFER('MISS_PROP', p.name)returnACCEPT

[0121] This implementation strictly follows the decision priority defined by (M2-b): constraint violation takes precedence over mandatory missing fields, thereby ensuring the processing order of "falsification first, then waiting for completion" and avoiding wasting completion resources on candidates that are structurally invalid.

[0122] One implementation method involves queue flow and multi-agent collaboration:

[0123] In this implementation, candidate triples are sharded using consistent hashing based on the primary key of the header entity and processed by several parallel instances, each undertaking the roles of extraction, verification, disambiguation / completion, and inspection. Tasks are passed between instances via message queues, and task status is recorded using key-value storage. The specific message middleware, key-value storage, and parallel scheduling framework are all replaceable engineering carriers.

[0124] One implementation method, weighted disambiguation score:

[0125] score(record) = w1*sourceTrust + w2*recency + w3*conf + w4*evidenceLen. The default values ​​for Len are w1=0.4, w2=0.3, w3=0.2, and w4=0.1. Those skilled in the art can adjust the set of factors and weights according to business needs without deviating from the mechanism (M2-d).

[0126] One implementation method includes an extraction prompt template constrained by a meta-graph:

[0127] You are a knowledge extraction assistant. Only the following entity and relation types are allowed: {{EntityTypes_with_properties}}{{RelationTypes_with_from_to_predicate}}. Please extract triples from the following text and output a JSON array with the following fields: {head:{type,props}, rel:{name}, tail:{type,props},evidence:str, conf:0~1}. If no items can be extracted, return an empty array. Text: """{{text}}"""

[0128] The template is decoupled from the specific large language model selection; any large language model that can be generated based on a limited vocabulary can be used as the carrier of this mechanism (M2-e).

[0129] In a further embodiment of this invention, the intermediate representation of DSL and clause-by-clause generation, pre-verification, and compilation are explained, corresponding to mechanism M3, which is the clause-by-clause generation mechanism of intermediate representation of DSL and pre-verification of the received meta-graph.

[0130] This is designed to address the issues that "the native graph query language has a high user threshold, the native statements directly generated by the large language model have insufficient executability and intent accuracy, and the large language model lacks an alignable semantic reference system for 'when is it legal'".

[0131] This embodiment defines a domain-specific query language as an intermediate representation, hereinafter referred to as the intermediate representation IR, including:

[0132] (M3-a) Clause Structure: IR consists of seven types of clauses: "target", "filter", "path", "operator", "return", "sort", and "truncate". There are dependencies and partial orders between the clauses, which allows the generation process to unfold in a defined order.

[0133] (M3-b) Forced upper bound on path clauses: IR's variable-length path clauses require an explicit declaration of the upper bound on the number of hops, and prohibits path expressions without an upper bound at the syntax level, thereby eliminating path dead loops;

[0134] (M3-c) Operator-based semantic recall and rule referencing: semantic recall operators carry vector similarity matching, and rule filtering operators refer to rule identifiers in runtime meta-graph objects, so that business rules participate in queries by referencing rather than by hard-coding.

[0135] (M3-d) Clause-by-clause generation—pre-validation: The query agent generates IR clause by clause in a partial order of (M3-a). For each clause generated, the query runtime metagraph object performs a validity pre-validation. If the pre-validation fails, it falls back to candidate generation, thereby shifting the "exposure time of semantic errors" from the execution period to the generation period.

[0136] (M3-e) IR to native query language compilation: The compilation process includes three compile-time transformations: rule replacement (replacing rule filtering operators with expressions corresponding to rule identifiers in runtime metagraph objects), vector operator pushdown (pushing down semantic recall operators to similarity calculations that can be performed by the underlying graph storage or vector index), and reorder bypass (inserting an optional secondary reordering stage on the native query results).

[0137] Among them, the "pre-verification by clause" in (M3-d) expands the metagraph from a "constraint library" to a "semantic reference system", enabling large language models to eliminate most errors during the generation phase, rather than feeding back after failures during the execution phase.

[0138] Implementation method of this embodiment:

[0139] One implementation method: IR grammar and compilation example

[0140] Query::= 'FIND' Target ('WHERE' BoolExpr)?('VIA' PathPattern)?('USING' Operator (',' Operator)*)?('RETURN' Field (',' Field)*)?('ORDER BY'Field ('ASC'|'DESC'))?('LIMIT' INT)?Target::= EntityRefPathPattern ::=EntityRef ('-[' RelRef MaxHop? ']->' EntityRef)+MaxHop::= '*' INT '..' INT#Must explicitly cap Operator::= 'embedding_search(' EntityRef ',' STR ',' STRATEGY')'| 'rule_filter(' RuleId ')'| 'temporal(' Field ',' RANGE ')'| 'rerank('MODEL ')'BoolExpr::= ... (>, <, =, in, like, AND / OR / NOT)

[0141] Example of compiling IR into native graph query language (using the native query language of a graph database):

[0142] FIND Product(p) WHERE p.category='Watch' VIA Company(c)-[:OWNS_PRODUCT*1..2]->Product(p) USING embedding_search(p, 'Smartwatch Waterproof', name_category_embedding),rule_filter('PROD_ON_SALE'),rerank('reranker-base') RETURN p.name,p.category, p.launchDate, score ORDER BY score DESC LIMIT 10 ↓ Compiled artifacts (excerpt, native graph query language): MATCH (c:Company)-[:OWNS_PRODUCT*1..2]->(p:Product) WHERE p.category='Watch' WITH p, vec_cos(p.name_emb, $qEmb) AS score WHERE score>0.6 AND p.status='ON_SALE' RETURN p.name, p.category, p.launchDate, scoreORDER BYscore DESC LIMIT 10.

[0143] To fully disclose the technical effects of the present invention, comparative experimental results in one embodiment are given below.

[0144] This embodiment uses a specific graph database, vector index, and large language model as the engineering carrier; those skilled in the art can repeat this experimental design on different carriers to verify the effectiveness of the mechanism of the present invention.

[0145] Table 1 below shows a comparison of the quantitative effects of existing solutions and embodiments of the present invention:

[0146] index Existing solution baseline This invention (exemplary) relative improvement AI triplet extraction accuracy 73.4% 94.6% +21.2pp AI illusion rate (generating non-existent entities / relationships) 18.7% 2.1% -16.6pp NL2 native query language executability 62.0% 98.3% +36.3pp NL2 native query language semantic accuracy 48.0% 89.7% +41.7pp Average response time for complex multi-hop queries 1820ms 640ms -65% New business model launch time 5 people a day 0.5 person-days -90% Multi-source fusion automatic conflict resolution rate Manual labor required 92.4% —

[0147] Mechanism reasoning: (1) Mechanism M2-e transforms the large language model from open generation to closed set classification, which is the fundamental reason for the improvement in extraction accuracy and the decrease in illusion rate; (2) Mechanism M3-d moves the exposure time of semantic errors to the generation period, which is the fundamental reason for the simultaneous improvement of executability and semantic accuracy; (3) The operator pushdown of mechanism M3-e reduces the dependence on full table scanning of graph, which is the fundamental reason for the decrease in response time; (4) The versioned differential submission of mechanism M1-f allows new business models to be launched only by submitting differentials, which is the fundamental reason for the decrease in launch time; (5) The weighted disambiguation of mechanism M2-d provides a basis for adjudication of multi-source conflicts, which is the fundamental reason for the improvement in adjudication rate.

[0148] An experimental design is provided to support the quantitative comparison of the above embodiments:

[0149] Dataset:

[0150] Comparative experiments were conducted using three types of datasets, covering structured, semi-structured, and unstructured scenarios:

[0151] (1) Internal business dataset A: contains approximately 120 million triples, 120 entity types, and 380 relation types, covering three business sources: ERP, CRM, and product manuals of a certain group; used to evaluate the end-to-end maintenance and query performance under a large-scale graph.

[0152] (2) Public dataset B: Based on publicly available domain knowledge bases, it consists of approximately 5 million triples and is used to eliminate internal data bias and verify the transferability of methods;

[0153] (3) Natural Language Query Set C: 1,000 natural language queries annotated by domain experts and end users. Each query is accompanied by a gold standard native query statement and a gold standard answer set to evaluate executability, semantic accuracy and response time.

[0154] Baseline method:

[0155] To avoid confusion with the mechanism of this invention, all baselines are strictly implemented according to existing technologies:

[0156] B1: Manual schema + naive extraction – Domain experts manually model the data, and only type and deduplication checks are performed after extraction from the large language model; used to compare whether the three-state verification of the M2-a mechanism brings any gains.

[0157] B2: Manual schema + large language model directly generates native query language - no IR is performed on the query side, and the native query language is directly generated by the large language model; used to check whether the clause-by-clause pre-verification of the M3-d comparison mechanism brings any gains;

[0158] B3: Graph database built-in schema constraints - rely solely on the graph database's own schema constraint mechanism for verification; used to compare whether cross-entity predicates and graph-level topology constraints in mechanism M1 bring any gains;

[0159] B4: The complete solution of this invention—mechanisms M1+M2+M3 are all activated.

[0160] Table 2 below shows the definitions of the evaluation indicators:

[0161] index definition Calculation caliber Extraction accuracy The proportion of the extracted triplet that matches the gold standard TP / (TP+FP) AI illusion rate Percentage of generated triples of non-existent entity / relation types Number of violations generated / Total number of generated Execution rate The proportion of generated query statements that are syntax-free and can be successfully executed on graph storage. Executables / Total Number of Generated Executables semantic accuracy Among executable queries, the proportion of results that match the gold standard. Consistent number / Executable number Response time End-to-end time from query request to result return (median) P50 latency Online man-hours The number of person-days required to complete the integration of a new business model Manual records Conflict adjudication rate The proportion of multi-source conflicts that are automatically adjudicated by the system without human intervention Number of automatic rulings / Total number of conflicts

[0162] Ablation experimental design:

[0163] To clarify the independent contributions of mechanisms M1, M2, and M3, three ablation configurations were designed:

[0164] (Ablation-1) Close the queue flow of M2-c, and directly downgrade DEFER to REJECT. Observe the loss of recoverable triples; the expected decrease in extraction accuracy is 4–7 percentage points.

[0165] (Ablation-2) Disable clause-by-clause pre-validation of M3-d, generate IR once and then validate it, observe the executability rate and the number of rollbacks during generation; the executability rate is expected to decrease by 8–12 percentage points.

[0166] (Ablation-3) Turn off the graph-level topology constraints of M1-c and retain only the single entity attribute constraints. Observe the number of illegal topologies (isolated nodes, pattern cycles) in the graph. The number of illegal topologies is expected to increase by 5-10 times.

[0167] Experimental environment:

[0168] The experiment was conducted in one embodiment of the hardware and software environment: a general-purpose GPU server cluster, several general-purpose graph database instances, a general-purpose message middleware, and a key-value store; specific models, versions, and manufacturers do not constitute limitations of this invention.

[0169] Repeatability and statistical significance:

[0170] All indicators were reported as mean and standard deviation in three independent runs, and paired t-tests (two-tailed, significance level 0.05) were performed on each invention and each baseline. The invention was statistically significant relative to the baseline on all principal indicators (p < 0.01).

[0171] Furthermore, in this embodiment:

[0172] Instruction manual attached Figure 2The diagram illustrates the runtime metagraph object data structure, which includes three types of elements: EntityType nodes, PropertyDef child nodes, RelationType edges, and TopologyRule constraints, as well as a version node (Version). Each expression-type field is compiled into a syntax tree (ExprTree) and attached to its parent field as a child node.

[0173] Instruction manual attached Figure 3 The diagram shows an overview of the management agent maintenance process, which is as follows: S1 Data Access → S2 Knowledge Extraction → S3 Blueprint Verification (Three-State Determination) → (ACCEPT Branch) S4 Conflict Disambiguation → (Success Branch) Write to Graph Storage; (DEFER Branch) S5 Knowledge Completion → Return to S3 for Re-verification; (REJECT Branch) Write to Anomaly Audit; S6 Quality Inspection Periodic Backscan.

[0174] Instruction manual attached Figure 4 The sequence diagram for query agent generation and execution is shown. Where Actor = User; T1 Input Natural Language → T2 Intent Recognition → T3 Semantic Alignment → T4 IR Clause-by-Clause Generation (including Meta-Graph Pre-verification Loop) → T5 IR Compilation into Native Query Language and Execution → T6 Result Rendering Back to User;

[0175] Instruction manual attached Figure 5 The table shows a comparison of query performance between IR and native query language. The horizontal axis represents query scenarios, including exact, fuzzy, multi-hop, and rule filtering, while the vertical axis represents executability, semantic accuracy, and average response time.

[0176] Instruction manual attached Figure 6 The diagram illustrates a tri-state verification queue flow graph. At the center of the graph is the tri-state decision function 330, upstream of which is the candidate extraction queue 320. Downstream, it branches into three paths: the ACCEPT path passes through the sharder 341, performs consistency hashing based on the head entity primary key, enters the disambiguation queue 342, and is written to graph storage 60 after disambiguation; the DEFER path enters the completion queue 351, and after completion, sends the written-back candidate back to 320 to achieve a "re-verification" loop; the REJECT path enters the anomaly audit storage 333. Each edge is labeled with the data contract it carries, candidate triples, candidate triples and reason codes, compliant triples, triples to be completed, and write-back candidates.

[0177] Instruction manual attached Figure 6The diagram illustrates the IR generation, pre-validation, and compilation pipeline. From left to right, the flow is as follows: Intent slot 410 → Clause-by-clause generator 430 → Runtime metagraph object 20, serving as the pre-validation reference frame → Feedback loop: fall back to candidate generation if invalid → IR script 435 → Compiler 510, including three transformation stages: rule replacement, vector operator pushdown, and rearrangement bypass → Native query statement 520 → Graph storage execution 60 → Result backflow → Result integration 440. The "pre-validation loop" in the pipeline is explicitly drawn, corresponding to "performing a validity pre-validation against the runtime metagraph object for each generated clause" in the above embodiment.

[0178] Furthermore, alternative solutions to this embodiment include:

[0179] (1) Meta-language carrier: Any format with structured expression capabilities can be used, including but not limited to JSON, YAML, Protocol Buffers, and custom grammars. Their equivalence lies in the fact that they can all describe entity types, relation types, cross-entity predicates, graph-level topological constraints, and version differences.

[0180] (2) Expression syntax tree carrier: can be carried by any expression system capable of parsing Boolean logic, quantifiers and graph pattern assertions, including interpreters constructed by parser generators or handwritten recursive descent parsers.

[0181] (3) Large language model: Any large language model that supports generating structured output with closed set prompt words can be used, regardless of the specific vendor or parameter size.

[0182] (4) Graph storage and native query language: Any graph database that supports native graph query language can be used; the IR compilation target can be replaced by the compiler with native query language of different dialects without deviating from the M3-e mechanism.

[0183] (5) Message middleware, key-value storage and parallel scheduling framework: all are alternative engineering carriers. This mechanism M2-c only constrains the sharding key and at least one replay semantics, and does not constrain the specific implementation.

[0184] (6) Embedding and Rearrangement: The similarity calculation function pushed down by the semantic recall operator can be implemented by the distance function of any embedding space; the rearrangement operator can carry any secondary ranking model.

[0185] Unless otherwise specified, in this invention, terms such as "length," "width," "upper," "lower," "front," "rear," "left," "right," "vertical," "horizontal," "top," "bottom," "inner," "outer," "clockwise," "counterclockwise," "axial," "radial," and "circumferential" indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings. They are used only for the convenience of describing this invention and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation. Therefore, the terms used to describe orientation or positional relationships in this invention are for illustrative purposes only and should not be construed as limiting this patent. For those skilled in the art, the specific meaning of the above terms can be understood in conjunction with the accompanying drawings and according to the specific circumstances.

[0186] Unless otherwise explicitly specified and limited, the terms "set up," "connected," and "linked" in this invention should be interpreted broadly. For example, they can refer to a fixed connection, a detachable connection, or an integral connection; they can refer to a direct connection or an indirect connection through an intermediate medium; and they can refer to the internal connection of two components. Those skilled in the art can understand the specific meaning of the above terms in this invention based on the specific circumstances.

[0187] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention in any way. Any simple modifications or equivalent changes made to the above embodiments based on the technical essence of the present invention shall fall within the protection scope of the present invention.

Claims

1. A knowledge empowerment system based on meta-language modeling and AI Agent-driven approach, characterized in that: include: Meta-language parser, knowledge meta-graph storage layer, management agent module, query agent module, IR execution engine, and graph storage; The meta-language parser includes: M1, a meta-language expression mechanism that describes "cross-entity semantic predicates" and "graph-level topological constraints" with computable expressions, and compiles the expressions into runtime meta-graph objects that reside in memory and can be maintained and referenced by the query process. The management intelligent agent module includes: M2, a three-state verification-closed-loop maintenance mechanism, which uses the three states of acceptance, postponement, and rejection to determine the legality of each candidate triplet based on the runtime meta-graph object, forming a traceable and idempotent knowledge maintenance closed loop; The query agent module includes: M3, a clause-by-clause generation mechanism for DSL intermediate representation and received meta-graph pre-verification, and describes the DSL intermediate representation and clause-by-clause generation, pre-verification, and compilation; The IR execution engine compiles the intermediate representation output by the query agent into a native graph query language and sends it to the graph storage.

2. The knowledge empowerment system based on meta-language modeling and AI Agent-driven as described in claim 1, characterized in that: M1, the meta-language expression mechanism, includes methods for constructing runtime meta-graph objects based on meta-language descriptions. S101, Receive a meta-language definition document, wherein the meta-language definition document describes entity types, relation types and graph-level topology rules in the form of structured data, wherein the entity type includes at least an attribute set, attribute type, required fields, primary key and attribute-level constraint expression, wherein the relation type includes at least a start and end entity type, cardinality, direction and cross-entity semantic predicate expression, and wherein the graph-level topology rules include at least a graph pattern Boolean expression carried by quantifiers; S102, the attribute-level constraint expressions, cross-entity semantic predicate expressions and graph pattern Boolean expressions in the meta-language definition document are compiled into syntax trees that can be evaluated at runtime. The syntax trees contain field reference nodes, built-in function nodes, Boolean logic nodes and quantifier nodes. S103 assembles the compilation artifacts into a runtime metagraph object containing entity indexes, relation start indexes, relation end indexes, a list of topological rule expressions, and version metadata; S104, the runtime metagraph object is exposed to the subsequent maintenance and query processes as a unified reference for legality determination and semantic alignment.

3. The knowledge empowerment system based on meta-language modeling and AI Agent-driven according to claim 2, characterized in that: The built-in functions supported by the syntax tree in S102 include set operations, string operations, numerical comparisons, quantifiers, and graph pattern assertions; the graph pattern assertions include at least reachability determination and loop determination. S103 includes persisting the runtime metagraph object in a versioned manner, with each version recorded by the parent version number and the field level difference, and performing backward compatibility checks when a new version is submitted. The backward compatibility checks include at least: prohibiting the deletion of existing required attributes; and prohibiting the reversal of existing relationship directions.

4. The knowledge empowerment system based on meta-language modeling and AI Agent-driven according to claim 2, characterized in that: M2, the three-state verification-closed-loop maintenance mechanism, includes methods for automated knowledge base maintenance: S201, receive raw data from multiple data sources and produce candidate triples, wherein the production process injects the entity type, relation type and predicate in the runtime metagraph object into the prompt word context of the large language model in a closed set manner; S202, for each candidate triplet, perform a three-state judgment in the following order: entity type existence, relation type existence, relation direction, cross-entity predicate, attribute constraint, and required attribute existence. If any of the first five items fails, output a rejection state; if only the required attribute is missing, output a deferred state; if all items pass, output an acceptance state. The judgment result includes a reason code and a location field. S203, according to the judgment result, the candidate triples in the accept state enter the disambiguation queue; the candidate triples in the deferred state enter the completion queue, and after completion, the candidate is written back and a re-verification is triggered; the candidate triples in the reject state enter the abnormal audit storage.

5. The knowledge empowerment system based on meta-language modeling and AI Agent-driven according to claim 4, characterized in that: In S203, each queue performs consistent hash sharding processing using the primary key of the head entity of the candidate triplet as the sharding key, and supports at least one replay semantics through message middleware. The processing in the disambiguation queue includes: when multiple sources give different values ​​for the same attribute of the same entity, the winning value is selected according to the multi-factor weighted score, which includes at least the data source credibility, record freshness, extraction confidence and evidence length; the losing value enters the shadow branch to retain the traceability chain; S202 includes writing the judgment result and reason code back to the training sample pool for use in the selection of prompt word samples in the subsequent extraction process.

6. The knowledge empowerment system based on meta-language modeling and AI Agent-driven according to claim 5, characterized in that: The automated knowledge base maintenance method also includes a topology-level inspection step: periodically traversing the list of topology rule expressions in the runtime metagraph object, evaluating the expressions of graphs that have been stored in the database, and routing violators to the repair process according to priority.

7. The knowledge empowerment system based on meta-language modeling and AI Agent-driven according to claim 4, characterized in that: M3, the clause-by-clause generation mechanism of intermediate representation and pre-verification of the meta-graph in DSL, including knowledge query reasoning methods: S301, a domain-specific query language is provided as an intermediate representation. The intermediate representation consists of seven types of clauses: target, filter, path, operator, return, sort, and truncation. There are dependencies and partial orders among the seven types of clauses. The variable-length path in the path clause must explicitly declare the upper limit of the number of hops. The operators include at least a semantic recall operator and a rule filtering operator. S302, the query agent receives the user's natural language intent and produces the intermediate representation clause by clause according to the dependent partial order; S303, each clause generated is pre-validated against the runtime metagraph object, and if the pre-validation fails, it falls back to candidate generation; S304, the intermediate representation is converted into a native graph query language through a compilation process and executed. The compilation process includes at least: replacing the rule filtering operator with the expression corresponding to the rule identifier in the runtime metagraph object; pushing down the semantic recall operator to the underlying similarity calculation; and inserting an optional secondary rearrangement stage on the native query result.

8. The knowledge empowerment system based on meta-language modeling and AI Agent-driven according to claim 6, characterized in that: In S302, clause generation adopts a search process with candidate bundles. When a clause fails pre-verification, the candidate bundle is backed up to the candidate set corresponding to that clause for replacement. S303's validity pre-verification includes at least the following: the entity type exists in the runtime metagraph object; the attribute exists in the entity type; the relationship direction and start / end entity type are consistent with the runtime metagraph object; and the path pattern can be verified as reachable by the relationship index of the runtime metagraph object. The domain-specific query language in S301 prohibits unlimited variable-length path expressions at the syntax level.

9. The knowledge empowerment system based on meta-language modeling and AI Agent-driven according to claim 1, characterized in that: The management intelligent agent module includes a data access submodule, a knowledge extraction submodule, a blueprint verification submodule, a conflict disambiguation submodule, a knowledge completion submodule, and a quality inspection submodule. The query agent module includes an intent recognition submodule, a semantic alignment submodule, an IR generation submodule, and a result integration submodule. Both the blueprint verification submodule and the IR generation submodule are connected to the metamap storage layer to obtain the runtime metamap object.

Images