Multi-Agent GraphRAG: A Text-to-Cypher Framework for Labeled Property

Graphs
Anton Gusarov1, 2 , Anastasia Volkova2 , Valentin Khrulkov1 , Andrey Kuznetsov1, 2, 3 ,
Evgenii Maslov1, 2 , Ivan Oseledets1, 2
1
AIRI, 2 Skoltech, 3 Innopolis University
Corresponding author: gusarov@[Link]
Preprint

Abstract knowledge graphs, Labeled Property Graphs (LPGs) pro-

arXiv:2511.08274v1 [[Link]] 11 Nov 2025

vide a more expressive alternative supporting rich attributes

While Retrieval-Augmented Generation (RAG) methods on both nodes and edges, flexible schemas, and native com-
commonly draw information from unstructured documents,
patibility with declarative graph query languages such as
the emerging paradigm of GraphRAG aims to leverage
structured data such as knowledge graphs. Most existing Cypher.
GraphRAG efforts focus on Resource Description Frame- However, applying RAG methods to LPGs introduces
work (RDF) knowledge graphs, relying on triple representa- distinct challenges. Compared to RDF graphs with fixed
tions and SPARQL queries. However, the potential of Cypher ontologies and triple-based (subject-predicate-object) struc-
and Labeled Property Graph (LPG) databases to serve as tures, LPGs exhibit greater schema variability and require
scalable and effective reasoning engines within GraphRAG support for multi-hop traversal, typed relationships, and
pipelines remains underexplored in current research litera- attribute-level reasoning. These issues are amplified when
ture. To fill this gap, we propose Multi-Agent GraphRAG, a adapting RAG pipelines for structured querying tasks, where
modular LLM agentic system for text-to-Cypher query gen- the system must retrieve information by constructing cor-
eration serving as a natural language interface to LPG-based
rect and executable graph queries. Recent efforts have shown
graph data. Our proof-of-concept system features an LLM-
based workflow for automated Cypher queries generation and promise in structured generation, but primarily focus on tab-
execution, using Memgraph as the graph database backend. ular or RDF formats. In contrast, LLM-based querying over
Iterative content-aware correction and normalization, rein- full-schema LPGs remains underexplored .
forced by an aggregated feedback loop, ensures both seman- We address the gap in enabling natural language in-
tic and syntactic refinement of generated queries. We evaluate terfaces for Cypher-based question answering over prop-
our system on the CypherBench graph dataset covering sev- erty graphs, with a particular focus on high-impact do-
eral general domains with diverse types of queries. In addi- mains such as digital construction. Our approach centers
tion, we demonstrate performance of the proposed workflow on a multi-agent GraphRAG workflow that interprets user
on a property graph derived from the IFC (Industry Founda- queries, interacts with a graph database, and iteratively gen-
tion Classes) data, representing a digital twin of a building.
erates schema-compliant Cypher queries. As noted by (Han
This highlights how such an approach can bridge AI with
real-world applications at scale, enabling industrial digital au- et al. 2025), GraphRAG pipelines must manage diverse,
tomation use cases. interdependent, and domain-specific information with non-
transferable semantics. Building on this insight, we empha-
size explicit query entity verification, LLM-driven observa-
Introduction tion, and database-grounded feedback to support robust it-
Graph databases are NoSQL systems designed to manage erative query refinement. In this paper we introduce Multi-
graph-structured data, typically based on the property graph Agent GraphRAG, a system for natural language querying
model (Angles 2018). They are increasingly adopted across over property graphs. Our architecture includes query gen-
diverse domains from bioscience (Walsh, Mohamed, and eration, schema and query entity identifiers verification, exe-
Nováček 2020) to infrastructure (Donkers, Yang, and Baken cution, and feedback-driven refinement. We demonstrate its
2020) as a powerful abstraction for representing interlinked effectiveness on both benchmark (CypherBench (Feng, Pa-
entities with rich semantics, both in knowledge graphs and picchio, and Rahman 2025)) and domain-specific datasets,
in specialized domain-specific databases. In this work, we providing insights into its performance and limitations.
explore how large language models (LLMs) can serve as nat-
ural language interface to complex technical data encoded in
Labeled Property Graphs
property graphs. A property graph is a labeled directed multi-graph defined
Retrieval-Augmented Generation (RAG) has emerged as as a tuple (Angles et al. 2024):
a prominent strategy for grounding LLM outputs in struc- G = (N, E, ρ, λ, σ)
tured or semi-structured sources. While most RAG ap-
proaches rely on unstructured documents or RDF-based where:
– N is a finite set of nodes (vertices), bases. KBQA approaches typically fall into two main cate-
– E is a finite set of edges (relationships), disjoint from N , gories (Luo et al. 2024): (i) semantic parsing methods, which
convert natural language queries into executable logical
– ρ : E → (N × N ) is a total function that assigns to each
forms over the knowledge base, and (ii) information retrieval
edge its source and target nodes,
methods, which retrieve relevant subgraphs or facts to in-
– λ : (N ∪ E) → P+ (L) is a partial function assigning form the answer generation process (Jiang et al. 2024, 2023;
each node or edge a finite non-empty set of labels from Peng et al. 2024). The closely related concept of GraphRAG
an infinite label set L, extends IR-based KBQA by leveraging graph-structured re-
– σ : (N ∪ E) × P → P+ (V ) is a partial function assigning trieval mechanisms, effectively treating IR-based KBQA as
each property key from the infinite set P a finite non- a special case within a broader framework for structured in-
empty set of values from V . formation access (Han et al. 2025).
Here, P+ (X) denotes the set of all finite non-empty sub- Text-to-SQL Semantic Parsing. Natural language inter-
sets of a set X. faces (NLI) to relational databases continue to attract vast
A path π in a property graph G = (N, E, ρ, λ, σ) is a attention in applied AI research. The sketch-based approach
finite alternating sequence of nodes and edges: is one of the earliest methods of structured synthesis in gen-
π = (n1 , e1 , n2 , e2 , . . . , ek , nk+1 ) eral and of code in particular (Solar-Lezama 2009; Li et al.
2023b) that maps user queries to SQL by first predicting a
such that k ≥ 0, ni ∈ N , ei ∈ E, and for all 1 ≤ i ≤ k, high-level SQL pattern and then performing slot filling to
ρ(ei ) = (ni , ni+1 ). generate the complete query(Xu, Liu, and Song 2017; Yu
The length of π is k, the number of edge identifiers. A et al. 2018a).
path of length zero is simply a single node. The path label Seq2SQL (Zhong, Xiong, and Socher 2017) introduces a
λ(π) is the concatenation of the edge labels: λ(e1 ) . . . λ(ek ). sequence-to-sequence model with reinforcement learning to
generate SQL queries from natural language, and belongs to
Related Work the seq2seq (sequence-to-sequence) family of text-to-SQL
methods (Li et al. 2023a).
While the Cypher language (Francis et al. 2018) has become
Tree- or structure-based methods include bottom-up se-
the de-facto standard for querying property graphs in graph
mantic parsers that construct SQL queries from semantically
database systems like Neo4j and has significantly influenced
meaningful subtrees. A notable example is RAT-SQL (Wang
the ISO/IEC 39075:2024 GQL standard (ISO/IEC 2024),
et al. 2021) which introduces a relation-aware transformer
its application to LLM-backed graph reasoning and struc-
that models the question and schema as a relational graph,
tured knowledge extraction remains limited. In contrast, the
enabling effective schema linking and structured represen-
Resource Description Framework (RDF) and the SPARQL
tation learning for text-to-SQL parsing. SmBoP (Rubin and
query language have seen extensive adoption in semantic
Berant 2021) employs a chart-based bottom-up decoder to
reasoning tasks and integration with large language models.
generate SQL queries as compositional trees, coupled with
The existing literature on property graphs tends to em-
the RAT-SQL encoder to jointly encode the user utterance
phasize algorithmic and model-level approaches over query-
and database schema.
level execution and semantics.
SyntaxSQLNet (Yu et al. 2018b) introduces a syntax
GraphRAG. Retrieval augmented generation on graphs tree-based decoder that leverages SQL grammar to gener-
(GraphRAG) is a novel paradigm that extends conventional ate complex SQL queries, enabling generalization to unseen
retrieval-augmented generation (RAG) by incorporating ex- schemas and compositional structures. It belongs to the fam-
isting or generating on-the-go graph-structured data as a re- ily of grammar-based or syntax-constrained decoding meth-
trieval source for more accurate, interpretable, and multi- ods, which guide query generation using formal production
hop reasoning. Although research on GraphRAG has ex- rules to ensure syntactic correctness.
panded, it remains fragmented with a focus on knowl-
edge and document graphs limiting application in other do- LLM Multi-Agent Text-to-SQL. Recent studies adopt an
mains (Han et al. 2025). According to (Peng et al. 2024) agent-based approach to Text-to-SQL generation leveraging
GraphRAG can be split into three stages: graph-based index- modular design to split the task across multiple specialized
ing, graph-guided retrieval, and graph-enhanced generation. agents. Unlike monolithic models, this setup promotes task-
Together, they enable structured retrieval and response syn- specific delegation and inter-agent collaboration for scala-
thesis by transforming graph data into formats optimized for bility and coordination. One example is CHASE-SQL (Pour-
LLM-based generation. GraphRAG proposed in (Edge et al. reza et al. 2024) which harnesses multiple LLMs to generate
2025) combines RAG and query-focused summarization by diverse SQL candidates by decomposing complex queries,
using an LLM to build an entity-based graph index and gen- simulating execution plans via chain-of-thought reasoning,
erate community summaries, enabling scalable question an- and providing instance-specific few-shot examples, with
swering over large, private text corpora. a dedicated selection agent ranking outputs through pair-
wise comparison using a fine-tuned LLM. Mac-SQL (Wang
Knowledge Base Question Answering (KBQA). KBQA et al. 2025) framework features a central decomposer agent
represents a task of generating precise answers to natural for few-shot chain-of-thought Text-to-SQL generation, sup-
language queries by reasoning over structured knowledge ported by expandable auxiliary agents that dynamically as-
Figure 1: State diagram outlining the proposed Multi-Agent GraphRAG workflow for Cypher-based information retrieval on
property graphs.

sist with sub-database retrieval and SQL refinement. Alpha- to graph databases. However, this is based on the Chinese
SQL (Li et al. 2025) tackles the challenges of zero-shot Text- language OwnThink knowledge graph and not available
to-SQL by combining Monte Carlo Tree Search (MCTS) for direct download. (Feng, Papicchio, and Rahman 2025)
with an LLM-based action model and self-supervised re- present CypherBench, a benchmark for evaluating LLM-
ward. based question answering over full-schema property graphs
using Cypher, built on Wikidata-derived datasets with di-
Agent-Based Graph Reasoning. Several recent papers on verse query types aligned to realistic graph schemas. (Tiwari
iterative agent-based methods aimed at graph data. et al. 2025) introduce Auto-Cypher, a fully automated LLM-
The Graph Chain-of-Thought solution (Jin et al. 2024) supervised pipeline for generating and verifying synthetic
tackles the LLM graph reasoning problem with three-step Text2Cypher training data (SynthCypher) and introduces an
iterations: reasoning, interaction, and execution. adapted SPIDER-Cypher benchmark to address the lack of
Based on Graph-CoT ideas, (Gao et al. 2025) proposes a evaluation standards in this domain.
multi-agent GraphRAG approach addressing QA tasks with In comparison to prior work that primarily focus on static
cooperative agentic KG exploration and extraction strategies prompt-based Cypher generation or dataset construction for
search supported by a multi-perspective self-reflection mod- benchmarking, our approach introduces a modular multi-
ule that refines reasoning strategy. agent GraphRAG workflow that emphasizes iterative refine-
Text-to-Cypher. (Hornsteiner et al. 2024) develop a mod- ment, named entity verification, and aggregated semantic-
ular natural language interface for Neo4j using GPT-4 Turbo syntactic feedback. Crucially, our system integrates runtime
to perform Cypher query generation, database selection, interaction with the graph database to detect and correct
and error correction, employing the design science research both hallucinations and logical errors. In contrast to (Horn-
methodology and reporting high accuracy in few-shot sce- steiner et al. 2024), which targets Neo4j, we implement our
narios for practical Text-to-Cypher tasks on CLEVR graph workflow on Memgraph, demonstrating broader applicabil-
dataset (Mack and Jefferson 2018), representing a transport ity to LPG-compatible backends where runtime efficiency
transit network. is critical. Additionally, we test the system on industry-
(Chatterjee and Dethlefs 2022) present an automated QA grade use cases, specifically IFC-based digital building rep-
system for wind turbine maintenance that uses a semantic resentations, extending beyond general-purpose or synthetic
parser to convert natural language queries into Cypher for datasets into the AEC (Architecture, Engineering, and Con-
interactive decision-making support, and release a domain- struction) domain.
specific dataset of question-Cypher pairs for this purpose.
Quite a few question-to-Cypher datasets are publicly Implementation
available. SpCQL (Guo et al. 2022) introduces the first We propose an LLM workflow that adopts a modular agentic
large-scale Text-to-Cypher (Text-to-CQL) semantic pars- architecture with a feedback-driven refinement loop to over-
ing dataset containing 10,000 natural language and Cypher come the limitations of standalone LLMs in text-to-Cypher
query pairs over a Neo4j graph, highlighting the unique generation by leveraging their reasoning capabilities for it-
challenges of Cypher compared to SQL and exposing the erative improvement (Qu et al. 2024). Figure 1 provides an
limitations of existing Text-to-SQL models when applied overview of the system components and data flow.
 The implementation code along with the experimental re- queries to the database. For any entity not found, indicat-
sults is publicly available at: [Link] ing likely hallucination, the module initiates a two-step
recovery process. First, it retrieves candidate replace-
Agent Roles and Responsibilities. The workflow is com- ments based on the normalized Levenshtein similarity ra-
posed of seven cooperating agents and one graph database tio (Bachmann 2024). Second, it leverages an LLM to
query executor module, each specializing in a distinct sub- semantically rank all existing entities of the same type in
task. the database, selecting the most contextually appropriate
1. Query Generator formulates a Cypher query based on alternative.
the user question in natural language. The query should 6. Instructions Generator synthesizes revision instruc-
be both syntactically correct and semantically aligned tions based on the verification results targeting halluci-
with the user intent. The generation is grounded on the nated or misnamed entities. It takes as input the struc-
provided context graph schema to the model, including tured feedback from the Verification Module, including
node and pairwise relationship descriptions. In subse- which entities failed to match the data content. For each
quent iterations, if the first-shot generation was not ac- invalid component, it generates a correction proposal by
cepted, the agent takes aggregated feedback from the combining: (i) edit-based suggestions derived from high-
Evaluator and Verification agents to refine the previous similarity alternatives, and (ii) semantically grounded
revision of the Cypher query. recommendations ranked by the LLM. The output is a
2. Graph Database Executor interfaces with the underly- concise instruction to guide the Query Generator on how
ing graph database engine (Memgraph in our case) to ex- to revise the query.
ecute the generated Cypher query and retrieve the out- 7. Feedback Aggregator integrates the outputs of both the
come, which may consist of structured result data, an er- Query Evaluator and the Verification Module into a uni-
ror message, or an empty result set. The latter is com- fied correction strategy. It consolidates signals such as
mon when the Query Generator’s LLM incorrectly refer- semantic inconsistencies, execution errors, and naming
ences attribute names, often due to hallucinations or in- mismatches to produce structured and prioritized feed-
sufficient data in the graph schema. back. This aggregated feedback is the basis for guiding
3. Query Evaluator is responsible for assessing the seman- the subsequent correction of the query, ensuring that both
tic and logical adequacy of the generated Cypher query logical soundness and schema compliance are addressed.
relative to the user’s intent and the correctness of the 8. Accepted queries are passed to the Interpreter, which
query results. Functionally, it serves as an LLM-based finally generates a concise, domain-relevant natural lan-
critic (McAleese et al. 2024; Yang et al. 2025) within guage answer.
our pipeline. The evaluator is prompted to analyze three
key aspects: (1) consistency between the user’s intended Each agent in our pipeline is guided by a system prompt
semantics and its natural language explanation, (2) align- tailored to its role. The complete prompt templates are
ment of the query logic with the user question, and (3) va- provided in the public implementation: [Link]
lidity and informativeness of the returned results. Based your-repo.
on this assessment, it outputs both structured feedback Self-Correction Loop. The iterative schema-aware cor-
and a discrete query grade from the set: rection and normalization is a critical mechanism for boost-
• Accept: the query is error-free and the returned results ing query accuracy and semantic alignment. It operates over
fully and logically answer the user question. a maximum of four iterations, progressively improving the
Cypher query by incorporating feedback from both seman-
• Incorrect: the query executes without error and re-
tic validation and data-level verification. At each step, the
turns data, but is semantically misaligned, logically
system analyzes execution outcomes, detects logical flaws
flawed, or incomplete.
or schema mismatches, and generates targeted correction in-
• Error or Empty: the query either fails to execute due structions. The refinement loop is detailed in Algorithm 1.
to a runtime error or returns no results.
Incorporating Graph Schema into LLM Prompts. The
The last case commonly arises from misidentified named
LLM is data-informed such that the graph database schema
entities, overly restrictive conditions, or invalid traversal
is explicitly incorporated into the system prompt of the
paths in the graph often due to LLM hallucinations.
Query Generator agent. We experimentally observed that
4. Named Entity Extractor is an LLM-based component generation quality significantly improves when the schema
that identifies elements within the query such as node la- is presented in a format closely resembling actual Cypher
bels, property-value pairs, and relationship types that are query syntax, as this provides better structural grounding
susceptible to hallucination. Its primary function is to de- and improves token-level alignment with expected outputs.
compose the query to enable subsequent verification of For each node type, representative attribute–value exam-
their existence in the underlying graph data. ples are also provided to guide the generation of property-
5. Verification Module follows the Named Entity Extrac- based query conditions. Detailed listings of the node and
tor and for verifies the existence and correctness of the relationship schema used for the fictional character graph
extracted schema elements against the actual graph data. from the CypherBench dataset (Feng, Papicchio, and Rah-
This is done first programmatically via auxiliary Cypher man 2025) are included in Appendix A.
Figure 2: Single-storey Sample House IFC model (xBIM Team 2024), first utilized for GraphRAG-based information extraction
in (Iranmanesh, Saadany, and Vakaj 2025). Left: 3D representation of the building. Right: fragment illustrating the cross-
relations of IFC entities mapped into a labeled property graph, including spatial hierarchies, property sets, and quantitative
attributes.

Algorithm 1: Cypher query refinement with semantic vali- Experiments

dation and named entities verification
Experimental Setup
Input: User question Q, nodes and relationships schema S
Output: Valid Cypher query C and NL answer A Datasets. We evaluate our Multi-Agent RAG system on
a subset of the CypherBench benchmark (Feng, Papic-
1: C ← GenerateQuery(Q, S) chio, and Rahman 2025), a recently introduced dataset for
2: R ← ExecuteQuery(C) evaluating question answering over property graphs using
3: E ← EvaluateQuery(Q, C, R) Cypher. CypherBench includes realistic, large-scale knowl-
4: t ← 1 // iteration counter edge graphs extracted from Wikidata, each accompanied by
5: while Estatus ̸= Accept and t ≤ 4 do a set of natural language questions aligned with the underly-
ing schema and publicly available graph. From this suite, we
6: if Estatus = Illogic or Incomplete R then selected five diverse graphs: art, flight accident, company,
7: C ← GenerateQuery(Q, S, Ef eedback ) geography, and fictional character to assess the generaliza-
8: else if Estatus = Error or Empty then tion ability of our agentic pipeline across varied domains.
9: Eent ← ExtractNamedEntities(C)
For each graph, we randomly sampled 150 ques-
10: V ← VerifyNamedEntities(Eent , Graph)
tion–answer pairs to ensure a balanced evaluation across
11: // check existence and suggest replacements for:
domains. These graphs exhibit heterogeneous schemas and
12: – Node labels
for the geography graph, we additionally include our re-
13: – Node property values
processed schema in Appendix A to illustrate how structured
14: – Pairwise edge patterns
schema information was incorporated into the Query Gener-
15: I ← GenerateFixInstructions(V )
ator context. To the best of our knowledge, CypherBench
16: F ← AggregateFeedback(Q, Ef eedback , I)
is the only large-scale text-to-Cypher benchmark that offers
17: C ← GenerateQuery(Q, S, F )
fully public access to both multi-domain property graphs
18: end if
and text–to–Cypher question–query pairs at scale with 7.8
19: t←t+1
million entities and 11 subject domains.
20: R ← ExecuteQuery(C)
To evaluate the feasibility of our multi-agent GraphRAG
21: E ← EvaluateQuery(Q, C, R)
pipeline in real-world engineering scenarios, we additionally
22: end while
used a graph derived from the Industry Foundation Classes
23: A ← InterpretResult(Q, R)
(IFC) standard data widely adopted for building information
24: return A, C
modeling (BIM) (Vanlande, Nicolle, and Cruz 2008) in ar-
chitecture, engineering, and construction (AEC). IFC data,
due to its object-oriented structure and typed relationships,
Implementation Details. The proposed Multi-Agent naturally maps to a labeled property graph model, making it
GraphRAG system is implemented in Python 3.12 using well suited for Cypher-based reasoning for information in-
the LangGraph framework for agent orchestration and asyn- quiry.
chronous state management. The underlying graph database We use the publicly available single-storey house IFC
is Memgraph (Memgraph Ltd. 2025), an in-memory, with model (xBIM Team 2024) we refer to as the Sample House
C++ backed, open-sourced graph engine optimized for low- and its corresponding graph representation from the dataset
latency query execution. LLM agents are integrated via an introduced in (Iranmanesh, Saadany, and Vakaj 2025), which
API with OpenAI-compatible interface. includes 10 manually curated natural language questions of
 Gemini 2.5 Pro GPT-4o (2024-11-20) Qwen3 Coder GigaChat 2 MAX
Dataset
Single Agentic Single Agentic Single Agentic Single Agentic
art 55.70% 63.33% 55.03% 56.85% 32.00% 51.33% 30.67% 40.00%
flight accident 82.67% 92.00% 78.00% 86.67% 74.00% 76.00% 67.33% 75.33%
company 59.33% 68.46% 46.00% 48.00% 30.67% 31.33% 25.50% 38.26%
geography 68.00% 76.35% 54.00% 63.09% 47.33% 56.00% 45.33% 54.67%
fictional character 69.33% 86.01% 47.33% 59.68% 44.67% 52.38% 37.33% 47.95%
Average 67.00% 77.23% 56.07% 62.86% 45.73% 53.40% 41.23% 51.24%

Table 1: Accuracy comparison between linear-pass LLM baseline and our multi-agent text-to-Cypher generation system across
CypherBench domains and models.

varying structural complexity. This evaluation setup allows line across all models and domains in the experiment.
us to demonstrate the applicability of our method beyond On average, the proposed agentic workflow yields notice-
open-domain knowledge graphs and into structured engi- able improvements: on average +10.23% for Gemini 2.5
neering data contexts. A visualization of the sample building Pro, +6.79% for GPT-4o, +7.67% for Qwen3 Coder and
and IFC data structure is shown in Figure 2. +10.01% for GigaChat 2 MAX. The results indicate that in-
corporating iterative refinement, verification, and semantics-
Baseline and Models. We evaluate our proposed multi- syntax feedback aggregation enhances structured query gen-
agent Cypher generation pipeline against a baseline imple- eration capabilities in LLM-based information retrieval sys-
mented using four state-of-the-art LLM backbones: Gem- tems over the property graphs.
ini 2.5 Pro, GPT-4o (2024-11-20), GigaChat 2 MAX, and
Qwen3 Coder. Each model is tested under two configura- Sample IFC data. Table in Appendix C presents the re-
tions: (i) “Single”, a linear-pass baseline where only the sults of our workflow using Gemini 2.5 Pro on the architec-
Query Generator → Executor → Interpreter sequence per- tural Sample House IFC dataset, which contains ten ground-
forms the full answer generation task without iterative feed- truth question–answer pairs. Following the evaluation pro-
back but (up to four attempts also allowed); and (ii) “Agen- tocol of (Iranmanesh, Saadany, and Vakaj 2025), we re-
tic”, our Multi-Agent GraphRAG setup, in which the same port all questions and answers in full. Their method and
model drives the proposed multi-agent workflow with dis- results are used as the baseline for comparison. Compared
tinct roles for evaluation, verification, and iterative Cypher to (Iranmanesh, Saadany, and Vakaj 2025), our Multi-Agent
query refinement. GraphRAG system correctly answers the last three questions
(previously unanswered or answered partially) and shows
Evaluation Metrics. We report accuracy as the percent- the ability to express uncertainty (e.g., Question 2) and
age of correctly answered questions in natural language grounding responses on the graph database contents (e.g.,
form. Answer correctness is assessed using a reference- Questions 7 and 8).
based evaluation procedure, where a dedicated LLM com-
pares the generated natural language answer against the Discussion and limitations
given in a form of JSON database outcome ground truth.
In this section, we analyze the performance of the proposed
Following the LLM-as-a-judge framework (Tiwari et al.
workflow by tracing how its components process data, make
2025), we employ GigaChat 2 MAX as the evaluation model
decisions and refine Cypher query from iteration to iteration.
to judge semantic equivalence between the answers. This au-
Drawing on qualitative analysis of system traces (see exam-
tomated evaluation approach allows consistent and scalable
ple in Appendix B), we highlight factors contributing to suc-
evaluation across all tested models and domains. The prompt
cessful query generation and identify remaining limitations.
of a judge LLM apart from instructions contains few-shot
All experimental traces are publicly available together with
examples and available in the project’s repository.
the system’s code implementation.
The effectiveness of the Multi-Agent GraphRAG stems
Experimental Results from several key design components. First of all, schema
CypherBench dataset. Table 1 presents the accuracy re- validation and query names normalization play a crucial
sults following LLM-as-a-judge metric across five selected role. Database-grounded feedback enables correction of
CypherBench dataset domains for four foundation models structural errors such as misused relationship directions or
in both single-pass (without iterative refinement) and multi- types, while entity verification mitigates LLM hallucinations
agent settings. The final row reports the average perfor- by enforcing consistency with actual graph database con-
mance across all evaluated datasets. The pipeline was exe- tent. For example, when the system generates a query on
cuted once per dataset graph to obtain accuracy results, al- employees and their managers, database-informed feedback
lowing up to four refinement attempts per query. pushes correct relationship traversal (e.g., from employee to
According to these results, Multi-Agent GraphRAG manager via Reports to relationship), while entity veri-
pipeline consistently outperforms the linear-pass LLM base- fication ensures that department names or employee iden-
tifiers match actual entries via auxiliary database queries. structured querying. Furthermore, while previous systems
Together, they support multi-hop reasoning and allow the often rely on static schemas, our refinement loop dynami-
system to iteratively converge to schema-compliant and ex- cally interacts with the database through auxiliary Cypher
ecutable queries. queries, enabling more adaptive and context-aware correc-
The workflow also benefits from reformulating Cypher’s tion strategies.
strict comparisons into explicit value retrieval. Rather than These systems show promise as natural interfaces to com-
relying on binary equality checks that may yield empty plex domain-specific data. In our study, we demonstrated
or ambiguous results, returning relevant property values performance on IFC (Industry Foundation Classes) sample
for each entity allows it to infer the answer more trans- data – a widely adopted format for representing buildings
parently. For instance, when asked whether two characters in the AEC (Architecture, Engineering, and Construction)
share the same creator, the system first attempted a direct sector, highlighting the value of such pipelines for enabling
equality check ([Link] = [Link]), which simplified access to complex structured technical data.
returned nothing due to a mismatch. A subsequent refor- Future work includes extending this approach to multi-
mulation MATCH (c:Character) WHERE [Link] IN turn dialogue scenarios, incorporating explicit subgoal plan-
["Morbius, the Living Vampire", "Giganto"] ning for compositional queries, and developing larger
RETURN [Link], [Link] explicitly retrieves each domain-specific datasets, particularly for IFC-linked Cypher
character’s creator, avoiding empty results and making the queries, to support the adoption of AI-driven solutions in
comparison observable in the output. digital construction and operation.
Despite these strengths, several limitations remain, which
we outline below based on failure cases observed in the References
traces. One observed limitation is the difficulty in handling
compositional queries involving disjunctions (e.g., ”Who Angles, R. 2018. The Property Graph Database Model. In
are married to Cersei Lannister or have Cassana Baratheon Alberto Mendelzon Workshop on Foundations of Data Man-
as their mother?”, which requires the union of two struc- agement.
turally distinct subqueries) and symmetric relationships (e.g. Angles, R.; Bonifati, A.; Garcı́a, R.; and Vrgoč, D. 2024.
(:Character)-[:hasSpouse]-(other:Character), Path-based Algebraic Foundations of Graph Query Lan-
which can match from either side and therefore complicates guages. arXiv:2407.04823.
schema validation and query formulation) even with multi- Bachmann, M. 2024. RapidFuzz: Fuzzy String Matching for
step feedback. Addressing these cases may require explicit Python. [Link]
query planning or intermediate symbolic representations of Accessed: 2025-07-30.
query intent.
Chatterjee, J.; and Dethlefs, N. 2022. Automated Question-
The Multi-Agent GraphRAG also struggles with multi-
Answering for Interactive Decision Support in Operations
intent questions that require decomposing and aligning dis-
and Maintenance of Wind Turbines. IEEE Access.
tinct subgoals such as e.g. listing children and counting their
descendants (in CypherBench’s fictional character) leading Donkers, A.; Yang, D.; and Baken, N. 2020. Linked data for
to semantic conflation and misaligned answer structure. This smart homes: comparing RDF and labeled property graphs.
highlights a limitation in handling compositional queries In LDAC.
where sub-intents must be separated and resolved indepen- Edge, D.; Trinh, H.; Cheng, N.; Bradley, J.; Chao, A.; Mody,
dently. A.; Truitt, S.; Metropolitansky, D.; Ness, R. O.; and Larson,
These findings suggest that the system’s success is tied to J. 2025. From Local to Global: A Graph RAG Approach to
its ability to integrate database-aware verification, semantic- Query-Focused Summarization. arXiv:2404.16130.
syntactic feedback, and iterative refinement. At the same Feng, Y.; Papicchio, S.; and Rahman, S. 2025. Cypher-
time, addressing the remaining limitations, particularly for Bench: Towards Precise Retrieval over Full-scale Modern
compositional and structurally complex Cypher queries, Knowledge Graphs in the LLM Era. arXiv:2412.18702.
opens a way for future improvements in agentic query gen-
eration over PLG graphs. Francis, N.; Green, A.; Guagliardo, P.; Libkin, L.; Lindaaker,
T.; Marsault, V.; Plantikow, S.; Rydberg, M.; Selmer, P.; and
Conclusion Taylor, A. 2018. Cypher: An evolving query language for
property graphs. In Proceedings of the 2018 international
We presented the Multi-Agent GraphRAG system for conference on management of data, 1433–1445.
text-to-Cypher question answering over property graph
databases. Our approach combines modular LLM-agentic Gao, J.; Zou, X.; Ai, Y.; Li, D.; Niu, Y.; Qi, B.; and
components for query generation, query entities verification, Liu, J. 2025. Graph Counselor: Adaptive Graph Explo-
execution, and feedback aggregation into an iterative refine- ration via Multi-Agent Synergy to Enhance LLM Reason-
ment loop. Experimental results across CypherBench and ing. arXiv:2506.03939.
IFC-derived datasets demonstrate that this design improves Guo, A.; Li, X.; Xiao, G.; Tan, Z.; and Zhao, X. 2022.
query accuracy and robustness compared to existing LLM Spcql: A semantic parsing dataset for converting natural lan-
baselines. guage into cypher. In Proceedings of the 31st ACM Inter-
Unlike prior work focused primarily on Neo4j, our system national Conference on Information & Knowledge Manage-
targets Memgraph, expanding the landscape of LLM-based ment, 3973–3977.
Han, H.; Wang, Y.; Shomer, H.; Guo, K.; Ding, J.; Lei, Y.; McAleese, N.; Pokorny, R. M.; Uribe, J. F. C.; Nitishin-
Halappanavar, M.; Rossi, R. A.; Mukherjee, S.; Tang, X.; skaya, E.; Trebacz, M.; and Leike, J. 2024. LLM Critics
He, Q.; Hua, Z.; Long, B.; Zhao, T.; Shah, N.; Javari, A.; Help Catch LLM Bugs. arXiv:2407.00215.
Xia, Y.; and Tang, J. 2025. Retrieval-Augmented Generation Memgraph Ltd. 2025. Memgraph Database. https://
with Graphs (GraphRAG). arXiv:2501.00309. [Link]. Accessed: 2025-07-31.
Hornsteiner, M.; Kreussel, M.; Steindl, C.; Ebner, F.; Empl, Peng, B.; Zhu, Y.; Liu, Y.; Bo, X.; Shi, H.; Hong, C.; Zhang,
P.; and Schönig, S. 2024. Real-time text-to-cypher query Y.; and Tang, S. 2024. Graph Retrieval-Augmented Genera-
generation with large language models for graph databases. tion: A Survey. arXiv:2408.08921.
Future Internet, 16(12): 438.
Pourreza, M.; Li, H.; Sun, R.; Chung, Y.; Talaei, S.;
Iranmanesh, S.; Saadany, H.; and Vakaj, E. 2025. LLM- Kakkar, G. T.; Gan, Y.; Saberi, A.; Ozcan, F.; and Arik,
assisted Graph-RAG Information Extraction from IFC Data. S. O. 2024. CHASE-SQL: Multi-Path Reasoning and
arXiv:2504.16813. Preference Optimized Candidate Selection in Text-to-SQL.
ISO/IEC. 2024. ISO/IEC 39075:2024 Information technol- arXiv:2410.01943.
ogy – Database languages – Graph Query Language (GQL). Qu, Y.; Zhang, T.; Garg, N.; and Kumar, A. 2024. Recur-
Technical Report ISO/IEC 39075:2024, ISO/IEC. Standard. sive introspection: Teaching language model agents how to
Jiang, J.; Zhou, K.; Zhao, W. X.; Song, Y.; Zhu, C.; Zhu, H.; self-improve. Advances in Neural Information Processing
and Wen, J.-R. 2024. KG-Agent: An Efficient Autonomous Systems, 37: 55249–55285.
Agent Framework for Complex Reasoning over Knowledge Rubin, O.; and Berant, J. 2021. SmBoP: Semi-
Graph. arXiv:2402.11163. autoregressive Bottom-up Semantic Parsing.
Jiang, J.; Zhou, K.; Zhao, W. X.; and Wen, J.-R. 2023. arXiv:2010.12412.
UniKGQA: Unified Retrieval and Reasoning for Solving Solar-Lezama, A. 2009. The sketching approach to program
Multi-hop Question Answering Over Knowledge Graph. synthesis. In Asian symposium on programming languages
arXiv:2212.00959. and systems, 4–13. Springer.
Jin, B.; Xie, C.; Zhang, J.; Roy, K.; Zhang, Y.; Li, Z.; Li, Tiwari, A.; Malay, S. K. R.; Yadav, V.; Hashemi, M.; and
R.; Tang, X.; Wang, S.; Meng, Y.; and Han, J. 2024. Graph Madhusudhan, S. T. 2025. Auto-Cypher: Improving LLMs
Chain-of-Thought: Augmenting Large Language Models by on Cypher generation via LLM-supervised generation-
Reasoning on Graphs. In Ku, L.-W.; Martins, A.; and Sriku- verification framework. arXiv:2412.12612.
mar, V., eds., The 62nd Annual Meeting of the Associa-
Vanlande, R.; Nicolle, C.; and Cruz, C. 2008. IFC and
tion for Computational Linguistics, Proceedings of the An-
building lifecycle management. Automation in construction,
nual Meeting of the Association for Computational Linguis-
18(1): 70–78.
tics, 163–184. Association for Computational Linguistics
(ACL). Publisher Copyright: © 2024 Association for Com- Walsh, B.; Mohamed, S. K.; and Nováček, V. 2020. BioKG:
putational Linguistics.; Findings of the 62nd Annual Meet- A Knowledge Graph for Relational Learning On Biological
ing of the Association for Computational Linguistics, ACL Data. Proceedings of the 29th ACM International Confer-
2024 ; Conference date: 11-08-2024 Through 16-08-2024. ence on Information & Knowledge Management.
Li, B.; Zhang, J.; Fan, J.; Xu, Y.; Chen, C.; Tang, N.; and Wang, B.; Ren, C.; Yang, J.; Liang, X.; Bai, J.; Chai, L.; Yan,
Luo, Y. 2025. Alpha-SQL: Zero-Shot Text-to-SQL using Z.; Zhang, Q.-W.; Yin, D.; Sun, X.; and Li, Z. 2025. MAC-
Monte Carlo Tree Search. arXiv:2502.17248. SQL: A Multi-Agent Collaborative Framework for Text-to-
SQL. arXiv:2312.11242.
Li, H.; Zhang, J.; Li, C.; and Chen, H. 2023a. Resdsql: De-
coupling schema linking and skeleton parsing for text-to-sql. Wang, B.; Shin, R.; Liu, X.; Polozov, O.; and Richardson,
In Proceedings of the AAAI Conference on Artificial Intelli- M. 2021. RAT-SQL: Relation-Aware Schema Encoding and
gence, volume 37, 13067–13075. Linking for Text-to-SQL Parsers. arXiv:1911.04942.
Li, J.; Li, Y.; Li, G.; Jin, Z.; Hao, Y.; and Hu, X. 2023b. xBIM Team. 2024. [Link]: Example Building
Skcoder: A sketch-based approach for automatic code gen- Model in IFC Format. [Link]
eration. In 2023 IEEE/ACM 45th International Conference com/xBimTeam/XbimEssentials/refs/heads/master/Tests/
on Software Engineering (ICSE), 2124–2135. IEEE. TestFiles/[Link]. Accessed: 2025-07-31.
Luo, H.; E, H.; Tang, Z.; Peng, S.; Guo, Y.; Zhang, W.; Ma, Xu, X.; Liu, C.; and Song, D. 2017. SQLNet: Generating
C.; Dong, G.; Song, M.; Lin, W.; Zhu, Y.; and Luu, A. T. Structured Queries From Natural Language Without Rein-
2024. ChatKBQA: A Generate-then-Retrieve Framework forcement Learning. arXiv:1711.04436.
for Knowledge Base Question Answering with Fine-tuned Yang, R.; Ye, F.; Li, J.; Yuan, S.; Zhang, Y.; Tu, Z.; Li,
Large Language Models. In Findings of the Association for X.; and Yang, D. 2025. The Lighthouse of Language:
Computational Linguistics ACL 2024, 2039–2056. Associa- Enhancing LLM Agents via Critique-Guided Improvement.
tion for Computational Linguistics. arXiv:2503.16024.
Mack, D.; and Jefferson, A. 2018. CLEVR graph: A dataset Yu, T.; Li, Z.; Zhang, Z.; Zhang, R.; and Radev, D. 2018a.
for graph question answering. [Link] TypeSQL: Knowledge-based Type-Aware Neural Text-to-
ai/clevr-graph. Accessed: 2025-07-29. SQL Generation. arXiv:1804.09769.
Yu, T.; Yasunaga, M.; Yang, K.; Zhang, R.; Wang, D.; Li,
Z.; and Radev, D. 2018b. SyntaxSQLNet: Syntax Tree Net-
works for Complex and Cross-DomainText-to-SQL Task.
arXiv:1810.05237.
Zhong, V.; Xiong, C.; and Socher, R. 2017. Seq2SQL: Gen-
erating Structured Queries from Natural Language using Re-
inforcement Learning. arXiv:1709.00103.
 Appendix A Listing 2: Example relationships schema from the fictional
The listings below provide example schemas used to guide character graph in CypherBench
the Query Generator agent during Cypher query generation. Type: basedIn
They include representative node and relationship defini- - (:Organization)-[:basedIn]->(:Location)
tions for the fictional character graph in the CypherBench
dataset (Feng, Papicchio, and Rahman 2025), note that the Type: bornIn
- (:Character)-[:bornIn]->(:Location)
schemas are formatted to closely resemble Cypher syntax.
Type: diedIn
Listing 1: Example node schema with properties and sam- - (:Character)-[:diedIn]->(:Location)
pled values from the fictional character graph in Cypher-
Bench dataset Type: fromUniverse
Each node type includes properties - (:Character)-[:fromUniverse]->
hierarchy divided by ’.’ and sampled (:FictionalUniverse)
examples of each property values. - (:Organization)-[:fromUniverse]->
(:FictionalUniverse)
Node Type: Character
Properties: Type: hasFather
.aliases: "Ibuki Suika" - (:Character)-[:hasFather]->(:Character)
.birth_name: Thomas Merlyn
.country_of_citizenship: "Denmark" Type: hasMother
.creator: Ake Holmberg - (:Character)-[:hasMother]->(:Character)
.description: adventure time character
.gender: trans woman Type: hasSpouse
.name: Thunderbolt (DC Comics) - (:Character)-[:hasSpouse]->(:Character)
.occupation: "prophet, psychic"
Type: hasStudent
Node Type: FictionalUniverse - (:Character)-[:hasStudent]->(:Character)
Properties:
.aliases: "SoD universe" Type: killedBy
.copyright_holder: Sony Group - (:Character)-[:killedBy]->(:Character)
.creator: CD Projekt RED
.description: self-contained narrative Type: memberOf
universe of the SCP web-based - (:Character)-[:memberOf]->
collaborative writing project (:Organization)
.inception_year: 1999
.name: The Black Hole universe

Node Type: Location

Properties:
.aliases: "Jiangzhou Fu"
.description: Klingon penal
colony in Star Trek
.name: Erui

Node Type: Organization

Properties:
.aliases: "Neo Team Rocket"
.description: fictional tribe
in Far Cry 3
.name: Wayne Enterprises
 Appendix B Verification Module: Query Entities Extractor
Extracted entities:
{
An example trace of the proposed Multi-Agent GraphRAG "node_labels": [
pipleline’s question-answering process for a question from "Character"
the fictional character graph in CypherBench (Feng, Papic- ],
chio, and Rahman 2025) dataset is shown below. The output "node_property_values": [[
from the Query Entities Checker is simplified for conve- "Character",
nient visual inspection in the actual pipeline it returns results "name",
in a structured JSON format. "corlys velaryon"
],[
Q: How many characters have Corlys Velaryon as their fa- "Character",
ther or are married to Daemon Targaryen? "name",
"daemon targaryen"
Query Generator ]
MATCH (father:Character), ],
(spouse:Character) "pairwise_relationships": [
WHERE toLower([Link]) = "(:Character)-[:hasFather]->(:
’corlys velaryon’ Character)",
AND toLower([Link]) = "(:Character)-[:hasSpouse]->(:
’daemon targaryen’ Character)"
MATCH (c:Character) ]
WHERE (c)-[:hasFather]->(father) }
OR (c)-[:hasSpouse]-(spouse)
RETURN count(DISTINCT c) Verification Module: Query Entities Checker
Node labels verification result:
Graph DB Executor ------------------------------
Memgraph returned the exception: null
Not yet implemented: atom expression
(c)-[:hasFather]->(father). Nodes properties verification results:
Try to rewrite the query by using OPTIONAL ------------------------------------
MATCH, WITH and WHERE clauses. Node label: "Character"

(Query execution attempts made: 1) Node property value used in the query:
"corlys velaryon"
Query Evaluator
Evaluation: Error or empty Suggested node property corrections:
Property: "Corlys Velaryon"
Feedback: Levenstein similarity score: 86.66
The query failed because it uses a pattern expression, such
Property: "Lucerys Velaryon"
as (c)-[:hasFather]->(father), directly inside a Levenstein similarity score: 77.41
WHERE clause. This syntax is not supported by Mem-
graph, as indicated by the error message. To check for Property: "Jacaerys Velaryon"
the existence of a relationship pattern, it must be wrapped Levenstein similarity score: 75.0
in the EXISTS() function. The query should be rewrit-
ten to use OPTIONAL MATCH or separate MATCH clauses Other semantically relevant suggestions:
with WITH to combine the results, which is a more robust "Laenor Velaryon",
pattern. "Laena Velaryon",
"Jacaerys Velaryon"
For example: ---
Node label: "Character"
MATCH (child:Character)-[:hasFather]->(f:
Character)
Node property value used in the query:
WHERE toLower([Link]) = ’corlys velaryon’
"daemon targaryen"
WITH COLLECT(child) AS children MATCH
(spouse_char:Character)-[:hasSpouse]-(s:
Suggested node property corrections
Character)
Property: "Daemon Targaryen"
WHERE toLower([Link]) = ’daemon targaryen’
Levenstein similarity score: 87.5
WITH children + COLLECT(spouse_char) as
allPeople!
Property: "Aemon Targaryen"
UNWIND allPeople as person
Levenstein similarity score: 83.87
RETURN count(DISTINCT person).
 Query Evaluator
Property: "Aemond Targaryen" Evaluation: Accept
Levenstein similarity score": 81.25
Feedback:
Other semantically relevant suggestions:
"Daemon Targaryen", The query correctly implements the required logic. It uses
"Aemond Targaryen", two separate OPTIONAL MATCH clauses to find characters
"Daeron Targaryen" satisfying each condition (child of Corlys, spouse
of Daemon), combines the results into a single list, and
Relationships verification results: then counts the distinct characters in that list. This is a
--------------------------------- valid, though somewhat complex, way to implement an
[] OR condition and correctly answers the user’s question.

Verification Module: Instructions Generator Interpreter

Based on the verification results, here are the required Answer:
corrections for your Cypher query:
There are 3 characters who have Corlys Velaryon as their
1. In the Character node, the property value ‘corlys ve- father or are married to Daemon Targaryen.
laryon‘ is incorrect. Replace it with ‘Corlys Velaryon‘.
2. In the Character node, the property value daemon
targaryen is incorrect. Replace it with Daemon
Targaryen.

Feedback Aggregator
Your query incorrectly used an expression in the WHERE
clause. Instead, use two separate MATCH clauses for each
condition: one to find characters :hasFather Corlys
Velaryon, and another to find characters :hasSpouse
Daemon Targaryen. Combine the results from both
matches, then unwind the list and return the count of dis-
tinct characters. Ensure you use the exact, case-sensitive
names Corlys Velaryon and Daemon Targaryen for
the ‘name‘ property.
(Query generation attempt: 2)
Query Generator
OPTIONAL MATCH
(child:Character)-[:hasFather]->
(:Character{name: ’Corlys Velaryon’})
WITH collect(DISTINCT child) AS children
OPTIONAL MATCH
(spouse_char:Character)-
[:hasSpouse]-
(:Character{name: ’Daemon Targaryen’})
WITH children + collect(
DISTINCT spouse_char
)
AS all_chars UNWIND all_chars AS c
RETURN count(DISTINCT c)

Graph DB Executor
Query outcome:
[
{
"count(DISTINCT c)": 3
}
]
 Appendix C
Below are the predicted answers and generated correspond-
ing Cypher queries on the Sample House IFC data using
our Multi-Agent GraphRAG pipeline. The user questions
and corresponding expected answers are sourced from (Iran-
manesh, Saadany, and Vakaj 2025).

User question Expected response Generated Cypher query Given response

1. How many doors exist There are 3 doors. MATCH (d:IfcDoor) RETURN The building contains 3
in the building? count(d) doors.
2. What is the volume of The gross volume of the MATCH (s:IfcSpace) WHERE The gross volume of the
the roof space? roof space is 76.47 cubic [Link] roof space is 76465.52
meters. = ’Roof’ RETURN m³. This value appears
[Link] unusually large.
3. How many storey There are 2 storey in the MATCH (n:IfcBuildingStorey) The building contains 2
exist in the building? building RETURN count(n) stories.
4. What is the gross The gross floor area of MATCH (space:IfcSpace) WHERE The gross floor area of
floor area of the entrance the entrance hall is 8.69 toLower([Link]) CONTAINS the space ’3 - Entrance
hall? square meters. ’entrance hall’ hall’ is 8.69 m².
RETURN [Link],
[Link].
GrossFloorArea
5. What is the The illuminance unit MATCH (unit:IfcSIUnit) The defined unit for
illuminance unit defined defined in the file is Lux. WHERE [Link] = illuminance is LUX.
in the file? ’ILLUMINANCEUNIT’ RETURN
[Link]
6. Is there a Laundry in No there isn’t any MATCH (s:IfcSpace) No, the database
the building? Laundry space in the WHERE toLower([Link]) contains no space
building. CONTAINS ’laundry’ OR identified as a Laundry
toLower([Link])
CONTAINS ’laundry’ OR
toLower([Link] [Link])
CONTAINS ’laundry’ RETURN
count(s) > 0
7. What is the perimeter The entrance hall has a MATCH (s:IfcSpace) WHERE The gross perimeter of
of the entrance hall? perimeter of 12,810. toLower([Link]) CONTAINS the space ’3 - Entrance
’entrance hall’ RETURN [Link], hall’ is 12.81 m.
[Link]
8. What is the building The address is MATCH (b:IfcBuilding) The building address is
address? ’Westminster, London, -[:BUILDINGADDRESS]-> Westminster, London,
UK’ (pa:IfcPostalAddress) RETURN UK. Some fields are
[Link], [Link], missing.
[Link], [Link]
9. What is the The roof has an MATCH (s:IfcSpace) WHERE The unconnected height
unconnected height of unconnected height of [Link] of the roof space is 1.00
the roof space? 1000 mm (1 meter). = ’Roof’ RETURN m.
[Link] Height
10. What is the name of The project name is MATCH (p:IfcProject) RETURN The project is named
the project? ’ProjectName’. [Link] Project Name.