m8flow 1.0.1 → 1.1.0

package/bundled/backend/templates.py

@@ -1,745 +1,2907 @@
-"""Pre-built node templates. Each template is just Python source defining `def run(...)`."""
-
-# ── Data ──────────────────────────────────────────────────────────────────────
-
-CSV_LOADER = '''import pandas as pd
-from typing import Annotated
-
-def run(file_path: Annotated[str, "file"] = "data.csv") -> dict:
-    df = pd.read_csv(file_path)
-    return {"data": df}
-'''
-
-CSV_EXPORTER = '''import pandas as pd
-import numpy as np
-import os
-from typing import Annotated
-
-def run(
-    data=None,
-    y_pred=None,
-    y_test=None,
-    file_path: Annotated[str, "file"] = "output.csv",
-) -> dict:
-    """Export any data to CSV. Accepts a DataFrame, or y_pred/y_test arrays from a model node."""
-    if data is None:
-        if y_pred is not None and y_test is not None:
-            data = pd.DataFrame({"y_test": np.asarray(y_test).ravel(), "y_pred": np.asarray(y_pred).ravel()})
-        elif y_pred is not None:
-            data = pd.DataFrame({"predictions": np.asarray(y_pred).ravel()})
-        else:
-            raise ValueError("Provide 'data' (DataFrame) or connect a model node (y_pred/y_test)")
-    if isinstance(data, (np.ndarray, list)):
-        data = pd.DataFrame({"value": np.asarray(data).ravel()})
-    if not isinstance(data, pd.DataFrame):
-        data = pd.DataFrame(data)
-    data.to_csv(file_path, index=False)
-    return {"status": "saved", "path": os.path.abspath(file_path), "rows": len(data)}
-'''
-
-# ── EDA ───────────────────────────────────────────────────────────────────────
-
-EDA = '''import pandas as pd
-import numpy as np
-
-def run(data) -> dict:
-    """Exploratory Data Analysis. Always passes 'data' through so it can be chained."""
-    df = data.copy() if hasattr(data, "copy") else pd.DataFrame(data)
-
-    shape = list(df.shape)
-    dtypes = {col: str(dt) for col, dt in df.dtypes.items()}
-
-    # Missing values
-    miss = df.isnull().sum()
-    missing = {
-        col: {"count": int(miss[col]), "pct": round(float(miss[col] / len(df) * 100), 2)}
-        for col in df.columns if miss[col] > 0
-    }
-
-    # Numeric summary
-    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
-    numeric_summary = {}
-    for col in num_cols:
-        s = df[col]
-        numeric_summary[col] = {
-            "mean":   round(float(s.mean()), 4),
-            "median": round(float(s.median()), 4),
-            "std":    round(float(s.std()), 4),
-            "min":    round(float(s.min()), 4),
-            "max":    round(float(s.max()), 4),
-            "skew":   round(float(s.skew()), 4),
-        }
-
-    # Categorical summary
-    cat_cols = df.select_dtypes(include=["object", "category"]).columns.tolist()
-    categorical_summary = {}
-    for col in cat_cols[:8]:
-        vc = df[col].value_counts()
-        categorical_summary[col] = {
-            "unique": int(df[col].nunique()),
-            "top":    str(vc.index[0]) if len(vc) else "",
-            "top_count": int(vc.iloc[0]) if len(vc) else 0,
-        }
-
-    # Correlations (top 10 pairs by absolute value)
-    correlations = {}
-    if len(num_cols) >= 2:
-        corr = df[num_cols].corr()
-        pairs = []
-        for i in range(len(num_cols)):
-            for j in range(i + 1, len(num_cols)):
-                a, b = num_cols[i], num_cols[j]
-                val = float(corr.loc[a, b])
-                if not (val != val):  # skip NaN
-                    pairs.append((abs(val), a, b, val))
-        pairs.sort(reverse=True)
-        correlations = {f"{a}—{b}": round(v, 4) for _, a, b, v in pairs[:10]}
-
-    return {
-        "data": df,                          # pass-through so chained nodes get the DataFrame
-        "shape": shape,
-        "dtypes": dtypes,
-        "missing": missing,
-        "numeric_summary": numeric_summary,
-        "categorical_summary": categorical_summary,
-        "correlations": correlations,
-    }
-'''
-
-# ── Preprocessing ─────────────────────────────────────────────────────────────
-
-DATA_CLEANING = '''import pandas as pd
-
-def run(data, strategy: str = "drop", fill_value: float = 0.0) -> dict:
-    df = data.copy()
-    if strategy == "fill":
-        df = df.fillna(fill_value)
-    else:
-        df = df.dropna()
-    return {"data": df}
-'''
-
-LABEL_ENCODER = '''from sklearn.preprocessing import LabelEncoder
-import pandas as pd
-
-def run(data, columns: str = "") -> dict:
-    """Encode categorical columns. Leave columns blank to encode all object columns."""
-    df = data.copy()
-    encoders = {}
-    cols = [c.strip() for c in columns.split(",") if c.strip()] if columns.strip() else \
-           df.select_dtypes(include=["object", "category"]).columns.tolist()
-    for col in cols:
-        if col in df.columns:
-            le = LabelEncoder()
-            df[col] = le.fit_transform(df[col].astype(str))
-            encoders[col] = list(le.classes_)
-    return {"data": df, "encoders": encoders}
-'''
-
-ONE_HOT_ENCODER = '''import pandas as pd
-
-def run(data, columns: str = "") -> dict:
-    """One-hot encode categorical columns. Leave columns blank to encode all object/category columns."""
-    df = data.copy()
-    cols = [c.strip() for c in columns.split(",") if c.strip()] if columns.strip() else \
-           df.select_dtypes(include=["object", "category"]).columns.tolist()
-    if cols:
-        df = pd.get_dummies(df, columns=cols, drop_first=False)
-        # Convert boolean columns produced by get_dummies to int (0/1) for sklearn
-        bool_cols = df.select_dtypes(include=["bool"]).columns.tolist()
-        if bool_cols:
-            df[bool_cols] = df[bool_cols].astype(int)
-    return {"data": df}
-'''
-
-TRAIN_TEST_SPLIT = '''from sklearn.model_selection import train_test_split as _split
-from typing import Annotated
-
-def run(
-    data,
-    target_column: Annotated[str, "column"] = "target",
-    test_size: float = 0.2,
-    random_state: int = 42,
-) -> dict:
-    X = data.drop(columns=[target_column])
-    y = data[target_column]
-    X_train, X_test, y_train, y_test = _split(
-        X, y, test_size=test_size, random_state=random_state
-    )
-    return {"X_train": X_train, "X_test": X_test, "y_train": y_train, "y_test": y_test}
-'''
-
-STANDARD_SCALER = '''from sklearn.preprocessing import StandardScaler
-
-def run(X_train, X_test, y_train, y_test) -> dict:
-    scaler = StandardScaler()
-    X_train_s = scaler.fit_transform(X_train)
-    X_test_s = scaler.transform(X_test)
-    return {"X_train": X_train_s, "X_test": X_test_s, "y_train": y_train, "y_test": y_test}
-'''
-
-MIN_MAX_SCALER = '''from sklearn.preprocessing import MinMaxScaler
-
-def run(X_train, X_test, y_train, y_test) -> dict:
-    scaler = MinMaxScaler()
-    X_train_s = scaler.fit_transform(X_train)
-    X_test_s = scaler.transform(X_test)
-    return {"X_train": X_train_s, "X_test": X_test_s, "y_train": y_train, "y_test": y_test}
-'''
-
-PCA = '''from sklearn.decomposition import PCA
-
-def run(X_train, X_test, y_train, y_test, n_components: int = 2) -> dict:
-    pca = PCA(n_components=n_components)
-    X_train_p = pca.fit_transform(X_train)
-    X_test_p = pca.transform(X_test)
-    explained = float(sum(pca.explained_variance_ratio_))
-    return {"X_train": X_train_p, "X_test": X_test_p, "y_train": y_train, "y_test": y_test,
-            "explained_variance": round(explained, 4)}
-'''
-
-# ── Shared CV helper (inlined into each template to stay self-contained) ────────
-#
-#   def _run_cv(model, X_train, y_train, cv_folds, scoring):
-#       scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring=scoring)
-#       return {"cv_mean": round(float(scores.mean()), 4),
-#               "cv_std":  round(float(scores.std()), 4),
-#               "cv_scores": [round(float(s), 4) for s in scores]}
-#
-# ── Classifier models ─────────────────────────────────────────────────────────
-
-LOGISTIC_REGRESSION = '''from sklearn.linear_model import LogisticRegression
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    C: float = 1.0, max_iter: int = 200, random_state: int = 42,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    model = LogisticRegression(C=C, max_iter=max_iter, random_state=random_state)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-RANDOM_FOREST_CLASSIFIER = '''from sklearn.ensemble import RandomForestClassifier
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    n_estimators: int = 100, max_depth: int = 0, random_state: int = 42,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    md = max_depth if max_depth > 0 else None
-    model = RandomForestClassifier(n_estimators=n_estimators, max_depth=md, random_state=random_state)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-GRADIENT_BOOSTING_CLASSIFIER = '''from sklearn.ensemble import GradientBoostingClassifier
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    n_estimators: int = 100, learning_rate: float = 0.1, random_state: int = 42,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    model = GradientBoostingClassifier(n_estimators=n_estimators, learning_rate=learning_rate, random_state=random_state)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-DECISION_TREE_CLASSIFIER = '''from sklearn.tree import DecisionTreeClassifier
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    max_depth: int = 0, random_state: int = 42,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    md = max_depth if max_depth > 0 else None
-    model = DecisionTreeClassifier(max_depth=md, random_state=random_state)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-SVM_CLASSIFIER = '''from sklearn.svm import SVC
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    C: float = 1.0, kernel: str = "rbf",
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    model = SVC(C=C, kernel=kernel)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-KNN_CLASSIFIER = '''from sklearn.neighbors import KNeighborsClassifier
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    n_neighbors: int = 5,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    model = KNeighborsClassifier(n_neighbors=n_neighbors)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-# ── Regressor models ──────────────────────────────────────────────────────────
-
-LINEAR_REGRESSION = '''from sklearn.linear_model import LinearRegression
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    model = LinearRegression()
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-RANDOM_FOREST_REGRESSOR = '''from sklearn.ensemble import RandomForestRegressor
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    n_estimators: int = 100, max_depth: int = 0, random_state: int = 42,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    md = max_depth if max_depth > 0 else None
-    model = RandomForestRegressor(n_estimators=n_estimators, max_depth=md, random_state=random_state)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-GRADIENT_BOOSTING_REGRESSOR = '''from sklearn.ensemble import GradientBoostingRegressor
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    n_estimators: int = 100, learning_rate: float = 0.1, random_state: int = 42,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    model = GradientBoostingRegressor(n_estimators=n_estimators, learning_rate=learning_rate, random_state=random_state)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-DECISION_TREE_REGRESSOR = '''from sklearn.tree import DecisionTreeRegressor
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    max_depth: int = 0, random_state: int = 42,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    md = max_depth if max_depth > 0 else None
-    model = DecisionTreeRegressor(max_depth=md, random_state=random_state)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-SVM_REGRESSOR = '''from sklearn.svm import SVR
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    C: float = 1.0, kernel: str = "rbf",
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    model = SVR(C=C, kernel=kernel)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-KNN_REGRESSOR = '''from sklearn.neighbors import KNeighborsRegressor
-from sklearn.model_selection import cross_val_score
-
-def run(
-    X_train, X_test, y_train,
-    n_neighbors: int = 5,
-    cross_validation: bool = False, cv_folds: int = 5,
-) -> dict:
-    model = KNeighborsRegressor(n_neighbors=n_neighbors)
-    if cross_validation:
-        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        return {"model": model, "y_pred": y_pred,
-                "cv_mean": round(float(scores.mean()), 4),
-                "cv_std":  round(float(scores.std()), 4),
-                "cv_scores": [round(float(s), 4) for s in scores]}
-    model.fit(X_train, y_train)
-    y_pred = model.predict(X_test)
-    return {"model": model, "y_pred": y_pred}
-'''
-
-# ── Evaluation ────────────────────────────────────────────────────────────────
-
-ACCURACY = '''from sklearn.metrics import accuracy_score
-
-def run(y_test, y_pred) -> dict:
-    return {"accuracy": float(accuracy_score(y_test, y_pred))}
-'''
-
-CLASSIFICATION_REPORT = '''from sklearn.metrics import (
-    accuracy_score, f1_score, precision_score, recall_score,
-    confusion_matrix, classification_report,
-)
-
-def run(y_test, y_pred) -> dict:
-    return {
-        "accuracy":   round(float(accuracy_score(y_test, y_pred)), 4),
-        "f1_score":   round(float(f1_score(y_test, y_pred, average="weighted", zero_division=0)), 4),
-        "precision":  round(float(precision_score(y_test, y_pred, average="weighted", zero_division=0)), 4),
-        "recall":     round(float(recall_score(y_test, y_pred, average="weighted", zero_division=0)), 4),
-        "confusion_matrix": confusion_matrix(y_test, y_pred).tolist(),
-        "class_report": classification_report(y_test, y_pred, output_dict=True, zero_division=0),
-    }
-'''
-
-VALIDATION_REPORT = '''from sklearn.model_selection import cross_validate
-import numpy as np
-
-def run(model, X_train, y_train, cv_folds: int = 5) -> dict:
-    """Run K-Fold cross validation and generate a robust validation report."""
-    # Using macro averages for multiclass compatibility
-    scoring = ['accuracy', 'precision_macro', 'recall_macro', 'f1_macro']
-    
-    # Catching cases where model might not be a classifier (though typically it will be here)
-    try:
-        scores = cross_validate(model, X_train, y_train, cv=cv_folds, scoring=scoring)
-        return {
-            "cv_folds": cv_folds,
-            "mean_accuracy":  round(float(np.mean(scores['test_accuracy'])), 4),
-            "std_accuracy":   round(float(np.std(scores['test_accuracy'])), 4),
-            "mean_precision": round(float(np.mean(scores['test_precision_macro'])), 4),
-            "mean_recall":    round(float(np.mean(scores['test_recall_macro'])), 4),
-            "mean_f1":        round(float(np.mean(scores['test_f1_macro'])), 4),
-        }
-    except Exception as e:
-        # Fallback for regressors
-        scores = cross_validate(model, X_train, y_train, cv=cv_folds, scoring=['r2', 'neg_mean_squared_error'])
-        return {
-            "cv_folds": cv_folds,
-            "mean_r2": round(float(np.mean(scores['test_r2'])), 4),
-            "mean_mse": round(float(np.mean(-scores['test_neg_mean_squared_error'])), 4),
-        }
-'''
-
-REGRESSION_METRICS = '''from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
-import numpy as np
-
-def run(y_test, y_pred) -> dict:
-    mse = float(mean_squared_error(y_test, y_pred))
-    return {
-        "mse":  round(mse, 4),
-        "rmse": round(float(np.sqrt(mse)), 4),
-        "mae":  round(float(mean_absolute_error(y_test, y_pred)), 4),
-        "r2":   round(float(r2_score(y_test, y_pred)), 4),
-    }
-'''
-
-FEATURE_IMPORTANCE = '''import numpy as np
-
-def run(model, X_train) -> dict:
-    """Extract feature importances from any tree-based model."""
-    if not hasattr(model, "feature_importances_"):
-        raise ValueError(f"{type(model).__name__} has no feature_importances_. Use RF, GBM, or DT.")
-    imps = model.feature_importances_
-    names = list(X_train.columns) if hasattr(X_train, "columns") else [f"f{i}" for i in range(len(imps))]
-    pairs = sorted(zip(imps, names), reverse=True)
-    top = min(20, len(pairs))
-    return {
-        "feature_importances": {name: round(float(imp), 6) for imp, name in pairs[:top]},
-        "top_feature": pairs[0][1],
-        "top_importance": round(float(pairs[0][0]), 6),
-    }
-'''
-
-AUTO_ML = '''from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import accuracy_score
-
-def run(X_train, X_test, y_train, y_test) -> dict:
-    candidates = {
-        "Random Forest":       RandomForestClassifier(n_estimators=100, random_state=42),
-        "Gradient Boosting":   GradientBoostingClassifier(random_state=42),
-        "Logistic Regression": LogisticRegression(max_iter=1000, random_state=42),
-    }
-    scores = {}
-    best_name, best_score, best_model, best_pred = "", -1.0, None, None
-    for name, mdl in candidates.items():
-        mdl.fit(X_train, y_train)
-        preds = mdl.predict(X_test)
-        score = float(accuracy_score(y_test, preds))
-        scores[name] = round(score, 4)
-        if score > best_score:
-            best_score, best_name, best_model, best_pred = score, name, mdl, preds
-    return {
-        "model": best_model,
-        "y_pred": best_pred,
-        "best_algorithm": best_name,
-        "accuracy": round(best_score, 4),
-        "all_scores": scores,
-    }
-'''
-
-
-EDA_HISTOGRAM = '''import pandas as pd
-import numpy as np
-from typing import Annotated
-
-def run(data, column: Annotated[str, "column"] = "price", bins: int = 20) -> dict:
-    """Distribution histogram for a single numeric column."""
-    series = data[column].dropna()
-    counts, edges = np.histogram(series, bins=bins)
-    return {
-        "histogram": {
-            "column": column,
-            "counts": counts.tolist(),
-            "bin_edges": [round(float(e), 2) for e in edges.tolist()],
-            "mean":   round(float(series.mean()), 2),
-            "median": round(float(series.median()), 2),
-            "std":    round(float(series.std()), 2),
-            "min":    round(float(series.min()), 2),
-            "max":    round(float(series.max()), 2),
-        }
-    }
-'''
-
-EDA_CORRELATION = '''import pandas as pd
-import numpy as np
-
-def run(data) -> dict:
-    """Full correlation matrix for all numeric columns."""
-    num_df = data.select_dtypes(include=[np.number])
-    corr = num_df.corr().round(3)
-    matrix = []
-    for row in corr.values.tolist():
-        matrix.append([None if (v != v) else round(v, 3) for v in row])
-    return {
-        "correlation_matrix": {
-            "columns": list(corr.columns),
-            "matrix": matrix,
-        }
-    }
-'''
-
-EDA_VALUE_COUNTS = '''import pandas as pd
-from typing import Annotated
-
-def run(data, column: Annotated[str, "column"] = "mainroad", top_n: int = 10) -> dict:
-    """Value counts for a categorical column."""
-    vc = data[column].value_counts().head(top_n)
-    return {
-        "value_counts": {
-            "column": column,
-            "labels": [str(l) for l in vc.index.tolist()],
-            "counts": vc.values.tolist(),
-            "total": int(len(data)),
-        }
-    }
-'''
-
-EDA_BOX_PLOT = '''import pandas as pd
-import numpy as np
-from typing import Annotated
-
-def run(data, column: Annotated[str, "column"] = "price") -> dict:
-    """Box plot statistics (min, Q1, median, Q3, max, outliers) for a column."""
-    s = data[column].dropna()
-    q1, q3 = float(s.quantile(0.25)), float(s.quantile(0.75))
-    iqr = q3 - q1
-    outliers = s[(s < q1 - 1.5*iqr) | (s > q3 + 1.5*iqr)]
-    return {
-        "box_plot": {
-            "column": column,
-            "min":    round(float(s.min()), 2),
-            "q1":     round(q1, 2),
-            "median": round(float(s.median()), 2),
-            "q3":     round(q3, 2),
-            "max":    round(float(s.max()), 2),
-            "mean":   round(float(s.mean()), 2),
-            "iqr":    round(iqr, 2),
-            "outlier_count": int(len(outliers)),
-            "whisker_low":  round(float(max(s.min(), q1 - 1.5*iqr)), 2),
-            "whisker_high": round(float(min(s.max(), q3 + 1.5*iqr)), 2),
-        }
-    }
-'''
-
-PREDICT = '''import pandas as pd
-import json
-
-def run(model, feature_json: str = "{}") -> dict:
-    """Predict from a trained model. Enter feature values as a JSON string.
-    Example: {"area": 7000, "bedrooms": 3, "bathrooms": 2, "stories": 2,
-              "mainroad": 1, "guestroom": 0, "basement": 0,
-              "hotwaterheating": 0, "airconditioning": 1, "parking": 2,
-              "prefarea": 0, "furnishingstatus": 1}
-    """
-    features = json.loads(feature_json) if feature_json.strip() else {}
-    if not features:
-        raise ValueError("Enter feature values as JSON in the feature_json field")
-    df = pd.DataFrame([features])
-    prediction = model.predict(df)
-    result = prediction[0]
-    scalar = float(result) if hasattr(result, "__float__") else str(result)
-    return {
-        "prediction": scalar,
-        "features_used": features,
-    }
-'''
-
-
-TEMPLATES: list[dict] = [
-    # Data
-    {"id": "csv_loader",                  "label": "CSV Loader",              "category": "Data",          "code": CSV_LOADER},
-    {"id": "csv_exporter",                "label": "CSV Exporter",            "category": "Data",          "code": CSV_EXPORTER},
-    {"id": "eda",                         "label": "EDA",                     "category": "Data",          "code": EDA},
-    {"id": "eda_histogram",               "label": "Histogram",               "category": "Visualize",     "code": EDA_HISTOGRAM},
-    {"id": "eda_correlation",             "label": "Correlation Matrix",      "category": "Visualize",     "code": EDA_CORRELATION},
-    {"id": "eda_value_counts",            "label": "Value Counts",            "category": "Visualize",     "code": EDA_VALUE_COUNTS},
-    {"id": "eda_box_plot",                "label": "Box Plot",                "category": "Visualize",     "code": EDA_BOX_PLOT},
-    {"id": "predict",                     "label": "Predict",                 "category": "Visualize",     "code": PREDICT},
-    # Preprocessing
-    {"id": "data_cleaning",               "label": "Data Cleaning",           "category": "Preprocessing", "code": DATA_CLEANING},
-    {"id": "label_encoder",               "label": "Label Encoder",           "category": "Preprocessing", "code": LABEL_ENCODER},
-    {"id": "one_hot_encoder",             "label": "One-Hot Encoder",         "category": "Preprocessing", "code": ONE_HOT_ENCODER},
-    {"id": "train_test_split",            "label": "Train/Test Split",        "category": "Preprocessing", "code": TRAIN_TEST_SPLIT},
-    {"id": "standard_scaler",             "label": "Standard Scaler",         "category": "Preprocessing", "code": STANDARD_SCALER},
-    {"id": "min_max_scaler",              "label": "Min-Max Scaler",          "category": "Preprocessing", "code": MIN_MAX_SCALER},
-    {"id": "pca",                         "label": "PCA",                     "category": "Preprocessing", "code": PCA},
-    # Classifiers
-    {"id": "logistic_regression",         "label": "Logistic Regression",     "category": "Classifiers",   "code": LOGISTIC_REGRESSION},
-    {"id": "random_forest_classifier",    "label": "RF Classifier",           "category": "Classifiers",   "code": RANDOM_FOREST_CLASSIFIER},
-    {"id": "gradient_boosting_classifier","label": "GB Classifier",           "category": "Classifiers",   "code": GRADIENT_BOOSTING_CLASSIFIER},
-    {"id": "decision_tree_classifier",    "label": "DT Classifier",           "category": "Classifiers",   "code": DECISION_TREE_CLASSIFIER},
-    {"id": "svm_classifier",              "label": "SVM Classifier",          "category": "Classifiers",   "code": SVM_CLASSIFIER},
-    {"id": "knn_classifier",              "label": "KNN Classifier",          "category": "Classifiers",   "code": KNN_CLASSIFIER},
-    # Regressors
-    {"id": "linear_regression",           "label": "Linear Regression",       "category": "Regressors",    "code": LINEAR_REGRESSION},
-    {"id": "random_forest_regressor",     "label": "RF Regressor",            "category": "Regressors",    "code": RANDOM_FOREST_REGRESSOR},
-    {"id": "gradient_boosting_regressor", "label": "GB Regressor",            "category": "Regressors",    "code": GRADIENT_BOOSTING_REGRESSOR},
-    {"id": "decision_tree_regressor",     "label": "DT Regressor",            "category": "Regressors",    "code": DECISION_TREE_REGRESSOR},
-    {"id": "svm_regressor",               "label": "SVM Regressor",           "category": "Regressors",    "code": SVM_REGRESSOR},
-    {"id": "knn_regressor",               "label": "KNN Regressor",           "category": "Regressors",    "code": KNN_REGRESSOR},
-    # Evaluation
-    {"id": "accuracy",                    "label": "Accuracy",                "category": "Evaluation",    "code": ACCURACY},
-    {"id": "classification_report",       "label": "Classification Report",   "category": "Evaluation",    "code": CLASSIFICATION_REPORT},
-    {"id": "validation_report",           "label": "Validation Report",       "category": "Evaluation",    "code": VALIDATION_REPORT},
-    {"id": "regression_metrics",          "label": "Regression Metrics",      "category": "Evaluation",    "code": REGRESSION_METRICS},
-    {"id": "feature_importance",          "label": "Feature Importance",      "category": "Evaluation",    "code": FEATURE_IMPORTANCE},
-    {"id": "auto_ml",                     "label": "AutoML",                  "category": "Evaluation",    "code": AUTO_ML},
-]
-
-
-def get_template(template_id: str) -> dict | None:
-    for t in TEMPLATES:
-        if t["id"] == template_id:
-            return t
-    return None
+"""Pre-built node templates. Each template is just Python source defining `def run(...)`."""
+
+# ── Data ──────────────────────────────────────────────────────────────────────
+
+CSV_LOADER = '''import pandas as pd
+import os
+from typing import Annotated
+
+def run(file_path: Annotated[str, "file"] = "data.csv") -> dict:
+    """Loads a CSV file. Looks in the storage directory if a relative path is provided."""
+    # Resolve path
+    if not os.path.isabs(file_path):
+        storage_dir = os.environ.get("M8FLOW_UPLOAD_DIR") or os.path.abspath("uploads")
+        potential_path = os.path.join(storage_dir, file_path)
+        if os.path.exists(potential_path):
+            file_path = potential_path
+            
+    df = pd.read_csv(file_path)
+    return {"data": df}
+'''
+
+CSV_EXPORTER = '''import pandas as pd
+import numpy as np
+import os
+from typing import Annotated
+
+def run(
+    data: Annotated[pd.DataFrame, "dataframe"] = None,
+    y_pred: Annotated[np.ndarray, "array"] = None,
+    y_test: Annotated[np.ndarray, "array"] = None,
+    file_path: Annotated[str, "file"] = "output.csv"
+) -> dict:
+    """Exports data to a CSV file. Supports DataFrames or Model predictions."""
+    # 1. Resolve data
+    if data is None:
+        if y_pred is not None and y_test is not None:
+            data = pd.DataFrame({"y_test": np.asarray(y_test).ravel(), "y_pred": np.asarray(y_pred).ravel()})
+        elif y_pred is not None:
+            data = pd.DataFrame({"predictions": np.asarray(y_pred).ravel()})
+        else:
+            return {"status": "error", "error": "No data or predictions provided to export"}
+    
+    if not isinstance(data, pd.DataFrame):
+        try:
+            data = pd.DataFrame(data)
+        except Exception as e:
+            return {"status": "error", "error": f"Failed to convert input to DataFrame: {e}"}
+
+    # 2. Resolve output path
+    # If it's just a filename, try to save it in the storage directory if possible
+    # We look for M8FLOW_UPLOAD_DIR or default 'uploads'
+    storage_dir = os.environ.get("M8FLOW_UPLOAD_DIR") or os.path.abspath("uploads")
+    if not os.path.isabs(file_path):
+        os.makedirs(storage_dir, exist_ok=True)
+        full_path = os.path.join(storage_dir, file_path)
+    else:
+        full_path = file_path
+            
+    data.to_csv(full_path, index=False)
+    return {"status": "saved", "path": full_path, "rows": len(data)}
+'''
+
+# ── EDA ───────────────────────────────────────────────────────────────────────
+
+EDA = '''import pandas as pd
+import numpy as np
+
+def run(data) -> dict:
+    """Exploratory Data Analysis. Always passes 'data' through so it can be chained."""
+    df = data.copy() if hasattr(data, "copy") else pd.DataFrame(data)
+
+    shape = list(df.shape)
+    dtypes = {col: str(dt) for col, dt in df.dtypes.items()}
+
+    # Missing values
+    miss = df.isnull().sum()
+    missing = {
+        col: {"count": int(miss[col]), "pct": round(float(miss[col] / len(df) * 100), 2)}
+        for col in df.columns if miss[col] > 0
+    }
+
+    # Numeric summary
+    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    numeric_summary = {}
+    for col in num_cols:
+        s = df[col]
+        numeric_summary[col] = {
+            "mean":   round(float(s.mean()), 4),
+            "median": round(float(s.median()), 4),
+            "std":    round(float(s.std()), 4),
+            "min":    round(float(s.min()), 4),
+            "max":    round(float(s.max()), 4),
+            "skew":   round(float(s.skew()), 4),
+        }
+
+    # Categorical summary
+    cat_cols = df.select_dtypes(include=["object", "category"]).columns.tolist()
+    categorical_summary = {}
+    for col in cat_cols[:8]:
+        vc = df[col].value_counts()
+        categorical_summary[col] = {
+            "unique": int(df[col].nunique()),
+            "top":    str(vc.index[0]) if len(vc) else "",
+            "top_count": int(vc.iloc[0]) if len(vc) else 0,
+        }
+
+    # Correlations (top 10 pairs by absolute value)
+    correlations = {}
+    if len(num_cols) >= 2:
+        corr = df[num_cols].corr()
+        pairs = []
+        for i in range(len(num_cols)):
+            for j in range(i + 1, len(num_cols)):
+                a, b = num_cols[i], num_cols[j]
+                val = float(corr.loc[a, b])
+                if not (val != val):  # skip NaN
+                    pairs.append((abs(val), a, b, val))
+        pairs.sort(reverse=True)
+        correlations = {f"{a}—{b}": round(v, 4) for _, a, b, v in pairs[:10]}
+
+    return {
+        "data": df,                          # pass-through so chained nodes get the DataFrame
+        "shape": shape,
+        "dtypes": dtypes,
+        "missing": missing,
+        "numeric_summary": numeric_summary,
+        "categorical_summary": categorical_summary,
+        "correlations": correlations,
+    }
+'''
+
+# ── Preprocessing ─────────────────────────────────────────────────────────────
+
+SMART_OUTLIER_REMOVER = '''import pandas as pd
+import numpy as np
+
+def run(
+    data,
+    multiplier: float = 1.5,
+    method: str = "drop",   # choices: drop | clip
+) -> dict:
+    """Remove or clip outliers using the IQR method across all numeric columns."""
+    df = data.copy()
+    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    removed_per_col = {}
+    for col in num_cols:
+        q1 = df[col].quantile(0.25)
+        q3 = df[col].quantile(0.75)
+        iqr = q3 - q1
+        lo  = q1 - multiplier * iqr
+        hi  = q3 + multiplier * iqr
+        outliers = ((df[col] < lo) | (df[col] > hi)).sum()
+        removed_per_col[col] = int(outliers)
+        if method == "clip":
+            df[col] = df[col].clip(lower=lo, upper=hi)
+        else:  # drop
+            df = df[(df[col] >= lo) & (df[col] <= hi)]
+    return {
+        "data": df,
+        "rows_before": len(data),
+        "rows_after":  len(df),
+        "outliers_removed_per_col": removed_per_col,
+    }
+'''
+
+ADVANCED_IMPUTER = '''import pandas as pd
+import numpy as np
+
+def run(
+    data,
+    strategy: str = "knn",   # choices: knn | mice
+    n_neighbors: int = 5,
+) -> dict:
+    """Smart missing-value imputation: KNNImputer or IterativeImputer (MICE)."""
+    from sklearn.impute import KNNImputer
+    df = data.copy()
+    num_cols  = df.select_dtypes(include=[np.number]).columns.tolist()
+    cat_cols  = df.select_dtypes(exclude=[np.number]).columns.tolist()
+    missing_before = int(df[num_cols].isnull().sum().sum())
+    if strategy == "mice":
+        from sklearn.experimental import enable_iterative_imputer  # noqa: F401
+        from sklearn.impute import IterativeImputer
+        imputer = IterativeImputer(max_iter=10, random_state=42)
+    else:
+        imputer = KNNImputer(n_neighbors=n_neighbors)
+    df[num_cols] = imputer.fit_transform(df[num_cols])
+    # Fill remaining categorical columns with mode
+    for col in cat_cols:
+        if df[col].isnull().any():
+            df[col] = df[col].fillna(df[col].mode()[0])
+    return {
+        "data": df,
+        "strategy": strategy,
+        "missing_before": missing_before,
+        "missing_after":  int(df[num_cols].isnull().sum().sum()),
+    }
+'''
+
+SKEWNESS_FIXER = '''import pandas as pd
+import numpy as np
+
+def run(
+    data,
+    threshold: float = 0.75,
+) -> dict:
+    """Detect skewed numeric columns and apply log1p or sqrt transformation."""
+    df = data.copy()
+    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    transformed = {}
+    for col in num_cols:
+        skew = float(df[col].skew())
+        if abs(skew) > threshold:
+            if df[col].min() >= 0:
+                if skew > 2:  # heavy skew → log1p
+                    df[col] = np.log1p(df[col])
+                    transformed[col] = {"skew_before": round(skew, 4), "transform": "log1p"}
+                else:  # moderate skew → sqrt
+                    df[col] = np.sqrt(df[col])
+                    transformed[col] = {"skew_before": round(skew, 4), "transform": "sqrt"}
+            else:  # column has negatives → shift then log1p
+                shift = abs(df[col].min()) + 1
+                df[col] = np.log1p(df[col] + shift)
+                transformed[col] = {"skew_before": round(skew, 4), "transform": f"log1p(x+{round(shift,2)})"}
+    return {
+        "data": df,
+        "columns_transformed": transformed,
+        "n_transformed": len(transformed),
+    }
+'''
+
+HIGH_CARDINALITY_ENCODER = '''import pandas as pd
+import numpy as np
+from typing import Annotated
+
+def run(
+    data,
+    column: Annotated[str, "column"] = "city",
+    target: Annotated[str, "column"] = "target",
+    smoothing: float = 1.0,
+) -> dict:
+    """Target Encoding for high-cardinality columns (e.g. City, ZipCode).
+    Uses smoothed means to prevent overfitting on rare categories.
+    Supports comma-separated lists of columns."""
+    df = data.copy()
+    if target not in df.columns:
+        raise ValueError(f"Target column \'{target}\' not found in DataFrame.")
+    
+    global_mean = df[target].mean()
+    cols_to_encode = [c.strip() for c in column.split(",") if c.strip()]
+    stats_info = {}
+    
+    for col in cols_to_encode:
+        if col not in df.columns:
+            continue
+        stats = df.groupby(col)[target].agg(["mean", "count"])
+        # Smoothed target encoding formula
+        stats["smoothed"] = (
+            (stats["count"] * stats["mean"] + smoothing * global_mean)
+            / (stats["count"] + smoothing)
+        )
+        df[col] = df[col].map(stats["smoothed"]).fillna(global_mean)
+        stats_info[col] = int(len(stats))
+        
+    return {
+        "data": df,
+        "encoded_columns": cols_to_encode,
+        "target_column": target,
+        "categories_encoded_per_col": stats_info,
+        "global_mean": round(float(global_mean), 6),
+    }
+'''
+
+FEATURE_SCALER_ROBUST = '''import pandas as pd
+import numpy as np
+
+def run(data) -> dict:
+    """Scale numeric features with RobustScaler (median + IQR).
+    Unlike StandardScaler, it is not distorted by extreme outliers."""
+    from sklearn.preprocessing import RobustScaler
+    df = data.copy()
+    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    scaler = RobustScaler()
+    df[num_cols] = scaler.fit_transform(df[num_cols])
+    return {
+        "data": df,
+        "scaled_columns": num_cols,
+        "n_scaled": len(num_cols),
+    }
+'''
+
+MULTICOLLINEARITY_FILTER = '''import pandas as pd
+import numpy as np
+
+def run(
+    data,
+    threshold: float = 0.90,
+) -> dict:
+    """Drop features whose absolute Pearson correlation with any other feature exceeds threshold."""
+    df = data.copy()
+    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    corr_matrix = df[num_cols].corr().abs()
+    upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
+    to_drop = [col for col in upper.columns if any(upper[col] > threshold)]
+    highly_correlated_pairs = []
+    for col in to_drop:
+        partners = upper.index[upper[col] > threshold].tolist()
+        for partner in partners:
+            highly_correlated_pairs.append({
+                "dropped": col,
+                "correlated_with": partner,
+                "correlation": round(float(upper.loc[partner, col]), 4),
+            })
+    df = df.drop(columns=to_drop)
+    return {
+        "data": df,
+        "dropped_columns": to_drop,
+        "n_dropped": len(to_drop),
+        "highly_correlated_pairs": highly_correlated_pairs,
+        "remaining_features": df.shape[1],
+    }
+'''
+
+TEXT_CLEANER_BASIC = '''import pandas as pd
+import re
+from typing import Annotated
+
+def run(
+    data,
+    column: Annotated[str, "column"] = "text",
+    remove_stopwords: bool = True,
+) -> dict:
+    """Basic NLP text cleaning: lowercase, strip HTML, remove punctuation, remove stop words."""
+    df = data.copy()
+    if column not in df.columns:
+        raise ValueError(f"Column \'{column}\' not found in DataFrame.")
+    # Build stop-word set (use nltk if available, otherwise fall back to a minimal list)
+    stop_words = set()
+    if remove_stopwords:
+        try:
+            import nltk
+            try:
+                from nltk.corpus import stopwords
+                stop_words = set(stopwords.words("english"))
+            except LookupError:
+                nltk.download("stopwords", quiet=True)
+                from nltk.corpus import stopwords
+                stop_words = set(stopwords.words("english"))
+        except ImportError:
+            # Minimal fallback stop-word list if nltk is not installed
+            stop_words = {
+                "i","me","my","we","our","you","your","he","she","it","its",
+                "they","their","this","that","a","an","the","and","but","or",
+                "in","on","at","to","for","of","is","was","are","were","be",
+                "been","have","has","do","does","did","with","as","by","from",
+            }
+    def _clean(text):
+        if not isinstance(text, str):
+            return ""
+        text = text.lower()
+        text = re.sub(r"<[^>]+>", " ", text)          # remove HTML tags
+        text = re.sub(r"[^a-z0-9\s]", " ", text)      # remove punctuation
+        text = re.sub(r"\s+", " ", text).strip()       # collapse whitespace
+        if stop_words:
+            text = " ".join(w for w in text.split() if w not in stop_words)
+        return text
+    original_sample = str(df[column].iloc[0]) if len(df) else ""
+    df[column] = df[column].apply(_clean)
+    return {
+        "data": df,
+        "cleaned_column": column,
+        "sample_before": original_sample[:120],
+        "sample_after":  str(df[column].iloc[0])[:120] if len(df) else "",
+    }
+'''
+
+SMOTE_SAMPLER = '''import pandas as pd
+import numpy as np
+from typing import Annotated
+
+def run(
+    data,
+    target_column: Annotated[str, "column"] = "target",
+    random_state: int = 42,
+    k_neighbors: int = 5,
+) -> dict:
+    """Oversample the minority class to fix class imbalance using SMOTE.
+    Falls back to RandomOverSampler if imbalanced-learn is unavailable."""
+    df = data.copy()
+    if target_column not in df.columns:
+        raise ValueError(f"Target column \'{target_column}\' not found in DataFrame.")
+    X = df.drop(columns=[target_column])
+    y = df[target_column]
+    # Keep only numeric features for sampling
+    X_num = X.select_dtypes(include=[np.number])
+    class_counts_before = y.value_counts().to_dict()
+    sampler_used = None
+    try:
+        from imblearn.over_sampling import SMOTE
+        sampler = SMOTE(k_neighbors=k_neighbors, random_state=random_state)
+        sampler_used = "SMOTE"
+    except ImportError:
+        try:
+            from imblearn.over_sampling import RandomOverSampler
+            sampler = RandomOverSampler(random_state=random_state)
+            sampler_used = "RandomOverSampler (SMOTE unavailable)"
+        except ImportError:
+            # Pure-numpy fallback: duplicate minority rows
+            classes, counts = np.unique(y, return_counts=True)
+            majority_count = counts.max()
+            X_resampled, y_resampled = X_num.copy(), y.copy()
+            for cls, cnt in zip(classes, counts):
+                if cnt < majority_count:
+                    shortage = majority_count - cnt
+                    minority_rows = X_num[y == cls]
+                    minority_y    = y[y == cls]
+                    idx = np.random.RandomState(random_state).choice(len(minority_rows), shortage, replace=True)
+                    X_resampled = pd.concat([X_resampled, minority_rows.iloc[idx]], ignore_index=True)
+                    y_resampled = pd.concat([y_resampled, minority_y.iloc[idx]], ignore_index=True)
+            df_out = X_resampled.copy()
+            df_out[target_column] = y_resampled.values
+            return {
+                "data": df_out,
+                "sampler_used": "numpy_fallback",
+                "rows_before": len(data),
+                "rows_after":  len(df_out),
+                "class_distribution_before": {str(k): int(v) for k, v in class_counts_before.items()},
+                "class_distribution_after":  {str(k): int(v) for k, v in y_resampled.value_counts().items()},
+            }
+    X_res, y_res = sampler.fit_resample(X_num, y)
+    df_out = pd.DataFrame(X_res, columns=X_num.columns)
+    df_out[target_column] = y_res
+    return {
+        "data": df_out,
+        "sampler_used": sampler_used,
+        "rows_before": len(data),
+        "rows_after":  len(df_out),
+        "class_distribution_before": {str(k): int(v) for k, v in class_counts_before.items()},
+        "class_distribution_after":  {str(k): int(v) for k, v in pd.Series(y_res).value_counts().items()},
+    }
+'''
+
+DATA_CLEANING = '''import pandas as pd
+
+def run(data, strategy: str = "drop", fill_value: float = 0.0) -> dict:
+    df = data.copy()
+    if strategy == "fill":
+        df = df.fillna(fill_value)
+    else:
+        df = df.dropna()
+    return {"data": df}
+'''
+
+LABEL_ENCODER = '''from sklearn.preprocessing import LabelEncoder
+import pandas as pd
+
+def run(data, columns: str = "") -> dict:
+    """Encode categorical columns. Leave columns blank to encode all object columns."""
+    df = data.copy()
+    encoders = {}
+    cols = [c.strip() for c in columns.split(",") if c.strip()] if columns.strip() else \
+           df.select_dtypes(include=["object", "category"]).columns.tolist()
+    for col in cols:
+        if col in df.columns:
+            le = LabelEncoder()
+            df[col] = le.fit_transform(df[col].astype(str))
+            encoders[col] = list(le.classes_)
+    return {"data": df, "encoders": encoders}
+'''
+
+ONE_HOT_ENCODER = '''import pandas as pd
+
+def run(data, columns: str = "") -> dict:
+    """One-hot encode categorical columns. Leave columns blank to encode all object/category columns."""
+    df = data.copy()
+    cols = [c.strip() for c in columns.split(",") if c.strip()] if columns.strip() else \
+           df.select_dtypes(include=["object", "category"]).columns.tolist()
+    if cols:
+        df = pd.get_dummies(df, columns=cols, drop_first=False)
+        # Convert boolean columns produced by get_dummies to int (0/1) for sklearn
+        bool_cols = df.select_dtypes(include=["bool"]).columns.tolist()
+        if bool_cols:
+            df[bool_cols] = df[bool_cols].astype(int)
+    return {"data": df}
+'''
+
+TRAIN_TEST_SPLIT = '''from sklearn.model_selection import train_test_split as _split
+from typing import Annotated
+
+def run(
+    data,
+    target_column: Annotated[str, "column"] = "target",
+    test_size: float = 0.2,
+    random_state: int = 42,
+) -> dict:
+    X = data.drop(columns=[target_column])
+    y = data[target_column]
+    X_train, X_test, y_train, y_test = _split(
+        X, y, test_size=test_size, random_state=random_state
+    )
+    return {"X_train": X_train, "X_test": X_test, "y_train": y_train, "y_test": y_test}
+'''
+
+STANDARD_SCALER = '''from sklearn.preprocessing import StandardScaler
+
+def run(X_train, X_test, y_train, y_test) -> dict:
+    scaler = StandardScaler()
+    X_train_s = scaler.fit_transform(X_train)
+    X_test_s = scaler.transform(X_test)
+    return {"X_train": X_train_s, "X_test": X_test_s, "y_train": y_train, "y_test": y_test}
+'''
+
+MIN_MAX_SCALER = '''from sklearn.preprocessing import MinMaxScaler
+
+def run(X_train, X_test, y_train, y_test) -> dict:
+    scaler = MinMaxScaler()
+    X_train_s = scaler.fit_transform(X_train)
+    X_test_s = scaler.transform(X_test)
+    return {"X_train": X_train_s, "X_test": X_test_s, "y_train": y_train, "y_test": y_test}
+'''
+
+PCA = '''from sklearn.decomposition import PCA
+
+def run(X_train, X_test, y_train, y_test, n_components: int = 2) -> dict:
+    pca = PCA(n_components=n_components)
+    X_train_p = pca.fit_transform(X_train)
+    X_test_p = pca.transform(X_test)
+    explained = float(sum(pca.explained_variance_ratio_))
+    return {"X_train": X_train_p, "X_test": X_test_p, "y_train": y_train, "y_test": y_test,
+            "explained_variance": round(explained, 4)}
+'''
+
+# ── Shared CV helper (inlined into each template to stay self-contained) ────────
+#
+#   def _run_cv(model, X_train, y_train, cv_folds, scoring):
+#       scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring=scoring)
+#       return {"cv_mean": round(float(scores.mean()), 4),
+#               "cv_std":  round(float(scores.std()), 4),
+#               "cv_scores": [round(float(s), 4) for s in scores]}
+#
+# ── Classifier models ─────────────────────────────────────────────────────────
+
+LOGISTIC_REGRESSION = '''from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    C: float = 1.0, max_iter: int = 200, random_state: int = 42,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    model = LogisticRegression(C=C, max_iter=max_iter, random_state=random_state)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+RANDOM_FOREST_CLASSIFIER = '''from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    n_estimators: int = 100, max_depth: int = 0, random_state: int = 42,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    md = max_depth if max_depth > 0 else None
+    model = RandomForestClassifier(n_estimators=n_estimators, max_depth=md, random_state=random_state)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+GRADIENT_BOOSTING_CLASSIFIER = '''from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    n_estimators: int = 100, learning_rate: float = 0.1, random_state: int = 42,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    model = GradientBoostingClassifier(n_estimators=n_estimators, learning_rate=learning_rate, random_state=random_state)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+DECISION_TREE_CLASSIFIER = '''from sklearn.tree import DecisionTreeClassifier
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    max_depth: int = 0, random_state: int = 42,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    md = max_depth if max_depth > 0 else None
+    model = DecisionTreeClassifier(max_depth=md, random_state=random_state)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+SVM_CLASSIFIER = '''from sklearn.svm import SVC
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    C: float = 1.0, kernel: str = "rbf",
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    model = SVC(C=C, kernel=kernel)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+KNN_CLASSIFIER = '''from sklearn.neighbors import KNeighborsClassifier
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    n_neighbors: int = 5,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    model = KNeighborsClassifier(n_neighbors=n_neighbors)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="accuracy")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+# ── Regressor models ──────────────────────────────────────────────────────────
+
+LINEAR_REGRESSION = '''from sklearn.linear_model import LinearRegression
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    model = LinearRegression()
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+RANDOM_FOREST_REGRESSOR = '''from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    n_estimators: int = 100, max_depth: int = 0, random_state: int = 42,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    md = max_depth if max_depth > 0 else None
+    model = RandomForestRegressor(n_estimators=n_estimators, max_depth=md, random_state=random_state)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+GRADIENT_BOOSTING_REGRESSOR = '''from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    n_estimators: int = 100, learning_rate: float = 0.1, random_state: int = 42,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    model = GradientBoostingRegressor(n_estimators=n_estimators, learning_rate=learning_rate, random_state=random_state)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+DECISION_TREE_REGRESSOR = '''from sklearn.tree import DecisionTreeRegressor
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    max_depth: int = 0, random_state: int = 42,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    md = max_depth if max_depth > 0 else None
+    model = DecisionTreeRegressor(max_depth=md, random_state=random_state)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+SVM_REGRESSOR = '''from sklearn.svm import SVR
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    C: float = 1.0, kernel: str = "rbf",
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    model = SVR(C=C, kernel=kernel)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+KNN_REGRESSOR = '''from sklearn.neighbors import KNeighborsRegressor
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    n_neighbors: int = 5,
+    cross_validation: bool = False, cv_folds: int = 5,
+) -> dict:
+    model = KNeighborsRegressor(n_neighbors=n_neighbors)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()), 4),
+                "cv_scores": [round(float(s), 4) for s in scores]}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+# ── Evaluation ────────────────────────────────────────────────────────────────
+
+ACCURACY = '''from sklearn.metrics import accuracy_score
+
+def run(y_test, y_pred) -> dict:
+    return {"accuracy": float(accuracy_score(y_test, y_pred))}
+'''
+
+CLASSIFICATION_REPORT = '''from sklearn.metrics import (
+    accuracy_score, f1_score, precision_score, recall_score,
+    confusion_matrix, classification_report,
+)
+
+def run(y_test, y_pred) -> dict:
+    return {
+        "accuracy":   round(float(accuracy_score(y_test, y_pred)), 4),
+        "f1_score":   round(float(f1_score(y_test, y_pred, average="weighted", zero_division=0)), 4),
+        "precision":  round(float(precision_score(y_test, y_pred, average="weighted", zero_division=0)), 4),
+        "recall":     round(float(recall_score(y_test, y_pred, average="weighted", zero_division=0)), 4),
+        "confusion_matrix": confusion_matrix(y_test, y_pred).tolist(),
+        "class_report": classification_report(y_test, y_pred, output_dict=True, zero_division=0),
+    }
+'''
+
+VALIDATION_REPORT = '''from sklearn.model_selection import cross_validate
+import numpy as np
+
+def run(model, X_train, y_train, cv_folds: int = 5) -> dict:
+    """Run K-Fold cross validation and generate a robust validation report."""
+    # Using macro averages for multiclass compatibility
+    scoring = ['accuracy', 'precision_macro', 'recall_macro', 'f1_macro']
+    
+    # Catching cases where model might not be a classifier (though typically it will be here)
+    try:
+        scores = cross_validate(model, X_train, y_train, cv=cv_folds, scoring=scoring)
+        return {
+            "cv_folds": cv_folds,
+            "mean_accuracy":  round(float(np.mean(scores['test_accuracy'])), 4),
+            "std_accuracy":   round(float(np.std(scores['test_accuracy'])), 4),
+            "mean_precision": round(float(np.mean(scores['test_precision_macro'])), 4),
+            "mean_recall":    round(float(np.mean(scores['test_recall_macro'])), 4),
+            "mean_f1":        round(float(np.mean(scores['test_f1_macro'])), 4),
+        }
+    except Exception as e:
+        # Fallback for regressors
+        scores = cross_validate(model, X_train, y_train, cv=cv_folds, scoring=['r2', 'neg_mean_squared_error'])
+        return {
+            "cv_folds": cv_folds,
+            "mean_r2": round(float(np.mean(scores['test_r2'])), 4),
+            "mean_mse": round(float(np.mean(-scores['test_neg_mean_squared_error'])), 4),
+        }
+'''
+
+REGRESSION_METRICS = '''from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
+import numpy as np
+
+def run(y_test, y_pred) -> dict:
+    mse = float(mean_squared_error(y_test, y_pred))
+    return {
+        "mse":  round(mse, 4),
+        "rmse": round(float(np.sqrt(mse)), 4),
+        "mae":  round(float(mean_absolute_error(y_test, y_pred)), 4),
+        "r2":   round(float(r2_score(y_test, y_pred)), 4),
+    }
+'''
+
+FEATURE_IMPORTANCE = '''import numpy as np
+
+def run(model, X_train) -> dict:
+    """Extract feature importances from any tree-based model."""
+    if not hasattr(model, "feature_importances_"):
+        raise ValueError(f"{type(model).__name__} has no feature_importances_. Use RF, GBM, or DT.")
+    imps = model.feature_importances_
+    names = list(X_train.columns) if hasattr(X_train, "columns") else [f"f{i}" for i in range(len(imps))]
+    pairs = sorted(zip(imps, names), reverse=True)
+    top = min(20, len(pairs))
+    return {
+        "feature_importances": {name: round(float(imp), 6) for imp, name in pairs[:top]},
+        "top_feature": pairs[0][1],
+        "top_importance": round(float(pairs[0][0]), 6),
+    }
+'''
+
+AUTO_ML = '''from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score
+
+def run(X_train, X_test, y_train, y_test) -> dict:
+    candidates = {
+        "Random Forest":       RandomForestClassifier(n_estimators=100, random_state=42),
+        "Gradient Boosting":   GradientBoostingClassifier(random_state=42),
+        "Logistic Regression": LogisticRegression(max_iter=1000, random_state=42),
+    }
+    scores = {}
+    best_name, best_score, best_model, best_pred = "", -1.0, None, None
+    for name, mdl in candidates.items():
+        mdl.fit(X_train, y_train)
+        preds = mdl.predict(X_test)
+        score = float(accuracy_score(y_test, preds))
+        scores[name] = round(score, 4)
+        if score > best_score:
+            best_score, best_name, best_model, best_pred = score, name, mdl, preds
+    return {
+        "model": best_model,
+        "y_pred": best_pred,
+        "best_algorithm": best_name,
+        "accuracy": round(best_score, 4),
+        "all_scores": scores,
+    }
+'''
+
+
+EDA_HISTOGRAM = '''import pandas as pd
+import numpy as np
+from typing import Annotated
+
+def run(data, column: Annotated[str, "column"] = "price", bins: int = 20) -> dict:
+    """Distribution histogram for a single numeric column."""
+    series = data[column].dropna()
+    counts, edges = np.histogram(series, bins=bins)
+    return {
+        "histogram": {
+            "column": column,
+            "counts": counts.tolist(),
+            "bin_edges": [round(float(e), 2) for e in edges.tolist()],
+            "mean":   round(float(series.mean()), 2),
+            "median": round(float(series.median()), 2),
+            "std":    round(float(series.std()), 2),
+            "min":    round(float(series.min()), 2),
+            "max":    round(float(series.max()), 2),
+        }
+    }
+'''
+
+EDA_CORRELATION = '''import pandas as pd
+import numpy as np
+
+def run(data) -> dict:
+    """Full correlation matrix for all numeric columns."""
+    num_df = data.select_dtypes(include=[np.number])
+    corr = num_df.corr().round(3)
+    matrix = []
+    for row in corr.values.tolist():
+        matrix.append([None if (v != v) else round(v, 3) for v in row])
+    return {
+        "correlation_matrix": {
+            "columns": list(corr.columns),
+            "matrix": matrix,
+        }
+    }
+'''
+
+EDA_VALUE_COUNTS = '''import pandas as pd
+from typing import Annotated
+
+def run(data, column: Annotated[str, "column"] = "mainroad", top_n: int = 10) -> dict:
+    """Value counts for a categorical column."""
+    vc = data[column].value_counts().head(top_n)
+    return {
+        "value_counts": {
+            "column": column,
+            "labels": [str(l) for l in vc.index.tolist()],
+            "counts": vc.values.tolist(),
+            "total": int(len(data)),
+        }
+    }
+'''
+
+EDA_BOX_PLOT = '''import pandas as pd
+import numpy as np
+from typing import Annotated
+
+def run(data, column: Annotated[str, "column"] = "price") -> dict:
+    """Box plot statistics (min, Q1, median, Q3, max, outliers) for a column."""
+    s = data[column].dropna()
+    q1, q3 = float(s.quantile(0.25)), float(s.quantile(0.75))
+    iqr = q3 - q1
+    outliers = s[(s < q1 - 1.5*iqr) | (s > q3 + 1.5*iqr)]
+    return {
+        "box_plot": {
+            "column": column,
+            "min":    round(float(s.min()), 2),
+            "q1":     round(q1, 2),
+            "median": round(float(s.median()), 2),
+            "q3":     round(q3, 2),
+            "max":    round(float(s.max()), 2),
+            "mean":   round(float(s.mean()), 2),
+            "iqr":    round(iqr, 2),
+            "outlier_count": int(len(outliers)),
+            "whisker_low":  round(float(max(s.min(), q1 - 1.5*iqr)), 2),
+            "whisker_high": round(float(min(s.max(), q3 + 1.5*iqr)), 2),
+        }
+    }
+'''
+
+PREDICT = '''import pandas as pd
+import json
+
+def run(model, feature_json: str = "{}") -> dict:
+    """Predict from a trained model. Enter feature values as a JSON string.
+    Example: {"area": 7000, "bedrooms": 3, "bathrooms": 2, "stories": 2,
+              "mainroad": 1, "guestroom": 0, "basement": 0,
+              "hotwaterheating": 0, "airconditioning": 1, "parking": 2,
+              "prefarea": 0, "furnishingstatus": 1}
+    """
+    features = json.loads(feature_json) if feature_json.strip() else {}
+    if not features:
+        raise ValueError("Enter feature values as JSON in the feature_json field")
+    df = pd.DataFrame([features])
+    prediction = model.predict(df)
+    result = prediction[0]
+    scalar = float(result) if hasattr(result, "__float__") else str(result)
+    return {
+        "prediction": scalar,
+        "features_used": features,
+    }
+'''
+
+CONFUSION_MATRIX_PLOTTER = '''import numpy as np
+from sklearn.metrics import confusion_matrix
+import json
+
+def run(y_test, y_pred, normalize: bool = False) -> dict:
+    """Computes the confusion matrix and outputs a JSON-serializable structure."""
+    labels = sorted(list(set(y_test) | set(y_pred)))
+    cm = confusion_matrix(y_test, y_pred, labels=labels)
+    if normalize:
+        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
+        cm = np.nan_to_num(cm)
+    
+    matrix_data = cm.tolist()
+    labels_data = [str(l) for l in labels]
+    
+    return {
+        "correlation_heatmap": {
+            "x": labels_data,
+            "y": labels_data,
+            "z": matrix_data
+        },
+        "summary": "Confusion matrix for error analysis"
+    }
+'''
+
+ROC_PR_CURVE_DATA = '''import numpy as np
+from sklearn.metrics import roc_curve, precision_recall_curve, auc
+
+def run(model, X_test, y_test) -> dict:
+    """Calculates ROC and PR curves data (TPR, FPR, Precision, Recall) across thresholds."""
+    if not hasattr(model, "predict_proba"):
+        raise ValueError("Model does not support predict_proba() required for ROC/PR curves.")
+    
+    classes = model.classes_
+    if len(classes) != 2:
+        raise ValueError("ROC/PR curve data generation currently supports binary classification only.")
+    
+    y_scores = model.predict_proba(X_test)[:, 1]
+    pos_label = classes[1]
+    
+    fpr, tpr, roc_thresh = roc_curve(y_test, y_scores, pos_label=pos_label)
+    roc_auc = auc(fpr, tpr)
+    
+    precision, recall, pr_thresh = precision_recall_curve(y_test, y_scores, pos_label=pos_label)
+    pr_auc = auc(recall, precision)
+    
+    return {
+        "roc_curves": {
+            "ROC (FPR vs TPR)": {
+                "fpr": fpr.tolist(),
+                "tpr": tpr.tolist(),
+                "auc": float(roc_auc)
+            },
+            "PR (Recall vs Prec)": {
+                "fpr": recall.tolist(),  # X-axis
+                "tpr": precision.tolist(), # Y-axis
+                "auc": float(pr_auc)
+            }
+        }
+    }
+'''
+
+RESIDUAL_PLOTTER = '''import numpy as np
+
+def run(y_test, y_pred) -> dict:
+    """Generates (Predicted, Residual) pairs for regression error analysis."""
+    y_test_arr = np.array(y_test).ravel()
+    y_pred_arr = np.array(y_pred).ravel()
+    
+    residuals = y_test_arr - y_pred_arr
+    
+    if len(y_pred_arr) > 1000:
+        idx = np.random.choice(len(y_pred_arr), 1000, replace=False)
+        y_pred_arr = y_pred_arr[idx]
+        residuals = residuals[idx]
+        
+    return {
+        "feature_target_scatter": {
+            "x": y_pred_arr.tolist(),
+            "y": residuals.tolist(),
+            "feature_name": "Predicted",
+            "target_name": "Residuals"
+        },
+        "summary": "Residual plot data points"
+    }
+'''
+
+FEATURE_IMPORTANCE_VISUALIZER = '''import numpy as np
+
+def run(model, X_train=None, top_n: int = 10) -> dict:
+    """Extracts and sorts feature importances or coefficients from a model."""
+    importances = None
+    names = None
+    
+    if hasattr(model, 'feature_importances_'):
+        importances = model.feature_importances_
+    elif hasattr(model, 'coef_'):
+        importances = np.abs(model.coef_[0]) if model.coef_.ndim > 1 else np.abs(model.coef_)
+    else:
+        raise ValueError("Model has neither 'feature_importances_' nor 'coef_'.")
+        
+    if hasattr(model, 'feature_names_in_'):
+        names = model.feature_names_in_
+    elif X_train is not None and hasattr(X_train, 'columns'):
+        names = X_train.columns
+    else:
+        names = [f"Feature {i}" for i in range(len(importances))]
+        
+    indices = np.argsort(importances)[::-1][:top_n]
+    
+    top_importances = importances[indices].tolist()
+    top_names = [str(names[i]) for i in indices]
+    
+    return {
+        "value_counts": {
+            "labels": top_names,
+            "counts": top_importances,
+            "column": "Feature Importance",
+            "total": sum(top_importances) if sum(top_importances) > 0 else 1
+        },
+        "summary": f"Top {top_n} features"
+    }
+'''
+
+DECISION_BOUNDARY_2D = '''import numpy as np
+from sklearn.decomposition import PCA
+
+def run(model, X_train, y_train, grid_resolution: int = 50) -> dict:
+    """Reduces data to 2D (if needed) and predicts over a meshgrid to visualize decision boundaries."""
+    X = np.array(X_train)
+    y = np.array(y_train)
+    
+    pca_used = False
+    if X.shape[1] > 2:
+        pca = PCA(n_components=2)
+        X_2d = pca.fit_transform(X)
+        pca_used = True
+    elif X.shape[1] == 2:
+        X_2d = X
+    else:
+        raise ValueError("Cannot draw 2D boundary for 1D feature space.")
+        
+    x_min, x_max = X_2d[:, 0].min() - 1, X_2d[:, 0].max() + 1
+    y_min, y_max = X_2d[:, 1].min() - 1, X_2d[:, 1].max() + 1
+    
+    xx, yy = np.meshgrid(
+        np.linspace(x_min, x_max, grid_resolution),
+        np.linspace(y_min, y_max, grid_resolution)
+    )
+    
+    grid_points_2d = np.c_[xx.ravel(), yy.ravel()]
+    
+    if pca_used:
+        grid_points_orig = pca.inverse_transform(grid_points_2d)
+        Z = model.predict(grid_points_orig)
+    else:
+        Z = model.predict(grid_points_2d)
+        
+    sample_size = min(300, len(X_2d))
+    idx = np.random.choice(len(X_2d), sample_size, replace=False)
+    
+    if hasattr(Z[0], "item"):
+        Z = np.array([z.item() if hasattr(z, "item") else z for z in Z])
+    
+    return {
+        "feature_target_scatter": {
+            "x": X_2d[idx, 0].tolist(),
+            "y": X_2d[idx, 1].tolist(),
+            "feature_name": "Dim 1",
+            "target_name": "Dim 2"
+        },
+        "summary": f"Decision Boundary Scatter. PCA applied: {pca_used}"
+    }
+'''
+
+PREDICTION_VS_ACTUAL_SCATTER = '''import numpy as np
+
+def run(y_test, y_pred) -> dict:
+    """Returns actual vs predicted pairs for plotting a regression scatter plot."""
+    y_test_arr = np.array(y_test).ravel()
+    y_pred_arr = np.array(y_pred).ravel()
+    
+    if len(y_test_arr) > 1000:
+        idx = np.random.choice(len(y_test_arr), 1000, replace=False)
+        y_test_arr = y_test_arr[idx]
+        y_pred_arr = y_pred_arr[idx]
+        
+    return {
+        "feature_target_scatter": {
+            "x": y_test_arr.tolist(),
+            "y": y_pred_arr.tolist(),
+            "feature_name": "Actual",
+            "target_name": "Predicted"
+        },
+        "summary": "Actual vs Predicted points"
+    }
+'''
+
+POLYNOMIAL_FEATURES = '''import pandas as pd
+from sklearn.preprocessing import PolynomialFeatures
+
+def run(data, degree: int = 2, interaction_only: bool = False) -> dict:
+    df = data.copy()
+    num_cols = df.select_dtypes(include=['number']).columns.tolist()
+    if not num_cols:
+        return {"data": df, "summary": "No numeric columns found"}
+    
+    poly = PolynomialFeatures(degree=degree, interaction_only=interaction_only, include_bias=False)
+    poly_features = poly.fit_transform(df[num_cols])
+    
+    feature_names = poly.get_feature_names_out(num_cols)
+    poly_df = pd.DataFrame(poly_features, columns=feature_names, index=df.index)
+    
+    df = df.drop(columns=num_cols)
+    df = pd.concat([df, poly_df], axis=1)
+    
+    return {"data": df, "summary": f"Added {len(feature_names)} polynomial features"}
+'''
+
+DATETIME_EXTRACTOR = '''import pandas as pd
+from typing import Annotated
+
+def run(data, column: Annotated[str, "column"] = "date") -> dict:
+    df = data.copy()
+    if column not in df.columns:
+        raise ValueError(f"Column '{column}' not found.")
+        
+    dt_series = pd.to_datetime(df[column], errors='coerce')
+    
+    df[f"{column}_year"] = dt_series.dt.year
+    df[f"{column}_month"] = dt_series.dt.month
+    df[f"{column}_day"] = dt_series.dt.day
+    df[f"{column}_dayofweek"] = dt_series.dt.dayofweek
+    
+    df = df.drop(columns=[column])
+    
+    return {"data": df, "summary": f"Extracted datetime components from {column}"}
+'''
+
+RFE_FEATURE_SELECTOR = '''import pandas as pd
+import numpy as np
+from typing import Annotated
+from sklearn.feature_selection import RFE
+from sklearn.ensemble import RandomForestRegressor
+
+def run(data, target_column: Annotated[str, "column"] = "target", n_to_select: int = 10) -> dict:
+    df = data.copy()
+    if target_column not in df.columns:
+        raise ValueError(f"Target column '{target_column}' not found.")
+        
+    y = df[target_column]
+    X = df.drop(columns=[target_column])
+    
+    X_num = X.select_dtypes(include=[np.number])
+    X_non_num = X.select_dtypes(exclude=[np.number])
+    
+    if X_num.shape[1] <= n_to_select:
+        return {"data": df, "summary": "Feature count already <= n_to_select"}
+        
+    estimator = RandomForestRegressor(n_estimators=50, random_state=42)
+    selector = RFE(estimator, n_features_to_select=n_to_select, step=1)
+    
+    selector.fit(X_num, y)
+    
+    selected_features = X_num.columns[selector.support_].tolist()
+    
+    df_out = pd.concat([X_non_num, X_num[selected_features]], axis=1)
+    df_out[target_column] = y
+    
+    return {"data": df_out, "selected_features": selected_features}
+'''
+
+INVERSE_TARGET_TRANSFORMER = '''import numpy as np
+
+def run(y_pred, y_test, method: str = "expm1") -> dict:
+    y_p = np.array(y_pred)
+    y_t = np.array(y_test)
+    
+    if method == "expm1":
+        y_p_inv = np.expm1(y_p)
+        y_t_inv = np.expm1(y_t)
+    elif method == "square":
+        y_p_inv = np.square(y_p)
+        y_t_inv = np.square(y_t)
+    else:
+        raise ValueError(f"Unsupported method: {method}")
+        
+    return {
+        "y_pred": y_p_inv.tolist() if hasattr(y_p_inv, "tolist") else y_p_inv,
+        "y_test": y_t_inv.tolist() if hasattr(y_t_inv, "tolist") else y_t_inv,
+        "method": method
+    }
+'''
+
+THRESHOLD_OPTIMIZER = '''import numpy as np
+from sklearn.metrics import f1_score, precision_score, recall_score, accuracy_score
+
+def run(model, X_test, y_test, target_metric: str = "f1") -> dict:
+    if not hasattr(model, "predict_proba"):
+        raise ValueError("Model does not support predict_proba required for threshold optimization.")
+        
+    classes = model.classes_
+    if len(classes) != 2:
+        raise ValueError("Threshold optimization requires binary classification.")
+        
+    y_scores = model.predict_proba(X_test)[:, 1]
+    pos_label = classes[1]
+    
+    y_true_bin = (np.array(y_test) == pos_label).astype(int)
+    
+    thresholds = np.linspace(0.0, 1.0, 101)
+    best_thresh = 0.5
+    best_score = -1.0
+    
+    metrics = []
+    
+    for t in thresholds:
+        y_pred_t = (y_scores >= t).astype(int)
+        
+        if target_metric == "f1":
+            score = f1_score(y_true_bin, y_pred_t, zero_division=0)
+        elif target_metric == "precision":
+            score = precision_score(y_true_bin, y_pred_t, zero_division=0)
+        elif target_metric == "recall":
+            score = recall_score(y_true_bin, y_pred_t, zero_division=0)
+        elif target_metric == "accuracy":
+            score = accuracy_score(y_true_bin, y_pred_t)
+        else:
+            raise ValueError(f"Unsupported target_metric: {target_metric}")
+            
+        metrics.append({"threshold": float(t), "score": float(score)})
+        
+        if score > best_score:
+            best_score = score
+            best_thresh = t
+            
+    return {
+        "best_threshold": float(best_thresh),
+        "best_score": float(best_score),
+        "target_metric": target_metric,
+        "curve_data": metrics
+    }
+'''
+
+
+BINARY_ENCODER = '''import pandas as pd
+try:
+    import category_encoders as ce
+except ImportError:
+    pass
+
+def run(data, columns: str = "") -> dict:
+    df = data.copy()
+    cols = [c.strip() for c in columns.split(",") if c.strip()] if columns.strip() else            df.select_dtypes(include=["object", "category"]).columns.tolist()
+           
+    if not cols:
+        return {"data": df, "summary": "No columns to encode"}
+        
+    try:
+        encoder = ce.BinaryEncoder(cols=cols)
+        df = encoder.fit_transform(df)
+        return {"data": df, "summary": f"Binary encoded {len(cols)} columns"}
+    except NameError:
+        return {"data": df, "summary": "category_encoders not installed. Skipping."}
+'''
+
+FREQUENCY_ENCODER = '''import pandas as pd
+
+def run(data, columns: str = "") -> dict:
+    df = data.copy()
+    cols = [c.strip() for c in columns.split(",") if c.strip()] if columns.strip() else            df.select_dtypes(include=["object", "category"]).columns.tolist()
+           
+    if not cols:
+        return {"data": df, "summary": "No columns to encode"}
+        
+    for col in cols:
+        if col in df.columns:
+            freq = df[col].value_counts(normalize=True)
+            df[col] = df[col].map(freq)
+            
+    return {"data": df, "summary": f"Frequency encoded {len(cols)} columns"}
+'''
+
+ORDINAL_ENCODER = '''import pandas as pd
+from sklearn.preprocessing import OrdinalEncoder
+
+def run(data, columns: str = "") -> dict:
+    df = data.copy()
+    cols = [c.strip() for c in columns.split(",") if c.strip()] if columns.strip() else            df.select_dtypes(include=["object", "category"]).columns.tolist()
+           
+    if not cols:
+        return {"data": df, "summary": "No columns to encode"}
+        
+    encoder = OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1)
+    df[cols] = encoder.fit_transform(df[cols].astype(str))
+    
+    return {"data": df, "summary": f"Ordinal encoded {len(cols)} columns"}
+'''
+
+VIF_FEATURE_SELECTION = '''import pandas as pd
+import numpy as np
+from statsmodels.stats.outliers_influence import variance_inflation_factor
+
+def run(data, threshold: float = 5.0) -> dict:
+    df = data.copy()
+    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    
+    if len(num_cols) < 2:
+        return {"data": df, "summary": "Not enough numeric columns for VIF"}
+        
+    X = df[num_cols].dropna()
+    dropped = []
+    
+    while True:
+        vif_data = pd.DataFrame()
+        vif_data["feature"] = X.columns
+        vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(len(X.columns))]
+        
+        max_vif = vif_data["VIF"].max()
+        if max_vif > threshold:
+            max_feat = vif_data.sort_values("VIF", ascending=False).iloc[0]["feature"]
+            X = X.drop(columns=[max_feat])
+            dropped.append(max_feat)
+        else:
+            break
+            
+    df = df.drop(columns=dropped)
+    return {"data": df, "summary": f"Dropped {len(dropped)} features due to high VIF: {dropped}"}
+'''
+
+PCA_WHITENING = '''import pandas as pd
+import numpy as np
+from sklearn.decomposition import PCA
+
+def run(data, n_components: int = 0, whiten: bool = True) -> dict:
+    df = data.copy()
+    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    
+    if not num_cols:
+        return {"data": df, "summary": "No numeric columns for PCA"}
+        
+    n = n_components if n_components > 0 else None
+    pca = PCA(n_components=n, whiten=whiten)
+    
+    pca_features = pca.fit_transform(df[num_cols].fillna(0))
+    
+    feature_names = [f"pca_{i}" for i in range(pca_features.shape[1])]
+    pca_df = pd.DataFrame(pca_features, columns=feature_names, index=df.index)
+    
+    df = df.drop(columns=num_cols)
+    df = pd.concat([df, pca_df], axis=1)
+    
+    return {"data": df, "summary": f"Applied PCA whitening, created {len(feature_names)} components"}
+'''
+
+K_MEANS_CLUSTERING_FEATURES = '''import pandas as pd
+import numpy as np
+from sklearn.cluster import KMeans
+
+def run(data, n_clusters: int = 3, random_state: int = 42) -> dict:
+    df = data.copy()
+    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    
+    if not num_cols:
+        return {"data": df, "summary": "No numeric columns for KMeans"}
+        
+    kmeans = KMeans(n_clusters=n_clusters, random_state=random_state, n_init='auto')
+    df['ClusterID'] = kmeans.fit_predict(df[num_cols].fillna(0))
+    
+    return {"data": df, "summary": f"Added ClusterID with {n_clusters} clusters"}
+'''
+
+XGBOOST_NODE = '''import pandas as pd
+import numpy as np
+
+def run(X_train, X_test, y_train, task_type: str = "classifier", n_estimators: int = 100, learning_rate: float = 0.1, max_depth: int = 3) -> dict:
+    if task_type.lower() == "classifier":
+        from xgboost import XGBClassifier
+        model = XGBClassifier(n_estimators=n_estimators, learning_rate=learning_rate, max_depth=max_depth, use_label_encoder=False, eval_metric='logloss')
+    else:
+        from xgboost import XGBRegressor
+        model = XGBRegressor(n_estimators=n_estimators, learning_rate=learning_rate, max_depth=max_depth)
+        
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    
+    return {"model": model, "y_pred": y_pred}
+'''
+
+LIGHTGBM_NODE = '''import pandas as pd
+
+def run(X_train, X_test, y_train, task_type: str = "classifier", n_estimators: int = 100, learning_rate: float = 0.1, max_depth: int = -1) -> dict:
+    if task_type.lower() == "classifier":
+        from lightgbm import LGBMClassifier
+        model = LGBMClassifier(n_estimators=n_estimators, learning_rate=learning_rate, max_depth=max_depth)
+    else:
+        from lightgbm import LGBMRegressor
+        model = LGBMRegressor(n_estimators=n_estimators, learning_rate=learning_rate, max_depth=max_depth)
+        
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    
+    return {"model": model, "y_pred": y_pred}
+'''
+
+ADABOOST_NODE = '''import pandas as pd
+
+def run(X_train, X_test, y_train, task_type: str = "classifier", n_estimators: int = 50, learning_rate: float = 1.0) -> dict:
+    if task_type.lower() == "classifier":
+        from sklearn.ensemble import AdaBoostClassifier
+        model = AdaBoostClassifier(n_estimators=n_estimators, learning_rate=learning_rate)
+    else:
+        from sklearn.ensemble import AdaBoostRegressor
+        model = AdaBoostRegressor(n_estimators=n_estimators, learning_rate=learning_rate)
+        
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    
+    return {"model": model, "y_pred": y_pred}
+'''
+
+VOTING_ENSEMBLE = '''import pandas as pd
+import numpy as np
+
+def run(model1, model2, model3, X_train, X_test, y_train, task_type: str = "classifier", voting: str = "hard") -> dict:
+    estimators = [('m1', model1), ('m2', model2), ('m3', model3)]
+    
+    if task_type.lower() == "classifier":
+        from sklearn.ensemble import VotingClassifier
+        model = VotingClassifier(estimators=estimators, voting=voting)
+    else:
+        from sklearn.ensemble import VotingRegressor
+        model = VotingRegressor(estimators=estimators)
+        
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    
+    return {"model": model, "y_pred": y_pred}
+'''
+
+LAG_FEATURE_GENERATOR = '''import pandas as pd
+from typing import Annotated
+
+def run(data, column: Annotated[str, "column"], lags: int = 3) -> dict:
+    df = data.copy()
+    if column not in df.columns:
+        raise ValueError(f"Column '{column}' not found.")
+        
+    for i in range(1, lags + 1):
+        df[f"{column}_lag_{i}"] = df[column].shift(i)
+        
+    return {"data": df, "summary": f"Created {lags} lag features for {column}"}
+'''
+
+ROLLING_WINDOW_STATS = '''import pandas as pd
+from typing import Annotated
+
+def run(data, column: Annotated[str, "column"], window: int = 7) -> dict:
+    df = data.copy()
+    if column not in df.columns:
+        raise ValueError(f"Column '{column}' not found.")
+        
+    df[f"{column}_roll_mean_{window}"] = df[column].rolling(window=window).mean()
+    df[f"{column}_roll_std_{window}"] = df[column].rolling(window=window).std()
+    
+    return {"data": df, "summary": f"Created rolling window ({window}) stats for {column}"}
+'''
+
+PERMUTATION_IMPORTANCE = '''import numpy as np
+from sklearn.inspection import permutation_importance
+
+def run(model, X_test, y_test, scoring: str = "accuracy", n_repeats: int = 5, random_state: int = 42) -> dict:
+    result = permutation_importance(model, X_test, y_test, scoring=scoring, n_repeats=n_repeats, random_state=random_state)
+    
+    importances = result.importances_mean
+    
+    if hasattr(X_test, 'columns'):
+        names = X_test.columns
+    else:
+        names = [f"Feature {i}" for i in range(len(importances))]
+        
+    indices = np.argsort(importances)[::-1]
+    
+    top_importances = importances[indices].tolist()
+    top_names = [str(names[i]) for i in indices]
+    
+    return {
+        "features": top_names,
+        "importances": top_importances,
+        "summary": "Permutation Importance"
+    }
+'''
+
+LEARNING_CURVE_DATA = '''import numpy as np
+from sklearn.model_selection import learning_curve
+
+def run(model, X_train, y_train, cv_folds: int = 5, scoring: str = "accuracy") -> dict:
+    train_sizes, train_scores, test_scores = learning_curve(
+        model, X_train, y_train, cv=cv_folds, scoring=scoring,
+        train_sizes=np.linspace(0.1, 1.0, 10), random_state=42
+    )
+    
+    train_mean = np.mean(train_scores, axis=1).tolist()
+    test_mean = np.mean(test_scores, axis=1).tolist()
+    sizes = train_sizes.tolist()
+    
+    return {
+        "train_sizes": sizes,
+        "train_scores": train_mean,
+        "val_scores": test_mean,
+        "scoring": scoring,
+        "summary": "Learning Curve Data"
+    }
+'''
+
+LIFT_GAIN_CHARTS = '''import numpy as np
+
+def run(model, X_test, y_test) -> dict:
+    if not hasattr(model, "predict_proba"):
+        raise ValueError("Model does not support predict_proba required for lift/gain charts.")
+        
+    classes = model.classes_
+    if len(classes) != 2:
+        raise ValueError("Lift/Gain charts require binary classification.")
+        
+    y_scores = model.predict_proba(X_test)[:, 1]
+    pos_label = classes[1]
+    
+    y_true_bin = (np.array(y_test) == pos_label).astype(int)
+    
+    indices = np.argsort(y_scores)[::-1]
+    y_true_sorted = y_true_bin[indices]
+    
+    total_positives = y_true_bin.sum()
+    total_samples = len(y_true_bin)
+    
+    cum_positives = np.cumsum(y_true_sorted)
+    
+    gain = cum_positives / max(total_positives, 1)
+    
+    count = np.arange(1, total_samples + 1)
+    lift = (cum_positives / count) / (total_positives / total_samples)
+    
+    deciles = np.linspace(0, 1, 11)[1:]
+    gain_deciles = [gain[min(int(d * total_samples) - 1, total_samples - 1)] for d in deciles]
+    lift_deciles = [lift[min(int(d * total_samples) - 1, total_samples - 1)] for d in deciles]
+    
+    return {
+        "deciles": deciles.tolist(),
+        "gain": gain_deciles,
+        "lift": lift_deciles,
+        "summary": "Lift and Gain Data"
+    }
+'''
+
+TOMEK_LINKS = '''import pandas as pd
+import numpy as np
+from typing import Annotated
+
+def run(data, target_column: Annotated[str, "column"] = "target") -> dict:
+    df = data.copy()
+    if target_column not in df.columns:
+        raise ValueError(f"Target column '{target_column}' not found.")
+        
+    X = df.drop(columns=[target_column])
+    y = df[target_column]
+    
+    try:
+        from imblearn.under_sampling import TomekLinks
+        tl = TomekLinks()
+        X_res, y_res = tl.fit_resample(X, y)
+        df_out = X_res.copy()
+        df_out[target_column] = y_res
+        
+        return {"data": df_out, "summary": f"Tomek Links removed {len(df) - len(df_out)} noisy samples."}
+    except ImportError:
+        return {"data": df, "summary": "imbalanced-learn not installed. Skipping Tomek Links."}
+'''
+
+RANDOM_UNDER_SAMPLER = '''import pandas as pd
+from typing import Annotated
+
+def run(data, target_column: Annotated[str, "column"] = "target", random_state: int = 42) -> dict:
+    df = data.copy()
+    if target_column not in df.columns:
+        raise ValueError(f"Target column '{target_column}' not found.")
+        
+    try:
+        from imblearn.under_sampling import RandomUnderSampler
+        X = df.drop(columns=[target_column])
+        y = df[target_column]
+        rus = RandomUnderSampler(random_state=random_state)
+        X_res, y_res = rus.fit_resample(X, y)
+        df_out = X_res.copy()
+        df_out[target_column] = y_res
+        
+        return {"data": df_out, "summary": f"Undersampled from {len(df)} to {len(df_out)} rows."}
+    except ImportError:
+        min_class_size = df[target_column].value_counts().min()
+        df_out = df.groupby(target_column).sample(n=min_class_size, random_state=random_state)
+        return {"data": df_out, "summary": f"Manual undersampled from {len(df)} to {len(df_out)} rows."}
+'''
+
+CORRELATION_HEATMAP = '''import pandas as pd
+import numpy as np
+
+def run(data: pd.DataFrame) -> dict:
+    numeric_df = data.select_dtypes(include=[np.number])
+    if numeric_df.empty:
+        return {"error": "No numeric columns found for correlation."}
+    
+    corr_matrix = numeric_df.corr().fillna(0)
+    cols = corr_matrix.columns.tolist()
+    
+    z_values = corr_matrix.values.tolist()
+    
+    return {
+        "correlation_heatmap": {
+            "x": cols,
+            "y": cols,
+            "z": z_values
+        }
+    }
+'''
+
+MISSING_VALUE_MAP = '''import pandas as pd
+
+def run(data: pd.DataFrame) -> dict:
+    if len(data) > 100:
+        sampled = data.sample(100, random_state=42)
+    else:
+        sampled = data
+        
+    null_matrix = sampled.isnull().astype(int)
+    cols = null_matrix.columns.tolist()
+    
+    z_values = null_matrix.values.tolist()
+    
+    return {
+        "missing_value_map": {
+            "x": cols,
+            "y": list(range(len(sampled))),
+            "z": z_values
+        }
+    }
+'''
+
+CLASS_BALANCE_VISUALIZER = '''import pandas as pd
+from typing import Annotated
+
+def run(data: pd.DataFrame, target: Annotated[str, "column"]) -> dict:
+    if target not in data.columns:
+        return {"error": f"Target column '{target}' not found."}
+        
+    counts = data[target].value_counts(dropna=False)
+    percentages = data[target].value_counts(normalize=True, dropna=False) * 100
+    
+    classes = [str(c) for c in counts.index]
+    
+    return {
+        "class_balance": {
+            "classes": classes,
+            "counts": counts.tolist(),
+            "percentages": percentages.tolist()
+        }
+    }
+'''
+
+FEATURE_TARGET_SCATTER = '''import pandas as pd
+import numpy as np
+from typing import Annotated
+
+def run(data: pd.DataFrame, target: Annotated[str, "column"]) -> dict:
+    if target not in data.columns:
+        return {"error": f"Target column '{target}' not found."}
+        
+    df = data.dropna(subset=[target])
+    
+    # Identify numeric features (excluding target)
+    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    if target in numeric_cols:
+        numeric_cols.remove(target)
+        
+    if not numeric_cols:
+        return {"error": "No numeric features found."}
+        
+    target_is_numeric = pd.api.types.is_numeric_dtype(df[target])
+    
+    corrs = []
+    for col in numeric_cols:
+        if target_is_numeric:
+            corr = df[col].corr(df[target])
+            if pd.isna(corr): corr = 0
+            corrs.append((col, corr))
+        else:
+            corrs.append((col, 0))
+            
+    # Sort by absolute correlation and take top 8
+    corrs.sort(key=lambda x: abs(x[1]), reverse=True)
+    top_features = [x[0] for x in corrs[:8]]
+    top_corrs = {x[0]: x[1] for x in corrs[:8]}
+    
+    # Cap samples for rendering speed
+    if len(df) > 600:
+        df = df.sample(600, random_state=42)
+        
+    panels = []
+    for f in top_features:
+        panels.append({
+            "feature": f,
+            "x": df[f].tolist(),
+            "y": df[target].tolist(),
+            "corr": top_corrs[f]
+        })
+        
+    return {
+        "scatter_grid": {
+            "panels": panels,
+            "title": "Continuous Feature vs Target",
+            "target_name": target
+        }
+    }
+'''
+
+MODEL_ERROR_HISTOGRAM = '''import numpy as np
+
+def run(y_test, y_pred) -> dict:
+    y_t = np.array(y_test)
+    y_p = np.array(y_pred)
+    
+    residuals = y_t - y_p
+    counts, bin_edges = np.histogram(residuals, bins=30)
+    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+    
+    return {
+        "model_error_histogram": {
+            "counts": counts.tolist(),
+            "bin_centers": bin_centers.tolist(),
+            "bin_edges": bin_edges.tolist()
+        }
+    }
+'''
+
+PARTIAL_DEPENDENCE_DATA = '''import pandas as pd
+import numpy as np
+from sklearn.inspection import partial_dependence
+from typing import Annotated
+
+def run(model, X_train: pd.DataFrame, feature: Annotated[str, "column"]) -> dict:
+    if feature not in X_train.columns:
+        return {"error": f"Feature '{feature}' not found in X_train."}
+        
+    if len(X_train) > 1000:
+        X_sample = X_train.sample(1000, random_state=42)
+    else:
+        X_sample = X_train
+        
+    try:
+        pd_result = partial_dependence(model, X_sample, features=[feature], kind='average')
+        avg_response = pd_result['average'].tolist()
+        grid_values = pd_result['grid_values'][0].tolist()
+        
+        return {
+            "partial_dependence": {
+                "feature": feature,
+                "grid": grid_values,
+                "average_response": avg_response
+            }
+        }
+    except Exception as e:
+        return {"error": f"Partial dependence failed: {str(e)}"}
+'''
+
+MULTICLASS_ROC_DATA = '''import numpy as np
+from sklearn.metrics import roc_curve, auc
+from sklearn.preprocessing import label_binarize
+
+def run(model, X_test, y_test) -> dict:
+    if not hasattr(model, "predict_proba"):
+        return {"error": "Model does not support predict_proba, which is required for ROC."}
+        
+    y_t = np.array(y_test)
+    classes = np.unique(y_t)
+    
+    if len(classes) < 2:
+        return {"error": "Need at least 2 classes for ROC."}
+        
+    try:
+        y_prob = model.predict_proba(X_test)
+    except Exception as e:
+        return {"error": f"predict_proba failed: {str(e)}"}
+    
+    roc_data = {}
+    
+    if len(classes) == 2:
+        fpr, tpr, _ = roc_curve(y_t, y_prob[:, 1], pos_label=classes[1])
+        roc_data[str(classes[1])] = {
+            "fpr": fpr.tolist(),
+            "tpr": tpr.tolist(),
+            "auc": auc(fpr, tpr)
+        }
+    else:
+        y_test_bin = label_binarize(y_t, classes=classes)
+        for i, cls in enumerate(classes):
+            fpr, tpr, _ = roc_curve(y_test_bin[:, i], y_prob[:, i])
+            roc_data[str(cls)] = {
+                "fpr": fpr.tolist(),
+                "tpr": tpr.tolist(),
+                "auc": auc(fpr, tpr)
+            }
+            
+    return {"roc_curves": roc_data}
+'''
+
+DBSCAN_CLUSTERING = '''import pandas as pd
+import numpy as np
+from sklearn.cluster import DBSCAN
+
+def run(data: pd.DataFrame, eps: float = 0.5, min_samples: int = 5) -> dict:
+    numeric_df = data.select_dtypes(include=[np.number]).dropna()
+    if numeric_df.empty:
+        return {"error": "No numeric data available for DBSCAN."}
+        
+    dbscan = DBSCAN(eps=eps, min_samples=min_samples)
+    labels = dbscan.fit_predict(numeric_df)
+    
+    out_df = numeric_df.copy()
+    out_df["ClusterID"] = labels
+    
+    noise_count = int((labels == -1).sum())
+    
+    return {
+        "data": out_df,
+        "labels": labels.tolist(),
+        "summary": f"DBSCAN found {len(set(labels)) - (1 if -1 in labels else 0)} clusters and {noise_count} noise points."
+    }
+'''
+
+TSNE_VISUALIZER = '''import pandas as pd
+import numpy as np
+from sklearn.manifold import TSNE
+from typing import Annotated
+
+def run(
+    data: pd.DataFrame,
+    label_column: Annotated[str, "column"] = "",
+    n_clusters: int = 4,
+    perplexity: float = 30.0,
+) -> dict:
+    """t-SNE 2D scatter with automatic cluster coloring.
+
+    label_column : name of a column whose values will color the dots.
+                   Leave blank → KMeans auto-clustering (n_clusters groups).
+    n_clusters   : number of KMeans clusters used when label_column is blank.
+    perplexity   : t-SNE perplexity (5–50 works for most datasets).
+    """
+    df = data.copy()
+    numeric_df = df.select_dtypes(include=[np.number]).dropna()
+
+    if numeric_df.empty:
+        return {"error": "No numeric data available for t-SNE."}
+
+    # Cap at 3000 rows for speed; keep a reproducible sample
+    if len(numeric_df) > 3000:
+        numeric_df = numeric_df.sample(3000, random_state=42)
+
+    # ── Run t-SNE ──────────────────────────────────────────────────────────────
+    perp = min(float(perplexity), max(5.0, (len(numeric_df) - 1) / 3))
+    tsne = TSNE(n_components=2, perplexity=perp, random_state=42, n_iter=300)
+    embedding = tsne.fit_transform(numeric_df.values)
+
+    # ── Build labels array for color-coding ───────────────────────────────────
+    col = label_column.strip() if label_column else ""
+
+    if col and col in df.columns:
+        # Use the requested column aligned to sampled rows
+        raw = df[col].loc[numeric_df.index]
+        dtype = raw.dtype
+
+        if dtype == object or str(dtype) == "category":
+            # Categorical: use as-is
+            labels = [str(v) for v in raw]
+        else:
+            # Numeric target → bucket into 4 quantile bands for readability
+            try:
+                banded = pd.qcut(raw, q=min(n_clusters, raw.nunique()), duplicates="drop", labels=False)
+                labels = [f"Q{int(v)+1}" if pd.notna(v) else "?" for v in banded]
+            except Exception:
+                labels = [str(v) for v in raw]
+    else:
+        # Auto-cluster with KMeans
+        from sklearn.cluster import KMeans
+        from sklearn.preprocessing import StandardScaler
+        scaled = StandardScaler().fit_transform(numeric_df.values)
+        k = min(n_clusters, len(numeric_df) - 1, 10)
+        km = KMeans(n_clusters=k, random_state=42, n_init="auto")
+        cluster_ids = km.fit_predict(scaled)
+        labels = [f"Cluster {int(c)}" for c in cluster_ids]
+
+    n = len(embedding)
+    dot_size = 8 if n < 500 else (6 if n < 1500 else 4)
+
+    return {
+        "tsne_scatter": {
+            "x":       embedding[:, 0].tolist(),
+            "y":       embedding[:, 1].tolist(),
+            "labels":  labels,                         # ← color-coding key
+            "title":   "t-SNE Cluster Visualization",
+            "x_label": "Dim 1",
+            "y_label": "Dim 2",
+            "dot_size": dot_size,
+        },
+        "summary": f"t-SNE projection of {n} samples with {len(set(labels))} color groups.",
+    }
+'''
+
+ISOLATION_FOREST_ANOMALY = '''import pandas as pd
+import numpy as np
+from sklearn.ensemble import IsolationForest
+
+def run(data: pd.DataFrame, contamination: float = 0.05) -> dict:
+    numeric_df = data.select_dtypes(include=[np.number]).dropna()
+    if numeric_df.empty:
+        return {"error": "No numeric data available for Isolation Forest."}
+        
+    clf = IsolationForest(contamination=contamination, random_state=42)
+    labels = clf.fit_predict(numeric_df)
+    
+    out_df = numeric_df.copy()
+    out_df["is_anomaly"] = labels
+    
+    anomaly_count = int((labels == -1).sum())
+    
+    return {
+        "data": out_df,
+        "summary": f"Isolation Forest detected {anomaly_count} anomalies."
+    }
+'''
+
+STACKING_REGRESSOR = '''import pandas as pd
+from sklearn.ensemble import StackingRegressor, RandomForestRegressor
+from sklearn.linear_model import LinearRegression, Ridge
+try:
+    from xgboost import XGBRegressor
+except ImportError:
+    XGBRegressor = None
+
+def run(X_train, y_train, X_test):
+    estimators = [
+        ('lr', LinearRegression()),
+        ('rf', RandomForestRegressor(n_estimators=50, random_state=42))
+    ]
+    if XGBRegressor is not None:
+        estimators.append(('xgb', XGBRegressor(n_estimators=50, random_state=42)))
+        
+    model = StackingRegressor(
+        estimators=estimators,
+        final_estimator=Ridge()
+    )
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    
+    return {
+        "model": model,
+        "y_pred": y_pred.tolist(),
+        "summary": f"Stacked Regressor with {len(estimators)} base models and Ridge final estimator."
+    }
+'''
+
+QUANTILE_REGRESSOR = '''import pandas as pd
+from typing import Annotated
+
+def run(X_train, y_train, X_test, quantile: Annotated[float, "percentile (0-1)"] = 0.5) -> dict:
+    try:
+        from sklearn.linear_model import QuantileRegressor
+        model = QuantileRegressor(quantile=quantile, solver='highs')
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        
+        return {
+            "model": model,
+            "y_pred": y_pred.tolist(),
+            "summary": f"Quantile Regressor fitted for {quantile*100}th percentile."
+        }
+    except Exception as e:
+        return {"error": f"QuantileRegressor failed: {str(e)}"}
+'''
+
+EPSILON_GREEDY_BANDIT = '''import pandas as pd
+import numpy as np
+from typing import Annotated
+
+def run(data: pd.DataFrame, action_col: Annotated[str, "column"], reward_col: Annotated[str, "column"], epsilon: float = 0.1) -> dict:
+    if action_col not in data.columns or reward_col not in data.columns:
+        return {"error": "Action or reward column not found."}
+        
+    actions = data[action_col].unique()
+    q_values = {a: 0.0 for a in actions}
+    action_counts = {a: 0 for a in actions}
+    
+    for _, row in data.iterrows():
+        a = row[action_col]
+        r = row[reward_col]
+        action_counts[a] += 1
+        q_values[a] += (r - q_values[a]) / action_counts[a]
+        
+    optimal_action = max(q_values, key=q_values.get)
+    
+    return {
+        "q_values": q_values,
+        "optimal_policy": str(optimal_action),
+        "summary": f"Bandit converged on optimal action: {optimal_action}"
+    }
+'''
+
+MARKOV_CHAIN_SIMULATOR = '''import pandas as pd
+import numpy as np
+from typing import Annotated
+
+def run(data: pd.DataFrame, state_col: Annotated[str, "column"]) -> dict:
+    if state_col not in data.columns:
+        return {"error": "State column not found."}
+        
+    states = data[state_col].astype(str).tolist()
+    transitions = {}
+    
+    for i in range(len(states) - 1):
+        curr_state = states[i]
+        next_state = states[i+1]
+        
+        if curr_state not in transitions:
+            transitions[curr_state] = {}
+        if next_state not in transitions[curr_state]:
+            transitions[curr_state][next_state] = 0
+            
+        transitions[curr_state][next_state] += 1
+        
+    probs = {}
+    for state, next_states in transitions.items():
+        total = sum(next_states.values())
+        probs[state] = {k: v / total for k, v in next_states.items()}
+        
+    return {
+        "transition_probabilities": probs,
+        "summary": f"Markov Chain built with {len(probs)} distinct states."
+    }
+'''
+
+SILHOUETTE_SCORE_NODE = '''import pandas as pd
+import numpy as np
+from sklearn.metrics import silhouette_score
+from typing import Annotated
+
+def run(data: pd.DataFrame, labels_col: Annotated[str, "column"]) -> dict:
+    if labels_col not in data.columns:
+        return {"error": "Labels column not found."}
+        
+    numeric_df = data.select_dtypes(include=[np.number]).drop(columns=[labels_col], errors='ignore').dropna()
+    labels = data[labels_col].loc[numeric_df.index]
+    
+    unique_labels = len(set(labels))
+    if unique_labels < 2 or unique_labels >= len(numeric_df):
+        return {"error": "Silhouette score requires 2 <= n_clusters <= n_samples - 1"}
+        
+    if len(numeric_df) > 5000:
+        idx = np.random.choice(numeric_df.index, 5000, replace=False)
+        numeric_df = numeric_df.loc[idx]
+        labels = labels.loc[idx]
+        
+    score = silhouette_score(numeric_df, labels)
+    
+    return {
+        "silhouette_score": score,
+        "summary": f"Clusters are {'well-separated' if score > 0.5 else 'overlapping'}. Score: {score:.3f}"
+    }
+'''
+
+# ══════════════════════════════════════════════════════════════════════════════
+# NEW TEMPLATES — Advanced Preprocessing, Clustering, Specialised Models, XAI
+# ══════════════════════════════════════════════════════════════════════════════
+
+# ── Advanced Preprocessing ────────────────────────────────────────────────────
+
+PROPER_CAPITALIZATION_CLEANER = '''from typing import Annotated
+
+def run(data, columns: str = "") -> dict:
+    """Standardise text casing in string columns (title-case by default).
+    Leave columns blank to process all object columns.
+    """
+    import pandas as pd
+
+    df = data.copy()
+    cols = [c.strip() for c in columns.split(",") if c.strip()] if columns.strip() \
+           else df.select_dtypes(include=["object", "category"]).columns.tolist()
+    fixed = []
+    for col in cols:
+        if col in df.columns:
+            df[col] = df[col].astype(str).str.strip().str.title()
+            fixed.append(col)
+    return {"data": df, "fixed_columns": fixed}
+'''
+
+Z_SCORE_OUTLIER_DETECTOR = '''
+def run(data, threshold: float = 3.0, method: str = "flag") -> dict:
+    """Detect extreme outliers using Z-scores (|Z| > threshold).
+
+    method='flag'  — adds a boolean  *_outlier  column for each numeric feature.
+    method='drop'  — removes rows where ANY feature exceeds the threshold.
+    method='clip'  — clips values to ±threshold standard deviations.
+    """
+    import pandas as pd
+    import numpy as np
+
+    df = data.copy()
+    num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    rows_before = len(df)
+
+    if method == "flag":
+        for col in num_cols:
+            mean, std = df[col].mean(), df[col].std()
+            if std > 0:
+                df[f"{col}_outlier"] = (((df[col] - mean) / std).abs() > threshold)
+        return {"data": df, "columns_flagged": len(num_cols)}
+
+    elif method == "drop":
+        keep = pd.Series(True, index=df.index)
+        for col in num_cols:
+            mean, std = df[col].mean(), df[col].std()
+            if std > 0:
+                keep &= ((df[col] - mean) / std).abs() <= threshold
+        df = df[keep]
+        return {"data": df, "rows_removed": rows_before - len(df)}
+
+    else:  # clip
+        for col in num_cols:
+            mean, std = df[col].mean(), df[col].std()
+            if std > 0:
+                df[col] = df[col].clip(mean - threshold * std, mean + threshold * std)
+        return {"data": df, "columns_clipped": len(num_cols)}
+'''
+
+BOX_COX_TRANSFORMER = '''from typing import Annotated
+
+def run(data, columns: str = "") -> dict:
+    """Apply Box-Cox transformation to stabilise variance in positive numeric columns.
+
+    More powerful than log1p for regression targets — finds the optimal lambda
+    per column. Skips columns with non-positive values (Box-Cox requires x > 0).
+    Leave columns blank to transform all eligible numeric columns.
+    """
+    import pandas as pd
+    import numpy as np
+    from scipy.stats import boxcox
+
+    df = data.copy()
+    num_cols = [c.strip() for c in columns.split(",") if c.strip()] if columns.strip() \
+               else df.select_dtypes(include=[np.number]).columns.tolist()
+
+    transformed, skipped, lambdas = [], [], {}
+    for col in num_cols:
+        if col not in df.columns:
+            continue
+        if df[col].min() <= 0:
+            skipped.append(col)
+            continue
+        df[col], lam = boxcox(df[col].dropna())
+        lambdas[col] = round(float(lam), 4)
+        transformed.append(col)
+
+    return {"data": df, "transformed": transformed, "skipped_non_positive": skipped, "lambdas": lambdas}
+'''
+
+MEAN_TARGET_ENCODER = '''from typing import Annotated
+
+def run(data,
+        column: Annotated[str, "column"] = "category",
+        target: Annotated[str, "column"] = "target",
+        smoothing: int = 10) -> dict:
+    """Replace a categorical column with the smoothed mean of the target per category.
+
+    Smoothing blends category mean with global mean to prevent overfitting on rare
+    categories. The original column is dropped; a new *_mean_enc column is added.
+    Ideal for high-cardinality columns in Kaggle-style tasks.
+    """
+    import pandas as pd
+    import numpy as np
+
+    df = data.copy()
+    if column not in df.columns:
+        raise ValueError(f"Column '{column}' not found.")
+    if target not in df.columns:
+        raise ValueError(f"Target '{target}' not found.")
+
+    global_mean = df[target].mean()
+    stats = df.groupby(column)[target].agg(["mean", "count"])
+    smoothed = (stats["count"] * stats["mean"] + smoothing * global_mean) / (stats["count"] + smoothing)
+
+    new_col = f"{column}_mean_enc"
+    df[new_col] = df[column].map(smoothed).fillna(global_mean)
+    df = df.drop(columns=[column])
+    return {"data": df, "new_column": new_col, "unique_categories": int(len(stats))}
+'''
+
+COLOCATED_FEATURE_GENERATOR = '''from typing import Annotated
+
+def run(data,
+        lat_col: Annotated[str, "column"] = "latitude",
+        lon_col: Annotated[str, "column"] = "longitude") -> dict:
+    """Generate distance-based features from latitude/longitude coordinates.
+
+    Adds: distance_from_centroid, distance_from_origin, lat_lon_product.
+    Useful for real estate, logistics, and location-based prediction tasks.
+    """
+    import pandas as pd
+    import numpy as np
+
+    df = data.copy()
+    for col in (lat_col, lon_col):
+        if col not in df.columns:
+            raise ValueError(f"Column '{col}' not found.")
+
+    lat, lon = df[lat_col].astype(float), df[lon_col].astype(float)
+    cx, cy = lat.mean(), lon.mean()
+
+    df["distance_from_centroid"] = np.sqrt((lat - cx) ** 2 + (lon - cy) ** 2)
+    df["distance_from_origin"]   = np.sqrt(lat ** 2 + lon ** 2)
+    df["lat_lon_product"]        = lat * lon
+    df["lat_lon_ratio"]          = (lat / lon.replace(0, np.nan)).fillna(0)
+
+    return {"data": df, "features_added": ["distance_from_centroid", "distance_from_origin", "lat_lon_product", "lat_lon_ratio"]}
+'''
+
+ZIP_CODE_GROUPER = '''from typing import Annotated
+
+def run(data,
+        zip_column: Annotated[str, "column"] = "zip_code",
+        prefix_length: int = 3) -> dict:
+    """Cluster postal codes into regional groups by truncating to the first N digits.
+
+    Reduces cardinality from thousands of unique zip codes down to hundreds of regions.
+    Adds a new  *_region  column and drops the original.
+    """
+    import pandas as pd
+
+    df = data.copy()
+    if zip_column not in df.columns:
+        raise ValueError(f"Column '{zip_column}' not found.")
+
+    region_col = f"{zip_column}_region"
+    df[region_col] = df[zip_column].astype(str).str.strip().str[:prefix_length].str.zfill(prefix_length)
+    original_unique = int(df[zip_column].nunique())
+    region_unique   = int(df[region_col].nunique())
+    df = df.drop(columns=[zip_column])
+    return {"data": df, "original_unique": original_unique, "region_unique": region_unique, "new_column": region_col}
+'''
+
+NULL_INDICATOR_CREATOR = '''
+def run(data, min_missing_rate: float = 0.0) -> dict:
+    """Add boolean indicator columns for columns that contain missing values.
+
+    For each column with missing rate > min_missing_rate, adds a *_was_null
+    binary column (1 = was missing, 0 = was present).
+
+    Sometimes the FACT that data is missing is itself a predictive signal
+    (e.g., a blank 'income' field may indicate unemployment).
+    """
+    import pandas as pd
+
+    df = data.copy()
+    missing_rates = df.isnull().mean()
+    eligible = missing_rates[missing_rates > min_missing_rate].index.tolist()
+
+    added = []
+    for col in eligible:
+        indicator = f"{col}_was_null"
+        df[indicator] = df[col].isnull().astype(int)
+        added.append(indicator)
+
+    return {"data": df, "indicators_added": added, "count": len(added)}
+'''
+
+# ── Unsupervised & Clustering ─────────────────────────────────────────────────
+
+UMAP_DIMENSIONALITY_REDUCTION = '''
+def run(data, n_components: int = 2, n_neighbors: int = 15, min_dist: float = 0.1) -> dict:
+    """Reduce dimensions to 2D (or n_components) using UMAP.
+
+    Falls back to t-SNE if umap-learn is not installed.
+    Samples up to 10,000 rows for speed. Adds  umap_1, umap_2  columns.
+    """
+    import numpy as np
+    import pandas as pd
+
+    df = data.copy()
+    num_df = df.select_dtypes(include=[np.number]).dropna()
+    if num_df.empty:
+        raise ValueError("No numeric columns found for UMAP.")
+    if len(num_df) > 10_000:
+        num_df = num_df.sample(10_000, random_state=42)
+
+    try:
+        import umap
+        reducer = umap.UMAP(n_components=n_components, n_neighbors=n_neighbors,
+                            min_dist=min_dist, random_state=42)
+        embedding = reducer.fit_transform(num_df.values)
+        method = "UMAP"
+    except ImportError:
+        from sklearn.manifold import TSNE
+        reducer = TSNE(n_components=min(n_components, 3), perplexity=min(30, len(num_df) - 1),
+                       random_state=42, n_iter=500)
+        embedding = reducer.fit_transform(num_df.values)
+        method = "t-SNE (UMAP fallback — pip install umap-learn)"
+
+    out_df = num_df.copy()
+    for i in range(embedding.shape[1]):
+        out_df[f"umap_{i+1}"] = embedding[:, i]
+
+    return {
+        "data": out_df,
+        "method": method,
+        "feature_target_scatter": {
+            "x": embedding[:, 0].tolist(),
+            "y": embedding[:, 1].tolist(),
+            "feature_name": "umap_1",
+            "target_name":  "umap_2",
+        },
+    }
+'''
+
+ELBOW_METHOD_DATA = '''
+def run(data, max_k: int = 10, sample_size: int = 5000) -> dict:
+    """Compute K-Means inertia for K = 1 … max_k to produce an Elbow curve.
+
+    Run this BEFORE KMeans to pick the optimal number of clusters.
+    Returns inertias and a recommended_k heuristic (largest second-derivative).
+    """
+    import numpy as np
+    import pandas as pd
+    from sklearn.cluster import KMeans
+    from sklearn.preprocessing import StandardScaler
+
+    df = data.select_dtypes(include=[np.number]).dropna()
+    if len(df) > sample_size:
+        df = df.sample(sample_size, random_state=42)
+
+    scaler = StandardScaler()
+    X = scaler.fit_transform(df)
+
+    inertias, ks = [], list(range(1, max_k + 1))
+    for k in ks:
+        km = KMeans(n_clusters=k, n_init=5, random_state=42)
+        km.fit(X)
+        inertias.append(float(km.inertia_))
+
+    # Second-derivative heuristic for recommended K
+    recommended_k = 2
+    if len(inertias) >= 3:
+        diffs2 = [inertias[i-1] - 2*inertias[i] + inertias[i+1] for i in range(1, len(inertias)-1)]
+        recommended_k = diffs2.index(max(diffs2)) + 2  # +2 because we start at k=1
+
+    return {"ks": ks, "inertias": inertias, "recommended_k": recommended_k, "summary": f"Elbow suggests K={recommended_k}"}
+'''
+
+# ── Specialised Models ────────────────────────────────────────────────────────
+
+BALANCED_RF_CLASSIFIER = '''from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import cross_val_score
+
+def run(
+    X_train, X_test, y_train,
+    n_estimators: int = 100,
+    max_depth: int = 0,
+    random_state: int = 42,
+    cross_validation: bool = False,
+    cv_folds: int = 5,
+) -> dict:
+    """Random Forest with class_weight='balanced' — handles imbalanced classes automatically.
+
+    Unlike a standard RF, every tree is trained with inverse-frequency sample weights so
+    minority classes receive equal attention. No SMOTE required.
+    """
+    import numpy as np
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.model_selection import cross_val_score
+
+    md = max_depth if max_depth > 0 else None
+    model = RandomForestClassifier(
+        n_estimators=n_estimators,
+        max_depth=md,
+        class_weight="balanced",
+        random_state=random_state,
+    )
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="f1_weighted")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()),  4)}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+RIDGE_CV_REGRESSOR = '''
+def run(X_train, X_test, y_train, cv_folds: int = 5) -> dict:
+    """Ridge regression with automatic alpha selection via built-in cross-validation.
+
+    RidgeCV tests a range of regularisation strengths and picks the best one
+    automatically — no manual hyperparameter tuning needed.
+    """
+    import numpy as np
+    from sklearn.linear_model import RidgeCV
+
+    alphas = [0.01, 0.1, 1.0, 10.0, 100.0, 1000.0]
+    model  = RidgeCV(alphas=alphas, cv=cv_folds)
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {
+        "model": model,
+        "y_pred": y_pred,
+        "best_alpha": float(model.alpha_),
+        "summary": f"RidgeCV selected alpha={model.alpha_:.4g}",
+    }
+'''
+
+POISSON_REGRESSOR = '''
+def run(
+    X_train, X_test, y_train,
+    max_iter: int = 300,
+    alpha: float = 1.0,
+    cross_validation: bool = False,
+    cv_folds: int = 5,
+) -> dict:
+    """Poisson regression — purpose-built for non-negative integer count data.
+
+    Use when the target represents counts (insurance claims, website visits,
+    defects per unit). Standard linear regression is incorrect for count targets.
+    """
+    import numpy as np
+    from sklearn.linear_model import PoissonRegressor
+    from sklearn.model_selection import cross_val_score
+
+    model = PoissonRegressor(alpha=alpha, max_iter=max_iter)
+    if cross_validation:
+        scores = cross_val_score(model, X_train, y_train, cv=cv_folds, scoring="r2")
+        model.fit(X_train, y_train)
+        y_pred = model.predict(X_test)
+        return {"model": model, "y_pred": y_pred,
+                "cv_mean": round(float(scores.mean()), 4),
+                "cv_std":  round(float(scores.std()),  4)}
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+    return {"model": model, "y_pred": y_pred}
+'''
+
+# ── Deep Evaluation & XAI ────────────────────────────────────────────────────
+
+SHAP_EXPLAINER = '''
+def run(model, X_train, X_test) -> dict:
+    """Compute SHAP (Shapley Additive Explanations) values for model interpretability.
+
+    Returns per-feature mean |SHAP| importances and the top feature.
+    Falls back to permutation importance if shap is not installed.
+    Samples up to 200 rows from X_test for speed.
+    """
+    import numpy as np
+    import pandas as pd
+
+    cols = list(X_train.columns) if hasattr(X_train, "columns") else [f"f{i}" for i in range(X_train.shape[1])]
+    X_sample = X_test[:200] if len(X_test) > 200 else X_test
+
+    try:
+        import shap
+        # TreeExplainer is fast for tree-based models; falls back to KernelExplainer otherwise
+        try:
+            explainer   = shap.TreeExplainer(model)
+            shap_values = explainer.shap_values(X_sample)
+        except Exception:
+            explainer   = shap.KernelExplainer(model.predict, shap.sample(X_sample, 50))
+            shap_values = explainer.shap_values(X_sample, nsamples=100)
+
+        # For multiclass, shap_values is a list — take mean over classes
+        if isinstance(shap_values, list):
+            shap_arr = np.mean([np.abs(sv) for sv in shap_values], axis=0)
+        else:
+            shap_arr = np.abs(shap_values)
+
+        mean_shap = shap_arr.mean(axis=0)
+        pairs     = sorted(zip(mean_shap, cols), reverse=True)
+        return {
+            "feature_importances": {c: round(float(v), 6) for v, c in pairs},
+            "top_feature":         pairs[0][1],
+            "top_shap_value":      round(float(pairs[0][0]), 6),
+            "method":              "SHAP",
+        }
+
+    except ImportError:
+        # Fallback: permutation importance
+        from sklearn.inspection import permutation_importance
+        r = permutation_importance(model, X_sample, model.predict(X_sample), n_repeats=5, random_state=42)
+        pairs = sorted(zip(r.importances_mean, cols), reverse=True)
+        return {
+            "feature_importances": {c: round(float(v), 6) for v, c in pairs},
+            "top_feature":         pairs[0][1],
+            "top_shap_value":      round(float(pairs[0][0]), 6),
+            "method":              "Permutation Importance (pip install shap for SHAP values)",
+        }
+'''
+
+PARTIAL_DEPENDENCE_PLOTS = '''from typing import Annotated
+
+def run(model, X_train, feature: Annotated[str, "column"] = "feature_name") -> dict:
+    """Compute Partial Dependence Plot data: the marginal effect of one feature on predictions.
+
+    Shows HOW the model's output changes as a single feature varies, holding all others constant.
+    Crucial for understanding the direction and shape of a feature's influence.
+    """
+    import numpy as np
+    import pandas as pd
+    from sklearn.inspection import partial_dependence
+
+    if feature not in X_train.columns:
+        raise ValueError(f"Feature '{feature}' not in X_train columns: {list(X_train.columns)}")
+
+    sample = X_train.sample(min(1000, len(X_train)), random_state=42) if len(X_train) > 1000 else X_train
+
+    try:
+        result   = partial_dependence(model, sample, features=[feature], kind="average")
+        grid     = result["grid_values"][0].tolist()
+        response = result["average"][0].tolist()
+    except Exception as e:
+        raise ValueError(f"Partial dependence failed: {e}")
+
+    return {
+        "partial_dependence": {
+            "feature":          feature,
+            "grid":             grid,
+            "average_response": response,
+        },
+        "feature_name": feature,
+    }
+'''
+
+CALIBRATION_CURVE_DATA = '''
+def run(model, X_test, y_test, n_bins: int = 10) -> dict:
+    """Check if a classifier's predicted probabilities are well-calibrated.
+
+    A perfectly calibrated model has its 90th-percentile predictions correct 90% of the time.
+    Returns fraction_of_positives vs mean_predicted_probability for plotting.
+    """
+    import numpy as np
+    from sklearn.calibration import calibration_curve
+
+    if not hasattr(model, "predict_proba"):
+        raise ValueError("Model must support predict_proba for calibration analysis.")
+
+    y_prob = model.predict_proba(X_test)
+    # Binary: use positive class; multiclass: use max probability
+    if y_prob.shape[1] == 2:
+        prob_pos = y_prob[:, 1]
+        y_bin    = np.asarray(y_test)
+    else:
+        prob_pos = y_prob.max(axis=1)
+        y_bin    = (np.asarray(y_test) == model.classes_[y_prob.argmax(axis=1)]).astype(int)
+
+    frac_pos, mean_pred = calibration_curve(y_bin, prob_pos, n_bins=n_bins, strategy="uniform")
+
+    brier = float(np.mean((prob_pos - y_bin) ** 2))
+    return {
+        "fraction_of_positives": frac_pos.tolist(),
+        "mean_predicted_value":  mean_pred.tolist(),
+        "brier_score":           round(brier, 4),
+        "summary": f"Brier score: {brier:.4f} (lower = better calibrated)",
+    }
+'''
+
+LEARNING_CURVE_ANALYZER = '''
+def run(model, X_train, y_train, cv_folds: int = 5, scoring: str = "accuracy") -> dict:
+    """Plot training vs validation score across increasing dataset sizes.
+
+    Diagnoses model behaviour:
+      - High train score, low val score → overfitting (try regularisation)
+      - Both scores low → underfitting (try more complex model or features)
+      - Scores converge at high sample count → more data won't help
+    """
+    import numpy as np
+    from sklearn.model_selection import learning_curve
+
+    # Use 5 evenly spaced training sizes from 10% to 100%
+    train_sizes_abs, train_scores, val_scores = learning_curve(
+        model, X_train, y_train,
+        cv=cv_folds,
+        scoring=scoring,
+        train_sizes=np.linspace(0.1, 1.0, 5),
+        n_jobs=-1,
+    )
+
+    return {
+        "train_sizes":   train_sizes_abs.tolist(),
+        "train_scores":  train_scores.mean(axis=1).round(4).tolist(),
+        "val_scores":    val_scores.mean(axis=1).round(4).tolist(),
+        "train_std":     train_scores.std(axis=1).round(4).tolist(),
+        "val_std":       val_scores.std(axis=1).round(4).tolist(),
+        "scoring":       scoring,
+        "summary":       f"Final val {scoring}: {val_scores.mean(axis=1)[-1]:.4f}",
+    }
+'''
+
+COST_BENEFIT_MATRIX = '''
+def run(
+    y_test, y_pred,
+    tp_value:  float = 100.0,
+    fp_cost:   float =  10.0,
+    fn_cost:   float =  50.0,
+    tn_value:  float =   0.0,
+) -> dict:
+    """Compute business value of model predictions using a cost-benefit matrix.
+
+    Assign dollar values to each outcome type (TP, FP, FN, TN) to translate
+    model accuracy into real business impact. Essential for fraud detection,
+    churn prevention, and medical diagnostics where error costs differ.
+    """
+    import numpy as np
+    from sklearn.metrics import confusion_matrix
+
+    y_t, y_p = np.asarray(y_test), np.asarray(y_pred)
+    if len(np.unique(y_t)) != 2:
+        raise ValueError("Cost-benefit matrix requires binary classification.")
+
+    cm = confusion_matrix(y_t, y_p)
+    tn, fp, fn, tp = cm.ravel()
+
+    total_value     = tp * tp_value - fp * fp_cost - fn * fn_cost + tn * tn_value
+    random_value    = (len(y_t) * y_t.mean()) * tp_value - (len(y_t) * (1 - y_t.mean())) * fp_cost
+    value_per_case  = total_value / len(y_t)
+
+    return {
+        "confusion_matrix": {"TP": int(tp), "FP": int(fp), "FN": int(fn), "TN": int(tn)},
+        "total_business_value": round(total_value,    2),
+        "random_baseline_value": round(random_value,  2),
+        "value_per_case":        round(value_per_case, 2),
+        "roi_vs_random":         round((total_value - random_value) / max(abs(random_value), 1) * 100, 1),
+        "summary": f"Model generates ${total_value:,.0f} total vs ${random_value:,.0f} random baseline.",
+    }
+'''
+
+
+TEMPLATES: list[dict] = [
+    # Data
+    {"id": "csv_loader",                  "label": "CSV Loader",              "category": "Data",          "code": CSV_LOADER},
+    {"id": "csv_exporter",                "label": "CSV Exporter",            "category": "Data",          "code": CSV_EXPORTER},
+    {"id": "eda",                         "label": "EDA",                     "category": "Data",          "code": EDA},
+    {"id": "eda_histogram",               "label": "Histogram",               "category": "Visualize",     "code": EDA_HISTOGRAM},
+    {"id": "eda_correlation",             "label": "Correlation Matrix",      "category": "Visualize",     "code": EDA_CORRELATION},
+    {"id": "eda_value_counts",            "label": "Value Counts",            "category": "Visualize",     "code": EDA_VALUE_COUNTS},
+    {"id": "eda_box_plot",                "label": "Box Plot",                "category": "Visualize",     "code": EDA_BOX_PLOT},
+    {"id": "predict",                     "label": "Predict",                 "category": "Visualize",     "code": PREDICT},
+    # Preprocessing
+    {"id": "data_cleaning",               "label": "Data Cleaning",           "category": "Preprocessing", "code": DATA_CLEANING},
+    {"id": "smart_outlier_remover",        "label": "Smart Outlier Remover",   "category": "Preprocessing", "code": SMART_OUTLIER_REMOVER},
+    {"id": "advanced_imputer",            "label": "Advanced Imputer",        "category": "Preprocessing", "code": ADVANCED_IMPUTER},
+    {"id": "skewness_fixer",              "label": "Skewness Fixer",          "category": "Preprocessing", "code": SKEWNESS_FIXER},
+    {"id": "high_cardinality_encoder",    "label": "High-Cardinality Encoder","category": "Preprocessing", "code": HIGH_CARDINALITY_ENCODER},
+    {"id": "feature_scaler_robust",       "label": "Robust Scaler",           "category": "Preprocessing", "code": FEATURE_SCALER_ROBUST},
+    {"id": "multicollinearity_filter",    "label": "Multicollinearity Filter","category": "Preprocessing", "code": MULTICOLLINEARITY_FILTER},
+    {"id": "text_cleaner_basic",          "label": "Text Cleaner",            "category": "Preprocessing", "code": TEXT_CLEANER_BASIC},
+    {"id": "smote_sampler",               "label": "SMOTE Sampler",           "category": "Preprocessing", "code": SMOTE_SAMPLER},
+    {"id": "label_encoder",               "label": "Label Encoder",           "category": "Preprocessing", "code": LABEL_ENCODER},
+    {"id": "one_hot_encoder",             "label": "One-Hot Encoder",         "category": "Preprocessing", "code": ONE_HOT_ENCODER},
+    {"id": "train_test_split",            "label": "Train/Test Split",        "category": "Preprocessing", "code": TRAIN_TEST_SPLIT},
+    {"id": "standard_scaler",             "label": "Standard Scaler",         "category": "Preprocessing", "code": STANDARD_SCALER},
+    {"id": "min_max_scaler",              "label": "Min-Max Scaler",          "category": "Preprocessing", "code": MIN_MAX_SCALER},
+    {"id": "pca",                         "label": "PCA",                     "category": "Preprocessing", "code": PCA},
+    {"id": "polynomial_features",         "label": "Polynomial Features",     "category": "Preprocessing", "code": POLYNOMIAL_FEATURES},
+    {"id": "datetime_extractor",          "label": "Datetime Extractor",      "category": "Preprocessing", "code": DATETIME_EXTRACTOR},
+    {"id": "binary_encoder",              "label": "Binary Encoder",          "category": "Preprocessing", "code": BINARY_ENCODER},
+    {"id": "frequency_encoder",           "label": "Frequency Encoder",       "category": "Preprocessing", "code": FREQUENCY_ENCODER},
+    {"id": "ordinal_encoder",             "label": "Ordinal Encoder",         "category": "Preprocessing", "code": ORDINAL_ENCODER},
+    {"id": "vif_feature_selection",       "label": "VIF Feature Selection",   "category": "Preprocessing", "code": VIF_FEATURE_SELECTION},
+    {"id": "pca_whitening",               "label": "PCA Whitening",           "category": "Preprocessing", "code": PCA_WHITENING},
+    {"id": "k_means_clustering_features", "label": "K-Means Features",        "category": "Preprocessing", "code": K_MEANS_CLUSTERING_FEATURES},
+    {"id": "lag_feature_generator",       "label": "Lag Features",            "category": "Preprocessing", "code": LAG_FEATURE_GENERATOR},
+    {"id": "rolling_window_stats",        "label": "Rolling Window Stats",    "category": "Preprocessing", "code": ROLLING_WINDOW_STATS},
+    {"id": "tomek_links",                 "label": "Tomek Links",             "category": "Preprocessing", "code": TOMEK_LINKS},
+    {"id": "random_under_sampler",        "label": "Random Under Sampler",    "category": "Preprocessing", "code": RANDOM_UNDER_SAMPLER},
+    {"id": "rfe_feature_selector",        "label": "RFE Feature Selector",    "category": "Preprocessing", "code": RFE_FEATURE_SELECTOR},
+    # Classifiers
+    {"id": "logistic_regression",         "label": "Logistic Regression",     "category": "Classifiers",   "code": LOGISTIC_REGRESSION},
+    {"id": "random_forest_classifier",    "label": "RF Classifier",           "category": "Classifiers",   "code": RANDOM_FOREST_CLASSIFIER},
+    {"id": "gradient_boosting_classifier","label": "GB Classifier",           "category": "Classifiers",   "code": GRADIENT_BOOSTING_CLASSIFIER},
+    {"id": "decision_tree_classifier",    "label": "DT Classifier",           "category": "Classifiers",   "code": DECISION_TREE_CLASSIFIER},
+    {"id": "svm_classifier",              "label": "SVM Classifier",          "category": "Classifiers",   "code": SVM_CLASSIFIER},
+    {"id": "knn_classifier",              "label": "KNN Classifier",          "category": "Classifiers",   "code": KNN_CLASSIFIER},
+    {"id": "xgboost_node",                "label": "XGBoost",                 "category": "Classifiers",   "code": XGBOOST_NODE},
+    {"id": "lightgbm_node",               "label": "LightGBM",                "category": "Classifiers",   "code": LIGHTGBM_NODE},
+    {"id": "adaboost_node",               "label": "AdaBoost",                "category": "Classifiers",   "code": ADABOOST_NODE},
+    {"id": "voting_ensemble",             "label": "Voting Ensemble",         "category": "Classifiers",   "code": VOTING_ENSEMBLE},
+    # Regressors
+    {"id": "linear_regression",           "label": "Linear Regression",       "category": "Regression",    "code": LINEAR_REGRESSION},
+    {"id": "random_forest_regressor",     "label": "RF Regressor",            "category": "Regression",    "code": RANDOM_FOREST_REGRESSOR},
+    {"id": "gradient_boosting_regressor", "label": "GB Regressor",            "category": "Regression",    "code": GRADIENT_BOOSTING_REGRESSOR},
+    {"id": "decision_tree_regressor",     "label": "DT Regressor",            "category": "Regression",    "code": DECISION_TREE_REGRESSOR},
+    {"id": "svm_regressor",               "label": "SVM Regressor",           "category": "Regression",    "code": SVM_REGRESSOR},
+    {"id": "knn_regressor",               "label": "KNN Regressor",           "category": "Regression",    "code": KNN_REGRESSOR},
+    # Evaluation
+    {"id": "accuracy",                    "label": "Accuracy",                "category": "Evaluation",    "code": ACCURACY},
+    {"id": "classification_report",       "label": "Classification Report",   "category": "Evaluation",    "code": CLASSIFICATION_REPORT},
+    {"id": "validation_report",           "label": "Validation Report",       "category": "Evaluation",    "code": VALIDATION_REPORT},
+    {"id": "regression_metrics",          "label": "Regression Metrics",      "category": "Evaluation",    "code": REGRESSION_METRICS},
+    {"id": "feature_importance",          "label": "Feature Importance",      "category": "Evaluation",    "code": FEATURE_IMPORTANCE},
+    {"id": "confusion_matrix_plotter",    "label": "Confusion Matrix",        "category": "Visualize",     "code": CONFUSION_MATRIX_PLOTTER},
+    {"id": "roc_pr_curve_data",           "label": "ROC & PR Curves",         "category": "Visualize",     "code": ROC_PR_CURVE_DATA},
+    {"id": "residual_plotter",            "label": "Residual Plot",           "category": "Visualize",     "code": RESIDUAL_PLOTTER},
+    {"id": "feature_importance_visualizer","label": "Feature Importance Plot","category": "Visualize",     "code": FEATURE_IMPORTANCE_VISUALIZER},
+    {"id": "decision_boundary_2d",        "label": "Decision Boundary 2D",    "category": "Visualize",     "code": DECISION_BOUNDARY_2D},
+    {"id": "prediction_vs_actual_scatter","label": "Pred vs Actual Scatter",  "category": "Visualize",     "code": PREDICTION_VS_ACTUAL_SCATTER},
+    {"id": "inverse_target_transformer",  "label": "Inverse Transformer",     "category": "Evaluation",    "code": INVERSE_TARGET_TRANSFORMER},
+    {"id": "threshold_optimizer",         "label": "Threshold Optimizer",     "category": "Evaluation",    "code": THRESHOLD_OPTIMIZER},
+    {"id": "permutation_importance",      "label": "Permutation Importance",  "category": "Evaluation",    "code": PERMUTATION_IMPORTANCE},
+    {"id": "learning_curve_data",         "label": "Learning Curve",          "category": "Evaluation",    "code": LEARNING_CURVE_DATA},
+    {"id": "lift_gain_charts",            "label": "Lift & Gain Charts",      "category": "Evaluation",    "code": LIFT_GAIN_CHARTS},
+    {"id": "auto_ml",                     "label": "AutoML",                  "category": "Evaluation",    "code": AUTO_ML},
+    {"id": "correlation_heatmap",         "label": "Correlation Heatmap",     "category": "Visualize",     "code": CORRELATION_HEATMAP},
+    {"id": "missing_value_map",           "label": "Missing Value Map",       "category": "Visualize",     "code": MISSING_VALUE_MAP},
+    {"id": "class_balance_visualizer",    "label": "Class Balance",           "category": "Visualize",     "code": CLASS_BALANCE_VISUALIZER},
+    {"id": "feature_target_scatter",      "label": "Feature/Target Scatter",  "category": "Visualize",     "code": FEATURE_TARGET_SCATTER},
+    {"id": "model_error_histogram",       "label": "Model Error Histogram",   "category": "Visualize",     "code": MODEL_ERROR_HISTOGRAM},
+    {"id": "partial_dependence_data",     "label": "Partial Dependence",      "category": "Visualize",     "code": PARTIAL_DEPENDENCE_DATA},
+    {"id": "multiclass_roc_data",         "label": "Multiclass ROC",          "category": "Visualize",     "code": MULTICLASS_ROC_DATA},
+    
+    # Unsupervised
+    {"id": "dbscan_clustering",           "label": "DBSCAN Clustering",       "category": "Unsupervised",  "code": DBSCAN_CLUSTERING},
+    {"id": "tsne_visualizer",             "label": "t-SNE Visualizer",        "category": "Unsupervised",  "code": TSNE_VISUALIZER},
+    {"id": "isolation_forest_anomaly",    "label": "Isolation Forest",        "category": "Unsupervised",  "code": ISOLATION_FOREST_ANOMALY},
+
+    # Ensembles
+    {"id": "stacking_regressor",          "label": "Stacking Regressor",      "category": "Regression",    "code": STACKING_REGRESSOR},
+    {"id": "quantile_regressor",          "label": "Quantile Regressor",      "category": "Regression",    "code": QUANTILE_REGRESSOR},
+
+    # Agentic / Reinforcement
+    {"id": "epsilon_greedy_bandit",       "label": "Epsilon-Greedy Bandit",   "category": "Agentic",       "code": EPSILON_GREEDY_BANDIT},
+    {"id": "markov_chain_simulator",      "label": "Markov Chain Simulator",  "category": "Agentic",       "code": MARKOV_CHAIN_SIMULATOR},
+
+    # Evaluation
+    {"id": "silhouette_score_node",       "label": "Silhouette Score",        "category": "Evaluation",    "code": SILHOUETTE_SCORE_NODE},
+
+    # ── Advanced Preprocessing ───────────────────────────────────────────────
+    {"id": "proper_capitalization_cleaner", "label": "Capitalisation Cleaner",   "category": "Preprocessing", "code": PROPER_CAPITALIZATION_CLEANER},
+    {"id": "z_score_outlier_detector",      "label": "Z-Score Outlier Detector", "category": "Preprocessing", "code": Z_SCORE_OUTLIER_DETECTOR},
+    {"id": "box_cox_transformer",           "label": "Box-Cox Transformer",      "category": "Preprocessing", "code": BOX_COX_TRANSFORMER},
+    {"id": "mean_target_encoder",           "label": "Mean Target Encoder",      "category": "Preprocessing", "code": MEAN_TARGET_ENCODER},
+    {"id": "colocated_feature_generator",   "label": "Geo Feature Generator",    "category": "Preprocessing", "code": COLOCATED_FEATURE_GENERATOR},
+    {"id": "zip_code_grouper",              "label": "Zip Code Grouper",         "category": "Preprocessing", "code": ZIP_CODE_GROUPER},
+    {"id": "null_indicator_creator",        "label": "Null Indicator Creator",   "category": "Preprocessing", "code": NULL_INDICATOR_CREATOR},
+
+    # ── Unsupervised & Clustering ────────────────────────────────────────────
+    {"id": "umap_dimensionality_reduction", "label": "UMAP Reducer",            "category": "Unsupervised",  "code": UMAP_DIMENSIONALITY_REDUCTION},
+    {"id": "elbow_method_data",             "label": "Elbow Method",            "category": "Unsupervised",  "code": ELBOW_METHOD_DATA},
+
+    # ── Specialised Models ───────────────────────────────────────────────────
+    {"id": "balanced_rf_classifier",        "label": "Balanced RF Classifier",  "category": "Classifiers",   "code": BALANCED_RF_CLASSIFIER},
+    {"id": "ridge_cv_regressor",            "label": "RidgeCV Regressor",       "category": "Regression",    "code": RIDGE_CV_REGRESSOR},
+    {"id": "poisson_regressor",             "label": "Poisson Regressor",       "category": "Regression",    "code": POISSON_REGRESSOR},
+
+    # ── Deep Evaluation & XAI ────────────────────────────────────────────────
+    {"id": "shap_explainer",                "label": "SHAP Explainer",          "category": "Evaluation",    "code": SHAP_EXPLAINER},
+    {"id": "partial_dependence_plots",      "label": "Partial Dependence Plots","category": "Evaluation",    "code": PARTIAL_DEPENDENCE_PLOTS},
+    {"id": "calibration_curve_data",        "label": "Calibration Curve",       "category": "Evaluation",    "code": CALIBRATION_CURVE_DATA},
+    {"id": "learning_curve_analyzer",       "label": "Learning Curve Analyzer", "category": "Evaluation",    "code": LEARNING_CURVE_ANALYZER},
+    {"id": "cost_benefit_matrix",           "label": "Cost-Benefit Matrix",     "category": "Evaluation",    "code": COST_BENEFIT_MATRIX},
+]
+
+
+def get_template(template_id: str) -> dict | None:
+    for t in TEMPLATES:
+        if t["id"] == template_id:
+            return t
+    return None