Add 6 features: mode-click->UMAP, food-group filter, why-explainers, recipe builder, public API, saved queries (BrowserState)

app.py

@@ -1,4 +1,21 @@
-"""Epicure Explorer: chef-facing operators over the three sibling embeddings."""
+"""Epicure Explorer: chef-facing operators over the three sibling embeddings.
+
+Features:
+  - Basket pairings (with pairwise cosine heatmap)
+  - Supervised SLERP (with "why these results" explainer)
+  - Emergent SLERP (with explainer)
+  - Arithmetic (Mikolov-style, with explainer)
+  - Mode atlas (click row -> highlight on UMAP)
+  - Compare siblings (one query, three columns)
+  - UMAP visualisation (2D / 3D)
+  - Parse my fridge (free-text -> canonical vocab via rapidfuzz)
+  - Recipe builder (hybrid retrieval: rapidfuzz + sentence-transformers over mode labels)
+  - Saved queries (per-browser persistence via gr.BrowserState)
+  - Public developer API (gr.api endpoints for neighbours / slerp / arithmetic / embed)
+  - Food-group filter on every ingredient dropdown
+
+Paper: https://arxiv.org/abs/2605.22391
+"""
 
 from __future__ import annotations
 
@@ -6,13 +23,16 @@ import os
 import re
 import sys
 import json
+import uuid
+from datetime import datetime, timezone
+from functools import lru_cache
+
 import numpy as np
 import gradio as gr
 import plotly.graph_objects as go
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
-from matplotlib.patches import Patch
 
 try:
     from epicure import Epicure
@@ -29,15 +49,12 @@ KAIKAKU_DARK  = "#0F2D2F"
 KAIKAKU_DEEP  = "#0A1F20"
 KAIKAKU_MID   = "#1A3D3F"
 KAIKAKU_EDGE  = "#2A4D4F"
-KAIKAKU_ACCENT = "#288B79"          # darker teal-green - readable on white
+KAIKAKU_ACCENT = "#288B79"
 KAIKAKU_ACCENT_HOVER = "#1E6E5F"
-KAIKAKU_ACCENT_LIGHT = "#A8D5CA"    # background tints only
-KAIKAKU_MINT  = KAIKAKU_ACCENT      # backwards-compat aliases used elsewhere
-KAIKAKU_MINT_BRIGHT = KAIKAKU_ACCENT_HOVER
+KAIKAKU_ACCENT_LIGHT = "#A8D5CA"
 KAIKAKU_TEXT  = "#0F2D2F"
 KAIKAKU_MUTED = "#5A7878"
 
-# Light matplotlib defaults; mint is an accent only
 plt.rcParams.update({
     "figure.facecolor": "#ffffff",
     "axes.facecolor": "#ffffff",
@@ -73,11 +90,28 @@ FG_COLORS = {
     "Other":      "#cccccc",
 }
 
-# Sanity-check log on import so Space logs show whether assets loaded
 print(f"[epicure-explorer] models loaded: {list(MODELS)}", flush=True)
-print(f"[epicure-explorer] UMAP shapes: {{cooc:{UMAP_DATA['cooc'].shape}, core:{UMAP_DATA['core'].shape}, chem:{UMAP_DATA['chem'].shape}}}", flush=True)
-print(f"[epicure-explorer] food group labels: {len(FOOD_GROUPS)} ingredients, "
-      f"{sum(1 for fg in FOOD_GROUPS if fg != 'Other')} with concrete group", flush=True)
+print(f"[epicure-explorer] food group labels: {len(FOOD_GROUPS)} ingredients", flush=True)
+
+# ===== Feature 5: food-group filter helpers =====
+
+_NAME_TO_GROUP: dict[str, str] = {NAMES_BY_IDX[i]: FOOD_GROUPS[i] for i in range(len(NAMES_BY_IDX))}
+FOOD_GROUP_CHOICES = ["All", "Vegetable", "Spice", "Fruit", "Dairy", "Grain", "Pantry", "Beverage", "Other"]
+
+def _choices_for_group(group: str) -> list[str]:
+    if not group or group == "All":
+        return ALL_INGREDIENTS
+    return sorted(n for n in ALL_INGREDIENTS if _NAME_TO_GROUP.get(n, "Other") == group)
+
+def _filter_dropdown(group: str, current_value):
+    new_choices = _choices_for_group(group)
+    allowed = set(new_choices)
+    cur = current_value or []
+    if isinstance(cur, str):
+        kept = cur if cur in allowed else None
+    else:
+        kept = [v for v in cur if v in allowed]
+    return gr.Dropdown(choices=new_choices, value=kept)
 
 # ===== math helpers =====
 
@@ -123,7 +157,58 @@ def _slerp(v, d, theta_deg):
     th = np.deg2rad(float(theta_deg))
     return _unit(np.cos(th)*v + np.sin(th)*d_perp)
 
-# ===== heatmap (matplotlib, reliable) =====
+# ===== Feature 4: explainer helpers =====
+
+def _fmt_nb_inline(pairs):
+    return ", ".join(f"{n} ({s:+.2f})" for n, s in pairs)
+
+def _slerp_explainer(m, basket, direction_keys, theta, q, v, d, kind):
+    if v is None or d is None or q is None:
+        return "_(no rotation applied)_"
+    cos_theta = float(q @ v)
+    travelled = min(max(float(theta) / 90.0, 0.0), 1.0)
+    dir_nb = _topk(m, _unit(d), k=5, exclude=basket or [])
+    seed_nb = _topk(m, v, k=3, exclude=basket or [])
+    dir_names = ", ".join(n for n, _ in dir_nb[:3])
+    label = "direction pole" if kind == "supervised" else "factor-mode pole"
+    dirs_str = " + ".join(direction_keys) if direction_keys else "(none)"
+    return (
+        f"**Why these results**  \n"
+        f"- Rotated query vs. seed centroid: cos = {cos_theta:.3f} (theta = {float(theta):.0f}°; "
+        f"{travelled*100:.0f}% of the way to the {label}).  \n"
+        f"- {label.capitalize()} ({dirs_str}) nearest in vocab: {_fmt_nb_inline(dir_nb)}.  \n"
+        f"- Seed basket's own top-3 (baseline): {_fmt_nb_inline(seed_nb)}.  \n"
+        f"- At {float(theta):.0f}° the query lands near: {dir_names}."
+    )
+
+def _arithmetic_explainer(m, positives, negatives, q, pos_v, neg_v):
+    if q is None:
+        return "_(no result: missing positives)_"
+    pos_sims = [(n, float(_unit(m.E[m.vocab[n]]) @ q)) for n in (positives or []) if n in m.vocab]
+    neg_sims = [(n, float(_unit(m.E[m.vocab[n]]) @ q)) for n in (negatives or []) if n in m.vocab]
+    top = _topk(m, q, k=1, exclude=(positives or []) + (negatives or []))
+    top_name, top_sim = top[0] if top else ("(none)", 0.0)
+    pos_part = ", ".join(f"{n} ({s:+.2f})" for n, s in pos_sims) or "(none)"
+    neg_part = ", ".join(f"{n} ({s:+.2f})" for n, s in neg_sims) or "(none)"
+    input_max = max((s for _, s in pos_sims + neg_sims), default=0.0)
+    if pos_sims or neg_sims:
+        gap = top_sim - input_max
+        if gap > 0.05:
+            interp = (f"Result sits closer to **{top_name}** ({top_sim:+.2f}) "
+                      f"than to any input (max {input_max:+.2f}); the embedding separates these concepts.")
+        else:
+            interp = (f"Result is dominated by the inputs themselves "
+                      f"(top neighbour {top_name} only {gap:+.2f} above max input cosine).")
+    else:
+        interp = f"Result top neighbour: {top_name} ({top_sim:+.2f})."
+    return (
+        f"**Why these results**  \n"
+        f"- Result vs. positives: {pos_part}.  \n"
+        f"- Result vs. negatives: {neg_part}.  \n"
+        f"- {interp}"
+    )
+
+# ===== heatmap =====
 
 def _basket_heatmap(m, basket):
     valid = [n for n in (basket or []) if n in m.vocab]
@@ -154,7 +239,7 @@ def _basket_heatmap(m, basket):
     plt.tight_layout()
     return fig
 
-# ===== UMAP (Plotly, SINGLE TRACE, bulletproof) =====
+# ===== UMAP =====
 
 def _umap_coords(sibling, three_d):
     base = UMAP_DATA[sibling]
@@ -172,86 +257,65 @@ def umap_view(sibling, basket, show_neighbours, k, three_d=False):
     coords2, z = _umap_coords(sibling, three_d)
     m = MODELS[sibling]
     n = len(NAMES_BY_IDX)
-
-    # Pre-compute marker colors and hover text per ingredient
-    colors = [FG_COLORS.get(fg, KAIKAKU_MUTED) for fg in FOOD_GROUPS]
+    colors = [FG_COLORS.get(fg, "#cccccc") for fg in FOOD_GROUPS]
     hover_text = [f"{NAMES_BY_IDX[i]}<br>group: {FOOD_GROUPS[i]}" for i in range(n)]
-
     basket_set = set(basket or [])
     basket_idxs = [m.vocab[b] for b in (basket or []) if b in m.vocab]
-
     neighbour_set: set[str] = set()
     if show_neighbours and basket_idxs:
         centroid = _basket_centroid(m, basket)
         if centroid is not None:
             nb_pairs = _topk(m, centroid, k=int(k), exclude=basket)
             neighbour_set = {nm for nm, _ in nb_pairs}
-
-    # SINGLE background trace: all 1790 points coloured by food group.
-    # One trace beats N traces for reliability in gr.Plot.
-    bg_x = [float(coords2[i, 0]) for i in range(n) if NAMES_BY_IDX[i] not in basket_set and NAMES_BY_IDX[i] not in neighbour_set]
-    bg_y = [float(coords2[i, 1]) for i in range(n) if NAMES_BY_IDX[i] not in basket_set and NAMES_BY_IDX[i] not in neighbour_set]
-    bg_z = [float(z[i])           for i in range(n) if NAMES_BY_IDX[i] not in basket_set and NAMES_BY_IDX[i] not in neighbour_set] if three_d else None
-    bg_c = [colors[i]             for i in range(n) if NAMES_BY_IDX[i] not in basket_set and NAMES_BY_IDX[i] not in neighbour_set]
-    bg_h = [hover_text[i]         for i in range(n) if NAMES_BY_IDX[i] not in basket_set and NAMES_BY_IDX[i] not in neighbour_set]
-
+    bg_keep = lambda i: NAMES_BY_IDX[i] not in basket_set and NAMES_BY_IDX[i] not in neighbour_set
+    bg_x = [float(coords2[i, 0]) for i in range(n) if bg_keep(i)]
+    bg_y = [float(coords2[i, 1]) for i in range(n) if bg_keep(i)]
+    bg_z = [float(z[i]) for i in range(n) if bg_keep(i)] if three_d else None
+    bg_c = [colors[i] for i in range(n) if bg_keep(i)]
+    bg_h = [hover_text[i] for i in range(n) if bg_keep(i)]
     fig = go.Figure()
-
     if three_d:
         fig.add_trace(go.Scatter3d(
             x=bg_x, y=bg_y, z=bg_z, mode="markers",
             marker=dict(size=3, color=bg_c, opacity=0.55, line=dict(width=0)),
-            text=bg_h, hovertemplate="%{text}<extra></extra>", name="ingredients",
-            showlegend=False,
+            text=bg_h, hovertemplate="%{text}<extra></extra>", name="ingredients", showlegend=False,
         ))
     else:
         fig.add_trace(go.Scattergl(
             x=bg_x, y=bg_y, mode="markers",
             marker=dict(size=5, color=bg_c, opacity=0.65, line=dict(width=0)),
-            text=bg_h, hovertemplate="%{text}<extra></extra>", name="ingredients",
-            showlegend=False,
+            text=bg_h, hovertemplate="%{text}<extra></extra>", name="ingredients", showlegend=False,
         ))
-
-    # Neighbour highlights (amber)
     if neighbour_set:
         ni = [i for i in range(n) if NAMES_BY_IDX[i] in neighbour_set]
         nx = [float(coords2[i, 0]) for i in ni]
         ny = [float(coords2[i, 1]) for i in ni]
         nz = [float(z[i]) for i in ni] if three_d else None
         nlabels = [NAMES_BY_IDX[i] for i in ni]
-        marker = dict(size=11 if not three_d else 6,
-                      color="#ff8800",
-                      opacity=0.95,
+        marker = dict(size=11 if not three_d else 6, color="#ff8800", opacity=0.95,
                       line=dict(color="#ffffff", width=1.2))
         TR = go.Scatter3d if three_d else go.Scatter
-        kwargs = dict(mode="markers+text",
-                      marker=marker, text=nlabels, textposition="top center",
+        kwargs = dict(mode="markers+text", marker=marker, text=nlabels, textposition="top center",
                       textfont=dict(size=10),
                       hovertemplate="<b>%{text}</b> (neighbour)<extra></extra>",
                       name=f"top-{k} neighbours")
         fig.add_trace(TR(x=nx, y=ny, z=nz, **kwargs) if three_d else TR(x=nx, y=ny, **kwargs))
-
-    # Basket highlights (mint star, accent only)
     if basket_idxs:
         bx = [float(coords2[i, 0]) for i in basket_idxs]
         by = [float(coords2[i, 1]) for i in basket_idxs]
         bz = [float(z[i]) for i in basket_idxs] if three_d else None
         blabels = [NAMES_BY_IDX[i] for i in basket_idxs]
-        marker = dict(size=18 if not three_d else 9,
-                      color=KAIKAKU_MINT,
+        marker = dict(size=18 if not three_d else 9, color=KAIKAKU_ACCENT,
                       symbol="star" if not three_d else "diamond",
                       line=dict(color="#111111", width=1.5))
         TR = go.Scatter3d if three_d else go.Scatter
-        kwargs = dict(mode="markers+text",
-                      marker=marker, text=blabels, textposition="top center",
+        kwargs = dict(mode="markers+text", marker=marker, text=blabels, textposition="top center",
                       textfont=dict(size=13, color="#111111"),
                       hovertemplate="<b>%{text}</b> (basket)<extra></extra>", name="basket")
         fig.add_trace(TR(x=bx, y=by, z=bz, **kwargs) if three_d else TR(x=bx, y=by, **kwargs))
-
     title_suffix = " (3D)" if three_d else ""
     fig.update_layout(
-        title=dict(text=f"UMAP of Epicure-{sibling.capitalize()}{title_suffix} - {n} ingredients",
-                   font=dict(size=15)),
+        title=dict(text=f"UMAP of Epicure-{sibling.capitalize()}{title_suffix} - {n} ingredients", font=dict(size=15)),
         height=650, margin=dict(l=40, r=40, t=60, b=40),
         paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
         legend=dict(orientation="v", x=1.02, y=1, font=dict(size=11)),
@@ -260,15 +324,11 @@ def umap_view(sibling, basket, show_neighbours, k, three_d=False):
         fig.update_xaxes(showgrid=True, gridcolor="#eeeeee", zeroline=False, title="UMAP 1")
         fig.update_yaxes(showgrid=True, gridcolor="#eeeeee", zeroline=False, title="UMAP 2")
     else:
-        fig.update_layout(scene=dict(
-            xaxis=dict(title="UMAP 1"),
-            yaxis=dict(title="UMAP 2"),
-            zaxis=dict(title="PC1 (z)"),
-            bgcolor="#ffffff",
-        ))
+        fig.update_layout(scene=dict(xaxis=dict(title="UMAP 1"), yaxis=dict(title="UMAP 2"),
+                                     zaxis=dict(title="PC1 (z)"), bgcolor="#ffffff"))
     return fig
 
-# ===== tab handlers =====
+# ===== tab handlers (with explainers) =====
 
 def basket_pairings(sibling, basket, k):
     m = MODELS[sibling]
@@ -288,32 +348,38 @@ def basket_pairings(sibling, basket, k):
 def supervised_slerp_multi(sibling, basket, directions, theta, k):
     m = MODELS[sibling]
     v = _basket_centroid(m, basket)
-    if v is None: return []
+    if v is None:
+        return [], "_(empty basket)_"
     d = _stack_directions(m, directions, use_factor_pole=False)
     if d is None:
-        return [[n, f"{s:.4f}"] for n, s in _topk(m, v, k, basket)]
+        return [[n, f"{s:.4f}"] for n, s in _topk(m, v, k, basket)], "_(no direction selected)_"
     q = _slerp(v, d, theta)
-    return [[n, f"{s:.4f}"] for n, s in _topk(m, q, k, basket)]
+    rows = [[n, f"{s:.4f}"] for n, s in _topk(m, q, k, basket)]
+    return rows, _slerp_explainer(m, basket, directions or [], theta, q, v, d, "supervised")
 
 def emergent_slerp_multi(sibling, basket, mode_labels, theta, k):
     m = MODELS[sibling]
     label_to_id = {f"{mode.label} ({mode.mode_id})": mode.mode_id for mode in m.modes if mode.kind == "factor"}
     mode_ids = [label_to_id[lab] for lab in (mode_labels or []) if lab in label_to_id]
     v = _basket_centroid(m, basket)
-    if v is None: return []
+    if v is None:
+        return [], "_(empty basket)_"
     d = _stack_directions(m, mode_ids, use_factor_pole=True)
     if d is None:
-        return [[n, f"{s:.4f}"] for n, s in _topk(m, v, k, basket)]
+        return [[n, f"{s:.4f}"] for n, s in _topk(m, v, k, basket)], "_(no factor mode selected)_"
     q = _slerp(v, d, theta)
-    return [[n, f"{s:.4f}"] for n, s in _topk(m, q, k, basket)]
+    rows = [[n, f"{s:.4f}"] for n, s in _topk(m, q, k, basket)]
+    return rows, _slerp_explainer(m, basket, mode_ids, theta, q, v, d, "emergent")
 
 def arithmetic(sibling, positives, negatives, k):
     m = MODELS[sibling]
     pos = _basket_centroid(m, positives)
-    if pos is None: return []
+    if pos is None:
+        return [], "_(no positives provided)_"
     neg = _basket_centroid(m, negatives) if negatives else None
     q = _unit(pos - neg) if neg is not None else pos
-    return [[n, f"{s:.4f}"] for n, s in _topk(m, q, k, (positives or []) + (negatives or []))]
+    rows = [[n, f"{s:.4f}"] for n, s in _topk(m, q, k, (positives or []) + (negatives or []))]
+    return rows, _arithmetic_explainer(m, positives or [], negatives or [], q, pos, neg)
 
 def browse_modes(sibling, kind_filter, query):
     m = MODELS[sibling]
@@ -323,7 +389,8 @@ def browse_modes(sibling, kind_filter, query):
             continue
         if q and q not in mode.label.lower() and q not in mode.property.lower():
             continue
-        rows.append([mode.mode_id, mode.kind, mode.property, mode.label, mode.n_members, ", ".join(mode.members[:12])])
+        rows.append([mode.mode_id, mode.kind, mode.property, mode.label, mode.n_members,
+                     ", ".join(mode.members[:12])])
     rows.sort(key=lambda r: (r[1], -r[4]))
     return rows
 
@@ -343,15 +410,110 @@ def compare_siblings(basket, directions, theta, k):
         out.append([[n, f"{s:.4f}"] for n, s in hits])
     return out[0], out[1], out[2]
 
+# ===== Feature 6: recipe builder (lazy-loaded sentence-transformer) =====
+
+_ST_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+_ST = None
+def _get_st():
+    global _ST
+    if _ST is None:
+        print(f"[epicure-explorer] loading {_ST_MODEL_NAME} (first call, ~80MB)", flush=True)
+        from sentence_transformers import SentenceTransformer
+        _ST = SentenceTransformer(_ST_MODEL_NAME, device="cpu")
+    return _ST
+
+@lru_cache(maxsize=4)
+def _mode_label_matrix(sibling: str):
+    m = MODELS[sibling]
+    modes = [md for md in m.modes if md.kind == "factor"]
+    if not modes:
+        return [], [], np.zeros((0, 384), dtype=np.float32)
+    labels = [md.label for md in modes]
+    mids = [md.mode_id for md in modes]
+    M = _get_st().encode(labels, normalize_embeddings=True, convert_to_numpy=True)
+    return mids, labels, M.astype(np.float32)
+
+def _mode_quartile(mode):
+    members = list(mode.members or [])
+    n = max(4, min(12, (len(members) + 3) // 4))
+    return members[:n]
+
+_PROMPT_STOPWORDS = {
+    "i","im","i'm","a","an","the","for","of","with","and","or","some","my","me","we",
+    "make","making","cook","cooking","prepare","preparing","want","need","to","tonight",
+    "people","person","servings","dinner","lunch","dish","recipe","quick","easy",
+    "tasty","yummy","good","great","food","meal","style","plate","plates",
+}
+_TOKEN_RE = re.compile(r"[A-Za-z][A-Za-z\-']{1,}")
+
+def suggest_basket(prompt, sibling, k=10):
+    if not prompt or not prompt.strip():
+        return [], [], "Type a dish description first."
+    vocab = list(MODELS[sibling].vocab.keys())
+    vocab_sp = [v.replace("_", " ") for v in vocab]
+    raw_tokens = _TOKEN_RE.findall(prompt.lower())
+    tokens = [t for t in raw_tokens if t not in _PROMPT_STOPWORDS and len(t) > 2]
+    direct = {}
+    direct_evidence = []
+    for tok in tokens:
+        hits = fuzz_process.extract(tok, vocab_sp, scorer=fuzz_scorers.token_set_ratio,
+                                    score_cutoff=88, limit=2)
+        for _sp, score, idx in hits:
+            name = vocab[idx]
+            if score > direct.get(name, 0):
+                direct[name] = float(score)
+                direct_evidence.append((tok, name, float(score)))
+    mids, labels, M = _mode_label_matrix(sibling)
+    thematic = {}
+    thematic_modes = []
+    if M.shape[0] > 0:
+        q = _get_st().encode([prompt], normalize_embeddings=True, convert_to_numpy=True)[0]
+        sims = M @ q
+        order = np.argsort(-sims)
+        picked = [(mids[i], labels[i], float(sims[i])) for i in order[:3] if sims[i] >= 0.25]
+        thematic_modes = picked
+        id_to_mode = {md.mode_id: md for md in MODELS[sibling].modes if md.kind == "factor"}
+        for mid, lab, sim in picked:
+            for name in _mode_quartile(id_to_mode[mid]):
+                s_existing, _ = thematic.get(name, (0.0, ""))
+                s_new = max(s_existing, sim * 100.0)
+                thematic[name] = (s_new, lab)
+    combined = {}
+    for name, sc in direct.items():
+        combined[name] = (sc, "direct")
+    for name, (sc, lab) in thematic.items():
+        prev = combined.get(name)
+        if prev is None or sc > prev[0]:
+            tag = "both" if prev else "thematic"
+            combined[name] = (sc, tag)
+    ranked = sorted(combined.items(),
+                    key=lambda kv: (-kv[1][0], 0 if kv[1][1] != "thematic" else 1, kv[0]))[:int(k)]
+    rows = [[name, src, round(score, 1)] for name, (score, src) in ranked]
+    names = [name for name, _ in ranked]
+    lines = []
+    if direct_evidence:
+        dm = ", ".join(sorted({f"`{n}` (from '{t}')" for t, n, _ in direct_evidence}))
+        lines.append(f"**Direct mentions:** {dm}")
+    else:
+        lines.append("**Direct mentions:** _none cleared score threshold_")
+    if thematic_modes:
+        bits = []
+        id_to_mode = {md.mode_id: md for md in MODELS[sibling].modes if md.kind == "factor"}
+        for mid, lab, sim in thematic_modes:
+            sample = ", ".join(id_to_mode[mid].members[:4])
+            bits.append(f"`{lab}` (cos {sim:.2f}; e.g. {sample})")
+        lines.append("**Matched factor modes:** " + "; ".join(bits))
+    else:
+        lines.append("**Matched factor modes:** _no mode label cleared cosine 0.25_")
+    return rows, names, "\n\n".join(lines)
+
 # ===== fridge parser =====
 
 _LINE_SPLIT = re.compile(r"[\n;]")
 _BRACKET = re.compile(r"\([^)]*\)")
-_QTY = (r"(?:\d+(?:[\.,/]\d+)?|"
-        r"a|an|one|two|three|four|five|six|seven|eight|nine|ten|half|quarter)")
-_UNIT = (r"(?:cups?|tbsp\.?|tablespoons?|tsp\.?|teaspoons?|"
-         r"oz\.?|ounces?|lbs?\.?|pounds?|grams?|kgs?|kilos?|"
-         r"ml|liters?|litres?|cloves?|bunches?|sprigs?|pinch(?:es)?|"
+_QTY = (r"(?:\d+(?:[\.,/]\d+)?|a|an|one|two|three|four|five|six|seven|eight|nine|ten|half|quarter)")
+_UNIT = (r"(?:cups?|tbsp\.?|tablespoons?|tsp\.?|teaspoons?|oz\.?|ounces?|lbs?\.?|pounds?|"
+         r"grams?|kgs?|kilos?|ml|liters?|litres?|cloves?|bunches?|sprigs?|pinch(?:es)?|"
          r"slices?|pieces?|cans?|packets?|sticks?|leaves?|stalks?|heads?|inch(?:es)?|"
          r"splash(?:es)?|dash(?:es)?|drops?|handfuls?|large|small|medium)")
 _LEADING_QTY = re.compile(rf"^\s*{_QTY}\s+(?:{_UNIT}\b\s*)?(?:of\s+)?", re.IGNORECASE)
@@ -359,18 +521,14 @@ _LEADING_UNIT_ONLY = re.compile(rf"^\s*{_UNIT}\b\s*(?:of\s+)?", re.IGNORECASE)
 _JUICE_OF = re.compile(rf"^\s*(?:juice|zest)\s+(?:of\s+)?(?:{_QTY}\s+)?", re.IGNORECASE)
 _LEADING_PREP = re.compile(
     r"^\s*(?:fresh|dried|cooked|frozen|raw|ripe|firm|boneless|skinless|smoked|low[- ]fat)\s+",
-    re.IGNORECASE,
-)
+    re.IGNORECASE)
 _TRAILING_PREP = re.compile(
     r"\s*,\s*(?:chopped|minced|diced|sliced|grated|crushed|whole|ground|peeled|"
     r"to taste|optional|finely|coarsely|cubed|shredded|julienned|halved|quartered|warmed|"
     r"toasted|roasted|bruised|melted|softened|cooked|drained|rinsed|patted dry|trimmed|"
-    r"deveined|seeded|stemmed|crumbled).*$", re.IGNORECASE,
-)
-_KNOWN_PLURALS = {
-    "tortillas":"tortilla","thighs":"thigh","leaves":"leaf","onions":"onion",
-    "potatoes":"potato","tomatoes":"tomato","cloves":"clove",
-}
+    r"deveined|seeded|stemmed|crumbled).*$", re.IGNORECASE)
+_KNOWN_PLURALS = {"tortillas":"tortilla","thighs":"thigh","leaves":"leaf","onions":"onion",
+                  "potatoes":"potato","tomatoes":"tomato","cloves":"clove"}
 
 def _clean_line(line):
     s = line.strip().lower()
@@ -425,11 +583,146 @@ def parse_fridge(raw_text, sibling, min_score=70):
         if n not in seen: seen.add(n); dedup.append(n)
     return rows, dedup
 
+# ===== Feature 8: public API endpoints =====
 
-# ===== UI =====
+def _suggest(name: str, sibling: str, n: int = 5) -> list[str]:
+    vocab = list(MODELS[sibling].vocab.keys())
+    hits = fuzz_process.extract((name or "").lower().replace(" ", "_"),
+                                vocab, scorer=fuzz_scorers.WRatio, limit=n)
+    return [h[0] for h in hits]
+
+def _validate_sibling(sibling):
+    if sibling not in MODELS:
+        return {"error": f"sibling '{sibling}' not in {{cooc, core, chem}}",
+                "suggestions": ["cooc","core","chem"]}
+    return None
+
+def _validate_ingredient(name, sibling, field="ingredient"):
+    if not isinstance(name, str) or not name:
+        return {"error": f"{field} must be a non-empty string"}
+    if name not in MODELS[sibling].vocab:
+        return {"error": f"{field} '{name}' not in vocab",
+                "suggestions": _suggest(name, sibling)}
+    return None
+
+def api_neighbors(ingredient, sibling="chem", k=5):
+    err = _validate_sibling(sibling) or _validate_ingredient(ingredient, sibling)
+    if err: return err
+    m = MODELS[sibling]
+    q = _unit(m.E[m.vocab[ingredient]])
+    pairs = _topk(m, q, int(k), exclude=[ingredient])
+    return [{"name": n, "cosine": round(float(s), 6)} for n, s in pairs]
+
+def api_slerp(seed, direction, theta_deg=30, sibling="chem", k=5):
+    err = _validate_sibling(sibling) or _validate_ingredient(seed, sibling, "seed")
+    if err: return err
+    m = MODELS[sibling]
+    if direction not in m.supervised_poles:
+        return {"error": f"direction '{direction}' not a supervised pole",
+                "suggestions": sorted(m.supervised_poles.keys())[:10]}
+    v = _unit(m.E[m.vocab[seed]])
+    d = _unit(m.supervised_poles[direction])
+    q = _slerp(v, d, float(theta_deg))
+    pairs = _topk(m, q, int(k), exclude=[seed])
+    return [{"name": n, "cosine": round(float(s), 6)} for n, s in pairs]
+
+def api_arithmetic(positives, negatives, sibling="chem", k=5):
+    err = _validate_sibling(sibling)
+    if err: return err
+    positives = list(positives or [])
+    negatives = list(negatives or [])
+    if not positives:
+        return {"error": "positives must be a non-empty list"}
+    m = MODELS[sibling]
+    unknown = [x for x in positives + negatives if x not in m.vocab]
+    if unknown:
+        return {"error": f"unknown ingredients: {unknown}",
+                "suggestions": {x: _suggest(x, sibling) for x in unknown}}
+    pos = _basket_centroid(m, positives)
+    neg = _basket_centroid(m, negatives) if negatives else None
+    q = _unit(pos - neg) if neg is not None else pos
+    pairs = _topk(m, q, int(k), exclude=positives + negatives)
+    return [{"name": n, "cosine": round(float(s), 6)} for n, s in pairs]
+
+def api_embed(ingredient, sibling="chem"):
+    err = _validate_sibling(sibling) or _validate_ingredient(ingredient, sibling)
+    if err: return err
+    m = MODELS[sibling]
+    v = _unit(m.E[m.vocab[ingredient]])
+    return [float(x) for x in v.tolist()]
+
+def api_list_directions(sibling="chem"):
+    err = _validate_sibling(sibling)
+    if err: return err
+    return sorted(MODELS[sibling].supervised_poles.keys())
+
+def api_list_factor_modes(sibling="chem"):
+    err = _validate_sibling(sibling)
+    if err: return err
+    return [{"mode_id": mode.mode_id, "label": str(mode.label),
+             "kind": str(mode.kind), "property": str(mode.property),
+             "n_members": int(mode.n_members)}
+            for mode in MODELS[sibling].modes if mode.kind == "factor"]
+
+# ===== Feature 9: saved queries helpers =====
+
+TAB_IDS = {
+    "basket": "tab_basket",
+    "supervised_slerp": "tab_sup",
+    "emergent_slerp": "tab_em",
+    "arithmetic": "tab_ar",
+    "compare": "tab_cmp",
+}
+TAB_LABELS = {
+    "basket": "Basket pairings",
+    "supervised_slerp": "Supervised SLERP",
+    "emergent_slerp": "Emergent SLERP",
+    "arithmetic": "Arithmetic",
+    "compare": "Compare siblings",
+}
+
+def _summarise(tab, inputs):
+    sib = inputs.get("sibling", "")
+    if tab == "basket":
+        return f"[{sib}] basket: {', '.join(inputs.get('basket', [])[:3])} k={inputs.get('k')}"
+    if tab == "supervised_slerp":
+        b = ", ".join(inputs.get("basket", [])[:2])
+        d = ", ".join(inputs.get("directions", [])[:2])
+        return f"[{sib}] {b} +{inputs.get('theta')}° -> {d}"
+    if tab == "emergent_slerp":
+        b = ", ".join(inputs.get("basket", [])[:2])
+        return f"[{sib}] {b} +{inputs.get('theta')}° -> {len(inputs.get('modes', []))} factor modes"
+    if tab == "arithmetic":
+        p = " + ".join(inputs.get("positives", [])[:2])
+        n = " + ".join(inputs.get("negatives", [])[:2])
+        return f"[{sib}] {p}" + (f" - {n}" if n else "")
+    if tab == "compare":
+        return f"[3 siblings] {', '.join(inputs.get('basket', [])[:2])} +{inputs.get('theta')}°"
+    return "(unknown)"
+
+def save_query(saved, tab, inputs_dict):
+    saved = list(saved or [])
+    rec = {
+        "id": str(uuid.uuid4()),
+        "created_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "tab": tab,
+        "inputs": inputs_dict,
+        "summary": _summarise(tab, inputs_dict),
+    }
+    saved.insert(0, rec)
+    saved = saved[:200]
+    return saved, _render_saved(saved)
+
+def delete_query(saved, qid):
+    saved = [q for q in (saved or []) if q.get("id") != qid]
+    return saved, _render_saved(saved)
+
+def _render_saved(saved):
+    return [[q["created_at"], TAB_LABELS.get(q["tab"], q["tab"]), q["summary"], q["id"]]
+            for q in (saved or [])]
+
+# ===== Theme + CSS =====
 
-# Theme: light background, BLACK text everywhere, accent color reserved for
-# interactive UI (buttons, sliders, focused borders) and brand cues.
 THEME = gr.themes.Soft(
     primary_hue=gr.themes.Color(
         c50="#E8F4F1", c100="#C8E6DE", c200=KAIKAKU_ACCENT_LIGHT,
@@ -440,14 +733,12 @@ THEME = gr.themes.Soft(
     neutral_hue="slate",
     font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"],
 ).set(
-    # Force readable label/title text instead of letting Soft tint them with primary
     block_label_text_color="#1f2937",
     block_label_text_weight="600",
     block_title_text_color="#0f172a",
     block_title_text_weight="700",
     body_text_color="#0f172a",
     body_text_color_subdued="#475569",
-    # Primary button: dark accent + white text -> high contrast
     button_primary_background_fill=KAIKAKU_ACCENT,
     button_primary_background_fill_hover=KAIKAKU_ACCENT_HOVER,
     button_primary_text_color="#ffffff",
@@ -462,66 +753,32 @@ THEME = gr.themes.Soft(
 CUSTOM_CSS = f"""
 .gradio-container {{max-width: 1280px !important;}}
 footer {{visibility: hidden;}}
-
-/* Make sure NOTHING uses the faded light-mint label color */
-.gradio-container label,
-.gradio-container .label,
+.gradio-container label, .gradio-container .label,
 .gradio-container [data-testid="block-label"],
-.gradio-container .block-label,
-.gradio-container .gr-block-label {{
-  color: #0f172a !important;
-  font-weight: 600 !important;
-  background: transparent !important;
-}}
-
-/* Tab labels readable */
-.gradio-container button[role="tab"] {{
-  color: #334155 !important;
-  font-weight: 500 !important;
+.gradio-container .block-label, .gradio-container .gr-block-label {{
+  color: #0f172a !important; font-weight: 600 !important; background: transparent !important;
 }}
+.gradio-container button[role="tab"] {{ color: #334155 !important; font-weight: 500 !important; }}
 .gradio-container button[role="tab"][aria-selected="true"] {{
-  color: {KAIKAKU_ACCENT} !important;
-  border-bottom-color: {KAIKAKU_ACCENT} !important;
-  font-weight: 700 !important;
-}}
-
-/* Primary button: dark accent + white text */
-.gradio-container button.primary,
-.gradio-container .primary > button {{
-  background: {KAIKAKU_ACCENT} !important;
-  color: #ffffff !important;
-  border-color: {KAIKAKU_ACCENT} !important;
-  font-weight: 600 !important;
-}}
-.gradio-container button.primary:hover {{
-  background: {KAIKAKU_ACCENT_HOVER} !important;
-  border-color: {KAIKAKU_ACCENT_HOVER} !important;
+  color: {KAIKAKU_ACCENT} !important; border-bottom-color: {KAIKAKU_ACCENT} !important; font-weight: 700 !important;
 }}
-
-/* Dataframe headers: black, bold, readable */
-.gradio-container table thead th,
-.gradio-container .gr-dataframe thead th {{
-  color: #0f172a !important;
-  font-weight: 700 !important;
-  background: #f8fafc !important;
+.gradio-container button.primary, .gradio-container .primary > button {{
+  background: {KAIKAKU_ACCENT} !important; color: #ffffff !important;
+  border-color: {KAIKAKU_ACCENT} !important; font-weight: 600 !important;
 }}
-.gradio-container table tbody td {{
-  color: #0f172a !important;
+.gradio-container button.primary:hover {{ background: {KAIKAKU_ACCENT_HOVER} !important; border-color: {KAIKAKU_ACCENT_HOVER} !important; }}
+.gradio-container table thead th, .gradio-container .gr-dataframe thead th {{
+  color: #0f172a !important; font-weight: 700 !important; background: #f8fafc !important;
 }}
-
-/* Sibling card */
+.gradio-container table tbody td {{ color: #0f172a !important; }}
 .sibling-card {{
-  border-left: 3px solid {KAIKAKU_ACCENT};
-  padding: 10px 14px;
-  margin: 6px 0;
-  background: #f8fafc;
-  border-radius: 4px;
+  border-left: 3px solid {KAIKAKU_ACCENT}; padding: 10px 14px;
+  margin: 6px 0; background: #f8fafc; border-radius: 4px;
 }}
-.sibling-name {{color: {KAIKAKU_DARK}; font-weight: 700; font-size: 1.02em;}}
-.sibling-desc {{color: #334155; font-size: 0.95em; line-height: 1.5;}}
+.sibling-name {{ color: {KAIKAKU_DARK}; font-weight: 700; font-size: 1.02em; }}
+.sibling-desc {{ color: #334155; font-size: 0.95em; line-height: 1.5; }}
 """
 
-# Precompute initial figures so plots are populated on first page load
 _INITIAL_UMAP = umap_view("chem", ["chicken","lemon","garlic"], True, 8, three_d=False)
 _INITIAL_HEATMAP = _basket_heatmap(MODELS["chem"], ["chicken","lemon","garlic"])
 
@@ -540,10 +797,24 @@ SIBLING_CARDS = """
 </div>
 """
 
+# ===== Helper for ingredient picker with food-group filter =====
+
+def _ingredient_picker(label, default_value, multiselect=True, max_choices=10):
+    radio = gr.Radio(choices=FOOD_GROUP_CHOICES, value="All",
+                     label=f"{label} - food group filter", interactive=True)
+    dd = gr.Dropdown(choices=ALL_INGREDIENTS, value=default_value, label=label,
+                     multiselect=multiselect, max_choices=max_choices)
+    radio.change(_filter_dropdown, inputs=[radio, dd], outputs=dd, show_progress="hidden")
+    return radio, dd
+
+# ===== UI =====
+
 with gr.Blocks(title="Epicure Explorer", theme=THEME, css=CUSTOM_CSS) as demo:
 
+    saved_state = gr.BrowserState(default_value=[], storage_key="epicure_saved_queries_v1")
+
     gr.Markdown(
-        f"""# Epicure Explorer
+        """# Epicure Explorer
 Chef-facing operators over three sibling ingredient embeddings (Cooc / Core / Chem) from
 [arXiv:2605.22391](https://arxiv.org/abs/2605.22391). 1,790 canonical ingredients across 7 languages,
 300-D Metapath2Vec, controlled chemistry-vs-recipe-context spectrum."""
@@ -555,196 +826,354 @@ Chef-facing operators over three sibling ingredient embeddings (Cooc / Core / Ch
 
     shared_basket = gr.State([])
 
-    # ---------- Tab 1: Basket pairings + heatmap ----------
-    with gr.Tab("Basket pairings"):
-        gr.Markdown(
-            "Pick one or more ingredients. Tool averages their unit vectors and returns nearest neighbours "
-            "plus closest modes of that centroid. The heatmap shows whether the basket is coherent."
-        )
-        basket = gr.Dropdown(
-            choices=ALL_INGREDIENTS, value=["chicken","lemon","garlic"],
-            label="Ingredient basket (pick 1+)", multiselect=True, max_choices=10,
-        )
-        k_pair = gr.Slider(1, 15, value=8, step=1, label="K")
-        pair_btn = gr.Button("Find pairings", variant="primary")
-        with gr.Row():
-            nb_table = gr.Dataframe(headers=["Neighbour","Cosine"], label="Top-K nearest neighbours", interactive=False)
-            mode_table = gr.Dataframe(headers=["Mode id","Label","Kind","Cosine"], label="Closest modes", interactive=False)
-        heatmap_plot = gr.Plot(value=_INITIAL_HEATMAP, label="Pairwise cosine (matplotlib)")
-        pair_btn.click(
-            basket_pairings, inputs=[sibling, basket, k_pair],
-            outputs=[nb_table, mode_table, heatmap_plot],
-            show_progress="full",
-        )
-        gr.Examples(
-            examples=[
-                ["chem", ["chicken","lemon","garlic"], 8],
-                ["core", ["miso","ginger","sesame_oil"], 8],
-                ["chem", ["tomato","basil","mozzarella_cheese"], 8],
-                ["cooc", ["chocolate","strawberry","cream"], 8],
-                ["chem", ["cumin","coriander","turmeric"], 8],
-                ["core", ["soy_sauce","ginger","scallion"], 8],
-                ["chem", ["red_wine","beef","rosemary"], 8],
-                ["core", ["coconut_milk","lemongrass","fish_sauce"], 8],
-            ],
-            inputs=[sibling, basket, k_pair],
-            label="Try one of these baskets",
-        )
+    with gr.Tabs() as tabs:
+
+        # ---------- Tab 1: Basket pairings ----------
+        with gr.Tab("Basket pairings", id="tab_basket"):
+            gr.Markdown("Pick one or more ingredients. The tool averages their unit vectors and returns nearest neighbours plus closest modes of that centroid.")
+            basket_radio, basket = _ingredient_picker("Ingredient basket (pick 1+)", ["chicken","lemon","garlic"])
+            k_pair = gr.Slider(1, 15, value=8, step=1, label="K")
+            with gr.Row():
+                pair_btn = gr.Button("Find pairings", variant="primary")
+                save_basket_btn = gr.Button("Save this query", variant="secondary")
+            with gr.Row():
+                nb_table = gr.Dataframe(headers=["Neighbour","Cosine"], label="Top-K nearest neighbours", interactive=False)
+                mode_table = gr.Dataframe(headers=["Mode id","Label","Kind","Cosine"], label="Closest modes", interactive=False)
+            heatmap_plot = gr.Plot(value=_INITIAL_HEATMAP, label="Pairwise cosine (matplotlib)")
+            pair_btn.click(basket_pairings, inputs=[sibling, basket, k_pair],
+                           outputs=[nb_table, mode_table, heatmap_plot], show_progress="full")
+            gr.Examples(
+                examples=[
+                    ["chem", ["chicken","lemon","garlic"], 8],
+                    ["core", ["miso","ginger","sesame_oil"], 8],
+                    ["chem", ["tomato","basil","mozzarella_cheese"], 8],
+                    ["cooc", ["chocolate","strawberry","cream"], 8],
+                    ["chem", ["cumin","coriander","turmeric"], 8],
+                    ["core", ["soy_sauce","ginger","scallion"], 8],
+                    ["chem", ["red_wine","beef","rosemary"], 8],
+                    ["core", ["coconut_milk","lemongrass","fish_sauce"], 8],
+                ],
+                inputs=[sibling, basket, k_pair],
+                label="Try one of these baskets",
+            )
+
+        # ---------- Tab 2: Supervised SLERP ----------
+        with gr.Tab("Supervised SLERP", id="tab_sup"):
+            gr.Markdown("Rotate the seed basket toward one or more supervised pole vectors.")
+            sup_radio, sup_basket = _ingredient_picker("Seed basket (pick 1+)", ["rice"])
+            sup_dirs = gr.Dropdown(choices=_supervised_choices("chem"), value=["cuisine:South_Asian"],
+                                   label="Supervised directions (pick 1+; summed)",
+                                   multiselect=True, max_choices=5)
+            sup_theta = gr.Slider(0, 90, value=30, step=5, label="Rotation angle (deg)")
+            sup_k = gr.Slider(1, 15, value=8, step=1, label="K")
+            with gr.Row():
+                sup_btn = gr.Button("Rotate", variant="primary")
+                save_sup_btn = gr.Button("Save this query", variant="secondary")
+            sup_table = gr.Dataframe(headers=["Ingredient","Cosine"], label="Top-K rotated-query neighbours")
+            sup_explainer = gr.Markdown()
+            sup_btn.click(supervised_slerp_multi,
+                          inputs=[sibling, sup_basket, sup_dirs, sup_theta, sup_k],
+                          outputs=[sup_table, sup_explainer], show_progress="full")
+            sibling.change(lambda s: gr.Dropdown(choices=_supervised_choices(s), value=[]),
+                           inputs=sibling, outputs=sup_dirs)
+            gr.Examples(
+                examples=[
+                    ["chem", ["rice"], ["cuisine:South_Asian"], 30, 8],
+                    ["chem", ["corn"], ["cuisine:Latin_American"], 30, 8],
+                    ["core", ["chicken"], ["cuisine:Mediterranean"], 45, 8],
+                    ["core", ["tomato","basil"], ["cuisine:Southeast_Asian"], 45, 8],
+                    ["chem", ["beef"], ["cuisine:East_Asian"], 60, 8],
+                    ["cooc", ["chocolate"], ["cuisine:Latin_American"], 30, 8],
+                ],
+                inputs=[sibling, sup_basket, sup_dirs, sup_theta, sup_k],
+                label="Try one of these rotations",
+            )
+
+        # ---------- Tab 3: Emergent SLERP ----------
+        with gr.Tab("Emergent SLERP", id="tab_em"):
+            gr.Markdown("Rotate the seed basket toward one or more emergent FastICA factor-mode poles.")
+            em_radio, em_basket = _ingredient_picker("Seed basket (pick 1+)", ["chocolate"])
+            factor_opts = _factor_mode_choices("chem")
+            em_modes = gr.Dropdown(choices=[label for label, _ in factor_opts],
+                                   value=[factor_opts[0][0]] if factor_opts else [],
+                                   label="Factor modes (pick 1+; summed)", multiselect=True, max_choices=5)
+            em_theta = gr.Slider(0, 90, value=30, step=5, label="Rotation angle (deg)")
+            em_k = gr.Slider(1, 15, value=8, step=1, label="K")
+            with gr.Row():
+                em_btn = gr.Button("Rotate", variant="primary")
+                save_em_btn = gr.Button("Save this query", variant="secondary")
+            em_table = gr.Dataframe(headers=["Ingredient","Cosine"], label="Top-K rotated-query neighbours")
+            em_explainer = gr.Markdown()
+            em_btn.click(emergent_slerp_multi,
+                         inputs=[sibling, em_basket, em_modes, em_theta, em_k],
+                         outputs=[em_table, em_explainer], show_progress="full")
+            sibling.change(lambda s: gr.Dropdown(choices=[label for label, _ in _factor_mode_choices(s)], value=[]),
+                           inputs=sibling, outputs=em_modes)
+
+        # ---------- Tab 4: Arithmetic ----------
+        with gr.Tab("Arithmetic", id="tab_ar"):
+            gr.Markdown("Mikolov-style vector arithmetic: `centroid(positives) - centroid(negatives)`, then top-K neighbours. Killer demo: `miso - salt` on Core.")
+            pos_radio, pos_box = _ingredient_picker("Positives (added)", ["miso"])
+            neg_radio, neg_box = _ingredient_picker("Negatives (subtracted)", ["salt"])
+            ar_k = gr.Slider(1, 15, value=8, step=1, label="K")
+            with gr.Row():
+                ar_btn = gr.Button("Compute", variant="primary")
+                save_ar_btn = gr.Button("Save this query", variant="secondary")
+            ar_table = gr.Dataframe(headers=["Ingredient","Cosine"], label="Top-K nearest to result vector")
+            ar_explainer = gr.Markdown()
+            ar_btn.click(arithmetic, inputs=[sibling, pos_box, neg_box, ar_k],
+                         outputs=[ar_table, ar_explainer], show_progress="full")
+            gr.Examples(
+                examples=[
+                    ["core", ["miso"], ["salt"], 8],
+                    ["core", ["chicken","tofu"], ["beef"], 8],
+                    ["cooc", ["basil","cumin"], ["parsley"], 8],
+                    ["chem", ["chocolate"], ["sugar"], 8],
+                    ["chem", ["wine"], ["beer"], 8],
+                    ["core", ["bread"], ["flour"], 8],
+                    ["core", ["coffee"], ["milk"], 8],
+                    ["chem", ["mozzarella_cheese"], ["milk"], 8],
+                ],
+                inputs=[sibling, pos_box, neg_box, ar_k],
+                label="Try one of these arithmetic queries",
+            )
+
+        # ---------- Tab 5: Mode atlas (click row -> UMAP) ----------
+        with gr.Tab("Mode atlas", id="tab_atlas"):
+            gr.Markdown(
+                "Browse the GMM mode atlas. Cooc 150 / Core 193 / Chem 200 modes. "
+                "**Click any row** to send that mode's members to the UMAP tab as a basket."
+            )
+            atlas_kind = gr.Radio(choices=["all","factor","continuous","binary"], value="all", label="Mode kind")
+            atlas_search = gr.Textbox(label="Search labels / properties", placeholder="e.g. South Asian, baking, fiber", value="")
+            atlas_btn = gr.Button("Browse modes", variant="primary")
+            atlas_table = gr.Dataframe(
+                headers=["mode_id","kind","property","label","n_members","top members"],
+                label="Modes (click a row to highlight on UMAP)",
+                wrap=True, interactive=False,
+            )
+            atlas_btn.click(browse_modes, inputs=[sibling, atlas_kind, atlas_search], outputs=atlas_table, show_progress="full")
+
+        # ---------- Tab 6: Compare siblings ----------
+        with gr.Tab("Compare siblings", id="tab_cmp"):
+            gr.Markdown("Same query, three siblings, side by side.")
+            cmp_radio, cmp_basket = _ingredient_picker("Seed basket", ["chicken"])
+            cmp_dirs = gr.Dropdown(choices=_supervised_choices("chem"), value=[],
+                                   label="Optional directions (empty = pure pairings)",
+                                   multiselect=True, max_choices=5)
+            cmp_theta = gr.Slider(0, 90, value=30, step=5, label="Rotation angle (deg)")
+            cmp_k = gr.Slider(1, 15, value=8, step=1, label="K")
+            with gr.Row():
+                cmp_btn = gr.Button("Compare across siblings", variant="primary")
+                save_cmp_btn = gr.Button("Save this query", variant="secondary")
+            with gr.Row():
+                cmp_cooc = gr.Dataframe(headers=["Cooc neighbour","Cosine"], label="Cooc (recipe-context)")
+                cmp_core = gr.Dataframe(headers=["Core neighbour","Cosine"], label="Core (blended)")
+                cmp_chem = gr.Dataframe(headers=["Chem neighbour","Cosine"], label="Chem (chemistry)")
+            cmp_btn.click(compare_siblings, inputs=[cmp_basket, cmp_dirs, cmp_theta, cmp_k],
+                          outputs=[cmp_cooc, cmp_core, cmp_chem], show_progress="full")
+
+        # ---------- Tab 7: UMAP ----------
+        with gr.Tab("UMAP visualisation", id="tab_umap"):
+            gr.Markdown(
+                "2-D UMAP of the 1,790-ingredient embedding (cosine, n_neighbors=30, min_dist=0.03). "
+                "Points coloured by food group. Basket members appear as accent stars; top-K neighbours as amber dots."
+            )
+            umap_radio, umap_basket = _ingredient_picker("Highlight these ingredients", ["chicken","lemon","garlic"])
+            with gr.Row():
+                umap_show_nb = gr.Checkbox(value=True, label="Show top-K neighbours of basket centroid")
+                umap_3d = gr.Checkbox(value=False, label="3-D perspective (UMAP + PC1)")
+                umap_k = gr.Slider(1, 20, value=10, step=1, label="K neighbours")
+            umap_btn = gr.Button("Update plot", variant="primary")
+            umap_plot = gr.Plot(value=_INITIAL_UMAP, label="UMAP")
+            umap_btn.click(umap_view, inputs=[sibling, umap_basket, umap_show_nb, umap_k, umap_3d],
+                           outputs=umap_plot, show_progress="full")
+            sibling.change(umap_view, inputs=[sibling, umap_basket, umap_show_nb, umap_k, umap_3d],
+                           outputs=umap_plot)
+
+        # ---------- Tab 8: Parse my fridge ----------
+        with gr.Tab("Parse my fridge", id="tab_fridge"):
+            gr.Markdown(
+                "Paste a free-text ingredient list. Quantities, units, and prep notes are stripped, "
+                "then each line is fuzzy-matched to canonical vocab. Click **Send matched to Basket tab** "
+                "to populate the Basket Pairings input."
+            )
+            fridge_text = gr.Textbox(
+                label="Free-text ingredients (one per line or semicolon-separated)",
+                lines=8,
+                value=("2 boneless chicken thighs\n1 cup coconut milk\n1 tbsp fish sauce (or soy sauce)\n"
+                       "fresh lemongrass, bruised\n3 cloves garlic, minced\n1 inch fresh ginger\n"
+                       "juice of one lime\nsalt to taste"),
+            )
+            fridge_min = gr.Slider(40, 100, value=70, step=5, label="Min match score (rapidfuzz)")
+            with gr.Row():
+                fridge_btn = gr.Button("Parse and match", variant="primary")
+                fridge_send = gr.Button("Send matched to Basket tab", variant="secondary")
+            fridge_table = gr.Dataframe(
+                headers=["Input line", "Canonical match", "Score", "Cleaned"],
+                label="Parsed matches", interactive=False,
+            )
+            fridge_matched = gr.Textbox(label="Matched ingredients", interactive=False)
+            def _parse(txt, sib, mn):
+                rows, matches = parse_fridge(txt, sib, int(mn))
+                return rows, ", ".join(matches), matches
+            fridge_btn.click(_parse, inputs=[fridge_text, sibling, fridge_min],
+                             outputs=[fridge_table, fridge_matched, shared_basket], show_progress="full")
+            fridge_send.click(lambda matches: gr.Dropdown(value=matches[:10] if matches else []),
+                              inputs=[shared_basket], outputs=[basket])
+
+        # ---------- Tab 9: Recipe builder ----------
+        with gr.Tab("Recipe builder", id="tab_recipe"):
+            gr.Markdown(
+                "Describe a dish in plain English. Hybrid retrieval: rapidfuzz token matching for direct "
+                "ingredient mentions + sentence-transformer cosine against the sibling's factor-mode labels "
+                "for thematic matches. First call after Space cold-start downloads ~80MB encoder (one-time)."
+            )
+            rb_prompt = gr.Textbox(label="Dish description", lines=3,
+                                   value="I'm making Thai green curry for 4 people")
+            rb_k = gr.Slider(4, 20, value=10, step=1, label="Suggestions (K)")
+            rb_btn = gr.Button("Suggest starter basket", variant="primary")
+            rb_table = gr.Dataframe(
+                headers=["Ingredient", "Source", "Score"],
+                label="Suggested basket (source = direct / thematic / both)", interactive=False,
+            )
+            rb_explainer = gr.Markdown()
+            rb_matched = gr.State([])
+            rb_send = gr.Button("Send to Basket tab", variant="secondary")
+            def _rb(prompt, sib, k):
+                rows, names, md = suggest_basket(prompt, sib, int(k))
+                return rows, md, names
+            rb_btn.click(_rb, inputs=[rb_prompt, sibling, rb_k],
+                         outputs=[rb_table, rb_explainer, rb_matched], show_progress="full")
+            rb_send.click(lambda names: gr.Dropdown(value=(names or [])[:10]),
+                          inputs=[rb_matched], outputs=[basket])
+            gr.Examples(
+                examples=[
+                    ["I'm making Thai green curry for 4 people", 10],
+                    ["spicy vegetarian taco filling", 10],
+                    ["weeknight pasta with tomatoes and herbs", 10],
+                    ["Japanese miso-glazed salmon and greens", 10],
+                    ["Moroccan tagine with lamb and dried fruit", 10],
+                ],
+                inputs=[rb_prompt, rb_k],
+                label="Try one of these prompts",
+            )
+
+        # ---------- Tab 10: Saved queries ----------
+        with gr.Tab("Saved queries", id="tab_saved"):
+            gr.Markdown(
+                "Stored locally in your browser via `localStorage` (gr.BrowserState). "
+                "~5 MB quota; per-browser, not per-account. Clearing browser data wipes them."
+            )
+            saved_table = gr.Dataframe(
+                headers=["created_at", "tab", "summary", "id"],
+                label="Your saved queries (newest first)", interactive=False, wrap=True,
+            )
+            with gr.Row():
+                selected_id = gr.State("")
+                del_btn = gr.Button("Delete selected", variant="secondary")
+            def _on_select(saved, evt: gr.SelectData):
+                if evt is None or evt.index is None:
+                    return ""
+                row = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+                return (saved or [{}])[row].get("id", "") if row < len(saved or []) else ""
+            saved_table.select(_on_select, inputs=[saved_state], outputs=selected_id)
+            del_btn.click(delete_query, inputs=[saved_state, selected_id],
+                          outputs=[saved_state, saved_table])
+            demo.load(lambda s: _render_saved(s), inputs=saved_state, outputs=saved_table)
+
+    # ---- Wire Save buttons (after all tabs exist so all components are in scope) ----
+    save_basket_btn.click(
+        lambda s, sib, b, k: save_query(s, "basket",
+            {"sibling": sib, "basket": b or [], "k": int(k)}),
+        inputs=[saved_state, sibling, basket, k_pair],
+        outputs=[saved_state, saved_table],
+    )
+    save_sup_btn.click(
+        lambda s, sib, b, d, th, k: save_query(s, "supervised_slerp",
+            {"sibling": sib, "basket": b or [], "directions": d or [], "theta": float(th), "k": int(k)}),
+        inputs=[saved_state, sibling, sup_basket, sup_dirs, sup_theta, sup_k],
+        outputs=[saved_state, saved_table],
+    )
+    save_em_btn.click(
+        lambda s, sib, b, m, th, k: save_query(s, "emergent_slerp",
+            {"sibling": sib, "basket": b or [], "modes": m or [], "theta": float(th), "k": int(k)}),
+        inputs=[saved_state, sibling, em_basket, em_modes, em_theta, em_k],
+        outputs=[saved_state, saved_table],
+    )
+    save_ar_btn.click(
+        lambda s, sib, p, n, k: save_query(s, "arithmetic",
+            {"sibling": sib, "positives": p or [], "negatives": n or [], "k": int(k)}),
+        inputs=[saved_state, sibling, pos_box, neg_box, ar_k],
+        outputs=[saved_state, saved_table],
+    )
+    save_cmp_btn.click(
+        lambda s, b, d, th, k: save_query(s, "compare",
+            {"basket": b or [], "directions": d or [], "theta": float(th), "k": int(k)}),
+        inputs=[saved_state, cmp_basket, cmp_dirs, cmp_theta, cmp_k],
+        outputs=[saved_state, saved_table],
+    )
 
-    # ---------- Tab 2: Supervised SLERP ----------
-    with gr.Tab("Supervised SLERP"):
-        gr.Markdown("Rotate the seed basket toward one or more supervised direction poles. Multiple directions are summed.")
-        sup_basket = gr.Dropdown(choices=ALL_INGREDIENTS, value=["rice"], label="Seed basket (pick 1+)", multiselect=True, max_choices=10)
-        sup_dirs = gr.Dropdown(choices=_supervised_choices("chem"), value=["cuisine:South_Asian"],
-                               label="Supervised directions (pick 1+)", multiselect=True, max_choices=5)
-        sup_theta = gr.Slider(0, 90, value=30, step=5, label="Rotation angle (deg)")
-        sup_k = gr.Slider(1, 15, value=8, step=1, label="K")
-        sup_btn = gr.Button("Rotate", variant="primary")
-        sup_table = gr.Dataframe(headers=["Ingredient","Cosine"], label="Top-K rotated-query neighbours")
-        sup_btn.click(supervised_slerp_multi, inputs=[sibling, sup_basket, sup_dirs, sup_theta, sup_k],
-                      outputs=sup_table, show_progress="full")
-        sibling.change(lambda s: gr.Dropdown(choices=_supervised_choices(s), value=[]),
-                       inputs=sibling, outputs=sup_dirs)
-        gr.Examples(
-            examples=[
-                ["chem", ["rice"], ["cuisine:South_Asian"], 30, 8],
-                ["chem", ["corn"], ["cuisine:Latin_American"], 30, 8],
-                ["core", ["chicken"], ["cuisine:Mediterranean"], 45, 8],
-                ["core", ["tomato","basil"], ["cuisine:Southeast_Asian"], 45, 8],
-                ["chem", ["beef"], ["cuisine:East_Asian"], 60, 8],
-                ["cooc", ["chocolate"], ["cuisine:Latin_American"], 30, 8],
-            ],
-            inputs=[sibling, sup_basket, sup_dirs, sup_theta, sup_k],
-            label="Try one of these rotations",
+    # ---- Mode atlas row click -> UMAP highlight + jump to UMAP tab ----
+    def atlas_row_to_umap(sibling_value, table_value, show_nb, k_value, three_d_value, evt: gr.SelectData):
+        if evt is None or evt.index is None or table_value is None:
+            return gr.update(), gr.update(), gr.update(), gr.update()
+        row = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+        try:
+            clicked_mode_id = (table_value.iloc[row, 0] if hasattr(table_value, "iloc")
+                               else table_value[row][0])
+        except Exception:
+            return gr.update(), gr.update(), gr.update(), gr.update()
+        m = MODELS[sibling_value]
+        mode = next((md for md in m.modes if md.mode_id == clicked_mode_id), None)
+        if mode is None:
+            return gr.update(), gr.update(), gr.update(), gr.update()
+        members = [n for n in mode.members if n in m.vocab][:10]
+        if not members:
+            return gr.update(), gr.update(), gr.update(), gr.update()
+        fig = umap_view(sibling_value, members, bool(show_nb), int(k_value), three_d=bool(three_d_value))
+        return (
+            gr.Dropdown(value=members),
+            fig,
+            members,
+            gr.Tabs(selected="tab_umap"),
         )
+    atlas_table.select(
+        atlas_row_to_umap,
+        inputs=[sibling, atlas_table, umap_show_nb, umap_k, umap_3d],
+        outputs=[umap_basket, umap_plot, shared_basket, tabs],
+        show_progress="hidden",
+    )
 
-    # ---------- Tab 3: Emergent SLERP ----------
-    with gr.Tab("Emergent SLERP"):
-        gr.Markdown("Rotate the seed basket toward one or more emergent FastICA factor-mode poles.")
-        em_basket = gr.Dropdown(choices=ALL_INGREDIENTS, value=["chocolate"], label="Seed basket (pick 1+)", multiselect=True, max_choices=10)
-        factor_opts = _factor_mode_choices("chem")
-        em_modes = gr.Dropdown(choices=[label for label, _ in factor_opts],
-                               value=[factor_opts[0][0]] if factor_opts else [],
-                               label="Factor modes (pick 1+)", multiselect=True, max_choices=5)
-        em_theta = gr.Slider(0, 90, value=30, step=5, label="Rotation angle (deg)")
-        em_k = gr.Slider(1, 15, value=8, step=1, label="K")
-        em_btn = gr.Button("Rotate", variant="primary")
-        em_table = gr.Dataframe(headers=["Ingredient","Cosine"], label="Top-K rotated-query neighbours")
-        em_btn.click(emergent_slerp_multi, inputs=[sibling, em_basket, em_modes, em_theta, em_k],
-                     outputs=em_table, show_progress="full")
-        sibling.change(lambda s: gr.Dropdown(choices=[label for label, _ in _factor_mode_choices(s)], value=[]),
-                       inputs=sibling, outputs=em_modes)
-
-    # ---------- Tab 4: Arithmetic ----------
-    with gr.Tab("Arithmetic"):
-        gr.Markdown("Mikolov-style vector arithmetic: `centroid(positives) - centroid(negatives)`, then top-K neighbours.")
-        pos_box = gr.Dropdown(choices=ALL_INGREDIENTS, value=["miso"], label="Positives", multiselect=True, max_choices=10)
-        neg_box = gr.Dropdown(choices=ALL_INGREDIENTS, value=["salt"], label="Negatives", multiselect=True, max_choices=10)
-        ar_k = gr.Slider(1, 15, value=8, step=1, label="K")
-        ar_btn = gr.Button("Compute", variant="primary")
-        ar_table = gr.Dataframe(headers=["Ingredient","Cosine"], label="Top-K nearest to result vector")
-        ar_btn.click(arithmetic, inputs=[sibling, pos_box, neg_box, ar_k], outputs=ar_table, show_progress="full")
-        gr.Examples(
-            examples=[
-                ["core", ["miso"], ["salt"], 8],
-                ["core", ["chicken","tofu"], ["beef"], 8],
-                ["cooc", ["basil","cumin"], ["parsley"], 8],
-                ["chem", ["chocolate"], ["sugar"], 8],
-                ["chem", ["wine"], ["beer"], 8],
-                ["core", ["bread"], ["flour"], 8],
-                ["core", ["coffee"], ["milk"], 8],
-                ["chem", ["mozzarella_cheese"], ["milk"], 8],
-            ],
-            inputs=[sibling, pos_box, neg_box, ar_k],
-            label="Try one of these arithmetic queries",
-        )
+    # ---- Public API endpoints ----
+    gr.api(api_neighbors,         api_name="neighbors")
+    gr.api(api_slerp,             api_name="slerp")
+    gr.api(api_arithmetic,        api_name="arithmetic")
+    gr.api(api_embed,             api_name="embed")
+    gr.api(api_list_directions,   api_name="list_directions")
+    gr.api(api_list_factor_modes, api_name="list_factor_modes")
 
-    # ---------- Tab 5: Mode atlas ----------
-    with gr.Tab("Mode atlas"):
-        gr.Markdown("Browse the GMM mode atlas. Cooc 150 / Core 193 / Chem 200 modes.")
-        atlas_kind = gr.Radio(choices=["all","factor","continuous","binary"], value="all", label="Mode kind")
-        atlas_search = gr.Textbox(label="Search labels / properties", placeholder="e.g. South Asian, baking, fiber", value="")
-        atlas_btn = gr.Button("Browse modes", variant="primary")
-        atlas_table = gr.Dataframe(
-            headers=["mode_id","kind","property","label","n_members","top members"],
-            label="Modes (sorted by kind, then size descending)", wrap=True, interactive=False,
-        )
-        atlas_btn.click(browse_modes, inputs=[sibling, atlas_kind, atlas_search], outputs=atlas_table, show_progress="full")
-
-    # ---------- Tab 6: Compare siblings ----------
-    with gr.Tab("Compare siblings"):
-        gr.Markdown("Same query, three siblings, side by side. The spectrum-of-models thesis in one screen.")
-        cmp_basket = gr.Dropdown(choices=ALL_INGREDIENTS, value=["chicken"], label="Seed basket", multiselect=True, max_choices=10)
-        cmp_dirs = gr.Dropdown(choices=_supervised_choices("chem"), value=[],
-                               label="Optional directions (empty = pure pairings)", multiselect=True, max_choices=5)
-        cmp_theta = gr.Slider(0, 90, value=30, step=5, label="Rotation angle (deg)")
-        cmp_k = gr.Slider(1, 15, value=8, step=1, label="K")
-        cmp_btn = gr.Button("Compare across siblings", variant="primary")
-        with gr.Row():
-            cmp_cooc = gr.Dataframe(headers=["Cooc neighbour","Cosine"], label="Cooc (recipe-context)")
-            cmp_core = gr.Dataframe(headers=["Core neighbour","Cosine"], label="Core (blended)")
-            cmp_chem = gr.Dataframe(headers=["Chem neighbour","Cosine"], label="Chem (chemistry)")
-        cmp_btn.click(compare_siblings, inputs=[cmp_basket, cmp_dirs, cmp_theta, cmp_k],
-                      outputs=[cmp_cooc, cmp_core, cmp_chem], show_progress="full")
-
-    # ---------- Tab 7: UMAP visualisation ----------
-    with gr.Tab("UMAP visualisation"):
-        gr.Markdown(
-            "2-D UMAP of the 1,790-ingredient embedding (cosine, n_neighbors=30, min_dist=0.03 -- paper Figure 1). "
-            "Points coloured by food group. Basket members appear as mint stars; top-K neighbours as amber dots."
-        )
-        umap_basket = gr.Dropdown(choices=ALL_INGREDIENTS, value=["chicken","lemon","garlic"],
-                                  label="Highlight these ingredients", multiselect=True, max_choices=10)
-        with gr.Row():
-            umap_show_nb = gr.Checkbox(value=True, label="Show top-K neighbours of basket centroid")
-            umap_3d = gr.Checkbox(value=False, label="3-D perspective (UMAP + PC1)")
-            umap_k = gr.Slider(1, 20, value=10, step=1, label="K neighbours")
-        umap_btn = gr.Button("Update plot", variant="primary")
-        umap_plot = gr.Plot(value=_INITIAL_UMAP, label="UMAP")
-        umap_btn.click(umap_view, inputs=[sibling, umap_basket, umap_show_nb, umap_k, umap_3d],
-                       outputs=umap_plot, show_progress="full")
-        sibling.change(umap_view, inputs=[sibling, umap_basket, umap_show_nb, umap_k, umap_3d],
-                       outputs=umap_plot)
-
-    # ---------- Tab 8: Parse my fridge ----------
-    with gr.Tab("Parse my fridge"):
-        gr.Markdown(
-            "Paste a free-text ingredient list. Quantities, units, and prep notes are stripped, "
-            "then each line is fuzzy-matched to canonical vocab. "
-            "Click **Send matched to Basket tab** to populate the Basket Pairings input."
-        )
-        fridge_text = gr.Textbox(
-            label="Free-text ingredients (one per line or semicolon-separated)",
-            lines=8,
-            value=("2 boneless chicken thighs\n1 cup coconut milk\n1 tbsp fish sauce (or soy sauce)\n"
-                   "fresh lemongrass, bruised\n3 cloves garlic, minced\n1 inch fresh ginger\n"
-                   "juice of one lime\nsalt to taste"),
-        )
-        fridge_min = gr.Slider(40, 100, value=70, step=5, label="Min match score (rapidfuzz)")
-        with gr.Row():
-            fridge_btn = gr.Button("Parse and match", variant="primary")
-            fridge_send = gr.Button("Send matched to Basket tab", variant="secondary")
-        fridge_table = gr.Dataframe(
-            headers=["Input line", "Canonical match", "Score", "Cleaned"],
-            label="Parsed matches", interactive=False,
-        )
-        fridge_matched = gr.Textbox(label="Matched ingredients", interactive=False)
+    gr.Markdown(
+        """---
+### Developer API
 
-        def _parse(txt, sib, mn):
-            rows, matches = parse_fridge(txt, sib, int(mn))
-            return rows, ", ".join(matches), matches
-        fridge_btn.click(_parse, inputs=[fridge_text, sibling, fridge_min],
-                         outputs=[fridge_table, fridge_matched, shared_basket], show_progress="full")
+These operators are also exposed as JSON endpoints. See `/?view=api` for the auto-generated schema.
 
-        def _send_to_basket(matches):
-            return gr.Dropdown(value=matches[:10] if matches else [])
-        fridge_send.click(_send_to_basket, inputs=[shared_basket], outputs=[basket])
+```python
+from gradio_client import Client
+c = Client("Kaikaku/epicure-explorer")
+c.predict("garlic", "chem", 5, api_name="/neighbors")
+c.predict("rice", "cuisine:South_Asian", 30, "chem", 5, api_name="/slerp")
+c.predict(["miso"], ["salt"], "core", 8, api_name="/arithmetic")
+c.predict("garlic", "chem", api_name="/embed")          # 300-D L2-normalised vector
+c.predict("chem", api_name="/list_directions")
+c.predict("chem", api_name="/list_factor_modes")
+```
 
-    gr.Markdown(
-        """---
-**Cite:** Radzikowski and Chen, 2026, *Epicure: Navigating the Emergent Geometry of Food Ingredient Embeddings*, [arXiv:2605.22391](https://arxiv.org/abs/2605.22391).
+Endpoints validate inputs and return `{"error": "...", "suggestions": [...]}` on bad input. Free-tier limits: ~1-2 req/sec shared, no auth, Space sleeps after ~48h idle (cold start ~30-60s on next request).
 
-Artefacts: [epicure-cooc](https://huggingface.co/Kaikaku/epicure-cooc) | [epicure-core](https://huggingface.co/Kaikaku/epicure-core) | [epicure-chem](https://huggingface.co/Kaikaku/epicure-chem) | [corpus dataset](https://huggingface.co/datasets/Kaikaku/epicure-corpus-resources)
+---
+**Cite:** Radzikowski and Chen, 2026, *Epicure: Navigating the Emergent Geometry of Food Ingredient Embeddings*, [arXiv:2605.22391](https://arxiv.org/abs/2605.22391). Artefacts: [epicure-cooc](https://huggingface.co/Kaikaku/epicure-cooc) | [epicure-core](https://huggingface.co/Kaikaku/epicure-core) | [epicure-chem](https://huggingface.co/Kaikaku/epicure-chem) | [corpus dataset](https://huggingface.co/datasets/Kaikaku/epicure-corpus-resources)
 """
     )
 

requirements.txt

@@ -1,8 +1,9 @@
-gradio>=5.0.0
+gradio>=5.6.0
 huggingface_hub>=0.24.0
 safetensors>=0.4.0
 numpy>=1.24
 plotly>=5.20.0
 matplotlib>=3.8.0
 rapidfuzz>=3.6.0
+sentence-transformers>=2.7.0
 audioop-lts; python_version >= "3.13"