Molecule Operations

from LLM4Chem.generation import LlaSMolGeneration

generator = LlaSMolGeneration('osunlp/LlaSMol-Mistral-7B')

query = "Describe this molecule: <SMILES> CCOC(=O)C1=CN=CN1[C@H](C)C1=CC=CC=C1 </SMILES>"
result = generator.generate(query)
print(result[0]['output'][0])

The molecule is an imidazole derivative with short-acting sedative, hypnotic, 
and general anesthetic properties. Etomidate appears to have gamma-aminobutyric 
acid (GABA) like effects, mediated through GABA-A receptor. The action enhances 
the inhibitory effect of GABA on the central nervous system by causing chloride 
channel opening events which leads to membrane hyperpolarization.

smiles_list = [
    "CCO",  # Ethanol
    "C1=CC=CC=C1",  # Benzene
    "CC(=O)O"  # Acetic acid
]

for smiles in smiles_list:
    query = f"Describe this molecule: <SMILES> {smiles} </SMILES>"
    result = generator.generate(query)
    print(f"\n{smiles}:")
    print(result[0]['output'][0])

query = """Give me a molecule that satisfies the conditions outlined in the description: 
The molecule is a member of the class of tripyrroles that is a red-coloured pigment 
with antibiotic properties produced by Serratia marcescens. It has a role as an 
antimicrobial agent, a biological pigment, a bacterial metabolite, an apoptosis 
inducer and an antineoplastic agent. It is a tripyrrole, an aromatic ether and 
a ring assembly."""

result = generator.generate(query)
print(result[0]['output'][0])
# Output: Here is a potential molecule: <SMILES> CCCCCC1=C(C)NC(/C=C2\N=C(C3=CC=CN3)C=C2OC)=C1 </SMILES>

from plan_execute_agent.chem_tools import validate_smiles_rdkit

query = "Generate a simple aromatic compound"
result = generator.generate(query)

# Extract SMILES from output
import re
match = re.search(r'<SMILES>\s*(.+?)\s*</SMILES>', result[0]['output'][0])
if match:
    smiles = match.group(1)
    validation = validate_smiles_rdkit.invoke({"smiles_string": smiles})
    
    if validation['valid']:
        print(f"Valid molecule generated: {smiles}")
    else:
        print(f"Invalid SMILES: {validation['error_message']}")

import asyncio
from plan_execute_agent.rdkit_agent import process_input

query = "Generate a molecule that is an NMDA receptor antagonist"

result, completed, attempts, llasmol_response, errors, formatted_input = \
    asyncio.run(process_input(query))

if completed and not errors:
    print(f"Generated and validated: {result}")
else:
    print(f"Generation issues: {errors}")

# Step 1: Start with a reference molecule
reference_smiles = "CC(C)Cl"

# Step 2: Get its description
caption_query = f"Describe this molecule: <SMILES> {reference_smiles} </SMILES>"
description = generator.generate(caption_query)[0]['output'][0]

print(f"Original description:\n{description}\n")

# Step 3: Modify the description
modified_desc = description + " Additionally, the molecule should have a hydroxyl group."

# Step 4: Generate a new molecule
gen_query = f"Generate a molecule: {modified_desc}"
new_molecule = generator.generate(gen_query)[0]['output'][0]

print(f"New molecule:\n{new_molecule}\n")

# Step 5: Verify the new molecule
import re
match = re.search(r'<SMILES>\s*(.+?)\s*</SMILES>', new_molecule)
if match:
    new_smiles = match.group(1)
    verify_query = f"Describe this molecule: <SMILES> {new_smiles} </SMILES>"
    verification = generator.generate(verify_query)[0]['output'][0]
    print(f"Verification:\n{verification}")

base_description = "A molecule that inhibits HIV replication"

variants = [
    f"{base_description} with high water solubility",
    f"{base_description} with improved lipophilicity",
    f"{base_description} with reduced toxicity"
]

for i, variant in enumerate(variants, 1):
    result = generator.generate(f"Generate a molecule: {variant}")
    print(f"\nVariant {i}:")
    print(result[0]['output'][0])

# Get description of original molecule
original = "C1=CC=C(C=C1)O"  # Phenol
caption = generator.generate(f"Describe: <SMILES> {original} </SMILES>")

# Generate alternative scaffolds
query = f"{caption[0]['output'][0]}. Generate a molecule with different core structure but similar properties."
result = generator.generate(query)