Papers for

enterprise data engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Knowledge graph repair improves by selectively retrieving external evidence

Selective Retrieval Routing for Multi-Violation Knowledge Graph Repair

Abstract: Knowledge graphs often contain missing or inconsistent facts that undermine the applications built on them. Schema validation detects such violations but does not identify which of several valid repairs recovers the intended graph. External corpora can supply the evidence needed to identify the intended repair, but retrieving from them is costly and not always successful. We propose a framework for selective retrieval in iterative graph repair. An LLM repair agent explores and edits the graph, while a router controls its access to a researcher agent that retrieves external evidence. We extend a violation-injection framework to generate cases with multiple compatible violations and known reference repairs. The agent's repair outcomes on these cases provide supervision for training the deployment-specific router. On two building-automation datasets, researcher access improves repairs for some violations and degrades them for others, with effects differing across deployments. The router uses fewer repair-time tokens than always enabling access in all six evaluation suites. It achieves higher repair $F_1$ than always disabling access in five of six suites.

Thu 5 NovDatabasesArtificial Intelligence
The gist
Knowledge graphs store facts but can have errors or missing information that affects their usefulness. The authors created a method where a computer agent tries to fix these errors step-by-step and decides when to look up extra information from outside sources. Using this system, the agent learns when consulting outside knowledge helps or hurts fixing errors, which varies by situation. This approach uses less effort than always checking outside sources and usually fixes the graph better than never checking.
Open → 2611.07342v1

Knowledge graph lakehouse architecture manages enterprise data efficiently

Knowledge Graph Lakehouse: A Cloud-Native Architecture for Managing Enterprise Knowledge Graphs at Scale

Abstract: Modern data architectures for integrating heterogeneous data sources to discover actionable knowledge include the data warehouse, the data lake, and the data lakehouse, which combines the flexibility of the data lake with the structured data management capabilities of the data warehouse through metadata, indexes, and caching. Enterprise knowledge graphs (KGs) offer an alternative approach to such integration for the purposes of data analysis, but handling them at scale must address the Three Vs of big data: volume, velocity, and variety. Contextualized KGs (CKGs) meet part of that challenge by enriching facts with contextual information, yet many applications require only a context-specific subset of that knowledge. We propose the Knowledge Graph Lakehouse (KG Lakehouse), a cloud-native microservice architecture that adapts the data lakehouse paradigm for management of CKGs at scale. The KG Lakehouse indexes incoming source documents along configurable context dimensions and stores these documents in a data lake, from which application-specific CKGs are constructed on demand instead of maintaining a single, monolithic KG. We realize the proposed architecture as a proof of concept, with independently deployable services built from established cloud technology; context dimensions and format-specific document handling enter as configuration, leaving the architecture independent of the application domain. We evaluate the implemented system in experiments on a distributed cluster deployment.

Tue 3 NovDatabases
The gist
Combining lots of different types of data from many sources is hard, especially when that data is big and fast-changing. The authors propose a new system called Knowledge Graph Lakehouse to handle this better by storing original documents in a flexible storage system and creating smaller, custom knowledge graphs on demand instead of one huge graph. Their design uses cloud technology to keep the system scalable and adaptable to various needs without being tied to any one kind of data. They built a working version and tested it on multiple computers to show it works.
Open → 2611.04899v1

NovaFilter makes data transformation easy for nonprogrammers

NovaFilter - A Rule-Based ETL Staging Framework for Fault-Tolerant Relational Databases

Abstract: NovaFilter is a completely new approach to deriving structured relational data from heterogeneous input data in different data formats. It combines consistency checks, rule-based data transformation, and a human-in-the-loop example discussion. Using these three components, NovaFilter stores all transformation knowledge in an explicit rule base, which is continuously expanded through the example discussion with the user. The resulting data transformation process is deterministic, transparent, and reusable. As a result, the method can replace conventional ETL scripts and offers a completely new strategy for transforming data between different data models and schemas. Its main advantage is that users without programming skills (e.g. domain experts) can answer the example discussion and thus it is a building block for democratization of ETL script developement.

Sat 31 OctDatabases
The gist
Turning messy information from many sources into neat tables can be very hard and usually requires writing computer code. The researchers created NovaFilter, a new way that uses rules and questions to guide users, even those without programming skills, to organize and check data. This approach keeps all the transformation steps clear and reusable, helping people fix problems together with the computer. Because it talks with users through examples, it helps keep data accurate and makes the whole process easier to understand.
Open → 2611.00959v1

FIRME improves linking investor knowledge across different sources and times

FIRME: Registry-Anchored Memory Graphs for Evolving, Heterogeneous Investor Knowledge

Abstract: Financial AI workflows that reuse investor knowledge need persistent memory that integrates observations across sources and periods without losing identity or provenance. In a knowledge graph, recurring observations may use different surface forms, fragmenting relationship histories and preventing evidence from accumulating. We introduce Fusion and Identity Registry for Memory Evolution (FIRME), a registry-anchored memory graph that reconciles incoming observations to persistent canonical relationships and retains their source, time, and context. Within periods, rule-based fusion links investor-call discussions to portfolio cash-flow signals, directly or through a fixed product-topic ontology. Across periods, canonical identities and persistent aliases direct recurring observations to the same relationship history; deterministic updates summarize reinforcement, inactivity, and reactivation. We evaluate FIRME on proprietary investor-call and cash-flow records and on S&P 500 earnings-call transcripts. Compared with a historical registry that retains canonical identities and semantic fallback but omits alias memory, FIRME increases final-period Correct Match Rate by 7.8-12.1 percentage points across four dataset-backend settings under a fixed-judge and fallback-review protocol. A blinded human audit of 200 incoming observations per setting finds Correct Match Rate gains of 9.0-16.5 points and reattachment-recall gains of 22.5-29.0 points, with higher observed merge precision in all four samples. A separate audit finds valid evidence paths for 293 of 300 outputs from full within-period fusion in the investor-call setting. Extraction-faithfulness and round-trip diagnostics assess source grounding and preservation of extractor-derived graph content.

Thu 29 OctArtificial IntelligenceComputation and Language
The gist
Financial AI systems that track investor information often struggle to keep track of who or what is being talked about when data uses different names or descriptions. The authors describe FIRME, a system that merges various pieces of investor data into consistent, linked records while keeping track of where and when the data came from. This helps create a clearer picture by connecting conversations and financial signals without losing track of their source. Tests show FIRME matches information more accurately and maintains better evidence chains than previous methods.
Open → 2610.40482v1

RADAR improves knowledge graph learning by smart negative sampling

How Many and How Much? Contrastive Learning with Negative Samples for Knowledge Graph Embedding

Abstract: Knowledge graph embedding (KGE), a fundamental technique for knowledge-centric Web and KG-augmented AI applications, is commonly trained through contrastive learning with negative samples to learn discriminative representations. Despite its empirical success, two crucial questions regarding negative samples remain underexplored: (Q1) how many negative samples should be used for each positive sample and (Q2) how much should each negative sample contribute to learning? To answer these questions, we propose RADAR, a novel contrastive learning framework for KGE models with two effective strategies, respectively: (1) Risk-aware negative budget allocation quantifies false-negative sampling risk by modeling an open-world KG as a stochastic partial observation of its closed-world counterpart and adaptively assigns a negative budget to each positive sample based on its risk; (2) Distribution-calibrated negative weighting assigns negative weights by calibrating the weighting strength for each positive based on two complementary characteristics of the negative-score distribution: dispersion and concentration. Extensive experiments on 3 real-world KGs with 4 KGE models reveal that RADAR achieves the best KGE performance on average across all model--KG combinations and reduces sampled false negatives by over 90% compared with conventional fixed-budget methods.

Tue 27 OctMachine Learning
The gist
Knowledge graphs are like huge maps of facts, and computers learn to understand them by comparing true facts to false ones called negative samples. This paper looks at two questions: how many negative samples to use per true fact, and how strongly each negative sample should affect learning. The authors introduce RADAR, which smartly decides how many negatives to use based on the chance of mistakenly including true facts as negatives, and adjusts their importance by looking at how the negative samples are spread out. Their experiments show that RADAR boosts the learning quality and greatly reduces wrong negative samples compared to usual methods.
Open → 2610.37389v1

Llm improves reasoning on knowledge graphs without question labels

Evolve on Graph: Self-Evolving Knowledge Graph Reasoning without Question Annotations

Abstract: Knowledge graphs (KGs) provide reliable external knowledge for multi-hop factual reasoning with large language models (LLMs), yet most KGs in real-world domains such as finance and industry lack question--answer (QA) annotations. Without such annotations, existing methods struggle to improve LLM graph reasoning: training-free agents cannot improve their exploration through interaction; reinforcement learning (RL) agents depend on QA data annotated by humans or synthesized by closed-source models; and training data is typically built offline, so its topology mix is fixed and cannot follow the agent's ability. We propose Evolve on Graph (EoG), a framework that lets an LLM self-evolve its graph reasoning without any QA annotations. Through Graph Self-Play, a single LLM alternates between a Proposer that poses questions and a Solver that answers them. To make questions verifiable, Symbolically Verifiable Topology Synthesis (SVTS) samples reasoning topologies on the KG and executes the corresponding first-order logic queries, yielding topology skeletons with correct and complete answer sets; guided by a skeleton, the Proposer explores the graph to pose a multi-hop question. To let task topologies follow the Solver, a Boundary-Aware Graph Curriculum rewards the Proposer by the Solver's score variance, keeping questions at the Solver's capability boundary so that complex topologies enter training as the Solver improves. On six benchmarks over Freebase, Wikidata, and an industrial KG, EoG consistently outperforms prompting-, retrieval-, and agent-based methods, showing that LLM graph reasoning can improve through self-play without QA annotations. Our code is available at https://github.com/Szy5/EoG

Mon 26 OctArtificial Intelligence
The gist
Large language models (LLMs) often use knowledge graphs to find answers that require several reasoning steps. However, many real-world knowledge graphs lack labeled questions and answers to help train such models. The authors propose a way for an LLM to teach itself by playing both the role of asking and answering questions using the knowledge graph. Their method generates verifiable multi-step questions and gradually increases difficulty as the model improves. This approach works well on different knowledge graphs without needing any pre-existing question annotations.
Open → 2610.35598v1

Uber-Join cuts costs joining diverse tables with high accuracy

Uber-Join: Unifying Diverse Table Joins using LLMs with Precision and Cost Guarantees

Abstract: When two tables from different sources are joined, the values that should join often differ in spelling, format, or meaning, and fuzzy-, transformation-, and semantic-joins each handle one type of these differences. Large language models (LLMs) can match values that differ in several ways at once, but every LLM call is billed, and having an LLM compare the rows of two large tables can cost far more than a typical budget allows. This paper studies how to combine these join types with LLMs to join two tables under a dollar budget, maximizing recall while keeping the precision of the result at or above a target, a problem that is NP-hard. Our key idea is to use LLMs selectively to create join programs and verify their outputs through sampling, while adaptively deciding which joins to pursue under budget and precision constraints. This combines the scalability of program-based joins with selective LLM verification, while maintaining a statistical precision guarantee on the accumulated result. We develop Uber-Join, which treats creating a join and checking the output of a created join as two levels of arms in a budgeted multi-armed bandit. It commits an output only if the precision of the whole result, estimated from an LLM's judgments of sampled pairs, stays at or above the target with high confidence. Under the same budget, Uber-Join achieves the highest recall at the precision target in nearly all settings on three join benchmarks and Join-Hard, a new benchmark of large tables.

Sun 18 OctDatabases
The gist
When combining two tables from different places, the matching values often look different, making it hard to join them properly. The authors show how to use smart programs and careful checks with language AI to join tables without exceeding a budget and while staying very accurate. Their method, called Uber-Join, decides when to use AI to match and verify pairs, improving how many matches it finds without losing precision. This makes it easier and cheaper to combine big, messy data tables from different sources.
Open → 2610.25178v1

Pretrained graph models improve relational data prediction without fine-tuning

Path to Prior-Data Fitted Relational Models via Learned Latent Multi-table Representations

Abstract: Prior-data fitted networks (PFNs) show that pretraining on large populations of synthetic tasks can enable generalization to unseen datasets with little or no downstream fine-tuning. This paradigm is effective for transformer-based tabular and relational foundation models such as RDB-PFN, but remains largely unexplored for graph-based relational models built on message passing. We pretrain the graph-based relational foundation model Griffin on large collections of synthetic relational databases and ask whether curriculum learning, which benefits transformer-based relational learners, also improves message-passing representations. Rather than fine-tune on downstream tasks, we use the pretrained encoder as a general-purpose relational representation learner and pass its latent representations to a frozen in-context predictor (\ticl{}); no component is trained on the target task. On 16 real-world relational classification tasks, evaluated over five seeds against raw-feature and untrained-encoder baselines, a purely synthetic curriculum that begins with schema-guided data and continues with schema-agnostic data gives the strongest frozen in-context performance\rev{, outperforming real-data-only pretraining and every unordered single-stage mixture of the corpora; when appended after real-data pretraining, it yields the best encoders overall}. These results provide initial evidence that PFN-style synthetic pretraining transfers to graph-based relational foundation models.

Fri 16 OctMachine LearningArtificial Intelligence
The gist
Understanding data spread across multiple tables can be tricky, especially when the data is connected like a graph. The authors study a kind of machine learning model that mimics how information passes between connected nodes and pretrained it on lots of made-up databases. They found that this pretraining helps the model understand real-world data better, even without extra tweaking. Their approach uses synthetic data in a step-by-step way that leads to stronger predictions across many tasks.
Open → 2610.23073v1

Ownership guides best routing for answering questions from multiple data tables

Fan Out or Relay? Ownership-Aware Routing for LLM Agents Querying Siloed Tables

Abstract: Inside organizations, a question's data often sit with several owners, who query their own tables but never hand them over. An LLM coordinator can fan out, sending the question to every owner at once, or relay, querying owners in turn and reusing earlier rows. We show that neither is safe in advance, because data ownership decides which one is right. Across thirteen settings on PeopleJoin and BIRD with three model families, fan-out is more accurate in twelve on questions one owner can answer, yet answers at most 4.3% of those joining two owners' tables. The flip follows ownership, not query shape: on BIRD two-table joins, fan-out answers 32-44% when one owner holds both and 1-4% otherwise. Relay wins by conditioning on returned rows, and hiding them from an otherwise identical planner cuts two-owner accuracy from 23.2% to 5.1%. Since ownership is public, we propose Ownership-Aware Routing (OAR), which drafts a schema-only SQL query, counts the owners whose tables it joins, and routes the question before any private row is read. In ten settings OAR is never significantly less accurate than the best fixed protocol, and beats every fixed protocol on PeopleJoin, by up to 9.3 points on held-out organizations.

Tue 13 OctComputation and LanguageArtificial IntelligenceMultiagent Systems
The gist
When a question involves data owned by different groups, it’s tricky to decide how to ask for answers. Sending the question to all owners at once works best if only one owner has the data needed, but asking owners one after another works better if the data must be combined across owners. The authors show that knowing who owns which data lets a coordinator pick the right way to route queries without exposing private data early. Their method improves accuracy when joining data from multiple owners, balancing privacy and correctness.
Open → 2610.18157v1

Benchmark tests multi database agents for finding and using data correctly

DSABench: Benchmarking Source Discovery, Coordination, and Execution for Multi-Database Agents

Abstract: Most text-to-SQL benchmarks provide the target database. In a large data catalog, however, choosing the sources is part of the problem: an agent must find every database needed for a request, determine how their results fit together, and execute the resulting workflow. We present DSABench to evaluate these capabilities jointly. Its 815 human-reviewed tasks draw on Spider, BIRD, and LiveSQLBench; 618 require several databases to contribute, and 105 allow more than one interpretation of the required sources. Executable contracts define source participation, cross-source dependencies, and source-local execution, while RouteEnv lets agents inspect public catalog evidence without revealing the gold annotations. In our routing-only study across seven model backends, the highest RA-Set score is 60.55%, compared with a highest RA-Graph score of 34.66% when coordination requirements are included. The gap becomes more pronounced when execution is required. Across four backends, median non-privileged Route+Exec-Graph success ranges from 6.69% to 7.98% without clarification and from 11.44% to 13.25% with one clarification; the best observed clarified configuration reaches 16.99%. On ambiguous tasks, clarification improves exact branch-source recovery by 39.8-43.2 percentage points. These findings illustrate why retrieving plausible databases or producing correct local SQL is not enough: an agent must carry the right information through the entire multi-database workflow.

Sat 10 OctArtificial Intelligence
The gist
When computers answer questions by searching databases, they often assume they already know which databases to use. This paper shows that in real situations with many databases, the computer first needs to figure out which databases to use, how to combine their answers, and then run the full process correctly. The authors created DSABench, a new benchmark with complex tasks requiring multiple databases, to test how well computer agents handle this challenge. Their tests reveal big gaps between just finding databases and correctly combining and executing data from them, and that asking clarifying questions helps improve results on tricky tasks.
Open → 2610.14700v1

VADER speeds up filtered vector searches with automatic recall control

VADER: Filtered Vector Search with Declarative Recall

Abstract: Approximate filtered vector search (FVS), a core operation in many data management tasks that combine structured data with vector embeddings, exhibits increased complexity due to the characteristics of filtering predicates. Each predicate is defined by selectivity (i.e., the fraction of vectors that satisfy the predicate) and correlation (i.e., the relationship between the filter and the vector space), which can significantly affect search difficulty even for the same query vector. This poses a key challenge for users aiming to integrate vector search with structured data, as efficient execution often requires extensive manual tuning of algorithm parameters. In this paper, we present VADER, the first approach that eliminates hyperparameter tuning by introducing declarative recall for approximate filtered vector search. With declarative recall, users specify a desired recall target, and VADER executes FVS queries to meet this target without requiring manual configuration. VADER achieves this by employing a filter-aware recall predictor that generalizes across varying selectivities and correlations without explicit tuning, and by performing early termination once the predicted recall reaches the user-defined target. Through extensive experimental evaluation, we show that VADER achieves near-optimal early termination, while providing significant speedups of up to 53% faster and improved result quality of 28% compared to the best-performing baseline.

Tue 29 SeptDatabases
The gist
Filtered vector search helps computers find related items based on both data details and numeric patterns, which is usually complicated and needs a lot of fine-tuning. The authors present VADER, a system that lets users set how complete they want their search results to be, and then automatically adjusts the search process to meet that goal without manual tweaking. VADER predicts how well the search is doing and stops early when the target is reached, making searches faster and better. Tests show that VADER is often quicker and provides higher quality results than previous methods.
Open → 2609.38053v1

Semantic indexing system improves context-aware knowledge extraction

5W1H+Which: Context-Valid Semantic Indexing with Progressive Ontology Binding

Abstract: Transforming raw data into queryable knowledge requires both early extraction of reusable information and explicit types, relations, and applicability conditions for particular tasks. If indexing selects content too early around a single business schema, later tasks may be unable to use information that was omitted. If the index retains only open-ended text, however, rule-based reasoning lacks checkable premises. We propose 5W1H+Which, a semantic indexing design that separates content extraction from ontology binding. The 5W1H questions organize source-grounded content units; Which points to versioned ontology elements and records mapping relations, scope, and validation status. Time, location, system environment, and participant roles are not merely retrieval labels: together, they constrain the contexts in which facts, bindings, and rules apply. Unbound content remains searchable, while bound content enters a formal reasoning path only after premise checks. The method further distinguishes business valid time, system knowledge time, and operational traces, and uses dependency records to support binding revalidation and the maintenance of derived conclusions. A worked example of migration from an on-premises server to a cloud environment illustrates the different treatment of world-state changes, ontology-version changes, and changes in rule applicability. We formulate three groups of falsifiable hypotheses concerning cross-task evidence coverage, control of contextual misuse, and incremental update cost. The planned evaluation includes a strong typed fact-graph baseline with the same evidence, temporal information, and budget, to test whether benefits arise from 5W1H organization, deferred binding, or additional information and engineering effort. The contribution is a testable indexing mechanism, not a claim to a new universal ontology or a demonstrated performance advantage.

Mon 28 SeptArtificial IntelligenceComputation and LanguageInformation Retrieval
The gist
Turning raw data into useful knowledge requires both finding important facts early and knowing exactly what those facts mean. The authors propose a method called 5W1H+Which that first gathers raw facts by answering who, what, when, where, why, and how questions, and then links those facts to clear definitions in an organized way. This method keeps track of different times and settings to ensure facts are used correctly in context, while also allowing flexible searching. They test it using an example of moving servers to the cloud and set up ways to measure if their method helps later tasks.
Open → 2609.35184v1

Enterprise data agents improve reasoning with learned identity routing

Learned Enterprise Data Comprehension: Compression and Routing for Data Agents

Abstract: Structured-data agents in enterprise settings must reason over complex data environments whose relevant evidence is distributed across schemas, relationships, policies, and recurring business roles. Modern agentic systems often address this burden through reusable markdown-style memory or skill files that preserve previously discovered information for later queries, reducing the need to rediscover the same structure repeatedly. This is useful, but it obscures a natural division of labor: agents are well suited to semantic reasoning, while learned systems are well suited to predicting and organizing recurring structure. We introduce latent equivalence learning to bridge this gap. The framework separates persistent task-relevant identities from their dataset-relative realizations. In our realization, supporting and opposing evidence shape support-realized Gaussian prototypes that learn how those identities are expressed in a particular data environment, while soft-membership profiles retain distinctions lost under a hard assignment. A separate learned query-prototype system represents recurring evidential requirements and maps them through a learned compatibility function into the same persistent identity structure. This identity-factorized, query-conditioned routing materializes the relevant dataset-specific evidence for downstream reasoning, allowing the agent to operate over an already organized evidential state rather than reconstructing cross-schema structure at every query. On the Data Agent Benchmark, spanning 54 queries across 12 heterogeneous datasets, our full implementation achieves 94.67% dataset-macro stratified Pass@1 over five complete trials and 258/270 successful raw query attempts, compared with 55.51% for the benchmark's Claude Opus 4.6 reference agent, ranking first among 40 leaderboard entries at submission.

Mon 21 SeptArtificial Intelligence
The gist
Enterprise data agents have trouble finding and using related pieces of information spread across complex databases. The authors created a method that helps the agent understand and organize important identities in different datasets, so it can quickly find relevant evidence without starting from scratch every time. This method uses learned patterns to link identities and queries, improving the agent's ability to reason with structured data. Their approach scored much higher than previous systems on a challenging data benchmark.
Open → 2609.25286v1

Graph databases differ widely in speed and costs for queries and updates

Graph Memory for LLM Agents: At What Cost? A Comparative Evaluation of Query, Ingest, and Update Performance Across Graph Database Engines

Abstract: Graph databases are frequently positioned as categorically necessary for connected-data workloads, yet the systems dimension along which they actually differ - query planning, indexing, and data-readiness cost - is rarely isolated from vendor framing. We construct a synthetic, biomedical-shaped property graph (1.02 million nodes, 5.34 million total node and edge rows) and a twenty-query workload spanning neighborhood lookups, bounded paths, set intersections, anti-joins, grouped aggregation, top-k ranking, temporal filters, full scans, and relational joins. We benchmark Corvic AI - a purpose-built columnar query engine underlying Corvic's ontology management layer ("memories")- against seven purpose-built or graph-extension database systems (LoraDB, Ladybug, DuckPGQ, Memgraph, Neo4j, HugeGraph, and FalkorDB) at three graph scales spanning three orders of magnitude. We report query latency geomeans, bulk-ingest throughput, point-update latency, and answer correctness for each system, and we derive a simple total-cost-of-ownership model that expresses the ingest/query trade-off as a function of query volume. Our central finding is that no system in this sample is categorically fastest: a native graph engine (Ladybug) outperforms Corvic AI on narrow, bounded-neighborhood shapes, while Corvic AI is faster on shapes that scan or join a large fraction of the graph, and a system implementing graph query syntax via SQL/PGQ (DuckPGQ) is measurably slower purely due to query-plan choice. The dominant cost differential in our data is not query latency but the cost of making data queryable at all: bulk-ingest throughput varies by three orders of magnitude across engines (5.0k-4.3M rows/s), a gap that a simple crossover-point calculation shows dominates total cost for any workload with fewer than roughly 105 queries per data refresh.

Sun 20 SeptDatabasesArtificial Intelligence
The gist
Not all graph databases work equally well for searching and updating connected data, even if they seem similar on the surface. The authors tested eight different database systems using a large biomedical network and a variety of common query types. They found that some systems were faster for small, local searches, while others were better for big scans or complex joins. Most importantly, the time it takes to load the data into the database varied hugely and often dominated the overall cost for tasks with fewer queries. This means choosing the right system depends a lot on how often you query versus how often you update your data.
Open → 2609.23315v1

Self demonstrations boost database schema matching with LLMs

Surprising Effectiveness of Self-Demonstrations in Enhancing Schema-Ontology Mapping with LLMs

Abstract: Integrating heterogeneous relational databases into a centralized ontology remains a persistent challenge in enterprise knowledge representation, primarily due to semantic heterogeneity, cryptic schema naming, missing metadata, and the abstraction gap between relational schemas and ontological models. Although large language models (LLMs) offer strong semantic reasoning capabilities, we show that directly applying them through one-shot prompting or naive multi-stage pipelines leads to poor performance for schema-ontology mapping. This paper presents a self-demonstration-driven approach that combines a neuro-symbolic task decomposition with a novel mechanism for automatically generating pattern-guided, dependency-aware demonstrations to address this integration challenge. Our approach incorporates two key strategies to achieve substantial accuracy gains over existing LLM-based schema integration methods: (i) a neuro-symbolic decomposition of the task into cascaded sub-tasks, where symbolic constraints structure the search space and LLMs perform semantic reasoning within each focused sub-task, and (ii) self-generated demonstrations guided by domain-agnostic patterns to supervise each sub-task. Experiments on three of the most challenging scenarios from the RODI benchmark show that our approach achieves state-of-the-art performance, substantially outperforming (25 percentage points F1 improvements) both traditional schema-to-ontology mapping techniques and recent LLM-based schema-to-ontology and schema matching approaches. Ablation studies further reveal the significant benefits of pattern-guided self-demonstrations and the complementary benefits of neuro-symbolic task decomposition.

Sat 12 SeptArtificial Intelligence
The gist
Combining data from different databases into one knowledge model is hard because database layouts can be confusing and incomplete. The authors found that simply asking large language models (LLMs) to do this mapping often fails. They created a method that breaks the task into smaller steps with clear rules and automatically generates helpful examples to guide the LLMs. This method works much better than previous attempts, improving accuracy by a large margin on standard tests.
Open → 2609.13776v1

Federated knowledge graphs enable multi-hop question answering without sharing raw data

FedV-KGQA in Practice: Design Lessons and an Interactive Prototype

Abstract: Knowledge graph question answering usually assumes that one system can reach the whole graph. In practice, facts are often held by organizations that share entity identifiers but own disjoint relation types, so no single party sees a complete reasoning chain. This poster presents the empirical findings of FedV-KGQA on multi-hop question answering over such vertically partitioned graphs. Each silo enriches its local graph and trains a knowledge graph embedding on its own triples. A server then concatenates the silo-specific entity views, anchors the projected question at the topic entity, and ranks candidates by similarity. Raw triples and relation embeddings never leave a silo. Comparing the FedV-KGQA experiments with one another yields three results. First, federated fusion recovers most of the centralized accuracy, while a single silo recovers little. Second, anchoring and enrichment matter more than the choice of embedding model. Third, the cheapest encoder depends on the target accuracy rather than on parameter count. This poster paper contributes that cross-experiment comparison, four design lessons drawn from it, and an interactive prototype that runs real inference and traces the full pipeline, per question, on released checkpoints.

Sat 12 SeptArtificial IntelligenceComputation and LanguageInformation Retrieval
The gist
Question answering systems that use knowledge graphs usually need access to all the information in one place. The authors study what happens when different organizations hold parts of the knowledge graph with unique relationships but share common entity identifiers. They show that combining knowledge locally enriched and embedded in separate silos can nearly match the accuracy of a system that sees everything. They also find that focusing on linking questions to key entities and enriching the data matters more than using complex embedding models. The authors provide lessons from comparing different settings and an interactive prototype that demonstrates the approach.
Open → 2609.13661v1