Cypher-RI: Reinforcement Learning for Integrating Schema Selection into Cypher Generation
Authors: Hanchen Su
Xuyuan Li
Yan Zhou
zhuoyi lu
Ziwei Chai
Haozheng Wang
Chen Zhang
Yang Yang
Venue: NeurIPS 2025 poster ()
Keywords: Text-to-Cypher
Reinforcement learning
Graph Databases
Large Language Models
Primary area: applications

Abstract: The increasing utilization of graph databases across various fields stems from their capacity to represent intricate interconnections. Nonetheless, exploiting the full capabilities of graph databases continues to be a significant hurdle, largely because of the inherent difficulty in translating natural language into Cypher. Recognizing the critical role of schema selection in database query generation and drawing inspiration from recent progress in reasoning-augmented approaches trained through reinforcement learning to enhance inference capabilities and generalization, we introduce Cypher-RI, a specialized framework for the Text-to-Cypher task. Distinct from conventional approaches, our methodology seamlessly integrates schema selection within the Cypher generation pipeline, conceptualizing it as a critical element in the reasoning process. The schema selection mechanism is guided by textual context, with its outcomes recursively shaping subsequent inference processes. Impressively, our 7B-parameter model, trained through this RL paradigm, demonstrates superior performance compared to baselines, exhibiting a 9.41\% accuracy improvement over GPT-4o on CypherBench. These results underscore the effectiveness of our proposed reinforcement learning framework, which integrates schema selection to enhance both the accuracy and reasoning capabilities in Text-to-Cypher tasks.

Cypher-RI: Reinforcement Learning for Integrating Schema Selection into Cypher Generation
Hanchen Su Zhejiang University hcsu@zju. edu.
Xuyuan Li Zhejiang University 32201029708zju. edu. cn
Yan Zhou Createlink Technology zhouyan@chuang] wwwpanggiittcchhccm com
Zhuoyi Lu Zhejiang University 224512178zju.edi edu. cn
Ziwei Chai Zhejiang University zwchai@zju. edu. en
Haozheng Wang Independent Researcher haozheng. wanggensea. fr
Chen Zhang Createlink Technology
Yang Yang Zhejiang University yangyaızju ju. edu. cn
zhangchen@chuangl1 intteaahnnniniiin..oiac com
Abstract
The increasing utilization of graph databases across various fields stems from their capacity to represent intricate interconnections. Nonetheless, exploiting the full capabilities of graph databases continues to be significant hurdle, largely because the inherent difficulty in translating natural language into Cypher. Recognizing the critical role of schema selection in database query generation and drawing in- spiration from recent progress in aasoning-augmented approaches trained through reinforcement learning enhance inference capabilities and generalization, introduce Cypher-RI, (ipherr-R,, specialized framework for the Texl-to-Cypher task. Distinct from conventional approaches, our methodology seamlessly integrates schema selection within the Cypher generation pipeline, conceptualizing it as a critical element in the reasoning process. The schema selection mechanism is guided by textual context, with its outcomes recursively shaping subsequent inference pro- cesses. Impressively, our 7B-parameter model, trained through this RL paradigm, demonstrates superior performance compared to baselines, cxhibiting a 9.41 % accuracy improvement over GPT-44o on CypherBench. These results underscore the effectiveness of our proposed reinforcement learning framework, which inte- grates schema selection to enhance both the accuracy and reasoning capabilities Text-to-Cypher tasks.
Introduction
Graph databases 28 37 are commonly utilized to efficiently handle graph data, providing a powerful solution for representing and storing intricate, highly connected information. However, effectively utilizing them remains a formidable challenge, primarily due to the nuanced and complex syntax of graph query iogguage-Cypher [9] [T0] 26). which poses obstacles for general users seeking to use graph databases, particularly those unfamiliar with programming paradigms. Therefore, The development of system for converting natural language into Cypher [1]] has gained significant importance.
"Coneesponiig authors.
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

The automatic conversion of natural language questions into Cypher queries remains a persistent challenge in graph database retrieval [7]44] The emergence of large language models (LLMs) [2 38
40] has led to substantial progress. R - [4] combines small and large language models for various tasks including ranking, rewriting, and refinement. This methodology exploits the capabilities of finetuned small models for initial stages while harnessing the advanced generalization and query formulation abilities of big LLMs for the final transformation into Cypher. An alternative strategy paired
proposed by Liang et al. (22] employs ChatGPT (2] to generate natural language- datasets through self-instruction, based on given graph databases. These datasets are subsequently used to fine-tune LLMs, facilitating alignment between LLMs and the graph databases. Nevertheless, this approach necessitates dataset construction and model retraining for each new graph database, incurring significant time and financial costs. Ozsoy et al. [30 curated and structured several publicly available datasets, facilitating effective fine-tuning. The models fine-tuned on this dataset demonstrated significant performance improvements.
Existing approaches predominantly depend on supervised fine-tuning 23 and few-shot prompting 11 to guide models in Cypher query generation. Nevertheless, when faced with intricate database schemas or ambiguous linguistic contexts that necessitate advanced reasoning, such models often fail to produce Cypher queries accurately reflecting users' intentions, due to their reliance on static generation patterns and previously observed data. Consequently, current systems exhibit limited robustness [5] in adapting new domains and generalizing across diverse database environments. Moreover, the opaque reasoning mechanisms underlying Cypher generation restrict the applicability of these models in critical sectors like law and finance, where transparency and accountability are paramount.
33 has emerged as promising paradigm for en- hancing the reasoning capabilities of LLMs. Unlike traditional fine-tuning, RL enables adaptive modification of decision policies through continuous interaction with dynamic environments, re- sulting in improved performance on complex inference tasks. Empirical studies have validated the efficacy of RL-based frameworks in strengthening reasoning proficiency and generalization in areas such as information retrieval 4 20). mathematical problem solving [17 (3] and SQL genera- tion (27 B1]. Furthermore, innovations in expansive reasoning models, exemplified by OpenAl ol 19 and DeepSeck-R R1 [12] demonstrate that allocating additional computational resources during inference construct deliberate reasoning paths substantially elevates output quality.
Recently, reinforcement learning (RL) 16
32
Providing an LLM with concise structural metadata about a graph database helps it convert natural- language questions into precise query statements. Feeding complete schema dumps to the model, however, often injects irrelevant detail, provokes spurious outputs, and increases computational expenses. Schema selection 3 24,, which focuses on identifying and providing only the schema components pertinent to a given query context, serves as a key mechanism for enhancing the precision and overall performance of natural-language to database query generation models. By steering the model's 's attention toward relevant schema elements, it alleviates cognitive burden and significantly narrows the exploration space for LLMs. Motivated by advancements in training reasoning models through RI. and recognizing the advantages of schema selection, we introduce Cypher-RI, reinforcement learning- based framework that integrates schema selection into Cypher generation. This method promotes the articulation of explicit intermediate reasoning trajectories, thereby substantially improving the reasoning quality and final query accuracy of LLMs.
Unlike common reasoning process solely involves <think> and <answer>, our framework incorpo- rates additional components: specifically, the identification of needed entities and relations (annotated within <json> tags) alongside the results of schema selection (enclosed within <schema> tags). We conceptualize schema selection dynamic interactions between schema selection and textual deliberation. Notably, no manually anno- tated reasoning traces are provided to guide the language models. Instead, employ reinforcement learning techniques to motivate LLMS to autonomously develop reasoning chains that integrate schema selection behavior.
integral element of the overall reasoning trajectory, enabling
We train Cypher-RI from scratch using Owwn2.5-Coder-777 and perform comprehensive evaluations on multiple Text-to-Cypher benchmarks. Notably, we validate the generalization capability of our framework by evaluating the trained models on graph databases distinct from those used during training. On CypherBench [8). our models achieve substantial absolute improvements ranging from

---

Simplitted Graph
Memally de
Sulemaal exeglex prip adeeo cecrepuainng
The thas Clib that ttd ritesee to the
"raber:/wwwee (labet:
Cley
("abeft "aaaa"),
Studiun can your hefore io 2019 and
(Pabee: Sabbe:--alliies "uulizaaieene"" habi CaE"" nel lnatt
Ervadd
"purlllingge" habi taa laalt "Eaagee) )..]
"Lac" "Char
sotte
racteraa (Tamee "ucccrt
and year, at oight sfll meil" curvet weea....
"ibd "Vonce"
"haad coudt Taat
Select
Queetion
ISON
"roepron year tamae
Whach dath treurum Hemoee
"lacc Verut
chera
(aauf: "aeae" "rrpperact Phanee hor113 "elatowr" "aateee/eaaar" "aat badr, "char rol, andf:
Retieeve schema
sequences
Hanger Stadure AND
WHERE camro "Tetmilnn
"ay Mill "Voue"
"Mose" Yergented"
Generaie Cypher
Loed you to 2009)
NILL OR
tee 1131
RETURN clivarne
An overview of the Cypher-RI training process. During the rollout phase, the LLM integrates schema selection into Cypher generation. The two LLMSs shown in the figure correspond to the same model. Only the text highlighted with a yellow background participates in backpropagation.
Figure 1:
13.12% to 69.59% over the base model, and outperform the strong GPT-4o baseline by up to 9.41%. Our principal contributions are as follows:
This study offers new insights into leveraging reinforcement learning to enhance the Cypher generation capabilities of LLMs,, marking the first RL-driven framework designed autonomously optimize the reasoning process for the Text-to-Cypher task.
We introduce Cypher-RI, novel approach that integrates schema selection directly into the Cypher generation during training. Cypher-RI enables LLMs to learn reasoning strategies from scratch without relying on any supervised annotations for intermediate reasoning steps.
Extensive empirical evaluations validate the effectiveness of method consistently achieving substantial improvements over baseline approaches, and even outperforming the strong GPT-4o model while being much more cost effective.
2 Method
Schema selection is fundamental to the accuracy and effectiveness of Text-to-Cypher systems. Providing the entire schema as input to an LLM can cause information overload, hindering the model's ability to distinguish relevant information from irrelevant details. Schema selection mitigates this issue by directing the model's focus toward pertinent schema components. By filtering out irrelevant data, schema selection enables more accurate mapping of natural language queries to corresponding nodes and edges within the graph schema, thereby improving the accuracy of the generated Cypher queries. For questions requiring traversal across multiple nodes involving complex aggregations, correctly selecting the relevant nodes and edges is crucial. Schema selection identifies the necessary components for constructing appropriate queries, effectively reducing the search space for LLMs. In essence, schema selection serves as the semantic grounding step, interpreting the user's intent within the specific context of the target database.
Considering the benefits of schema selection and drawing inspiration from the success of the o-series models developed by OpenAl and DeepScek-RI in learning reason, integrate schema selection into the reasoning process, as illustrated Figure We train LLMs from scratch using reinforcement learning without any labeled data on reasoning chains, enabling LLMs to learn schema selection and Cypher generation in a unified manner.
The training methodology for Cypher-RI RI is presented first with an in-depth exploration of GRPO and the implementation of rollout strategies that incorporate schema selection during reinforcement learning. Subsequently, we describe the design of a training template that steers LLMs to produce rollouts predefined format. Lastly, we outline the reward design, which plays pivotal role in guiding the optimization process within the reinforcement learning framework.
3

---

2.1 Reinforcement Learning
When generating database query language, accurate schema selection plays a pivotal role in enhanc- ing precision. However, obtaining labeled reasoning data that incorporates schema selection for supervised fine-tuning of LLMs remains sigmificant challenge, especially when aiming to replicate reasoning patterns with schema selection. A promising solution lies in reinforcement learning, which has demonstrated remarkable efficacy in training L.LMs to perform reasoning tasks, even in the absence of labeled data. The core idea of reinforcement learning in our method is to sample diverse reasoning processes through schema selection and Cypher generation chains, and to optimize the LLMs to maximize the likelihood of producing rollouts that achieve higher rewards.
Unlike traditional reasoning models, which typically involve only the <think> and <answer> phases, the Cypher-RI RI rollout incorporates an additional schema selection step. In this process, the question and a simplified version of the graph schema containing only the names of entities and relations are provided as imput to the LLM. The model first identifies the schema relevant to the question and generates formattrd string to retrieve the complete version of the selected schema, which includes the properties of entities and relations. These instructions are detailed in the training templates, which will be explained in subsequent sections. The rollout procedure follows a sequence of reasoning steps: thinking, selecting the schema, retrieving the complete schema, further reasoning. and generating the answer, as depicted in Figure More specifically, the rollout process terminates upon encountering the </json> tag. If the string between the <json> and </jsoni tags can be successfully parsed and the parsed labels exist in the schema, the label will be used as a key to retrieve the corresponding complete schema. If the string fails to conform to the JSON format or the label is not found in the schema, the complete schema encompassing all entities and relations will be returned. This complete schema is enclosed within <schema> and </schema> tags and appended to the rollout sequence. The updated rollout, now containing the complete selected schema, is then used as input for the next generation step until the end-of-sentence tag is reached.
To enhance the stability of function approximation, Deepseck propose Group Relative Policy Optimization(GRPO) Proximal Policy Optimization (PPO). GRPO utilizes the mean reward derived from a set of sampled outputs as a baseline, instead of depending on a learned value function. Specifically, given an input query J. GRPO samples batch of responses {y,, ./;-...,30 from the policy model ma. The policy model is subsequently optimized by maximizing the following objective function:
optimization and eliminate the necessity for auxiliary value
Unlike
((0)= = E ED 1i ao (1z)
())
min
[o(uilz) (3)l1))
A., clip
neww (Milar) (a)) 1 1+ A.) -Dax (soll (vollmom)) Miss
[u (4r]
Mis
A T; mcan (mnca((ryh)) (
(3)
(r
where Tref is the reference model, Told is the old policy model, e and 3 are hyperparameters, while A, represents the advantage, calculated from the relative rewards r; of outputs within each group. This method eliminates the need for additional complexity when computing A, Rather than introducing the Haillback-Leibler (KL) divergence as a penalty the reward function, GRPO regularizes the model by directly incorporating the KL divergence between the learned policy and the reference policy into the loss function.
Additionally, we multiply Ma, by each token when computing the GRPO loss. The value of M,,e is either 1. During the reinforcement learning process of LLMs, token-level losses are calculated across the entire rollout sequence. In RI, this sequence comprises both tokens generated by the LLM and tokens representing the full schema retrieved from an external dictionary. While optimizing the LLM--generate tokens enhances the model's 's ability to perform reasoning, selection, and generation, applying the same optimization to the retrieved tokens could inadvertently introduce undesired learning behaviors. To mitigate this issue, we propose the use of loss masking for the retrieved tokens, ensuring that the policy gradient objective computed solely based on the LLM- generated tokens and excluding the retrieved tokens from the optimization. This method contributes to the stabilization of the training process while consolidating schema selection and Cypher generation into a cohesive framework.

---

Table 1: Training template for Cypher-RI. During training and inference, the placcholders question and schema will be replaced with specific instances.
A conversation between a User and an Assistant. The user asks the Assistant to translate the question Cypher query based simplified version of the schema of graph database. The Assistant first identifies the necessary schema components required to answer the User's s question within <think> </think> tags. Next, the Assistant outputs the needed schema JSON format within <json> </joon> tags. If the selected schema is valid, the Assistant is provided with the complete version of the selected schema enclosed within <schema> tags, or it is provided with the complete version of the full schema. After that, the Assistant explains the reasoning process for generating the Cypher query within <think> </think> tags. Finally, the Assistant provides the Cypher query enclosed within <answer> </answer> tags. For example, <think> This the reasoning process. </think> <json> ("name": "" "entities": [. "relations": []} </json> <schema> This is the complete version of the schema. </schema> <think> This is the reasoning process. </think> <answer> This is the Cypher query </answer>. Graph schema: (schema) User: (question) Assistant:
2.2 Training Template
The training of Cypher-RI begins with the creation of straightforward template designed to guide the initial LLM in adhering to predefined instructions. As illustrated in Table [ this framework organizes the output into five iterative components: initial reasoning phase identifying the needed schema, followed by a JSON-formatted string representing the selected schema, the complete version of schema, subsequent reasoning phase focused Cypher query generation, and ultimately, the final response. By guiding LLMs to comprehend the rollout format, we incorporate schema selection into the training process, enabling the model to jointly learn schema selection and Cypher generation in unified framework.
2.3 Reward design
In the reinforcement learning process of Cypher-RI, supervised reasoning data is utilized, and optimization of LLMs guided solely through simplified reward mechanism applied to rollouts. Empirically, rule-based reward function is sufficient to effectively elicit the reasoning capabilities that integrate schema selection and Cypher generation within LLMs. The reward function is composed of three key parts: format reward, schema selection reward, and Cypher execution reward.
To compute the format reward, we first specify the correct format as follows:
The model's reasoning process and final answer should be enclosed within the <think?..<<thinnke and Sanswer>...<anawer>> tags.
The <json><< </json> and <answer> </anser>> tags must appear once, while the <think </think> tags must appear twice.
The order of the tags must conform to <think </think> <json> </json> <think>
</think> <answer> </ /aanswer>.
According to the aforementioned format requirements, the format reward is defined as follows:
11.0,
if the format is correct the format incorrect
Tormat 11000
(4)
For the schema selection reward, we first parse the string generated within the <json> tags and then compare the parsed selected schema against the gold answer.
2.0,
if the selected schema matches the gold answer
Pselection
1.5,
if the selected schema does not match the gold answer
(5)
2.0,
if the selected schema unparseable
5

---

For the Cypher execution reward, we extract the generated Cypher query enclosed within the <answer> tags, then execute both the extracted Cypher and the gold answer on the graph database.
2.0,
if the generated Cypher executes consistently with the gold answer 1.5, if the generated Cypher executes inconsistently with the gold answer (6)
lexzccution
2.0,
if the generated Cypher fails execute
The final reward is the sum the format reward, schema selection reward, and Cypher execution reward.
format + reselcctoon + Tesecution
3 Experiment
3.1 Training Data
GRPO algorithm encounters issue related to vanishing gradients when certain prompts achieve perfect accuracy. If all generated outputs for a given question are correct and receive a reward of the computed advantage for that group becomes zero. A zero advantage provides no meaningful gradient signal for policy updates, which severely limits sample efficiency. The situation which all outputs are incorrect remains the same. To this end, perform data selection by generating eight Cypher queries per prompt using our method.
Specifically, select training instances from the CypherBench [8] training set We employ the 2.5---255-oder- 7B model to first perform schema selection, then generate the corresponding Cypher queries, and subsequently execute them within the database. Prompts with mean selection accuracy of and mean execution accuracy I, as well as those with a mean selection accuracy of 0 and mean execution accuracy of 0, subsequently filtered out. Finally, we obtain 8,295 samples from four distinct graph databases: Art, Terrorist Attack, Soccer, and Biology.
3.2 Evaluation Datasets and Metrics
We use two datasets to evaluate the conversion of natural language into Cypher queries: CypherBench, Neo4j-TexttCypher. Specifically, CypherBench constructed across seven different property graphs. including Fictional Character, Company, Flight Accident, Geography, Movie, NBA and Politics. Neo4j-Teex2Cypherr is synthetic dataset developed by Neo4j. comprising 15 graph databases.
To ensure fair comparison, we adopt the evaluation standards established in previous benchmarks. Specifically, we assess model performance using Execution Accuracy (EX), Provenance Subgraph Jaccard Similarity (PSJS), executable percentage (Exec.) and Google-BLEU. Execution Accuracy evaluates whether the database results executed by the predicted query align with those produced by the ground-truth query. The provenance subgraph is defined as the portion of the graph retrieved by executing the MATCH clause in combination with RETURN * The PSJS metric quantifies query similarity by computing the Jaccard similarity between provenance subgraphs of generated and ground- Cypher queries. Exec. assesses whether the generated Cypher queries can be executed in graph databases without compiler errors. Google-BI.R BLEU metric quantifies textual correspondence by analyzing n- n-gram matches between the generated Cypher and the gold answer.
3.3 Baselines
To evaluate the effectiveness of Cypher-RI, we compare it with a range of baseline approaches: (1)
General Purpose Methods: including Owen-2.5-Coder--7B [8), Llama3. 1-8][6), Gemma-2-9B 35).
GPT-4o-mini, Gemini-1.5-ProfB33 and GP'T-4o I]; and (2) Text-to-Cypher Specific Methods: R
NLGQL [1. Text2Cypher- Gemphher--Gmmm--2227777 30 36). These baselines collectively represent both
Nomain-agnostic and domain-specialized strategies, enabling thorough and multifaceted evaluation of the proposed method.
3.4 Implementation Details
In our Cypher-RT framework, we adopt Qwen-2.5-Coder-- as the base model for training. The dataset consists of 8,295 instances sourced from the CypherBench training split. During the training

---

Table 2: Main results of different methods on CypherBench and Neox)-Texx2Cypher. The best performance set in bold.
Methods
CypherBench
Nensk-Texx22Cyper
EX (%)
PSJS (%)
Exec. (%)
EX (%)
Google-BLEU (%)
0wen2.5-Coder-78
13.12
22.65
62.95
12.06
44.37
Gemma--299B
18.61
30.67
68.57
14.49
51.04
Llama3: 1-8B
18.82
30.98
90.67
11.86
41,30
R*-NLGQL
23,94
38.12
64.83
19.27
47,91
GPT-4o-mini
31.43
45.91
87.39
25.82
59.62
Text Tex12Cyphen-Gemmm-33
38.71
55.53
92.97
29.84
50.10
Gemini-1.5-PV
39,95
57.70
86.03
23.07
58.45
GPT-4o
60.18
76.87
94.90
31.73
62.93
Cypher-Rl((urs)
69.59
75.21
99.28
30.61
60.13
process, each instance is sampled through 8 rollouts with the sampling temperature maintained 1.0. We employ a training batch size of 128 and set the rollout batch size to 128 as well. The learning rate is fixed at x 10-6 Further training details provided in Appendix B In RR*NNGQL, Qwen-2.5-Coder-77 is employed as the foundation model across all components.
3.5
Main Results
Table reports the comprchensive evaluation results of Cypher-RI and several strong baseline models across two benchmarks. Cypher-RI demonstrates state-of-the-ar performance in crucial aspects of Cypher query generation, achieving the highest Execution Accuracy at 69.59%. This represents significant margin over other models, notably outperforming the strong GPT-4o model, which scored 60.18% by 9.41 percentage points. Furthermore, Cypher-RI also sets new standard for generating syntactically valid queries, attaining an exceptional Executable Percentage of 99.28%. This near- perfect rate in producing executable queries the highest among all evaluated models, surpassing GPT-4o and indicating the high reliability and robustness of our approach. In terms of PSIS, GPT-4o records the highest score at 76.87%, with Cypher-RI achieving very competitive second place at 75.21%. While GPT-4o shows a slight edge in aligning more closely with the exact structural representation of the ground truth provenance subgraph, Cypher-RI's leading EX score suggests that it effectively identifies and retrieves the correct data, potentially through equally valid but structurally slightly different query patterns. This also implies that while PSJS is an important measure of structural understanding, Cypher-RI excels in translating this understanding into executable and correct queries.
When compared to its base model, Qwen2.5-Coder-775 which scored 13.12% EX, 22.65% PSJS, and 62.95% Exec., Cypher-RI exhibits remarkable improvement across all evaluated metrics. Specifically, Cypher-RI boosts the Execution Accuracy by an absolute 56.47 percentage points, the Provenance Subgraph Jaccard Similarity by 52.56 percentage points, and the Executable Percentage by 36.33 percentage points over its foundation. This substantial leap in performance clearly demonstrates the profound efficacy of our training methodology in refining and specializing the base model for complex Cypher query generation.
In terms of PSJS, Cypher-RI RI achieving very competitive second place 75.21% %. While GPT-4o shows slight edge in aligning more closely with the exact structural representation of the ground truth provenance subgraph, Cypher-RI's leading EX score suggests that it generates valid but structurally slightly different query. This observation is consistent with our training reward, which is defined in terms of execution accuracy.
In the Tex4i-Teet2Cyypee evaluation, Cypher-RI also exhibits highly competitive results. It achieves an Execution Accuracy of 30.61 %. closely matching GPT-4o's 's 31. 1.73%. and outperforms all other baselines. Regarding Google -LEU, which measures n-gram level similarity between generated queries and references, Cypher-RI achieves 60.13%, again ranking just behind GPT-4o.
particularly noteworthy finding from our experiments is the efficiency and effectiveness of Cypher- RI relative to model scale. Despite being developed upon 7B parameter model, Cypher-RI consis- tently outperforms significantly larger and more general-purpose models the specialized domain of Cypher generation. For instance, surpasses GPT-4o in both exccution accuracy and the ability
7

---

BASIC patterns
Special patterns
RETURN templates
Optional Match
Time--ensiiive
PROPERTY
AGGREGATE
tel-el
Lez m24
in un (m)))
(m(m)
Union
FILTER
NAKE
Group By
ell (mi))
Compar son
ARGMAX
SORT
Figure 2: Performance evaluation of four models across distinct BASIC patterns, MATCH Patterns and RETURN templates.
to generate executable queries in CypherBench. Similarly, Sewz2Cypher-Gemma---21 parameter model specifically finetuned for Text-to-Cypher tasks, also lags behind Cypher-Re RI with an EX of 38.71%. This highlights Cypher-RI's RI's advanced capabilities and its potential for providing highly accurate Cypher generation without necessitating the substantial computational resources typically associated with much larger models.
a 27B
3.6 Analysis
In this section, we provide a detailed analysis of the performance breakdown across multiple dimen- sions. As illustrated in Figure the left chart presents the execution accuracy across different basic Cypher patterns. Here, "(:)" denotes node, "(:n [)" indicates node with specified properties, and "-[ze]->" represents an edge. Notably, the performance Qwee-2.5-Coderr77
significantly lower than that of the other models, underscoring substantial capability gap. In contrast, our RL-trained model achieves highly competitive, and frequently superior, performance compared to the strong baseline of GPT-4o. While GPT-4o exhibits robust general capabilities, Cypher-RI RI demonstrates distinct advantage on several more complex Cypher structures, including two-hop paths and bidirec- tional patterns. Cypher-RI not only achieves high peak performance but also demonstrates greater consistency across the range of patterns. Its performance floor is significantly higher than the other models, especially the base version. This robustness is critical for practical applications where wide variety of query types might be encountered. The high accuracy on complex patterns suggests an ability to handle disjunctive conjunctive relational conditions effectively.
The mid chart in Figure 2 edisplays execution accuracy across the special patterns. Compared with GPT-4o, Cypher-RL RI showcased competitive and, in several categories, superior performance. Notably, our model achieved higher exccution accuracy in "Time-sensitive", "Comparison" and "Group By" queries. While GPT-4o demonstrated stronger performance in "Union" and "Optional Match" ppttterns. The ability of our model to handle intricate Cypher patterns such as time-sensitive constraints and optional graph traversals with high accuracy testament to the benefits of our training approach.
Delving into specific return templates, as illustrated in the right chart of Figure 2 Cypher-RI demonstrates exceptional proficiency in handling all clauses, achieving the highest execution accuracy in these categories. This suggests that the reinforcement learning process has effectively equipped the model to understand and generate complex query structures involving specific entity returns, ordering of results, and aggregation functions. In the "SORT" template, which typically requires more sophisticated semantic understanding to order values based on specific criteria, all other models achieve an execution accuracy of less than 25%. In contrast, Cypher-RI attains accuracy of 84.21%.
Integrating schema selection into Cypher generation within reinforcement learning framework and applying it to the training of LLMS can achieve state-of-the-art performance the Text-to-Cypher task, providing more efficient and targeted alternative to relying solely on larger, general-purpose models. The experimental results compellingly highlight the effectiveness of our method in training large language models for Cypher generation, enhancing their ability capture semantic subtlcties
8

---

patterns
Special
RETURN templates
Optional Match
Time--ensilive
PROPERTY
AGGREGATE
tel-al
Jez
un (((m)
un t (mm))
Union
FILTER
NAKE
Group By
enl (mi))
Compor son
ARGMAX
SORT
Figure 3:
Performance evaluation of ablation models across distinct BASIC patterns, MATCH Patterns and RETURN templates.
and syntactic rules. Notably, the improvements are particularly pronounced in cases involving multiple relationships, time-related questions, and sorting requirements. Cypher-RI, our RL-trained model, significantly outperforms its base model and shows competitive, often superior, performance compared to GPT-4o across a variety of fundamental Cypher patterns. These findings demonstrate that trained open-source models can achieve highly accurate and reliable natural language-to-Cypher translation, validating the advantages our specialized RL training method.
3.7 Ablation Study
In this section, we aim to assess the en- hancement effects of reinforcement learn- ing and the integration of schema selection into training through comparative experi- ments. To demonstrate the effectiveness of reinforcement learning. we performed su- pervised fine-tuning on the model. Specif- ically, we used the same model as the reinforcement learning setup to collect roll- outs on the training sets CypherBench. For each instance to first select schema and then generate the corresponding Cypher query. The generated Cypher was executed against the graph database, and if the execution result matched the gold answer, we added the trajectory the training data. We sampled trajectories until the model generated the correct answer, with a maximum of cight attempts per instance. To evaluate the effectiveness of integrating schema selection into the training process, also trained the model using reinforcement learning without schema selection, similar to the approach in DeepSeek R1.
Model
EX (%)
PSJS (%)
Exec. (%)
SFT
44.34
49,80
94,34
RL(wo schema selection) Cypher-RI
66.55
96.
69.59
75.21
99.28
Table 3: Ablation Study Experiment the Cypher- Bench Test Set.
training set, we prompted the LLM
The results of these experiments are presented in Table 3 We can see that Cypher-RI outperforms SFT and RL (without schema selection) on the test sets, demonstrating superior Cypher generation capability and better generalization across graph databases. Figure [ cleearly illustrates the types of situations where our method provides improvements. Compared other methods, Cypher-RI shows significant gains complex basic patterns, "Group By"and "Time-sensitive" special patterns, as well as "FILTER" and "SORT" templates.
We also evaluated the model's performance on the training data to better understand its learning behavior. As shown in Table the SFT method achieved the highest EX score on the training data but the lowest EX score on test data. This phenomenon demon- strates that RI excels at learning general- izable knowledge, whereas SFT tends simply memorize the training data.
Model
EX (%)
PSJS (%)
Exec. (%)
SFT
85.66
85.63
97.15
RL/wo schema selection)
80.89
81.20
99.39
Cypher-RI
84.59
86.39
99.78
Table Ablation Study Experiment on the Training Data.

---

4 Related Work
Text-to-Cypher Methods. Recent progress in large language models has markedly advanced methods for translating natural language into Cypher queries. Hornsteiner et al. [15] proposed framework
that notably improves user-graph database interaction and establishes a scaffold for integrating multiple database systems with large language models. The R [4] approach combines big and small language models across different stages, exploiting smaller models' strengths for preliminary ranking and textual normalization, while assigning final query synthesis and broad generalization to larger models to produce high-quality GQL outputs. Liang et al. [22] synthesize paired NL-GQL examples grounded in the target graph schema firstly. Next, these synthetic pairs serve to fine-tune LLMs so that their outputs better conform to the database's 's schema and querying conventions. Text2Cypher (30) demonstrate the value of aggregating, sanitizing, and structuring several public resources into a consolidated training corpus; models trained on this cleaned collection exhibited notable gains in downstream query-generann performance. NAT-NL2GQL [3 proposed three agents to generate Cypher: a Preprocessor for context processing, Generator for GQL creation, and a Refiner that optimizes outputs using execution feedback.
Reinforcement I Learning for Large Language Models. Reinforcement learning (RL) has proven to be valuable approach for improving the reasoning abilities of large language models. Ouyang et al. (29) were among the first to apply RL. to LLM fine-tuning by using reinforcement learning from human preferences. Their pipeline trains reward model from human preference annotations and then leverages that learned reward signal to perform policy optimization on the base language model process commonly implemented with PPO. DeepSeek proposed GRPO, which eliminates the need for a critic model by estimating baselines from group scores, exhibiting strong performance in math field. Beyond these examples, reinforcement learning has been increasingly applied to a variety of generation oriented tasks, each leveraging RL to enhance model reasoning. For instance, in SQL generation, systems such as SQL-R1 (27) and Reasoning-SQQ [3] employ reward functions derived from query execution accuracy to guide policy updates, enabling the models to generate correct SQL.. the logical reasoning domain, Logic-RI. (39] trains language models by using the exact match of the final answer the reward signal, enabling the model to iteratively refine its logical reasoning when solving puzzles, For code generation, Code-RI [25] integrates RL objectives based on functional correctness, optimizing the model toward producing executable and efficient programs. Search-RI I [20] combines reinforcement learning with search-enhanced training, where the model is rewarded for selecting informative retrieval paths and reasoning chains, effectively aligning its search strategy with the goal of more accurate multi-hop reasoning.
5 Limitations
This study focuses specifically on the generation of Cypher queries. While Cypher is the most widely used graph query language, we acknowledge that other graph query languages such as Gremlin, PGQL and G-CORE are also utilized in the graph database landscape. Future research could extend our reinforcement learning methodology investigate its applicability and performance in generating queries for these alternative languages, thereby broadening the scope of LLM-driven text-to-query translation for graph databases.
6 Conclusion
This study presents Cypher-RI, an innovative framework that integrates schema selection into Cypher query generation through reinforcement learning, without relying on any annotated reasoning step supervision. In our methodology, schema selection is embedded as a critical element within the reasoning process: the model first performs text-driven schema selection, and the selected schema is then concatenated into the rollout sequence to guide the subsequent Cypher generation. Extensive em- pirical evaluations across multiple Text-to-Ca -o-yhhrr benchmarks demonstrate that Cypher- RI achieves substantial gains compared to existing baseline models. Moreover, the findings suggest strong applicability of our framework to practical, real-world environments. Overall, this research under- scores the promise of reinforcement learning in jointly modeling schema selection and Cypher query generation, offering compelling direction toward building more capable, trustworthy M.-.-er Text-to-Cypher systems.
10

---

References
[1] Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, lige Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. Gpt-4 technical report. arXiv preprint arXiv:2303.08774. 2023.
[]] Tom B Brown. Language models are few-shot learners. arXiv preprint arXiv:2005. 2020.
[3] Zhenbiao Cao, Yuanlei Zheng, Zhihao Fan, Xiaojin Zhang. Wei Chen, and Xiang Bai. Rsl-sql: Robust schema linking in text-to-sql generation. arXiv preprint arXiv:2411.0007. 2024.
[4] Mingyang Chen, Tianpeng Li, Haoze Sun, Yijie Zhou, Chenzheng Zhu, Fan Yang, Zenan Zhou, Weipeng Chen, Haofen Wang, Jeff Z. Pan, et al. Learning to reason with search for Ilms via reinforcement learning. arXiv preprint arXiv:2503. 19470, 2025.
[5] Tianzhe Chu, Yuexiang Zhai, Jihan Yang, Shengbang Tong, Saining Xie, Dale Schuurmans, Quoc V Le, Sergey Levine, and Yi Ma. Sft memorizes, 1l generalizes: A comparative study of foundation model post-traing training arXiv preprint arXiv:2501.171611 2025.
[6] Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, al. The llama 3 herd of models. arXiv preprint arXin:2407.2178. 2024.
[7] Guandong Feng, Guoliang Zhu, Shengze Shi, Yue Sun, Zhongyi Fan, Sulin Gao, and Jun Hu. Robust nl-to-cypher translation for kbqa: Harnessing large language model with chain of prompts. In China Conference on Knowledge Graph and Semantic Computing, pages 317-326. Springer, 2023.
[8] Yanlin Feng, Simone Papicchio, and Sajjadur Rahman. Cypherbench: Towards precise retrieval over full-scale modern knowledge graphs in the I1m era. arXiv preprint arXiv:2412.1877 2024.
[9] Nadime Francis, Alastair Green, Paolo Guagliardo, Leonid Libkin, Tobias Lindaaker, Victor Marsault, Stefan Plantikow, Mats Rydberg, Petra Selmer, and Andrés Taylor. Cypher: An evolv- ing query language for property graphs. In Proceedings of the 2018 international conference on management of data, pages 1433-1445, 2018.
[10] Balaji Ganesan, Sambit Ghosh, Nitin Gupta, Manish Kesarwani, Sameep Mehta, and Renuka Sindhgatta. Llm-po alm-powered graphql generator for data retrieval. In Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, pages 8657-8661 2024.
[11] Alastair Green, Paolo Guagliardo, Leonid Libkin, Tobias Lindaaker, Victor Marsault, Stefan Plantikow, Martin Schuster, Petra Selmer, and Hannes Voigt. Updating graph databases with cypher. Proceedings of the VLDB Endowment, 12(12):2242-2254, 2019.
[12] Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song. Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang. Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in Ilms via reinforcement learning, arXiv preprint arXiv:2501.12244 2025.
[13] Florian Holzschuher and René Peinl. Performance of graph query languages: comparison of cypher, gremlin and native access in neo4j. In Proceedings of the Joint EDBT/CCTT 2013 Workshops, pages 195-204, 2013.
[14] Markus Hornsteiner, Michael Kreussel, Christoph Steindl, Fabian Ebner, Philip Empl. and Stefan Schönig. Real-time text-to-cypher query generation with large language models for graph databases. Future Internet, 16(12):438 2024.
[15] Markus Homsteener, Michael Kreussel, Christoph Steindl, Fabian Ebner, Philip Empl, and Stefan Schönig. Real-time text-to-cypher query generation with large language models for graph databases. Future Internet, 16( 16(12):438, 2024.
[16] Jian Hu. Reinforce+:: A simple and efficient approach for aligning large language models. arXiv preprint arXhv:2501.03262, 2025.

---

[17] Jingcheng Hu, Yinmin Zhang, Qi Han, Daxin Jiang, Xiangyu Zhang, and Heung. Yeung Shum. Open-reasoner zero: An open source approach scaling up reinforcement learning on the base model. arXiv preprini arXiv:2503.24290, 2025.
[18] Binyuan Hui, Jian Yang. Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jia- jun Zhang, Bowen Yu, Keming Lu, et al. Qwen2. 5-coder technical report. arXiv preprint arXiv:2409. 18666, 2024.
[19] Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Camey,, et al. Openai of system card. arXiv preprint mrXiv:2412.16720) 2024.
[20] Bowen Jin, Hansi Zeng, Zhenrui Yue, Jinsung Yoon, Sercan Arik, Dong Wang, Hamed Za- mani, and Jiawei Han. Search-rl: Training Ilms to reason and leverage search engines with reinforcement learning. arXiv preprint arXiv:2503.09516, 2025.
[21] Jean Kaddour, Joshua Harris, Maximilian Mozes, Herbie Bradley, Roberta Raileanu, and Robert McHardy, Challenges and applications of large language models. arXiv preprint 2.0.:22377.1066, 2023.
[22] Yuanyuan Liang, Keren Tan, Tingyu Xie, Wenbiao Tao, Siyuan Wang, Yunshi Lan, and Weining Qian. Aligning large language models to domain-specific graph database. arXiv preprint arXiv:2402.. /6567, 2024.
[23] Yuanyuan Liang, Tingyu Xie, Gan Peng, Zihao Huang, Yunshi Lan, and Weining Qian. Nat- nl2gql: A novel multi-agent framework for translating natural language to graph query language. arXiv preprint arXiv:2412.10433 2024.
[24] Geling Liu, Yunzhi Tan, Ruichao Zhong, Yuanzhen Xie, Lingchen Zhao, Qian Wang, Bo Hu, and Zang Li. Solid-sql: Enhanced schema-linking based in in-conextt learning for robust text-to-sql. arXiv preprint arXiv:2412.12522, 2024.
[25] Jiawei Liu and Lingming Zhang. Code-rl: Reproducing rl for code with reliable rewards. 2025.
[26] Yang Liu, Xin Wang, Jiake Ge, Hui Wang, Dawei Xu, and Yongzhe Jia. Text to graph query using filter condition attributes. Proceedings of the VLDB Endowment. ISSN, 2150:8097.
[27] Peixian Ma, Xialie Zhuang. Chengjin Xu, Xuhui Jiang, Ran Chen, and Jian Guo. Sql-rl: Training natural language to sql reasoning model by reinforcement learning. arXiv preprint arXiv:2504.n 08600, 2025.
[28] Justin Miller. Graph database applications and concepts with neo4j. Proceedings of the southern association for information systems conference, Atlanta, GA, USA, volume 2324, pages 141-147, 2013.
[29] Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. Advances in neural information processing systems, 1122770-227444 2022.
[30] Makbule Gulein Ozsoy, Leila Messallem, Jon Besga, and Gianandrea Minneci. Text2cypher: Bridging natural language and graph databases. arXiv preprint arXiv:2412.10064 2024.
[31] Mohammadreza Pourreza, Shayan Talaci, Ruoxi Sun, Xingchen Wan, Hailong Li, Azalia Mirhoseini, Amin Saberi, Sercan Arik, et al. Reasoning-sqj. Reinforcement learning with sql tailored partial rewards for reasoning-enhann enhanneed text-to-sql. arXiv preprint arXiv:2503.23157, 2025.
[32] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv: 06347. 2017.
[33] Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint ar arXiv:2402. 03300, 2024.
12

---

[34] Gemini Team, Petko Georgiev, Ving lan Lei, Ryan Burnell, Libin Bai, Anmol Gulati, Garrett Tanzer, Damien Vincent, Zhufeng Pan, Shibo Wang, al. Gemini 1.5: Unlocking multimodal understanding across millions of tokens of context. arXiv preprint arXiv:2403.05530, 2024.
[35] Gemma Team, Morgane Riviere, Shreya Pathak, Pier Giuseppe Sessa, Cassidy Hardin, Surya Bhupatiraju, Léonard Hussenot, Thomas Mesnard, Bobak Shahriari, Alexandre Ramé, et al. Gemma 2: Improving open language models at practical size. arXiv preprint arXiv:2408.001 08 2024.
[36] Gemma Team, Aishwarya Kamath, Johan Ferret, Shreya Pathak, Nino Vieillard, Ramona Merhej, Sarah Perrin, Tatiana Matejovicova, Alexandre Ramé, Morgane Rivière, et al. Gemma 3 technical report. arXiv preprini arXiv:2503. 19786, 2025.
[37] Bing Tong, Yan Zhou, Chen Zhang, Jianheng Tang, Jing Tang, Leihong Yang, Qiye Li, Manwu Lin. Zhongxin Bao, Jia Li, et al. Galaxybase: high performance native distributed graph database for htap.
[38] Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, et al. Emergent abilities large language models. arXiv preprint arXiv:2206.0760 07682, 2022.
[39] Tian Xie, Zitian Gao, Qingnan Ren, Haoming Luo, Yuqian Hong, Bryan Dai, Joey Zhou, Kai Qiu, Zhirong Wu, and Chong Luo. Logic-rl: Unleashing Ilm reasoning with cule-based reinforcement learning. arXiv preprint arXiv:2502. 2025.
[40] Wayne Xin Zhao. Kun Zhou, Junyi Li. Tianyi Tang, Xiaolei Wang, Yupeng Hou, Yingqian Min, Beichen Zhang, Junjie Zhang, Zican Dong, et al. A survey of large language models. arXiv preprint arXiv:2303.188 18223, 2023.
[41] Yuhang Zhou, Yu He, Siyu Tian, Yuchen Ni, Zhangyue Yin, Xiang Liu, Chuanjun Ji, Sen Liu, Xipeng Qiu, Guangnan Ye, et al. -9lng2gq A model coordination and knowledge graph alignment approach for n/2gql. 2024.
13

---

NeurIPS Paper Checklist
The checklist is designed encourage best practices for responsible machine learning research, addressing issues of reproducibility, transparency, research ethics, and societal impact. Do not remove the checklist: The papers not including the checklist will be desk rejected. The checklist should follow the references and follow the (optional) supplemental material. The checklist does NOT count towards the page limit.
Please read the checklist guidelines carefully for information on how to answer these questions. For each question in the checklist:
You should answer [Yes], [No], or [NA].
[NA] means either that the question Not Applicable for that particular paper or the relevant information is Not Available.
Please provide short (1-2 sentence) justification right after your answer (even for NA).
The checklist answers are an integral part of your paper submission. They are visible to the reviewers, area chairs, senior area chairs, and ethics reviewers. You will be asked to also include (after eventual revisions) with the final version of your paper, and its final version will published with the paper.
The reviewers of your paper will be asked use the checklist as one of the factors their evaluation. While "[Yes] is generally preferable to "[No]" ", it is perfectly acceptable to answer "[No] providedd proper justification is given (e.g.. "error bars are not reported because it would be too computationally expensive" or "we were unable to find the license for the dataset we used"). In general, answering binary way, we
"[No] or "[NA]" is not grounds for rejection. While the questions are phrased acknowledge that the true answer is often more nuanced, please just use your best judgment and write justification to elaborate. All supporting evidence can appear either in the main paper or the supplemental material, provided in appendix. If you answer [Yes] to a question, in the justification please point to the section(s) where related material for the question can be found.
IMPORTANT, please:
Delete this instruction block, but keep the section heading "NeurIPS Paper Checklist",
Keep the checklist subsection headings, questions/answers and guidelines below.
Do not modify the questions and only use the provided macros for your answers.
1. Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification: Abstract and Section Iictionnnnttttn Introduction.
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made in the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or
NA answer to this question will not perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results be expected to generalize other settings.
is fine include aspirational goals as motivation long is clear that these goals are not attained by the paper.
2. Limitations
Question: Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
Justification: Section Limitations.
14

---

Guidelines:
The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create a separate "Limitations" section their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect on the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution low or images are taken in low lighting. Or speech-to-tex system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairesss.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an impor- tant role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.
3. Theory assumptions and proofs
Question: For each theoretical result, does the paper provide the full set of assumptions and complete (and correct) proof?
Answer: [NA]
Justification:
The paper does not include theoretical results.
Guidelines:
The answer NA means that the paper does not include theoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced the statement of any theorems.
The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide short proof sketch to provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.
Theorems and Lemmas that the proof relies upon should be properly referenced.
4. Experimental result reproducibility
Question: Does the paper fully disclose all the information needed to reproduce the main ex- perimental results of the paper to the extent that affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?
Answer: [Yes]
Justification: We report the setup throughout the paper as well as in the Section 3.4 and Appendix [B]
Guidelines:
The answer NA means that the paper does not include experiments.
15

---

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. w
For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
While NeurlPS does not require releasing code, the conference does require all submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily new algorithm, the paper should make it clear how to reproduce that algorithm. (b) the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.
(c) If the contribution is new model (e.g., a large language model), then there should either be way to access this model for reproducing the results or way to reproduce the model (e.g., with an open-source dataset instructions for how to construct the dataset).
(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.
5. Open access to data and code
Question: Does the paper provide open access to the data and code, with sufficient instruc- tions to faithfully reproduce the main experimental results, as described in supplemental material?
Answer: [Yes]
Justification:
We use publicly available datasets and the code of our work is fully provided.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurIPS code and data submission guidelines (nttps://nips.. cc/
for more details.
While we encourage the release of code and data, we understand that this might not be possible, so "No" an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurlPS code and data submission guidelines (https
/ 7/nips. /ttppp.cc/pbllc/guudeeee http://oeeubiiissioooooooooo
for more details.
The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. only subset of experiments are reproducible, they should state which ones are omitted from the script and why.
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
16

---

Providing as much information as possible in supplemental material (appended to the paper) recommended, but including URLs to data and code permitted.
6. Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification: We report the training and test details in the Section 3.4 Appendix and Appendix [
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented in the core of the paper to level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, or as supplemental material.
7. Experiment statistical significance
Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Question:
Answer: [Yes]
Justification: The LLMs only have checkpoint, only edit once for each setting. But we test our method and baselines under various models, settings, and datasets, therefore, the statistical significance of the experiments can be verified and supported.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by emror bars, confi- dence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall
run with given experimental conditions).
The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
The assumptions made should be given (e.g., Normally distributed errors).
should be clear whether the error bar is the standard deviation the standard error of the mean.
It is OK to report 1-sigma error bars, but should state it. The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).
show in tables or
error bars are reported in tables or plots, The authors should explain the text how they were calculated and reference the corresponding figures or tables in the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the com- puter resources (type of compute workers, memory, time of execution) needed reproduce the experiments?
Question:
Answer: [Yes]
Justification: In Appendix
Guidelines:
The answer NA means that the paper does not include experiments.
17

---

The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.
The paper should provide the amount compute required for each of the individual experimental runs well estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make into the paper).
9. Code of ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurlPS Code of Ethics
Answer: [Yes]
Justification: We use publicly standard datasets that do not contain information about individual people or offensive context to our knowledge.
Guidelines:
The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.
If the authors answer No, they should explain the special circumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (c.g.. there a special consid- eration due to laws regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification: In Appendix
Guidelines:
The answer NA means that there is no societal impact of the work performed.
If the authors answer NA No, they should explain why their work has societal impact or why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
The conference expects that many papers will be foundational research and not tied partieular applications, let alone deployments. However, if there is direct path any negative applications, the authors should point it out. For example, it is legitimate point that improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.
If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition attacks, mechanisms for monitoring misuse, mechanisms to monitor how system learns from feedback over time, improving the efficiency and accessibility of ML).
11. Safeguards
Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (c.g., pretrained language models, image generators, scraped datasets)?
Question:
Answer: [NA]
18

---

Justification: [NA]
Guidelines:
The answer NA means that the paper poses no such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards challenging, and many papers do not require this, but encourage authors to take this into account and make best faith effort.
12. Licenses for existing assets
Are the creators original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?
Question:
Answer: [Yes]
Justification: Section 3.2
We use publicly available artifacts.
Guidelines:
The answer NA means that the paper does not existing assets. The authors should cite the original paper that produced the code package dataset.
The authors should state which version of the asset used and, possible, include URL.
The name of the license (c.g., CC-BY 4.0) should be included for each asset.
For scraped data from a particular source (e.g., website). the copyright and terms of service of that source should be provided.
assets are released, the license, copyright information, and terms use in the package should be provided. For popular datasets, haperswithcode com/ datasets has curated licenses for some datascts. Their licensing guide can help determine the license of dataset.
For existing datasets that re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.
If this information is not available online, the authors are encouraged to reach out to the asset's creators.
13. New assets
Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Question:
Answer: [Yes]
Justification:
Our code is provided.
Guidelines:
The answer NA means that the paper does not release assets.
Researchers should communicate the details of the dataset/code/moodl as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent was obtained from people whose asset is used.
At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well details about compensation (if any)?
19

---

Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does involve crowdsourcing nor research with
human subjects.
Including this information in the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then as much detail as possible should be included in the main paper.
According the NeurIPS Code of Ethies, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals equivalent for research with human subjects
Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
Question:
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the paper does involve crowdsourcing nor research with human subjects.
Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurlPS Code of Ethics and the guidelines for their institution.
For initial submissions, not include any information that would break anonymity (if applicable), such as the institution conducting the review.
16. Declaration of LLM usage
Question: Does the paper describe the usage of LLMs if is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing. editing, or formatting purposes and does not impact the core methodology, scientific rigorousness, originality of the research, declaration is not required.
Answer: [NA]
Justification: [NA]
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs as any important, original, non sta-srdd components.
Please refer to LLM policy (nttps://neuri)) http://ppp...ooooeeeeeeee/////// for what should or should not be described.
20

---

Table 5: Dataset description
Dataset
Database
Samples
biology soccer
2289
1820
Training
art
2750
terrorist attack
1436
geography
366
flight accident
189
politics
390
CypherBench
company
347
fictional character
385
movie
401
nba
270
bluesky
39
buzzoverflow
120
companies
275
fincen
146
gameofthrones
148
grandstack
182
movies
203
neoflix
261
network
109
northwind
197
offshoreleaks
115
recommendations
253
stackoverflow2
91
twitch
185
twitter
146
A Dataset Description
We conduct our experiments on two representative and diverse datasets: CypherBench and Neo4j- Text2Cypher. These datasets are selected to comprchensively evaluate the generalization ability and query generation performance of our proposed method across different domains and database schemas. For training purposes, we construct our dataset by utilizing the training portion of CypherBench, ensuring that the model is exposed to wide variety of graph structures and query patterns during learning.
T a detailed summary of the databases involved and the number of samples available for each. The training dataset consists of four domains: biology, soccer, art, and terrorist attack, comprising a total of 8,295 examples. This diverse collection enables the model to learn from a broad spectrum of semantic structures and query intents.
The CypherBench test set, designed to evaluate zero-shot generalization, includes seven distinct domains such as geography, flight accident, politics, company, fictional character, movie, and NBA. Each domain presents unique challenges terms of entity types, relationships, and query complexity, making it robust benchmark for assessing model performance unseen data.
The Neo4j- Teedjj-Txx22ypher dataset, which covers 15 diverse domains, including real-world and synthetic graphs like Bluesky, BuzzOverflow, Fincen, Game of Thrones, Northwind, and Twitter. With total of 2,380 examples, Neo4j-Text22 Text2Cypher tests the model's ability handle heterogeneous graph schemas and varied user query styles.
B Implementation Details
Our training conduct on 4x Nvidia A800 GPUs, with full parameter optimization and gradient checkpointing, We show some important parameter settings in Table 6
21

---

Table 6: Implementation details of Cypher-RI. Rl.
Parameter
Value
Base Model
Qwen2.5-Coder
Train Batch Size
1024
Micro Train Batch Size
8
Rollout Batch Size
128
Micro Rollout Batch Size
16
Learning Rate
le-6
Prompt Max Length
1,024
Generation Max Length
2,000
Initial KI. Coefficient
0
Mixed Precision
BF16
Rollout Temperature
1.0
Optimizer
AdamW
Clip Ratio
0.2
Number of Rollout
8
C
Social Impacts
This paper introduces Cypher-RI as a foundation model tailored for Text-to-Cypher tasks. Cypher-RI focuses on improving the accuracy, reliability, and generalization of natural language to Cypher query translation, enabling enhanced interaction with structured graph data. Our work aims to facilitate user-friendly access to graph databases through natural language, without posing any potential ethical concerns or negative social impacts.
22


Reviews:
[{"review_id": "OlcRZJ1FGl", "reviewer": "Reviewer_QSLq", "summary": "The paper develops a reinforcement learning method for improving the ability of an LLM to translate natural language questions into Cypher, a programming language akin to SQL but for graph databases. The method involves prompting the model with a minimized schema for the graph database along with the question, after which the model should generate reasoning tokens in <think> tags and then output a JSON representation of the parts of the schema that it's interested in. The prompt is extended with the schema details, after which the model should generate more thinking and then output the final query.\n\nThe authors use reinforcement learning with GRPO to train the Qween-2.5-Coder-7B model on the CypherBench training set. They compare against 6 general-purpose LLMs and 2 other Cypher-specific methods, and report better or similar performance compared to all other models, including proprietary models like GPT-4o which are presumably much larger than the 7B model. They also compare against a rejection sampling-based SFT method and RL without the schema selection part and show that the proposed method performs better than the ablations.", "questions": "- How often does the model fail to generate valid JSON for the schema?", "limitations": "Yes", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 3, "originality": 2, "strengths_and_weaknesses": "## Strengths\n- The authors perform extensive experiments using many comparison methods, two distinct test sets, an ablation study, and comparing the performance on different subsets of the test sets.\n- The method shows clearly convincing improvements over previous methods, especially considering that some of the other models compared are much larger.\n- The paper studies a relatively narrow but impactful problem with potential for real-world impact.\n- The authors provide code, which makes it much easier to reproduce the details of the paper.\n\n## Weaknesses\n- There is no study of the tradeoff between inference costs and the increase in accuracy obtained. By allowing the model to generate shorter or longer amounts of reasoning tokens, it might be that close-enough performance can be achieved with fewer tokens or that performance can be improved even further with more tokens.\n- There is no comparison against other models that also use thinking tokens.", "was_revised": true, "final_justification": "The authors have sufficiently addressed my questions with additional experimental results. The other reviews and the discussion did not raise any concerns on my end for lowering the score from before. My score was already positive and I believe it is appropriate to maintain it as-is.", "rebuttal": "We sincerely thank the reviewer for their constructive feedback, which has helped us improve our work. We address the specific questions and weaknesses below.\n- Q1: Accuracy of JSON Schema Generation\n\n  We have evaluated the accuracy of generating valid  JSON format. The results on both benchmark datasets are presented below.\n\n    |                  | CypherBench(%) | Neo4j-Text2Cypher(%) |\n    | :--------------: | :------------: | :------------------: |\n    | Qwen2.5-Coder-7B |     78.32      |        62.65         |\n    |    Cypher-RI     |     100.00     |        99.62         |\n\n  As shown in the table below, our method achieves near-perfect format accuracy on both datasets: **100.00%** on CypherBench and **99.62%** on Neo4j-Text2Cypher. \n\n  In addition to evaluating accuracy in JSON format, we also assessed the accuracy of schema selection on both benchmarks.\n\n    |     Methods      | CypherBench(%) | Neo4j-Text2Cypher(%) |\n    | :--------------: | :---------: | :---------------: |\n    | Qwen2.5-Coder-7B |    76.45    |       73.98       |\n    |    Cypher-RI     |    95.87    |       93.87       |\n\n  As shown, our model improves the accuracy of schema selection by a significant margin of **20 percentage points** over the base model on both datasets. This demonstrates that the RL process effectively teaches the model to select needed schema, which is a critical first step in the generation pipeline.\n\n- W1: Trade-off Between Inference Cost and Accuracy.\n\n  We agree with the reviewer that the trade-off between inference cost  and performance is a critical aspect of reasoning models. While longer reasoning chains can improve accuracy, the lack of control over their length makes it difficult to manage test-time compute budgets.\n\n  To investigate this trade-off, we designed an additional experiment, inspired by prior work [1,2,3], aimed at controlling the length of the generated reasoning tokens. We introduce a **length-based penalty**, $r_{length}$, into our reward function. The modified reward is: \n  $$\n  r=r_{format}+(r_{selection}+r_{execution})*r_{length}\n  $$\n\n  $$\n  r_{\\text{length}} =\n    \\begin{cases}\n    1, & r_{selection}+r_{execution}<=0 \\newline\n    \\text{clip}(\\alpha*(n_{max}-n_{y}),0,1), & r_{selection}+r_{execution}> 0\n    \\end{cases}\n  $$\n\n  where, $n_y$ is the number of tokens generated during rollout, and $n_{max}$ is a hyperparameter that sets the desired maximum token limit. By adjusting $n_{max}$ during training, we can explicitly guide the model to produce reasoning chains of varying lengths.\n\n  The results on CypherBench for models trained with different $n_{max}$ values are below:\n\n  | Methods                   | Inference Tokens | EX(%) | PSJS (%) | Exec. (%) |\n  | ------------------------- | :--------------: | :---: | :------: | --------- |\n  | Qwen2.5-Coder-7B          |        53        | 13.12 |  22.65   | 62.95     |\n  | Cypher_RI($n_{max}=256$)  |       223        | 45.78 |  49.65   | 91.93     |\n  | Cypher_RI($n_{max}=512$)  |       436        | 60.78 |  64.29   | 96.93     |\n  | Cypher_RI($n_{max}=1024$) |       901        | 66.99 |  71.73   | 98.93     |\n  | Cypher_RI($n_{max}=1280$) |       1045       | 67.46 |  74.39   | 99.11     |\n  | Cypher_RI(w/o $n_{max}$)  |       1482       | 69.59 |  75.21   | 99.28     |\n\n  As we increase the allowed inference tokens, the model's performance improves across all metrics. However, the gains exhibit **diminishing returns**. For example, increasing the token count from 223 to 436 yields a **15%** absolute gain in Execution Accuracy (EX), while increasing from 1045 to 1482 tokens yields only a **2.13%** gain. This analysis shows that our model can be adapted to control inference costs. By incorporating a length-based reward, we can choose a balance between performance and computational budget.\n\n- W2: Comparison with Additional Reasoning Models.\n\n  Per the reviewer's suggestion, we have benchmarked our model against a wider array of reasoning language models. The results on CypherBench are as follows:\n\n  | Methods        | EX(%) | PSJS (%) | Exec. (%) |\n  | -------------- | :---: | :------: | :-------: |\n  | Qwen3-8B       | 48.72 |  66.49   |   81.26   |\n  | Qwen3-32B      | 58.56 |  81.23   |   80.75   |\n  | DeepSeek-R1    | 60.01 |  73.52   |   96.68   |\n  | o3-mini        | 62.39 |  74.73   |   98.00   |\n  | Gemini 2.5-pro | 74.14 |  81.70   |   99.45   |\n  | Cypher-RI      | 69.59 |  75.21   |   99.28   |\n\n  These experiments further strengthen our paper's claims. Our model significantly outperforms much larger models, including the Qwen3-32B and DeepSeek-R1. \n\n  References:\n\n  [1] L1: Controlling How Long A Reasoning Model Thinks With Reinforcement Learning\n\n  [2] AdaptThink: Reasoning Models Can Learn When to Think\n\n  [3] Learn to Reason Efficiently with Adaptive Length-based Reward Shaping"}, {"review_id": "59139atFFs", "reviewer": "Reviewer_9WgR", "summary": "The paper targets the Text-to-Cypher task over property-graph databases. It proposes Cypher-RI, a framework that (i) interleaves schema selection steps with reasoning tokens inside the generation trace, and (ii) trains a 7 B-parameter code LLM (Qwen-2.5-Coder) end-to-end with Group-Relative Policy Optimisation (GRPO) plus a simple rule-based reward composed of format, schema-selection, and execution components. Empirical results show superior performance compared to GPT4o on CypherBench and compatible performance on Neo4j-Text2Cypher.", "questions": "N/A", "limitations": "N/A", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 4, "clarity": 4, "significance": 2, "originality": 2, "strengths_and_weaknesses": "Pros:\nIntegrating schema selection as learned intermediate actions, rather than separate pre- or post-processing, is a neat idea.\nBeating GPT-4o with a 7 B open model shows the training recipe is competitive.\nPaper provides data splits, implementation hyper-parameters, and claims open-sourcing code.\nRoll-out template (Table 1) and Figure 1 make the pipeline easy to follow.\n\nCons:\nThe work seems to lack technical contribution. The GRPO algorithms and RL paradigm have been popular these days. The paper didn't make much contribution to the algorithm. Though the results are good, the paper is more or less like a direct application of GRPO to the domain specific problem.", "was_revised": true, "final_justification": "I will increase my score because of the additional experiments on other datasets to show the effectiveness.", "rebuttal": "We sincerely thank the reviewer for their valuable feedback and for acknowledging the strengths of our work. We wish to address the main concern regarding the technical contribution and originality, and provide new experimental results that further underscore the significance and generality of our method.\n\nThe reviewer suggests our work is \"more or less like a direct application of GRPO to the domain specific problem.\" We respectfully argue that this perspective undervalues two key aspects of our contribution: (1) the significance of the problem itself and our novelty in addressing it, and (2) the generalizability of our proposed framework, which we demonstrate with new experiments.\n\n**1.The Importance and Novelty of the Text-to-Cypher Challenge**\n\nWhile the RL algorithm (GRPO) is not our invention, our primary contribution lies in designing a novel framework, Cypher-RI, that is the first to successfully leverage reinforcement learning to holistically solve the Text-to-Cypher task by unifying reasoning and schema selection.\n\nGraph databases are increasingly central to modern data infrastructure, yet their potential is capped by the complexity of query languages like Cypher. Automating the translation from natural language to Cypher is a critical bottleneck that, if solved effectively, unlocks vast capabilities for a broader, non-technical audience. The value and difficulty of this domain should not be understated. \n\nPrior to our work, the prevailing methods relied on supervised fine-tuning or few-shot prompting. These approaches often struggle with complex queries and lack robustness. \n\nCypher-RI is the first framework to demonstrate that reinforcement learning can effectively benefit Cypher generation without requiring supervised reasoning traces. Moreover, it integrates the crucial component of schema selection as an explicit reasoning step within the RL process. This is a significant methodological shift for the Text-to-Cypher domain. The \"application\" itself—designing the specific reasoning trace, reward function, and training pipeline that makes this possible is the core technical innovation.\n\n**2.New Experiments to Demonstrate Practicality and Broader Applicability**\n\n**Practical Usability and Inference Efficiency**\n\nWe benchmarked Cypher-RI's inference latency against the GPT-4o API. \n\n| Methods       | Inference Time |\n| ------------- | :------------: |\n| GPT-4o        |      2.79      |\n| **Cypher-RI** |    **0.61**    |\n\nOur locally-deployed 7B model is approximately **4.5 times faster** than the GPT-4o API. This result highlights that Cypher-RI offers a state-of-the-art solution that is highly practical for real-world deployment due to its lower latency and computational cost.\n\n**Zero-Shot Generalization to a New Graph Query Language**\n\nWe tested our Cypher-trained model on a public Gremlin dataset to assess its ability to generalize to an unseen graph query language without any fine-tuning.\n\n| Methods                 | EX(%) |\n| ----------------------- | :---: |\n| Qwen2.5-Coder-7B        | 60.73 |\n| Text2Cypher-Gemma-3-27B | 70.09 |\n| Qwen3-32B               | 73.41 |\n| GPT-4o                  | 80.06 |\n| Gemini 2.5-pro          | 88.82 |\n| Cypher-RI               | 77.79 |\n\nRemarkably, Cypher-RI improves performance on Gremlin by **17%** over its base model and **7.7%** over a 27B model fine-tuned for Text-to-Cypher. This indicates that our training method helps the model learn underlying graph logic that partially transfers across languages, proving our approach teaches more than just syntactic memorization.\n\n**Expanding the Methodology to Text-to-SQL Generation**\n\nTo prove that our core idea—explicitly integrating schema selection within an RL framework—is a portable principle, we applied it to the Text-to-SQL domain. We adapted the existing SQL-R1 framework by incorporating a schema selection step and a corresponding reward component ($S_c$), while keeping all other experimental conditions identical.\n\nThe reward function in SQL-R1 is:\n$$\nS=S_f+S_e+S_r+S_l\n$$\nwhere the components represent rewards for format $S_f$, execution $S_e$, result correctness $S_r$, and query length $S_l$.\n\nThe modified reward function is: \n$$\nS=S_f+S_e+S_r+S_l+S_c\n$$\nwhere the new schema selection reward $S_c$ is:\n$$\nS_c =\n\\begin{cases}\n3, & \\text{if schema selection result is correct} \\newline\n0, & \\text{if json format of selected schema is incorrect} \\newline\n-3, & \\text{if schema selection result is incorrect} \n\\end{cases}\n$$\nWe evaluated this enhanced framework on the Spider and BIRD benchmarks.\n\n| Methods  |    Base Model    | Spider(Dev) | Spider(Test) | BIRD(Dev) |\n| -------- | :--------------: | :---------: | :----------: | --------- |\n| OmniSQL  | Qwen2.5-Coder-7B |    85.5     |     88.9     | 66.1      |\n| DAIL-SQL |      GPT-4       |    83.6     |     86.2     | 54.8      |\n| MAC-SQL  |      GPT-4       |    86.8     |     82.8     | 59.4      |\n| SQL-R1   | Qwen2.5-Coder-7B |    84.5     |     86.1     | 63.1      |\n| **Ours** | Qwen2.5-Coder-7B |  **87.1**   |   **86.8**   | **65.4**  |\n\nOur approach yields consistent improvements, with a **2.6-point gain on Spider (Dev)** and a **2.3-point gain on BIRD (Dev)**. These results confirm that explicitly rewarding schema selection within an RL loop is a **robust and portable methodology** that enhances performance in other major Text-to-Query systems.\n\nIn summary, we introduce the first RL-based framework for the important Text-to-Cypher task, achieving SOTA performance with a practical, efficient model. Furthermore, our new experiments demonstrate that the core principle of our work is not a narrow, domain-specific trick, but a generalizable methodology that improves performance on other query languages and database types."}, {"review_id": "RHtDxufhge", "reviewer": "Reviewer_YGjX", "summary": "This paper introduces Cypher-RI, a reinforcement learning framework that integrates schema selection into the Text-to-Cypher generation process. The method trains a 7B-parameter model from scratch using a custom rollout format and GRPO optimization, enabling explicit schema selection steps without annotated reasoning traces. Experiments on CypherBench and Neo4j-Text2Cypher show strong improvements over multiple baselines, including a 9.4% Execution Accuracy gain over GPT-4o. The paper is well-written, technically sound, and offers a practical contribution for robust natural language to graph query translation.", "questions": "1. Why did you choose Gemini-1.5-Pro instead of Gemini-2.5 series?\n2. Can you report schema selection accuracy separately?\n3. How fast is inference compared to GPT-4o?", "limitations": "See above", "rating": 4, "confidence": 2, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "**Strengths:**  \n1. **Novel integration** of schema selection as an explicit reasoning step within RL-based text-to-Cypher generation.  \n2. **Strong empirical gains** over strong baselines (e.g., GPT-4o) on multiple benchmarks.  \n3. **Clear training design** with open-sourced code and detailed rollout/reward structure for reproducibility.\n\n**Weaknesses:**  \n1. **Reward design is fairly simple and rule-based**, which may limit flexibility or generalization.  \n2. **Relies on existing RL techniques** without introducing major new algorithmic components.  \n3. **Scope limited to Cypher**, with no evaluation on other graph query languages like Gremlin or PGQL.", "was_revised": true, "final_justification": "The author has partially addressed my concerns, especially regarding the improvements in the experiments. I will raise my score.", "rebuttal": "We sincerely thank the reviewer for their insightful feedback and positive evaluation of our work. Below, we address the questions and weaknesses raised.\n\n- Q1: Experiments on Reasoning Models\n\n  Our primary experiments were completed prior to the official release of the Gemini-2.5 series. We have now benchmarked our model against a suite of more powerful reasoning models on CypherBench.\n  \n  | Methods        | EX(%) | PSJS (%) | Exec. (%) |\n  | -------------- | :---: | :------: | :-------: |\n  | Qwen3-8B       | 48.72 |  66.49   |   81.26   |\n  | Qwen3-32B      | 58.56 |  81.23   |   80.75   |\n  | DeepSeek-R1    | 60.01 |  73.52   |   96.68   |\n  | o3-mini        | 62.39 |  74.73   |   98.00   |\n  | Gemini 2.5-pro | 74.14 |  81.70   |   99.45   |\n  | Cypher-RI      | 69.59 |  75.21   |   99.28   |\n  \n  Our 7B Cypher-RI model significantly outperforms much larger models, including the Qwen3-32B and DeepSeek-R1.\n  \n- Q2: Accuracy of Schema Selection.\n  \n  The accuracy of the initial schema selection step is a critical component of our model's success. The following table reports this accuracy on both benchmarks.\n  \n  |     Methods      | CypherBench | Neo4j-Text2Cypher |\n  | :--------------: | :---------: | :---------------: |\n  | Qwen2.5-Coder-7B |    76.45    |       73.98       |\n  |  **Cypher-RI**   |  **95.87**  |     **93.87**     |\n  \n\n  Our Cypher-RI framework boosts schema selection accuracy by a remarkable **~20 percentage points** over the base model. This confirms that the model effectively learns to identify the correct schema elements.\n\n\n- Q3: Comparison of inference time.\n\n  To assess practical usability, we benchmarked the inference latency of Cypher-RI against the GPT-4o API. Cypher-RI was deployed on a single NVIDIA A800 GPU using the vLLM inference server. The results below show the average time to process one question.\n\n  | Methods       | Inference Time |\n  | ------------- | :------------: |\n  | GPT-4o        |      2.79      |\n  | **Cypher-RI** |    **0.61**    |\n\n  Our locally-deployed 7B model is approximately **4.5 times faster** than the GPT-4o API, offering state-of-the-art accuracy with significantly lower latency and computational cost, making it a highly practical solution.\n\n- W1: Discussions about Reward design\n\n  Our choice of a simple, rule-based reward function was a deliberate one, aimed at ensuring stable learning and preventing **reward hacking**. In complex generation tasks, learned or overly intricate reward functions can sometimes be exploited by the model to maximize the reward signal without actually improving performance on the intended task. A clear, rule-based function directly incentivizes the desired behaviors—correct format, valid schema selection, and accurate query execution—which is crucial for effective and targeted learning in an RL framework.\n\n  Furthermore, our framework is not limited by this initial design; it is inherently **flexible** and can be generalized to incorporate other objectives. We have conducted a new experiment introducing a **length-based penalty** into our reward function to explore the trade-off between performance and inference cost. The modified reward is:\n  $$\n  r=r_{format}+(r_{selection}+r_{execution})*r_{length}\n  $$\n  \n  $$\n  r_{\\text{length}} =\n    \\begin{cases}\n    1, & r_{selection}+r_{execution}<=0 \\\\\n    \\text{clip}(\\alpha*(n_{max}-n_{y}),0,1), & r_{selection}+r_{execution}> 0\n    \\end{cases}\n  $$\n  Here, $n_y$ is the number of tokens generated, and $n_{max}$ is a hyperparameter setting the desired token limit. This allows us to explicitly guide the model to produce reasoning chains of varying lengths.\n\n  The results on CypherBench for models trained with different $n_{max}$ values are below:\n\n  | Methods                   | Inference Tokens | EX(%) | PSJS (%) | Exec. (%) |\n  | ------------------------- | :--------------: | :---: | :------: | --------- |\n  | Qwen2.5-Coder-7B          |        53        | 13.12 |  22.65   | 62.95     |\n  | Cypher_RI($n_{max}=256$)  |       223        | 45.78 |  49.65   | 91.93     |\n  | Cypher_RI($n_{max}=512$)  |       436        | 60.78 |  64.29   | 96.93     |\n  | Cypher_RI($n_{max}=1024$) |       901        | 66.99 |  71.73   | 98.93     |\n  | Cypher_RI($n_{max}=1280$) |       1045       | 67.46 |  74.39   | 99.11     |\n  | Cypher_RI(w/o $n_{max}$)  |       1482       | 69.59 |  75.21   | 99.28     |\n\n  By incorporating the length-related reward term $r_{length}$ and adjusting the parameter $n_{max}$, we can effectively control the model’s output length. This demonstrates that, although simple, our reward design is not rigid; rather, it is modular and **extensible**, enabling the integration of additional objectives such as computational efficiency or domain-specific constraints.\n\n- W2: Relies on Existing RL Technique\n\n  We agree with the reviewer that our work employs an established RL algorithm (GRPO) as its optimization engine. We believe this is a strength, as it grounds our method in a proven, stable technique.\n\n  Our core contribution is not a new RL algorithm, but rather a novel framework for the Text-to-Cypher task. The originality lies in formulating schema selection as an explicit, learnable step within the model's reasoning process. We designed a custom training template, rollout mechanism, and reward function specifically to enable the model to learn this complex, multi-stage task without direct supervision on reasoning traces. \n\n  The effectiveness of our approach is demonstrated by strong empirical performance, including outperformance of significantly larger models. This validates the originality and impact of our formulation. Additionally, to highlight the generality of our methodology beyond graph databases, we successfully apply our framework to the Text-to-SQL task, as elaborated in our response to Reviewer W3.\n\n- W3: Expand scope of our method\n\n  To demonstrate the broader applicability of our work, we have conducted two new sets of experiments.\n\n  **1. Generalization to a New Graph Query Language (Gremlin)**\n\n  We evaluated our Cypher-trained model on a public Gremlin dataset [1] to test its zero-shot, cross-language generalization. The model was not fine-tuned on Gremlin.\n  | Methods                 | EX(%) |\n  | ----------------------- | :---: |\n  | Qwen2.5-Coder-7B        | 60.73 |\n  | Text2Cypher-Gemma-3-27B | 70.09 |\n  | Qwen3-32B               | 73.41 |\n  | GPT-4o                  | 80.06 |\n  | Gemini 2.5-pro          | 88.82 |\n  | Cypher-RI               | 77.79 |\n\n  Remarkably, our model, despite being trained only on Cypher data, improves performance on Gremlin by **17%** over its base model and **7.7%** over a 27B model fine-tuned for Text-to-Cypher. This indicates that our training method helps the model learn underlying graph logic that partially transfers to other query languages.\n\n  **2.Expand Schema Selection to SQL Generation**\n\n  To validate the generalizability of our proposed methodology, we extended its application from graph databases to the Text-to-SQL domain. This involved integrating our core concept—an explicit schema selection stage within a RL framework—into an existing Text-to-SQL pipeline.\n  \n  Our experiment builds upon the SQL-R1 [2] framework. In its original form, SQL-R1 employs an RL agent optimized with the following composite reward function:\n  $$\n  S=S_f+S_e+S_r+S_l\n  $$\n\t$$\n  S_r =\n  \\begin{cases}\n  3, & \\text{if query result is correct} \\newline\n  0, & \\text{if format is incorrect or SQL candidate is not executable} \\newline\n  -3, & \\text{if query result is incorrect}\n  \\end{cases}\n\t$$\n\n  where the components represent rewards for format $S_f$, execution $S_e$, result correctness $S_r$, and query length $S_l$.\n\n  To integrate schema selection into the training process, we modified the prompt to require the model to perform schema selection before generating the SQL query, similar to our Cypher-RI approach. Consequently, we introduced a new reward function:\n\t$$\n  S=S_f+S_e+S_r+S_l+S_c\n\t$$\n\n\t$$\n  S_c =\n  \\begin{cases}\n  3, & \\text{if schema selection result is correct} \\newline\n  0, & \\text{if json format of selected schema is incorrect} \\newline\n  -3, & \\text{if schema selection result is incorrect} \n  \\end{cases}\n\t$$\n  where $S_c$ is the new schema selection reward.\n  \n  For a controlled and fair comparison, we omitting the SFT step to isolate the performance gains attributable to our RL-based approach and strictly adhered to the experimental conditions of SQL-R1. \n  \n  We evaluated our enhanced framework on the Spider and BIRD benchmarks. The evaluation results are detailed in the table below.\n  \n  | Methods  |    Base Model    | Spider(Dev) | Spider(Test) | BIRD(Dev) |\n  | -------- | :--------------: | :---------: | :----------: | --------- |\n  | OmniSQL  | Qwen2.5-Coder-7B |    85.5     |     88.9     | 66.1      |\n  | DAIL-SQL |      GPT-4       |    83.6     |     86.2     | 54.8      |\n  | MAC-SQL  |      GPT-4       |    86.8     |     82.8     | 59.4      |\n  | SQL-R1   | Qwen2.5-Coder-7B |    84.5     |     86.1     | 63.1      |\n  | **Ours** | Qwen2.5-Coder-7B |  **87.1**   |   **86.8**   | **65.4**  |\n  \n  Our approach improves performance across the board, achieving a **2.6-point** gain on Spider (Dev) and a **2.3-point** gain on BIRD (Dev).\n  \n  These experiments confirm that our central idea—explicitly integrating schema selection within an RL framework—is a portable principle that enhances performance beyond just Cypher. It is a robust methodology applicable to a wider range of Text-to-Query systems.\n\nReferences:\n\n[1] numb3r33/know_gremlin dataset in huggingface\n\n[2] SQL-R1: Training Natural Language to SQL Reasoning Model By Reinforcement Learning"}, {"review_id": "EzMGbAJSgR", "reviewer": "Reviewer_YjPt", "summary": "This paper proposed Cypher-RI, a framework that improves the schema selection for the cypher generation pipeline. Cypher-RI addresses these challenges by conceptualizing schema selection as an important element of the reasoning process. More specifically, without supervision on intermediate steps, the authors trained a 7B parameter LLM (Qwen2.5-Coder-7B) to both select relevant schema elements and generate executable Cypher queries via GRPO. Experimental results on CypherBench and Neo4j-Text2Cypher proved the effectiveness of the framework, and showed 9.41% accuracy improvement over GPT-4o on CypherBench.", "questions": "- How is the reward designed? Do we have any ablation on those values?\n- What are the sample sizes that are used in SFT, RL(w/o schema selection), and Cypher-RI in the ablation study? Are the sample sizes significantly different for these methods?", "limitations": "yes", "rating": 5, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "## Strengths\n- First framework by leveraging RL to optimize the reasoning process for Text-to-Cypher. The method does not rely on the intermediate reasoning steps annotations. \n- The proposed method consistently outperforms the baselines and even outperforming GPT-4o.\n\n## Weaknesses\n- I believe that the schema selection/linking is an important component for many languages besides Cypher, such as SQL queries. The limited impact of paper would have be strengthened if more diverse programming languages can be experimented. \n- I observe that the performance on Neo4J-Text2Cypher is quite low (30.61%). This is be a generalization problem since the model is trained on CypherBench. It is important to have the ablation study on Neo4J-Text2Cypher, to see what's the performance of SFT and RL(w/o schema selection). However, this critial ablation study is missing.", "was_revised": true, "final_justification": "1. The experiments are expanded to text-to-SQL, showing better impact than the previous version.\n2. sample size question is answered.", "rebuttal": "We sincerely thank the reviewer for their thorough evaluation and constructive feedback. The suggestions have been invaluable in helping us strengthen our work. In the following sections, we address each of the reviewer's points in detail, providing clarifications and new experimental results to support our claims and demonstrate the effectiveness of our method.\n\n- Q1: Reward Function Design and Ablation.\n\n  Our reward function is central to the reinforcement learning process, providing essential supervision signals where explicit intermediate annotations are unavailable. The function is designed to guide the model through the key stages of the Text-to-Cypher task by decomposing the total reward into three distinct components.\n\n  The total reward is the sum of three parts: $r_{format}$,  $r_{selection}$ and $r_{execution}$. \n  \n  **Format Reward**: This reward encourages the model to generate its reasoning (thought process) before providing the final Cypher query. This \"think first, answer later\" structure improves the model's logical flow and interpretability. \n  $$\n  r_{format} =\n  \\begin{cases}\n  a, & \\text{if the format is correct} \\newline\n  -a, & \\text{if the format is incorrect} \n  \\end{cases}\n  $$\n  **Schema Selection Reward**: This reward is crucial for the core task of identifying the question related schema. It guides the model to select the right nodes, relationships, and properties needed to construct the query. \n  \n  $$\n  r_{selection} =\n    \\begin{cases}\n    2.0, & \\text{if the selected schema matches the gold answer} \\newline\n    b, & \\text{if the selected schema does not match the gold answer} \\newline\n    -2.0, & \\text{if the selected schema is unparseable}\n    \\end{cases}\n  $$\n  \n  **Execution Reward**: This is the ultimate measure of success. The reward is based on whether the final generated Cypher query executes and produces the same result as the ground truth query. \n  $$\n  r_{execution} =\n    \\begin{cases}\n    2.0, & \\text{if the generated Cypher executes consistently with the gold answer} \\newline\n    b, & \\text{if the generated Cypher executes inconsistently with the gold answer} \\newline\n    -2.0, & \\text{if the generated Cypher fails to execute}\n    \\end{cases}\n  $$\n  \n  To determine the optimal values for the hyperparameters $a$ and $b$, we conducted the following ablation studies.\n  \n  **1.Determining the Value of a**\n  \n  Our hypothesis was that the format reward ($a$) should be substantial enough to enforce the desired output structure but smaller than the primary task rewards for selection and execution (which have a magnitude of 2.0). A value that is too high might cause the model to prioritize formatting over correctness. We tested values of $a\\in\\{0.5,1.0,2.0\\}$.\n  \n  | Methods                 |   EX(%)   | PSJS (%)  | Exec. (%) |\n  | ----------------------- | :-------: | :-------: | --------- |\n  | Cypher_RI( $a=0.5$)     |   69.04   |   74.62   | 99.04     |\n  | Cypher_RI( $a=2.0$)     |   68.36   |   74.35   | 98.74     |\n  | **Cypher_RI( $a=1.0$)** | **69.59** | **75.21** | **99.28** |\n  \n  The results confirm our hypothesis. Setting $a=1.0$ achieves the best performance across all metrics, striking the right balance between enforcing structure and prioritizing query correctness.\n  \n  **1.Determining the Value of b**\n  \n  Next, we investigated the appropriate penalty ($b$) for outputs that are syntactically valid but semantically incorrect (i.e., a parseable schema that is wrong, or an executable query that returns the wrong result). We theorized that a moderate penalty would be more effective than a penalty that is too lenient or too harsh. A moderate penalty discourages incorrect solutions while still recognizing that a syntactically valid attempt is better than a complete failure. We tested values of $b\\in\\{−1.0,−1.5,−2.0\\}$.\n  \n  | Methods                  |   EX(%)   | PSJS (%)  | Exec. (%) |\n  | ------------------------ | :-------: | :-------: | --------- |\n  | Cypher_RI( $b=-1.0$)     |   68.02   |   74.10   | 98.43     |\n  | Cypher_RI( $b=-2.0$)     |   65.72   |   72.83   | 98.05     |\n  | **Cypher_RI( $b=-1.5$)** | **69.59** | **75.21** | **99.28** |\n  \n  The experiment demonstrates that setting $b=−1.5$ yields the best performance. A lenient penalty of −1.0 is insufficient, while a harsh penalty of −2.0 (the same as for a complete failure) is detrimental. This result supports our strategy of providing a nuanced, moderate penalty for partially correct attempts.\n\n\n- Q2: Discussion Sample Sizes of Training.\n\n  To ensure a fair comparison in our main experiments,  the sample size is **identical** for all methods: SFT, RL and our Cypher-RI. We used a dataset of 8,295 samples.\n\n  This dataset was curated through a careful process to enhance training efficiency for RL: For each question in the source dataset, we used Qwen-2.5-Coder-7B to generate 8 candidate Cypher queries with schema selection. We then filtered these generations, keeping only those prompts where the 8 attempts were either all correct (mean accuracy = 1.0) or all incorrect (mean accuracy = 0.0).\n\n  Inspired by the reviewer's question, we further investigated how performance scales with data size. We trained all three models on subsets of 2k, 4k, and our full ~8k dataset.\n\n  | Methods                     | EX(%) | PSJS (%) | Exec. (%) |\n  | --------------------------- | :---: | :------: | :-------: |\n  | SFT-2k                      | 36.43 |  39.27   |   87.22   |\n  | SFT-4k                      | 40.84 |  44.53   |   91.78   |\n  | SFT-8k                      | 44.34 |  49.80   |   94.34   |\n  | RL(w/o schema selection)-2k | 49.19 |  53.92   |   89.82   |\n  | RL(w/o schema selection)-4k | 55.20 |  60.03   |   93.38   |\n  | RL(w/o schema selection)-8k | 58.35 |  64.55   |   96.12   |\n  | Cypher-RI-2k                | 58.73 |  65.21   |   93.78   |\n  | Cypher-RI-4k                | 65.20 |  70.29   |   97.74   |\n  | Cypher-RI-8k                | 69.59 |  75.21   |   99.28   |\n\n  The results show that all methods improve as the number of training samples increases, though the gains are not substantial. We think this phenomenon might be related to the limited diversity and complexity of the training data, and improving these aspects could be a valuable direction for future work.\n\n- W1: Integrating schema selection into SQL Generation.\n\n  To prove that our core idea—explicitly integrating schema selection within an RL framework—is an important component for many query languages, we applied it to the Text-to-SQL domain. We adapted the existing SQL-R1 [1] framework by incorporating a schema selection step and a corresponding reward component ($S_c$), while keeping all other experimental conditions identical.\n\n  The reward function in SQL-R1 is:\n  $$\n  S=S_f+S_e+S_r+S_l\n  $$\n  where the components represent rewards for format $S_f$, execution $S_e$, result correctness $S_r$, and query length $S_l$.\n\n  The modified reward function is: \n  $$\n  S=S_f+S_e+S_r+S_l+S_c\n  $$\n  where the new schema selection reward $S_c$ is:\n  $$\n  S_c =\n  \\begin{cases}\n  3, & \\text{if schema selection result is correct} \\newline\n  0, & \\text{if json format of selected schema is incorrect} \\newline\n  -3, & \\text{if schema selection result is incorrect} \n  \\end{cases}\n  $$\n  We evaluated this enhanced framework on the Spider and BIRD benchmarks.\n\n  | Methods  |    Base Model    | Spider(Dev) | Spider(Test) | BIRD(Dev) |\n  | -------- | :--------------: | :---------: | :----------: | --------- |\n  | OmniSQL  | Qwen2.5-Coder-7B |    85.5     |     88.9     | 66.1      |\n  | DAIL-SQL |      GPT-4       |    83.6     |     86.2     | 54.8      |\n  | MAC-SQL  |      GPT-4       |    86.8     |     82.8     | 59.4      |\n  | SQL-R1   | Qwen2.5-Coder-7B |    84.5     |     86.1     | 63.1      |\n  | **Ours** | Qwen2.5-Coder-7B |  **87.1**   |   **86.8**   | **65.4**  |\n\n  Our approach yields consistent improvements, with a **2.6-point gain on Spider (Dev)** and a **2.3-point gain on BIRD (Dev)**. These results confirm that explicitly rewarding schema selection within an RL loop is a **robust and portable methodology** that enhances performance in other major Text-to-Query systems.\n\n  In summary, we introduce the first RL-based framework for the important Text-to-Cypher task, achieving SOTA performance with a practical, efficient model. Furthermore, our new experiments demonstrate that the core principle of our work is not a narrow, domain-specific trick, but a generalizable methodology that improves performance on other query languages and database types.\n\n- W2: Ablation study on Neo4J-Text2Cypher dataset.\n\n  For this new experiment, we trained SFT, RL(w/o schema selection), and Cypher-RI on a 4k-sample subset of the Neo4J-Text2Cypher training set.\n\n  | Methods                  |   EX(%)   | Google-BLEU (%) |\n  | ------------------------ | :-------: | :-------------: |\n  | SFT                      |   26.32   |      49.58      |\n  | RL(w/o schema selection) |   30.81   |      63.29      |\n  | **Cypher-RI**            | **38.58** |    **65.73**    |\n\n  The results clearly confirm the robustness of our method. Cypher-RI achieves an EX score of **38.58%**, which is a significant improvement of **~7.8 points** over RL(w/o schema selection) and **~12.3 points** over SFT. This demonstrates that the framework of Cypher-RI provides a generalization advantage.\n\nReferences:\n\n[1] SQL-R1: Training Natural Language to SQL Reasoning Model By Reinforcement Learning"}]

Author rebuttal:

Meta-review: This paper proposes Cypher-RI, a reinforcement learning framework that integrates schema selection directly into the query generation pipeline as part of the reasoning process. It uses reasoning tokens and recursive schema grounding during generation. The authors trained a 7B parameter model with GRPO and rule-based rewards (format, schema, execution) to achieve strong performance.
The paper is technically sound with good empirical results, and the method seems easy to reproduce. Weakness-wise, the paper has limited algorithmic novelty, a relatively narrow scope (only Cypher), and lacks some ablations.
Overall, the reviewers generally lean toward acceptance.
Decision: Accept (poster)