Large model query generation system and method combining graph structure analysis and execution

Abstract

The invention discloses a large model query generation system and method combining graph structure analysis and execution, and the system comprises a graph mode standardization module which converts a description file into a unified structured representation; the large language model module is used for screening out nodes, edges and sub-graph modes required by query statements according to the natural language problem and the structured representation of the user; the graph mode detection module is used for detecting and modifying the screened nodes, edges and sub-graph modes through scripts; the large language model module generates an initial query statement according to a natural language problem of a user and detected and modified nodes, edges and subgraph modes; the query statement detection module is used for detecting the initial query statement through a script and generating an error report; and the large language model module generates a modified query statement. According to the large model query generation system and method combining graph structure analysis and execution, the accuracy of graph mode selection is remarkably improved through the thinking ability of the large language model and the script error detection ability, and therefore the quality of graph database query statement generation is improved.

Description

Technical Field

[0001] This invention specifically relates to a large model query generation system and method that combines graph structure analysis and execution. Background Technology

[0002] Graph databases are widely used in knowledge graphs, social networks, and recommendation systems, and their query efficiency and accuracy directly impact the performance of upper-layer applications. Taking financial risk control as an example, graph databases can identify fraud chains of up to ten hops in real time, compressing traditional batch processing tasks that used to take hours into minutes. In recommendation systems, graph databases model the three-dimensional relationship between users, products, and scenarios into a single graph, increasing click-through rates by over 18% in cold-start scenarios. Users typically use natural language to describe their query intent, while graph databases use structured query languages ​​(such as Cypher) for data retrieval. Converting natural language into Cypher queries is a crucial step in connecting user intent with graph databases.

[0003] Traditional methods rely on rules or templates, making them ill-suited for complex and ever-changing natural language queries. In recent years, large language models have demonstrated powerful capabilities in natural language processing tasks, offering new approaches to graph database query generation. By vectorizing the structured information of knowledge graphs and aligning it with the semantic space of large language models, cross-modal retrieval can be achieved without exposing the original data, balancing privacy and performance. However, large language models may generate inaccurate or invalid queries when processing complex graph patterns, affecting the accuracy and completeness of query results.

[0004] To address the aforementioned issues, a method is urgently needed that can fully leverage the natural language understanding capabilities of large language models while ensuring the accuracy of node, edge, and attribute selection. By employing a dual detection technique using both large language models and scripts, the quality of Cypher query generation can be effectively improved. Furthermore, by modifying the query statements based on their execution results, the overall quality of the query statements can be further enhanced. Summary of the Invention

[0005] This invention provides a large-scale model query generation system and method that combines graph structure analysis and execution to solve the aforementioned technical problems. Specifically, the technical solution is as follows: A large-scale model query generation system combining graph structure analysis and execution includes: The graph schema standardization module is used to obtain the original schema description file of the graph database and convert it into a unified structured representation; The large language model module is used to receive the structured representation of the graph pattern standardization module and the user's natural language question, and to filter out the nodes, edges and subgraph patterns required by the query statement based on the user's natural language question and the structured representation. The graph pattern detection module is used to receive the node, edge and subgraph patterns filtered by the large language model module based on the user's natural language question and structured representation, and compare the filtered node, edge and subgraph patterns with the structured representation through a script to detect and modify the node, edge and subgraph patterns filtered by the large language model module. The large language model module generates an initial query statement based on the user's natural language question and the node, edge, and subgraph patterns detected and modified by the graph pattern detection module. The query statement detection module is used to receive the initial query statement generated by the large language model module, and to detect the initial query statement through a script and generate an error report. The large language model module generates a modified query statement based on the user's natural language question, the modified node, edge, and subgraph pattern detected by the graph pattern detection module, the initial query statement generated by the large language model module, and the error report generated by the query statement detection module.

[0006] Furthermore, the large model query generation system combining graph structure analysis and execution also includes: The query statement verification module is used to execute the modified query statement generated by the large language model module in the corresponding graph database, obtain the execution result, and output the query statement if the execution is successful, and return an error message if the execution fails.

[0007] Furthermore, the large model query generation system combining graph structure analysis and execution also includes: The iterative optimization module receives error information returned by the query statement verification module, coordinates the large language model module and the query statement detection module to optimize the current query statement based on the error information, and then passes the optimization result to the query statement verification module for verification until successful execution or a specified number of times is reached, and outputs the final query statement.

[0008] Furthermore, the original schema description file of the graph database contains node labels, edge types, attributes, indexes, and constraints. The graph schema standardization module extracts node labels, edge types, attributes, indexes, and constraints through a syntax parser and an information extractor, and transforms them into a unified structured representation containing nodes and attributes, edges and attributes, subgraph schemas, and other key information.

[0009] Furthermore, the graph pattern detection module employs a character-by-character difference comparison algorithm to match the node, edge, and subgraph patterns output by the large language model module with the structured representation, thereby detecting and modifying the node, edge, and subgraph patterns selected by the large language model module.

[0010] Furthermore, the query statement detection module extracts nodes, edges, and attributes from the initial query statement using regular expressions, compares them with the structured representation to determine if there are semantic errors, then uses regular expressions to determine if there are syntax errors in the initial query statement, and finally generates an error report.

[0011] Furthermore, the query statement is a Cypher query statement.

[0012] A method for generating large-scale model queries that combines graph structure analysis and execution includes the following steps: S1: Obtain the original schema description file of the graph database and convert it into a unified structured representation; S2: The large language model receives the structured representation and the user's natural language question, and filters out the nodes, edges and subgraph patterns required by the query statement based on the user's natural language question and the structured representation; S3: Receive the node, edge, and subgraph patterns selected by the large language model based on the user's natural language question and structured representation, and compare the selected node, edge, and subgraph patterns with the structured representation through a script, and detect and modify the node, edge, and subgraph patterns selected by the large language model. S4: The large language model generates an initial query statement based on the user's natural language question and the detected modified node, edge, and subgraph patterns; S5: Receives the initial query statement generated by the large language model, and uses a script to detect the initial query statement and generate an error report; S6: The large language model generates a modified query statement based on the user's natural language question, the detected modified nodes, edges and subgraph patterns, the initial query statement generated by the large language model, and the generated error report.

[0013] Furthermore, the large model query generation method combining graph structure analysis and execution also includes: S7: Execute the modified query statement generated by the large language model in the corresponding graph database, obtain the execution result, output the query statement if the execution is successful, and return the error message if the execution fails.

[0014] Furthermore, the large model query generation method combining graph structure analysis and execution also includes: S8: Receive the returned error information, optimize the current query statement based on the error information, verify the optimization result, and continue until successful execution or the specified number of times is reached, and output the final query statement.

[0015] The advantage of this invention lies in the large model query generation system and method that combines graph structure analysis and execution, which effectively improves the quality of generated query statements through dual detection technology of large language model and script.

[0016] The advantage of this invention lies in the fact that the large model query generation system and method that combines graph structure analysis and execution can also modify the query statement based on the execution result of the query statement, thereby further improving the quality of the generated query statement. Attached Figure Description

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

[0018] Figure 1 This is a schematic diagram of the large-scale model query generation system that combines graph structure analysis and execution as described in this application.

[0019] Figure 2 This is a schematic diagram of the large model query generation method combining graph structure analysis and execution in this application. Detailed Implementation

[0020] Embodiments of the present invention are described in detail below. Examples of these embodiments are illustrated in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain the present invention, and should not be construed as limiting the present invention.

[0021] The accompanying drawings are merely illustrative of the invention and are not necessarily drawn to scale. Some of the block diagrams shown in the drawings are functional entities and do not necessarily correspond to physically or logically independent entities. These functional entities can be implemented in software, in one or more hardware modules or integrated circuits, or in different network and / or processor devices and / or microcontroller devices.

[0022] The flowchart shown in the attached diagram is merely an illustrative example and does not necessarily include all steps. For example, some steps may be broken down, while others may be combined or partially combined; therefore, the actual execution order may change depending on the specific circumstances.

[0023] In a specific embodiment of the present invention, we demonstrate the innovability and practicality of the invention by describing an exemplary embodiment in detail. This embodiment, in conjunction with the system architecture and flowcharts in the accompanying drawings, clearly illustrates the various key modules of the invention and their interactions. The embodiments of the present invention aim to provide those skilled in the art with a technical solution that is easy to understand and implement, while demonstrating the advantages and effects of the present invention in practical applications.

[0024] The core idea of ​​this invention is to combine the natural language understanding capabilities of a large language model with the semantic retrieval capabilities of vector retrieval to improve the accuracy and efficiency of graph pattern selection. Specifically, the core idea is implemented through a "semantic-structural" dual-channel alignment mechanism: on the one hand, the large language model is used to perform intent parsing and context completion on natural language questions; on the other hand, vector retrieval is used to map the parsing results to a high-dimensional semantic space, thereby achieving rapid recall and precise localization of nodes, edges, and subgraph patterns within a unified structured representation framework. This mechanism not only reduces the dependence on the inference time of the large model but also significantly reduces alignment errors caused by pattern heterogeneity. Figure 1 The diagram illustrates a large-scale model query generation system combining graph structure analysis and execution, comprising: a graph pattern standardization module, a large language model module, a graph pattern detection module, a query statement detection module, a query statement verification module, and an iterative optimization module. Through a closed-loop process of "graph pattern standardization - script verification - large-scale model generation - execution feedback iteration," it achieves highly accurate and robust automatic generation of Cypher queries. The modules are described in detail below.

[0025] The graph schema standardization module is used to obtain the original schema description file of the graph database and convert it into a unified structured representation. In actual deployment, the original schema description file may be the result of Neo4j's CALLdb.schema.visualization(), TigerGraph's SHOW SCHEMA output, or an Amazon Neptune RDF Schema serialization file. In the embodiments of this application, the original schema description file of the graph database contains node labels, edge types, attributes, indexes, and constraints. The graph schema standardization module extracts node labels, edge types, attributes, indexes, and constraints through a syntax parser and information extractor, and converts them into a unified structured representation containing nodes and attributes, edges and attributes, subgraph patterns, and other key information for subsequent processing. Specifically, the structured representation text is divided into four parts: nodes and attributes, edges and attributes, subgraph patterns, and other key information. Nodes and attributes are formatted as "Node 1 {Attribute 1: Value 1, Attribute 2: Value 2}", edges and attributes are formatted as "Edge 1 {Attribute 1: Value 1, Attribute 2: Value 2}", and subgraph patterns are formatted as "(:Start Point) - [:Edge] -> (:End Point)". Other key information includes unique identifiers and brief explanations for nodes and edges. In visual debugging mode, developers can directly view the structured tree-like expanded view through the web frontend. The highlight colors of nodes and edges are consistent with their color configurations in the original graph database, thereby reducing cognitive load.

[0026] The large language model module receives the structured representation from the graph pattern standardization module and the user's natural language question. Based on the user's natural language question and the structured representation, it filters the nodes, edges, and subgraph patterns required for the query statement. The large language model module can utilize large language models from local or cloud services for related operations. In this application, the query statement is a Cypher query statement. To ensure compatibility with future GQL (ISO / IEC 39075) standards, the large language model module reserves an output adaptation layer, allowing for one-click switching of the target query language in the configuration file without modifying the downstream module logic.

[0027] The graph pattern detection module receives node, edge, and subgraph patterns filtered by the large language model module based on the user's natural language question and structured representation. It then uses a script to compare the filtered node, edge, and subgraph patterns with the structured representation, and detects and modifies the node, edge, and subgraph patterns filtered by the large language model module.

[0028] In the embodiments of this application, the graph pattern detection module uses a character-by-character difference comparison algorithm (integrated as a text comparator) to match the node, edge, and subgraph patterns output by the large language model module with the structured representation, and detects and modifies the node, edge, and subgraph patterns selected by the large language model module.

[0029] The large language model module generates an initial query statement based on the user's natural language question and the modified node, edge, and subgraph patterns detected by the graph pattern detection module.

[0030] The query statement detection module receives the initial query statement generated by the large language model module, and uses a script to detect the initial query statement and generate an error report.

[0031] Specifically, the query statement detection module extracts nodes, edges, and attributes from the initial query statement using regular expressions, compares them with the structured representation to determine if there are semantic errors, and then uses regular expressions to determine if the initial query statement has syntax errors, finally generating an error report. The regular expression library adopts a pre-compiled caching strategy, remaining resident in memory after the first load to avoid the performance loss caused by repeated compilation. To support optional syntax (such as EXISTS subqueries and CALL clauses), the regular expression library can be dynamically extended as a plugin without requiring a service restart. The query statement detection module accepts query statements generated by a large language model in response to user queries. Using regular expressions, it firstly extracts the relevant nodes, edges, and attributes, compares them with the corresponding parts of the graph-patterned structured text to determine if the query statement contains fictitious information or incorrect attributes, and secondly, detects syntax errors in the query statement. This module determines whether the query statement generated by the large language model contains errors.

[0032] The large language model module generates a modified query statement based on the user's natural language question, the modified node, edge, and subgraph patterns detected by the graph pattern detection module, the initial query statement generated by the large language model module, and the error report generated by the query statement detection module. In the correction prompts, the error report is embedded in natural language, such as "The node label Employee does not exist in the graph pattern; please change it to Person." The large language model uses this context learning to significantly improve correction accuracy without additional fine-tuning.

[0033] The query validation module executes the modified query statements generated by the large language model module in the corresponding graph database, retrieves the execution results, and outputs the query statement if successful, and returns an error message if it fails. The validation module incorporates a sandbox isolation mechanism: each execution is completed within an independent transaction, and automatic rollback occurs upon completion, preventing pollution of production data.

[0034] The iterative optimization module receives error messages from the query validation module and coordinates the large language model module and query validation module to optimize the current query based on these messages. The optimized result is then passed to the query validation module for verification until successful execution or a specified number of iterations is reached, at which point the final query is output. The iterative optimization module supports strategic configuration: users can set the maximum number of iterations, the rollback strategy (linear rollback / exponential rollback), and whether to enable parallel validation (sending correction requests to multiple large model instances simultaneously and taking the optimal result) via a YAML file. In an A / B testing environment, the iterative optimization module records the token consumption, latency, and success rate of each correction, providing data support for subsequent model distillation and cost optimization.

[0035] like Figure 2 The following is a method for generating large model queries that combines graph structure analysis and execution, as described in this application: S1: Obtain the original schema description file of the graph database and convert it into a unified structured representation. S2: The large language model receives the structured representation and the user's natural language question, and filters out the nodes, edges, and subgraph patterns required by the query statement based on the user's natural language question and the structured representation.

[0036] S3: Receive the node, edge, and subgraph patterns selected by the large language model based on the user's natural language question and structured representation, and compare the selected node, edge, and subgraph patterns with the structured representation through a script, and detect and modify the node, edge, and subgraph patterns selected by the large language model.

[0037] S4: The large language model generates an initial query statement based on the user's natural language question and the modified node, edge, and subgraph patterns detected.

[0038] S5: Receives the initial query statement generated by the large language model, and uses a script to detect the initial query statement and generate an error report.

[0039] S6: The large language model generates a modified query statement based on the user's natural language question, the detected modified nodes, edges and subgraph patterns, the initial query statement generated by the large language model, and the generated error report.

[0040] S7: Execute the modified query statement generated by the large language model in the corresponding graph database, obtain the execution result, output the query statement if the execution is successful, and return the error message if the execution fails.

[0041] S8: Receive the returned error information, optimize the current query statement based on the error information, verify the optimization result, and continue until successful execution or the specified number of times is reached, and output the final query statement.

[0042] The large model query generation method combining graph structure analysis and execution in this application is based on the aforementioned large model query generation system combining graph structure analysis and execution. For relevant details, please refer to the aforementioned large model query generation system combining graph structure analysis and execution, which will not be repeated here.

[0043] To verify the effectiveness of the technical solution of this invention, this embodiment uses graph datasets from various source domains for testing, including enterprise relationship graph data and market risk analysis graph data. The enterprise relationship graph data contains 700,600 nodes and 1,960,028 edges, while the market risk analysis graph data contains 920,000 nodes and 750,000 edges. Comparative experiments were conducted using language models, CoT-based language models, self-refinement-based language models, and vector retrieval-based language models.

[0044] Evaluation Metrics: The evaluation metric of this invention is the accuracy of the generated graph database query statement compared to the standard answer after using different methods to filter subgraph patterns based on the same language model for the same query requirement. Higher accuracy means the generated statement is closer to the standard answer.

[0045] Comparison Method: The experiment used the commonly used language model DeepSeek as the comparison method to compare the performance of different methods. The test results are shown in Table 1. Table 1 Experimental Results Data Table Comparison Methods Market Risk Analysis Chart Corporate Relationship Diagram DeepSeek + Vanilla Prompt 53.85 62.86 DeepSeek+COT 61.54 68.57 DeepSeek+ Self-Refine 65.38 74.29 DeepSeek+ This invention 85.29 88.46 As shown in Table 1, when using the same language model, the method of this invention effectively improves the accuracy of generated query statements by combining graph structure analysis and execution feedback optimization. In the market risk analysis graph, based on using only the original prompt (Vanilla Prompt) as the benchmark, its execution accuracy is 53.85%. Using the thought chain (COT) and self-refinement methods both improve the accuracy of generated graph database query statements, reaching 61.54 and 65.38 respectively, representing increases of 14.28% and 21.41%. After using this invention, the execution accuracy reaches 85.29, an increase of 58.38%, significantly better than the methods using thought chain and self-refinement. The same trend is also reflected in the enterprise relationship graph, which will not be elaborated further.

[0046] While achieving the aforementioned performance improvements, the method of this invention also exhibits good robustness. For example, in some extreme scenarios, when the graph data description text or user natural language questions are ambiguous, this invention can still provide consistent performance improvements. This indicates that by structuring the graph data description and iteratively optimizing the execution feedback, the method of this invention can efficiently improve the potential association between natural language and query statements, thereby achieving effective transfer in multi-task scenarios. The test results in Table 1 comprehensively demonstrate the wide applicability and superior performance of the graph structure analysis and execution feedback optimization proposed in this invention in multi-task and multi-domain scenarios. Through joint pre-training and optimization design of data from different domains, the method of this invention significantly improves the transferability of the model, laying a solid foundation for realizing a general graph model, and also providing an important reference for future research on graph model infrastructure.

[0047] The system embodiments of the present invention can be applied to any device with data processing capabilities, such as a computer or other similar device. The system embodiments can be implemented in software, hardware, or a combination of both. Taking software implementation as an example, as a logical device, it is formed by the processor of any data processing device loading the corresponding computer program instructions from non-volatile memory into memory for execution.

[0048] The foregoing has shown and described the basic principles, main features, and advantages of the present invention. Those skilled in the art should understand that the above embodiments do not limit the present invention in any way, and all technical solutions obtained by equivalent substitution or equivalent transformation fall within the protection scope of the present invention.

Claims

1. A large-scale model query generation system combining graph structure analysis and execution, characterized in that, include: The graph schema standardization module is used to obtain the original schema description file of the graph database and convert it into a unified structured representation; The large language model module is used to receive the structured representation of the graph pattern standardization module and the user's natural language question, and to filter out the nodes, edges and subgraph patterns required by the query statement based on the user's natural language question and the structured representation. The graph pattern detection module is used to receive the node, edge and subgraph patterns filtered by the large language model module based on the user's natural language question and structured representation, and compare the filtered node, edge and subgraph patterns with the structured representation through a script to detect and modify the node, edge and subgraph patterns filtered by the large language model module. The large language model module generates an initial query statement based on the user's natural language question and the node, edge, and subgraph patterns detected and modified by the graph pattern detection module. The query statement detection module is used to receive the initial query statement generated by the large language model module, and to detect the initial query statement through a script and generate an error report. The large language model module generates a modified query statement based on the user's natural language question, the modified node, edge, and subgraph pattern detected by the graph pattern detection module, the initial query statement generated by the large language model module, and the error report generated by the query statement detection module.

2. The large model query generation system combining graph structure analysis and execution according to claim 1, characterized in that, The large-scale model query generation system that combines graph structure analysis and execution also includes: The query statement verification module is used to execute the modified query statement generated by the large language model module in the corresponding graph database, obtain the execution result, and output the query statement if the execution is successful, and return an error message if the execution fails.

3. The large model query generation system combining graph structure analysis and execution according to claim 2, characterized in that, The large-scale model query generation system that combines graph structure analysis and execution also includes: The iterative optimization module receives error information returned by the query statement verification module, coordinates the large language model module and the query statement detection module to optimize the current query statement based on the error information, and then passes the optimization result to the query statement verification module for verification until successful execution or a specified number of times is reached, and outputs the final query statement.

4. The large model query generation system combining graph structure analysis and execution according to claim 1, characterized in that, The original schema description file of the graph database contains node labels, edge types, attributes, indexes and constraints. The graph schema standardization module extracts node labels, edge types, attributes, indexes and constraints through a syntax parser and an information extractor, and transforms them into a unified structured representation containing nodes and attributes, edges and attributes, subgraph schemas and other key information.

5. The large model query generation system combining graph structure analysis and execution according to claim 1, characterized in that, The graph pattern detection module uses a character-by-character difference comparison algorithm to match the node, edge, and subgraph patterns output by the large language model module with the structured representation, and detects and modifies the node, edge, and subgraph patterns selected by the large language model module.

6. The large model query generation system combining graph structure analysis and execution according to claim 1, characterized in that, The query statement detection module extracts nodes, edges, and attributes from the initial query statement using regular expressions, compares them with the structured representation to determine if there are semantic errors, then uses regular expressions to determine if there are syntax errors in the initial query statement, and finally generates an error report.

7. The large model query generation system combining graph structure analysis and execution according to claim 1, characterized in that, The query statement is a Cypher query statement.

8. A method for generating large-scale model queries that combines graph structure analysis and execution, characterized in that, Includes the following steps: S1: Obtain the original schema description file of the graph database and convert it into a unified structured representation; S2: The large language model receives structured representations and user natural language questions, and filters out the nodes, edges, and subgraph patterns required by the query statement based on the user's natural language questions and structured representations. S3: Receive the node, edge, and subgraph patterns selected by the large language model based on the user's natural language question and structured representation, and compare the selected node, edge, and subgraph patterns with the structured representation through a script, and detect and modify the node, edge, and subgraph patterns selected by the large language model. S4: The large language model generates an initial query statement based on the user's natural language question and the detected modified node, edge, and subgraph patterns; S5: Receives the initial query statement generated by the large language model, and uses a script to detect the initial query statement and generate an error report; S6: The large language model generates a modified query statement based on the user's natural language question, the detected modified nodes, edges and subgraph patterns, the initial query statement generated by the large language model, and the generated error report.

9. The method for generating large model queries combining graph structure analysis and execution according to claim 8, characterized in that, The method for generating large-scale model queries that combines graph structure analysis and execution also includes: S7: Execute the modified query statement generated by the large language model in the corresponding graph database, obtain the execution result, output the query statement if the execution is successful, and return the error message if the execution fails.

10. The method for generating large model queries combining graph structure analysis and execution according to claim 9, characterized in that, The method for generating large-scale model queries that combines graph structure analysis and execution also includes: S8: Receive the returned error information, optimize the current query statement based on the error information, verify the optimization result, and continue until successful execution or the specified number of times is reached, and output the final query statement.

Images