SINT-Flow: Schema Integration using Large Language Model Workflows

arXiv:2607.24492 · cs.CL · Submitted 2026-07-27 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: We're looking at the paper: "SINT-Flow: Schema Integration using Large Language Model Workflows".

Jane: Here's the gist of the paper. The gist The goal of schema integration is, given a set of input schemata or tables, to derive a global, unified schema that is able to represent the concepts, attributes, and relationships of all input tables in a coherent fashion.

Tom: SINT-Flow Framework SINT-Flow is presented as a schema integration framework composed of five LLM-based operators that can be combined into workflows to perform fully automated, end-to-end schema integration The framework consists of five operators: the Table Splitting, Schema Matching, Table Grouping, Attribute Merging, and Integrated Schema Output operators These operators can be arranged in different orders into schema integration workflows The paper proposes three distinct workflows to demonstrate the flexibility of combining these tools.

Jane: SINT-Bench Benchmark To evaluate SINT-Flow, a benchmark called SINT-Bench is introduced, comprising 10 schema integration tasks consisting of altogether 93 relational tables Eight of these tasks involve 2 or more entity types and require the splitting of the columns of each input table per entity type SINT-Bench is notable because it is the first schema integration benchmark to include ground truth for the detection of entity types and their attributes within each input table.

Tom: LLM Performance and Evaluation The evaluation utilized two models, GPT-5.2 and Qwen-3.6-27B, to test the workflows Using these models, SINT-Flow achieves F1 scores of at least 96% for entity-type detection, 85% for attribute detection, and 83% for schema mapping The evaluation metrics include Precision, Recall and the F1-score as evaluation metrics to evaluate all operator outputs.

Title and authors: Tom: Let's look at the title and who wrote this. It's "SINT-Flow: Schema Integration using Large Language Model Workflows." It immediately tells you this isn't just one algorithm; it’s a system design focused on using LLMs to build these integration workflows >

Jane: The authors are Keti Korini and Christian Bizer from the University of Mannheim in Germany. They are building this framework to solve that problem of deriving a global schema from multiple input tables >

Lu: What they want to achieve is processing those denormalized source tables that contain attributes describing multiple entity types, and decomposing them into separate entity-specific relations during that integration process >

Meng: So, the core mechanism involves using these LLM-based operators to systematically break down the structure of the data before you even get to the final integrated schema >

Lalam: They test this approach using two different models: GPT-five point two and an open-weight model called Qwen > <ref:2607.24492#pg1>

Tom: And that’s a good starting point, right? We're seeing how these LLMs handle the structure of data relationships rather than just statistical patterns across columns >

Jane: So, before we get into how it actually works in detail, let's talk about what they claim this framework can do when you look at the benchmarks they created.

The paper's summary: Tom: The paper summarizes SINT-Flow by saying that its goal is to derive a global, unified schema that represents the concepts, attributes, and relationships of all input tables in a coherent fashion >

Jane: They introduce SINT-Bench to evaluate this. It’s a benchmark with ten tasks involving ninety-three relational tables altogether <ref:2607.24492#pg1>. Eight of those tasks involve two or more entity types and require splitting the columns of each input table per entity type >

Lu: What makes SINT-Bench special, according to the paper, is that it’s the first schema integration benchmark to include ground truth for the detection of entity types and their attributes within each input table >

Meng: So, they're not just testing if a final schema looks right; they are testing if the AI can correctly identify *what* those entities are and *which* columns belong to them in the first place >

Lalam: The performance results on this benchmark were quite solid. Using GPT-five point two and Qwen, SINT-Flow achieved an F1 score of at least ninety-six percent for entity-type detection > <ref:2607.24492#pg1>

Tom: And for attribute detection, it hit about eighty-five percent, and schema mapping was around eighty-three percent across those models >

Jane: So they are showing that the combination of these LLM workflows can be very effective when applied to complex, real-world data structures like the ones in SINT-Bench >

Lu: It’s interesting because it moves beyond just finding attribute co-occurrence, which is what older probabilistic methods relied on >

The paper's improvements: Tom: Now let's talk about the actual improvements they suggest to make this framework better. They focus on making the existing operators more robust, right?

Jane: They point out that one key improvement is using self-consistency. Running each operator three times and taking a majority vote creates consistent outputs, which improves the F1 score by thirteen percent for the Qwen model and by about three percent for GPT-five point two compared to just averaging three individual runs >

Lu: That makes sense from a training standpoint; it helps stabilize the output of each operator >

Meng: I'm interested in another one they suggest: incorporating a "post-schema matching LLM reviewer loop." This loop checks if a matched column can also be matched to at least one other column, which prevents them from merging two attribute groups that should actually be separate >

Lalam: That’s smart. It addresses the issue of false matches where attributes might look similar but belong to different concepts >

Tom: And they also suggested developing better schema grouping capabilities by using co-occurrence counts between attributes or tables across multiple runs. If the co-occurrence is higher than half of the number of runs, they conclude those pairs should be in the same entity type group >

Jane: So it’s not just one trick; they suggest using self-consistency and this reviewer loop to catch potential false matches, and also improving grouping accuracy through these co-occurrence counts >

Lu: And another point is increasing the overall end-to-end performance by implementing a review loop in both operator types, because both using self-consistency and a reviewer loop to catch potential false matches impact the performance of the workflows positively >

Conclusion: Tom: So we’re wrapping up with the conclusion of this paper on SINT-Flow. Essentially, they show that combining LLMs with these decomposed workflows lets them perform end-to-end schema integration without needing human intervention >

Jane: The experiments showed both models reaching at least a ninety-six percent F1 score on entity type detection, and attributes are detected with an F1 score of at least eighty-five percent > <ref:2607.24492#pg1>

Lu: They concluded that the inclusion of the Schema Matching Operator in the workflows is beneficial because the implicit schema matching workflow they tested had the lowest F1 scores compared to the others >

Meng: And they confirmed that adding self-consistency to create consistent outputs per LLM operator shows a positive impact on those F1 scores for both GPT-five point two and Qwen > <ref:2607.24492#pg1>

Lalam: So, SINT-Flow is presented as a framework for constructing schema integration workflows that derive integrated schemata for the entity types identified in a set of input tables >

Tom: It’s definitely a system that breaks down the complex task into smaller, manageable steps using LLMs, and it shows that this decomposition approach works well for schema integration on these kinds of problems >

Jane: And it really shows how these LLMs can handle the complexity of understanding relationships between different data structures by following a structured process rather than just trying to guess everything at once >

Keti Korini, Christian Bizer

University of Mannheim

cs.CL

Submitted: 2026-07-27

Updated: 2026-10-20

Code: https://github.com/wbsg-uni-mannheim/SINT-Flow

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 88/100

The gist: The gist The goal of schema integration is, given a set of input schemata or tables, to derive a global, unified schema that is able to represent the concepts, attributes, and relationships of all

Key concepts

SINT-Flow
A framework composed of five LLM operators that can be combined in different sequences to perform end-to-end schema integration. Its goal is to derive a single, coherent global schema from various input tables by decomposing the task into manageable subtasks.
Table Splitting Operator
This operator identifies relevant entity types within an input table. It considers an entity type relevant if at least three columns can be associated with it, assigning each column to its corresponding entity type schema.
Schema Matching Operator
This operator finds matching pairs of columns across different input tables to form attribute groups. It includes a crucial post-schema matching LLM reviewer loop to verify and refine these matches, improving accuracy.
Self-consistency Strategy
Running each operator multiple times and using majority voting ensures consistent outputs from the LLM operators. This strategy improves performance by creating stable results, leading to higher F1 scores for entity type detection.

Terminology

Summary

The gist The goal of schema integration is, given a set of input schemata or tables, to derive a global, unified schema that is able to represent the concepts, attributes, and relationships of all input tables in a coherent fashion.

SINT-Flow Framework

SINT-Flow is presented as a schema integration framework composed of five LLM-based operators that can be combined into workflows to perform fully automated, end-to-end schema integration The framework consists of five operators: the Table Splitting, Schema Matching, Table Grouping, Attribute Merging, and Integrated Schema Output operators These operators can be arranged in different orders into schema integration workflows The paper proposes three distinct workflows to demonstrate the flexibility of combining these tools.

SINT-Bench Benchmark

To evaluate SINT-Flow, a benchmark called SINT-Bench is introduced, comprising 10 schema integration tasks consisting of altogether 93 relational tables Eight of these tasks involve 2 or more entity types and require the splitting of the columns of each input table per entity type SINT-Bench is notable because it is the first schema integration benchmark to include ground truth for the detection of entity types and their attributes within each input table.

LLM Performance and Evaluation

The evaluation utilized two models, GPT-5.2 and Qwen-3.6-27B, to test the workflows Using these models, SINT-Flow achieves F1 scores of at least 96% for entity-type detection, 85% for attribute detection, and 83% for schema mapping The evaluation metrics include Precision, Recall and the F1-score as evaluation metrics to evaluate all operator outputs.

Operator Details and Self-Consistency

The operators in SINT-Flow are detailed as follows:

  1. Table Splitting Operator: Its goal is to detect the relevant entity types in a given input table and to assign each table column to its associated entity type, considering an entity type relevant if at least 3 columns can be associated with it.

  2. Schema Matching Operator: This operator's task is to find matching pairs of columns in the input tables, and it includes a post-schema matching LLM reviewer loop to review the matches while forming the attribute groups.

  3. Table Grouping Operator: This operator is used to group (cluster) entity tables derived from the Table Splitting Operator by entity type.

  4. Attribute Merging Operator: The task of this operator is to choose for each attribute group a representative attribute from the group, which will be added to the intermediate integrated schema of its respective entity type.

  5. Integrated Schema Output Operator: This operator has a fixed position at the end of the workflows as its tasks are to i) remove redundant attributes between the intermediate integrated schemata of entity types ii) introduce identifiers if not already present, and iii) output foreign keys to link entity types.

Ablation Study Findings

The ablation study proved the utility of two key strategies:

  1. Self-consistency: Running each operator 3 times and using majority voting creates consistent outputs, which improves the F1-score by 13% for the Qwen model and by 3% for GPT-5.2 compared to averaging three individual runs.

  2. Schema Matching Operator Reviewer Loop: This loop increases the F1-score of the integrated attribute detection by 5% and the mappings by 10% for both models.

Workflow Comparison

The paper compares three workflows:

  1. Entity Type Detection on Input Tables Workflow: This workflow starts with Table Splitting, followed by Schema Matching, Table Grouping, Attribute Merging, and finally Integrated Schema Output.

  2. Implicit Schema Matching Workflow: This workflow combines the tasks of Schema Matching and Attribute Merging without using the Schema Matching Operator.

  3. Entity Type Detection on an Integrated Table Workflow: In this workflow, the Table Splitting Operator is applied at the end of the workflow to a single resulting integrated table.

Conclusion

The experiments demonstrated that LLMs, when combined with workflows that decompose the overall task into subtasks, can perform end-to-end schema integration without human intervention. Both models reach at least 96% F1-score on entity type detection, while attributes are detected with an F1-score of at least 85%. The inclusion of the Schema Matching Operator in the workflows is beneficial, as the implicit schema matching workflow had the lowest F1-scores compared to the others tested. The inclusion of self-consistency to create consistent outputs per LLM operator shows to have a positive impact to the F1 score for both models. The paper introduces SINT-Flow, a framework for constructing schema integration workflows that derive integrated schemata for the entity types identified in a set of input tables.

How it works

The core mechanism involves decomposing denormalized source tables into separate entity-specific relations during the schema integration process The Table Splitting Operator identifies relevant entity types, considering an entity type relevant if at least 3 columns can be associated with it. The Schema Matching Operator finds correspondences between attributes in different schemata, and it employs a post-schema matching LLM reviewer loop to refine attribute groups. The Table Grouping Operator then clusters the entity tables derived from the Table Splitting Operator by entity type. Finally, the Integrated Schema Output Operator removes redundant attributes and introduces identifiers to produce the final integrated schemata.

SINT-Flow Operators

The five operators are designed sequentially to achieve schema integration The Table Splitting Operator outputs entity type table schemata, where all columns of the input tables are assigned to an entity type table schema. The Schema Matching Operator outputs a set of correspondences between columns and the formed attribute groups. The Table Grouping Operator takes these entity tables and groups them by entity type, splitting the attribute groups into attribute groups per entity type. The Attribute Merging Operator selects a representative attribute from each group to build the intermediate integrated schema for each entity type. The Integrated Schema Output Operator performs the final cleanup, removing redundant attributes and outputting foreign keys.

SINT-Bench Benchmark

SINT-Bench is a schema integration benchmark comprising 10 schema integration tasks consisting of altogether 93 relational tables Eight of these tasks involve 2 or more entity types and require the splitting of the columns of each input table per entity type. SINT-Bench is distinguished by including ground truth for the detection of entity types and their attributes within each input table.

Related Work Comparison

SINT-Flow compares itself to existing methods across several categories:

-Based Methods:

Rule-based Symbolic Methods involve manual or semi-automatic approaches based on integration rules and human interaction. SINT-Flow is inspired by this methodology, finding entity type correspondences with the Table Grouping Operator and attribute-level correspondences with the Schema Matching Operator.

-Based Methods:

Probabilistic/Statistical Methods involve generating multiple possible integrated schemata with probabilities indicating likelihood.

-Based Methods:

Clustering-based Methods use attribute clustering to derive an integrated attribute from each attribute cluster, such as ALITE.

Improvements for AI systems

  1. Improve entity-type detection robustness by employing self-consistency across multiple LLM runs to mitigate errors, as this strategy can be used to create consistent outputs for each operator and improves F1 scores for both models.

  2. Enhance attribute correspondence accuracy by incorporating a post-schema matching LLM reviewer loop which checks if a matched column can also be matched to at least one other column, potentially leading to the merging of two attribute groups which should be separate and a loss of an integrated attribute being prevented.

  3. Develop more accurate schema grouping capabilities by utilizing co-occurrence counts between attributes/tables across multiple runs, concluding that if the co-occurence with an attribute/table is higher than half of the number of runs, we conclude that the pair of attributes/tables should be in the same entity type/group in the consistent output.

  4. Increase overall end-to-end schema integration performance by implementing a review loop in both operator types, as both using selfconsistency and a reviewer loop to catch potential false matches impact the performance of the workflows positively.

  5. Enable more flexible workflow design by allowing users to select from three distinct sequences of operators—Entity Type Detection on Input Tables Workflow, Implicit Schema Matching Workflow, and Entity Type Detection on an Integrated Table Workflow—based on data structure and desired integration strategy.

Sources

Related papers