drug-candidate-discovery

name	drug-candidate-discovery
description	Generate diverse druggable molecules for a given target or disease using OpenBioMed's AI-powered drug discovery tools. Use this skill when: (1) Generating drug candidates, molecules, or compounds for a target/disease, (2) Performing structure-based drug design or de novo drug design, (3) Finding or creating molecules that bind to a specific protein target, (4) Discovering potential drugs for a disease name, (5) Designing molecules with specific properties (LogP, QED, docking scores). The skill handles target identification, structure retrieval, molecule generation, and in silico evaluation.
license	MIT
category	drug-discovery
tags	["drug-design","molecule-generation","structure-based-design"]

Drug Candidate Discovery

This skill uses the OpenBioMed repository to generate diverse druggable molecules for a given target or disease. It orchestrates a complete drug discovery workflow from target identification to candidate evaluation.

CRITICAL REQUIREMENTS

You MUST execute code to produce actual outputs. Writing scripts without running them is NOT acceptable.

Required outputs that MUST be created:

1. SDF files containing 3D molecular structures
2. Visualization files (PNG images of molecules and complexes)
3. Comprehensive markdown report

After writing any script, you MUST run it using the Bash tool to generate the actual outputs.

Inputs

The user should provide:

• target_or_disease (required): Name of the target protein or disease (e.g., "BTK", "Alzheimer's disease", "KRAS G12C")
• num_candidates (optional, default=5): Number of desired candidate molecules
• property_constraints (optional): Desired molecular properties as a dictionary:
  • logp_min, logp_max: LogP range (e.g., -1 to 3)
  • qed_min: Minimum QED score (e.g., 0.5)
  • vina_max: Maximum Vina docking score in kcal/mol (e.g., -8)
  • sa_min: Minimum synthetic accessibility score (e.g., 0.5)
• device (optional, default="cuda:0"): GPU device for running models
• model_ckpt (optional, default="./checkpoints/molcraft/last_updated.ckpt"): Path to MolCraft checkpoint
• max_attempts (optional, default=100): Maximum generation/optimization cycles

Workflow Overview

Phase 1: Target Identification & Research

CRITICAL: You MUST search web databases to find PDB structures with bound ligands. Do NOT use hardcoded PDB IDs.

1. Web Search for Target Information

   • Use WebSearch tool to search for: "{target_name} protein drug target UniProt PDB structure"
   • Identify the UniProt ID for the target protein
   • Find known inhibitors/drugs and their PDB co-crystal structures

2. Query UniProt for Protein Metadata

   • Use UniProtRequester tool with the UniProt ID
   • Extract: protein name, gene name, organism, disease associations

3. Find PDB Structures with Ligands

   • Use web search: "{target_name} PDB structure inhibitor ligand co-crystal"
   • Search RCSB PDB API: https://search.rcsb.org/rcsbsearch/v2/query
   • Prioritize structures with:
     • Small molecule ligands (not just ions/waters)
     • High resolution (< 3.0 Å)
     • Known drug/inhibitor complexes

4. Extract UniProt ID from PDB (if starting from PDB)

   • Use PDBRequester with mode="metadata" to get PDB entry info
   • Cross-reference UniProt ID from the structure

Phase 2: Structure Retrieval & Validation

1. Download PDB Structure

   • Use PDBRequester tool with mode="file_only" to download the PDB file
   • Save to ./tmp/{pdb_id}.pdb

2. Extract Protein and Ligands

   • Use ExtractAllMoleculesFromPDB tool on the downloaded PDB file
   • This returns: protein chains, ligands, and ions separately
   • Identify the reference ligand (drug/inhibitor molecule)

3. Validate Binding Site

   • Ensure at least one ligand molecule was extracted
   • If no ligands found, try another PDB structure or notify user

Phase 3: Molecule Generation & Optimization

1. Define Binding Pocket

   • Use Pocket.from_protein_ref_ligand(protein, ligand, radius=10.0)
   • The pocket defines the 3D region for molecule generation

2. Generate Molecules

   • If MolCraft checkpoint available: Use InferencePipeline with task="structure_based_drug_design"
   • Otherwise: Use scaffold-based generation with modifications

3. Evaluate Properties

   • Calculate QED, LogP, SA score using molecule methods
   • Filter candidates meeting property constraints

Phase 4: Results & Reporting

1. Save candidate molecules as SDF files
2. Generate visualizations (2D structures, protein-ligand complexes)
3. Compile comprehensive markdown report with target research
4. VALIDATE that all outputs were created successfully

---

COMPLETE WORKFLOW SCRIPT

IMPORTANT: Write this complete script to a file, then EXECUTE it with the Bash tool.

Create a file drug_discovery_workflow.py in your output directory:

#!/usr/bin/env python
"""
Complete Drug Candidate Discovery Workflow
This script MUST be executed to generate actual outputs.

IMPORTANT: This workflow searches web databases for PDB structures with bound ligands.
It does NOT use hardcoded PDB IDs.
"""

import os
import sys
import json
import requests
from datetime import datetime
from pathlib import Path

# Set up output directory
OUTPUT_DIR = Path(__file__).parent / "outputs"
OUTPUT_DIR.mkdir(exist_ok=True)
(OUTPUT_DIR / "visualizations").mkdir(exist_ok=True)

# Add OpenBioMed to path if needed
WORK_DIR = "/home/luoyz/projects/OpenBioMed/OpenBioMed_dev"
sys.path.insert(0, WORK_DIR)
os.chdir(WORK_DIR)
os.makedirs("./tmp", exist_ok=True)

# Import OpenBioMed tools
from open_biomed.tools.tool_registry import TOOLS
from open_biomed.data import Protein, Molecule, Pocket

# =============================================================================
# CONFIGURATION - Set these based on user input
# =============================================================================
TARGET_NAME = "TARGET_NAME"  # e.g., "BACE1", "BTK", "KRAS G12C"
UNIPROT_ID = None  # Will be discovered via web search
PDB_ID = None  # Will be discovered via web search
NUM_CANDIDATES = 3

# =============================================================================
# PHASE 1: TARGET IDENTIFICATION & RESEARCH
# =============================================================================

 () -> :
    
    ()
    ( * )

    info = {
        : target_name,
        : ,
        : [],
        : [],
        : 
    }

    
    ()
    web_search = TOOLS[]

    search_query = 
    search_results, _ = web_search.run(query=search_query)

    
     re
    uniprot_pattern = 
    uniprot_matches = re.findall(uniprot_pattern, (search_results))
     uniprot_matches:
        info[] = uniprot_matches[]
        ()

    
    ()

    
    pdb_query = {
        : {
            : ,
            : ,
            : [
                {
                    : ,
                    : ,
                    : {
                        : ,
                        : ,
                        : target_name.upper()
                    }
                },
                {
                    : ,
                    : ,
                    : {
                        : ,
                        : ,
                        : 
                    }
                }
            ]
        },
        : ,
        : {
            : {: , : },
            : [{: , : }]
        }
    }

    :
        response = requests.post(
            ,
            json=pdb_query,
            headers={: }
        )
         response.status_code == :
            results = response.json()
             entry  results.get(, [])[:]:
                info[].append(entry.get())
            ()
     Exception  e:
        ()

    
      info[]:
        ()
        pdb_search_query = 
        pdb_results, _ = web_search.run(query=pdb_search_query)

        
        pdb_pattern = 
        pdb_matches = re.findall(pdb_pattern, (pdb_results))
        info[] = ((pdb_matches))[:]
        ()

    
    ()
    inhibitor_query = 
    inhibitor_results, _ = web_search.run(query=inhibitor_query)
    info[] = (inhibitor_results)[:]

     info

 () -> :
    
    ()

    uniprot_requester = TOOLS[]
    protein, _ = uniprot_requester.run(accession=uniprot_id)

    
    :
        response = requests.get()
         response.status_code == :
            data = response.json()
             {
                : data.get(, {}).get(, {}).get(, {}).get(, ),
                : data.get(, [{}])[].get(, {}).get(, ),
                : data.get(, {}).get(, ),
                : data.get(, [{}])[].get(, )  data.get()  ,
                : data.get(, {}).get(, ),
                : protein
            }
     Exception  e:
        ()

     {: protein}





 () -> :
    
    ()

    pdb_requester = TOOLS[]

    
    pdb_file, _ = pdb_requester.run(accession=pdb_id, mode=)
    ()

     pdb_file

 () -> :
    
    ()

    extractor = TOOLS[]
    results, metadata = extractor.run(pdb_file=pdb_file)

    protein = 
    ligands = []

     item_type, chain_id, obj  results:
         item_type ==   protein  :
            protein = obj
            ()
         item_type == :
            ligands.append((chain_id, obj))
            ()

      ligands:
        ()
         protein, 

    
     protein, ligands[][]





 () -> :
    
    ()

    
    pocket = Pocket.from_protein_ref_ligand(protein, ligand, radius=)
    ()

    
    molcraft_ckpt = Path()

     molcraft_ckpt.exists():
        ()
         open_biomed.core.pipeline  InferencePipeline

        pipeline = InferencePipeline(
            task=,
            model=,
            model_ckpt=(molcraft_ckpt),
            device=
        )

        candidates = []
         i  (num_candidates * ):  
            :
                outputs, _ = pipeline.run(pocket=pocket)
                 outputs  outputs[]:
                    candidates.append(outputs[])
             Exception  e:
                ()

         candidates[:num_candidates]
    :
        ()
         generate_from_scaffolds(num_candidates)

 () -> :
    
     rdkit  Chem
     rdkit.Chem  AllChem

    
    scaffolds = [
        ,  
        ,  
        ,  
        ,  
        ,  
    ]

    molecules = []
     i, smiles  (scaffolds[:num_candidates]):
        mol = Chem.MolFromSmiles(smiles)
         mol:
            mol = Chem.AddHs(mol)
            AllChem.EmbedMolecule(mol, randomSeed=i+)
            AllChem.MMFFOptimizeMolecule(mol)
            obm_mol = Molecule.from_rdmol(mol)
            obm_mol._add_smiles()
            molecules.append(obm_mol)

     molecules





 () -> :
    
    ()

    evaluated = []
     i, mol  (molecules):
        :
            mol._add_rdmol()
            metrics = {
                : mol.calc_qed(),
                : mol.calc_sa(),
                : mol.calc_logp(),
                : mol.calc_lipinski(),
            }
            evaluated.append((mol, metrics))
            ()
         Exception  e:
            ()

     evaluated

 ():
    
    ()

     rdkit  Chem
     rdkit.Chem  Draw, AllChem, Descriptors

    
    ()
     i, (mol, metrics)  (candidates):
        sdf_path = output_dir / 
        writer = Chem.SDWriter((sdf_path))
        mol.rdmol.SetProp(, )
        mol.rdmol.SetProp(, )
        mol.rdmol.SetProp(, )
        mol.rdmol.SetProp(, mol.smiles)
        mol.rdmol.SetProp(, target_info.get(, ))
        mol.rdmol.SetProp(, target_info.get(, ))
        writer.write(mol.rdmol)
        writer.close()
        ()

    
    ()
     i, (mol, metrics)  (candidates):
        img = Draw.MolToImage(mol.rdmol, size=(, ))
        img_path = output_dir /  / 
        img.save((img_path))
        ()

    
    ()
    report = generate_report(candidates, target_info)
    report_path = output_dir / 
     (report_path, )  f:
        f.write(report)
    ()

 () -> :
    
    report = 
     i, (mol, metrics)  (candidates):
        smiles = mol.smiles[:] +   (mol.smiles) >   mol.smiles
        report += 

    report += 
     report





 ():
    
    ( * )
    ()
    ()
    ( * )

    
    target_info = search_target_info(TARGET_NAME)

     target_info[]:
        uniprot_data = query_uniprot(target_info[])
        target_info.update(uniprot_data)

    
     target_info[]:
        pdb_id = target_info[][]
        target_info[] = pdb_id
        pdb_file = download_pdb_structure(pdb_id)
        protein, ligand = extract_protein_and_ligand(pdb_file)
    :
        ()
        ()
        

     ligand  :
        ()
        

    
    candidates = generate_molecules(protein, ligand, NUM_CANDIDATES)

    
    evaluated = evaluate_molecules(candidates)

    
    save_outputs(evaluated, target_info, OUTPUT_DIR)

    
    ( +  * )
    ()
    sdf_files = (OUTPUT_DIR.glob())
    viz_files = ((OUTPUT_DIR / ).glob())
    ()
    ()
    ()
    ( * )
    ()
    ()
    ( * )

 __name__ == :
    main()

---

Execution Steps

Step 1: Create Output Directory

mkdir -p ./outputs/drug_discovery_results
mkdir -p ./outputs/drug_discovery_results/visualizations

Step 2: Write and Execute the Workflow Script

CRITICAL: After writing the Python script to a file, you MUST execute it:

cd /home/luoyz/projects/OpenBioMed/OpenBioMed_dev
python outputs/drug_discovery_results/drug_discovery_workflow.py

The script will:

1. Search web databases for target information
2. Query UniProt for protein metadata
3. Search RCSB PDB for structures with bound ligands
4. Download and parse PDB files
5. Extract protein and ligand molecules
6. Generate candidate molecules
7. Calculate molecular properties
8. Save all outputs

Step 3: Verify Outputs Were Created

After execution, verify the outputs exist:

ls -la ./outputs/drug_discovery_results/
ls -la ./outputs/drug_discovery_results/visualizations/

If outputs are missing, debug and re-run until they are created.

---

Available OpenBioMed Tools

Tool	Description	Usage
web_search	Search the web for information	TOOLS["web_search"].run(query="BACE1 UniProt")
protein_uniprot_request	Query UniProt database	TOOLS["protein_uniprot_request"].run(accession="P56817")
protein_pdb_request	Download PDB structures	TOOLS["protein_pdb_request"].run(accession="4DJW", mode="file_only")
extract_molecules_from_pdb_file	Extract protein/ligand from PDB	TOOLS["extract_molecules_from_pdb_file"].run(pdb_file=path)
visualize_complex	Generate protein-ligand visualization	TOOLS["visualize_complex"].run(protein=p, molecule=m)

---

Alternative: Simplified Workflow (No ML Models)

If MolCraft checkpoint is unavailable, use this simplified workflow that still searches databases and produces valid outputs:

#!/usr/bin/env python
"""
Simplified drug discovery workflow using web search and database queries.
No ML model checkpoint required.
"""

import os
import sys
import json
import requests
import re
from datetime import datetime
from pathlib import Path

# Setup
OUTPUT_DIR = Path("./outputs/drug_discovery_results")
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
(OUTPUT_DIR / "visualizations").mkdir(exist_ok=True)

WORK_DIR = "/home/luoyz/projects/OpenBioMed/OpenBioMed_dev"
sys.path.insert(0, WORK_DIR)
os.chdir(WORK_DIR)

from open_biomed.tools.tool_registry import TOOLS
from rdkit import Chem
from rdkit.Chem import Draw, AllChem, Descriptors

# Configuration
TARGET_NAME = "BACE1"  # Replace with your target

print("=" * 60)
print(f"Drug Candidate Discovery for: {TARGET_NAME}")
print("=" * 60)

# Step 1: Web search for target info
print("\n[1] Searching for target information...")
web_search = TOOLS["web_search"]
results, _ = web_search.run(query=f"{TARGET_NAME} protein UniProt PDB inhibitor")

# Step 2: Extract UniProt ID
uniprot_pattern = r'[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9]([A-Z][A-Z0-9]{2}[0-9]){1,2}'
uniprot_matches = re.findall(uniprot_pattern, (results))
uniprot_id = uniprot_matches[]  uniprot_matches  
()


pdb_pattern = 
pdb_matches = re.findall(pdb_pattern, (results))
pdb_ids = ((pdb_matches))[:]
()


protein_downloaded = 
 pdb_id  pdb_ids:
    :
        pdb_requester = TOOLS[]
        pdb_file, _ = pdb_requester.run(accession=pdb_id, mode=)
        ()
        protein_downloaded = 
        
    :
        


()


candidates_smiles = [
    ,
    ,
    ,
]

 i, smiles  (candidates_smiles):
    ()

    mol = Chem.MolFromSmiles(smiles)
    mol = Chem.AddHs(mol)
    AllChem.EmbedMolecule(mol, randomSeed=i+)
    AllChem.MMFFOptimizeMolecule(mol)

    qed = Chem.QED.qed(mol)
    logp = Descriptors.MolLogP(mol)
    sa =  - (Descriptors.TPSA(mol) / , )

    ()

    sdf_path = OUTPUT_DIR / 
    writer = Chem.SDWriter((sdf_path))
    mol.SetProp(, )
    mol.SetProp(, )
    mol.SetProp(, )
    mol.SetProp(, smiles)
    mol.SetProp(, TARGET_NAME)
    mol.SetProp(, uniprot_id  )
    writer.write(mol)
    writer.close()

    img = Draw.MolToImage(mol, size=(, ))
    img_path = OUTPUT_DIR /  / 
    img.save((img_path))


()
report = 

 i, smiles  (candidates_smiles):
    mol = Chem.MolFromSmiles(smiles)
    qed = Chem.QED.qed(mol)
    logp = Descriptors.MolLogP(mol)
    sa =  - (Descriptors.TPSA(mol) / , )
    report += 

report += 

report_path = OUTPUT_DIR / 
 (report_path, )  f:
    f.write(report)

( +  * )
()
()
()
()
( * )

Execute this script:

cd /home/luoyz/projects/OpenBioMed/OpenBioMed_dev
python outputs/drug_discovery_results/simple_workflow.py

---

Output Structure

The skill MUST produce the following outputs:

outputs/drug_discovery_results/
├── candidate_1.sdf          # REQUIRED: 3D molecular structure with properties
├── candidate_2.sdf          # REQUIRED
├── candidate_3.sdf          # REQUIRED
├── visualizations/
│   ├── candidate_1_2d.png   # REQUIRED: 2D structure image
│   ├── candidate_2_2d.png   # REQUIRED
│   └── candidate_3_2d.png   # REQUIRED
└── report.md                # REQUIRED: Comprehensive report with target info from web search

---

Validation Checklist

Before reporting completion, verify:

• At least 1 SDF file exists in outputs directory
• At least 1 PNG visualization exists in visualizations directory
• report.md exists and contains:
  • Target introduction with UniProt ID (from web search)
  • PDB structure information (from database search)
  • Methods section describing the workflow
  • Results table with molecular properties
• All files have non-zero size

If any validation fails, debug and re-execute until it passes.

---

Dependencies

• OpenBioMed repository at /home/luoyz/projects/OpenBioMed/OpenBioMed_dev
• RDKit (required, always available)
• Internet access for web search and database queries
• MolCraft checkpoint (optional, ./checkpoints/molcraft/last_updated.ckpt)

Example Usage

Generate 3 drug candidates for BTK (Bruton's tyrosine kinase).

Or simply:
Find potential drug molecules for Alzheimer's disease targeting BACE1.

Or:
Design KRAS G12C inhibitors for cancer therapy.