alterlab-biopython skill
✓ VerifiedManipulate biological sequences, parse bioinformatics file formats, access NCBI databases, and perform structural or phylogenetic analysis.
- GitHub stars
- 86
- Files
- 9
- Last commit
- Nov 11, 2026
- License
- MIT
- Allowed tools
- 5
What does the alterlab-biopython skill do?
alterlab-biopython is an agent skill. Manipulate biological sequences, parse bioinformatics file formats, access NCBI databases, and perform structural or phylogenetic analysis.
Summary generated from the skill's SKILL.md.
About the alterlab-biopython skill
Researchers and bioinformaticians can automate complex molecular biology workflows by using this skill to manipulate biological sequences and parse diverse file formats like FASTA, GenBank, and PDB. It provides a programmatic interface for accessing NCBI databases through Entrez, running BLAST searches, and performing structural or phylogenetic analysis. An agent should load this skill when tasked with scripting custom bioinformatics pipelines, batch-processing sequence files, or calculating sequence statistics such as GC content and molecular weight.
The skill operates using Biopython 1.88 and relies on Python 3.10 through 3.14. It utilizes tools like Bio.SeqIO for file I/O, Bio.PDB for 3D protein structure navigation, and Bio.Phylo for tree manipulation. While it can fetch records from PubMed and GenBank, users must provide a contact email for NCBI access, and an optional API key can increase the request rate from 3 to 10 per second. It is specifically designed for computational biology tasks that require deep sequence or structural manipulation rather than simple one-off lookups.
What an agent can do with it
- 1Convert biological file formatsTransform a GenBank file into a FASTA format for easier sequence reading.
- 2Search NCBI databasesProgrammatically search PubMed for specific research topics and retrieve results.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the alterlab-biopython skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the alterlab-biopython skill in Plugin
/plugin marketplace add AlterLab-IEU/AlterLab-Academic-Skills /plugin install alterlab-bioinformatics@alterlab-academic-skills
Install the alterlab-biopython skill in Claude Code
~/.claude/skills/alterlab-biopython/SKILL.md
$ npx degit AlterLab-IEU/AlterLab-Academic-Skills/skills/bioinformatics/alterlab-biopython ~/.claude/skills/alterlab-biopythonInstall the alterlab-biopython skill in Claude Code (project)
.claude/skills/alterlab-biopython/SKILL.md
$ npx degit AlterLab-IEU/AlterLab-Academic-Skills/skills/bioinformatics/alterlab-biopython .claude/skills/alterlab-biopythonInstall the alterlab-biopython skill in Codex
~/.agents/skills/alterlab-biopython/SKILL.md
$ npx degit AlterLab-IEU/AlterLab-Academic-Skills/skills/bioinformatics/alterlab-biopython ~/.agents/skills/alterlab-biopythonInstall the alterlab-biopython skill in Gemini CLI
~/.gemini/skills/alterlab-biopython/SKILL.md
$ npx degit AlterLab-IEU/AlterLab-Academic-Skills/skills/bioinformatics/alterlab-biopython ~/.gemini/skills/alterlab-biopythonInstall the alterlab-biopython skill in Claude.ai
npx degit AlterLab-IEU/AlterLab-Academic-Skills/skills/bioinformatics/alterlab-biopython alterlab-biopython && zip -r alterlab-biopython.zip alterlab-biopython # claude.ai → Customize → Skills → + → Create skill → Upload a skill → alterlab-biopython.zip
Automated checks
Ran Nov 15, 2026Full report →Passed our automated checks. That is not a security audit: read the scripts before you let an agent run them. How checks work
- Source repository linked and reachablealterlab-ieu/alterlab-academic-skills/skills/bioinformatics/alterlab-biopython is public and reachablegithub.com/alterlab-ieu/alterlab-academic-skills/tree/HEAD/s ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit 2026-11-11github.com/alterlab-ieu/alterlab-academic-skills/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/alterlab-ieu/alterlab-academic-skills/blob/HEAD/s ↗Pass
- Pre-approved tools are scopedPre-approved: Read, Write, Edit, Bash(python:*), Bash(uv:*)github.com/alterlab-ieu/alterlab-academic-skills/blob/HEAD/s ↗Pass
- SKILL.md follows the Agent Skills formatValid name and description; says when to use it; 483 linesgithub.com/alterlab-ieu/alterlab-academic-skills/blob/HEAD/s ↗Pass
SKILL.md
View on GitHubBiopython: 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.88 (August 2026), which supports Python 3.10–3.14 and requires NumPy.
Removed / changed APIs to watch for
- Command-line wrappers are gone.
Bio.Applicationand everything built on it —Bio.Blast.Applications(Ncbiblastn/p/x…Commandline,NcbimakeblastdbCommandline) andBio.Align.Applications(ClustalOmegaCommandline,MuscleCommandline) — were deprecated in 1.78 and removed in 1.86. Call the executables throughsubprocess(seereferences/blast.mdandreferences/alignment.md).- PairwiseAligner gap scores changed in 1.86. The default gap score is now -1 (was 0), so an aligner left at defaults returns far fewer, non-degenerate alignments. The gap attributes were also renamed to insertion/deletion forms (
open_internal_insertion_score, …); the*_gap_scorenames still work as meta-attributes. Thealphabetattribute is deprecated and unused.Bio.pairwise2is deprecated — useBio.Align.PairwiseAligner.Bio.Blast.NCBIXMLis declared obsolete as of the 1.89 development line in favour of theBio.Blastparser added in 1.84 (Blast.parse/Blast.read,Blast.qblast). It still ships and works in 1.88; prefer the new API for new code.- Security fixes worth upgrading for: 1.87 fixed CVE-2025-68463 in
Bio.Entrez.Parser, and 1.88 removed anevalin theBio.Nexusparser that allowed code execution from a malicious NEXUS file. Treat downloaded records as untrusted input and keep Biopython current.
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
Does NOT Trigger
| Scenario | Use Instead |
|---|---|
Running local BLAST+ / makeblastdb from the command line, or DIAMOND |
alterlab-blast |
| A one-line lookup of a gene, sequence, or structure | alterlab-gget |
| One call across many web services (UniProt + KEGG + ChEMBL in a pipeline) | alterlab-bioservices |
| SAM/BAM/CRAM record access, pileups, and read filtering | alterlab-pysam |
| Building an ML phylogeny from unaligned sequences (MAFFT + IQ-TREE) | alterlab-phylogenetics |
Hand-off rule. When the request matches a row above, open your answer by naming that skill by its exact id (for example alterlab-blast) and saying in one line why it fits better, then stop applying this skill's procedure. Name it even when you also need to ask for missing input. If only part of the request is out of scope, name the skill for that part and do only the in-scope part. A brief general pointer is fine; the named skill does the work.
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 Biopython (requires Python 3 and NumPy). On this machine, prefer running scripts with uv run:
# Ad-hoc: run a script with Biopython available, no venv to manage
uv run --with biopython script.py
# Or add it to a project
uv add biopython
For NCBI database access, always set your email address (required by NCBI):
from Bio import Entrez
Entrez.email = "your.email@example.com"
# Optional: API key for higher rate limits (10 req/s instead of 3 req/s)
Entrez.api_key = "your_api_key_here"
Using This Skill
This skill provides comprehensive documentation organized by functionality area. When working on a task, consult the relevant reference documentation:
1. Sequence Handling (Bio.Seq & Bio.SeqIO)
Reference: references/sequence_io.md
Use for:
- Creating and manipulating biological sequences
- Reading and writing sequence files (FASTA, GenBank, FASTQ, etc.)
- Converting between file formats
- Extracting sequences from large files
- Sequence translation, transcription, and reverse complement
- Working with SeqRecord objects
Quick example:
from Bio import SeqIO
# Read sequences from FASTA file
for record in SeqIO.parse("sequences.fasta", "fasta"):
print(f"{record.id}: {len(record.seq)} bp")
# Convert GenBank to FASTA
SeqIO.convert("input.gb", "genbank", "output.fasta", "fasta")
2. Alignment Analysis (Bio.Align & Bio.AlignIO)
Reference: references/alignment.md
Use for:
- Pairwise sequence alignment (global and local)
- Reading and writing multiple sequence alignments
- Using substitution matrices (BLOSUM, PAM)
- Calculating alignment statistics
- Customizing alignment parameters
Quick example:
from Bio import Align
# Pairwise alignment
aligner = Align.PairwiseAligner()
aligner.mode = 'global'
alignments = aligner.align("ACCGGT", "ACGGT")
print(alignments[0])
3. Database Access (Bio.Entrez)
Reference: references/databases.md
Use for:
- Searching NCBI databases (PubMed, GenBank, Protein, Gene, etc.)
- Downloading sequences and records
- Fetching publication information
- Finding related records across databases
- Batch downloading with proper rate limiting
Quick example:
from Bio import Entrez
Entrez.email = "your.email@example.com"
# Search PubMed
handle = Entrez.esearch(db="pubmed", term="biopython", retmax=10)
results = Entrez.read(handle)
handle.close()
print(f"Found {results['Count']} results")
4. BLAST Operations (Bio.Blast)
Reference: references/blast.md
Use for:
- Running BLAST searches via NCBI web services
- Running local BLAST searches
- Parsing BLAST XML output
- Filtering results by E-value or identity
- Extracting hit sequences
Quick example (the Bio.Blast API introduced in 1.84 — NCBI requires a contact email):
from Bio import Blast
Blast.email = "your.email@example.com"
result_stream = Blast.qblast("blastn", "nt", "ATCGATCGATCG")
blast_record = Blast.read(result_stream)
# Each hit's alignments are Bio.Align objects; scores live in .annotations
for hit in blast_record[:5]:
print(f"{hit.target.id}: E-value={hit[0].annotations['evalue']}")
5. Structural Bioinformatics (Bio.PDB)
Reference: references/structure.md
Use for:
- Parsing PDB and mmCIF structure files
- Navigating protein structure hierarchy (SMCRA: Structure/Model/Chain/Residue/Atom)
- Calculating distances, angles, and dihedrals
- Secondary structure assignment (DSSP)
- Structure superimposition and RMSD calculation
- Extracting sequences from structures
Quick example:
from Bio.PDB import PDBParser
# Parse structure
parser = PDBParser(QUIET=True)
structure = parser.get_structure("1crn", "1crn.pdb")
# Calculate distance between alpha carbons
chain = structure[0]["A"]
distance = chain[10]["CA"] - chain[20]["CA"]
print(f"Distance: {distance:.2f} Å")
6. Phylogenetics (Bio.Phylo)
Reference: references/phylogenetics.md
Use for:
- Reading and writing phylogenetic trees (Newick, NEXUS, phyloXML)
- Building trees from distance matrices or alignments
- Tree manipulation (pruning, rerooting, ladderizing)
- Calculating phylogenetic distances
- Creating consensus trees
- Visualizing trees
Quick example:
from Bio import Phylo
# Read and visualize tree
tree = Phylo.read("tree.nwk", "newick")
Phylo.draw_ascii(tree)
# Calculate distance
distance = tree.distance("Species_A", "Species_B")
print(f"Distance: {distance:.3f}")
7. Advanced Features
Reference: references/advanced.md
Use for:
- Sequence motifs (Bio.motifs) - Finding and analyzing motif patterns
- Population genetics (Bio.PopGen) - GenePop files, Fst calculations, Hardy-Weinberg tests
- Sequence utilities (Bio.SeqUtils) - GC content, melting temperature, molecular weight, protein analysis
- Restriction analysis (Bio.Restriction) - Finding restriction enzyme sites
- Clustering (Bio.Cluster) - K-means and hierarchical clustering
- Genome diagrams (GenomeDiagram) - Visualizing genomic features
Quick example:
from Bio.SeqUtils import gc_fraction, molecular_weight
from Bio.Seq import Seq
seq = Seq("ATCGATCGATCG")
print(f"GC content: {gc_fraction(seq):.2%}")
print(f"Molecular weight: {molecular_weight(seq, seq_type='DNA'):.2f} g/mol")
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
grep -n "SeqIO.parse" references/sequence_io.md
# Find examples of specific tasks
grep -n "BLAST" references/blast.md
# Find information about specific concepts
grep -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 Seq -
Set Entrez email when using NCBI databases
Entrez.email = "your.email@example.com" -
Use 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 time -
Handle errors gracefully - Network operations and file parsing can fail
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 import Blast, Entrez, SeqIO
Entrez.email = Blast.email = "your.email@example.com"
# Run BLAST (Bio.Blast API, Biopython >= 1.84)
result_stream = Blast.qblast("blastn", "nt", sequence)
blast_record = Blast.read(result_stream)
# Get top hit accessions (hit.target is a SeqRecord)
accessions = [hit.target.name for hit in blast_record[: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 and proper delays
- 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.
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
- Mailing List: biopython@biopython.org
Quick Reference
To locate information in reference files, use these search patterns:
# Search for specific functions
grep -n "function_name" references/*.md
# Find examples of specific tasks
grep -n "example" references/sequence_io.md
# Find all occurrences of a module
grep -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.
Part of the AlterLab Academic Skills suite.
Files in this skill
9alterlab-biopython skill questions
How do I install the alterlab-biopython skill in Claude Code?
Run npx degit AlterLab-IEU/AlterLab-Academic-Skills/skills/bioinformatics/alterlab-biopython ~/.claude/skills/alterlab-biopython. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the alterlab-biopython skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.