Pith. sign in

REVIEW 4 major objections 5 minor 42 references

NAT-NL2GQL: A Novel Multi-Agent Framework for Translating Natural Language to Graph Query Language

T0 review · 4 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Splitting natural-language-to-graph-query translation into schema preprocessing, fine-tuned generation, and execution-error refinement yields new best results on two benchmarks: 85.44% exact-match on StockGQL and 59.99% on SpCQL.

desk verdict A plausible multi-agent NL2GQL framework with a new nGQL dataset, but the Refiner's gold-feedback ambiguity and missing error bars mean the SOTA claim needs verification. read the letter →

arxiv 2412.10434 v1 pith:BOUTU25R submitted 2024-12-11 cs.CL cs.AIcs.DB

Yuanyuan Liang , Tingyu Xie , Gan Peng , Zihao Huang , Yunshi Lan , Weining Qian This is my paper · ORCID
classification cs.CLcs.AIcs.DB
keywords NL2GQLgraphquerylanguagemulti-agentframeworkschemalinkingnGQLCypherdatabaseStock
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Translating a natural-language question into a graph query is hard because the system must first find the small piece of the database schema the question refers to; if that schema is wrong, every later step is likely wrong. The paper claims that a three-agent loop—a Preprocessor that extracts and cleans the related schema, a fine-tuned Generator that writes the query, and a Refiner that reacts to execution errors—breaks this error chain and beats existing NL2GQL methods. On the paper's new StockGQL benchmark the framework reaches 85.44% exact-match and 86.25% execution accuracy, and on the existing SpCQL benchmark it reaches 59.99% and 58.69%, both above the best prior baselines. The paper also contributes StockGQL, a multi-hop nGQL dataset built from a financial graph database.

What carries the argument

The load-bearing object is the related schema: the small subgraph of nodes, edges, and properties that a question actually needs. Its correctness is what lets a compact prompt reach a fine-tuned generator, and the paper's own measurements show the effect: with the golden related schema the generator hits 91.46% EM on StockGQL, with an erroneous related schema it falls to 20.34%, and with the full schema it sits in between at 82.67%. The Preprocessor produces this schema through LLM-based NER, locality-sensitive-hashing entity alignment, a linking-completion algorithm, and a ChatGPT-4o redundancy-filtering step; the Refiner's decision to return to the Preprocessor is specifically a mechanism for repairing a bad related schema.

What would settle it

A direct test is to rerun the framework on StockGQL with the related schema replaced by the oracle labels (golden schema) instead of the Preprocessor's predictions; the paper reports 91.46% versus 85.44% EM, so an independent replication finding a much smaller gap would indicate the claimed schema bottleneck is not the main driver. Conversely, injecting randomly corrupted schemas and observing little accuracy loss would contradict the paper's claim that related-schema accuracy controls end-to-end performance.

Watch

Extended reading notes

Core claim

The central claim is that NL2GQL should be treated as a collaborative, iterative multi-agent task rather than a single model pass. The Preprocessor agent performs named-entity recognition, entity alignment, path linking, and related-schema revision; the Generator agent is a LoRA-fine-tuned LLM that produces GQL from the rewritten question plus the related schema; and the Refiner agent reads the execution error and either rewrites the query or sends the failing information back to the Preprocessor to restart, up to three times. This arrangement yields new best results on both datasets, and the ablation shows each agent contributes; swapping the fine-tuned Generator for in-context ChatGPT-4o is the most damaging change, dropping EM from 85.44% to 50.04% on StockGQL.

Load-bearing premise

The framework's accuracy rests on the Preprocessor agent extracting the correct related schema using an unfine-tuned ChatGPT-4o; the paper's error analysis reports that schema errors cause 46% of all failures, so if that extraction step goes wrong the Generator and Refiner cannot reliably recover.

Editorial extensions

If this is right

  • NL2GQL systems should budget their effort on schema linking, since related-schema accuracy is the largest single lever on final query accuracy.
  • A fine-tuned generator plus execution-feedback refinement can beat strong in-context LLM prompting, so training on domain GQL pairs still pays off.
  • Iterative refinement with a hard iteration cap gives measurable gains without unbounded cost; removing the regeneration path alone costs 1.23 EM points.
  • The StockGQL dataset gives the community a public multi-hop nGQL benchmark with 63% of queries involving more than two hops.
  • The same three-agent structure transfers across GQL dialects, since it improves results on both nGQL (StockGQL) and Cypher (SpCQL).

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The three-agent split (context extraction, generation, execution-feedback repair) is a general recipe that likely transfers to other structured query tasks such as Text2SQL or SPARQL, but the paper does not test those settings.
  • Because schema errors account for 46% of failures, a fine-tuned or retrieval-based schema linker could plausibly raise end-to-end accuracy more than any improvement to the generator; this is a testable extension, not a paper claim.
  • The Refiner's 'Info Error' path effectively turns execution failure into a new training signal; one could measure its ceiling by giving the Refiner an oracle that always knows whether the schema is wrong.
  • The reported golden-schema ceiling of 91.46% EM suggests that even a perfect schema extractor would leave roughly 9% of errors, so future work will need question-comprehension improvements as well.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper introduces NAT-NL2GQL, a multi-agent framework for translating natural language questions into graph query language (GQL). It consists of a Preprocessor agent (NER, entity alignment, linking completion, related-schema revision, and question rewriting), a Generator agent (a LoRA fine-tuned LLM), and a Refiner agent that iteratively rewrites GQL or re-runs preprocessing based on execution results. The authors also construct StockGQL, a Chinese financial-domain nGQL dataset, and evaluate the framework on StockGQL and SpCQL using exact-match (EM) and execution (EX) accuracy. They report state-of-the-art results on both datasets and ablation studies indicating each component contributes to performance.

Significance. If the results are robust, the paper makes a useful contribution: a new open dataset for nGQL, a modular multi-agent architecture, and strong empirical gains on two datasets against several strong baselines including ICL and fine-tuned LLMs. The ablation study and the schema-impact analysis are informative. However, the current manuscript does not establish the headline claim with sufficient rigor: the Refiner's feedback signal at inference is not specified, the main table contains an uninterpretable row, and no uncertainty quantification is provided. These issues need to be resolved before the claimed state-of-the-art can be accepted.

major comments (4)
  1. [IV-C, Figure 3, Figure 7] The trigger for the Refiner agent's intervention is not specified at inference time. Figure 3 shows a 'Right?' decision after GQL execution, and the prompt in Figure 7 instructs the Refiner to fix queries whose 'returned output was empty or incorrect.' A deployed system has access only to execution errors or empty outputs; it cannot determine that a non-empty output is 'incorrect' without a gold answer. The manuscript never states whether the Table II evaluation uses gold-comparison feedback to decide whether to invoke the Refiner. If it does, the comparison with baselines is not a fair head-to-head; if it does not, the mechanism behind the 'Without Regeneration' ablation (Table VI) and the claimed detection of related-schema errors is unexplained. Please specify the exact feedback signal used in the main experiments and, if gold labels are used, also report results with execution-only feedback.
  2. [Table II] Table II contains a row labeled 'Others' approach' that reads 'SpCQL 1.4 1.8 2.3 2.6' with no method name, backbone, or citation; this row cannot be interpreted or reproduced. In addition, all results in the table appear to be single runs with no error bars or significance tests. Because LoRA fine-tuning and ChatGPT-4o prompting are stochastic, the reported improvements of 2.45 EM/2.12 EX on StockGQL and 4.93 EM/5.63 EX on SpCQL may be within run-to-run variance. Please correct or remove the malformed baseline row and report means and standard deviations over multiple runs for at least the main comparison.
  3. [V-A] The SpCQL experimental setup is underspecified in Section V-A. The paper does not state which train/dev/test split of SpCQL is used, the size of the fine-tuning set, the LoRA hyperparameters, or whether golden related schemas are used during SpCQL training. It also does not explain how the nGQL-oriented prompts and syntax conventions (e.g., '==' filters) are adapted to Cypher, beyond a brief mention of prompt adjustments. Without these details, the SpCQL results cannot be reproduced and the comparison across datasets is difficult to interpret.
  4. [V-C, Table IV] Error analysis (Figure 9) shows that 46% of failures on StockGQL are related-schema errors, and Table IV shows that an erroneous related schema reduces EM to 20.34%. Since the Preprocessor agent uses an unfine-tuned ChatGPT-4o for schema revision (Section IV-A), the overall accuracy of the framework is heavily dependent on an unvalidated, stochastic component. The paper should discuss this dependency explicitly and, ideally, report related-schema extraction accuracy on SpCQL as well, to show that the conclusion generalizes beyond StockGQL.
minor comments (5)
  1. [III, IV-A] Algorithm cross-references are inconsistent: the text refers to 'Algorithm 7' and 'algorithm shown in 15', but the paper contains Algorithms 1 and 2.
  2. [VI-A] In Section VI-A, the sentence 'the results on the two evaluation metrics, EX and EX, were not satisfactory' should read 'EM and EX'.
  3. [Table II] The caption of Table II says the red number in parentheses indicates improvement, but the table shows arrows with numbers and no parentheses; Table VI uses parentheses. Unify the notation.
  4. [Abstract, III] The abstract states that StockGQL 'will be released publicly', while Section III provides an active GitHub URL; make these statements consistent.
  5. [Figure 10] Figure 10 reports per-hop EM/EX without error bars or counts; given the small number of 'Others' test items (9 in Table I), the 66.67% value should be interpreted cautiously and the figure would benefit from showing counts.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity; the main SOTA claim is tested against an external benchmark and an independent baseline, with only a minor non-load-bearing self-citation.

full rationale

The paper's central claims are evaluated on a newly constructed StockGQL dataset and on the external SpCQL benchmark. Table II compares against R3-NL2GQL, which is independent of the authors, alongside Align-NL2GQL, the authors' own prior work used only as a baseline. The reported improvements are computed against the best of these baselines, not against a quantity fitted inside the framework. The Generator agent is fine-tuned on training data with golden related schemas and at inference uses predicted schemas, which is a standard train/inference separation rather than a fitted parameter renamed as a prediction. No equation in the paper reduces one quantity to another by construction, and no uniqueness theorem or ansatz is imported from a self-citation to force the design. Self-citations to [7] occur for dataset-construction techniques and schema-extraction motivation, but those are not the load-bearing derivation of the claimed performance; the external SpCQL results and the independent R3-NL2GQL baseline provide independent evidence. The Refiner loop's correctness trigger is underspecified: if the 'Right?' decision in Figure 3 were gated by gold answers, the evaluation could be unfair, but the paper never states that gold labels are used in the loop, so this is a correctness/validity concern rather than a demonstrated circular reduction. The error analysis showing that schema errors account for 46% of failures is a stated limitation, not a circular step.

Assumptions & free parameters 2 free parameters · 3 assumptions · 0 invented entities

The central claims rest on the reliability of the LLM-based Preprocessor, the representativeness of the self-constructed StockGQL dataset, and the correctness of the graph database execution environment. These are domain assumptions rather than derived facts.

free parameters (2)
  • LSH threshold gamma = 0.6
    Hand-chosen threshold for entity alignment in the Preprocessor agent; affects whether an entity is considered a match.
  • Maximum refinement iterations = 3
    Design choice that limits the Refiner agent's retry loop; affects the ability to correct errors.
assumptions (3)
  • domain assumption LLM-based NER and schema revision using ChatGPT-4o produce accurate related schemas
    The Preprocessor agent relies on an external, unfine-tuned LLM; the paper tests schema accuracy (86% on StockGQL) but does not guarantee generalization.
  • domain assumption StockGQL is a representative testbed for NL2GQL
    The dataset is synthetically constructed via self-instruct and masking, so its distribution may not match real-world queries.
  • domain assumption Execution environment correctly evaluates query correctness
    The EX metric depends on the graph database execution results; any mismatch in syntax or environment could affect scores.

how reviews work

0 comments
Cite this review

Pith. "Pith review of NAT-NL2GQL: A Novel Multi-Agent Framework for Translating Natural Language to Graph Query Language." pith.science (2026). https://pith.science/paper/BOUTU25R

@misc{pith2026241210434,
  author       = {Pith},
  title        = {Pith review of: NAT-NL2GQL: A Novel Multi-Agent Framework for Translating Natural Language to Graph Query Language},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/BOUTU25R}},
  note         = {Machine review of arXiv:2412.10434}
}
read the original abstract

The emergence of Large Language Models (LLMs) has revolutionized many fields, not only traditional natural language processing (NLP) tasks. Recently, research on applying LLMs to the database field has been booming, and as a typical non-relational database, the use of LLMs in graph database research has naturally gained significant attention. Recent efforts have increasingly focused on leveraging LLMs to translate natural language into graph query language (NL2GQL). Although some progress has been made, these methods have clear limitations, such as their reliance on streamlined processes that often overlook the potential of LLMs to autonomously plan and collaborate with other LLMs in tackling complex NL2GQL challenges. To address this gap, we propose NAT-NL2GQL, a novel multi-agent framework for translating natural language to graph query language. Specifically, our framework consists of three synergistic agents: the Preprocessor agent, the Generator agent, and the Refiner agent. The Preprocessor agent manages data processing as context, including tasks such as name entity recognition, query rewriting, path linking, and the extraction of query-related schemas. The Generator agent is a fine-tuned LLM trained on NL-GQL data, responsible for generating corresponding GQL statements based on queries and their related schemas. The Refiner agent is tasked with refining the GQL or context using error information obtained from the GQL execution results. Given the scarcity of high-quality open-source NL2GQL datasets based on nGQL syntax, we developed StockGQL, a dataset constructed from a financial market graph database. It is available at: https://github.com/leonyuancode/StockGQL. Experimental results on the StockGQL and SpCQL datasets reveal that our method significantly outperforms baseline approaches, highlighting its potential for advancing NL2GQL research.

Figures

Figures reproduced from arXiv: 2412.10434 by the authors.

Figure 3
Figure 3. The framework comprises three synergistic agents: [PITH_FULL_IMAGE:figures/full_fig_p002_3.png] view at source ↗
Figure 2
Figure 2. Our StockGQL dataset construction flowchart highlights the areas of improvement in our method, marked in red. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Our NAT-NL2GQL framework consists of three synergistic agents: the Preprocessor agent, the Generator agent, and [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (7 more)
Figure 4
Figure 4. Figure 4: Prompt for performing Name Entity Recognition on [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Prompt for revising the related schema. MiniLM-L12-v1. ˆd represents the entity names extracted based on the cosine similarity to X . Once the entity alignment is completed, we will obtain the entity names along with their corresponding entity types. Linking Completion…
Figure 8
Figure 8. Figure 8: In the fine-tuning approaches, the complete schema [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]
Figure 6
Figure 6. Figure 6: A Refiner example: From the example, we can see [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]
Figure 8
Figure 8. Figure 8: Prompt for In-Context Learning. 0-hop 14% 1-hop 24% 2-hop 38% 3-hop 16% 4-hop 6% others 2% Error Statistics by Hop Count Realted Schema Error 46% Misunderstanding 29% Calculation Error 17% others 8% Error Statistics by Type [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]
Figure 9
Figure 9. Figure 9: Error analysis statistics chart. On the left is the error [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]
Figure 10
Figure 10. Figure 10: The accuracy of the EM and EX metrics of our method [PITH_FULL_IMAGE:figures/full_fig_p010_10.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

42 extracted references · 16 canonical work pages

  1. [1]

    Graph data augmentation for graph machine learning: A survey,

    T. Zhao, W. Jin, Y . Liu, Y . Wang, G. Liu, S. Günnemann, N. Shah, and M. Jiang, “Graph data augmentation for graph machine learning: A survey,” arXiv preprint arXiv:2202.08871 , 2022

    arXiv 2022

  2. [2]

    Unleashing the power of graph data augmentation on covariate dis- tribution shift,

    Y . Sui, Q. Wu, J. Wu, Q. Cui, L. Li, J. Zhou, X. Wang, and X. He, “Unleashing the power of graph data augmentation on covariate dis- tribution shift,” Advances in Neural Information Processing Systems , vol. 36, 2024

    work page 2024

  3. [3]

    Graph databases: An alternative to relational databases in an interconnected big data environment,

    R. Pavliš, “Graph databases: An alternative to relational databases in an interconnected big data environment,” in 2024 47th MIPRO ICT and Electronics Convention (MIPRO). IEEE, 2024, pp. 247–252

    work page 2024

  4. [4]

    Scalability and performance evaluation of graph database systems: A comparative study of neo4j, janusgraph, memgraph, nebu- lagraph, and tigergraph,

    A. Lopes, D. Rodrigues, J. Saraiva, M. Abbasi, P. Martins, and C. Wanzeller, “Scalability and performance evaluation of graph database systems: A comparative study of neo4j, janusgraph, memgraph, nebu- lagraph, and tigergraph,” in 2023 Second International Conference On Smart Technologies For Smart Nation (SmartTechCon) . IEEE, 2023, pp. 537–542

    work page 2023

  5. [5]

    An empirical study on recent graph database systems,

    R. Wang, Z. Yang, W. Zhang, and X. Lin, “An empirical study on recent graph database systems,” in Knowledge Science, Engineering and Management: 13th International Conference, KSEM 2020, Hangzhou, China, August 28–30, 2020, Proceedings, Part I 13 . Springer, 2020, pp. 328–340

    work page 2020

  6. [6]

    Spcql: A semantic parsing dataset for converting natural language into cypher,

    A. Guo, X. Li, G. Xiao, Z. Tan, and X. Zhao, “Spcql: A semantic parsing dataset for converting natural language into cypher,” in Proceedings of the 31st ACM International Conference on Information & Knowledge Management , ser. CIKM ’22. New York, NY , USA: Association for Computing Machinery, 2022, p. 3973–3977. [Online]. Available: https://doi.org/10.114...

    arXiv 2022

  7. [7]

    Aligning large language models to a domain-specific graph database for nl2gql,

    Y . Liang, K. Tan, T. Xie, W. Tao, S. Wang, Y . Lan, and W. Qian, “Aligning large language models to a domain-specific graph database for nl2gql,” in Proceedings of the 33rd ACM International Conference on Information and Knowledge Management , 2024, pp. 1367–1377

    work page 2024

  8. [8]

    r3-NL2GQL: A model coordination and knowledge graph alignment approach for NL2GQL,

    Y . Zhou, Y . He, S. Tian, Y . Ni, Z. Yin, X. Liu, C. Ji, S. Liu, X. Qiu, G. Ye, and H. Chai, “r3-NL2GQL: A model coordination and knowledge graph alignment approach for NL2GQL,” in Findings of the Association for Computational Linguistics: EMNLP 2024, Y . Al-Onaizan, M. Bansal, and Y .-N. Chen, Eds. Miami, Florida, USA: Association for Computational Ling...

    work page 2024

Show all 42 references
  1. [9]

    Cyspider: A neural semantic parsing corpus with baseline models for property graphs,

    Z. Zhao, W. Liu, T. French, and M. Stewart, “Cyspider: A neural semantic parsing corpus with baseline models for property graphs,” in Australasian Joint Conference on Artificial Intelligence. Springer, 2023, pp. 120–132

    2023

  2. [10]

    Robust text-to-cypher using combination of bert, graphsage, and transformer (cobgt) model,

    Q.-B.-H. Tran, A. A. Waheed, and S.-T. Chung, “Robust text-to-cypher using combination of bert, graphsage, and transformer (cobgt) model,” Applied Sciences, vol. 14, no. 17, p. 7881, 2024

    2024

  3. [11]

    Inductive representation learning on large graphs,

    W. Hamilton, Z. Ying, and J. Leskovec, “Inductive representation learning on large graphs,” Advances in neural information processing systems, vol. 30, 2017

    2017

  4. [12]

    Kei-cql: A keyword extraction and infilling framework for text to cypher query language translation

    Y .-L. Liang, C.-Y . Chang, and S.-J. Wu, “Kei-cql: A keyword extraction and infilling framework for text to cypher query language translation.” International Journal of Design, Analysis & Tools for Integrated Circuits & Systems, vol. 13, no. 1, 2024

    2024

  5. [13]

    Autotqa: Towards autonomous tabular question answering through multi-agent large language models,

    J.-P. Zhu, P. Cai, K. Xu, L. Li, Y . Sun, S. Zhou, H. Su, L. Tang, and Q. Liu, “Autotqa: Towards autonomous tabular question answering through multi-agent large language models,” Proceedings of the VLDB Endowment, vol. 17, no. 12, pp. 3920–3933, 2024

    2024

  6. [14]

    Purple: Making a large language model a better sql writer,

    T. Ren, Y . Fan, Z. He, R. Huang, J. Dai, C. Huang, Y . Jing, K. Zhang, Y . Yang, and X. S. Wang, “Purple: Making a large language model a better sql writer,” arXiv preprint arXiv:2403.20014 , 2024

    2024 arXiv

  7. [15]

    Online index recommendation for slow queries,

    G. Peng, P. Cai, K. Ye, K. Li, J. Cai, Y . Shen, H. Su, and W. Xu, “Online index recommendation for slow queries,” in 2024 IEEE 40th International Conference on Data Engineering (ICDE) . IEEE, 2024, pp. 5294–5306

    2024

  8. [16]

    D-bot: Database diagnosis system using large language models,

    X. Zhou, G. Li, Z. Sun, Z. Liu, W. Chen, J. Wu, J. Liu, R. Feng, and G. Zeng, “D-bot: Database diagnosis system using large language models,” arXiv preprint arXiv:2312.01454 , 2023

    2023 arXiv

  9. [17]

    Gptuner: A manual-reading database tuning system via gpt-guided bayesian optimization,

    J. Lao, Y . Wang, Y . Li, J. Wang, Y . Zhang, Z. Cheng, W. Chen, M. Tang, and J. Wang, “Gptuner: A manual-reading database tuning system via gpt-guided bayesian optimization,” arXiv preprint arXiv:2311.03157 , 2023

    2023 arXiv

  10. [18]

    Finqa: A training-free dynamic knowledge graph question answering system in finance with llm-based revision,

    W. Tao, H. Zhu, K. Tan, J. Wang, Y . Liang, H. Jiang, P. Yuan, and Y . Lan, “Finqa: A training-free dynamic knowledge graph question answering system in finance with llm-based revision,” in Joint European Confer- ence on Machine Learning and Knowledge Discovery in Databases . ...

    2024

  11. [19]

    Self-instruct: Aligning language models with self- generated instructions,

    Y . Wang, Y . Kordi, S. Mishra, A. Liu, N. A. Smith, D. Khashabi, and H. Hajishirzi, “Self-instruct: Aligning language models with self- generated instructions,” arXiv preprint arXiv:2212.10560 , 2022

    2022 arXiv

  12. [20]

    Empirical study of zero-shot ner with chatgpt,

    T. Xie, Q. Li, J. Zhang, Y . Zhang, Z. Liu, and H. Wang, “Empirical study of zero-shot ner with chatgpt,” arXiv preprint arXiv:2310.10035 , 2023

    2023 arXiv

  13. [21]

    Chinese ner using multi-view transformer,

    Y . Xiao, Z. Ji, J. Li, and M. Han, “Chinese ner using multi-view transformer,” IEEE/ACM Transactions on Audio, Speech, and Language Processing, 2024

    2024

  14. [22]

    Large language models for generative information extraction: A survey,

    D. Xu, W. Chen, W. Peng, C. Zhang, T. Xu, X. Zhao, X. Wu, Y . Zheng, Y . Wang, and E. Chen, “Large language models for generative information extraction: A survey,” arXiv preprint arXiv:2312.17617 , 2023

    2023 arXiv

  15. [23]

    Locality-sensitive hashing scheme based on p-stable distributions,

    M. Datar, N. Immorlica, P. Indyk, and V . S. Mirrokni, “Locality-sensitive hashing scheme based on p-stable distributions,” in Proceedings of the twentieth annual symposium on Computational geometry, 2004, pp. 253– 262

    2004

  16. [24]

    Parameter-efficient fine-tuning of large- scale pre-trained language models,

    N. Ding, Y . Qin, G. Yang, F. Wei, Z. Yang, Y . Su, S. Hu, Y . Chen, C.-M. Chan, W. Chen et al. , “Parameter-efficient fine-tuning of large- scale pre-trained language models,” Nature Machine Intelligence, vol. 5, no. 3, pp. 220–235, 2023

    2023

  17. [25]

    On the effectiveness of parameter-efficient fine-tuning,

    Z. Fu, H. Yang, A. M.-C. So, W. Lam, L. Bing, and N. Collier, “On the effectiveness of parameter-efficient fine-tuning,” in Proceedings of the AAAI conference on artificial intelligence , vol. 37, no. 11, 2023, pp. 12 799–12 807

    2023

  18. [26]

    Qlora: Efficient finetuning of quantized llms,

    T. Dettmers, A. Pagnoni, A. Holtzman, and L. Zettlemoyer, “Qlora: Efficient finetuning of quantized llms,” Advances in Neural Information Processing Systems, vol. 36, 2024

    2024

  19. [27]

    Few-shot parameter-efficient fine-tuning is better and cheaper than in-context learning,

    H. Liu, D. Tam, M. Muqeeth, J. Mohta, T. Huang, M. Bansal, and C. A. Raffel, “Few-shot parameter-efficient fine-tuning is better and cheaper than in-context learning,” Advances in Neural Information Processing Systems, vol. 35, pp. 1950–1965, 2022

    1950

  20. [28]

    Lora: Low-rank adaptation of large language models,

    E. J. Hu, Y . Shen, P. Wallis, Z. Allen-Zhu, Y . Li, S. Wang, L. Wang, and W. Chen, “Lora: Low-rank adaptation of large language models,” arXiv preprint arXiv:2106.09685 , 2021

    2021 arXiv

  21. [30]

    Mac-sql: Multi-agent collaboration for text-to-sql,

    B. Wang, C. Ren, J. Yang, X. Liang, J. Bai, Q.-W. Zhang, Z. Yan, and Z. Li, “Mac-sql: Multi-agent collaboration for text-to-sql,” arXiv preprint arXiv:2312.11242, 2023

    2023 arXiv

  22. [31]

    Chess: Contextual harnessing for efficient sql synthesis,

    S. Talaei, M. Pourreza, Y .-C. Chang, A. Mirhoseini, and A. Saberi, “Chess: Contextual harnessing for efficient sql synthesis,” arXiv preprint arXiv:2405.16755, 2024

    2024 arXiv

  23. [32]

    Natural language query for technical knowledge graph navigation,

    Z. Zhao, M. Stewart, W. Liu, T. French, and M. Hodkiewicz, “Natural language query for technical knowledge graph navigation,” in Aus- tralasian Conference on Data Mining . Springer, 2022, pp. 176–191

    2022

  24. [33]

    Language to logical form with neural atten- tion,

    L. Dong and M. Lapata, “Language to logical form with neural atten- tion,” arXiv preprint arXiv:1601.01280 , 2016

    2016 arXiv

  25. [34]

    Incorporating copying mechanism in sequence-to-sequence learning,

    J. Gu, Z. Lu, H. Li, and V . O. Li, “Incorporating copying mechanism in sequence-to-sequence learning,” arXiv preprint arXiv:1603.06393, 2016

    2016 arXiv

  26. [35]

    Bert: Pre-training of deep bidirectional transformers for language understanding,

    J. D. M.-W. C. Kenton and L. K. Toutanova, “Bert: Pre-training of deep bidirectional transformers for language understanding,” in Proceedings of naacL-HLT, vol. 1. Minneapolis, Minnesota, 2019, p. 2

    2019

  27. [36]

    Exploring the limits of transfer learning with a unified text-to-text transformer,

    C. Raffel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y . Zhou, W. Li, and P. J. Liu, “Exploring the limits of transfer learning with a unified text-to-text transformer,” Journal of machine learning research, vol. 21, no. 140, pp. 1–67, 2020

    2020

  28. [37]

    Language models are unsupervised multitask learners,

    A. Radford, J. Wu, R. Child, D. Luan, D. Amodei, I. Sutskever et al., “Language models are unsupervised multitask learners,” OpenAI blog , vol. 1, no. 8, p. 9, 2019

    2019

  29. [38]

    Chase-sql: Multi-path reasoning and preference optimized candidate selection in text-to-sql,

    M. Pourreza, H. Li, R. Sun, Y . Chung, S. Talaei, G. T. Kakkar, Y . Gan, A. Saberi, F. Ozcan, and S. O. Arik, “Chase-sql: Multi-path reasoning and preference optimized candidate selection in text-to-sql,”

  30. [39]

    The death of schema linking? text-to-sql in the age of well-reasoned language models,

    K. Maamari, F. Abubaker, D. Jaroslawicz, and A. Mhedhbi, “The death of schema linking? text-to-sql in the age of well-reasoned language models,” 2024. [Online]. Available: https://arxiv.org/abs/2408.07702

    2024 arXiv

  31. [40]

    Can llm already serve as a database interface? a big bench for large-scale database grounded text-to-sqls,

    J. Li, B. Hui, G. Qu, J. Yang, B. Li, B. Li, B. Wang, B. Qin, R. Geng, N. Huo et al., “Can llm already serve as a database interface? a big bench for large-scale database grounded text-to-sqls,” Advances in Neural Information Processing Systems , vol. 36, 2024

    2024

  32. [41]

    E-sql: Direct schema linking via question enrichment in text-to-sql,

    H. A. Cafero ˘glu and Ö. Ulusoy, “E-sql: Direct schema linking via question enrichment in text-to-sql,” arXiv preprint arXiv:2409.16751 , 2024

    2024 arXiv

  33. [42]

    A survey on complex knowledge base question answering: Methods, challenges and solutions,

    Y . Lan, G. He, J. Jiang, J. Jiang, W. X. Zhao, and J.-R. Wen, “A survey on complex knowledge base question answering: Methods, challenges and solutions,” arXiv preprint arXiv:2105.11644 , 2021

    2021 arXiv

  34. [2024]

    Available: https://arxiv.org/abs/2410.01943

    [Online]. Available: https://arxiv.org/abs/2410.01943

    arXiv

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.