Documentation

Installation

Get started with BioQL in seconds using pip:

pip install bioql

Requirements

• Python 3.8 or higher
• Qiskit 1.3.0+ (automatically installed)
• NumPy, Matplotlib (dependencies handled)

pip install bioql[vina,viz,quantum_chemistry]

Quick Start

bioql_test_8a3f9d2c1e5b4f7a9c2d6e1f8b3a5c7d

Your first quantum drug discovery computation in 3 lines:

from bioql import quantum

# Example 1: Molecular Docking
result = quantum(
    "dock aspirin to COX-1 receptor",
    backend='ionq_simulator',
    api_key='bioql_test_8a3f9d2c1e5b4f7a9c2d6e1f8b3a5c7d',
    shots=4096
)

print(f"Binding Energy: {result.binding_energy} kcal/mol")

# Example 2: Create Quantum Entanglement
result = quantum(
    "create a bell state with two qubits and measure both",
    backend='ionq_simulator',
    api_key='bioql_test_8a3f9d2c1e5b4f7a9c2d6e1f8b3a5c7d',
    shots=1000
)

# Example 3: Drug Simulation with VQE
result = quantum(
    "simulate aspirin molecule using variational quantum eigensolver "
    "with 4 qubits to find ground state energy",
    backend='ionq_simulator',
    api_key='bioql_test_8a3f9d2c1e5b4f7a9c2d6e1f8b3a5c7d',
    shots=2048
)

What Just Happened?

1. Natural Language Parsing: Your request was analyzed using 164B+ patterns and converted to a quantum circuit
2. Algorithm Selection: BioQL automatically chose VQE for molecular simulation
3. Quantum Execution: Circuit ran on IonQ simulator with error mitigation
4. Results Returned: Binding energy, affinity metrics, and quantum advantage calculated

30-Second Demo

Run this one-liner to test BioQL:

pip install bioql && python -c "from bioql import quantum; print(quantum('create bell state', backend='ionq_simulator', api_key='bioql_test_8a3f9d2c1e5b4f7a9c2d6e1f8b3a5c7d'))"

Authentication

BioQL uses API keys for authentication. Get yours at the pricing page.

Using Environment Variables

# .env file
BIOQL_API_KEY=bioql_your_api_key_here
IBM_QUANTUM_TOKEN=your_ibm_token_here
IONQ_API_KEY=your_ionq_key_here

from bioql import quantum
import os

result = quantum(
    "predict ADME properties for ibuprofen",
    backend='ibm_quantum',
    api_key=os.getenv('BIOQL_API_KEY')
)

Natural Language Interface

BioQL understands over 164 billion natural language patterns across drug discovery, quantum chemistry, and bioinformatics. No quantum gates knowledge required!

"dock aspirin to COX-1"
"dock ligand SMILES CC(=O)OC... to protein PDB 1PTK"
"bind ibuprofen to cyclooxygenase"
"calculate binding affinity"

"predict ADME properties for ibuprofen"
"calculate bioavailability and half-life"
"analyze toxicity of compound"
"optimize drug-target interaction"

"simulate water molecule using VQE"
"calculate dipole moment with 4 qubits"
"find ground state energy of H2"
"compute bond angles and lengths"

"design CRISPR guide for ATCGATCG"
"optimize guide RNA with minimal off-targets"
"predict editing efficiency"
"analyze PAM sequence compatibility"

"create bell state with 2 qubits"
"apply grover search on 3 qubits"
"run QAOA optimization"
"implement quantum fourier transform"

"fold protein sequence MKLLVLCL"
"predict protein stability"
"analyze protein-ligand interaction"
"calculate binding free energy"

Drug Discovery Pipeline

Complete workflow from molecular docking to toxicity prediction:

from bioql import run_complete_pipeline

results = run_complete_pipeline(
    molecule_smiles="CC(=O)OC1=CC=CC=C1C(=O)O",
    target_protein_pdb="cox1.pdb",
    backend='simulator',
    api_key='your_api_key'
)

# Results include:
print(f"1. Docking Score: {results.docking.best_energy}")
print(f"2. Binding Affinity Kd: {results.affinity.kd} nM")
print(f"3. ADME Bioavailability: {results.adme.bioavailability}%")
print(f"4. Toxicity Risk: {results.toxicity.overall_risk}")
print(f"5. Drug-likeness: {results.lipinski_compliant}")

VSCode/Cursor Agent

Interactive AI agent extension for Visual Studio Code and Cursor that generates quantum code with automatic visualizations and error correction.

Key Features

Installation

# Step 1: Download the VSIX file above (📥 Download Extension button)

# Step 2: Install via command line
code --install-extension bioql-assistant-7.0.0.vsix

# Or via Command Palette in VS Code/Cursor:
# 1. Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows/Linux)
# 2. Type: "Extensions: Install from VSIX"
# 3. Select the downloaded bioql-assistant-7.0.0.vsix file

Configuration

// settings.json
{
  "bioql.apiKey": "your_bioql_api_key",
  "bioql.defaultBackend": "simulator",
  "bioql.enableQEC": false,
  "bioql.enableVisualizations": true,
  "bioql.defaultShots": 1000
}

Usage Examples

# Generate code with keyboard shortcut
# Cmd+Shift+G (Mac) / Ctrl+Shift+G (Windows)

# Chat interface
@bioql create a bell state with surface code QEC
@bioql dock metformin to AMPK with 4096 shots
@bioql optimize this quantum circuit for AWS Braket
@bioql explain this VQE implementation

# Commands
# - BioQL: Generate Code (Cmd+Shift+G)
# - BioQL: Fix Code (Cmd+Shift+F)
# - BioQL: Explain Code
# - BioQL: Run on Quantum Computer

Examples

Proteomics Module

Quantum-enhanced protein sequence analysis, post-translational modification prediction, and protein structure characterization.

Protein Sequence Analysis

from bioql.omics import ProteomicsCircuit

circuit = ProteomicsCircuit(
    backend='ibm_quantum',
    api_key='your_api_key'
)

# Analyze protein sequence
result = circuit.analyze_protein_sequence(
    sequence="MKLLVLCLAAALARPKHPIKHQGLPQEVLNENLLRFFVAPFPEVFGK",
    analysis_type="comprehensive",
    shots=4096
)

print(f"Molecular Weight: {result.molecular_weight} Da")
print(f"Isoelectric Point: {result.isoelectric_point}")
print(f"Hydrophobicity Score: {result.hydrophobicity}")
print(f"Secondary Structure: {result.secondary_structure}")

Post-Translational Modification Prediction

Predict phosphorylation, acetylation, methylation, and ubiquitination sites using quantum machine learning.

from bioql.omics import ProteomicsCircuit

circuit = ProteomicsCircuit(backend='ionq')

# Predict PTM sites
ptm_result = circuit.predict_ptm_sites(
    sequence="MKLLVLCLAAALARPKHPIKHQGLPQEVLNENLLRFFVAPFPEVFGK",
    modification_types=['phosphorylation', 'acetylation', 'methylation'],
    confidence_threshold=0.75
)

for site in ptm_result.predicted_sites:
    print(f"Position {site.position}: {site.modification_type}")
    print(f"  Confidence: {site.confidence:.2f}")
    print(f"  Residue: {site.residue}")

Metabolomics Module

Quantum algorithms for metabolite identification, pathway analysis, and metabolic flux prediction.

Metabolite Identification

from bioql.omics import MetabolomicsCircuit

circuit = MetabolomicsCircuit(
    backend='ibm_quantum',
    api_key='your_api_key'
)

# Identify metabolite from mass spectrum
result = circuit.identify_metabolite(
    mass_spectrum={
        'peaks': [180.063, 342.116, 504.169],
        'intensities': [100, 85, 45]
    },
    ionization_mode='positive',
    database='hmdb',
    shots=4096
)

print(f"Top Match: {result.top_match.name}")
print(f"HMDB ID: {result.top_match.hmdb_id}")
print(f"Match Score: {result.top_match.score:.3f}")
print(f"Formula: {result.top_match.molecular_formula}")

Metabolic Pathway Analysis

Analyze metabolic pathways and predict flux distributions using quantum optimization.

from bioql.omics import MetabolomicsCircuit

circuit = MetabolomicsCircuit(backend='simulator')

# Analyze metabolic pathway
pathway_result = circuit.analyze_metabolic_pathway(
    pathway_id='glycolysis',
    metabolite_concentrations={
        'glucose': 5.0,
        'pyruvate': 0.8,
        'lactate': 1.2
    },
    conditions={'pH': 7.4, 'temperature': 37}
)

print(f"Pathway Flux: {pathway_result.total_flux} mmol/L/h")
print(f"Rate-Limiting Step: {pathway_result.bottleneck_reaction}")
print(f"Pathway Efficiency: {pathway_result.efficiency:.2%}")

for enzyme in pathway_result.enzyme_activities:
    print(f"  {enzyme.name}: {enzyme.activity} U/mL")

Multi-Omics Integration

Integrate genomics, transcriptomics, proteomics, and metabolomics data for comprehensive biological insights using quantum algorithms.

Multi-Layer Omics Integration

from bioql.omics import MultiOmicsIntegrator

integrator = MultiOmicsIntegrator(
    backend='ibm_quantum',
    api_key='your_api_key'
)

# Integrate multiple omics layers
result = integrator.integrate_omics_layers(
    genomics_data={
        'variants': ['rs123456', 'rs789012'],
        'copy_number': {'EGFR': 3.2, 'TP53': 1.0}
    },
    transcriptomics_data={
        'gene_expression': {'EGFR': 8.5, 'TP53': 6.2}
    },
    proteomics_data={
        'protein_abundance': {'EGFR': 12.3, 'TP53': 5.8}
    },
    metabolomics_data={
        'metabolites': {'glucose': 5.0, 'lactate': 2.1}
    },
    integration_method='quantum_correlation',
    shots=8192
)

print(f"Integration Score: {result.integration_score:.3f}")
print(f"Key Correlations:")
for corr in result.correlations:
    print(f"  {corr.layer1} - {corr.layer2}: r={corr.coefficient:.3f}")

print(f"\nPathway Enrichment:")
for pathway in result.enriched_pathways:
    print(f"  {pathway.name}: p={pathway.p_value:.2e}")

Network Analysis

Build multi-omics interaction networks using quantum graph algorithms.

from bioql.omics import MultiOmicsIntegrator

integrator = MultiOmicsIntegrator(backend='simulator')

# Build interaction network
network = integrator.build_interaction_network(
    omics_data=result,
    network_type='correlation',
    threshold=0.7
)

print(f"Network Nodes: {network.num_nodes}")
print(f"Network Edges: {network.num_edges}")
print(f"Hub Genes: {network.hub_nodes}")
print(f"Communities Detected: {len(network.communities)}")

Advanced Genomics

Quantum algorithms for variant calling, RNA-seq analysis, and genome-wide association studies.

Variant Calling

from bioql.omics import GenomicsCircuit

circuit = GenomicsCircuit(
    backend='ibm_quantum',
    api_key='your_api_key'
)

# Call variants from sequencing data
variants = circuit.call_variants(
    bam_file='sample_aligned.bam',
    reference_genome='hg38',
    min_quality=30,
    min_depth=10,
    shots=4096
)

print(f"Total Variants Called: {len(variants.variants)}")
print(f"SNPs: {variants.num_snps}")
print(f"Indels: {variants.num_indels}")

for variant in variants.high_impact_variants:
    print(f"  {variant.chromosome}:{variant.position}")
    print(f"    {variant.ref} -> {variant.alt}")
    print(f"    Impact: {variant.impact_prediction}")

RNA-Seq Differential Expression

Quantum machine learning for differential gene expression analysis.

from bioql.omics import GenomicsCircuit

circuit = GenomicsCircuit(backend='ionq')

# Analyze RNA-seq data
rna_result = circuit.analyze_rna_seq(
    counts_matrix='gene_counts.csv',
    sample_groups={
        'control': ['S1', 'S2', 'S3'],
        'treatment': ['S4', 'S5', 'S6']
    },
    normalization='tmm',
    fdr_threshold=0.05
)

print(f"Differentially Expressed Genes: {len(rna_result.deg_list)}")
print(f"Upregulated: {rna_result.num_upregulated}")
print(f"Downregulated: {rna_result.num_downregulated}")

print(f"\nTop Upregulated Genes:")
for gene in rna_result.top_upregulated(5):
    print(f"  {gene.name}: log2FC={gene.log2fc:.2f}, padj={gene.padj:.2e}")

Changelog

v6.0.0 (Current - October 2025)

• 🎉 NEW: Multi-Omics Platform with 4 new modules
• 🧪 NEW: Proteomics module with PTM prediction
• 🔬 NEW: Metabolomics module with pathway analysis
• 🧬 NEW: Multi-Omics integration with quantum correlation
• 📊 NEW: Advanced genomics with variant calling and RNA-seq
• ✅ Enhanced quantum network analysis algorithms
• ✅ Integration with HMDB, KEGG, and MetaCyc databases
• ✅ Cross-omics pathway enrichment analysis

v5.7.5 (October 2025)

• ✅ Complete drug discovery pipeline with 7 modules
• ✅ De novo drug design module for novel molecule generation
• ✅ CRISPR-QAI module for gene editing optimization
• ✅ IBM Quantum Torino (133 qubits) support
• ✅ Advanced error mitigation (ZNE, PEC)
• ✅ 21 CFR Part 11 compliance logging
• ✅ Real Vina docking integration

v5.6.0 (September 2025)

• Added bioisosteric replacement database (12+ replacements)
• Similarity search across ChEMBL and PubChem
• Off-target screening panel (30+ proteins)
• Resistance profiling for mutations

View complete changelog →