Local reassembly is a targeted computational method that performs de novo assembly of sequencing reads mapping to a specific genomic region to resolve complex variants or haplotypes that cannot be determined by simple alignment. Unlike global alignment which forces reads onto a linear reference, local reassembly constructs a localized consensus sequence from the reads themselves, enabling the detection of compound insertions, deletions, and structural rearrangements that diverge significantly from the reference genome.
Glossary
Local Reassembly
A targeted computational method that performs de novo assembly of reads mapping to a specific region to resolve complex variants or haplotypes that cannot be determined by simple alignment.
TARGETED DE NOVO ASSEMBLY
What is Local Reassembly?
A computational method that performs active alignment refinement by constructing a localized consensus sequence from reads mapping to a specific genomic region, resolving complex variants that standard alignment algorithms cannot detect.
The process begins by identifying active regions where read alignment exhibits elevated entropy, soft-clipping, or discordant pairs. Reads overlapping these regions are collected and assembled into a local de Bruijn graph or overlap-layout-consensus structure, generating candidate haplotypes. These reassembled haplotypes are then aligned back to the reference using Smith-Waterman alignment, producing a more accurate representation of the true biological sequence. This method is a core component of tools like the GATK HaplotypeCaller, which uses local reassembly to accurately genotype complex indels and multi-allelic variants that would otherwise be missed by pileup-based callers.
TARGETED DE NOVO ASSEMBLY
Key Features of Local Reassembly
Local reassembly is a computational method that performs targeted de novo assembly of sequencing reads within a specific genomic interval to resolve complex variants that cannot be determined by simple read alignment alone.
01
Active Region Identification
The process begins by scanning the genome for active regions—intervals where the initial alignment shows evidence of variation inconsistent with a simple diploid model. These regions are identified by analyzing read pileup statistics, including soft-clipped reads, discordant insert sizes, and clusters of mismatches. Only regions with sufficient evidence of complexity are queued for reassembly, minimizing unnecessary computation on well-behaved loci.
02
De Bruijn Graph Construction
Within each active region, all reads are decomposed into overlapping k-mers (substrings of length k) to construct a De Bruijn graph. In this directed graph, nodes represent k-mers and edges represent k-1 overlaps between them. This data structure efficiently captures all possible sequence paths through the region, including alternative alleles and haplotypes, without requiring a reference genome as a scaffold.
03
Haplotype Path Enumeration
Once the De Bruijn graph is built, the assembler traverses the graph to enumerate all plausible haplotype paths connecting the start and end anchors of the active region. Graph pruning removes low-coverage edges likely caused by sequencing errors. The surviving paths represent candidate haplotypes—distinct sequences that may correspond to the maternal and paternal alleles or to complex structural rearrangements.
04
Read-to-Haplotype Realignment
Each sequencing read originally mapped to the active region is realigned against each candidate haplotype using full pairwise alignment algorithms such as Smith-Waterman. This step computes the likelihood of observing each read given each haplotype, accounting for base quality scores and indel penalties. The haplotype that best explains the read data is selected, resolving the true genotype at the locus.
05
Complex Variant Resolution
Local reassembly excels at resolving variant classes that confuse traditional alignment-based callers:
- Multi-nucleotide variants (MNVs): Clusters of nearby SNPs phased together
- Indels in repetitive regions: Homopolymer and tandem repeat length variations
- Complex substitutions: Events where a short sequence is replaced by a different sequence
- Small inversions: Localized sequence reversals within a single read length
06
Assembly vs. Alignment Trade-offs
Local reassembly offers superior sensitivity for complex variants but at higher computational cost than direct alignment. Key trade-offs include:
- Sensitivity: Detects variants invisible to alignment-only methods
- Specificity: Reduces false positives from mismapped reads
- Compute: De Bruijn graph construction and read realignment are CPU-intensive
- K-mer size: Must be tuned to balance graph connectivity against sequence uniqueness
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.
Enterprise searchRAGPermissions
Read more
Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.
AI agentsWorkflow automationGovernance
Read more
Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
AI integrationDecision supportModel routing
Read moreLOCAL REASSEMBLY EXPLAINED
Frequently Asked Questions
Targeted answers to common questions about the computational method that performs de novo assembly of reads mapping to a specific genomic region to resolve complex variants.
Local reassembly is a targeted computational method that performs de novo assembly exclusively on sequencing reads mapped to a specific genomic region, rather than assembling an entire genome. The process begins by identifying a locus where simple alignment is ambiguous—often due to complex structural variants, dense clusters of single nucleotide polymorphisms, or repetitive elements. All reads aligned to that region are collected and used to construct a de Bruijn graph or overlap-layout-consensus graph. This graph is traversed to generate candidate haplotype sequences, which are then aligned back to the reference to resolve the true variant architecture. Unlike global assembly, local reassembly is computationally efficient because it restricts the graph construction to a narrow window, allowing it to resolve complex haplotypes that read-backed phasing or simple pileup analysis would miss. Tools like Platypus, Scalpel, and the local reassembly module within GATK HaplotypeCaller implement variations of this strategy to improve indel and structural variant calling accuracy.
About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
LinkedIn
Limited slotsGet a Free AI Consultation
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us