custom-component

REINVENT4 Custom Scoring Component

Write a comp_*.py plugin file that REINVENT4 discovers at runtime via namespace packages. No MCP server needed — write the file directly with the Write tool.

Workflow — New Component

1. Gather requirements

Ask the user:

• What does this component score? (e.g., "predict pIC50 using my QSAR model")
• What configurable inputs does it need? (names, types)
• RDKit Mol objects or raw SMILES? (molcache vs raw)
• Standard score, filter, or penalty?
  • __component (default): contributes to the aggregated score
  • filter: zeros the entire stage score if this component returns 0
  • penalty: multiplier on the total score
• Any external dependencies? (torch, scikit-learn, etc.)

2. Choose the output directory

Default: reinvent_plugins/components/ inside the REINVENT4 package (or a directory on PYTHONPATH). No __init__.py files must exist in reinvent_plugins/ or components/.

# Find the installed reinvent_plugins location:
python -c "import reinvent_plugins; print(reinvent_plugins.__path__)"

If the user has a custom plugins dir, confirm it is on PYTHONPATH:

export PYTHONPATH=/path/to/plugins_parent:$PYTHONPATH

3. Write the plugin file

Use the Write tool to create <components_dir>/comp_<snake_name>.py. File name must start with comp_. Use $0 (PascalCase) for the class name.

Template — with molcache (receives List[Chem.Mol]):

"""comp_<snake_name>.py — <description>"""
from __future__ import annotations
from dataclasses import dataclass
from typing import List

import numpy as np
from rdkit.Chem import Mol

from reinvent_plugins.components.component_results import ComponentResults
from reinvent_plugins.mol_cache import molcache
from reinvent_plugins.normalize import add_tag


@add_tag("__parameters")
@dataclass
class Parameters:
    # Each field must be List[T] — REINVENT4 collects per-endpoint params into lists
    model_path: List[str]      # example: path to a saved model file
    # threshold: List[float]   # add more as needed


@add_tag("__component")   # change to "filter" or "penalty" if needed
class <ClassName>:
    def __init__(self, params: Parameters):
        # Unpack the first endpoint's params (index 0)
        self.model_path = params.model_path[0]
        # Load model once here, e.g.:
        # import joblib
        # self.model = joblib.load(self.model_path)

    @molcache   # remove decorator if use_molcache=False (receives List[str] instead)
    def __call__(self, mols: List[Mol]) -> ComponentResults:
        scores = []
        for mol in mols:
            if mol is None:
                scores.append(np.nan)
                continue
            # --- implement scoring here ---
            # score = self.model.predict([get_fingerprint(mol)])[0]
            score = 0.0   # TODO: replace with real logic
            scores.append(score)
        return ComponentResults([np.array(scores, dtype=float)])