betaFeedback

WorksComputer Science

HeriKGQA: Grounded Knowledge-Graph Question Answering over Cultural Heritage Sensor Data

Abstract

Cultural heritage sites are increasingly monitored by sensor networks, but querying their data requires database expertise. Large Language Models (LLMs) offer a natural-language interface, yet over raw sensor records they lose track of which sensor, site, and time each value belongs to, and silently miscompute. We present HeriKGQA, a knowledge-graph question-answering method that confines the LLM to interpreting questions and phrasing answers, leaving computation to SPARQL and deterministic code. Questions are parsed into intents constrained by a heritage ontology aligning W3C SOSA/SSN with CIDOC-CRM, compiled into SPARQL, and answered from query results and temporal, spatial, and anomaly facts derived by a grounding layer, with error correction guarding each LLM step. On 500 questions over real data from five heritage sites, HeriKGQA reaches 99.0% accuracy, 18.2 points above the strongest of three baselines using the same LLM and receiving the same anomaly rules and answer conventions, with comparable answer quality while running almost four times faster. Without grounding, accuracy drops by 12.2 points and on anomaly questions from 99% to 66%. We report lessons from development and live deployment.

Introduction

Cultural heritage sites are increasingly monitored by sensor networks that record temperature, humidity, and vibration [1, 13]. Conservators ask questions such as “Has the temperature changed too rapidly in the last hour?” (Figure 1), which are easy to state but require filtering, aggregating, and checking thousands of raw readings against expert-defined thresholds. Large Language Models (LLMs) offer a natural-language interface, but over readings serialised as text, they lose track of which sensor, site, and time each value belongs to and

Example challenge of QA over heritage data

Figure 1. Example challenge of QA over heritage data. Over raw text, the LLM mixes two sensors’ readings and raises a false alarm (left); HeriKGQA evaluates sensors separately over the knowledge graph (right).

miscompute aggregates [9]. These errors are silent: a fluent answer hides a miscomputed number and can thus mislead conservators deciding whether a monument is at risk.

Retrieval-Augmented Generation (RAG) only selects which readings enter the prompt, leaving the LLM to compute over them. Table-oriented variants like TableRAG [2] execute LLM-written pandas code over retrieved cells, and LLM-based Knowledge Graph Question Answering (KGQA) methods such as Interactive-KBQA execute LLM-written SPARQL, including aggregate queries [22]. Their answers are thus only as correct as the LLM-written code or queries. Designed for general-domain tables and graphs [11, 16], these methods do not address spatial, temporal, and anomaly-related questions over heritage sensor data, whose answers need exact computation.

We present HeriKGQA,1 a KGQA method built on the principle that *the LLM reasons over data but never computes over it. Rather than letting the LLM write free-form code or queries, HeriKGQA restricts the LLM to a constrained intent, compiles it deterministically into SPARQL, and computes spatial, temporal, and rule-based results with pre-implemented, domain-specific functions in a grounding layer; the LLM then verbalises the answer from these results. Its knowledge graph maps the sensor database onto a heritage ontology that makes each reading’s relations explicit, and the intent enforces their use. Our contributions are:

  • We realise this principle in HeriKGQA through ontology-constrained intent parsing, deterministic SPARQL compilation, a grounding layer, and LLM error correction (§ 3).

  • We construct a 500-question benchmark over real data from five heritage sites, with validated answers, on which HeriKGQA outperforms three baselines and two ablations (§ 4).

  • We deploy HeriKGQA in the ARGUS chatbot for live heritage monitoring, evaluate it on real user questions, and report lessons (§ 5).

Problem Setting

We consider five heritage sites, Baltanas, Delos, Lucretili, Ranverso, and Schenkenberg (Table 2(a)), monitored by 71 sensor nodes. Readings arrive as raw, mostly unitless device channels whose names are reused across sensors (at Baltanas alone, 19 sensors report temperature), so a reading is interpretable only together with its site, node, sensor, timestamp, and position. Conservation experts also defined 37 anomaly rules, each comparing a computation over a quantity against a site-specific threshold; some refer to quantities, such as crack width or tilt, that no deployed sensor measures.

SiteNodesSensorsTemperature sensorsObserved propertiesReadingsObservationsRules
Baltanas15301967709,1702,138,5108
Delos19301043225,945580,8734
Lucretılı15201839574,5781,454,88916
Ranverso1319954108,150511,9705
Schenkenberg914125559,713541,3794
Total7111368137¹1,677,5565,227,61737
SiteRuleChecksThreshold(s)Data
BaltanasR1_ppvpeak particle velocity (PPV)0.25
BaltanasR2_hum_daily_rangedaily humidity range10
BaltanasR3_gnss_changeday-over-day GNSS position change3
BaltanasR4_soil_highhigh soil moisture70
BaltanasR4b_soil_rangedaily soil moisture range3
BaltanasR5a_airflow_constairflow constancy0.05✓
BaltanasR5b_airflow_rangeairflow range0.35✓
BaltanasR6_rain_1h1-hour rainfall10✓
DelosR1a_rain_1h1-hour rainfall10
DelosR1b_rain_3h3-hour rainfall20
DelosR2_windwind speed12✓
DelosR3_hum_crosshumidity threshold crossings9; 75
LucretılıR10_solar_zscoredaily GNSS z-score1
LucretılıR1a_crack_stepcrack step0.7
LucretılıR1b_crack_offsetcrack offset0.9
LucretılıR2a_tilt_steptilt step0.7
LucretılıR2b_tilt_offsettilt offset0.9
LucretılıR3_vib_zscorevibration z-score7
LucretılıR4a_hum_spike6-hour humidity spike98✓
LucretılıR4b_hum_persist_7d7-day humidity persistence90✓
LucretılıR4c_hum_rapid_1hrapid 1-hour humidity change20✓
LucretılıR5_visitorsvisitor peak3✓
LucretılıR6a_rain_1h1-hour and 24-hour rainfall5; 20✓
LucretılıR6b_rain_cum7d7-day cumulative rainfall100✓
LucretılıR7_windwind peak ratio6✓
LucretılıR8_baro6-hour barometric pressure range300✓
LucretılıR9a_temp_ltdaily temperature range20✓
LucretılıR9b_temp_stshort-term (1-hour) temperature change5✓
RanversoR1_hum_insideindoor humidity80
RanversoR2_rain_7d7-day rainfall20✓
RanversoR3_temp_modiffsoil/air temperature difference2✓
RanversoR4_soil_highhigh soil moisture60✓
RanversoR4b_soil_lowlow soil moisture5✓
SchenkenbergR1_temp_humlow temperature with high humidity0; 90✓
SchenkenbergR2_crack_stepcrack step0.1✓
SchenkenbergR3_vib_zscorevibration z-score4.5✓
SchenkenbergR4_pgapeak ground acceleration (PGA)0.5✓

Table 2. Statistics of the evaluation snapshot (13 May–12 August 2026), per site. (a) Data statistics: Readings are sosa:ObservationCollections and Observations are sosa:Observations; Rules are Policy instances linking each rule to its site. ¹Distinct across sites, since sites share property names. (b) The 37 AD-RT anomaly rules with their thresholds; ✓: the snapshot contains usable readings the rule applies to.

Conservators and site managers ask spatial, temporal, and anomaly-related questions, alone or as follow-ups to earlier turns. Formally, given a knowledge graph GG of sites, nodes, sensors, observations, and anomaly rules, a question qq, and an optional history HH, the task is to produce an answer aa whose requested quantitative claim (e.g., a count, average, extremum, range, distance, duration, or threshold verdict) is correct with respect to GG. When GG lacks the data needed, aa must say so instead of producing a number, and when an applicable rule cannot be evaluated and no rule fires, an anomaly answer must be Cannot be determined.

Method

A tempting baseline is to retrieve relevant readings and let an LLM answer from them directly, which fails silently in two ways. First, the readings are serialised as plain text, where the relations linking each value to its sensor, site, time, and rule are no longer explicit: two temperature sensors at Lucretili reading steadily near 10 and 18, once interleaved, appear to jump by 8 at every step, triggering a false alarm against the 1-hour threshold of 5 (Figure 1). Second, the LLM computes over raw values itself, which it does unreliably [9]: Baltanas alone produces about 7,760 readings per day, so the model either answers from a truncated subset or must aggregate thousands of values; “the last hour” must be anchored at the latest observation, not the current time, as data arrive with delays and gaps; and spatial questions, such as finding the closest pair, require 171 haversine distances among the 19 nodes at Delos.

HeriKGQA (Figure 2) answers questions over a knowledge graph (§ 3.1) in three steps (§ 3.2), supported by a grounding layer and guarded by error correction (§ 3.3).

Overview diagram of HeriKGQA

Figure 2. Overview of HeriKGQA. Bottom: sensor readings are mapped through a heritage ontology, extended with anomaly rules, into a virtual knowledge graph GG. Middle: the LLM (purple) only parses the question and verbalises the answer, while SPARQL and the grounding layer (teal) compute every number from GG. Top: voting over intents, retrying failed queries, and verifying answer numbers guard the LLM steps.

Sensor Knowledge Graph

We build the sensor knowledge graph of HeriKGQA on PANOPTES [12], a digital twin ontology for cultural heritage assets that aligns SOSA/SSN [7, 5] with CIDOC-CRM [4]. We map each sensor reading to a sosa:ObservationCollection with one sosa:Observation per reported quantity, linked to its sensor, node, and site, and each anomaly rule to a PANOPTES Policy linked to its site (Table 2(b)). Every value thus keeps the relations that plain-text rows lose (§ 2): its sensor, so that anomaly checks run per sensor and observed property even when channel names are shared; its node’s WGS84 coordinates and altitude, for distances; its timestamp, for time windows; and its site’s rules, for site-specific thresholds. Ontop [21] serves the graph virtually by translating each SPARQL query into SQL, so new readings are queryable immediately.

Three-Step Pipeline

Semantic parsing. An LLM maps the question to a JSON intent: a target class with filters, return properties, joins, and an optional aggregation, ordering, and limit. Relative expressions such as “the last hour” become a relative_time amount and unit, and questions about information the graph does not model are marked unanswerable and declined without a query. The parser is schema-constrained: it sees only the instantiated ontology classes and all property, site, and node labels in GG, so its filters use the graph’s own names. Its prompt also states the reference time (the latest observation in GG) and keeps computation out of the parser: statistics must be expressed as aggregations, and distance questions return only coordinates. Anomaly questions are marked with an anomaly_check flag and an optional as_of time, and target the anomaly rules of the named site for the named quantity; for each retrieved rule, a second query fetches that quantity’s observations within the rule’s window, which the grounding layer evaluates per sensor. Follow-up questions are resolved into standalone intents using the last hh question–intent pairs (Appendix § 12).

SPARQL execution. The intent is validated and compiled deterministically into SPARQL, with joins as triple patterns, filters as FILTER expressions, and aggregations as GROUP BY clauses, so all aggregates are computed by the query engine. Unlike free-form SPARQL written by an LLM, an intent can be checked against the schema and voted over, and its compiled queries follow fixed patterns: relative windows end at the latest observation rather than the wall clock, and each aggregate returns its number of values, so an aggregate over no data is treated as empty rather than reported as 0. Since truncating rows passed to the LLM would cause silent errors, more than 1,000 such rows prompt the user for an aggregate or a narrower question.

Answer generation. A second LLM call verbalises the answer from the question, the query results, and the facts and verdicts computed by the grounding layer (§ 3.3). Its prompt requires reporting aggregates and verdicts exactly as given, never recomputing them from the retrieved rows or presenting a limited result as complete, and stating when no data or rule was found. Anomaly answers begin with Yes, No, or Cannot be determined, and every answer ends with a deterministically appended note on the time range of the data used.

Grounding and Error Correction

Grounding layer. SPARQL covers statistics, but spatial, temporal, and anomaly questions need derived facts, such as distances or rule verdicts, that the answer LLM would otherwise compute. This layer therefore derives them from all returned rows, each only when the rows contain its inputs: temporal facts (oldest and newest timestamp, time span, and age of each reading), spatial facts (centroid, bounding box, altitude range, and nearest and farthest node pairs by haversine distance), and numeric summaries (count, minimum, maximum, and mean) of the listed distinct values per property, never merging quantities. For anomaly questions, each retrieved rule is evaluated by type (a threshold on the latest value, a windowed sum, mean, or range, a z-score, or a custom metric such as the rate of change) per sensor and observed property, with windows ending at the rule’s latest matching reading (at or before as_of, if given). Per-sensor results are combined by maximum or minimum as the rule requires and compared with the site-specific threshold, yielding exceeds or within with supporting values; rules lacking an implementation or matching data are flagged without a verdict. Verdicts and references follow the implemented rules, some approximating the expert definitions (Appendix § 12), rather than an independent risk assessment.

Error correction. The two LLM steps can still fail: a misparsed intent yields a wrong or empty query, which surfaces as missing data, and the answer LLM may alter a number while phrasing it. Three mechanisms guard against this. Error-driven retry: if an intent is invalid or its query fails or returns nothing, the error, query, and intent are fed back to the parser for at most kk retries. Intent voting: the parser samples nn intents in parallel, the greedy parse and n−1n - 1 at temperature 0.7, and keeps the most frequent, breaking ties in favour of the greedy parse, a form of self-consistency (Wang et al., [19]). Answer verification: every number in the answer is checked against the rows, facts, verdicts, and question (for its occurrence, not for its association with a sensor, site, or time), and an anomaly answer must lead with the computed verdict; a failing answer is regenerated once and otherwise replaced by a deterministic template answer. Deterministic compilation ensures that the query executes the parsed intent, not that the intent matches the question, so parsing errors remain the main source of errors (Appendix § 14).

Offline Experiments

Data and benchmark. Experiments run on a fixed snapshot of the sensor database covering the five sites, 71 nodes, and 37 anomaly rules of § 2. The snapshot spans 13 May–12 August 2026, contains 5,227,617 observations, and is served by Ontop as a virtual knowledge graph over a read-only database copy. We evaluate on 500 questions, 100 each of five types: basic, spatial, temporal, anomaly-related, and follow-up (Appendix § 11).

Baselines and ablations. We compare HeriKGQA against three baselines: (1) TextRAG, which serialises retrieved readings as plain-text rows; (2) TableRAG (Chen et al., [2]), which retrieves columns and cells from the snapshot flattened into one table and answers by executing LLM-written pandas code; and (3) Interactive-KBQA (Xiong et al., [22]), which has the LLM explore the knowledge graph over multiple turns through SPARQL-based tools. We also ablate the grounding layer (w/o grounding), leaving the answer LLM to compute the facts and rule verdicts from the retrieved rows, and error correction (w/o error correction: one greedy parse, without retries or answer verification). All six systems use the same LLM (gpt-oss-120b) via an institutional LLM endpoint. They differ in the setup around the LLM: schema exposure, demonstrations, tools, and result handling (Table 4). All systems receive the same answer conventions (lead with the verdict; say when the data cannot answer the question) and the rule definitions, which TableRAG finds as rows of its table. HeriKGQA anchors relative time windows deterministically at the latest observation; the baselines must infer the anchor: TextRAG is told the period the data cover, TableRAG’s table caption gives its date range, and Interactive-KBQA can query the latest timestamp (Appendix § 12).

TextRAGTableRAGInteractive-KBQAHeriKGQA
Representation and querying
Data representationPlain-text rows, chunked by site, node, sensor, property, and dayOne flattened table (pandas)The same virtual RDF knowledge graph (Ontop)Virtual RDF knowledge graph (Ontop)
RetrievalHybrid BM25 and dense retrieval (RRF)LLM query expansion, then schema and cell retrieval (top 5 per query)Multi-turn exploration via SPARQL toolsSingle structured intent
Query generation–Pandas commands written by the LLM in a ReAct loopFree-form SPARQL written by the LLMDeterministic compilation of the LLM’s intent
Schema knowledgeChunk titles onlyRetrieved columns with types and example valuesHand-written schema, tool descriptions, and patternsOntology-derived schema of instantiated classes
In-context examplesNoneNo task-specific ones (official prompts)3 demonstration dialogs14 question–intent examples covering question types
Computation
StatisticsLLM, over retrieved rowsLLM-written pandas codeLLM-written aggregates, if anySPARQL aggregates, if parsed
Temporal and spatial factsLLM inferenceLLM-written pandas code or LLM inferenceLLM inference or SPARQLDeterministic grounding layer
Anomaly verdictsLLM judgement against rule textLLM judgement against rule rows, possibly via codeLLM-written threshold queryPer-sensor rule evaluation with site thresholds
Relative timeData range stated in the promptDate range stated in the table captionInferred by the LLM, or queried as the latest timestampAnchored to the latest reading, timestamp reported
Robustness
Large resultsTruncation at 1,000 rowsCell retrieval capped at 10,000 values; code runs on the full tableTruncation at 2,000 charactersRequest to narrow above 1,000 rows, no truncation
Query failures–LLM self-correction from execution errors (at most 5 steps)LLM self-correction until an action repeatsParser retry with error feedback (at most 2)
Follow-up questionsPrevious turns in retrieval query and promptEarlier questions in the promptEarlier questions in the promptShort history, with new sites or quantities replacing old ones
Cost and observed behaviour
LLM calls per question12 query expansions, plus up to 5 solver stepsUp to 10 steps × 3 candidates, plus 1 or 23 parses and 1 answer, plus up to 2 retries and 1 regeneration
LatencyLow, stableModerateHigh, variableModerate
Main failure modesIncomplete retrieval, arithmetic errorsStep limit reached, incorrect pandas code, false abstentionsParsing errors, exploration detours, incorrect SPARQLIntent parsing errors, unsupported question types

Table 4. Comparison of the evaluated systems.

Evaluation metrics. Answer accuracy counts an answer as correct only if the requested quantitative claim (§ 2) matches a manually validated reference computed independently from G\mathcal{G}, anomaly answers give the correct verdict, and unanswerable questions are declined. Verdicts count wherever they appear in the answer and are extracted by an LLM classifier. Answer quality is rated by an LLM judge on readability, conciseness, and comprehension following FLASK (Ye et al., [24]), and complemented by a human pairwise evaluation against Interactive-KBQA (Appendix § 13). Latency is the end-to-end time per question (median, p90).

Main results. As shown in Table 1, HeriKGQA answers 495 of the 500 questions correctly (99.0%), 18.2 points above the strongest baseline, Interactive-KBQA (80.8%), and reaches at least 98% on every question type, whereas each baseline falls below 60% on at least one. The baselines fail wherever computation is left to the LLM, either directly (TextRAG) or through code and queries it writes (TableRAG, Interactive-KBQA). TextRAG reaches only 17% on basic questions, as it must derive statistics from limited retrieved text. TableRAG recovers them through pandas code (76%), but its code rarely reproduces distances or rule evaluations (22% spatial, 26% anomaly). Interactive-KBQA, despite querying the same graph, performs well where SPARQL aggregates suffice (95% basic, 91% temporal) but drops on spatial (54%) and anomaly (79%) questions, which require distances and per-sensor rule evaluations that it must express in its own SPARQL or estimate from retrieved values. Appendix § 15 tests the generality of our design on MultiTQ (Chen et al., [3]), where HeriKGQA is competitive with Interactive-KBQA (75.4% vs. 73.4%), and its robustness to a smaller backbone (qwen3-8-27b) with unchanged accuracy.

SystemMeanBasicSpatialTemporalAnomalyFollowMean ↑<4 (%) ↓Medianp90
TextRAG37.617632663194.728.43.912.4
TableRAG48.276225726604.3932.28.917.1
Interactive-KBQA80.895549179854.856.246.7130.9
HeriKGQA99.0991009899994.793.212.022.9
w/o grounding86.899839866884.789.811.424.4
w/o error correction97.6971009899944.823.28.118.4

Table 1. Answer accuracy, quality, and latency. Accuracy Mean (shaded) averages the five question types. Ablations remove the grounding layer or the error-correction mechanisms. Quality is rated by an LLM judge (Appendix § 13): Mean averages the Readability, Conciseness, and Comprehension scores (1–5), and <4 is the share with any category scored below 4. Best values in bold. †Human evaluators agree with the judge on 79% of its non-tie verdicts and prefer HeriKGQA (66 vs. 28 of 100 questions sampled across judge verdicts; Table 6).

Ablations. Without the grounding layer, the answer-generation LLM still receives the rule definitions, computation conventions, and readings each rule applies to, but must compute the facts and verdicts itself. Accuracy then falls by 12.2 points to 86.8%: basic and temporal questions are barely affected (99% and 98%), as their numbers still come from SPARQL aggregates, but spatial and anomaly accuracy drop to 83% and 66%. 29 of the 34 anomaly errors are declines, as the raw readings the LLM would need exceed the 1,000-row limit; on the 41 verdict questions whose readings fit, the LLM decides 36 correctly, against 41 with grounding (Appendix § 14). The drop thus reflects both the grounding layer’s computation and its answer check, which cannot run without the computed facts. Compared with Interactive-KBQA, which queries the same graph with the same LLM, the compiled intent (w/o grounding) raises spatial accuracy from 54% to 83% and overall accuracy from 80.8% to 86.8%. Removing error correction costs 1.4 points (97.6%), mostly on basic and follow-up questions (97% and 94%): 7 of its 12 errors follow an empty query result, and with error correction 6 of these 7 are answered correctly

through an error-driven retry or intent voting.

Answer quality and latency. Confining the LLM to verbalisation does not reduce answer quality: HeriKGQA scores 4.79 out of 5, on par with Interactive-KBQA (4.85), with the fewest answers rated below 4 in any category (3.2%). TableRAG scores lowest (4.39), as its answers are concise but often incomplete (Comprehension 4.00; Table 5), and removing the grounding layer triples the share of low-rated answers (from 3.2% to 9.8%). HeriKGQA answers in a median of 12.0 s (p90 22.9 s), 3.9 times faster than Interactive-KBQA (46.7 s); the faster TextRAG and TableRAG (median 3.9 s and 8.9 s) stay below 50% accuracy.

SystemMeanBasicSpatialTemporalAnomalyFollowReadabilityConcisenessComprehension
TextRAG4.724.614.704.604.894.774.874.484.80
TableRAG4.394.704.284.583.944.454.314.864.00
Interactive-KBQA4.854.934.844.804.954.714.984.724.84
HeriKGQA4.794.774.854.654.964.724.904.574.90
w/o grounding4.784.824.904.724.704.765.004.634.71
w/o error correction4.824.824.864.674.944.814.994.574.90

Table 5. Answer quality by question type and category, rated by the LLM judge (1–5). Each type score averages the three category scores; Mean (shaded) averages the five types. Best value per column in bold.

Online Deployment

Deployment setup. On the ARGUS project’s infrastructure, HeriKGQA answers sensor-data questions in the platform’s chatbot, alongside a document-based RAG service for general questions about the sites; its data layer runs as four Docker services: a PostgreSQL database storing the sensor data, an ingestion service that polls live readings from the site gateways, another that loads the context data (sites, nodes, sensors, and rules), and an Ontop 5.5 server (Xiao et al., [21]) that exposes the database as a virtual SPARQL endpoint through an OBDA mapping onto PANOPTES. HeriKGQA queries this endpoint, so newly ingested readings are queryable immediately (§ 3.1), and accesses the LLM through the same institutional endpoint as in § 4. Each answer includes an expandable References section that shows its parsed intent, SPARQL query, and retrieved data (Figure 3), so users can inspect how it was computed.

HeriKGQA deployed in the chatbot of the ARGUS platform

Figure 3. HeriKGQA deployed in the chatbot of the ARGUS platform. Users select a pilot site (top left; here the House of Masks, Delos), shown as a 3D model with its sensor nodes, and ask questions in the chat panel (right). Each answer states the time of the latest reading used and its data source, with an expandable References section holding the parsed intent, SPARQL query, and retrieved data behind it, and a feedback prompt.

Lessons from development. Three issues on real sensor data shaped the design. *Vocabulary mismatch: users name quantities differently from device channels (e.g., “soil temperature” for soil_temperature), which motivated giving the parser all entity and property labels in GG. Label resolution: resolving result URIs to labels one at a time dominated query time, and batching them into VALUES queries of 50 URIs halves retrieval time for a 200-row result. LLM capacity: when we first let the LLM compute averages from the retrieved rows, its results on 12 test questions were off by 4% on average and up to 21%, which motivated computing requested statistics in SPARQL.

Evaluation on real user questions. From 21 August to 14 October 2026, the deployment logged 618 queries from project partners and site managers; 239 were routed to HeriKGQA, the others to the document service or general replies. After removing duplicates, misrouted, and overly vague questions, we kept 80 questions about the sensor data and replayed them retrospectively: all systems were re-run over the frozen snapshot (the two follow-ups with their preceding turns) and scored against references computed under benchmark conventions. This measures replay accuracy, not that of the original live answers. HeriKGQA answers 78.8% (63/80) correctly, ahead of its ablations without grounding (73.8%) and error correction (70.0%) and of Interactive-KBQA (57.5%). Error correction contributes more here than grounding (7 vs. 4 questions), as free phrasing more often uses labels not in the graph. HeriKGQA and Interactive-KBQA both correctly decline the 11 questions about data or rules the snapshot lacks, so the gap comes from the remaining 69 questions, which need a substantive answer (52 vs. 35 correct); HeriKGQA’s 17 errors mostly involve places not modelled as sites in the knowledge graph, results above the 1,000-row cap, and long answer lists.

Related Work

Cultural heritage monitoring. Ontologies combining SOSA/SSN with CIDOC-CRM link sensor data to heritage documentation, from sensor-enabled digital twins ([10]) to our previous ontology PANOPTES ([12]). SigSPARQL ([14]) adds signal operators to SPARQL for sensor monitoring. Heritage question answering, however, targets static knowledge, like intangible heritage ([23]), museum content ([17]), and numerical aggregation over genealogical graphs ([15]), not live sensor data.

LLMs over structured data. LLMs struggle with precise computation over tables ([9]). A common remedy has the LLM write code that an engine runs, such as table operations in Chain-of-Table ([20]) or SQL in MAC-SQL ([18]), and TableRAG ([2]) scales this to million-cell tables by retrieving relevant columns and cells; their results are only as correct as that code. Plan-Compiler ([6]) instead compiles a validated, typed LLM plan deterministically, but for generic data-processing workflows.

Knowledge graph question answering. LLM-based KGQA ([11]) either reasons over the graph, as in Think-on-Graph ([16]), or generates executable queries, as in Interactive-KBQA ([22]), schema-aware SAGA ([25]), and a data-centre telemetry chatbot ([8]). These methods return entities, timestamps, or the results of queries the LLM writes, rather than the spatial, temporal, and rule-based facts that HeriKGQA computes deterministically from observations.

Conclusion

We presented HeriKGQA along with a heritage sensor knowledge graph and a QA benchmark with validated reference answers. Its core principle is that the LLM neither computes nor writes the code that computes: it parses questions into constrained intents and verbalises grounded values, while compiled SPARQL and pre-implemented functions compute every number. HeriKGQA is more accurate than all baselines and ablations, with comparable answer quality and low latency, most clearly on spatial and anomaly-related questions, and the principle transfers to other domains through a new ontology mapping and rule implementations.

Limitations

While HeriKGQA answers heritage sensor questions accurately, our work has five main limitations.

Benchmark coverage. Our 500-question benchmark covers five question types, but its questions are generated from templates over a single snapshot. Questions that real users asked during deployment are phrased more variably, combine several constraints, or rest on false premises, which the templates do not capture. Our evaluation on 80 user questions (§ 5) only partly addresses this, and we plan to extend the benchmark with user questions in future work.

Graph-specific grounding layer. Although the principle transfers to other datasets such as MultiTQ, the temporal, spatial, and anomaly computations are written for this knowledge graph: they encode which classes carry timestamps, which properties hold coordinates, and the anomaly rules, re-implemented from their original definitions. The parser and the SPARQL compiler read the schema from the ontology, so new classes and properties can be queried without code changes, but a new type of analysis or rule set requires new code.

In-context examples. The parser’s 14 examples, none from the benchmark, cover existing question types, whereas baselines receive at most three demonstrations (Table 4). With prompts fixed, grounding accounts for 12.2 of the 18.2-point margin over Interactive-KBQA; the remaining 6.0 may partly reflect both the in-context examples and the intent parsing, neither of which we ablated.

Large results are declined. Questions whose listings exceed 1,000 rows are declined rather than truncated, to avoid answers computed from a sample. Questions that genuinely need many rows, such as listing all readings in a long window, are therefore outside the system’s scope.

Human evaluation. The human evaluation compares HeriKGQA only with Interactive-KBQA on 100 sampled answer pairs, rated by three evaluators. Agreement is low (Fleiss’ κ=0.129\kappa= 0.129), partly because the evaluators used “tie” at very different rates, and because answers from two systems using the same LLM are often hard to distinguish.

Ethics Statement

Use of AI assistants. Beyond the LLMs evaluated and used as system components in this work, we used generative AI assistants to polish the writing and help draft code. The research ideas and system design are the authors’ own; the authors reviewed and verified all AI-assisted text and code and take full responsibility for the paper’s content.

Human evaluation. Answer quality was compared by three volunteer evaluators with mixed backgrounds in cultural heritage and musicology. One of the three evaluators is a co-author. Evaluators were informed of the study’s purpose and saw only questions and anonymised system outputs, and no personal information was collected about them beyond their academic background.

Data and deployment. The sensor data are open to the public under the project policy. In the deployment, questions, answers, and ratings are logged anonymously for research, as stated in the interface, without recording users’ personal information.

Risks. Wrong answers could mislead conservation decisions. HeriKGQA mitigates this by computing every number deterministically, declining unanswerable questions, and exposing the time range, intent, and SPARQL query behind each answer, to support rather than replace expert judgement. LLM calls go to an institutional endpoint, so no monitoring data reach third parties.

Acknowledgment

This work has been supported by the ARGUS EU project (Grant Agreement No. 101132308), funded by the European Union. Views and opinions expressed are however those of the author(s) only and do not necessarily reflect those of the European Union or of the European Research Executive Agency (REA). Neither the European Union nor the granting authority can be held responsible for them. We thank Ziyue Chen and Ruiyu Ren (University of Cologne) for the human evaluation.

Data and Benchmark

Data. Offline experiments use a frozen snapshot of the sensor database from 13 May to 12 August 2026 (Table 2(a)): 71 sensor nodes at five heritage sites host 113 sensors reporting 137 distinct observed properties, giving 1,677,556 readings and 5,227,617 observations. Each observation carries spatial context (the latitude, longitude, and altitude of its node, known for 68 of the 71 nodes) and temporal context (its timestamp), and is reported on a raw device channel such as temperature or voltage_1. Of the 37 anomaly rules (Table 2(b)), 19 have usable readings at their site. Of the other 18, 12 refer to quantities that no sensor at that site reports, such as crack width, tilt, or indoor humidity; 5 refer to quantities reported, but not in the form the rule uses: rainfall as intensities and running totals, not windowed amounts (three rules, Baltanas and Delos), humidity on channels Baltanas’s rule excludes, and GNSS as raw fixes, not long-term series; and one humidity rule (Delos) needs smoothing not reproducible on irregular readings.

Questions. We wrote 52 templates covering basic (counts and statistics of a quantity), spatial (node positions, distances, and centroids), temporal (time spans, daily or monthly statistics, and relative windows), anomaly-related (rule verdicts and thresholds), and follow-up questions (e.g., “What about Delos?”), each preceded by one earlier turn (88 questions) or two (12). Spatial questions include “Which two nodes at Baltanas are closest together?”, where distances matter at scale (the 19 nodes at Delos span up to 1,670 m), and temporal questions include “What time period do the readings at Baltanas cover?”. Templates are instantiated with entities from the snapshot and sampled with a fixed seed and per-template quotas, giving 100 questions per type and 95–124 per site; questions coinciding with any system’s in-context examples are excluded. No template was held out, so the benchmark measures accuracy on these question forms; generalisation to unseen formulations is evaluated separately on real user questions (§ 5) and on MultiTQ (Appendix § 15). Seven questions cannot be answered from G\mathcal{G}, as they ask for unmeasured quantities (e.g., CO2_2), unmodelled information, or periods outside the snapshot, and should be declined. Of the anomaly-related questions, 30 ask for a threshold and 70 for a verdict, balanced over Yes (23), No (25), and Cannot be determined (22). Table 3 shows example questions with reference answers, including undeterminable and unanswerable ones.

TypeQuestionReference answer
BasicWhat is the average soil temperature observed at Baltanas?28.216
SpatialWhat is the distance between sensor nodes AF3 and GNSS-Rover at Baltanas?11.0 m
TemporalWhat was the average temperature at Baltanas over the last 24 hours?25.871 (4,713 observations, window ending 12 Aug, 09:15)
AnomalyAccording to the AD-RT anomaly rules, was there a rainfall anomaly at Ranverso on 2026-07-20?No: 7-day rainfall 5.2, below the threshold of 20 (R2_rain_7d)
Follow-upQ1: What is the average temperature at Lucretili? (23.639 °C) Q2: What about Baltanas? (21.722 °C) Q3: And the maximum there?44.6 °C
Undeterminable (anomaly)Did the crack width at Schenkenberg exceed its AD-RT threshold on 2026-06-02?Cannot be determined: no crack width readings at Schenkenberg
UnanswerableWhat is the average CO₂ concentration at Lucretili?Declined: no CO₂ data

Table 3. Example benchmark questions. In the follow-up, earlier turns are shown with their reference answers.

Reference answers. References are computed from the snapshot in separate SQL and Python code that follows the rule conventions of Appendix § 12. Times are in UTC, relative windows end at the last observation (12 August 2026, 09:15), distances are haversine distances on a sphere of radius 6,371 km (between nodes, also accepted with their altitude difference), and centroids are mean node coordinates. For anomaly questions, each (sensor, quantity) series is evaluated separately over windows that end at the rule’s latest matching reading on or before the named day (or the snapshot’s end), and series without readings in a window are skipped. A z-score rule compares each series’ latest reading up to the end of that day with the mean and standard deviation of the series’ readings up to then; as no recency is required, a series that has stopped reporting contributes its last reading; 4 Yes verdicts at Schenkenberg rest on stale readings (up to 29 days old). The verdict is Yes if any applicable rule fires, No if every applicable rule was evaluated and none fired, and Cannot be determined otherwise. The rules of a question share their input quantity and are either all evaluated or none is, so no verdict rests on a subset of its rules. For the same reason, this definition coincides on the benchmark with the one in the baselines’ prompts (Appendix § 16), under which No requires at least one evaluated rule and none fired. A second, independent SQL implementation, which also recomputes earlier follow-up turns, reproduces the reference for all 489 questions whose answer can be computed, including the 2 unanswerable questions about unmeasured quantities, for which it finds no data; there is no disagreement. The other 11 (the 5 unanswerable questions about unmodelled information or periods outside the snapshot, and 6 anomaly questions with no applicable or evaluable rule) were adjudicated manually. Co-authors and colleagues from the pilot sites validated all references. Both implementations, per-question verification queries and decisions, and the matching rules (numerical tolerance, units, timestamps, lists) are in our repository.

Implementation Details

Knowledge graph mapping. Each sosa:ObservationCollection is linked to the sensor that produced it, the node hosting that sensor, and the site where the node is deployed, so that every reading can be traced from its value to its site. Each anomaly rule is mapped to an instance of Policy, the PANOPTES class for conservation policies, which links the rule’s definition and site-specific threshold to the site it applies to. Beyond policies, PANOPTES also models threats and conservation decisions.

Parsing and compilation. The parser’s system message contains the intent schema, an operator guide, the main graph paths, the rules that keep computation out of the parser, and 14 few-shot examples, followed by the schema of instantiated ontology classes, the labels of all observed properties, sites, and nodes, and each site’s rule identifiers, so that filters use the graph’s own names (e.g., soil_temperature). The user message holds the reference time (the latest observation in gg), the last h=2h = 2 question–intent pairs with result summaries, the question, and, on a retry, the error, failed query, and previous intent. An intent is a JSON object with target_class, filters, return_properties, joins, aggregation (count, min, max, avg, sum, or range, optionally grouped by a property or by day or month), order_by, limit, anomaly_check, as_of, relative_time, and unanswerable, a reason for declining without a query. Invalid intents (e.g., contradictory filters) and non-JSON outputs trigger a retry. Compilation maps names to ontology identifiers: the target class becomes a type triple, return properties and unfiltered joins become OPTIONAL patterns, filters become FILTER expressions (a bare date denoting the whole UTC day), relative windows become timestamp filters ending at the reference time, and aggregations become aggregate functions with GROUP BY. Every aggregate also returns the number of aggregated entities (n_values), and a result with n_values = 0 is treated as empty, so that an average over no data is not reported as 0. A limit combined with joins compiles into a subquery, so that “the highest node at Baltanas” ranks only Baltanas’s nodes. For exam-

ple, “What was the highest temperature at Baltanas in the last 24 hours?” compiles to:

SELECT (MAX(?v) AS ?max)
(COUNT(DISTINCT ?obs) AS ?n_values)
WHERE {
  ?oc a sosa:ObservationCollection ;
      sosa:resultTime ?t .
  FILTER(STR(?t) > "2026-08-11T09:15:00+00:00")
  ?oc herikg:hasObservation ?obs .
  ?obs sosa:observedProperty ?p .
  ?p rdfs:label ?pl .
  FILTER(LCASE(STR(?pl)) = LCASE("temperature"))
  ?oc herikg:hasSite ?site .
  ?site rdfs:label ?sl .
  FILTER(LCASE(STR(?sl)) = LCASE("Baltanas"))
  ?obs sosa:hasSimpleResult ?v . }

Timestamps are rendered as UTC ISO 8601 strings with offset +00:00, so lexical comparison matches chronological order; no upper bound is needed, as the reference time is the latest observation.

Follow-up resolution and execution details. The parser runs at temperature 0, which also yields the greedy parse used in intent voting. For follow-ups, each result summary contains the row count, column names, and up to eight sample values; a newly named site or quantity replaces the previous one, and “among these” inherits the previous target and filters. Relative windows that lie entirely outside the data are declined, and the 1,000-row cap applies only to rows passed to the answer LLM, not to rule readings. Queries run on Ontop 5.5 over the read-only PostgreSQL snapshot with a 120 s timeout; URIs are resolved to labels in batches of 50, as Ontop rejects batches of 100, and non-aggregated results above 1,000 rows are declined.

Grounding and answer generation. Beyond the facts of § 3.3, temporal facts are measured from the latest observation in GG, and spatial facts add all pairwise distances for results of at most 25 nodes, per-site centroids for multi-site results, and facts about the nodes named in the question. For an anomaly question, the rules of the named site that match the named quantity are retrieved; running totals (cumulative rainfall and visitor counts) and rainfall intensity are never matched, as rule thresholds refer to amounts within a window. Direct rules compare the latest reading with the threshold, windowed rules compute a sum, mean, or range over 1 h to 7 d, z-score rules compare the latest value with the mean and standard deviation of the sensor’s values up to the cutoff, and custom rules compute metrics such as the rate of change or a combination of two quantities; series are combined by their maximum, or minimum for rules that fire on low values or variability. The question’s verdict follows the definition in Appendix § 11. The answer LLM additionally receives the executed query and, for a follow-up, the earlier questions and the parser’s interpretation; its prompt asks for one to three sentences that do not present a limited result as complete and avoid internal identifiers. Besides checking numbers, the verifier requires an anomaly answer to lead with the computed verdict; if the regenerated answer fails again, a template answer listing the rows and facts, or the verdict and evaluated rules, is returned. Every answer ends with the time range of the data it rests on.

Rule implementations. The 19 evaluable rules are implemented once, for both the grounding layer and the rule definitions given to the baselines (Appendix § 16). A rule fires when its metric exceeds the threshold, or falls below it for R4b_soil_low and R5a_airflow_const, which detect low values or variability; R1_temp_hum fires when temperature falls below and humidity exceeds their thresholds. Windows end at the latest matching reading on or before the cutoff, and thresholds are stated in the channels’ raw units. Eight rules approximate their expert definitions: R5a_airflow_const, R5b_airflow_range, and R9a_temp_lt use a rolling 24 h window instead of calendar days; R4c_hum_rapid_1h and R9b_temp_st take the largest change between consecutive readings in a rolling 1 h window instead of AD-RT’s resampled bins; R4b_hum_persist_7d and R6b_rain_cum7d take a plain mean or sum over the raw readings of the 7-day window, the former instead of a mean of daily means; and R1_temp_hum pairs the latest reading of each quantity rather than readings at the same timestamp. Z-score rules use the population standard deviation of the series up to the cutoff. No rule requires a minimum number of readings or a recent one, so a series that has stopped reporting contributes its last value (Appendix § 11). The Delos humidity rule that requires smoothing is not implemented and is flagged without a verdict; the rule code is versioned in our repository.

Settings and ablations. All results come from a single run per system. The parser votes over n=3n = 3 intents, the greedy parse and two sampled at temperature 0.7, and is retried at most k=2k = 2 times; the answer LLM runs at temperature 0.3. All systems use gpt-oss-120b through an OpenAI-compatible endpoint (three concurrent requests, exponential backoff, 120 s timeout) and qwen3-embedding-8b for embeddings. Systems run one after another on the same endpoint to make latencies comparable. The w/o grounding ablation computes no facts; for anomaly questions, each rule’s windowed readings and definition are passed to the answer LLM, which must reach the verdict itself, and these readings count towards the 1,000-row limit. The answer check, defined against the computed facts, is skipped. The w/o error correction ablation uses a single greedy parse, no retries, and no answer check, but an anomaly answer not leading with the computed verdict is still replaced by the template.

Baselines. All baselines use the same LLM, receive the earlier questions of a follow-up, and are instructed to lead anomaly answers with the verdict and to say when the data cannot answer a question; Table 4 compares them. TextRAG serialises observations as text rows chunked by site, node, sensor, observed property, and day, with separate chunks for sites, nodes, rules, threats, and decisions; it retrieves chunks with BM25 and dense retrieval fused by reciprocal rank fusion, up to 1,000 rows or 50 chunks, and answers in one call. TableRAG (Chen et al., [2]), designed for million-cell tables, runs the official agent with its default settings (query expansion, schema and cell retrieval with K=5K = 5 and B=10,000B = 10{,}000, and a ReAct solver executing pandas commands for at most five steps) over the snapshot flattened into one table, with one row per observation, one per reading without observations, and one per rule; we raise the per-step output limit from 128 to 4,096 tokens, as the model reasons before answering. We verified on these runs that final answers are parsed as in the official code. Interactive-KBQA (Xiong et al., [22]) keeps its three tools (SEARCHNODES, SEARCHGRAPHPATTERNS, and EXECUTESPARQL), reimplemented over our graph, with a tool description covering the schema and three graph-specific patterns and three demonstration dialogs. Each of at most ten steps keeps the most frequent of n=3n = 3 candidate actions sampled at temperature 0.7, matching HeriKGQA’s intent voting, and a final call verbalises the dialog, since the original returns only query results. scoring. We use the same three categories for every answer so that scores are comparable across systems and question types: Readability, Conciseness and Comprehension (whether the response addresses what the question asks); categories that require the correct answer are excluded because correctness is measured by accuracy. The judge prompt (Figure 4) varies only in the questions and the responses; HeriKGQA’s provenance note is removed so that it does not reveal the system. For a follow-up question (e.g., “And on the following day?”), earlier questions of its conversation are listed before the current question. The judge is deepseek-v4.1-flash (552B parameters), run on an institutional LLM endpoint with FLASK’s temperature of 0.2, unlike gpt-oss-120b, which all

LLM-as-judge prompt

Figure 4. LLM-as-judge prompt (adapted from FLASK’s prompt [24] without sample answer; rubrics omitted). Only the questions and responses vary; for a question without earlier turns, only the current one is shown.

Answer Quality Measurement

LLM-as-judge. We rate answer quality with the LLM-as-judge protocol of FLASK [24], which scores a response on fine-grained quality categories, each with its own 1–5 rubric. We reuse FLASK’s2 prompt, category rubrics and score parser and adapt only the choice of quality categories, the inputs, the judge and its output limit, which we raise because the judge reasons before systems use. We report the mean score of each category and question type per system in Table 5.

Human evaluation. The human evaluation was carried out on the answers of an earlier run of the same two systems on a previous version of the data snapshot, which contained fewer sensor measurements. As a diagnostic check of the LLM judge, three volunteer evaluators compare HeriKGQA with Interactive-KBQA pairwise, as pairwise preferences are more reliable than absolute ratings for human evaluators (Zheng et al., 2023). Since the judge scores each answer separately, we derive its pairwise verdict from the two answers’ quality scores averaged over the three categories; scores differing by less than 0.1 are a tie. We select 100 of the 500 questions across the three verdicts: the 34 and 33 questions with the largest score gaps in favour of HeriKGQA and of Interactive-KBQA, respectively, and 33 random ties. For each question, evaluators independently choose the better answer or a tie, based on the judge’s category descriptions (Figure 4). The answer order is randomised, and evaluators do not see the system names, the provenance note or the judge’s verdict. The human label is the majority vote (a tie if all three disagree). Table 6 reports the results. Inter-evaluator agreement is slight (Fleiss’ κ=0.129\kappa= 0.129), mainly because evaluators used “tie” at very different rates (3, 18, and 28 times), while all three prefer HeriKGQA more often than Interactive-KBQA. The human label matches the judge on 79% of its non-tie verdicts (91% when the judge favours HeriKGQA, 67% when it favours Interactive-KBQA), likely an

nnHeriKGQAIKBQATieAgree w/ judge
By judge verdict
HeriKGQA win34311291%
IKBQA win331022167%
Tie3325539%
By evaluator
Evaluator 110067303–
Evaluator 2100513118–
Evaluator 3100423028–

Table 6. Human pairwise evaluation of HeriKGQA versus IKBQA (Interactive-KBQA) on 100 questions sampled evenly across judge verdicts (human label: majority vote). Inter-evaluator agreement is slight (Fleiss’ κ=0.129\kappa= 0.129; observed 48.0%, chance 40.3%): all three agree on 23% of questions and at least two on 98%. Answers come from an earlier run (Appendix § 13).

upper bound since these are the judge’s clearest verdicts, but on only 9% of its ties, where humans prefer HeriKGQA on 25 of 33 cases. Across these 100 questions, humans prefer HeriKGQA on 66 and Interactive-KBQA on 28.

Failure Analysis and Case Studies

Failure taxonomy. We assign each wrong answer to exactly one category, checked in the following order: (i) no answer (an empty answer, or a reasoning or tool-call trace instead of an answer); (ii) declined (size) (declined because the results exceed the 1,000-row cap); (iii) false abstention (an answerable question answered with “cannot be determined” or “no data”); (iv) missed decline (an unanswerable question answered anyway); (v) wrong verdict (a wrong anomaly verdict); and (vi) wrong value (a wrong number, timestamp, node, or site, or a failed query). Table 7 gives the counts.

SystemWrongNo answerDeclined (size)False abst.Missed declineWrong verdictWrong value
TextRAG3128061044199
TableRAG2599205312588
Interactive-KBQA96201932547
HeriKGQA5002102
w/o grounding6603521523
w/o error corr.12009102

Table 7. Wrong answers out of 500 per system, by first matching failure category (in column order).

HeriKGQA’s errors. None of HeriKGQA’s five errors comes from arithmetic. Four start in the parser and one in query execution. Two are false abstentions. In A071, the parser reads “1-hour and 24-hour rainfall rule” as a rule the graph lacks, because the rule’s name (“rainfall short window”) does not mention its two windows. In F099, a follow-up asking “And the relative humidity?” at Lucretili, the parser declares relative humidity unmodelled, although in the five other relative-humidity questions it maps the quantity to the weather station’s humidity channel. In the missed decline (B099), the parser maps “solar radiation” to the illuminance channel (measured in lux) and reports its mean instead of declining. In T099, the parser omits the aggregation for “What was the relative humidity at Baltanas on 2026-07-01?”. The query therefore returns the 45 distinct values rather than all 296 readings, and their mean (55.2%) differs from the reference (57.1%). In T025, the compiled ranking query for the highest peak ground acceleration at Schenkenberg exceeds the 120 s timeout, and each ysady re-parse yields an equivalent query that times out as well. Rule retrieval matches the quantity by keyword and can also retrieve an unrelated rule: in A061, “wind” also matches the description of a rainfall rule (“short-window rainfall”), which is evaluated and found within its threshold. As No requires every retrieved rule to be evaluated, and the actual wind rule has no readings up to that day, HeriKGQA still answers Cannot be determined, as the reference does; an unrelated rule that fired, however, would still yield a wrong Yes.

Error correction. Without error correction, 7 of the 12 errors follow an empty query result. In B094 and F025, a misplaced join (a reversed node join; a value attached to the reading rather than its observation) returns no rows. In B098, F098, F100 and F036, a property label is not in the graph (“humidity” instead of the channel hum1, and “soil water potential” instead of soil_water_potential). With error correction, 6 of these 7 questions are answered correctly, either because the empty result is fed back to the parser for a retry or because voting selects a parse whose query returns rows. In the seventh, T099, voting selects such a parse, so no retry is triggered, but that parse omits the aggregation (see above). Overall, 12 questions need at least one retry and 11 of them are then answered correctly; the exception is T025, where every query times out. The answer check triggers a regeneration for 107 of the 500 answers, and 55 of these are replaced by the deterministic template answer.

Baselines. Interactive-KBQA mostly computes wrong values (47) or verdicts (25), and 12 of its 19 false abstentions come without a single query that returned rows. TextRAG’s errors are dominated by wrong values (199 of 312), since aggregates cannot be computed from a sample of rows, and 61 of its answers wrongly declare the retrieved data insufficient. Of TableRAG’s 500 runs, 352 end with a final answer and 148 exhaust the five ReAct steps, in which case the final step is taken as the answer; 92 of these 148 yield no answer, as the final step is reasoning or a pandas command.

Why anomaly accuracy drops without grounding. Without grounding, HeriKGQA answers 66 of the 100 anomaly questions correctly instead of 99, and its 34 errors have two causes. In 29 questions, all of them verdicts at Lucretili and Schenkenberg, the raw rule readings passed to the LLM exceed the 1,000-row cap (up to 75,344 rows), so the system declines; with grounding, these readings are evaluated in code and never enter the prompt.

Of the 41 verdict questions whose readings fit, the LLM decides 36 correctly, against 41 with grounding. Four of its errors answer No where no matching readings exist, treating the absence of an exceedance as evidence that none occurred, and one pools readings across sensors (Case 1). Threshold lookups, which need no computation, are unaffected (30/30).

Case 1: pooled sensors cause a false alarm (A005). For “According to the AD-RT expert rules, was there a temperature anomaly at Lucretili on 2026-05-14?”, rule R9a fires when a sensor’s daily temperature range exceeds 20 °C. The window holds 911 readings from 17 sensors, with a largest per-sensor range of 19.0 °C, so the reference is No, as HeriKGQA answers. Without grounding, the LLM receives the same readings and the instruction to evaluate each sensor separately, yet answers Yes with a range of 20.7 °C: the maximum of one sensor (22.7 °C) minus the minimum of another (2.0 °C). Interactive-KBQA makes the same mistake with the same numbers.

Case 2: geodesic arithmetic (S005). For “How far apart are the two most distant sensor nodes at Schenkenberg?”, the reference is 5.3 m, or 8.4 m with the altitude difference; HeriKGQA obtains the former from pairwise haversine distances. Other systems estimate or misread it. Without grounding, the LLM picks the pair farthest apart with altitude but reports only their altitude difference (8.2 m). Interactive-KBQA derives about 5.9 m from the ranges of latitude and longitude, which no node pair spans. TextRAG picks the same pair but overstates its horizontal offset (5 m instead of 1.6 m, about 10 m in total), and TableRAG answers “0 km”. When nodes lie a few metres apart, approximate coordinate arithmetic is too imprecise.

Case 3: a z-score rule needing the full series (F073). For “Was the vibration at Schenkenberg anomalous on 2026-07-23 according to its AD-RT rules?”, the user asks “What about on 2026-07-27?”. Rule R3 compares each sensor’s latest reading up to that day with the mean and standard deviation of its series. All systems resolve the follow-up, and HeriKGQA correctly answers Yes (z-score 7.42). The baselines all answer Cannot be determined: Interactive-KBQA queries only the wrong ground-acceleration series, ending in May; TextRAG retrieves no vibration readings; TableRAG filters the day’s rows but computes nothing. None assembles the per-sensor series a z-score needs. Without grounding, HeriKGQA declines: the raw readings of the two vibration rules (63,041 rows across all sensors) exceed the 1,000-row cap.

Additional Experiments

Generality on MultiTQ. We also evaluate HeriKGQA and Interactive-KBQA on 500 test questions from the temporal KGQA benchmark MultiTQ ([3]), sampled across its six question types. Porting HeriKGQA replaces only its domain-facing parts (the ontology, prompts and 8 few-shot examples, an entity linker for the graph’s ∼10.5k\sim10.5\mathrm{k} entities, and a script loading the data, about 500 lines in all), while the compiler and error correction are reused and the temporal grounding layer gains one generic extension, a time filter anchored at another event’s time (under 100 lines); both systems use gpt-oss-120b and the same entity linker. HeriKGQA is competitive, with a modest advantage in this single run (75.4% vs. 73.4%; Table 8(a)): it gains on questions answered by an ordering over timestamps (e.g., Before Last, +6.0), which the compiler expresses in SPARQL, but trails slightly where a reference time must be resolved from another event, since it declines when that lookup fails. The design thus carries over to a different graph with competitive accuracy, and its advantage is clearest on heritage data, where spatial and rule-based computation matters most.

(a) Generality: MultiTQ
SystemMeanEqualBefore/AfterFirst/LastEqual MultiBefore LastAfter First
HeriKGQA75.494.071.496.353.767.969.0
Interactive-KBQA73.490.572.692.756.161.966.7
(b) Robustness: backbone LLM on our benchmark
BackboneMeanBasicSpatialTemporalAnomalyFollow-up
gpt-oss-120b99.099100989999
qwen3-8-27b99.098999910099

Table 8. Robustness of HeriKGQA. (a) Accuracy (%) on 500 MultiTQ questions sampled across its six question types (82–84 each), with both systems using gpt-oss-120b. (b) Accuracy (%) of HeriKGQA with two LLM backbones on our 500 benchmark questions (100 per type) as in Table 1. Mean averages question types. Best per panel in bold.

Smaller backbone. To test whether HeriKGQA depends on a large LLM, we rerun it on the 500 benchmark questions with qwen3-8-27b, a 27B-parameter model, in place of gpt-oss-120b, leaving the configuration, prompts, embeddings and snapshot unchanged. Accuracy does not drop (99.0% with both backbones; Table 8(b)): the two backbones differ on only 6 questions, 3 in each direction. Of the 3 questions that only Qwen gets wrong, two report the number of observations instead of readings and one names the wrong nearest node. Because the LLM only has to map a question to an intent, and every number in the answer is computed by SPARQL and the grounding layer, a smaller backbone is enough.

LLM Prompts

This appendix shows the main parts of the prompts sent to the LLM, rendered from the experiment code; omitted parts are marked with square brackets, and everything else is verbatim. None of the parser’s 14 few-shot examples is a benchmark question; questions coinciding with any system’s in-context examples were excluded (Appendix § 11).

Semantic parser (system message). The parser outputs an intent and computes nothing: statistics are computed in the query, and distances, times and rule verdicts by the grounding layer.

You are a semantic parser for a heritage sensor knowledge
graph.

Given a natural-language query, output ONLY a valid JSON
object (no markdown fences)
with this exact schema:

{
  "target_class": "<class name, one of: Asset, AssetState,
      Decision, Device, DeviceType, EngineeringUnit,
      InstalledDevice, InstalledInstrument, Instrument,
      InstrumentType, Location, Node, Observation,
      ObservationCollection, ObservedProperty,
      PhysicalQuantity, Policy, Sensor, Site, Threat>",
  "filters": [
    {"property": "<property>", "op":
      "contains|equals|in|gt|lt|from|until|after|before",
      "value": "<string, or a list for in>"}
  ],
  "return_properties": ["<list of properties to SELECT>"],
  "joins": [
    {
      "class": "<related class>",
      "via": "<property name>",
      "direction": "outgoing|incoming",
      "return_properties": ["<properties of the related
      class>"],
      "filters": [
        {"property": "<property>", "op":
          "contains|equals|in|gt|lt|from|until|after|before",
          "value": "<string, or a list for in>"}
      ]
    }
  ],
  "aggregation": null or {"type":
      "count|min|max|avg|sum|range", "group_by":
      "ClassName.property", "time_bucket":
      null|"day"|"month", "target": "<class or property>",
      "distinct": true|false},
  "order_by": null or {"variable": "ClassName.property",
      "direction": "ASC|DESC"},
  "limit": null or <integer>,
  "anomaly_check": true|false,
  "as_of": null or "<ISO date or datetime, e.g.
      '2025-02-11'>",
  "relative_time": null or {"amount": <integer>, "unit":
      "hours|days|weeks"},
  "unanswerable": null or "<what the knowledge graph does not
      model>",
  "explanation": "<one sentence>"
}

[Operator guide: contains, equals, gt/lt, in, from, until, after, before.]

Key graph paths (direct edges — use these for joins): ObservationCollection —[hasSite]→ Site ObservationCollection —[madeBySensor]→ Sensor ObservationCollection —[hasObservation]→ Observation ObservationCollection —[hasNode]→ Node Observation —[observedProperty]→ ObservedProperty [Multi-hop paths, variable naming, node coordinates, the governance graph of rules and pilot metadata.]

Rules: [...]

  • "unanswerable": set (to a short reason) ONLY when the question needs something this knowledge graph does not model at all — e.g. ownership, costs, opening hours, construction materials, people — i.e. nothing in the schema or the label lists could hold it. Never for a quantity or period that might merely have no readings (that is decided by running the query), and never for an expert-rule/anomaly question (whether a rule applies is decided by the AD-RT rule evaluation). Leave the rest of the intent minimal when set.

Queries and aggregation (rules of the query compiler): [...]

  • AGGREGATE FIRST — this is a correctness rule, not an optimisation. If the question asks for a statistic ("average", "mean", "total", "sum", "how many", "highest", "lowest", "maximum", "minimum"), you MUST set "aggregation" so the statistic is computed inside the query. Detail rows go through DISTINCT de-duplication, so any average, sum or count derived from them afterwards is WRONG. Only omit "aggregation" when the user genuinely wants the individual values listed, or when the statistic depends on distances between nodes (see the spatial rules: those are computed downstream from the coordinates).

[...]

Time (rules of the temporal layer):

  • Time periods are resultTime filters, written with bare dates and from/until, both ends inclusive: [...]

  • "relative_time": set for a window that ends now ("in the last 24 hours", "over the past 7 days", "this past week" = 1 week). "Now" is the latest reading in the knowledge graph (given with the query as the reference time), not today's date; the window is turned into a resultTime filter downstream, so do NOT also add resultTime filters for it. Null otherwise.

[...]

Spatial questions (rules of the spatial grounding layer):

  • Counting or picking nodes BY DISTANCE ("how many nodes are within R m of X", "which node is closest to X") is a spatial question, not an aggregation: set aggregation to null and return the coordinates of all nodes of that site — the count or the nearest node is computed downstream from the distances. An aggregation here would count the site's nodes without any distance.

[...]

Expert rules and anomalies (rules of the AD-RT rule evaluation): [...]

  • "anomaly_check": true only for a yes/no verdict against a known threshold ("has X exceeded threshold", "is there an anomaly"). False for a plain "what is the threshold for X" lookup, which wants the definition, not a verdict.

  • When anomaly_check is true: build the intent exactly like a Policy threshold lookup (target_class=Policy, filter by ruleId/label contains the quantity, join Site via appliesToSite) — do NOT join or aggregate Observation data yourself — separate deterministic step (outside this JSON) takes the rule(s) this query returns and checks each against its threshold; it needs the rule identity first, which is what this query provides. Do not switch off anomaly_check because the question mentions a quantity/site.

[...]

Follow-up handling (earlier turns may appear above as question → intent pairs):

  • Treat the current question as SELF-CONTAINED by default.

  • If it can be understood on its own, IGNORE the earlier turns completely.

  • When resolving, copy only the specific missing piece. NEVER carry over filters, aggregations, limits, joins or target_class that the current question does not itself imply. A new site/quantity mentioned now REPLACES the old one — it does not add to it.

  • Relative periods in a follow-up ("the following day", "the next month", "the day before") are relative to the period of the previous turn — not relative to the previous intent and shift it: previous "on 2025-03-04" + "the following day" → from 2025-03-05, until 2025-03-05.

[...]

--- EXAMPLES ---

Q: "Did the airflow at Baltanas trigger an expert-rule alarm on 2025-02-11?"

{ "target_class": "Policy", "filters": [{"property": "ruleId", "op": "contains", "value": "airflow"}], "return_properties": ["policyDescription", "ruleId", "thresholdValue", "thresholdJson"], "joins": [ {"class": "Site", "via": "appliesToSite", "direction": "outgoing", "return_properties": ["label"], "filters": [{"property": "label", "op": "equals", "value": "Baltanas"}]} ], "aggregation": null, "order_by": null, "limit": null, "anomaly_check": true, "as_of": "2025-02-11", "explanation": "Same Policy lookup as any anomaly_check question — the date is NOT a filter here (Policy has no resultTime), it goes in as_of so the deterministic step checks the rule against readings as of that day instead of the latest available." }

[13 further examples: averages, values and sensors per site, the latest readings, a site's quantities, a monthly count, the month with the lowest mean, a 48-hour count, node coordinates, a threshold lookup, an anomaly check on the latest data, a follow-up, and pilot metadata.]

--- END EXAMPLES ---

[The ontology schema: 26 classes and their properties, generated from the ontology file.]

Labels in this knowledge graph — filter on them verbatim with op equals (or in), choosing the label that matches the user's wording (e.g. "soil temperature" → soil_temperature, "voltage" → voltage, not voltage_1). A quantity named in the question is ONE label: use equals, never contains (contains "voltage" also matches voltage_1 and voltage_polynomial_4). Use contains only when the user explicitly asks for a family ("all voltage channels"). A name that appears under Node.label is a sensor node, not a quantity. [The 71 node labels, the 137 quantity labels, the 5 site labels, and the rule identifiers per site.]

Semantic parser (user message). Earlier turns of a follow-up precede it as question–intent pairs, each with a note on the previous result (row count, columns and sample values).

[Reference time — the latest reading in the knowledge graph: 2026-08-12 09:15:00+00:00 UTC. Relative time is anchored for this time, not to today's date.] Query: <question>

On a retry, append: --- FEEDBACK FROM PREVIOUS ATTEMPT --- <error, failed query and previous intent> Please fix the intent JSON based on this feedback. Use only SHORT property names without namespace prefix. Output ONLY the corrected JSON.

Answer generator (system message). For the w/o grounding ablation, the second sentence reads “You are given a user question and SPARQL results. No numeric summary or analysis is provided.”, the LLM computes times, distances and ranges and receives rule definitions and readings, not verdicts.

You are a concise sensor data analyst for a cultural heritage
monitoring system.

You are given a user question, SPARQL results, and a numeric
summary.

Rules:
- Answer the question directly in 1-3 short sentences.
[...]
- If the question asks about something the results do not
  contain (something the knowledge graph does not model,
  e.g. ownership or costs), say it cannot be answered
  from the knowledge graph — do not answer a different
  question with the rows you have.
- Do NOT output URIs or internal identifiers — use
  human-readable names and labels only.
[...]

Numbers and facts:
- If the analysis has a section "Facts for this question", it
  was computed for exactly what was asked (a named pair's
  distance, the node nearest to a named node, the nodes
  within a radius, the distance between site centroids) —
  answer from it.
- Report numbers as the results/analysis give them, in the
  same unit (do not convert m to km or back) and with at
  least the decimals shown in the analysis (distances to
  0.1 m or 0.1 km).

Statistics:
- When the query already computed an aggregate (a
  count/avg/min/max/sum column), report that value — it
  is the authoritative one.
- Otherwise the rows are a de-duplicated listing, so do NOT
  compute an average, total or record count from them;
  give the values, ranges or examples the rows support
  and leave it there.
[...]

AD-RT rule check (when present in the prompt):
- If a message includes a section starting "AD-RT rule
  check", that verdict (EXCEEDS/within a threshold) was
  computed in Python, not by you — report it as-is, do
  NOT recompute or second-guess it by comparing raw
  numbers yourself.
[...]
- If the prompt says "This is a yes/no anomaly check", START
  with "Yes."/ "No."/ "Cannot be determined." (Yes if ANY
  listed rule fired), then give the supporting numbers
  and, if multiple rules were checked, which fired.

Answer generator (user message).

[For a follow-up: the earlier questions and how the parser
resolved the follow-up.]

User question:
<question>

SPARQL query executed:
```sparql
<compiled query>

Results — all <n> distinct rows (<m> total): <rows as JSON>

Pre-computed spatial & temporal analysis: <facts of the grounding layer>

<AD-RT rule check, for an anomaly question>

(This is a yes/no anomaly check — lead your answer with Yes/No/Cannot be determined.)

[After a failed answer check:] --- YOUR PREVIOUS ANSWER FAILED A CHECK --- <what was wrong>

Write a corrected answer.


An example of the rule check computed by the grounding layer (question A005):

AD-RT rule check for site='Lucretileli', quantity='R9a_temp_lt, R9b_temp_st', as of 2026-05-14T23:59:59 (computed here, not by the model):

  • R9a_temp_lt: daily range (max−min per day). Window(s) ending 2026-05-14T22:00:00+00:00: 24h range=19 (th 20, max of 17 sensor series) → combined metric 19 vs threshold 20 → within. (Despite the '_lt' in the name this is a RANGE rule, not a less-than rule; approximated here as a rolling 24h window.)

  • R9b_temp_st: max absolute 1h change (rate of change). max |consecutive Δ| over 1 = 0.1, max of 6 sensor series vs threshold 5 → within. (approximated as the max consecutive-sample difference| within a rolling real-time 1h window, not AD-RT's resample-bin-based rolling window)


**Instructions added to the baselines.** All three baselines receive the earlier questions of a follow-up, the instruction to lead an anomaly answer with the verdict, and the instruction to say when the data cannot answer the question; TextRAG and Interactive-KBQA also receive the rule definitions, which TableRAG finds as rows of its table. Each rule definition follows the matcher and computation of HeriKGQA’s rule evaluation, e.g.:
  • site Lucretileli: Rule R9a_temp_lt ('AD-RT Lucretileli policy - daily temperature range'), threshold=20, threshold parameters={'R9a_temp_lt': 20}, quantities: label contains any of temp; label contains none of rain_acc, counter_acc, rain_1, definition: daily range (max-min per day), windows: 24h range vs threshold 'R9a_temp_lt', note: Despite the '_lt' in the name this is a RANGE rule, not a less-than rule; approximated here as a rolling 24h window.


TextRAG (system message; the rule definitions are added to the retrieved rule chunks):

You are a sensor data analyst for a cultural heritage monitoring system. You are given a user question and sensor data retrieved for it, as plain-text rows. Answer the question directly in 1-3 sentences, using only the retrieved data, and include the key numbers. If the retrieved data does not contain the information needed, say that it cannot be determined from the data. AD-RT expert-rule evaluation (how a verdict is decided): each rule is evaluated per data series — one quantity of one sensor — never on readings pooled across sensors or quantities; time windows end at the latest matching reading (at or before the end of the day the question names, if any); a rule fires if any series crosses its threshold. A question's verdict is Yes if any applicable rule fires, No if at least one rule could be evaluated and none fired, and Cannot be determined if no applicable rule exists or none could be evaluated (e.g. no matching readings). If the question asks whether an anomaly occurred or a threshold was exceeded, start the answer with "Yes.", "No.", or "Cannot be determined."


Interactive-KBQA (in addition to its original tool description and demonstrations):

[Appended to the tool description: the expert-rule evaluation paragraph given above for TextRAG, and one definition per rule, 37 in all.]

[Final request, after the dialog:] Based only on the observations above, answer the question: <question, with earlier questions for a follow-up>

Answer directly in 1–3 sentences with the key numbers. If the
observations do not contain the information needed, say
that it cannot be determined from the knowledge graph.
If the question asks whether an anomaly occurred or a
threshold was exceeded, start the answer with "Yes.",
"No." or "Cannot be determined."

[Only if that answer was another tool call:]
The tools are no longer available, so no further query can be
run. Do not write an Action. Give the final answer now,
as asked above, based only on the observations already
in this conversation.

TableRAG (the question passed to the agent):

<question> (If the question asks whether an anomaly occurred
or a threshold was exceeded, start the final answer
with Yes, No or Cannot be determined. If the table does
not contain the information needed, the final answer
should say that it cannot be determined.)

A follow-up question is passed to TextRAG, TableRAG, and Interactive-KBQA as:

Earlier questions in this conversation: "<earlier question>";
... . Current question: <question>

References

  1. [1]Sanjeev Bhatta and Ji Dang. 2024. Use of iot for structural health monitoring of civil engineering structures: a state-of-the-art review. Urban Lifeline, 2(1):17.DOI
  2. [2]Si-An Chen, Lesly Miculicich, Julian Eisenschlos, Zifeng Wang, Zilong Wang, Yanfei Chen, Yasuhisa Fujii, Hsuan-Tien Lin, Chen-Yu Lee, and Tomas Pfister. 2024. Tablerag: Million-token table understanding with language models. In NeurIPS. graphs. In SEMANTiCS, volume 62 of Studies on the Semantic Web, pages 159–175. IOS Press.arxiv.org/abs/2410.04739
  3. [3]Ziyang Chen, Jinzhi Liao, and Xiang Zhao. 2023. Multi-granularity temporal question answering over knowledge graphs. In ACL (1), pages 11378–11392. Association for Computational Linguistics.DOI
  4. [4]Martin Doerr. 2003. The CIDOC conceptual reference module: An ontological approach to semantic interoperability of metadata. AI Mag., 24(3):75–92.
  5. [5]Armin Haller, Krzysztof Janowicz, Simon J. D. Cox, Maxime Lefrançois, Kerry Taylor, Danh Le Phuoc, Joshua Lieberman, Raúl García-Castro, Rob Atkinson, and Claus Stadler. 2019. The modular SSN ontology: A joint W3C and OGC standard specifying the semantics of sensors, observations, sampling, and actuation. Semantic Web, 10(1):9–32.
  6. [6]Pranav Harikumar. 2026. Plancompiler: A deterministic compilation architecture for structured multi-step LLM pipelines. CoRR, abs/2604.13092.arxiv.org/abs/2604.13092
  7. [7]Krzysztof Janowicz, Armin Haller, Simon J. D. Cox, Danh Le Phuoc, and Maxime Lefrançois. 2019. SOSA: A lightweight ontology for sensors, observations, samples, and actuators. J. Web Semant., 56:1–10.
  8. [8]Junaid Ahmed Khan, Hiari Pizzini Cavagna, Andrea Proia, and Andrea Bartolini. 2025. From data center iot telemetry to data analytics chatbots—virtual knowledge graph is all you need. arXiv preprint arXiv:2506.22267.arxiv.org/abs/2506.22267
  9. [9]Tianyang Liu, Fei Wang, and Muhao Chen. 2024. Rethinking tabular data understanding with large language models. In NAACL-HLT, pages 450–482. Association for Computational Linguistics.arxiv.org/abs/2312.16702
  10. [10]Franco Niccolucci and Achille Felicetti. 2024. Digital twin sensors in cultural heritage ontology applications. Sensors, 24(12):3978.DOI
  11. [11]Shirui Pan, Linhao Luo, Yufei Wang, Chen Chen, Jiapu Wang, and Xindong Wu. 2024. Unifying large language models and knowledge graphs: A roadmap. IEEE Trans. Knowl. Data Eng., 36(7):3580–3599.DOI
  12. [12]George Pavlidis, Vasileios Sevletidis, and Vasileios Arampatzakis. 2025. Panoptes: A digital twin ontology for cultural asset management. In 2025 IEEE International Conference on Cyber Humanities (IEEE-CH), pages 1–6. IEEE.DOI
  13. [13]Michela Rossi and Dionysios Bournas. 2023. Structural health monitoring and management of cultural heritage structures: a state-of-the-art review. Applied Sciences, 13(11):6450.DOI
  14. [14]Tobias Schwarzinger, Gernot Steindl, Thomas Frühwirth, Thomas Preindl, Konrad Diwold, Kathrin Ehrenmüller, and Fajar J. Ekaputra. 2025. Sigsparql: Signals as a first-class citizen when querying knowledge graphs. In SEMANTiCS, volume 62 of Studies on the Semantic Web, pages 159–175. IOS Press.DOI
  15. [15]Omri Suissa, Maayan Zhitomirsky-Geffet, and Avshalom Elmalech. 2023. Around the GLOBE: numerical aggregation question-answering on heterogeneous genealogical knowledge graphs with deep neural networks. ACM Journal on Computing and Cultural Heritage, 16(3):51:1–51:24.DOI
  16. [16]Jiashuo Sun, Chengjin Xu, Luminguayan Tang, Saizhuo Wang, Chen Lin, Yeyun Gong, Lionel M. Ni, Heung-Yeung Shum, and Jian Guo. 2024. Think-on-graph: Deep and responsible reasoning of large language model on knowledge graph. In ICLR. OpenReview.net.arxiv.org/abs/2307.07697
  17. [17]Iva Vasic, Hans-Georg Fill, Ramona Quattrini, and Roberto Perdiccer. 2025. Knowledge graphs vs. large language models: Competitors or partners in supporting virtual museums. ACM Journal on Computing and Cultural Heritage, 18(4):61:1–61:28.DOI
  18. [18]Bing Wang, Changyu Ren, Jian Yang, Xinnian Liang, Ji-agi Bai, Jinzheng Chai, Zhao Yan, Qian-Wen Zhang, Di Yin, Xing Sun, and Zhoujun Li. 2025. MAC-SQL: A multi-agent collaborative framework for text-to-sql. In COLING, pages 540–557. Association for Computational Linguistics.
  19. [19]Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc V. Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2023. Self-consistency improves chain of thought reasoning in language models. In ICLR. OpenReview.net.arxiv.org/abs/2203.11171
  20. [20]Zilong Wang, Hao Zhang, Chun-Liang Li, Julian Martin Eisenschlos, Vincent Perot, Zifeng Wang, Lesly Mi- culicich, Yasuhisa Fujii, Jingbo Shang, Chen-Yu Lee, and Tomas Pfister. 2024. Chain-of-table: Evolving tables in the reasoning chain for table understanding. In ICLR. OpenReview.net.arxiv.org/abs/2401.04398
  21. [21]Guohui Xiao, Davide Lanti, Roman Kontchakov, Sarah Komla-Ebri, Elem Güzel Kalayci, Linfang Ding, Julien Corman, Benjamin Cogrel, Diego Calvanese, and Elena Botoeva. 2020. The virtual knowledge graph system ontop. In ISWC (2), volume 12507 of Lecture Notes in Computer Science, pages 259–277. Springer.DOI
  22. [22]Guanming Xiong, Junwei Bao, and Wen Zhao. 2024. Interactive-kbqa: Multi-turn interactions for knowledge base question answering with large language models. In ACL (1), pages 10561–10582. Association for Computational Linguistics.
  23. [23]Liang Xu, Lu Lu, Minglu Liu, Chengxuan Song, and Lizhen Wu. 2024. Nanjing yunjin intelligent question-answering system based on knowledge graphs and retrieval augmented generation technology. Heritage Science, 12(1):118.DOI
  24. [24]Seonghyeon Ye, Doyoung Kim, Sungdong Kim, Hyeon-bin Hwang, Seungone Kim, Yongrae Jo, James Thorne, Juho Kim, and Minjoon Seo. 2024. FLASK: fine-grained language model evaluation based on alignment skill sets. In ICLR. OpenReview.net.
  25. [25]Yiming Zhang and Koji Tsuda. 2026. SAGA: schema-aware grounding for agentic text-to-sparql generation. CoRR, abs/2607.14494.arxiv.org/abs/2607.14494

Paper details

vlnc:W_vun74ygd
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY-SA 4.0
Usage

views · 3

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents