The increasing adoption of Large Language Models (LLMs) has led to a growing number of prompt-to-RDF approaches that rely on LLMs to directly transform heterogeneous data collections into RDF graph representations. While efective for rapid prototyping, such approaches raise concerns regarding transparency, reproducibility, and maintainability, as modeling decisions remain implicit and dificult to validate or reuse. This vision paper argues for repositioning LLMs in graph transformation workflows, from black-box data transformers to assistive generators of schema mappings. In the proposed approach, LLMs are used to produce schema mappings, a task that is traditionally manual and labor-intensive, while data transformation is delegated to established data transformation frameworks. By doing so, the schema mapping process can be significantly accelerated, addressing key bottlenecks in large-scale semantic integration pipelines. The paper grounds this vision in ongoing work that explores the use of diferent LLMs and prompting strategies to generate schema mappings using X3ML mapping framework. While a full experimental evaluation is beyond the scope of this paper, this work illustrates the feasibility of the approach. Overall, the paper outlines a research agenda towards more explainable, trustworthy and semantically grounded LLM-assisted transformation pipelines.
The transformation of heterogeneous data into RDF graph representations plays a central role in semantic data integration, knowledge graph construction and interoperability across information systems. By lifting data from relational databases, tabular files, APIs, and semi-structured formats into RDF graphs aligned with shared ontologies, organizations can enable semantic querying, reasoning, data re-use, and cross-domain integration. As a result, the transformation of data to RDF-based graphs has become a foundational component of data infrastructures across various domains such as cultural heritage, life sciences, e-government and others.
At the same time, the scale and diversity of data landscapes across diferent disciplines, pose significant
challenges for RDF graph construction. Large volumes of heterogeneous data are continuously produced,
updated, and exchanged. In this context, through the recent advances in Large Language Models (LLMs),
emerged a new alternative for constructing RDF knowledge graphs. These approaches have explored
the use of LLMs as tools to directly transform raw data into RDF graphs. While this approach is quick
and attractive for small-scale scenarios and rapid prototyping, it has serious limitations over massive
and continuously evolving datasets. Furthermore, it is computationally expensive and dificult to sustain
in production systems. In addition, repeatedly invoking LLMs for data transformations raises concerns
regarding cost, latency and operational scalability. Similar concerns have been raised in recent work
on deep learning, which highlights the need for scalable graph-based abstractions over relational data,
rather than relying on costly instance-level processing pipelines [
In contrast, schema mappings provide a well-established mechanism for specifying how source data structures correspond to target schemata (i.e. ontologies). Such mappings make modeling decisions explicit, enable the reuse across datasets, and support validation, adaptation, debugging, and maintenance of transformation pipelines. After the definition of schema mappings, dedicated data transformation software components, use them to transform data and construct RDF knowledge graphs. However, the definition of schema mappings remains a manual and expertise-intensive process, often constituting a major bottleneck in semantic integration workflows. More specifically, the definition of schema mappings requires expertise and knowledge of: (a) the domain and the schema of the source data, (b) the target ontology, and (c) the schema mapping technology. Given the volume and heterogeneity of today’s data, the manual generation of schema mappings does not scale.
This paper argues that automating the construction of schema mappings is a more efective and sustainable strategy than applying LLMs directly to data transformation. By leveraging LLMs to assist in generating schema mappings, rather than transforming data themselves, semantic data integration pipelines can combine scalability and eficiency with transparency and semantic validation. This vision positions LLMs as accelerators of human modeling efort, enabling the definition of explicit, reusable schema mappings that can be exploited by existing transformation frameworks and tools over large volumes of data.
The contributions of our work are: (a) a conceptual reframing of the role of LLMs for graph transformations, positioning themselves as assistants for schema mapping generation, rather than data transformation engines; (b) an analysis of the limitations of prompt-to-RDF approaches; and (c) a grounded vision for scalable and reusable semantic data integration based on X3ML schema mapping framework.
The paper is organized as follows: Section 1 introduces the objectives of the paper and outlines its main contributions. Section 2 provides background information and details about related works. Section 3 elaborates on the limitations of prompt-to-RDF approaches. Section 4 presents our vision of repositioning LLMs as schema mapping accelerators. Section 5 grounds this vision by discussing our experience to date with an existing schema mapping framework and LLMs. Finally, Section 6 concludes and identifies directions for further research.
The construction of RDF knowledge graphs through data transformation from heterogeneous data
sources has been extensively studied in the literature (e.g. the survey in [
More recently, several approaches have explored the use of LLMs to directly transform data into RDF.
LLM2KB [
While both schema mapping-based approaches and LLM-based approaches aim to transform heterogeneous data into RDF knowledge graphs they difer in how transformation logic is expressed and applied. The implications of these diferences are examined in the following section.
A key limitation of direct LLM-based data transformation is the absence of an explicit intermediate representation, that describe class assignments, property selections and others. In prompt-to-RDF workflows, such modeling decisions are embedded implicitly in the generated RDF triples. This lack of an explicit schema mapping layer makes it dificult to verify, review, or adjust transformation logic before its execution. As a result, validation typically occurs only after RDF graphs are constructed, at which point identifying and correcting potential errors becomes costly and impractical.
Another issue, closely related to the previous one, is the limited support for debugging and maintenance. When errors occur in RDF graphs produced by LLMs, tracing their origin is cumbersome, as there is no inspectable step that documents how source elements were transformed. In contrast to traditional schema mapping approaches, prompt-to-RDF transformations operate as black boxes, complicating error diagnosis and refinement of the transformation logic.
Another concern is variability in transformation results. LLM-based data transformations may yield diferent RDF graphs across runs, prompts, or model versions, even when applied to the same source data. Such variability undermines reproducibility, raises concerns for the accuracy of the generated graphs, and poses significant challenges for maintaining consistent RDF graph representations especially when applied over continuously evolving data sources.
Scalability and eficiency further limit the applicability of prompt-to-RDF approaches. Applying LLMs directly to large data collections requires repeated model invocations over large volumes of data, leading to high computational cost and latency. This is a problem that does not occur when source data are used for generating schema mappings, since in this case only a small subset or sample of the data is needed. Of course, even in this case, the transformation of large volumes of data has a computational cost, which is however lower and can scale using dedicated transformation frameworks, compared to LLMs.
Overall, these limitations highlight that directly relying on LLMs for data transformations mixes transformation logic with transformation execution. This coupling hinders verification, debugging, reproducibility, and scalability, motivating the need for alternative approaches that preserve explicit transformation logic while still get all the potential from LLM capabilities.
The aforementioned limitations indicate that the challenges of LLM-based data transformations stem not from the actual use of LLM themselves, but from their direct application to data-level transformation. In particular, the absence of an explicit and inspectable transformation layer hinders validation, debugging and reuse of the transformation logic. This observation suggests that the strengths of LLMs (i.e. their ability to interpret the semantics of heterogeneous data) could be more efectively leveraged at the level of schema mapping generation rather than the data transformation execution. For this reason, we outline a vision for repositioning LLMs as assistants for generating explicit schema mappings, enabling scalable and explainable graph transformation pipelines while preserving the benefits of existing transformation frameworks.
Figure 1 illustrates the proposed vision; heterogeneous data sources are first collected and structurally normalized so that they can be consistently interpreted by the transformation engine used at execution time. Representative samples are selected to capture the structural characteristics and semantics of the source schema, as the objective is to derive mapping rules and correspondences, not to transform the entire dataset during prompting. A small subset or sample of those data, together with the target ontologies are then given as input to an LLM-assisted schema mapping generator component through a prompt construction process. Rather than operating on a full data collection, LLMs are guided using samples to generate explicit schema mappings that capture how source data elements correspond to classes, properties and relationships in the target ontologies. Crucially, no data-level transformation is performed by the LLM; the outcome of this process is the inspectable schema mappings, where expert validation results can be fed back to the generator to guide subsequent mapping generation rounds.
The schema mapping repository plays a central role in the proposed architecture by supporting and
guiding the LLM-assisted schema mapping generation process. More specifically, the repository acts as
a source of contextual knowledge that can be exploited to improve the accuracy and consistency of the
generated mappings. Existing schema mappings can be retrieved based on their relevance with new
data sources; for example, by comparing the structure or the contents of the source data, with the input
data used in existing schema mappings (e.g. using text embeddings [
The generated schema mappings can be therefore reviewed, validated and refined by mapping experts prior to their execution, enabling early detection of modeling errors. Importantly, expert feedback resulting from this validation process can be fed back to the LLM-assisted schema mapping generation component, allowing the revision of the mappings based on curated human advice. Expert feedback is incorporated by adding corrected mappings fragments to subsequent prompts enabling iterative refinement of the generated schema mappings.
Upon the definition of the schema mappings and their revision/validation by mapping experts, the
generated schema mappings can be used for the actual data transformation part. This is carried out
without relying on the LLM, by delegating it to well-known data transformation engines (e.g. X3ML
Engine [
This explicit feedback loop, together with the separation of mapping definition from transformation execution enables a scalable and explainable approach to graph transformation in which human expertise and LLM capabilities are efectively combined. This solution significantly accelerates the traditionally manual and time-consuming schema mapping definition process. At the same time, delegating the actual data transformations to dedicated transformation engines ensures eficiency, reproducibility, and robustness when operating over large and evolving data collections. Table 1 shows a side-by-side comparison with respect to diferent aspects.
To ground the proposed vision in practice, this section summarizes ongoing work that explores the use
of LLMs for generating schema mappings based on X3ML framework [
Figure 2 illustrates a minimal example of the proposed approach. The upper part consists of an
XML source record describing a person with an identifier and a name. Based on this and the target
ontology (e.g., CIDOC CRM [
In [
In [
Figure 3 provides an aggregated overview of the impact of the prompting techniques on the accuracy of the generated schema mappings. The figure is intended to illustrate general trends, rather than to support a detailed comparative evaluation that goes beyond the scope of this vision paper. As shown, zero-shot prompting yields the lowest accuracy, as it frequently generates schema mappings with invalid or incomplete structure with respect to X3ML schema. Syntax-aware prompting significantly improves the validity and usefulness of the generated mappings, by constraining the LLM output to the expected mapping format. In-context prompting technique further improves accuracy by guiding the LLM with representative examples, leading to schema mappings that align to existing modelling practices and consists of semantically correct components.
Our observations directly support the design choices outlined in Section 4. In particular the efectiveness of in-context prompting reinforces the central role of reusing existing schema mappings in guiding LLM-assisted mapping generation. Direct quantitative comparison with existing techniques is currently not possible, as there are no established baselines for this. Consequently, the reported accuracy values should be interpreted as indicative evidence of feasibility rather than competitive performance results. The observed average accuracy of 0.53 for the in-context strategy should be interpreted in relation to the complexity of schema mapping definition, which typically requires expert knowledge of the source domain and schemata, target ontologies and mapping languages. Achieving correct generation for more than half of mapping components without manual authoring constitutes a strong indication that the traditionally manual and time-consuming schema mapping process can be substantially accelerated, and in certain cases partially automated. We should however mention that this level of accuracy is not intended to replace expert involvement, but to provide high-quality initial mappings and reduce manual efort.
This paper presented a vision for repositioning LLMs in graph transformation workflows, motivated by the scale and diversity of data landscapes. Given the massive volumes of heterogeneous data that must be integrated today, relying on LLMs to directly transform data into RDF knowledge graphs is impractical and highly resource-consuming. In this context, accelerating the traditionally manual and expertise-intensive task of schema mapping definition emerges as a sustainable strategy for enabling large-scale semantic data integration. By using LLMs as assistive generators of schema mappings rather than as black-box data transformation engines, the proposed approach decouples transformation logic from execution and enables scalable and transparent and semantically enhanced transformation pipelines. The grounding of this vision through ongoing work with the X3ML framework, demonstrates the practical feasibility of the proposed approach. Observations reveal strong indications that the time-consuming schema mapping process can be substantially accelerated. Overall, this vision opens opportunities for hybrid human-LLM workflows, in which language models support human experts, while established transformation frameworks ensure scalability in production settings. Looking to the future, several research directions stem from this work, such as methods to improve LLM-assisted mapping generation, the investigation of decomposing complex source data into smaller units that can be used for generating more fine-grained schema mappings, and methods for retrieving relevant existing mappings to support in-context generation. 1https://github.com/ymark/x3ml_comparator
The authors did not use generative AI systems for generating scientific content, analysis, results, figures or conclusions presented in the paper; such tools were used exclusively for language refinement and proofreading.
Figure 2: Illustrative example of an XML source record, and the corresponding X3ML schema mapping. Figure 3: Aggregated accuracy of diferent prompting strategies.