@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/chemistry/chemeagle-guide/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: chemeagle-guide
+description: "Multi-agent system for chemical literature information extraction"
+metadata:
+  openclaw:
+    emoji: "🦅"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["ChemEagle", "chemical extraction", "literature mining", "reaction extraction", "chemistry NLP", "multi-agent"]
+    source: "https://github.com/CYF2000127/ChemEagle"
+---
+
+# ChemEagle Guide
+
+## Overview
+
+ChemEagle is a multi-agent system for extracting structured chemical information from scientific literature. It uses specialized agents for recognizing chemical entities, extracting reaction conditions, identifying product yields, and building structured databases from unstructured chemistry papers. Particularly useful for building reaction databases and automating systematic reviews in chemistry.
+
+## Agent Pipeline
+
+```
+Chemistry Paper (PDF/text)
+         ↓
+   Document Parser Agent (section identification)
+         ↓
+   Chemical NER Agent
+   ├── Compound names → SMILES/InChI
+   ├── Reagents and catalysts
+   ├── Solvents and conditions
+   └── Product identification
+         ↓
+   Reaction Extraction Agent
+   ├── Reactants → Products mapping
+   ├── Reaction conditions (T, P, time)
+   ├── Yields and selectivity
+   └── Procedure steps
+         ↓
+   Validation Agent (cross-check extracted data)
+         ↓
+   Structured Output (JSON, CSV, database)
+```
+
+## Usage
+
+```python
+from chemeagle import ChemEagle
+
+eagle = ChemEagle(llm_provider="anthropic")
+
+# Extract from a chemistry paper
+result = eagle.extract("paper.pdf")
+
+# Extracted reactions
+for rxn in result.reactions:
+    print(f"\nReaction {rxn.id}:")
+    print(f"  Reactants: {rxn.reactants}")
+    print(f"  Products: {rxn.products}")
+    print(f"  Catalyst: {rxn.catalyst}")
+    print(f"  Solvent: {rxn.solvent}")
+    print(f"  Temperature: {rxn.temperature}")
+    print(f"  Time: {rxn.time}")
+    print(f"  Yield: {rxn.yield_percent}%")
+    print(f"  SMILES: {rxn.product_smiles}")
+
+# Extracted compounds
+for compound in result.compounds:
+    print(f"{compound.name}: {compound.smiles}")
+```
+
+## Batch Processing
+
+```python
+# Process multiple papers
+results = eagle.extract_batch(
+    input_dir="chemistry_papers/",
+    output_format="csv",
+    output_file="reactions_database.csv",
+)
+
+print(f"Papers processed: {results.papers_processed}")
+print(f"Reactions extracted: {results.total_reactions}")
+print(f"Unique compounds: {results.unique_compounds}")
+```
+
+## Chemical Entity Recognition
+
+```python
+# Standalone NER
+entities = eagle.recognize_entities(
+    "The Suzuki coupling of 4-bromoanisole with phenylboronic "
+    "acid using Pd(PPh3)4 catalyst in THF/water at 80°C "
+    "gave 4-methoxybiphenyl in 95% yield."
+)
+
+for entity in entities:
+    print(f"  [{entity.type}] {entity.text}")
+    if entity.smiles:
+        print(f"    SMILES: {entity.smiles}")
+
+# Output:
+# [REACTANT] 4-bromoanisole — SMILES: COc1ccc(Br)cc1
+# [REACTANT] phenylboronic acid — SMILES: OB(O)c1ccccc1
+# [CATALYST] Pd(PPh3)4
+# [SOLVENT] THF/water
+# [CONDITION] 80°C
+# [PRODUCT] 4-methoxybiphenyl — SMILES: COc1ccc(-c2ccccc2)cc1
+# [YIELD] 95%
+```
+
+## Database Building
+
+```python
+# Build a searchable reaction database
+from chemeagle import ReactionDatabase
+
+db = ReactionDatabase("reactions.db")
+
+# Add extracted reactions
+db.add_from_extraction(result)
+
+# Search by substrate
+hits = db.search(reactant="bromoanisole", reaction_type="coupling")
+for hit in hits:
+    print(f"{hit.reactants} → {hit.products} ({hit.yield_percent}%)")
+    print(f"  Source: {hit.paper_doi}")
+
+# Search by conditions
+hits = db.search(catalyst="palladium", temperature_max=100)
+
+# Export
+db.export_csv("all_reactions.csv")
+db.export_json("all_reactions.json")
+```
+
+## Use Cases
+
+1. **Reaction mining**: Extract reactions from chemistry literature
+2. **Database building**: Automated reaction database construction
+3. **Systematic reviews**: Structured data from chemistry papers
+4. **Synthesis planning**: Search conditions for target reactions
+5. **Trend analysis**: Track reaction methodology evolution
+
+## References
+
+- [ChemEagle GitHub](https://github.com/CYF2000127/ChemEagle)
+- [RDKit](https://www.rdkit.org/) — Chemistry toolkit
+- [PubChem](https://pubchem.ncbi.nlm.nih.gov/) — Chemical database

package/skills/domains/chemistry/chemgraph-agent-guide/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: chemgraph-agent-guide
+description: "Automate molecular simulations with the ChemGraph agentic framework"
+metadata:
+  openclaw:
+    emoji: "⚗️"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["ChemGraph", "molecular simulation", "computational chemistry", "DFT", "LangGraph", "ASE"]
+    source: "https://github.com/argonne-lcf/ChemGraph"
+---
+
+# ChemGraph Agent Guide
+
+## Overview
+
+ChemGraph is an agentic framework from Argonne National Lab that automates molecular simulation workflows using LLMs. Built on LangGraph and ASE (Atomic Simulation Environment), it enables natural language control of computational chemistry tasks — structure generation, geometry optimization, thermochemistry, and more. Supports DFT (NWChem, ORCA), semi-empirical (xTB), and ML potentials (MACE).
+
+## Installation
+
+```bash
+pip install chemgraph
+
+# Or via Docker
+docker pull ghcr.io/argonne-lcf/chemgraph:latest
+```
+
+## Core Capabilities
+
+### Natural Language Chemistry
+
+```python
+from chemgraph import ChemGraphAgent
+
+agent = ChemGraphAgent(
+    llm_provider="anthropic",
+    calculator="xtb",  # fast semi-empirical
+)
+
+# Natural language molecular tasks
+result = agent.run("Optimize the geometry of caffeine and calculate its vibrational frequencies")
+print(result.energy)
+print(result.frequencies)
+
+# Thermochemistry
+result = agent.run("Calculate the enthalpy of formation of ethanol at 298K")
+print(f"ΔHf = {result.enthalpy:.2f} kJ/mol")
+```
+
+### Supported Calculators
+
+| Calculator | Type | Speed | Accuracy |
+|-----------|------|-------|----------|
+| xTB (TBLite) | Semi-empirical | Fast | Moderate |
+| MACE | ML potential | Fast | Good |
+| NWChem | Ab initio DFT | Slow | High |
+| ORCA | Ab initio/DFT | Slow | High |
+| UMA | Universal ML | Fast | Good |
+
+### Workflow Automation
+
+```python
+# Multi-step workflow
+workflow = agent.create_workflow([
+    "Generate 3D structure of aspirin from SMILES",
+    "Optimize geometry with DFT/B3LYP/6-31G*",
+    "Calculate IR spectrum",
+    "Identify key functional group vibrations",
+])
+results = workflow.execute()
+
+# Reaction pathway
+pathway = agent.run(
+    "Find the transition state for the Diels-Alder reaction "
+    "between butadiene and ethylene"
+)
+```
+
+### Integration with ASE
+
+```python
+from ase.io import read
+from chemgraph.calculators import get_calculator
+
+# Use ChemGraph's calculator with ASE directly
+atoms = read("molecule.xyz")
+calc = get_calculator("xtb")
+atoms.calc = calc
+
+energy = atoms.get_potential_energy()
+forces = atoms.get_forces()
+```
+
+## Agent Architecture
+
+ChemGraph uses LangGraph's state machine to orchestrate:
+
+1. **Parser Agent** — Interprets natural language into chemistry tasks
+2. **Structure Agent** — Generates/retrieves molecular structures (SMILES, PDB, CIF)
+3. **Calculator Agent** — Selects and runs appropriate simulation backend
+4. **Analysis Agent** — Processes results and generates reports
+
+## Use Cases
+
+1. **High-throughput screening**: Automated property calculation for molecular libraries
+2. **Reaction discovery**: Transition state finding and reaction pathway analysis
+3. **Materials design**: Optimize structures for target properties
+4. **Education**: Natural language interface for learning computational chemistry
+
+## Requirements
+
+- Python 3.10+
+- At least one calculator backend (xTB recommended for getting started)
+- LLM API key (Anthropic, OpenAI, or local)
+
+## References
+
+- [ChemGraph GitHub](https://github.com/argonne-lcf/ChemGraph)
+- [ASE Documentation](https://wiki.fysik.dtu.dk/ase/)
+- [LangGraph](https://github.com/langchain-ai/langgraph)

package/skills/domains/chemistry/molecular-dynamics-guide/SKILL.md

@@ -0,0 +1,237 @@
+---
+name: molecular-dynamics-guide
+description: "Molecular dynamics simulation setup, execution, and trajectory analysis"
+metadata:
+  openclaw:
+    emoji: "atom-symbol"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["molecular-dynamics", "simulation", "gromacs", "openmm", "force-field", "trajectory"]
+    source: "wentor"
+---
+
+# Molecular Dynamics Guide
+
+A skill for setting up, running, and analyzing molecular dynamics (MD) simulations. Covers force field selection, system preparation, simulation protocols, trajectory analysis, and free energy calculations using GROMACS, OpenMM, and MDAnalysis.
+
+## System Preparation
+
+### Building a Simulation System
+
+The standard workflow for preparing an MD simulation:
+
+```
+1. Obtain structure (PDB, homology model, or docking pose)
+2. Clean structure (add missing atoms, fix protonation states)
+3. Assign force field parameters
+4. Solvate in explicit water box
+5. Add counterions to neutralize charge
+6. Energy minimize
+7. Equilibrate (NVT then NPT)
+8. Production run
+```
+
+### GROMACS System Setup
+
+```bash
+# 1. Generate topology from PDB
+gmx pdb2gmx -f protein.pdb -o processed.gro -water tip3p -ff amber99sb-ildn
+
+# 2. Define simulation box (dodecahedron, 1.0 nm buffer)
+gmx editconf -f processed.gro -o boxed.gro -c -d 1.0 -bt dodecahedron
+
+# 3. Solvate
+gmx solvate -cp boxed.gro -cs spc216.gro -o solvated.gro -p topol.top
+
+# 4. Add ions to neutralize and set ionic strength (0.15 M NaCl)
+gmx grompp -f ions.mdp -c solvated.gro -p topol.top -o ions.tpr
+gmx genion -s ions.tpr -o ionized.gro -p topol.top -pname NA -nname CL -neutral -conc 0.15
+
+# 5. Energy minimization
+gmx grompp -f minim.mdp -c ionized.gro -p topol.top -o em.tpr
+gmx mdrun -deffnm em
+
+# 6. NVT equilibration (100 ps, 300 K)
+gmx grompp -f nvt.mdp -c em.gro -r em.gro -p topol.top -o nvt.tpr
+gmx mdrun -deffnm nvt
+
+# 7. NPT equilibration (100 ps, 300 K, 1 bar)
+gmx grompp -f npt.mdp -c nvt.gro -r nvt.gro -t nvt.cpt -p topol.top -o npt.tpr
+gmx mdrun -deffnm npt
+
+# 8. Production MD (100 ns)
+gmx grompp -f md.mdp -c npt.gro -t npt.cpt -p topol.top -o md.tpr
+gmx mdrun -deffnm md
+```
+
+## Force Field Selection
+
+### Common Force Fields
+
+| Force Field | Strengths | Typical Use |
+|-------------|-----------|------------|
+| AMBER ff14SB | Protein structure, dynamics | Protein simulations |
+| AMBER ff19SB | Improved backbone dihedrals | Latest protein simulations |
+| CHARMM36m | Proteins, lipids, carbohydrates | Membrane systems |
+| OPLS-AA/M | Small molecules, organic liquids | Drug-like molecules |
+| GAFF2 | General small molecules | Ligand parameterization |
+| CGenFF | CHARMM-compatible small molecules | Ligands in CHARMM systems |
+
+### OpenMM System Setup
+
+```python
+from openmm.app import PDBFile, ForceField, Modeller, Simulation
+from openmm.app import PME, HBonds, NoCutoff
+from openmm import LangevinMiddleIntegrator, MonteCarloBarostat
+from openmm.unit import kelvin, atmospheres, nanometers, picoseconds
+
+def setup_openmm_simulation(pdb_path: str,
+                              temperature: float = 300,
+                              pressure: float = 1.0,
+                              timestep: float = 0.002) -> Simulation:
+    """
+    Set up an OpenMM molecular dynamics simulation.
+    pdb_path: path to prepared PDB file
+    temperature: simulation temperature in Kelvin
+    pressure: pressure in atmospheres
+    timestep: integration timestep in picoseconds
+    """
+    pdb = PDBFile(pdb_path)
+    forcefield = ForceField("amber14-all.xml", "amber14/tip3pfb.xml")
+
+    modeller = Modeller(pdb.topology, pdb.positions)
+    modeller.addSolvent(forcefield, padding=1.0 * nanometers,
+                        ionicStrength=0.15)
+
+    system = forcefield.createSystem(
+        modeller.topology,
+        nonbondedMethod=PME,
+        nonbondedCutoff=1.0 * nanometers,
+        constraints=HBonds,
+    )
+
+    # Barostat for NPT ensemble
+    system.addForce(
+        MonteCarloBarostat(pressure * atmospheres, temperature * kelvin)
+    )
+
+    integrator = LangevinMiddleIntegrator(
+        temperature * kelvin,
+        1.0 / picoseconds,
+        timestep * picoseconds,
+    )
+
+    simulation = Simulation(modeller.topology, system, integrator)
+    simulation.context.setPositions(modeller.positions)
+
+    # Energy minimization
+    simulation.minimizeEnergy()
+
+    return simulation
+```
+
+## Trajectory Analysis
+
+### Structural Analysis with MDAnalysis
+
+```python
+import MDAnalysis as mda
+from MDAnalysis.analysis import rms, align, diffusionmap
+import numpy as np
+
+def analyze_trajectory(topology: str, trajectory: str) -> dict:
+    """
+    Comprehensive trajectory analysis: RMSD, RMSF, radius of gyration.
+    topology: topology file (GRO, PDB, PSF)
+    trajectory: trajectory file (XTC, TRR, DCD)
+    """
+    u = mda.Universe(topology, trajectory)
+    protein = u.select_atoms("protein and name CA")
+
+    # RMSD over time (C-alpha atoms)
+    ref = mda.Universe(topology)
+    rmsd_analysis = rms.RMSD(u, ref, select="protein and name CA")
+    rmsd_analysis.run()
+    rmsd_data = rmsd_analysis.results.rmsd  # shape: (n_frames, 3)
+
+    # RMSF per residue
+    align.AlignTraj(u, ref, select="protein and name CA", in_memory=True).run()
+    rmsf = rms.RMSF(protein).run()
+
+    # Radius of gyration
+    rg_values = []
+    for ts in u.trajectory:
+        rg_values.append(protein.radius_of_gyration())
+
+    return {
+        "n_frames": len(u.trajectory),
+        "rmsd_mean_nm": np.mean(rmsd_data[:, 2]) / 10,  # A to nm
+        "rmsd_final_nm": rmsd_data[-1, 2] / 10,
+        "rmsf_mean_nm": np.mean(rmsf.results.rmsf) / 10,
+        "rg_mean_nm": np.mean(rg_values) / 10,
+        "rg_std_nm": np.std(rg_values) / 10,
+        "simulation_time_ns": u.trajectory[-1].time / 1000,
+    }
+```
+
+### Hydrogen Bond Analysis
+
+```python
+from MDAnalysis.analysis.hydrogenbonds import HydrogenBondAnalysis
+
+def analyze_hbonds(universe: mda.Universe,
+                    donor_sel: str = "protein",
+                    acceptor_sel: str = "protein") -> dict:
+    """Analyze hydrogen bonds over the trajectory."""
+    hbonds = HydrogenBondAnalysis(
+        universe,
+        donors_sel=f"({donor_sel}) and (name N* or name O*)",
+        acceptors_sel=f"({acceptor_sel}) and (name O* or name N*)",
+        d_a_cutoff=3.5,
+        d_h_a_angle_cutoff=150,
+    )
+    hbonds.run()
+
+    return {
+        "total_hbonds_detected": len(hbonds.results.hbonds),
+        "mean_per_frame": len(hbonds.results.hbonds) / hbonds.n_frames,
+        "unique_pairs": len(set(
+            (int(r[1]), int(r[3])) for r in hbonds.results.hbonds
+        )),
+    }
+```
+
+## Free Energy Methods
+
+### Umbrella Sampling
+
+Umbrella sampling computes the potential of mean force (PMF) along a reaction coordinate:
+
+1. Generate windows along the reaction coordinate (e.g., distance between two groups)
+2. Run restrained simulations at each window with a harmonic bias
+3. Combine windows using WHAM (Weighted Histogram Analysis Method)
+4. Report the free energy profile (PMF)
+
+### Alchemical Free Energy Perturbation
+
+Used for computing binding free energies and solvation free energies:
+
+```
+Lambda schedule: 0.0, 0.1, 0.2, ..., 0.9, 1.0
+At lambda=0: full interaction (bound state)
+At lambda=1: no interaction (unbound state)
+
+Each lambda window: independent MD simulation
+Analysis: MBAR or TI to combine lambda windows
+```
+
+## Tools and Software
+
+- **GROMACS**: High-performance MD engine (free, GPU-accelerated)
+- **OpenMM**: Python-native MD with GPU support
+- **AMBER**: Comprehensive MD package (academic license)
+- **NAMD**: Scalable MD for large biomolecular systems
+- **MDAnalysis**: Python trajectory analysis library
+- **MDTraj**: Lightweight trajectory analysis
+- **PyMOL / VMD**: Molecular visualization and movie generation
+- **PLUMED**: Free energy and enhanced sampling methods plugin

package/skills/domains/chemistry/pubchem-api-guide/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: pubchem-api-guide
+description: "Search PubChem for chemical compounds, structures, and bioassay data"
+metadata:
+  openclaw:
+    emoji: "⚗️"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["pubchem", "chemistry", "compounds", "structures", "bioassay", "pharmacology"]
+    source: "https://pubchem.ncbi.nlm.nih.gov/docs/pug-rest"
+---
+
+# PubChem PUG REST API Guide
+
+## Overview
+
+PubChem is the world's largest free chemistry database, maintained by the National Center for Biotechnology Information (NCBI) at the U.S. National Library of Medicine. It contains information on over 115 million chemical compounds, 300 million substances from hundreds of data sources, and over 1.5 million bioassay experiments. PubChem is a critical resource for researchers in chemistry, pharmacology, drug discovery, toxicology, and related life sciences.
+
+The PUG REST (Power User Gateway RESTful) API provides programmatic access to PubChem's three primary databases: Compound (standardized chemical structures), Substance (depositor-provided records), and BioAssay (biological screening results). The API supports searches by name, molecular formula, structure similarity, substructure, and various identifiers including CID, SID, InChI, and SMILES.
+
+PUG REST is entirely free, requires no authentication, and returns data in JSON, XML, CSV, SDF, and other formats. It is designed for both simple lookups and complex cheminformatics workflows.
+
+## Authentication
+
+No authentication is required. PubChem PUG REST is a free public service.
+
+```bash
+# No API key needed
+curl "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/aspirin/JSON"
+```
+
+## Core Endpoints
+
+### Get Compound by Name
+
+```
+GET https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{name}/JSON
+```
+
+```bash
+curl -s "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/caffeine/JSON" \
+  | python3 -m json.tool
+```
+
+### Get Compound Properties
+
+Retrieve specific properties for a compound by CID.
+
+```
+GET https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/{cid}/property/{properties}/JSON
+```
+
+**Available properties:** MolecularFormula, MolecularWeight, CanonicalSMILES, InChI, InChIKey, IUPACName, XLogP, ExactMass, HBondDonorCount, HBondAcceptorCount, RotatableBondCount, TPSA
+
+```bash
+curl -s "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/ibuprofen/property/MolecularFormula,MolecularWeight,CanonicalSMILES,IUPACName,XLogP/JSON" \
+  | python3 -m json.tool
+```
+
+### Search by Molecular Formula
+
+```bash
+curl -s "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastformula/C8H10N4O2/property/IUPACName,MolecularWeight,CanonicalSMILES/JSON" \
+  | python3 -m json.tool
+```
+
+### Similarity Search
+
+Find compounds structurally similar to a given compound (Tanimoto threshold).
+
+```bash
+curl -s "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/fastsimilarity_2d/cid/2244/property/IUPACName,MolecularWeight,CanonicalSMILES/JSON?Threshold=90" \
+  | python3 -m json.tool
+```
+
+### Get BioAssay Data
+
+Retrieve biological activity data for a compound.
+
+```bash
+curl -s "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/2244/assaysummary/JSON" \
+  | python3 -m json.tool
+```
+
+### Python Example: Drug-Likeness Screening
+
+```python
+import requests
+import time
+
+PUG_REST = "https://pubchem.ncbi.nlm.nih.gov/rest/pug"
+
+def get_compound_properties(name):
+    """Fetch key drug-likeness properties for a named compound."""
+    props = "MolecularWeight,XLogP,HBondDonorCount,HBondAcceptorCount,TPSA,RotatableBondCount,IUPACName"
+    url = f"{PUG_REST}/compound/name/{name}/property/{props}/JSON"
+    resp = requests.get(url)
+    resp.raise_for_status()
+    data = resp.json()
+    return data.get("PropertyTable", {}).get("Properties", [{}])[0]
+
+def check_lipinski(props):
+    """Check Lipinski's Rule of Five for oral drug-likeness."""
+    violations = 0
+    mw = props.get("MolecularWeight", 0)
+    logp = props.get("XLogP", 0)
+    hbd = props.get("HBondDonorCount", 0)
+    hba = props.get("HBondAcceptorCount", 0)
+
+    if mw > 500: violations += 1
+    if logp > 5: violations += 1
+    if hbd > 5: violations += 1
+    if hba > 10: violations += 1
+    return violations
+
+drug_candidates = ["metformin", "atorvastatin", "lisinopril", "omeprazole"]
+print(f"{'Compound':<20} {'MW':>8} {'LogP':>6} {'HBD':>4} {'HBA':>4} {'Violations':>10}")
+print("-" * 60)
+
+for drug in drug_candidates:
+    props = get_compound_properties(drug)
+    violations = check_lipinski(props)
+    print(f"{drug:<20} {props.get('MolecularWeight', 0):>8.1f} "
+          f"{props.get('XLogP', 0):>6.1f} "
+          f"{props.get('HBondDonorCount', 0):>4} "
+          f"{props.get('HBondAcceptorCount', 0):>4} "
+          f"{violations:>10}")
+    time.sleep(0.3)
+```
+
+### Python Example: Compound Comparison
+
+```python
+import requests
+
+def compare_compounds(cid_list):
+    """Compare properties of multiple compounds by CID."""
+    cids = ",".join(str(c) for c in cid_list)
+    props = "IUPACName,MolecularFormula,MolecularWeight,CanonicalSMILES,XLogP"
+    url = f"{PUG_REST}/compound/cid/{cids}/property/{props}/JSON"
+    resp = requests.get(url)
+    resp.raise_for_status()
+    return resp.json().get("PropertyTable", {}).get("Properties", [])
+
+# Compare aspirin (2244), ibuprofen (3672), acetaminophen (1983)
+results = compare_compounds([2244, 3672, 1983])
+for compound in results:
+    print(f"\n{compound.get('IUPACName', 'Unknown')}")
+    print(f"  Formula: {compound.get('MolecularFormula')}")
+    print(f"  MW: {compound.get('MolecularWeight')}")
+    print(f"  SMILES: {compound.get('CanonicalSMILES')}")
+    print(f"  LogP: {compound.get('XLogP')}")
+```
+
+## Common Research Patterns
+
+**Structure-Activity Relationship (SAR) Analysis:** Use similarity searches to find structural analogs of lead compounds, then retrieve bioassay data to compare biological activity across the series.
+
+**Virtual Screening:** Screen large compound libraries against drug-likeness filters (Lipinski's rules, Veber's rules) using property endpoints to prioritize candidates for experimental testing.
+
+**Chemical Identifier Resolution:** Translate between compound names, CIDs, InChI, InChIKey, and SMILES notations. Essential for data integration across heterogeneous chemistry databases.
+
+**Toxicology Research:** Access bioassay results and safety data for compounds to support toxicity profiling and risk assessment in environmental health research.
+
+## Rate Limits and Best Practices
+
+- **Rate limit:** Maximum 5 requests per second; add 200ms delays between requests
+- **No more than 400 requests per minute** from a single IP
+- **Batch requests:** Use comma-separated CIDs (up to 200) in a single request to minimize API calls
+- **Async operations:** For large similarity/substructure searches, use the async workflow with list keys
+- **Response formats:** Use JSON for programmatic access, SDF for structure files, CSV for tabular data
+- **Caching:** Compound data is relatively static; cache property lookups aggressively
+- **Error handling:** HTTP 404 means compound not found; 503 means server busy (retry with backoff)
+
+## References
+
+- PubChem PUG REST Documentation: https://pubchem.ncbi.nlm.nih.gov/docs/pug-rest
+- PubChem PUG REST Tutorial: https://pubchem.ncbi.nlm.nih.gov/docs/pug-rest-tutorial
+- PubChem Compound Database: https://pubchem.ncbi.nlm.nih.gov/
+- PubChem Power User Gateway: https://pubchem.ncbi.nlm.nih.gov/docs/power-user-gateway