biopython
Provides Biopython (Bio.Seq, Bio.SeqIO, Bio.Align, Bio.Entrez, Bio.Blast, Bio.PDB, Bio.Phylo, Bio.motifs, Bio.SeqUtils, Bio.Restriction) for sequence handling, file parsing, NCBI access, BLAST, structures, and phylogenetic trees in Python. Reads, writes, and converts FASTA, GenBank, FASTQ, PDB, mmCIF, Newick, and NEXUS files. Use when manipulating or translating DNA, RNA, or protein sequences, converting sequence file formats, fetching records from NCBI via Entrez, running or parsing BLAST searches, doing pairwise or multiple sequence alignment, analyzing PDB structures, or building and editing phylogenetic trees. For quick lookups use gget; for multi-service integration use bioservices.
Install this skill
Works with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, and 70+ other harnesses.
npx skills add KalarisLabs/research-agent-skills --skill biopythonuvx research-agent-skills install biopythonDocumentation & Instructions
Biopython: Computational Molecular Biology in Python
Overview
Biopython is a comprehensive set of freely available Python tools for biological computation. It provides functionality for sequence manipulation, file I/O, database access, structural bioinformatics, phylogenetics, and many other bioinformatics tasks. The current version is Biopython 1.87 (released 30 March 2026). It supports Python 3.10-3.14 and PyPy3.10, and requires NumPy. Biopython 1.87 also addresses CVE-2025-68463 in Bio.Entrez.Parser when parsing untrusted files, so prefer 1.87+ for workflows that parse externally supplied Entrez XML.
When to Use This Skill
Use this skill when:
- Working with biological sequences (DNA, RNA, or protein)
- Reading, writing, or converting biological file formats (FASTA, GenBank, FASTQ, PDB, mmCIF, etc.)
- Accessing NCBI databases (GenBank, PubMed, Protein, Gene, etc.) via Entrez
- Running BLAST searches or parsing BLAST results
- Performing sequence alignments (pairwise or multiple sequence alignments)
- Analyzing protein structures from PDB files
- Creating, manipulating, or visualizing phylogenetic trees
- Finding sequence motifs or analyzing motif patterns
- Calculating sequence statistics (GC content, molecular weight, melting temperature, etc.)
- Performing structural bioinformatics tasks
- Working with population genetics data
- Any other computational molecular biology task
Core Capabilities
Biopython is organized into modular sub-packages, each addressing specific bioinformatics domains:
- Sequence Handling - Bio.Seq and Bio.SeqIO for sequence manipulation and file I/O
- Alignment Analysis - Bio.Align and Bio.AlignIO for pairwise and multiple sequence alignments
- Database Access - Bio.Entrez for programmatic access to NCBI databases
- BLAST Operations - Bio.Blast for running and parsing BLAST searches
- Structural Bioinformatics - Bio.PDB for working with 3D protein structures
- Phylogenetics - Bio.Phylo for phylogenetic tree manipulation and visualization
- Advanced Features - Motifs, population genetics, sequence utilities, and more
Installation and Setup
Install the current stable Biopython release with an explicit version pin for reproducibility:
uv pip install "biopython==1.87"
For NCBI database access, always set your email address (required by NCBI). For reusable software, set a stable Entrez.tool value and register the tool/email with NCBI. For higher rate limits (10 req/s instead of 3 req/s), read only NCBI_API_KEY from the environment — do not hardcode keys or load unrelated environment variables:
import os
from Bio import Entrez
Entrez.email = "your.email@example.com" # required — use your real email
Entrez.tool = "your_tool_name" # optional but recommended for reusable software
# Optional: register at https://www.ncbi.nlm.nih.gov/account/settings/
if api_key := os.environ.get("NCBI_API_KEY"):
Entrez.api_key = api_key
Using This Skill
Details, code examples and parameter tables: references/using-this-skill.md. Read it when this step applies.
General Workflow Guidelines
Reading Documentation
When a user asks about a specific Biopython task:
- Identify the relevant module based on the task description
- Read the appropriate reference file using the Read tool
- Extract relevant code patterns and adapt them to the user's specific needs
- Combine multiple modules when the task requires it
Example search patterns for reference files:
# Find information about specific functions
rg -n "SeqIO.parse" references/sequence_io.md
# Find examples of specific tasks
rg -n "BLAST" references/blast.md
# Find information about specific concepts
rg -n "alignment" references/alignment.md
Writing Biopython Code
Follow these principles when writing Biopython code:
Import modules explicitly
from Bio import SeqIO, Entrez from Bio.Seq import SeqSet Entrez email when using NCBI databases; load only
NCBI_API_KEYfrom the environment if presentimport os from Bio import Entrez Entrez.email = "your.email@example.com" Entrez.tool = "your_tool_name" if api_key := os.environ.get("NCBI_API_KEY"): Entrez.api_key = api_keyUse appropriate file formats - Check which format best suits the task
# Common formats: "fasta", "genbank", "fastq", "clustal", "phylip"Handle files properly - Close handles after use or use context managers
with open("file.fasta") as handle: records = SeqIO.parse(handle, "fasta")Use iterators for large files - Avoid loading everything into memory
for record in SeqIO.parse("large_file.fasta", "fasta"): # Process one record at a timeHandle errors gracefully - Network operations and file parsing can fail
from urllib.error import HTTPError try: handle = Entrez.efetch(db="nucleotide", id=accession) except HTTPError as e: print(f"Error: {e}")
Common Patterns
Pattern 1: Fetch Sequence from GenBank
from Bio import Entrez, SeqIO
Entrez.email = "your.email@example.com"
# Fetch sequence
handle = Entrez.efetch(db="nucleotide", id="EU490707", rettype="gb", retmode="text")
record = SeqIO.read(handle, "genbank")
handle.close()
print(f"Description: {record.description}")
print(f"Sequence length: {len(record.seq)}")
Pattern 2: Sequence Analysis Pipeline
from Bio import SeqIO
from Bio.SeqUtils import gc_fraction
for record in SeqIO.parse("sequences.fasta", "fasta"):
# Calculate statistics
gc = gc_fraction(record.seq)
length = len(record.seq)
# Find ORFs, translate, etc.
protein = record.seq.translate()
print(f"{record.id}: {length} bp, GC={gc:.2%}")
Pattern 3: BLAST and Fetch Top Hits
from Bio.Blast import NCBIWWW, NCBIXML
from Bio import Entrez, SeqIO
Entrez.email = "your.email@example.com"
# Run BLAST
result_handle = NCBIWWW.qblast("blastn", "nt", sequence)
blast_record = NCBIXML.read(result_handle)
# Get top hit accessions
accessions = [aln.accession for aln in blast_record.alignments[:5]]
# Fetch sequences
for acc in accessions:
handle = Entrez.efetch(db="nucleotide", id=acc, rettype="fasta", retmode="text")
record = SeqIO.read(handle, "fasta")
handle.close()
print(f">{record.description}")
Pattern 4: Build Phylogenetic Tree from Sequences
from Bio import AlignIO, Phylo
from Bio.Phylo.TreeConstruction import DistanceCalculator, DistanceTreeConstructor
# Read alignment
alignment = AlignIO.read("alignment.fasta", "fasta")
# Calculate distances
calculator = DistanceCalculator("identity")
dm = calculator.get_distance(alignment)
# Build tree
constructor = DistanceTreeConstructor()
tree = constructor.nj(dm)
# Visualize
Phylo.draw_ascii(tree)
Best Practices
- Always read relevant reference documentation before writing code
- Use grep to search reference files for specific functions or examples
- Validate file formats before parsing
- Handle missing data gracefully - Not all records have all fields
- Cache downloaded data - Don't repeatedly download the same sequences
- Respect NCBI rate limits - Use API keys, registered tool/email values for reusable software, and Entrez history/batching for large jobs
- Test with small datasets before processing large files
- Keep Biopython updated to get latest features and bug fixes
- Use appropriate genetic code tables for translation
- Document analysis parameters for reproducibility
Troubleshooting Common Issues
Issue: "No handlers could be found for logger 'Bio.Entrez'"
Solution: This is just a warning. Set Entrez.email to suppress it.
Issue: "HTTP Error 400" from NCBI
Solution: Check that IDs/accessions are valid and properly formatted.
Issue: "ValueError: EOF" when parsing files
Solution: Verify file format matches the specified format string.
Issue: Alignment fails with "sequences are not the same length"
Solution: Ensure sequences are aligned before using AlignIO or MultipleSeqAlignment.
Issue: BLAST searches are slow
Solution: Use local BLAST for large-scale searches, or cache results.
Issue: PDB parser warnings
Solution: Use PDBParser(QUIET=True) to suppress warnings, or investigate structure quality.
Issue: ImportError for Bio.HMM, Bio.MarkovModel, or Bio.Application
Solution: These modules were removed in Biopython 1.86. Use hmmlearn for HMMs and the standard library subprocess module instead of Bio.Application CLI wrappers.
Issue: PairwiseAligner returns fewer alignments after upgrading to 1.86+
Solution: The default gap score changed from 0 to -1 in 1.86, eliminating trivial tie alignments. Set aligner.gap_score = 0 to restore the old behavior if needed (see references/alignment.md).
Additional Resources
- Official Documentation: https://biopython.org/docs/latest/
- Tutorial: https://biopython.org/docs/latest/Tutorial/
- Cookbook: https://biopython.org/docs/latest/Tutorial/ (advanced examples)
- GitHub: https://github.com/biopython/biopython
- Release notes: https://github.com/biopython/biopython/blob/master/NEWS.rst
- Deprecated APIs: https://github.com/biopython/biopython/blob/master/DEPRECATED.rst
- Mailing List: biopython@biopython.org
Quick Reference
To locate information in reference files, use these search patterns:
# Search for specific functions
rg -n "function_name" references/*.md
# Find examples of specific tasks
rg -n "example" references/sequence_io.md
# Find all occurrences of a module
rg -n "Bio.Seq" references/*.md
Summary
Biopython provides comprehensive tools for computational molecular biology. When using this skill:
- Identify the task domain (sequences, alignments, databases, BLAST, structures, phylogenetics, or advanced)
- Consult the appropriate reference file in the
references/directory - Adapt code examples to the specific use case
- Combine multiple modules when needed for complex workflows
- Follow best practices for file handling, error checking, and data management
The modular reference documentation ensures detailed, searchable information for every major Biopython capability.
Agent operating procedure
- Check the environment. Confirm tool versions, the reference genome/annotation build and the input formats (FASTQ, BAM, VCF, h5ad).
- Pin down the inputs. Confirm formats, identifiers and parameters from the data or the user. Ask rather than guess any value that changes the result.
- Run a small version first. Run the pipeline on a small subset (one sample, one chromosome, a few thousand cells) first.
- Execute the full task using the instructions and references above.
- Validate the result. Check QC metrics, sample identities, genome build consistency and batch effects before interpreting results.
- Report. State what was run (versions, commands, parameters), what was checked, and what is still uncertain.
| If this happens | Do this |
|---|---|
| Genome builds or identifiers do not match between inputs | Stop and harmonize (liftover, ID mapping) before continuing. |
| A function, flag or endpoint in these instructions is missing in the installed version | Check the installed version's own documentation (help(), --help, official docs), adapt, and tell the user. Never invent an API. |
| A required input, identifier or parameter is ambiguous | Ask the user, or state the assumption explicitly before running. |
Integrity rules
- Never fabricate results, parameters, identifiers, citations or statistics. If something cannot be run or verified, say so plainly.
- Do not interpret biological significance beyond what the statistics support; report multiple-testing correction.
- Treat version-specific details here as possibly outdated: confirm them against the official documentation for the installed version.
- Ask before actions that cost money, consume shared GPUs or cloud quota, touch personal or patient data, or cannot be undone.
Related skills
scikit-bio: Python library scikit-bio for biological sequence and community-ecology analysis: DNA/RNA/protein sequences, pair_align alignment, phylogen…gget: Queries 20+ bioinformatics databases and analysis services through the gget CLI and Python package, covering Ensembl gene search, info and…etetoolkit: Analyze, manipulate, compare, annotate, and visualize phylogenetic or other hierarchical trees with ETE 4.
Trigger Prompts & Evaluation Corpus
These evaluation prompts test that the agent correctly selects biopython for relevant tasks and leaves it out for near misses.
Should trigger (3)
- should trigger
“How do I reverse-complement a DNA string and translate it in Python?”
expects Uses Bio.Seq: Seq(...).reverse_complement() and .translate(), mentions choosing the right frame and genetic code table (e.g., table=11 for bacteria) and to_stop handling. Provides a short runnable snippet.
- should trigger
“I have a GenBank file called plasmid_pUC19.gb and need a FASTA of just the CDS translations for each annotated gene, plus a GFF-free list of locus_tags. I'm getting 'ValueError: Sequence content is undefined' on some features when I call feature.extract(record.seq). What's going on and how do I fix it?”
expects Uses Bio.SeqIO.parse(..., 'genbank') and iterates record.features of type CDS, using feature.extract(record.seq) and translate, or the /translation qualifier. Explains that the error arises when the record has no sequence (e.g., a sequence-less/CON or contig-style record), so the sequence must be fetched or the qualifier translation used. Writes output with SeqIO.write in fasta format and collects locus_tag qualifiers, handling missing qualifiers.
- should trigger
“I've got about 40 accession numbers for the cytochrome b gene from different mammals. I want to pull them from NCBI, line them up, and draw a tree showing how the species relate to each other, all in one Python script.”
expects Builds a pipeline with Bio.Entrez (email set, optional NCBI_API_KEY from env, efetch in batches, rate limits respected), parses with SeqIO, performs a multiple alignment with an external tool (e.g., MUSCLE/MAFFT via subprocess, since Bio.Application was removed), reads it with AlignIO, computes distances with Bio.Phylo.TreeConstruction (DistanceCalculator and DistanceTreeConstructor NJ/UPGMA), and draws or saves the tree. Starts on a small subset and states assumptions and versions.
Near misses (2)
- near miss
“I have 16S rRNA amplicon data and need to compute Faith's PD and weighted UniFrac between my samples, then run PERMANOVA on the PCoA ordination by treatment group.”
expects Recognizes this is community-ecology diversity analysis, not Biopython work, and directs to scikit-bio (alpha/beta diversity, UniFrac, PCoA, PERMANOVA) rather than using Biopython.
- near miss
“What's the quickest way to look up the Ensembl ID and protein sequence for human TP53 without writing much code? Just something like a one-liner.”
expects Recommends gget (e.g., gget search / gget seq) for a quick single lookup instead of building Biopython Entrez code, and gives a short gget command or call.