@wentorai/research-plugins 1.0.0 → 1.1.0

package/skills/domains/business/operations-research-guide/SKILL.md

@@ -0,0 +1,258 @@
+---
+name: operations-research-guide
+description: "Optimization and operations research methods for business and logistics"
+metadata:
+  openclaw:
+    emoji: "gear"
+    category: "domains"
+    subcategory: "business"
+    keywords: ["optimization", "operations-research", "linear-programming", "scheduling", "supply-chain", "simulation"]
+    source: "wentor"
+---
+
+# Operations Research Guide
+
+A skill for applying operations research (OR) methods to business, logistics, and resource allocation problems. Covers linear programming, integer programming, scheduling, network optimization, simulation, and decision analysis using Python optimization libraries.
+
+## Linear Programming
+
+### Problem Formulation and Solving
+
+```python
+from scipy.optimize import linprog
+import numpy as np
+
+def solve_production_planning():
+    """
+    Example: A factory produces two products (A and B).
+    Product A: profit $40, uses 2h labor + 1kg material
+    Product B: profit $30, uses 1h labor + 2kg material
+    Constraints: 100h labor available, 80kg material available
+    Maximize total profit.
+    """
+    # linprog minimizes, so negate for maximization
+    c = [-40, -30]  # objective coefficients (negated)
+
+    # Inequality constraints: A_ub @ x <= b_ub
+    A_ub = [
+        [2, 1],   # labor constraint
+        [1, 2],   # material constraint
+    ]
+    b_ub = [100, 80]
+
+    # Non-negativity bounds
+    bounds = [(0, None), (0, None)]
+
+    result = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=bounds, method="highs")
+
+    return {
+        "product_A": result.x[0],
+        "product_B": result.x[1],
+        "max_profit": -result.fun,
+        "status": "optimal" if result.success else "infeasible",
+    }
+```
+
+### Using PuLP for Readable Models
+
+```python
+from pulp import LpProblem, LpMaximize, LpVariable, lpSum, value
+
+def workforce_scheduling():
+    """
+    Workforce scheduling: minimize staffing cost while meeting
+    demand for each day of the week. Workers work 5 consecutive days.
+    """
+    days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+    demand = [17, 13, 15, 19, 14, 16, 11]
+    cost_per_worker = 1  # uniform cost
+
+    prob = LpProblem("workforce_scheduling", LpMaximize)
+
+    # x[i] = number of workers starting on day i
+    x = {i: LpVariable(f"start_{days[i]}", lowBound=0, cat="Integer")
+         for i in range(7)}
+
+    # Minimize total workers
+    prob += -lpSum(x[i] for i in range(7))
+
+    # Each day, workers starting on days [d-4, d-3, ..., d] are available
+    for d in range(7):
+        workers_available = lpSum(x[(d - j) % 7] for j in range(5))
+        prob += workers_available >= demand[d], f"demand_{days[d]}"
+
+    prob.solve()
+
+    return {
+        "status": prob.status,
+        "schedule": {days[i]: int(value(x[i])) for i in range(7)},
+        "total_workers": int(sum(value(x[i]) for i in range(7))),
+    }
+```
+
+## Integer and Mixed-Integer Programming
+
+### Vehicle Routing Problem
+
+```python
+from itertools import combinations
+
+def solve_tsp_mtz(distances: np.ndarray) -> dict:
+    """
+    Solve the Traveling Salesman Problem using Miller-Tucker-Zemlin formulation.
+    distances: n x n distance matrix
+    Returns optimal tour and total distance.
+    """
+    from pulp import LpProblem, LpMinimize, LpVariable, LpBinary, lpSum, value
+
+    n = len(distances)
+    prob = LpProblem("TSP", LpMinimize)
+
+    # Binary variables: x[i][j] = 1 if edge (i,j) in tour
+    x = {(i, j): LpVariable(f"x_{i}_{j}", cat=LpBinary)
+         for i in range(n) for j in range(n) if i != j}
+
+    # Subtour elimination variables
+    u = {i: LpVariable(f"u_{i}", lowBound=1, upBound=n - 1)
+         for i in range(1, n)}
+
+    # Objective: minimize total distance
+    prob += lpSum(distances[i][j] * x[i, j] for i, j in x)
+
+    # Each city visited exactly once
+    for i in range(n):
+        prob += lpSum(x[i, j] for j in range(n) if j != i) == 1
+        prob += lpSum(x[j, i] for j in range(n) if j != i) == 1
+
+    # MTZ subtour elimination
+    for i in range(1, n):
+        for j in range(1, n):
+            if i != j:
+                prob += u[i] - u[j] + (n - 1) * x[i, j] <= n - 2
+
+    prob.solve()
+
+    # Extract tour
+    tour = [0]
+    current = 0
+    for _ in range(n - 1):
+        for j in range(n):
+            if j != current and (current, j) in x and value(x[current, j]) > 0.5:
+                tour.append(j)
+                current = j
+                break
+
+    return {
+        "tour": tour,
+        "total_distance": value(prob.objective),
+    }
+```
+
+## Queuing Theory
+
+### M/M/c Queue Analysis
+
+```python
+from math import factorial, exp
+
+def mmc_queue(arrival_rate: float, service_rate: float,
+              n_servers: int) -> dict:
+    """
+    Analyze an M/M/c queue (Poisson arrivals, exponential service, c servers).
+    arrival_rate: lambda (customers per unit time)
+    service_rate: mu (customers served per unit time per server)
+    n_servers: c (number of parallel servers)
+    """
+    rho = arrival_rate / (n_servers * service_rate)
+
+    if rho >= 1:
+        return {"stable": False, "utilization": rho}
+
+    # Erlang C formula: probability of waiting
+    a = arrival_rate / service_rate
+    sum_terms = sum(a ** k / factorial(k) for k in range(n_servers))
+    erlang_c = (a ** n_servers / factorial(n_servers)) / (
+        (a ** n_servers / factorial(n_servers)) + (1 - rho) * sum_terms
+    )
+
+    # Performance metrics
+    Lq = erlang_c * rho / (1 - rho)         # avg queue length
+    Wq = Lq / arrival_rate                    # avg wait time
+    W = Wq + 1 / service_rate                 # avg time in system
+    L = arrival_rate * W                      # avg number in system
+
+    return {
+        "stable": True,
+        "utilization": round(rho, 4),
+        "prob_wait": round(erlang_c, 4),
+        "avg_queue_length": round(Lq, 4),
+        "avg_wait_time": round(Wq, 4),
+        "avg_system_time": round(W, 4),
+        "avg_in_system": round(L, 4),
+    }
+```
+
+## Simulation Methods
+
+### Discrete-Event Simulation
+
+```python
+import simpy
+import random
+
+def simulate_service_center(n_servers: int, arrival_rate: float,
+                             service_rate: float, sim_time: float = 480):
+    """
+    Discrete-event simulation of a service center using SimPy.
+    sim_time: simulation duration in minutes (default 8-hour day).
+    """
+    wait_times = []
+
+    def customer(env, server):
+        arrival_time = env.now
+        with server.request() as req:
+            yield req
+            wait = env.now - arrival_time
+            wait_times.append(wait)
+            yield env.timeout(random.expovariate(service_rate))
+
+    def customer_generator(env, server):
+        customer_id = 0
+        while True:
+            yield env.timeout(random.expovariate(arrival_rate))
+            customer_id += 1
+            env.process(customer(env, server))
+
+    env = simpy.Environment()
+    server = simpy.Resource(env, capacity=n_servers)
+    env.process(customer_generator(env, server))
+    env.run(until=sim_time)
+
+    return {
+        "customers_served": len(wait_times),
+        "avg_wait": np.mean(wait_times) if wait_times else 0,
+        "max_wait": max(wait_times) if wait_times else 0,
+        "pct_waited": sum(1 for w in wait_times if w > 0) / len(wait_times) * 100,
+    }
+```
+
+## Decision Analysis
+
+### Multi-Criteria Decision Making
+
+| Method | Description | Best For |
+|--------|-------------|----------|
+| AHP (Analytic Hierarchy Process) | Pairwise comparison matrix | Structured group decisions |
+| TOPSIS | Distance to ideal/anti-ideal solution | Ranking alternatives |
+| Weighted scoring | Simple weighted sum | Quick comparisons |
+| Decision trees | Sequential decision under uncertainty | Multi-stage problems |
+
+## Tools and Libraries
+
+- **PuLP**: Python LP/MIP modeling with multiple solver backends
+- **OR-Tools (Google)**: Constraint programming, routing, scheduling
+- **Gurobi / CPLEX**: Commercial high-performance MIP solvers (free academic licenses)
+- **SimPy**: Python discrete-event simulation framework
+- **SciPy optimize**: Linear programming, nonlinear optimization
+- **Pyomo**: Algebraic modeling language for optimization in Python
+- **AMPL**: Commercial algebraic modeling language

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