Protocol for telomere-to-telomere assembly of Borrelia genomes using a hybrid method

Summary

Borrelia has a linear chromosome and linear plasmids capped by hairpin telomeres that short-read sequencing cannot resolve. Here, we present a protocol for telomere-to-telomere assembly of Borrelia genomes. We describe steps for spanning B. burgdorferi culture, DNA extraction, and sequencing through hybrid genome assembly to generate complete Borrelia genomes. The pipeline integrates Oxford Nanopore long reads and Illumina short reads to assemble hairpin telomeres, resolve paralogous linear and circular plasmids, and annotate and validate the assembled complete Borrelia genome.

For complete details on the use and execution of this protocol, please refer to Amin et al.¹

Graphical abstract

Highlights

• •Steps for assembling complete Borrelia genomes using a hybrid approach
• •Instructions for resolving the hairpin telomeres of linear chromosome and plasmids
• •Steps for telomeric end extension, trimming, and circularization of plasmids
• •Steps for validating and annotating the complete Borrelia genomes

Publisher’s note: Undertaking any experimental protocol requires adherence to local institutional guidelines for laboratory safety and ethics.

Borrelia has a linear chromosome and linear plasmids capped by hairpin telomeres that short-read sequencing cannot resolve. Here, we present a protocol for telomere-to-telomere assembly of Borrelia genomes. We describe steps for spanning B. burgdorferi culture, DNA extraction, and sequencing through hybrid genome assembly to generate complete Borrelia genomes. The pipeline integrates Oxford Nanopore long reads and Illumina short reads to assemble hairpin telomeres, resolve paralogous linear and circular plasmids, and annotate and validate the assembled complete Borrelia genome.

Before you begin

Overview

This protocol describes in detail a hybrid genome assembly pipeline optimized for Borrelia burgdorferi, a bacterium with a linear chromosome and multiple linear and circular plasmids terminated by covalently closed hairpin telomeres.¹ Successful application of this protocol requires careful attention to sample quality, sequencing strategy, and computational setup. Prior to starting, users should ensure that all biological materials, sequencing data, and computational resources meet the requirements outlined below.

This protocol has been optimized for Borrelia species and adaptation to organisms with different telomeric structures or replication mechanisms may require additional validation and workflow modification. Because accurate reconstruction of hairpin telomeres and paralogous plasmids depends on long contiguous reads, long read sequencing data is essential. Short read data alone is insufficient to resolve telomeric structures or discriminate among highly similar plasmids.

Innovation

This protocol introduces several methodological advances for generating complete, telomere-to-telomere assemblies of Borrelia genomes, including comprehensive recovery of their linear and circular plasmid repertoire.

Identification and validation of hairpin telomeres in linear chromosomes

This workflow enables the precise identification of inversion points associated with covalently closed hairpin telomeres and systematic detection of conserved telomeric motifs in assembled linear chromosomes. These steps facilitate accurate telomere-to-telomere chromosome reconstruction and enable comparative analyses of conserved and variable telomeric sequences across Borrelia strains.

Integration of a dedicated plasmid assembler into a hybrid assembly framework

The protocol combines long read and short read sequencing within a hybrid framework, using Trycycler² for robust linear chromosome assembly, while incorporating Plassembler,³ a plasmid-focused assembler, to reliably recover both high- and low-copy-number plasmids that are frequently missed or fragmented by general-purpose assemblers.

Extension of plasmid assembly to resolve complete linear plasmids

The workflow further customizes plasmid assembly by introducing a telomeric end extension step, enabling the reconstruction of linear plasmids with fully resolved hairpin telomeres and improving confidence in plasmid completeness, topology, and classification (plasmid topology determination method is explained in detail in step 26 and 27).

Together, these innovations establish a reproducible, scalable, and broadly applicable workflow for high-resolution Borrelia genome assembly, providing a practical framework for investigating plasmid diversity and genome plasticity at the telomeric ends of linear replicons.

Experimental design considerations

• 1.
  Generate both Oxford Nanopore Technologies (ONT) long reads and Illumina short reads from the same DNA preparation whenever possible.

  Note: Long reads are used to assemble complete linear and circular replicons, while short reads are used for polishing to improve base-level accuracy. The pipeline does not strictly require short reads; however, Illumina polishing is strongly recommended for highest base-level accuracy. If short reads are unavailable, use a high-accuracy ONT chemistry (R10.4.1, Q20+) or PacBio sequencing with a second round of long read only polishing.

  Note: Cultured isolates should be handled consistently, as Borrelia plasmid content—particularly linear plasmids—can change during prolonged in vitro passage.

  CRITICAL: High molecular weight genomic DNA is critical for successful telomere-to-telomere assembly. DNA should be minimally fragmented and free of contaminants that inhibit long read sequencing.

  • a.
    DNA fragments ≥50 kb are strongly recommended for ONT sequencing.
  • b.
    Avoid harsh mechanical disruption during extraction.
  • c.
    DNA purity should meet standard ONT requirements (A260/280 ≈ 1.8–2.0; A260/230 ≥ 2.0).
  • d.
    If possible, avoid repeated freeze-thaw cycles prior to library preparation.

    CRITICAL: Base calling should be performed using the latest ONT-supported base caller, and sequencing adapters must be removed prior to assembly. Keep complete documentation on library preparation, sequencing platform, and sequencing statistics (read length, quality).

Software requirements

• 2.Before beginning, ensure that all required software tools are installed and accessible in the user’s environment, including assemblers, polishers, and visualization tools.

Note: The pipeline is implemented in Python and BASH. To use it, Python 3.7 must be installed, which can be downloaded from this website https://www.python.org/downloads/release/python-370/. Additionally, Windows users will need to install BASH. Installation guidelines and documentation for each package or tool used in this pipeline are available on their respective GitHub repositories or official websites (see key resources table).

Note: We conducted our experiments on a High-Performance Computing (HPC) cluster where all necessary modules were preinstalled. For users working in a Unix environment without preinstalled modules, the required tools must be installed separately by following the provided installation guidelines. As a bioinformatics pipeline, the execution steps can be saved and resumed at any time. The runtime for each step will vary depending on the dataset size and the available computational resources.

Key resources table

REAGENT or RESOURCE	SOURCE	IDENTIFIER
Chemicals, peptides, and recombinant proteins
BSK-H medium	Sigma	B8291
Rifampicin	Fisher	BP26791
Dimethyl sulfoxide (DMSO)	J.T. Baker	9224-01
Glycoblue ™ Coprecipitant	Thermo Fisher	AM9516
Phosphate Buffered Saline (PBS)	Fisher bioreagents	BP399-1
Ethanol 100% Ultrapure	Sigma Aldrich	E7023
Isopropanol	Fisher bioreagents	BP2632-4
Agarose	Fisher bioreagents	BP160-500
SYBR-safe DNA gel stain	Invitrogen	S33102
Quick Load 1Kb Extend DNA ladder	New England Biolabs	N3239S
Boric acid	Fisher	BP168-1
EDTA	Invitrogen	AM9261
Tris	Invitrogen	15504-020
Commercial assays
Wizard® Genomic DNA Purification Kit	Promega	A1120
Deposited data
Assembled genomes	This paper	NCBI BioProject: PRJNA1293716
Raw sequencing data	This paper	Sequence Read Archive (SRA): PRJNA1293716
Software and algorithms
SAMtools v1.12	Li et al.4	http://www.htslib.org
Minimap2 v2.23	Li et al.5	https://github.com/lh3/minimap2
Canu v2.2	Koren et al.6	https://github.com/marbl/canu
Plassembler v1.1.0	Bouras et al.3	https://github.com/gbouras13/plassembler/tree/v1.1.0
Trycycler v0.5.5	Wick et al.2	https://github.com/rrwick/Trycycler
Bakta v1.11	Schwengers et al.7	https://github.com/oschwengers/bakta
Flye v2.9.4	Freire et al.8	https://github.com/mikolmogorov/Flye
Simple-Circularise	--	https://github.com/Kzra/Simple-Circularise
Polypolish v0.6.0	Wick et al.9	https://github.com/rrwick/Polypolish
Inverted Repeats Finder (IRF) v3.08	Warburton et al.10	https://github.com/Benson-Genomics-Lab/IRF
Filtlong v0.3.1	--	https://github.com/rrwick/Filtlong
BLAST	Altschul et al.11	https://blast.ncbi.nlm.nih.gov/Blast.cgi
BEDTools v2.31.0	Quinlan et al.12	https://github.com/arq5x/bedtools2
SeqKit v2.9.0	Shen et al.13	https://github.com/shenwei356/seqkit
seqtk	--	https://github.com/lh3/seqtk
NanoPlot v1.44.1	De Coster et al.14	https://github.com/wdecoster/NanoPlot
Medaka v2.0.1	--	https://github.com/nanoporetech/medaka
fastp v0.23.4	Chen et al.15	https://github.com/OpenGene/fastp
Other
Pyrex® VISTA™ culture tube, screwcap	Sigma Aldrich	CLS7082513
CO2 Incubator	VWR	N/A
Biological safety cabinet
Microfuge	Beckman Coulter	B31612
Heat block	Labnet	D1100
BioTek Cytation 5	Agilent	N/A
Wood stick applicators (6″)	MedPro	018-472
Dark-field microscope	Leica	N/A
Microscopy glass slides	Sigma Aldrich	S8902
Cover glasses	Sigma Aldrich	C8181
Disposable serological pipettes (10 mL)	Sarstedt	86.1254.001
Pipet filter tips (10 μL, 200 μL, 1,000 μL)	Sartorius	790011F, 790201F, 791001F
0.2 μm syringe filters	Thermo Fisher Scientific	83.1826.001
50 mL centrifuge tubes	Falcon	352070
1.5 mL microcentrifuge tubes	Progene	87-B150-AS
Cryovial	Corning	430488

Materials and equipment

TBE buffer 10X

Reagent	Final concentration	Amount
Tris base	0.89 M	108 g
Boric acid	0.89 M	55 g
EDTA (0.5 M, pH 8.0)	20mM	40 mL
dH20	-	960 mL
Total	N/A	1 L

Note: 10X TBE can be stored at 20°C–23°C for up to 6 months.

0.6% agarose gel

Reagent	Final concentration	Amount
Agarose	0.6%	1.2 g
TBE	1X	200 mL
Total	N/A	200 mL

Note: Prepare fresh for each experiment.

Step-by-step method details

Preparation of Borrelia cultures and extraction of high molecular weight genomic DNA

Timing: ∼11 days

This major step describes the culture of Borrelia strains and the extraction of intact, high molecular weight genomic DNA suitable for long read sequencing and hybrid genome assembly.

Borrelia burgdorferi culture preparation

Timing: 1 h

Note: For this study, we used nine isolates of Borrelia burgdorferi, all cultured under identical growth conditions.

• 1.
  Preparation of antibiotic stock.

  • a.
    Dissolve 50 mg of rifampicin in 1 mL of DMSO to make a 50 mg/mL stock solution.
  • b.
    Filter sterilize the solution using a 0.2 μm syringe filter.
  • c.
    Store the antibiotic stock solution at −20°C until use.

Note: Since Borrelia exhibits intrinsic resistance to rifampicin, this antibiotic is added to the medium to prevent contamination.

• 2.
  Preparation of Borrelia burgdorferi culture medium.

  • a.
    Barbour-Stoenner-Kelly (BSK-H) medium is supplied frozen. Thaw the medium at 4°C one day before use.
  • b.
    Aliquot 40 mL of BSK-H medium into 50 mL centrifuge tubes and store at −20°C for future use.
  • c.
    As the medium already contains 6% rabbit serum, supplement it with rifampicin to a final concentration of 50 μg/mL.
  • d.
    Store the prepared medium at 4°C for up to one month.

Note: Avoid repeated freeze-thaw cycles.

Borrelia burgdorferi culture

Timing: 1 h

Day 1

Note:Borrelia burgdorferi (Bb) samples are stored as glycerol cryostocks at −80°C and should be thawed only partially during inoculation.

Note:Borrelia samples should be handled in a laminar flow cabinet while wearing appropriate personal protective equipment, including gloves and a lab coat. All experimental manipulations, including culture, DNA extraction, and sample processing, must be conducted in a Biosafety Level 2 (BSL-2) certified facility in accordance with your institutional biosafety regulations.

Note: Before starting, ensure that all tubes, pipette tips, and wooden sticks have been autoclaved.

• 3.Add 7 mL of complete medium to a 13 mL Pyrex® VISTA™ culture tube.
• 4.Remove the Borrelia glycerol stock cryotube from −80°C and place it immediately on ice.

CRITICAL: Place cryotubes with cultures on ice to prevent the entire culture from thawing.

• 5.Using a sterile wooden stick, transfer a small amount of the frozen glycerol stock into the culture tube, holding the stick by its upper end to avoid contamination.
• 6.Submerge only the tip of the wooden stick into the medium, avoiding contact with the tube walls.
• 7.Incubate the culture at 33°C with 5% CO₂, without shaking.
• 8.Examine the culture after five days using dark-field microscopy; motile spirochetes should be visible. After 10–15 days, a substantial increase in spirochetes density should be observed.

Note: The time required for spirochetes to reach mid-log phase depends on the frozen stock. Typically, a density of 5 × 10⁷ spirochetes/mL is achieved within 1–2 weeks. In this study, all cultures reached a similar density after 10 days of incubation.

Day 10

• 9.Using dark-field microscopy, evaluate cultures for spirochete count, morphology, and motility. To do this, place 10 μL of culture on a glass slide, cover it with a coverslip, and examine it under the microscope.
• 10.Once the culture density is confirmed, along with the helical shape of the spirochetes and their high motility, transfer the 7 mL of culture to a 15 mL centrifuge tube.
• 11.Centrifuge at 16,000 × g for 2 min to collect the pellet.
• 12.Wash the pellet with 1 mL of PBS 1X buffer.
• 13.Centrifuge at 1,500 × g for 5 min at 4°C.
• 14.Resuspend the pellet with 1 mL of PBS 1X buffer and transfer it to a 1.5 mL centrifuge tube.
• 15.Centrifuge at 1,500 × g for 5 min at 4°C.
• 16.Discard the supernatant and proceed with DNA extraction.

Total DNA extraction

Timing: 1 day

Note: Genomic DNA is extracted from fresh cell pellets using the Wizard® Genomic DNA Purification Kit (Promega; see key resources table). The DNA is then used to sequence the Borrelia burgdorferi strains. This protocol has been refined to enhance the quality of DNA extraction.

• 17.
  Before starting the DNA extraction, prepare the following:

  • a.
    Preheat a heat block to 80°C.
  • b.
    Preheat a heat block to 37°C.
  • c.
    Prepare an aliquot of isopropanol 100%.
  • d.
    Make a 70% ethanol solution using nuclease-free water.
  • e.
    Perform all centrifugation steps at 4°C.
  • f.
    Use filtered pipette tips for all steps to avoid contamination of genomic DNA.
• 18.
  For genomic DNA extraction, follow these steps:

  • a.
    Add 600 μL of Nuclei Lysis Solution. Pipette gently until the cells are fully resuspended.
  • b.
    Incubate at 80°C for 5 min to lyse the cells. Then, cool the solution to 20°C–23°C for 5 min.
  • c.
    Add 3 μL of RNase Solution to the cell lysate. Gently invert the tube 2–5 times to mix thoroughly.
  • d.
    Incubate the mixture at 37°C for 60 min, then cool to 20°C–23°C for 5 min.
  • e.
    Add 200 μL of Protein Precipitation Solution to the RNase-treated cell lysate. Homogenize gently using a pipette. Do not vortex.

    Note: Avoid vortexing to prevent DNA fragmentation.

  • f.
    Incubate the sample on ice for 5 min.
  • g.
    Centrifuge at 16,000 × g for 3 min at 4°C.
  • h.
    Transfer the supernatant containing the DNA to a clean 1.5 mL microcentrifuge tube.
  • i.
    Add 3 μL of Glycoblue ™ coprecipitant to the supernatant (final concentration 50 μg/mL). Invert the tube 2–5 times to ensure proper mixing.

    Note: GlycoBlue coprecipitant enhances the recovery and visibility of nucleic acid pellets, making it especially useful for quantitative recovery of low-concentration DNA and preventing pellet loss during alcohol precipitation.

  • j.
    Add 600 μL of room-temperature isopropanol to the tube.
  • k.
    Mix gently by inversion to precipitate the DNA. Centrifuge at 16,000 × g for 2 min at 4°C.
  • m.
    Carefully pour off the supernatant, then drain the tube on clean absorbent paper. Add 600 μL of room-temperature 70% ethanol to the tube and gently invert several times to wash the DNA pellet.
  • n.
    Centrifuge at 16,000 × g for 2 min at 4°C. Carefully aspirate the ethanol without disturbing the pellet.
  • o.
    Drain the tube on clean absorbent paper and allow the pellet to air-dry at 20°C–23°C.
  • p.
    Add 50 μL of DNA Rehydration Solution and incubate the tube overnight at 20°C–23°C to rehydrate the DNA.
  • q.
    Quantify the DNA and measure purity using the Cytation 5 spectrophotometer.

    Note: Any low volume spectrophotometer can be used to assess DNA concentration and purity, such the Nanodrop (Thermo Scientific) or Biodrop (Biochrom).

  • r.
    Store the rehydrated DNA at −20°C.
• 19.
  Assessment of genomic DNA integrity.

  CRITICAL: It is essential to verify the integrity of genomic DNA before proceeding with sequencing. Degraded or fragmented DNA can result in incomplete or inaccurate sequencing data, potentially compromising downstream analyses, especially for long read sequencing. This step ensures optimal library preparation, sequencing yield, and accurate genome assembly.

  • a.
    Prepare a 0.6% agarose gel (see the materials and equipment section for the detailed recipe).

    • i.
      Add 20 μL of SYBR Safe DNA gel stain to 200 mL of 1X TBE buffer.
    • ii.
      Heat the mixture in a microwave for 3 min or until the agarose is fully dissolved.
    • iii.
      Allow the agarose solution to cool for 5 min.
    • iv.
      Pour the agarose into a gel tray with a comb in place.
    • v.
      Let the gel solidify at 20°C–23°C for 1 hour.
  • b.
    Mix 5 μL of DNA with 2 μL of 6X loading buffer.
  • c.
    Load the sample onto the agarose gel.
  • d.
    Run the agarose gel at 80 V for 6 h (see Figure 1).

    Note: Expected gel pattern: High molecular weight (HMW) genomic DNA should migrate as a tight band above the 10 kb marker. Faint lower molecular weight bands may be present and represent a minor proportion of fragmented DNA or small plasmids (∼5–6 kb for linear plasmid lp5), which is acceptable provided the dominant band is intact HMW DNA.

    Note: Unacceptable gel patterns: (a) Diffuse smear with no discrete band indicates extensive DNA shearing; DNA should not be used for ONT library preparation; repeat extraction with gentler lysis. (b) No visible band indicates insufficient DNA yield; increase culture volume or starting material.

• 20.Prior to library preparation, assess DNA quality and fragment size.

Note: In the current work, DNA quality was assessed using a Genomic DNA ScreenTape (Agilent TapeStation) and fragment size was confirmed using the FEMTO Pulse gDNA 165 kb Kit (Agilent). If DNA passes quality thresholds, proceed directly to sequencing the genomic DNA on your preferred short and long read platform without additional purification.

Note: The short read and long read sequencing of the recovered high molecular weight gDNA can be done at your favorite sequencing core facility. In the current example, sequencing was performed at the McGill University Genome Centre. For Illumina sequencing, libraries were prepared using the NxSeq AmpFREE Low DNA Library Kit (LCG Biosearch Technologies) following the manufacturer's instructions. The indexed libraries were multiplexed and sequenced on an Illumina MiSeq v2 flowcell in a paired-end 150 bp configuration. For ONT long read sequencing, libraries were prepared using native sample barcoding following Oxford Nanopore Technology instructions. The libraries were pooled and sequenced on MinION R10.3 flowcells. In both cases, nascent genomic DNA is used directly, and no PCR amplification of template DNA is performed.

Figure 1.

DNA integrity of nine clinical samples

Line 1: DNA ladder (Quick Load 1Kb Extend DNA ladder, New England Biolabs). Line 2: Sample 1; Line 3: Sample 3; Line 4: Sample 4; Line 5: Sample 5; Line 6: Sample 6; Line 7: sample 7; Line 8: sample 8; Line 9: sample 9; Line 10: sample 10. Line 11: DNA ladder (Quick Load 1Kb Extend DNA ladder, New England Biolabs).

Complete genome assembly and resolution of hairpin telomere

Timing: ∼2 days

Pipeline for genome assembly and annotation

Timing: 5 h (step 21)

Timing: 24 h (step 22)

Timing: 2 h (step 23)

Timing: 2 h (step 24)

Timing: 10 h (step 25)

This major step explains a genome assembly pipeline that generates a complete assembly of Borrelia burgdorferi genome using a hybrid approach that combines Illumina paired-end short reads with Oxford Nanopore Technologies (ONT) long reads. The example dataset includes raw paired-end Illumina reads and base called ONT reads for nine Borrelia strains and is available as Sequence Read Archive (SRA) under the NCBI BioProject accession number PRJNA1293716.

Borrelia species have a unique genomic architecture consisting of a linear chromosome and both linear and circular plasmids. While some plasmids are consistently retained across species and strains, others are frequently lost. The linear plasmids, in particular, present a significant assembly challenge due to their high sequence homology within and across different plasmid types.

We used Trycycler² for the linear chromosome assembly. Trycycler uses three different assemblers of choice and performs a consensus generation step for all the contigs generated by the three assemblers. Because Borrelia plasmids have high level of mosaism, Trycycler fails during the consensus generation step for the plasmid assembly. Moreover, Trycycler performs long read first assemblies which tends to miss small (<20 kb) plasmids¹⁶ and Borrelia has plasmids as small as 5 kb. Therefore, we developed a separate pipeline for assembling the plasmids (Figure 2). We used Plassembler,³ which is designed to capture even the low copy number plasmids by removing the chromosomal reads before performing plasmid specific assembly. In this major step, we explain the details of using Trycycler and Plassembler for the assembly of linear chromosomes and plasmid of Borrelia burgdorferi strains.

• 21.
  Perform quality control of the raw sequencing data.

  • a.
    For Illumina reads, use fastp¹⁵ with default parameters to remove the adaptors and trim the low quality regions of the reads using the following command.
    >fastp --in1 bb_illumina_R1.fastq.gz --in2 bb_illumina_R2.fastq.gz --out1 bb_illumina_R1_P.fastq.gz --out2 bb_illumina_R2_P.fastq.gz --unpaired1 bb_illumina_R1_U.fastq.gz --unpaired2 bb_illumina_R2_U.fastq.gz

    Note: The aim of this step is to discard the low-quality reads, trim adaptors or low-quality regions of the reads. For each strain, we had paired-end Illumina reads in FASTQ format as input, for example, bb_illumina_R1.fastq.gz and bb_illumina_R2.fastq.gz.

    Note:fastp will generate a QC report which needs to be thoroughly investigated to identify if the trimming was performed properly. For our case, the Illumina read quality was already good, with each library having ∼97% of the reads with >Q30 bases. Therefore, the fraction of trimmed reads was low (0.18%) and 99% of the reads passed the quality threshold (Figure 3).

  • b.
    Run Nanopore reads quality control and filtering using the following commands.

    • i.
      Use NanoPlot¹⁴ to investigate the quality of the ONT reads to take a decision regarding the filtering parameters.
    • ii.
      Utilize Filtlong (https://github.com/rrwick/Filtlong) to discard the worst 10% of the reads, which increases the N50 and the percent of reads with higher quality score (Figure 4).

      Note:NanoPlot creates a summary report to identify if the filtering was performed properly. Below is an example of the filtering approach for one sample, bb_ont.fastq.gz. In this example, Filtlong filtering improves mean read length by removing the shortest, lowest-quality reads that represent a large fraction of total read count but contribute minimally to total sequencing bases. In the current example, filtering increased N50 from 5,286 bp to 5,736 bp (∼8.5% improvement) and mean read length from 2,652 bp to 4,090 bp (∼54% improvement), with median Phred quality improving from Q12 to Q12.9. While the N50 improvement may appear modest, the primary benefit is enrichment of reads >1,000 bp that improve assembly graph continuity in subsequent steps.

      #!/bin/bash

      # Filter the input FASTQ file, keeping the top 90% of reads

      filtlong --keep_percent 90 bb_ont.fastq.gz > bb_ont_filtered.fastq

      # Run NanoPlot on the filtered FASTQ file

      NanoPlot --fastq bb_ont_filtered.fastq \

         -o ./bb_ont_filtered_QC \

         --tsv_stats \

         -c magenta \

         -cm plasma \

         -f tiff \

         --plots kde hex dot \

         --N50 \

         --title bb_ONT \

         --dpi 300 \

         --verbose
• 22.
  Assemble the linear chromosome using Trycycler.

  Note: Performing the QC steps, will generate the following filtered data, bb_illumina_R1_P.fastq.gz, bb_illumina_R2_P.fastq.gz, and bb_ont_filtered.fastq. Use Trycycler² to first perform a long read only assembly of the complete linear chromosome with the hairpin telomeres. Correct the draft assembly for small scale errors with the subsequent polishing steps using both Illumina and ONT reads.

  Note:Trycycler performs assembly in a multi-step process. The details of each step can be found in the Trycycler² documentation.

  • a.
    Run subsampling to produce semi-independent read subsets. Set the genome size to be 1 MB based on the linear chromosome length of the reference Borrelia burgdorferi genomes.
      >trycycler subsample --reads bb_ont_filtered.fastq --out_dir read_subsets --genome_size 1.0m

    Note: After this step, 12 FASTQ files will be saved in the “read_subsets” directory.

  • b.
    Run an assembly for each read subset. Select three different assemblers Canu,⁶ Flye,⁸ and Raven¹⁷ to generate a consensus assembly. 12 FASTA files will be saved in the “assemblies” directory as the assembled contigs.

    #!/bin/bash

    # Running assembly

    threads=16

    mkdir assemblies

    # Run Flye for sub-sample 01

    flye --nano-hq read_subsets/sample_01.fastq --threads "$threads" --out-dir assembly_01 && cp assembly_01/assembly.fasta assemblies/assembly_01.fasta

    # Run Canu for sub-sample 02

    canu -p assembly_02 -d canu_assembly_02 genomeSize=1m -nanopore read_subsets/sample_02.fastq useGrid=false maxThreads=“$threads”

    cp canu_assembly_02/assembly_02.contigs.fasta assemblies/assembly_02.fasta

    # Run Raven for sub-sample 03

    raven --threads "$threads" --disable-checkpoints read_subsets/sample_03.fastq > assemblies/assembly_03.fasta

    Note: Following similar commands, assemblies need to be performed for the rest of the sub-samples. In the end, 12 assemblies will be saved inside the “assemblies” directory.

  • c.
    Perform clustering of the contigs generated at the previous assemblies. This step requires manual intervention to identify the valid and desired clusters. An example is provided for cluster_001. Troubleshooting 1.

    • i.
      Look for the chromosomal contigs from the 12 generated assemblies, which are expected to form a single cluster.
    • ii.
      Identify the representative cluster of the linear chromosome contigs based on the expected length of the contigs.
    • iii.
      Use this representative cluster for the multiple sequence alignment, partitioning, and consensus generation steps.

      #!/bin/bash

      # Running clustering

      trycycler cluster --assemblies assemblies/∗.fasta --reads bb_ont_filtered.fastq --out_dir trycycler

      # Optional step for circular genome

      trycycler reconcile --reads bb_ont_filtered.fastq --cluster_dir trycycler/cluster_001

      # To run multiple sequence alignment on each cluster

      trycycler msa --cluster_dir trycycler/cluster_001

      # To assign each read to a cluster

      trycycler partition --reads bb_ont_filtered.fastq --cluster_dir trycycler/cluster_001

      # To generate a consensus for each cluster

      trycycler consensus --cluster_dir trycycler/cluster_001

      Note: After finishing the read partitioning steps, a file named 4_reads.fastq will be generated inside the corresponding cluster directory. This file carries the ONT reads associated with the cluster. After the consensus generation step, a final consensus assembly for the linear chromosome will be saved as 7_final_consensus.fasta. Both files will be used for assembly polishing in the next steps.

• 23.
  Polish the linear chromosome

  • a.
    To get an error free ONT only assembly, polish the draft assembly 7_final_consensus.fasta with the ONT reads using Medaka (https://github.com/nanoporetech/medaka) and save the output polished assembly as trycycler_medaka.fasta.

    Note: One key point to remember when running Medaka is matching its model to the basecaller used for the ONT sequencing. For our dataset, the r104_e81_sup_g610 model was the best match.

    #!/bin/bash

    # Running Medaka Polishing

    medaka_consensus -i trycycler/cluster_001/4_reads.fastq -d trycycler/cluster_001/7_final_consensus.fasta -o trycycler/cluster_001/medaka -m r104_e81_sup_g610

    mv trycycler/cluster_001/medaka/consensus.fasta trycycler/cluster_001/trycycler_medaka.fasta

    #!/bin/bash

    threads=16

    # Running Polypolish polishing

    # Step1: Running bwa alignment

    bwa index trycycler_medaka.fasta

    bwa mem -t "$threads" -a trycycler_medaka.fasta bb_illumina_R1_P.fastq.gz > alignments_1.sam

    bwa mem -t "$threads" -a trycycler_medaka.fasta bb_illumina_R2_P.fastq.gz > alignments_2.sam

    # Step2: Filter alignments using polypolish

    polypolish filter --in1 alignments_1.sam --in2 alignments_2.sam --out1 filtered_1.sam --out2 filtered_2.sam

    # Step3: Perform polishing with polypolish

    polypolish polish trycycler_medaka.fasta filtered_1.sam filtered_2.sam > trycycler_medaka_polypolish.fasta
  • b.
    After Medaka polishing, to correct any small scale error in the polished draft assembly, trycycler_medaka.fasta, polish further with Illumina reads using Polypolish⁹ to generate trycycler_medaka_polypolish.fasta as the final linear chromosome assembly.

    Note: The commands above were explained to perform Trycycler assembly for one sample. Since we had nine samples, we performed nine separate assembly and combined the assembled linear chromosomes in a single FASTA file.

• 24.
  Trim linear chromosome-based on the telomere hairpin positions. Troubleshooting 2.

  Note: After assembling and polishing the linear chromosomes the next step is to trim them based on the hairpin telomere positions. Terminal hairpin telomeres can be identified by a self-identity dot plot where the hairpin wraparounds are visualized as inverse duplications. However, to verify the assembly accuracy, the hairpin wraparound positions more precisely, and characterize strain-specific sequence variation within the conserved telomeric motifs (ATATTA, ATCATYTNT) at chromosome ends, search for the conserved telomeric sequences at both termini and trim the assembly based on that. Conserved telomeric sequences are already known for different Borrelia species, including Borrelia burgdorferi. Use the conserved telomeric sequences for the reference strain B31, ATATAATTTTTAATTAGTATAGAATATGTTAA (right end) and TAAATATAATTTAATAGTATAAAAAAAATT (left end) to identify the inversion positions in each assembly.¹⁸ Below are the steps to perform the trimming.

  • a.
    Make a single FASTA file called linear_chromosomes.fasta, combining the assembled linear chromosomes that need to be trimmed.

    CRITICAL: All chromosomes need to be in the same (either forward or reverse) direction.

  • b.
    Go to NCBI BLAST (https://blast.ncbi.nlm.nih.gov/Blast.cgi) > select Nucleotide BLAST > select Align two or more sequences > upload the linear_chromosomes.fasta file as subject sequence and upload the conserved telomeric sequences as query sequences > select the option blastn.
  • c.
    Once the results are generated for each assembled chromosome, select alignment > select graphics. This allows closer look at the alignments of the conserved telomeric sequences to the linear chromosome contig (Figure 5).

    Note: The telomeric ends need to be manually examined to identify the inversion positions accurately. Due to strain specific genetic variations, there might be one or two bases in between the inverse duplicates, and mismatches (SNPs or InDels) in the assembled chromosome compared to the conserved telomeric sequences, which need to be identified carefully to increase the accuracy of trimming.

  • d.
    Save the inversion positions of all linear chromosome contigs in a tab separated TXT file named trimming_position.txt.

    Note: The first column of the TXT file will be the header of each contig matching the linear_chromosomes.fasta, second column will be the inversion position of the left end, and the third column will be the inversion position of the right end. An example of the trimming_position.txt file is given below.

    bb1 11463 921975
    bb3 19033 921811
    bb4 15738 918517

    from Bio import SeqIO

    def trim_genomes(fasta_file, positions_file, output_file):

      # Read the positions with genome names

      positions = {}

      with open(positions_file, 'r') as pos_file:

       for line in pos_file:

        genome_name, start, end = line.strip().split()

        positions[genome_name] = (int(start), int(end))

      # Read the genomes and trim them based on the provided positions

      trimmed_records = []

      for record in SeqIO.parse(fasta_file, "fasta"):

       genome_name = record.id

       if genome_name in positions:

        start, end = positions[genome_name]

        trimmed_seq = record.seq[start-1:end]

        trimmed_record = record[start-1:end]

        trimmed_records.append(trimmed_record)

      # Write the trimmed genomes to a new FASTA file

      SeqIO.write(trimmed_records, output_file, "fasta")

    # File paths

    fasta_file = "linear_chromosomes.fasta"

    positions_file = "trimming_position.txt"

    output_file = "trimmed_chromosomes.fasta"

    # Trim the genomes

    trim_genomes(fasta_file, positions_file, output_file)
  • e.
    Save the above Python script, trimming_based_on_inversion_position.py in the same directory where the linear_chromosomes.fasta and trimming_position.txt files are located using a text editor such as vim or nano or VS Code. Make the script executable. Then, run the Python script from terminal.
    >vim trimming_based_on_inversion_position.py
    >chmod +x trimming_based_on_inversion_position.py
    >python trimming_based_on_inversion_position.py

    Note: The trimmed linear chromosomes will be saved as trimmed_chromosomes.fasta in the current directory.

  • f.
    Check if trimming was performed properly by comparing the length of the linear chromosomes before and after trimming using SeqKit¹³ and save it in a separate spreadsheet as shown below.

    Alignment span of conserved telomere seq				Length before trimming	Length after trimming
    Left end		Right end
    11463 (Trimming Position)	11492	921945	921975 (Trimming Position)	931948	910512

    Note: Conserved telomeric motifs are recognition sequences for ResT-mediated telomere resolution. This is recommended when investigating the biological integrity of hairpin telomeres across strains (Figure 1B¹). If the goal is assembly completion only, and a large number of linear replicons require trimming, users may proceed directly to Step 27a–c, where the trimming_based_on_inversion_position.py script automates contig trimming based on IRF-identified inversion positions.

• 25.
  Assemble plasmids using Plassembler and perform post processing of the contigs. Troubleshooting 3.

  Note: Complete assemblies for low copy number plasmids are challenging. Plassembler³ tackle this challenge by removing the chromosomal reads from the assembly process, increasing the computational efficiency and accuracy compared to the gold standard bacterial genome assembler such as Unicycler.¹⁹ Here, we used Plassembler for assembling even the low copy number Borrelia plasmids using a hybrid method of long and short read sequencing.

  • a.
    Use the same ONT reads bb_ont_filtered.fastq and the Illumina reads bb_illumina_R1_P.fastq and bb_illumina_R2_P.fastq used for the linear chromosome assembly as inputs for plasmid assembly using Plassembler.
  • b.
    Download the plassembler database following installation. The easiest way to install Plassembler is via conda.
     >conda install -c bioconda plassembler
     >plassembler download -d plass_DB

    #!/bin/bash

    # Running plassembler

    plassembler run \

     -d plass_DB/ \

     -l bb_ont_filtered.fastq \

     -1 bb_illumina_R1.fastq \

     -2 bb_illumina_R2.fastq \

     -o plassembler_output \

     -t 32 \

     -c 900000

    Note: Adjust -t (threads) to match the number of CPU cores available on your system. Here, -c, chromosome length threshold was set to 900,000 bp based on the reference chromosome length.

    Note: The assembled plasmids will be saved as plasmids.fasta in the “plassembler_output” directory. A summary.tsv file will be generated which includes information regarding the contig length, depth of coverage for short and long reads, estimated copy number, topology, concordance to a known plasmid in the plasmid database PLSDB,²⁰ accession number of the orthologous reference plasmid (ACC_NUCCORE), and description of the orthologs such as its length, strain, plasmid type, sample source, sample collection location, collection year, Biosample ID, etc (Table 1).

  • c.
    Filter the contigs generated by Plassembler based on length to identify the potential plasmid contigs. Set the plasmid contig length threshold to be at least 1000 bp. For the filtered contigs, divide them into circular and linear plasmid contigs based on the topology of the ortholog reference plasmid reported by Plassembler and save them into two different FASTA files, circular_plasmid_contigs.fasta and linear_plasmid_contigs.fasta. These FASTA files carrying the filtered plasmid contigs will be used as inputs for the next major step.

Figure 2.

Flowchart explaining the genome assembly pipeline

The orange boxes refer to the input files and the green boxes refer to the tools used for quality control of the raw sequencing data before using them for assembly pipeline. The blue and grey boxes represent the nuclear genome assembly and plasmid assembly pipelines, respectively. The names of the tools were italicized to distinguish them from the files. Reprinted and adapted with permission from Amin et al.¹

Figure 3.

Quality control of the Illumina short reads using fastp

(A) An example summary report showing the read quality matrices before and after filtering.

(B) Approximately 97% of the reads had quality score more than 30 before and after filtering.

Figure 4.

Quality control of the ONT reads using Filtlong

(A) An example of the NanoPlot report showing the quality parameters of the ONT reads before and after filtering. Orange colored row shows the improved quality parameters.

(B) Histograms showing increase of N50 before and after filtering.

Figure 5.

Identification of the inversion positions at the telomeres

Visualization of the inversion positions at the (A) left and (B) right telomeric ends of a linear chromosome.

Table 1.

An example of Plassembler output after filtering the contigs and selecting the desired columns for the filtered contigs

Contig	Length	ACC_NUCCORE	Length_NUCCORE	Description_NUCCORE	Topology_NUCCORE
1	53802	NC_013130.1	53786	Borreliella burgdorferi N40 plasmid N40_lp54	linear
2	37615	NC_017396.1	30019	Borreliella burgdorferi JD1 plasmid JD1 cp32-12	circular
3	30657	NC_019005.1	30641	Borreliella burgdorferi 297 plasmid 297_cp32-6	circular
4	30339	NC_018991.1	27035	Borreliella burgdorferi 297 plasmid 297_lp38	linear
5	30301	NC_018984.1	30301	Borreliella burgdorferi 297 plasmid 297_cp32-4	circular
6	29489	NC_017416.1	29424	Borreliella burgdorferi N40 plasmid N40_lp28-4	linear
7	28352	NZ_CP031402.1	26768	Borreliella burgdorferi strain MM1 plasmid plsm_lp28-3	linear
8	26743	NC_018989.1	20974	Borreliella burgdorferi 297 plasmid 297_lp28-5	linear
9	26521	NC_018983.1	26514	Borreliella burgdorferi 297 plasmid 297_cp26	circular
10	24627	NC_017409.1	22827	Borreliella burgdorferi JD1 plasmid JD1 lp25	linear

Telomeric end extension, trimming, and circularization of plasmid contigs

Timing: ∼2 days

Timing: 5 h (step 26)

Timing: 24 h (step 27)

This major step explains the curation of complete circular plasmids and extends the pipeline for assembling the complete linear plasmids.

Most of the existing plasmid assemblers are designed for circular plasmids. However, Borrelia species carry linear plasmids which have atypical hairpin telomeres. Plassembler uses Unicycler,¹⁹ a short read first assembler to assemble the circular plasmids. Unicycler also performs an in-built circularity test. However, it does not perform any completeness analysis for the linear plasmids.

In our study, even though Plassembler assembled the contigs of the linear plasmids, in most cases it could not assemble complete telomere-to-telomere linear plasmids. To tackle this challenge, we developed a plasmid completion and validation method customized for Borrelia genome. We incorporated “Telomere End Extension” to completely assemble the hairpin telomeres of the linear plasmids (Figure 6).

• 26.
  Perform the complete assembly of the circular plasmids.

  Note:Unicycler detects terminal overlaps of each contig, verifies the overlaps and circularizes the contig by trimming one end.¹⁹ However, it might fail to identify a terminal overlap if the long read coverage is lower than the default threshold at the junction. Moreover, high sequence similarity in distant region of the contig might also complicate the circularization process. Since Borrelia plasmids are heterogeneous and can show high sequence similarity, long read coverage can be uneven. As a result, using only the Unicycler pipeline might miss some plasmids. In that case, careful investigation and trimming is recommended. Below are the steps we followed to verify the circularization of plasmid contigs.

  • a.
    Identify the contigs that Unicycler already trimmed and circularized by finding the note “circular = true” in the header of the circular_plasmid_contigs.fasta file.
  • b.
    Use BLAST¹¹ alignment to identify the terminal overlaps when the contigs do not have “circular = true” in the header but are larger than the reference plasmids.
  • c.
    Use simple_circularise.py, a Python script (https://github.com/Kzra/Simple-Circularise) to trim those contigs.
    >python simple_circularise.py circular_plasmid_contigs.fasta circularized_contigs.fasta -r 10 -min 5000

    Note: Here, the script starts searching with an overlapping repeat size of 10 bp, which increases until the largest possible repeat is found. Set the minimum output size to be 5000 because the smallest known Borrelia plasmid is ∼5 kb in size. The output circularized_contigs.fasta have trimmed plasmid contigs and an output will be generated informing the repeat sizes and positions in the working directory.

  • d.
    Confirm the trimming by investigating the trimmed contigs using BLAST alignment by creating a self-identity dot plot.

    Note: The alignment and the dot plot can be created at the (https://blast.ncbi.nlm.nih.gov/Blast.cgi). Below is an example dot plot of a circular plasmid contig before and after trimming (Figure 7).

    Note: We report the contigs that were not circularized following the pipeline as partial assemblies.

• 27.
  Assemble complete linear plasmids with hairpin telomeres.

  Note: For linear plasmids, hairpin telomeres are identified by terminal inverse duplications. The duplicated regions need to be trimmed precisely to have a complete linear plasmid assembly. Below is the step-by-step procedure to perform trimming of linear plasmid contigs.

  • a.
    Identify the terminal inverse duplication in linear plasmid contigs.

    • i.
      To identify the terminal inverted repeats in the linear_plasmid_contigs.fasta using IRF,¹⁰ first, go to https://tandem.bu.edu/irf/home
    • ii.
      Select “Submit a Sequence”, then select “Basic” and upload the file. It will generate a HTML report with all the positions of the identified inverted repeats. If inverse duplications are present in a contig, go to the trimming step (step 27c). If inverse duplications for both telomeres are not detected in a contig, go to the telomeric end extension step (Figure 6).
  • b.
    Perform telomeric end extension.

    • i.
      Extract the telomeric reads by first aligning the filtered ONT reads to the assembled linear_plasmid_contigs.fasta using minimap2.⁵
    • ii.
      Convert the alignment output to a BAM file and create an index BAI file in the same directory using SAMtools.⁴
    • iii.
      Extract the ONT reads that are mapped to the first and last 5 kb of each linear plasmid contig from the alignment output using SeqKit,¹³ BEDtools,¹² and SAMtools⁴ and using a BED file with the contig header and the read extraction positions for each contig.

      Note: Below is an example of the BED file where the first column is the contig header in the linear_plasmid_contigs.fasta file, the second and the third columns are the positions to extract the mapped reads. The example regions.bed file is for the plasmid contig lp17.

      lp17 0  5000
      lp17 16000 21000

      #!/bin/bash

      # Loading minimap2 and samtools

      module load minimap2

      module load samtools

      # Running alignment using the nanopore reads

      minimap2 -a linear_plasmid_contigs.fasta bb_ont_filtered.fastq > ONT_mapped_to_linear_plasmid.sam

      # Processing alignment output

      for file in ∗.sam; do samtools view -bS $file|samtools view -h -F 0x900 -|samtools sort -o ${file%.bam}.sorted.bam - && samtools index ${file%.bam}.sorted.bam;done

      # Create a new directory named telomeric_end_reads

      mkdir telomeric_end_reads

      # Filter the alignments only for the reads mapped to the plasmid telomeres

      samtools view -b ∗.bam | bedtools intersect -a - -b regions.bed > ends_mapped_reads.bam

      # Create the index file for the filtered BAM

      samtools index ends_mapped_reads.bam

      # For each plasmid separate the left and right telomeric reads and save them in two different FASTA files in the telomeric_end_reads directory

      # For lp17 extracting the reads mapped to the first 5 kb region

      samtools view -b ends_mapped_reads.bam lp17:0-5000 | samtools fasta - > telomeric_end_reads/lp17_left_end_mapped_ONT_reads.fasta

      # For lp17 extracting the reads mapped to the last 5 kb region

      samtools view -b ends_mapped_reads.bam lp17:16000-21000 | samtools fasta - > telomeric_end_reads/lp17_right_end_mapped_ONT_reads.fasta
    • iv.
      Filter telomeric reads and assemble them using Flye.⁸

      Note: The code above will generate two FASTA files named lp17_left_end_mapped_ONT_reads.fasta and lp17_right_end_mapped_ONT_reads.fasta. To make the assembly process faster and efficient, filter the telomeric reads using seqtk (https://github.com/lh3/seqtk). To capture the hairpin inverse duplication at the 5 kb telomeric ends, keep the reads that are at least 6 kb in length. After that, perform assembly for each telomeric end separately using Flye.⁸Troubleshooting 4.

      #!/bin/bash

      # Loading seqtk and flye

      module load seqtk

      module load flye

      # Creating a new directory for the filtered reads

      mkdir filtered_reads

      # Filtering the telomeric ONT reads >= 6 kb

      for file in ∗.fasta;do seqtk seq -L 6000 $file > filtered_reads/filtered-$file;done

      # Checking the number of reads after filtering

      for file in filtered_reads/∗.fasta;do grep -c ">" $file;done

      # Running assembly

      # Creating a new directory inside filtered_reads for assembly output

      mkdir ./filtered_reads/flye_output

      # Directory containing the input FASTA files

      input_dir="./filtered_reads"

      output_base_dir="./filtered_reads/flye_output"

      # Process each FASTA file in the input directory

      for fasta_file in "$input_dir"/∗.fasta; do

        # Extract the base name of the file

        base_name=$(basename "$fasta_file".fasta)

        # Create a unique output directory for this file

        output_dir="$output_base_dir/$base_name"

        mkdir -p "$output_dir"

        # Run Flye on the input FASTA file

        flye -t 6 --nano-raw "$fasta_file" --genome-size 0.05m --out-dir "$output_dir"

      done

      echo "Processing completed."

      Note: The commands above will create two new directories with the output generated by Flye⁸ inside the flye_output directory. For each plasmid contig, one directory will be for the left end, and the other one will be for the right end assembly output. Flye will generate an assembly.fasta inside each of these directories. Save the assembly.fasta for the left telomeric end as contig_L_end.fasta and for the right end as contig_R_end.fasta.

    • v.
      Merge the linear plasmid contigs using a BLAST based method.

      Note: For each linear plasmid type, now there are three contigs, one larger initial contig generated by Plassembler, and the two others comparatively smaller telomeric left end and right end contigs. To merge these three contigs and form a single final contig, use a BLAST based method (Figure 8).

    • vi.
      In a directory named “linear_plasmid_telomere_extension”, create separate directories for each plasmid type where the name of the subdirectories will start with the extension contig_number.
    • vii.
      Inside these subdirectories, save the assembled telomeric end contigs for each plasmid type as contig_L_end.fasta and contig_R_end.fasta.
    • viii.
      Save the initial plasmid contig generated by Plassembler which starts with the extension of the strain name (for our case the strains started as bb1-9) in the same directory with the two telomeric end contigs.
    • ix.
      Use a Python script, merging_contigs_blast.py and a BASH script, batch_merge_contigs.sh to call the Python script and run it as a loop for all plasmid types in the directory.
    • x.
      From a terminal window, open the merging_contigs_blast.py and the batch_merge_contigs.sh scripts. Make both scripts executable. After, run the batch_merge_contigs.sh script. This will create a merged contig named merged_contig.fasta for each plasmid type within the corresponding directory.

      Note: Both scripts can be copied and saved using a text editor such as vim or nano.

      import os

      import sys

      import subprocess

      import pandas as pd

      from Bio import SeqIO

      from Bio.Seq import Seq

      def create_blast_db(reference_file):

       print(f“Creating BLAST database for {reference_file}”)

       db_command = [

        “makeblastdb”,

        “-in”, reference_file,

        “-dbtype”, “nucl”

       ]

       subprocess.run(db_command, check=True)

      def run_blast(query_file, db_file, output_file):

       print(f“Running BLAST: query={query_file}, db={db_file}, output={output_file}”)

       blast_command = [

        “blastn”,

        “-query”, query_file,

        “-db”, db_file,

        “-out”, output_file,

        “-outfmt”, “10 qseqid sseqid pident length mismatch gapopen qstart qend sstart send evalue bitscore qlen slen sstrand”

       ]

       subprocess.run(blast_command, check=True)

      def parse_blast_output(blast_output_file, is_small_contig1):

       print(f“Parsing BLAST output: {blast_output_file}”)

       df = pd.read_csv(blast_output_file, header=None)

       df.columns = [“qseqid”, “sseqid”, “pident”, “length”, “mismatch”, “gapopen”,

          “qstart”, “qend”, “sstart”, “send”, “evalue”, “bitscore”, “qlen”, “slen”, “sstrand”]

       if is_small_contig1:

       # For small_contig1 (Left_end_blast.csv)

       plus_strand = df[df[“sstrand”] == “plus”]

       if plus_strand.empty:

        raise ValueError(f“No 'plus' strand alignment found in {blast_output_file}”)

       candidate = plus_strand[plus_strand[“sstart”] == 1]

       if candidate.empty:

        raise ValueError(f“No suitable alignment found in {blast_output_file} for small_contig1”)

       overlap_start = candidate[“qstart”].iloc[0]

       overlap_end = candidate[“qend”].iloc[0]

       else:

        # For small_contig2 (Right_end_blast.csv), use the existing logic

        plus_strand = df[df[“sstrand”] == “plus”]

        if plus_strand.empty:

         raise ValueError(f“No 'plus' strand alignment found in {blast_output_file}”)

        candidate = plus_strand[plus_strand[“send”] == plus_strand[“slen”]]

        if candidate.empty:

         raise ValueError(f“No suitable alignment found where subject end equals subject length in {blast_output_file}”)

        overlap_start = candidate[“qstart”].iloc[0]

        overlap_end = candidate[“qend”].iloc[0]

       print(f“Determined overlap start: {overlap_start}, end: {overlap_end}”)

       return overlap_start, overlap_end
      d

      ef merge_contigs(large_contig, small_contig_1, small_contig_2, output_dir):

       print(f“Merging contigs for: {large_contig}, {small_contig_1}, {small_contig_2}”)

       # Create output directory if it doesn't exist

       os.makedirs(output_dir, exist_ok=True)

       left_blast_output = os.path.join(output_dir, “Left_end_blast.csv”)

       right_blast_output = os.path.join(output_dir, “Right_end_blast.csv”)

       # Create BLAST database for the large contig

       create_blast_db(large_contig)

       # Run BLAST for both small contigs against the large contig

       run_blast(small_contig_1, large_contig, left_blast_output)

       run_blast(small_contig_2, large_contig, right_blast_output)

       # Parse BLAST output to get overlap coordinates

       overlap_start_1, overlap_end_1 = parse_blast_output(left_blast_output, is_small_contig1=True)

       overlap_start_2, overlap_end_2 = parse_blast_output(right_blast_output, is_small_contig1=False)

       # Read sequences

       print(“Reading sequences...”)

       large_seq = SeqIO.read(large_contig, “fasta”).seq

       small_seq_1 = SeqIO.read(small_contig_1, “fasta”).seq

       small_seq_2 = SeqIO.read(small_contig_2, “fasta”).seq

       print(“Constructing merged sequence...”)

       # Construct the merged sequence

       merged_seq = small_seq_1[:overlap_start_1] + large_seq + small_seq_2[overlap_end_2:]

       # Create a new SeqRecord

       merged_record = SeqIO.SeqRecord(Seq(merged_seq), id=“merged_contig”, description=“Merged contig”)

       # Write to file

       output_file = os.path.join(output_dir, “merged_contig.fasta”)

       SeqIO.write(merged_record, output_file, “fasta”)

       print(f”Written merged sequence to {output_file}”)

      if __name__ == “__main__”:

       # Expecting command-line arguments: large_contig, small_contig_1, small_contig_2, output_dir

       if len(sys.argv) != 5:

        print(“Usage: python merge_contigs_blast_modified.py <large_contig> <small_contig_1> <small_contig_2> <output_dir>”)

        sys.exit(1)

       large_contig = sys.argv[1]

       small_contig_1 = sys.argv[2]

       small_contig_2 = sys.argv[3]

       output_dir = sys.argv[4]

       # Call merge_contigs function with provided arguments

       merge_contigs(large_contig, small_contig_1, small_contig_2, output_dir)
      batch_merge_contigs.sh

      #!/bin/bash

      # Iterate over directories matching contig∗

      for dir in ./contig∗/; do

       if [ -d “$dir” ]; then

        echo “Processing directory: $dir”

        # Find large contig (bb∗), small contig 1 (∗_L_end.fasta), and small contig 2 (∗_R_end.fasta)

        large_contig=$(find “$dir” -maxdepth 1 -type f -name “bb∗.fasta” | head -n 1)

        small_contig_1=$(find “$dir” -maxdepth 1 -type f -name “∗_L_end.fasta” | head -n 1)

        small_contig_2=$(find “$dir” -maxdepth 1 -type f -name “∗_R_end.fasta” | head -n 1)

        if [ -z “$large_contig” ] || [ -z “$small_contig_1” ] || [ -z “$small_contig_2” ]; then

         echo "Error: Required files not found in directory $dir. Skipping..."

          continue

        fi

        # Determine output directory

        output_dir="${dir}/merging_of_contigs"

        # Run Python script with contig set

        echo "Running merge_contigs for:"

        echo "Large contig: $large_contig"

        echo "Small contig 1: $small_contig_1"

        echo "Small contig 2: $small_contig_2"

        echo "Output directory: $output_dir"

        echo ""

        python merging_contigs_blast.py "$large_contig" "$small_contig_1" "$small_contig_2" "$output_dir"

        echo ""

       fi

      done

      Note: Below is the structure of the directories explained above for one strain bb8 as an example.

      linear_plasmid_telomere_extension
      ├── contig_12_lp17
      │ ├── bb8_contig_12_lp17.fasta
      │ ├── contig12_L_end.fasta
      │ ├── contig12_R_end.fasta
      │ ├── merged_contig.fasta
      ├── contig_1_lp54
      │ ├── bb8_contig_1_lp54.fasta
      │ ├── contig1_L_end.fasta
      │ ├── contig1_R_end.fasta
      ├── merging_contigs_blast.py
      ├── batch_merge_contigs.sh

      # Saving the scripts

      vim merging_contigs_blast.py

      vim batch_merge_contigs.sh

      # Making the scripts executable

      chmod +x merging_contigs_blast.py batch_merge_contigs.sh

      # Running the scripts

      ./batch_merge_contigs.sh

      Note: If no significant overlapping sequences are detected between the plasmid contig and at least one of the telomeric end contigs, merging will fail. In that case, a detail error message will be printed in the terminal indicating the plasmid type for which the merging process failed. Consider these plasmids as partial.

  • c.
    Trim the linear plasmids.

    • i.
      After generating the merged contigs for each plasmid type, concatenate the merged contigs in a single FASTA file named all_merged_linear_plasmids.fasta.
    • ii.
      Then, go back to step a) to identify the terminal inverse duplication using IRF.¹⁰
    • iii.
      Add the identified inverted repeat positions in the trimming_position.txt file followed by a trimming using the Python script trimming_based_on_inversion_position.py (from step 24 d, e).

      CRITICAL: Since Borrelia linear plasmids usually have complex repeat patterns and homologous sequences throughout the plasmids, sometimes repeats being present in the middle of the contigs, we recommend looking at the inversion positions identified by the IRF carefully before including them in the trimming_position.txt file. Even though this manual intervention takes time, especially because it needs to be done for each plasmid type separately and if there are multiple strains, it might take even longer, we recommend following this step to ensure accuracy in the trimming process.

      Note: Sometimes contigs might not have a perfect inversion, where the two inverted repeats are spaced by some extra bases in the middle. Investigating the inversion positions manually will help identify such cases and help take informed decisions regarding the accurate inversion positions. Thus, we recommend following the steps below before trimming the contigs.

    • iv.
      First, investigate the repeat structure of a reference plasmid before approaching the trimming step for the corresponding plasmid type. A self-identity dot plot using the nucleotide BLAST pairwise alignment method can be used for this purpose (Figure 9A).
    • v.
      Generate a self-identity dot plot of the initial plasmid contig (Figure 9B). Compare it with the reference to validate the assembly accuracy by comparing the repeat structure and contig length.
    • vi.
      Generate a self-identity dot plot of the merged plasmid contig (Figure 9C). By comparing it with the reference, identify the approximate trimming positions of the corresponding plasmid contig (Figure 9C, indicated by red box).
    • vii.
      Once you have the approximate inversion positions for the merged contig, confirm and identify the exact positions from the IRF output.

      Note:IRF gives the start and end positions of the left and right repeat indices. To get the full-length linear plasmid without the duplicated regions on each end (Figure 9D), select the trimming range as, end position of the left telomeric end to the start position of the right telomeric end. Below is an example output of the IRF.

      Left indices	Length	Right indices	Length	Loop	Percent Matches
      4589--14588	10000	14591--24574	9984	2	99.40
      37962--44134	6173	44137--50303	6167	2	99.90

      Note: Here, the inversion positions for the left and right telomeric ends are in bold. Selecting the inversion positions this way will ensure keeping the extra bases in the middle of the loop within the trimmed contig. In this example, the two bases (14589-14590) on the left end and the two bases on the right end (44135-44136) are part of the trimmed plasmid lp28-4.
  • d.
    Validate the trimmed plasmid contigs. Troubleshooting 5.

    • i.
      After generating the trimmed contigs for both circular and linear plasmids, combine all plasmid contigs with the linear chromosome contig of the corresponding strain and create a combined FASTA file bb_chromosome_plasmids.fa for the complete genome.
    • ii.
      Align ONT reads to the complete genome using Minimap2.⁵
    • iii.
      Convert the alignment output SAM file to BAM file, sort the BAM file and create an index file for the corresponding BAM file using SAMtools⁴ (use script from 27 b).
    • iv.
      After that, load the genome file and the BAM file to IGV to visualize the ONT coverage across the linear chromosome and plasmids.

      Note: A uniform ONT coverage throughout the genome will validate the accuracy of the assembly and trimming, whereas skewed and missing coverage will indicate possible mis-assembly.

    • v.
      Remove any spurious contig from the genome file before performing downstream analysis.

Figure 6.

Trimming and circularization pipeline of linear and circular plasmids

The blue boxes represent the steps unique for the circular plasmids, and the orange boxes represent the steps unique for the linear plasmids. The green box represents the “Telomeric end extension” step which is also specific to the linear plasmids. The grey boxes represent the steps common to all plasmids. Name of the tools were italicized to distinguish from file names. Reprinted and adapted with permission from Amin et al.¹

Figure 7.

Trimming and circularization of circular plasmids based on the terminal direct duplications

The dot plots represent the contig of a circular plasmid cp32-12 before and after trimming of the terminal direct duplications.

Figure 8.

Telomeric end extension of the linear plasmids

Schematic representation of the step “Telomeric end extension” showing (A) the merging of the three contigs and (B) then trimming of the hairpin telomeres of the merged contig to obtain (C) a final linear plasmid contig. Grey lines represent the original contig generated by Plassembler, and the orange lines represent the telomeric contigs assembled by Flye. Trimmed regions are indicated by the dashed lines.

Figure 9.

Assembly and trimming approach of linear plasmids

Dot plots showing (A) the reference linear plasmid; (B and C) the linear plasmid contigs before and after merging, and (D) the contig after trimming the terminal inverse duplication of the merged contig to generate a final complete linear plasmid assembly. Here, the example shows the assembly process of a linear plasmid where the lp28-4 from the reference strain B31 was used as a reference to explain the trimming approach. The red box in panel (C) represents the region of the merged contig without inverse duplications.

Annotation and quantitative validation of the assembled genomes

Timing: 5 h (step 28)

Timing: 15–19 h (step 29)

This major step explains the annotation of the complete linear chromosome, linear plasmids, and circular plasmids, and the steps for the quantitative validation of the final assemblies.

• 28.
  Annotate the assembled genome. After compiling the linear chromosomes with the assembled plasmids, perform annotation using Bakta.⁷

  • a.
    Download an annotation database before running Bakta.
  • b.
    Use the file bb_chromosome_plasmids.fa for running annotation.

    Note: It will generate several output files such as an annotation.gbff which is the annotated genome in GenBank format, a annotation.tsv file which is a tab-separated annotation table, and an annotation.json file with annotation details in JSON format.

     >bakta_db download --output bakta_db --type light
     >bakta -v --db bakta_db --output bb_annotation --genus Borreliella --species     burgdorferi --force --compliant --threads 16 bb_chromosome_plasmids.fa
• 29.Quantitative validation of final assemblies
  After assembling and annotating the genomes, validate the assembly accuracy following the steps below.

  • a.
    Compare final assembly length and GC content against the B31 reference (NC_001318.1) which is 910,724 bp and 28.6% respectively.

    Note: Mean CDS length should increase progressively from Trycycler consensus through Medaka and Medaka + Polypolish, reflecting systematic reduction of indel errors at each polishing stage (Table 2). Compare the remaining assembly metrics among the assembled strains to validate consistency of annotation completeness across strains.

  • b.
    Remap Illumina reads using BWA-MEM2 and ONT reads using Minimap2 to all final assemblies and visualize in IGV.

    Note: Illumina and ONT coverage should be uniform with no significant gaps. For representative coverage plots across all nine strains assembled in this study, see Amin et al., Figure S4¹

  • c.
    Inspect ONT read coverage specifically at both telomeric ends in IGV.

    Note: Coverage as low as 12x at telomeric ends is sufficient provided reads physically span the hairpin wraparound. For a representative alignment visualization of ONT reads spanning hairpin telomeres at both ends of a linear plasmid, see Figure 6A.¹

  • d.
    Generate self-identity dot plots of all consensus assemblies and confirm terminal inverse duplications at both ends of all linear replicons.

    Note: Check the difference of assembly length before and after trimming (Table 2). For representative dot plots of chromosomes across all nine strains, see Amin et al., Figure S3.¹

  • e.
    Compare recovered plasmid types against reference strain profiles.

    Note: For plasmid type assignments and complement comparison across nine strains assembled using this protocol, see Table 1.¹ For novel fusion plasmids, PCR-based validation of assembly junctions can be performed, see Figure 6E.¹

Table 2.

Assembly and annotation summary metrics for assembly validation

Strain	Assembly length		Mean CDS length (aa) in polishing stages			Final annotation (medaka + polypolish)
	Length before trimming (bp)	Final length after trimming (bp)	Consensus contig (aa)	Medaka (aa)	Medaka + polypolish (aa)	CDS	Pseudo- genes	Hypothetical proteins	tRNAs	rRNAs	GC (%)
Bb16 122	931948	910513	325	339	346	812	0	13	33	5	29
Bb16 131	932974	902779	321	337	343	811	2	13	33	5	29
Bb16 133	918585	902780	322	339	344	811	1	13	33	5	29
Bb16 134	924988	902780	322	333	345	811	1	13	33	5	29
Bb16 22	925188	910197	319	334	344	816	0	15	32	5	29
Bb16 33	933264	903010	316	339	347	810	0	13	32	5	29
Bb16 49	930171	910024	317	339	344	813	0	14	32	5	29
Bb16 47	926277	910705	319	337	346	814	0	15	32	5	29
Bb16 57	919254	907757	323	342	344	812	0	13	32	5	29

Coding Sequences (CDS), Pseudogenes, Hypothetical protein counts, tRNAs, rRNAs and GC content are from the Bakta annotation of the Medaka + Polypolish polished assembly. Mean CDS Length is extracted from the Bakta annotation output at each polishing stage. Adapted with permission from Amin et al.¹

Expected outcomes

Standard long read assemblers (e.g., Flye, Canu) produce chromosomal assemblies 13–66 kb longer than the true sequence due to unresolved hairpin telomere junctions, and generate fragmented, anonymous non-chromosomal contigs without confirmed replicon identity or topology (Table 3). This pipeline addresses both limitations through dedicated telomere reconstruction (Steps 26–27) and Plassembler-based chromosome-subtraction plasmid assembly (Steps 25–27), yielding individually named, topology-confirmed, and telomere-resolved replicons for each strain.

Table 3.

Assembly comparison between Flye, Canu, and the current pipeline for five representative Borrelia burgdorferi strains

Assembly comparison: Chromosome
Strain	Chromosome assembly length (bp)					Hairpin telomere reconstructed
	Current pipeline	Flye	Flye excess (bp)	Canu	Canu excess (bp)	Current pipeline	Flye	Canu
Bb16 122	910513	948810	38297	914179	3666	Yes	No	No
Bb16 131	902779	968601	65822	915048	12269	Yes	No	No
Bb16 134	902780	947871	45091	913034	10254	Yes	No	No
Bb16 33	903010	944619	41609	918201	15191	Yes	No	No
Bb16 47	910705	923976	13271	924334	13629	Yes	No	No

Assembly comparison: Plasmids
Strain	Current pipeline			Flye			Canu
	Plasmids assembled	Topology assigned	Telomere reconstructed	Other contigs (size range 500 bp to 100 kb)	Topology assigned (circ=Y)	Telomere reconstructed	Other contigs (size range 1kb to 707 kb)	Topology assigned (suggestCircular=yes)	Telomere reconstructed
Bb16 122	13	All	Yes	24	2	No	15	4	No
Bb16 131	11	All	Yes	14	4	No	11	0	No
Bb16 134	14	All	Yes	30	3	No	15	5	No
Bb16 33	10	All	Yes	45	2	No	15	3	No
Bb16 47	12	All	Yes	23	2	No	17	2	No

Plasmid topology assignment represents confident assignment of circularity or linearity.

This hybrid genome assembly pipeline is designed to achieve a complete and high-quality telomere-to-telomere genome assembly of Borrelia burgdorferi, including both linear and circular replicons. By integrating Illumina short reads with ONT long reads, the pipeline aims to provide accurate assembly of the linear chromosome and plasmids, including resolving the challenging hairpin telomeres. We used this pipeline to assemble nine B. burgdorferi strains and identified an average of 21 kb of telomeric end inverse duplication in the linear chromosome contigs of all strains.¹ This pipeline can be used for complete genome assembly of other Borrelia species.

For plasmid assembly, the pipeline leverages Plassembler to accurately assemble both high and low copy number plasmids by separating chromosomal and plasmid reads. This allows effective resolution of even low copy number plasmids that might be overlooked by traditional assemblers. The pipeline also incorporates a trimming and circularization step to ensure that circular plasmids are assembled to completion. For linear plasmids, a dedicated telomeric end extension step is used to capture and assemble the hairpin telomeres, which are typically difficult to resolve due to their inverted repeat structure. Using this ensemble plasmid assembly pipeline, we assembled between 10 to 15 plasmids including the smallest plasmid lp5 (∼5 kb) in each of the nine B. burgdorferi strains with higher confidence and accuracy (Table 1¹).

The final output is expected to be a complete genome assembly with linear and circular plasmids and enhanced telomere resolution, which will be used as a reference genome for Borrelia burgdorferi. The high-quality assembly is expected to support downstream comparative genomic analysis, evolutionary studies, and the identification of strain-specific genetic variations, contributing valuable insights into the genomic diversity of Borrelia species.

Limitations

The proposed pipeline still requires significant amount of manual intervention during the trimming process of hairpin telomeres and plasmid curation. However, this is necessary to ensure the accuracy of the assembly. We used Trycycler to generate a consensus assembly which is a multi-step process and requires substantial computational resources. Recently, the developer of Trycycler released an automated version of this assembler called Autocycler (https://github.com/rrwick/Autocycler) to facilitate the automation of the multi-step assembly process. Readers may consider using Autocycler to reduce manual effort. An updated version of Plassembler (v1.5.0) provides options to add an already existing Flye assembly as an input. Users might want to use that version if only plasmid sequences are available and no chromosomal assembly is required.

This pipeline does not include a detailed discussion of the genome quality assessment, which can be performed using Quast (https://github.com/ablab/quast) following the manual provided on this website (http://quast.sf.net). Additionally, the telomere trimming step of the linear chromosome relied on the known telomeric end motifs of B. burgdorferi reference strain B31, which might not be available for other bacterial species with linear replicons. In such cases, we recommend using the “Telomeric End Extension” step for the linear chromosomes and linear plasmids to ensure completeness of the hairpin telomeres.

Troubleshooting

Problem 1

Trycycler fails to generate a single representative cluster for the linear chromosome (step 22c).

Potential solution

This issue can occur when ONT read quality is low, coverage is uneven, or when highly repetitive regions cause fragmentation across assemblies. First, verify that the N50 and read length distribution of the filtered ONT reads are sufficient (>20 kb recommended). If multiple chromosome-sized contigs appear across clusters, manually inspect cluster membership and select the cluster containing contigs closest to the expected chromosome length. Reducing the number of subsampled read sets or excluding assemblies with clear misassemblies may also improve clustering. Alternatively, users may consider using Autocycler as an automated alternative to Trycycler.

Problem 2

No valid alignments are identified at the linear chromosome telomeric ends for the left and right conserved telomeric sequences (step 24 c).

Potential solution

Conserved Borrelia telomeric sequences can diverge significantly between strains due to accumulation of SNPs within the telomeric motifs. In our companion study (Figure 1B¹), strain Bb16 57 showed only 56% identity with the B31 reference telomeric sequence, which falls below the effective detection threshold of standard blastn and will return no significant hits.

If similar situation arises and the alignments are not identified using the blastn algorithm, try the discontinuous megablast algorithm. If neither algorithm returns hits due to extensive sequence divergence (as observed for strain Bb16 57¹), proceed to trimming using the IRF-identified inversion position (Step 27a, c), then align the B31 reference telomeric sequence against the trimmed chromosome ends to identify strain-specific mismatches.

Problem 3

Ortholog reference plasmid is not identified for a filtered plasmid contig (step 25 c).

Potential solution

If there is a novel plasmid or fusion plasmid in the assembled strain, Plassembler might fail to provide a reference ortholog and the plasmid topology. In that case, separate this contig and further investigate it to confirm the assembly validation and topology using step 26–28.

Problem 4

Flye assembly of telomeric ends fails (step 27 b iv).

Potential solution

Flye recommends a minimum read coverage of 20X to perform assembly of a small bacterial genome. Therefore, if there are not enough coverage after filtering ONT reads based on the length threshold (>= 6 kb), the assembly might fail. To solve this, make sure to have enough reads after filtering the ONT reads based on read length. If there are not enough reads, we recommend lowering the filtering threshold.

Problem 5

Merged linear plasmid contigs show uneven ONT read coverage or coverage dropouts after telomeric end extension (step 27d).

Potential solution

Uneven coverage may indicate incorrect contig merging, misidentified overlap regions, or incomplete telomeric extension. Load the merged contig and the ONT BAM file into IGV and inspect coverage continuity across the entire plasmid, particularly at junctions between the Plassembler contig and telomeric extension contigs. If coverage gaps or abrupt coverage changes are observed, re-evaluate the BLAST overlap coordinates used for merging and confirm strand orientation of the telomeric contigs. In some cases, lowering the minimum read-length threshold during telomeric read filtering can increase coverage and improve assembly continuity.

Resource availability

Lead contact

Further information and requests for resources and reagents should be directed to and will be fulfilled by the lead contact, David Langlais (david.langlais@mcgill.ca).

Technical contact

Further enquiries about the technical details should be directed to and will be fulfilled by the technical contact, Atia B. Amin (atia.amin@mail.mcgill.ca).

Materials availability

This study did not generate new unique reagents.

Data and code availability

The accession number for the complete genome assemblies reported in this paper is BioProject: PRJNA1293716. The raw sequencing data are available as SRA on NCBI BioProject: PRJNA1293716. The custom scripts and codes used for genome assembly and comparative genomics analyses are also publicly accessible on GitHub at https://doi.org/10.5281/zenodo.17969496.

Acknowledgments

We thank Public Health Agency of Canada for generously providing the Bb strains and the McGill Genome Center for sequencing services. A.B.A is supported by a Vanier Canada Graduate Scholarship. This work was supported by a McGill Interdisciplinary Initiative in Infection and Immunity (MI4) program grant. D.L. is also supported by a Fonds de la Recherche Québec-Santé (FRQ-S) Chercheur-Boursier Junior 2 Award (348782). C.F.P. is the holder of the Canada Research Chair in Parasitology and One Health (grant no. CRC-2024-00026).

Author contributions

A.B.A., C.F.P., and D.L. designed the study. A.B.A. and A.V.I.-M. performed the experiments, analyzed the data, and prepared the first draft of the manuscript. A.B.A., M.B., and D.L. contributed to the development of the analysis pipeline. C.F.P., M.B., and D.L. supervised the work. All authors have read and approved the content of this manuscript.

Declaration of interests

The authors declare no competing interests.