Deploy weighted-clustering-presets: 11 presets, custom weights, C7 search, 32D PCA

Dockerfile

@@ -7,7 +7,11 @@ RUN pip install --no-cache-dir -r requirements-hf.txt
 
 COPY app.py .
 COPY scripts/apply_labels_to_map.py scripts/
+COPY search/ search/
 COPY material_universe_cache/plotly_studio_export.csv material_universe_cache/
+COPY material_universe_cache/cluster_labels_*.npy material_universe_cache/
+COPY material_universe_cache/centroid_sim_*.npy material_universe_cache/
+COPY docs/cluster_definitions_presets.json docs/
 
 ENV HOST=0.0.0.0
 ENV PORT=7860

app.py

@@ -1,7 +1,9 @@
 """
 Materials Database Explorer — Dash 4.0
 
-Reproduces the Plotly-Studio-generated dashboard with 6 interactive charts.
+Reproduces the Plotly-Studio-generated dashboard with 7 interactive charts
+plus weighted clustering presets (Centroid Similarity Decomposition).
+
 Supports English and Japanese localization.
 
 Usage:
@@ -11,12 +13,18 @@ Usage:
 """
 
 import argparse
+import json
 import os
 import sys
+from pathlib import Path
+
+from dotenv import load_dotenv
+load_dotenv()
 
+import numpy as np
 import pandas as pd
 import plotly.express as px
-from dash import Dash, dcc, html, Input, Output, callback
+from dash import Dash, dcc, html, Input, Output, State, callback
 from sklearn.decomposition import PCA
 from sklearn.preprocessing import StandardScaler
 
@@ -48,7 +56,7 @@ DASH_I18N = {
         "c1_title": "Band gap distribution over material families",
         "c2_title": "Compare band gap distribution of material types",
         "c3_title": "Principal Component Analysis (PCA) for high-dimensional material embeddings",
-        "c3_desc": "Reduces 64-dimensional material embeddings to 2D/3D to reveal clustering patterns.",
+        "c3_desc": "Reduces 32-dimensional material embeddings to 2D/3D to reveal clustering patterns.",
         "c4_title": "Look up materials by chemical family",
         "c5_title": "Band gap by material family and material type",
         "c6_title": "Show the top N material families",
@@ -97,6 +105,46 @@ DASH_I18N = {
         "chart_variance_pct": "Variance (%)",
         "chart_top_n": "Top {n} Families by {metric}",
         "colorscale": "Colorscale: ",
+        "c7_title": "Similar Materials Search",
+        "c7_desc": (
+            "Find materials with similar physical behavior using weighted "
+            "cosine similarity fusion across 4 embedding spaces "
+            "(Orb-v3, MEGNet, OFM, eSEN)."
+        ),
+        "c7_lbl_material": "Query material",
+        "c7_lbl_material_ph": "Search by formula or MP_ID...",
+        "c7_lbl_topk": "Results",
+        "c7_lbl_weights": "Vector weights",
+        "c7_btn_search": "Search",
+        "c7_status_ready": "Select a material and click Search",
+        "c7_status_no_qdrant": "Vector database unavailable: {error}",
+        "c7_status_not_found": "Material not found in vector database",
+        "c7_col_rank": "Rank",
+        "c7_col_formula": "Formula",
+        "c7_col_mpid": "MP_ID",
+        "c7_col_bandgap": "BandGap (eV)",
+        "c7_col_orb": "Orb-v3",
+        "c7_col_lmm": "MEGNet",
+        "c7_col_lofm": "OFM",
+        "c7_col_esen": "eSEN",
+        "c7_col_weighted": "Weighted",
+        # Clustering mode (B5)
+        "lbl_cluster_mode": "Clustering Mode",
+        "mode_preset": "Named Presets",
+        "mode_custom": "Custom Weights",
+        "lbl_perspective": "Clustering Perspective",
+        "lbl_cluster_weights": "Embedding space weights",
+        "preset_balanced": "Balanced (Equal Weights)",
+        "preset_orb_only": "Orb-Only (Force Field)",
+        "preset_mm_only": "MEGNet-Only (Coordination)",
+        "preset_ofm_only": "OFM-Only (Orbital)",
+        "preset_esen_only": "eSEN-Only (Energy)",
+        "preset_stability": "Stability Focus",
+        "preset_electronic": "Electronic Focus",
+        "preset_structural": "Structural Focus",
+        "preset_chemical": "Chemical Focus",
+        "preset_coord_energy": "Coordination Energy",
+        "preset_mechanochem": "Mechanochemical",
     },
     "ja": {
         "app_title": "材料データベースエクスプローラー",
@@ -108,7 +156,7 @@ DASH_I18N = {
         "c1_title": "材料ファミリーごとのバンドギャップ分布",
         "c2_title": "材料タイプ別バンドギャップ分布の比較",
         "c3_title": "高次元材料埋め込みの主成分分析（PCA）",
-        "c3_desc": "64次元の材料埋め込みを2D/3Dに次元削減し、クラスタリングパターンを可視化。",
+        "c3_desc": "32次元の材料埋め込みを2D/3Dに次元削減し、クラスタリングパターンを可視化。",
         "c4_title": "化学ファミリーで材料を検索",
         "c5_title": "材料ファミリーと材料タイプ別バンドギャップ",
         "c6_title": "上位N材料ファミリーを表示",
@@ -157,6 +205,45 @@ DASH_I18N = {
         "chart_variance_pct": "寄与率（%）",
         "chart_top_n": "{metric}上位{n}ファミリー",
         "colorscale": "カラースケール: ",
+        "c7_title": "類似材料検索",
+        "c7_desc": (
+            "4つの埋め込み空間（Orb-v3、MEGNet、OFM、eSEN）を用いた"
+            "重み付きコサイン類似度融合により、物理的挙動が類似した材料を検索。"
+        ),
+        "c7_lbl_material": "クエリ材料",
+        "c7_lbl_material_ph": "化学式またはMP_IDで検索...",
+        "c7_lbl_topk": "結果数",
+        "c7_lbl_weights": "ベクトル重み",
+        "c7_btn_search": "検索",
+        "c7_status_ready": "材料を選択し検��をクリック",
+        "c7_status_no_qdrant": "ベクトルDB接続不可: {error}",
+        "c7_status_not_found": "ベクトルDBに材料が見つかりません",
+        "c7_col_rank": "順位",
+        "c7_col_formula": "化学式",
+        "c7_col_mpid": "MP_ID",
+        "c7_col_bandgap": "BandGap (eV)",
+        "c7_col_orb": "Orb-v3",
+        "c7_col_lmm": "MEGNet",
+        "c7_col_lofm": "OFM",
+        "c7_col_esen": "eSEN",
+        "c7_col_weighted": "重み付き",
+        # Clustering mode (B5)
+        "lbl_cluster_mode": "クラスタリングモード",
+        "mode_preset": "名前付きプリセット",
+        "mode_custom": "カスタム重み",
+        "lbl_perspective": "クラスタリング視点",
+        "lbl_cluster_weights": "埋め込み空間の重み",
+        "preset_balanced": "バランス（均等重み）",
+        "preset_orb_only": "Orb単独（力場）",
+        "preset_mm_only": "MEGNet単独（配位）",
+        "preset_ofm_only": "OFM単独（軌道）",
+        "preset_esen_only": "eSEN単独（エネルギー）",
+        "preset_stability": "安定性重視",
+        "preset_electronic": "電子構造重視",
+        "preset_structural": "構造重視",
+        "preset_chemical": "化学重視",
+        "preset_coord_energy": "配位エネルギー",
+        "preset_mechanochem": "力学化学",
     },
 }
 
@@ -169,7 +256,6 @@ TYPE_DISPLAY = {
     "Semiconductor": MT["type_semiconductor"],
     "Insulator": MT["type_insulator"],
 }
-FAMILY_DISPLAY = FAMILY_TRANSLATIONS_JA if LANG == "ja" else {}
 
 # Aggregation display mapping (label shown in chart titles)
 AGG_DISPLAY = {
@@ -187,21 +273,16 @@ METRIC_DISPLAY = {
 }
 
 
-def family_label(en_name):
-    """Translate family name using FAMILY_TRANSLATIONS_JA (verbatim)."""
-    return FAMILY_DISPLAY.get(en_name, en_name)
-
-
 def type_label(en_name):
     """Translate electronic type using MAP_TRANSLATIONS (verbatim)."""
     return TYPE_DISPLAY.get(en_name, en_name)
 
 
 # ── data ──────────────────────────────────────────────────────────────────
-CSV = "material_universe_cache/plotly_studio_export.csv"
+CACHE = Path("material_universe_cache")
+CSV = CACHE / "plotly_studio_export.csv"
 df = pd.read_csv(CSV)
-DIM_COLS = [f"dim_{i}" for i in range(64)]
-ALL_FAMILIES = sorted(df["Family"].unique())
+DIM_COLS = [f"dim_{i}" for i in range(32)]
 ALL_TYPES = ["Metallic", "Semiconductor", "Insulator"]
 
 # Pre-compute PCA (expensive, do once)
@@ -214,10 +295,156 @@ df["PC2"] = pc_all[:, 1]
 df["PC3"] = pc_all[:, 2]
 print("PCA done.")
 
-# Build display columns for charts
-df["FamilyDisplay"] = df["Family_JA"] if LANG == "ja" else df["Family"]
+# Build TypeDisplay column (static, never changes with clustering)
 df["TypeDisplay"] = df["Type"].map(TYPE_DISPLAY)
 
+# C7 material dropdown options (formula + mp_id for display, mp_id as value)
+c7_material_options = sorted([
+    {"label": f"{row['Formula']}  ({row['MP_ID']})", "value": row["MP_ID"]}
+    for _, row in df[["MP_ID", "Formula"]].drop_duplicates().iterrows()
+], key=lambda x: x["label"])
+
+# ── Preset label data ──────────────────────────────────────────────────
+PRESET_KEYS = [
+    "balanced", "orb_only", "mm_only", "ofm_only", "esen_only",
+    "stability", "electronic", "structural", "chemical",
+    "coord_energy", "mechanochem",
+]
+
+# Load preset label arrays and family name mappings
+PRESET_LABELS = {}
+PRESET_FAMILIES_EN = {}
+PRESET_FAMILIES_JA = {}
+
+# Load family name definitions
+_families_path = Path("docs/cluster_definitions_presets.json")
+_families_data = {}
+if _families_path.exists():
+    with open(_families_path, "r", encoding="utf-8") as f:
+        _families_data = json.load(f)
+
+for key in PRESET_KEYS:
+    label_path = CACHE / f"cluster_labels_{key}.npy"
+    if label_path.exists():
+        PRESET_LABELS[key] = np.load(label_path)
+        PRESET_FAMILIES_EN[key] = _families_data.get(key, {})
+        PRESET_FAMILIES_JA[key] = _families_data.get(f"{key}_ja", {})
+    else:
+        print(f"  WARNING: {label_path} not found, preset '{key}' unavailable")
+
+# Balanced family maps (used as stable reference for custom mode)
+BALANCED_FAMILY_EN = PRESET_FAMILIES_EN.get("balanced", {})
+BALANCED_FAMILY_JA = PRESET_FAMILIES_JA.get("balanced", {})
+
+# Fall back to static Family/Family_JA from CSV if no presets loaded
+if not PRESET_LABELS:
+    print("  WARNING: No preset labels loaded. Using static CSV clustering.")
+
+# ── Centroid similarity matrices (for custom mode) ─────────────────────
+S_ORB = S_MM = S_OFM = S_ESEN = None
+CLUSTER_IDS = []
+_sim_loaded = False
+
+for name in ["orb", "mm", "ofm", "esen"]:
+    sim_path = CACHE / f"centroid_sim_{name}.npy"
+    if sim_path.exists():
+        arr = np.load(sim_path)
+        if name == "orb":
+            S_ORB = arr
+        elif name == "mm":
+            S_MM = arr
+        elif name == "ofm":
+            S_OFM = arr
+        elif name == "esen":
+            S_ESEN = arr
+
+if S_ORB is not None and S_MM is not None and S_OFM is not None and S_ESEN is not None:
+    _sim_loaded = True
+    # Infer cluster IDs from balanced labels
+    if "balanced" in PRESET_LABELS:
+        CLUSTER_IDS = sorted(set(PRESET_LABELS["balanced"]) - {-1})
+    else:
+        CLUSTER_IDS = list(range(S_ORB.shape[1]))
+    print(f"Centroid similarity loaded: {S_ORB.shape}, {len(CLUSTER_IDS)} clusters")
+else:
+    print("  WARNING: Centroid similarity matrices not loaded. Custom mode unavailable.")
+
+# ── Label resolution ───────────────────────────────────────────────────
+
+def resolve_labels(active_data):
+    """Resolve current clustering labels from the active-labels store data.
+
+    Returns (clusters, families, displays) as pd.Series aligned to df.index.
+    - clusters: integer cluster IDs
+    - families: English family names
+    - displays: display family names (JA if LANG=="ja", else EN)
+    """
+    if active_data is None or not PRESET_LABELS:
+        # Fallback: use CSV columns
+        return df["Cluster"], df["Family"], df.get("FamilyDisplay", df["Family"])
+
+    mode = active_data.get("mode", "preset")
+
+    if mode == "preset":
+        key = active_data.get("key", "balanced")
+        if key not in PRESET_LABELS:
+            key = "balanced"
+        labels = PRESET_LABELS[key]
+        fam_en = PRESET_FAMILIES_EN.get(key, {})
+        fam_ja = PRESET_FAMILIES_JA.get(key, {})
+    else:
+        # Custom: weighted centroid similarity
+        if not _sim_loaded:
+            return df["Cluster"], df["Family"], df.get("FamilyDisplay", df["Family"])
+        w = active_data.get("weights", [0.25, 0.25, 0.25, 0.25])
+        S = w[0] * S_ORB + w[1] * S_MM + w[2] * S_OFM + w[3] * S_ESEN
+        label_indices = S.argmax(axis=1)
+        labels = np.array([CLUSTER_IDS[i] for i in label_indices])
+        fam_en = BALANCED_FAMILY_EN
+        fam_ja = BALANCED_FAMILY_JA
+
+    clusters = pd.Series(labels, index=df.index)
+    families = clusters.astype(str).map(fam_en).fillna("Unclassified")
+    if LANG == "ja":
+        displays = clusters.astype(str).map(fam_ja).fillna(families)
+    else:
+        displays = families
+
+    return clusters, families, displays
+
+
+def get_all_families(active_data):
+    """Get sorted unique family names for the current clustering."""
+    _, families, _ = resolve_labels(active_data)
+    return sorted(families.unique())
+
+
+# ── Lazy Qdrant client (only connected when C7 is used) ─────────────────
+_qdrant_client = None
+_qdrant_error = None
+
+
+def get_qdrant_client():
+    """Lazy-init Qdrant client. Returns (client, error_message)."""
+    global _qdrant_client, _qdrant_error
+    if _qdrant_client is not None:
+        return _qdrant_client, None
+    if _qdrant_error is not None:
+        return None, _qdrant_error
+    try:
+        from qdrant_client import QdrantClient
+        url = os.getenv("QDRANT_URL")
+        key = os.getenv("QDRANT_API_KEY")
+        if not url or not key:
+            _qdrant_error = "QDRANT_URL / QDRANT_API_KEY not set"
+            return None, _qdrant_error
+        _qdrant_client = QdrantClient(url=url, api_key=key, timeout=30)
+        _qdrant_client.get_collection("crystal-chroma-fusion")
+        return _qdrant_client, None
+    except Exception as e:
+        _qdrant_error = str(e)
+        return None, _qdrant_error
+
 # ── CSS ───────────────────────────────────────────────────────────────────
 CARD = {
     "background": "white",
@@ -233,7 +460,7 @@ BODY_FONT = (
     '"Hiragino Sans", "Noto Sans JP", sans-serif'
 )
 
-# ── helpers ───────────────────────────────────────────────────────────────
+# ── helpers ───────────────────────────────────────────────────────────
 AGG_MAP = {
     "Average": "mean", "Median": "median", "Max": "max",
     "Min": "min", "Sum": "sum", "Count": "count",
@@ -258,7 +485,19 @@ def value_to_color(val, vmin, vmax):
 
 
 # ── dropdown option builders ─────────────────────────────────────────────
-family_options = [{"label": family_label(f), "value": f} for f in ALL_FAMILIES]
+
+# Preset dropdown options
+preset_options = [
+    {"label": T[f"preset_{k}"], "value": k}
+    for k in PRESET_KEYS
+    if k in PRESET_LABELS
+]
+if not preset_options:
+    preset_options = [{"label": T["preset_balanced"], "value": "balanced"}]
+
+# Initial family list from balanced preset (will be dynamically updated)
+_init_families = get_all_families({"mode": "preset", "key": "balanced"})
+family_options = [{"label": f, "value": f} for f in _init_families]
 type_options = [{"label": type_label(t), "value": t} for t in ALL_TYPES]
 
 agg_options = [
@@ -337,6 +576,67 @@ app.layout = html.Div(
                style={"color": "#666", "maxWidth": "900px",
                        "marginBottom": "32px"}),
 
+        # ── Active labels store ─────────────────────────────────────────
+        dcc.Store(id="active-labels",
+                  data={"mode": "preset", "key": "balanced"}),
+
+        # ── Clustering control panel ────────────────────────────────────
+        html.Div(style={**CARD, "borderLeft": "4px solid #1976d2"}, children=[
+            html.H3(T["lbl_cluster_mode"],
+                     style={"marginTop": "0", "marginBottom": "12px"}),
+            html.Div(style={"display": "flex", "gap": "24px",
+                            "flexWrap": "wrap", "alignItems": "flex-start"},
+                     children=[
+                # Mode selector
+                html.Div([
+                    dcc.RadioItems(
+                        id="cluster-mode",
+                        options=[
+                            {"label": T["mode_preset"], "value": "preset"},
+                            {"label": T["mode_custom"], "value": "custom"},
+                        ],
+                        value="preset",
+                        inline=True,
+                        style={"fontSize": "14px"},
+                        inputStyle={"marginRight": "6px"},
+                        labelStyle={"marginRight": "20px"},
+                    ),
+                ], style={"marginBottom": "8px"}),
+            ]),
+            # Preset dropdown
+            html.Div(id="preset-container", children=[
+                html.Div(T["lbl_perspective"], style=LABEL),
+                dcc.Dropdown(
+                    id="perspective",
+                    options=preset_options,
+                    value="balanced",
+                    clearable=False,
+                    style={"width": "360px"},
+                ),
+            ], style={"marginTop": "8px"}),
+            # Custom weight sliders
+            html.Div(id="custom-container", children=[
+                html.Div(T["lbl_cluster_weights"],
+                         style={**LABEL, "marginTop": "4px"}),
+                html.Div(style={"display": "flex", "gap": "24px",
+                                "flexWrap": "wrap"}, children=[
+                    html.Div([
+                        html.Div(label, style={**LABEL, "fontSize": "12px"}),
+                        dcc.Slider(
+                            id=f"cw-{sid}", min=0, max=1, step=0.05,
+                            value=0.25,
+                            marks={0: "0", 0.5: "0.5", 1: "1"},
+                            tooltip={"placement": "bottom"},
+                        ),
+                    ], style={"width": "180px"})
+                    for sid, label in [
+                        ("orb", "Orb-v3"), ("mm", "l-MM"),
+                        ("ofm", "l-OFM"), ("esen", "eSEN"),
+                    ]
+                ]),
+            ], style={"marginTop": "8px", "display": "none"}),
+        ]),
+
         # ── 1  PCA ───────────────────────────────────────────────────────
         html.Div(style=CARD, children=[
             html.H3(T["c3_title"]),
@@ -410,7 +710,7 @@ app.layout = html.Div(
                 html.Div([
                     html.Div(T["lbl_families"], style=LABEL),
                     dcc.Dropdown(id="c1-families", options=family_options,
-                                 value=ALL_FAMILIES, multi=True,
+                                 value=_init_families, multi=True,
                                  style={"width": "500px"}),
                 ]),
             ]),
@@ -513,7 +813,7 @@ app.layout = html.Div(
             dcc.Graph(id="c6-graph"),
         ]),
 
-        # ── 6  Lookup table ──────────────────────────────────────────────
+        # ── 7  Lookup table ──────────────────────────────────────────────
         html.Div(style=CARD, children=[
             html.H3(T["c4_title"]),
             html.Div(style={"display": "flex", "gap": "16px",
@@ -547,6 +847,75 @@ app.layout = html.Div(
             ]),
             html.Div(id="c4-table"),
         ]),
+
+        # ── 8  Similar Materials Search ────────────────────────────────
+        html.Div(style=CARD, children=[
+            html.H3(T["c7_title"]),
+            html.P(T["c7_desc"],
+                   style={"color": "#666", "fontSize": "14px"}),
+            # Row 1: material selector + top-K + search button
+            html.Div(style={"display": "flex", "gap": "16px",
+                            "flexWrap": "wrap", "marginBottom": "12px",
+                            "alignItems": "flex-end"}, children=[
+                html.Div([
+                    html.Div(T["c7_lbl_material"], style=LABEL),
+                    dcc.Dropdown(
+                        id="c7-material",
+                        options=c7_material_options,
+                        placeholder=T["c7_lbl_material_ph"],
+                        style={"width": "360px"},
+                        searchable=True,
+                    ),
+                ]),
+                html.Div([
+                    html.Div(T["c7_lbl_topk"], style=LABEL),
+                    dcc.Dropdown(
+                        id="c7-topk",
+                        options=[5, 10, 20, 50],
+                        value=10,
+                        clearable=False,
+                        style={"width": "90px"},
+                    ),
+                ]),
+                html.Button(
+                    T["c7_btn_search"], id="c7-search-btn", n_clicks=0,
+                    style={
+                        "padding": "8px 24px", "background": "#1976d2",
+                        "color": "white", "border": "none",
+                        "borderRadius": "4px", "cursor": "pointer",
+                        "fontWeight": "600", "fontSize": "14px",
+                        "height": "36px",
+                    },
+                ),
+            ]),
+            # Row 2: weight sliders
+            html.Div([
+                html.Div(T["c7_lbl_weights"], style=LABEL),
+            ], style={"marginBottom": "4px"}),
+            html.Div(style={"display": "flex", "gap": "24px",
+                            "flexWrap": "wrap", "marginBottom": "16px"},
+                     children=[
+                html.Div([
+                    html.Div(label, style={**LABEL, "fontSize": "12px"}),
+                    dcc.Slider(
+                        id=f"c7-w-{sid}", min=0, max=1, step=0.05,
+                        value=0.25,
+                        marks={0: "0", 0.5: "0.5", 1: "1"},
+                        tooltip={"placement": "bottom"},
+                    ),
+                ], style={"width": "180px"})
+                for sid, label in [
+                    ("orb", "Orb-v3 (1792d)"), ("lmm", "MEGNet (758d)"),
+                    ("lofm", "OFM (188d)"), ("esen", "eSEN (128d)"),
+                ]
+            ]),
+            # Results area
+            html.Div(id="c7-status",
+                     style={"color": "#666", "marginBottom": "8px",
+                            "fontSize": "13px"},
+                     children=T["c7_status_ready"]),
+            html.Div(id="c7-results"),
+        ]),
     ],
 )
 
@@ -554,20 +923,73 @@ app.layout = html.Div(
 # CALLBACKS
 # ══════════════════════════════════════════════════════════════════════════
 
+# ── Active labels computation ──────────────────────────────────────────
+@callback(
+    Output("active-labels", "data"),
+    Input("cluster-mode", "value"),
+    Input("perspective", "value"),
+    Input("cw-orb", "value"),
+    Input("cw-mm", "value"),
+    Input("cw-ofm", "value"),
+    Input("cw-esen", "value"),
+)
+def compute_labels(mode, preset, w_orb, w_mm, w_ofm, w_esen):
+    if mode == "preset":
+        return {"mode": "preset", "key": preset or "balanced"}
+    # Custom: normalize weights
+    w = [w_orb or 0.25, w_mm or 0.25, w_ofm or 0.25, w_esen or 0.25]
+    total = sum(w)
+    if total > 0:
+        w = [x / total for x in w]
+    else:
+        w = [0.25, 0.25, 0.25, 0.25]
+    return {"mode": "custom", "weights": w}
+
+
+# ── Clustering mode toggle (show/hide preset vs custom controls) ───────
+@callback(
+    Output("preset-container", "style"),
+    Output("custom-container", "style"),
+    Input("cluster-mode", "value"),
+)
+def toggle_cluster_mode(mode):
+    if mode == "preset":
+        return {"marginTop": "8px"}, {"marginTop": "8px", "display": "none"}
+    return {"marginTop": "8px", "display": "none"}, {"marginTop": "8px"}
+
+
+# ── Dynamic family dropdown options (B4) ──────────────────────────────
+@callback(
+    Output("c1-families", "options"),
+    Output("c1-families", "value"),
+    Output("c4-family", "options"),
+    Input("active-labels", "data"),
+)
+def update_family_options(active_data):
+    families = get_all_families(active_data)
+    opts = [{"label": f, "value": f} for f in families]
+    c4_opts = [{"label": T["opt_all"], "value": "All"}] + opts
+    return opts, families, c4_opts
+
+
 # ── 1 Band gap distribution ──────────────────────────────────────────────
 @callback(
     Output("c1-graph", "figure"),
     Input("c1-agg", "value"),
     Input("c1-type", "value"),
     Input("c1-families", "value"),
+    Input("active-labels", "data"),
 )
-def chart1(agg, chart_type, families):
-    sub = df[df["Family"].isin(families)] if families else df
+def chart1(agg, chart_type, families, active_data):
+    _, fam_series, display_series = resolve_labels(active_data)
+    work = df.assign(Family=fam_series, FamilyDisplay=display_series)
+    sub = work[work["Family"].isin(families)] if families else work
     grouped = sub.groupby("Family")["BandGap"].agg(AGG_MAP[agg]).reset_index()
     grouped.columns = ["Family", "BandGap"]
     grouped = grouped.sort_values("BandGap")
-    # Translate family names for display
-    grouped["FamilyDisplay"] = grouped["Family"].map(family_label)
+    # Build display mapping from the current labels
+    fam_to_display = dict(zip(work["Family"], work["FamilyDisplay"]))
+    grouped["FamilyDisplay"] = grouped["Family"].map(fam_to_display)
     fn = px.bar if chart_type == "Bar" else px.line
     agg_display = AGG_DISPLAY.get(agg, agg)
     fig = fn(grouped, x="FamilyDisplay", y="BandGap",
@@ -585,12 +1007,15 @@ def chart1(agg, chart_type, families):
     Input("c2-left-type", "value"),
     Input("c2-right-type", "value"),
     Input("c2-yaxis", "value"),
+    Input("active-labels", "data"),
 )
-def chart2(left_type, right_type, yaxis_mode):
+def chart2(left_type, right_type, yaxis_mode, active_data):
+    clusters, _, _ = resolve_labels(active_data)
+    work = df.assign(Cluster=clusters)
     figs = []
     y_max = 0
     for mat_type in [left_type, right_type]:
-        sub = df[df["Type"] == mat_type]
+        sub = work[work["Type"] == mat_type]
         grouped = (sub.groupby("Cluster")["BandGap"].mean()
                    .reset_index().sort_values("Cluster"))
         type_disp = type_label(mat_type)
@@ -613,9 +1038,12 @@ def chart2(left_type, right_type, yaxis_mode):
     Input("c3-color", "value"),
     Input("c3-filter", "value"),
     Input("c3-topn", "value"),
+    Input("active-labels", "data"),
 )
-def chart3(ndim, color_by, filter_type, topn_str):
-    sub = df if filter_type == "All" else df[df["Type"] == filter_type]
+def chart3(ndim, color_by, filter_type, topn_str, active_data):
+    clusters, families, displays = resolve_labels(active_data)
+    work = df.assign(Cluster=clusters, Family=families, FamilyDisplay=displays)
+    sub = work if filter_type == "All" else work[work["Type"] == filter_type]
 
     # Determine color column — use display columns for translated labels
     if color_by == "None":
@@ -694,9 +1122,11 @@ COL_HEADERS = {
     Input("c4-type", "value"),
     Input("c4-sort", "value"),
     Input("c4-limit", "value"),
+    Input("active-labels", "data"),
 )
-def chart4(family, mat_type, sort_col, limit):
-    sub = df.copy()
+def chart4(family, mat_type, sort_col, limit, active_data):
+    clusters, families, displays = resolve_labels(active_data)
+    sub = df.assign(Cluster=clusters, Family=families, FamilyDisplay=displays)
     if family != "All":
         sub = sub[sub["Family"] == family]
     if mat_type != "All":
@@ -720,7 +1150,8 @@ def chart4(family, mat_type, sort_col, limit):
             if c == "BandGap":
                 val = f"{val:.3f}"
             elif c == "Family":
-                val = family_label(str(val))
+                # Use display name from FamilyDisplay
+                val = sub.loc[r.name, "FamilyDisplay"] if r.name in sub.index else str(val)
             elif c == "Type":
                 val = type_label(str(val))
             else:
@@ -743,11 +1174,18 @@ def chart4(family, mat_type, sort_col, limit):
     Input("c5-agg", "value"),
     Input("c5-color", "value"),
     Input("c5-sort", "value"),
+    Input("active-labels", "data"),
 )
-def chart5(row_dim, col_dim, val_col, agg_name, color_mode, sort_mode):
+def chart5(row_dim, col_dim, val_col, agg_name, color_mode, sort_mode, active_data):
+    clusters, families, displays = resolve_labels(active_data)
+    work = df.assign(Cluster=clusters, Family=families, FamilyDisplay=displays)
+
+    # Build display mapping for pivot labels
+    fam_to_display = dict(zip(work["Family"], work["FamilyDisplay"]))
+
     agg_fn = AGG_MAP[agg_name]
-    pivot = df.pivot_table(index=row_dim, columns=col_dim,
-                           values=val_col, aggfunc=agg_fn)
+    pivot = work.pivot_table(index=row_dim, columns=col_dim,
+                             values=val_col, aggfunc=agg_fn)
 
     # Sort
     if "Rows" in sort_mode:
@@ -780,12 +1218,11 @@ def chart5(row_dim, col_dim, val_col, agg_name, color_mode, sort_mode):
             })
         )
 
-    # Translate column headers
+    # Translate pivot labels
     def translate_pivot_label(val, dim):
-        """Translate pivot row/column labels."""
         s = str(val)
         if dim == "Family":
-            return family_label(s)
+            return fam_to_display.get(s, s)
         if dim == "Type":
             return type_label(s)
         return s
@@ -852,18 +1289,21 @@ def chart5(row_dim, col_dim, val_col, agg_name, color_mode, sort_mode):
     Output("c6-graph", "figure"),
     Input("c6-n", "value"),
     Input("c6-metric", "value"),
+    Input("active-labels", "data"),
 )
-def chart6(n, metric):
+def chart6(n, metric, active_data):
+    _, families, displays = resolve_labels(active_data)
+    work = df.assign(Family=families, FamilyDisplay=displays)
+    fam_to_display = dict(zip(work["Family"], work["FamilyDisplay"]))
     if metric == "Count":
-        grouped = df.groupby("Family").size().reset_index(name="Value")
+        grouped = work.groupby("Family").size().reset_index(name="Value")
     elif metric == "Average BandGap":
-        grouped = df.groupby("Family")["BandGap"].mean().reset_index(name="Value")
+        grouped = work.groupby("Family")["BandGap"].mean().reset_index(name="Value")
     else:
-        grouped = df.groupby("Family")["BandGap"].max().reset_index(name="Value")
+        grouped = work.groupby("Family")["BandGap"].max().reset_index(name="Value")
     grouped = grouped.nlargest(n, "Value")
     grouped = grouped.sort_values("Value")
-    # Translate family names for display
-    grouped["FamilyDisplay"] = grouped["Family"].map(family_label)
+    grouped["FamilyDisplay"] = grouped["Family"].map(fam_to_display)
     metric_display = METRIC_DISPLAY.get(metric, metric)
     fig = px.bar(grouped, y="FamilyDisplay", x="Value", orientation="h",
                  title=T["chart_top_n"].format(n=n, metric=metric_display),
@@ -873,6 +1313,119 @@ def chart6(n, metric):
     return fig
 
 
+# ── 7 Similar Materials Search ────────────────────────────────────────────
+
+def _render_c7_table(results, query_mp_id):
+    """Render weighted cosine similarity results as an HTML table."""
+    score_names = ["orb", "l_mm", "l_ofm", "esen"]
+    col_labels = [
+        T["c7_col_rank"], T["c7_col_formula"], T["c7_col_mpid"],
+        T["c7_col_bandgap"],
+        T["c7_col_orb"], T["c7_col_lmm"], T["c7_col_lofm"], T["c7_col_esen"],
+        T["c7_col_weighted"],
+    ]
+    hdr = html.Tr([
+        html.Th(c, style={"padding": "6px 10px", "fontWeight": "700",
+                          "fontFamily": MONO, "fontSize": "12px",
+                          "borderBottom": "2px solid #aaa",
+                          "textAlign": "right" if i >= 3 else "left"})
+        for i, c in enumerate(col_labels)
+    ])
+    rows = []
+    for rank, r in enumerate(results, 1):
+        is_self = r["mp_id"] == query_mp_id
+        row_bg = {"background": "#e3f2fd"} if is_self else {}
+        cell_style = {"padding": "4px 10px", "fontFamily": MONO,
+                      "fontSize": "12px", "borderBottom": "1px solid #eee"}
+        cells = [
+            html.Td(str(rank), style=cell_style),
+            html.Td(r["formula"], style={**cell_style,
+                     "fontWeight": "600" if is_self else "400"}),
+            html.Td(r["mp_id"], style=cell_style),
+            html.Td(f"{r['band_gap']:.4f}",
+                     style={**cell_style, "textAlign": "right"}),
+        ]
+        for name in score_names:
+            cells.append(html.Td(
+                f"{r['scores'][name]:.4f}",
+                style={**cell_style, "textAlign": "right"},
+            ))
+        cells.append(html.Td(
+            f"{r['weighted_score']:.4f}",
+            style={**cell_style, "textAlign": "right", "fontWeight": "700"},
+        ))
+        rows.append(html.Tr(cells, style=row_bg))
+    return html.Table(
+        [html.Thead(hdr), html.Tbody(rows)],
+        style={"width": "100%", "borderCollapse": "collapse"},
+    )
+
+
+@callback(
+    Output("c7-results", "children"),
+    Output("c7-status", "children"),
+    Input("c7-search-btn", "n_clicks"),
+    State("c7-material", "value"),
+    State("c7-topk", "value"),
+    State("c7-w-orb", "value"),
+    State("c7-w-lmm", "value"),
+    State("c7-w-lofm", "value"),
+    State("c7-w-esen", "value"),
+    prevent_initial_call=True,
+)
+def chart7(n_clicks, mp_id, top_k, w_orb, w_lmm, w_lofm, w_esen):
+    if not mp_id:
+        return None, T["c7_status_ready"]
+
+    # 1. Lazy Qdrant client
+    client, error = get_qdrant_client()
+    if error:
+        return None, T["c7_status_no_qdrant"].format(error=error)
+
+    # 2. Build & normalize weights
+    weights = {"orb": w_orb or 0, "l_mm": w_lmm or 0,
+               "l_ofm": w_lofm or 0, "esen": w_esen or 0}
+    total = sum(weights.values())
+    if total > 0:
+        weights = {k: v / total for k, v in weights.items()}
+    else:
+        weights = {k: 0.25 for k in weights}
+
+    # 3. Resolve mp_id → Qdrant point ID
+    from qdrant_client.models import Filter, FieldCondition, MatchValue
+    scroll_result = client.scroll(
+        collection_name="crystal-chroma-fusion",
+        scroll_filter=Filter(
+            must=[FieldCondition(key="mp_id", match=MatchValue(value=mp_id))]
+        ),
+        limit=1, with_vectors=False,
+    )
+    if not scroll_result[0]:
+        return None, T["c7_status_not_found"]
+    query_point_id = scroll_result[0][0].id
+
+    # 4. Run weighted cosine search
+    from search.fusion import weighted_cosine_search
+    try:
+        results = weighted_cosine_search(
+            client=client,
+            collection="crystal-chroma-fusion",
+            query_point_id=query_point_id,
+            weights=weights,
+            top_k=top_k,
+            prefetch_k=max(top_k * 5, 50),
+        )
+    except Exception as e:
+        return None, f"Search error: {e}"
+
+    if not results:
+        return None, T["c7_status_not_found"]
+
+    w_str = ", ".join(f"{k}={v:.2f}" for k, v in weights.items())
+    status = f"{len(results)} results  |  {w_str}"
+    return _render_c7_table(results, mp_id), status
+
+
 # ── run ───────────────────────────────────────────────────────────────────
 if __name__ == "__main__":
     host = os.environ.get("HOST", "127.0.0.1")

docs/cluster_definitions_presets.json

@@ -0,0 +1,400 @@
+{
+  "balanced": {
+    "-1": "Unclassified / Noise",
+    "0": "Heavy Transition Metal Intermetallics",
+    "1": "Alkali Fluorides",
+    "2": "Rare Earth Carbonitrides",
+    "3": "Alkali Hydroxides",
+    "4": "Alkali Chalcogenides",
+    "5": "Alkali Chlorides",
+    "6": "Alkali Heavy Halides",
+    "7": "Alkali Phosphates",
+    "8": "Alkali Chalcogenide Oxysalts",
+    "9": "Transition Metal Pnictides",
+    "10": "Transition Metal Silicides",
+    "11": "Heavy Transition Metal Borides",
+    "12": "p-Block Metal Intermetallics",
+    "13": "Rare Earth Intermetallics",
+    "14": "Heavy Transition Metal Oxides (Ba/Ru)",
+    "15": "Alkali Oxides",
+    "16": "Heavy Transition Metal Oxides (Ta/Ba)"
+  },
+  "balanced_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "重遷移金属金属間化合物",
+    "1": "アルカリ金属フッ化物",
+    "2": "希土類炭窒化物",
+    "3": "アルカリ金属水酸化物",
+    "4": "アルカリ金属カルコゲナイド",
+    "5": "アルカリ金属塩化物",
+    "6": "アルカリ金属重ハロゲン化物",
+    "7": "アルカリ金属リン酸塩",
+    "8": "アルカリ金属カルコゲン酸塩",
+    "9": "遷移金属プニクタイド",
+    "10": "遷移金属ケイ化物",
+    "11": "重遷移金属ホウ化物",
+    "12": "p-ブロック金属金属間化合物",
+    "13": "希土類金属間化合物",
+    "14": "重遷移金属酸化物 (Ba/Ru)",
+    "15": "アルカリ金属酸化物",
+    "16": "重遷移金属酸化物 (Ta/Ba)"
+  },
+  "orb_only": {
+    "-1": "Unclassified / Noise",
+    "0": "Alkali Fluorides",
+    "1": "Alkaline Earth Carbonitrides",
+    "2": "Alkali Chalcogenide Oxysalts",
+    "3": "Rare Earth Intermetallics (Hg/Pm)",
+    "4": "Alkali Chlorides",
+    "5": "Heavy Transition Metal Intermetallics (Pt/Rh)",
+    "6": "p-Block Metal Intermetallics",
+    "7": "Transition Metal Pnictides",
+    "8": "Heavy Transition Metal Borides",
+    "9": "Transition Metal Intermetallics (Si/B)",
+    "10": "Transition Metal Intermetallics (Ga/Zn)",
+    "11": "Rare Earth Intermetallics (Si/Ge)",
+    "12": "Heavy Transition Metal Intermetallics (In/Au)",
+    "13": "Alkaline Earth Pnictides",
+    "14": "Alkali Chalcogenides (Cu/K)",
+    "15": "Rare Earth Chalcogenides (Sb/As)",
+    "16": "Rare Earth Chalcogenides (La/Si)",
+    "17": "Alkali Chalcogenides (P/K)"
+  },
+  "orb_only_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "アルカリ金属フッ化物",
+    "1": "アルカリ土類炭窒化物",
+    "2": "アルカリ金属カルコゲン酸塩",
+    "3": "希土類金属間化合物 (Hg/Pm)",
+    "4": "アルカリ金属塩化物",
+    "5": "重遷移金属金属間化合物 (Pt/Rh)",
+    "6": "p-ブロック金属金属間化合物",
+    "7": "遷移金属プニクタイド",
+    "8": "重遷移金属ホウ化物",
+    "9": "遷移金属金属間化合物 (Si/B)",
+    "10": "遷移金属金属間化合物 (Ga/Zn)",
+    "11": "希土類金属間化合物 (Si/Ge)",
+    "12": "重遷移金属金属間化合物 (In/Au)",
+    "13": "アルカリ土類プニクタイド",
+    "14": "アルカリ金属カルコゲナイド (Cu/K)",
+    "15": "希土類カルコゲナイド (Sb/As)",
+    "16": "希土類カルコゲナイド (La/Si)",
+    "17": "アルカリ金属カルコゲナイド (P/K)"
+  },
+  "mm_only": {
+    "-1": "Unclassified / Noise",
+    "0": "Heavy Transition Metal Intermetallics",
+    "1": "Alkali Fluorides",
+    "2": "Alkali Chalcogenide Oxysalts",
+    "3": "Alkaline Earth Nitrides",
+    "4": "Rare Earth Chalcogenides"
+  },
+  "mm_only_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "重遷移金属金属間化合物",
+    "1": "アルカリ金属フッ化物",
+    "2": "アルカリ金属カルコゲン酸塩",
+    "3": "アルカリ土類窒化物",
+    "4": "希土類カルコゲナイド"
+  },
+  "ofm_only": {
+    "-1": "Unclassified / Noise",
+    "0": "Alkali Phosphates",
+    "1": "Transition Metal Nitrides",
+    "2": "Alkali Fluorides",
+    "3": "Rare Earth Intermetallics",
+    "4": "Heavy Transition Metal Intermetallics (Pt/Si)",
+    "5": "Heavy Transition Metal Intermetallics (Si/Ge)",
+    "6": "Transition Metal Chalcogenide Oxysalts (Mo/Mn)",
+    "7": "Transition Metal Chalcogenide Oxysalts (Ti/Zr)",
+    "8": "Transition Metal Chalcogenide Oxysalts (V/Ta)",
+    "9": "p-Block Metal Borates",
+    "10": "Alkali Silicates",
+    "11": "Alkali Chalcogenide Oxysalts",
+    "12": "Rare Earth Chalcogenide Oxysalts",
+    "13": "Heavy Transition Metal Chalcogenide Oxysalts"
+  },
+  "ofm_only_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "アルカリ金属リン酸塩",
+    "1": "遷移金属窒化物",
+    "2": "アルカリ金属フッ化物",
+    "3": "希土類金属間化合物",
+    "4": "重遷移金属金属間化合物 (Pt/Si)",
+    "5": "重遷移金属金属間化合物 (Si/Ge)",
+    "6": "遷移金属カルコゲン酸塩 (Mo/Mn)",
+    "7": "遷移金属カルコゲン酸塩 (Ti/Zr)",
+    "8": "遷移金属カルコゲン酸塩 (V/Ta)",
+    "9": "p-ブロック金属ホウ酸塩",
+    "10": "アルカリ金属ケイ酸塩",
+    "11": "アルカリ金属カルコゲン酸塩",
+    "12": "希土類カルコゲン酸塩",
+    "13": "重遷移金属カルコゲン酸塩"
+  },
+  "esen_only": {
+    "-1": "Unclassified / Noise",
+    "0": "Alkali Oxides",
+    "1": "Rare Earth Oxides",
+    "2": "Heavy Transition Metal Intermetallics",
+    "3": "Rare Earth Chalcogenides",
+    "4": "Alkali Pnictides",
+    "5": "Alkali Chalcogenides",
+    "6": "Alkali Chlorides"
+  },
+  "esen_only_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "アルカリ金属酸化物",
+    "1": "希土類酸化物",
+    "2": "重遷移金属金属間化合物",
+    "3": "希土類カルコゲナイド",
+    "4": "アルカリ金属プニクタイド",
+    "5": "アルカリ金属カルコゲナイド",
+    "6": "アルカリ金属塩化物"
+  },
+  "stability": {
+    "-1": "Unclassified / Noise",
+    "0": "Heavy Transition Metal Intermetallics (Li/Mg)",
+    "1": "Alkali Fluorides",
+    "2": "Alkali Hydroxides",
+    "3": "Rare Earth Carbonitrides",
+    "4": "Alkali Chalcogenides",
+    "5": "Alkali Phosphates",
+    "6": "Alkali Chalcogenide Oxysalts",
+    "7": "Alkali Chlorides",
+    "8": "Alkali Heavy Halides",
+    "9": "Heavy Transition Metal Oxides (Ba/Ru)",
+    "10": "Heavy Transition Metal Borides",
+    "11": "Transition Metal Pnictides (Ni/P)",
+    "12": "Transition Metal Pnictides (Si/Co)",
+    "13": "Transition Metal Oxides",
+    "14": "Rare Earth Intermetallics (Sn/Ge)",
+    "15": "Heavy Transition Metal Oxides (Ta/Ba)",
+    "16": "Alkali Oxides",
+    "17": "Alkaline Earth Silicates",
+    "18": "p-Block Metal Intermetallics",
+    "19": "Rare Earth Intermetallics (Pd/Ni)",
+    "20": "Heavy Transition Metal Intermetallics (Au/In)"
+  },
+  "stability_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "重遷移金属金属間化合物 (Li/Mg)",
+    "1": "アルカリ金属フッ化物",
+    "2": "アルカリ金属水酸化物",
+    "3": "希土類炭窒化物",
+    "4": "アルカリ金属カルコゲナイド",
+    "5": "アルカリ金属リン酸塩",
+    "6": "アルカリ金属カルコゲン酸塩",
+    "7": "アルカリ金属塩化物",
+    "8": "アルカリ金属重ハロゲン化物",
+    "9": "重遷移金属酸化物 (Ba/Ru)",
+    "10": "重遷移金属ホウ化物",
+    "11": "遷移金属プニクタイド (Ni/P)",
+    "12": "遷移金属プニクタイド (Si/Co)",
+    "13": "遷移金属酸化物",
+    "14": "希土類金属間化合物 (Sn/Ge)",
+    "15": "重遷移金属酸化物 (Ta/Ba)",
+    "16": "アルカリ金属酸化物",
+    "17": "アルカリ土類ケイ酸塩",
+    "18": "p-ブロック金属金属間化合物",
+    "19": "希土類金属間化合物 (Pd/Ni)",
+    "20": "重遷移金属金属間化合物 (Au/In)"
+  },
+  "electronic": {
+    "-1": "Unclassified / Noise",
+    "0": "Heavy Transition Metal Intermetallics (Li/Mg)",
+    "1": "Alkali Fluorides",
+    "2": "Alkaline Earth Carbonitrides",
+    "3": "Alkali Hydroxides",
+    "4": "Alkali Chalcogenides",
+    "5": "Heavy Transition Metal Intermetallics (Si/Ni)",
+    "6": "Alkali Phosphates",
+    "7": "Alkali Chlorides",
+    "8": "Alkali Heavy Halides",
+    "9": "Transition Metal Chalcogenide Oxysalts",
+    "10": "Transition Metal Oxides (Mo/V)",
+    "11": "Alkali Oxides",
+    "12": "Heavy Transition Metal Oxides",
+    "13": "Transition Metal Oxides (Mn/Fe)"
+  },
+  "electronic_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "重遷移金属金属間化合物 (Li/Mg)",
+    "1": "アルカリ金属フッ化物",
+    "2": "アルカリ土類炭窒化物",
+    "3": "アルカリ金属水酸化物",
+    "4": "アルカリ金属カルコゲナイド",
+    "5": "重遷移金属金属間化合物 (Si/Ni)",
+    "6": "アルカリ金属リン酸塩",
+    "7": "アルカリ金属塩化物",
+    "8": "アルカリ金属重ハロゲン化物",
+    "9": "遷移金属カルコゲン酸塩",
+    "10": "遷移金属酸化物 (Mo/V)",
+    "11": "アルカリ金属酸化物",
+    "12": "重遷移金属酸化物",
+    "13": "遷移金属酸化物 (Mn/Fe)"
+  },
+  "structural": {
+    "-1": "Unclassified / Noise",
+    "0": "Heavy Transition Metal Intermetallics",
+    "1": "Alkali Fluorides",
+    "2": "Rare Earth Carbonitrides",
+    "3": "Alkali Hydroxides",
+    "4": "Alkali Chalcogenides",
+    "5": "Alkali Phosphates",
+    "6": "Alkali Chlorides",
+    "7": "Alkali Heavy Halides",
+    "8": "Heavy Transition Metal Oxides (Ba/Ru)",
+    "9": "Transition Metal Pnictides (Ni/P)",
+    "10": "Alkali Chalcogenide Oxysalts",
+    "11": "Transition Metal Oxides (Mo/V)",
+    "12": "Heavy Transition Metal Borides",
+    "13": "Transition Metal Pnictides (Si/Co)",
+    "14": "p-Block Metal Intermetallics",
+    "15": "Rare Earth Intermetallics",
+    "16": "Alkali Silicates",
+    "17": "Heavy Transition Metal Oxides (Ba/Ta)",
+    "18": "Transition Metal Oxides (Mn/Fe)"
+  },
+  "structural_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "重遷移金属金属間化合物",
+    "1": "アルカリ金属フッ化物",
+    "2": "希土類炭窒化物",
+    "3": "アルカリ金属水酸化物",
+    "4": "アルカリ金属カルコゲナイド",
+    "5": "アルカリ金属リン酸塩",
+    "6": "アルカリ金属塩化物",
+    "7": "アルカリ金属重ハロゲン化物",
+    "8": "重遷移金属酸化物 (Ba/Ru)",
+    "9": "遷移金属プニクタイド (Ni/P)",
+    "10": "アルカリ金属カルコゲン酸塩",
+    "11": "遷移金属酸化物 (Mo/V)",
+    "12": "重遷移金属ホウ化物",
+    "13": "遷移金属プニクタイド (Si/Co)",
+    "14": "p-ブロック金属金属間化合物",
+    "15": "希土類金属間化合物",
+    "16": "アルカリ金属ケイ酸塩",
+    "17": "重遷移金属酸化物 (Ba/Ta)",
+    "18": "遷移金属酸化物 (Mn/Fe)"
+  },
+  "chemical": {
+    "-1": "Unclassified / Noise",
+    "0": "Heavy Transition Metal Intermetallics (Li/Mg)",
+    "1": "Alkali Fluorides",
+    "2": "Alkaline Earth Carbonitrides",
+    "3": "Alkali Hydroxides",
+    "4": "Alkali Phosphates",
+    "5": "Alkali Chalcogenides",
+    "6": "Alkali Heavy Halides",
+    "7": "Alkali Chlorides",
+    "8": "Transition Metal Pnictides",
+    "9": "Heavy Transition Metal Oxides (Ba/Ru)",
+    "10": "Heavy Transition Metal Borides",
+    "11": "Transition Metal Oxides (Mo/V)",
+    "12": "Alkali Chalcogenide Oxysalts",
+    "13": "Transition Metal Silicides",
+    "14": "Heavy Transition Metal Oxides (Ta/Ba)",
+    "15": "Transition Metal Oxides (Mn/Fe)",
+    "16": "Alkali Oxides",
+    "17": "Alkali Silicates",
+    "18": "Heavy Transition Metal Intermetallics (Pd/Ni)",
+    "19": "Heavy Transition Metal Intermetallics (Au/In)",
+    "20": "p-Block Metal Intermetallics"
+  },
+  "chemical_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "重遷移金属金属間化合物 (Li/Mg)",
+    "1": "アルカリ金属フッ化物",
+    "2": "アルカリ土類炭窒化物",
+    "3": "アルカリ金属水酸化物",
+    "4": "アルカリ金属リン酸塩",
+    "5": "アルカリ金属カルコゲナイド",
+    "6": "アルカリ金属重ハロゲン化物",
+    "7": "アルカリ金属塩化物",
+    "8": "遷移金属プニクタイド",
+    "9": "重遷移金属酸化物 (Ba/Ru)",
+    "10": "重遷移金属ホウ化物",
+    "11": "遷移金属酸化物 (Mo/V)",
+    "12": "アルカリ金属カルコゲン酸塩",
+    "13": "遷移金属ケイ化物",
+    "14": "重遷移金属酸化物 (Ta/Ba)",
+    "15": "遷移金属酸化物 (Mn/Fe)",
+    "16": "アルカリ金属酸化物",
+    "17": "アルカリ金属ケイ酸塩",
+    "18": "重遷移金属金属間化合物 (Pd/Ni)",
+    "19": "重遷移金属金属間化合物 (Au/In)",
+    "20": "p-ブロック金属金属間化合物"
+  },
+  "coord_energy": {
+    "-1": "Unclassified / Noise",
+    "0": "Heavy Transition Metal Intermetallics",
+    "1": "Alkali Fluorides",
+    "2": "Alkali Hydroxides",
+    "3": "Alkali Oxides",
+    "4": "Alkali Heavy Halides",
+    "5": "Alkaline Earth Carbonitrides",
+    "6": "Alkali Chalcogenides",
+    "7": "p-Block Metal Intermetallics",
+    "8": "Rare Earth Intermetallics",
+    "9": "Transition Metal Pnictides",
+    "10": "Transition Metal Silicides",
+    "11": "Heavy Transition Metal Borides"
+  },
+  "coord_energy_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "重遷移金属金属間化合物",
+    "1": "アルカリ金属フッ化物",
+    "2": "アルカリ金属水酸化物",
+    "3": "アルカリ金属酸化物",
+    "4": "アルカリ金属重ハロゲン化物",
+    "5": "アルカリ土類炭窒化物",
+    "6": "アルカリ金属カルコゲナイド",
+    "7": "p-ブロック金属金属間化合物",
+    "8": "希土類金属間化合物",
+    "9": "遷移金属プニクタイド",
+    "10": "遷移金属ケイ化物",
+    "11": "重遷移金属ホウ化物"
+  },
+  "mechanochem": {
+    "-1": "Unclassified / Noise",
+    "0": "Heavy Transition Metal Intermetallics",
+    "1": "Alkali Fluorides",
+    "2": "Alkaline Earth Carbonitrides",
+    "3": "Alkali Hydroxides",
+    "4": "Alkali Chlorides",
+    "5": "Alkali Heavy Halides",
+    "6": "Alkali Chalcogenides",
+    "7": "Alkali Phosphates",
+    "8": "Rare Earth Intermetallics",
+    "9": "Transition Metal Pnictides",
+    "10": "Transition Metal Silicides",
+    "11": "Heavy Transition Metal Borides",
+    "12": "Alkali Chalcogenide Oxysalts",
+    "13": "Transition Metal Chalcogenide Oxysalts",
+    "14": "Heavy Transition Metal Oxides",
+    "15": "Alkali Oxides",
+    "16": "Transition Metal Oxides",
+    "17": "Rare Earth Oxides"
+  },
+  "mechanochem_ja": {
+    "-1": "未分類 / ノイズ",
+    "0": "重遷移金属金属間化合物",
+    "1": "アルカリ金属フッ化物",
+    "2": "アルカリ土類炭窒化物",
+    "3": "アルカリ金属水酸化物",
+    "4": "アルカリ金属塩化物",
+    "5": "アルカリ金属重ハロゲン化物",
+    "6": "アルカリ金属カルコゲナイド",
+    "7": "アルカリ金属リン酸塩",
+    "8": "希土類金属間化合物",
+    "9": "遷移金属プニクタイド",
+    "10": "遷移金属ケイ化物",
+    "11": "重遷移金属ホウ化物",
+    "12": "アルカリ金属カルコゲン酸塩",
+    "13": "遷移金属カルコゲン酸塩",
+    "14": "重遷移金属酸化物",
+    "15": "アルカリ金属酸化物",
+    "16": "遷移金属酸化物",
+    "17": "希土類酸化物"
+  }
+}

material_universe_cache/centroid_sim_esen.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c98ab7da174c3f0937f88c701d24c5ed1ecad53ddb52ae778003746130e63de
+size 2310292

material_universe_cache/centroid_sim_mm.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8d7bf14dd86264aa1b71f5047772cfd19e83d6c0f51d8331d8397b871908212
+size 2310292

material_universe_cache/centroid_sim_ofm.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4bd40e74b7fa5d9bd089ffb1c7cf9a092999aaa67508d232117d1ed966c0ed1
+size 2310292

material_universe_cache/centroid_sim_orb.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:46c44c25a72dfed5554fbaff263af45440b005c803e5b3f287e03630aff012a3
+size 2310292

material_universe_cache/cluster_labels_balanced.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad2e2ca00f631643c5a461a88a0afd171560613de5bfe7157c5f167c6035f1dc
+size 271912

material_universe_cache/cluster_labels_chemical.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2dda41b9b2c73b7efac137e9c6cc80ad850f0c01a046a518f68cc9f9ff6b163a
+size 271912

material_universe_cache/cluster_labels_coord_energy.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f7b60ddd865245ff7f913f87fb9251a9798c2f8fdb41ee23af53fa353469cf2
+size 271912

material_universe_cache/cluster_labels_electronic.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11af565fe692d26483eef032089c25cf782f049d411af5fdc07e41f9c67792df
+size 271912

material_universe_cache/cluster_labels_esen_only.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:712e9ade496dca83a1d5d78edbe6706609aaa41a8507271f28005850d21c167f
+size 271912

material_universe_cache/cluster_labels_mechanochem.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26a450c477dcfa3e53415d5ded631b1a14debbb759fe4cf6ef68d20d4831f2f7
+size 271912

material_universe_cache/cluster_labels_mm_only.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3877c1e53ed00194261b6cecd42873141c5210029d142f0eb777a886cec6d2e7
+size 271912

material_universe_cache/cluster_labels_ofm_only.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0612cd6f5b93b42985ed1b87d17848d028b15fae74b6871e4f47aed8c0cdb8ee
+size 271912

material_universe_cache/cluster_labels_orb_only.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:611c644dbfbbc3559821e1c6dfe53771eeadfbca68666c29d199295ffca3575d
+size 271912

material_universe_cache/cluster_labels_stability.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a43025c1822ff6be232dec18acfa2d860763538ce7899f6b438296b7513bbd74
+size 271912

material_universe_cache/cluster_labels_structural.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38d85e5e8e03aefe0c4d6d6124541e8a3bc61bc4aa30e5663c58501b04001c45
+size 271912

material_universe_cache/plotly_studio_export.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0c09907db415aeb8b77eee2c1efdb6a0d44446a9c401a0e09b1731b64c68d61e
-size 24754864
+oid sha256:28d5a2616fc8dcd9469c0303f64b4eb61bb8c9bb07c8f614281076a93e87113e
+size 13630877

requirements-hf.txt

@@ -2,3 +2,6 @@ dash>=4.0.0
 plotly>=6.0
 pandas>=2.0
 scikit-learn>=1.0
+qdrant-client>=1.7.0
+python-dotenv>=1.0
+numpy>=2.0

search/fusion.py

@@ -0,0 +1,129 @@
+"""
+Weighted cosine similarity fusion for multi-vector search.
+
+Searches across all 4 named vector spaces in the crystal-chroma-fusion
+Qdrant collection and re-ranks candidates by a weighted sum of cosine
+similarities.
+
+Used by:
+    - app.py (C7 Similar Materials Search card)
+    - tests/test_quad_fusion.py (Test 6)
+"""
+
+import numpy as np
+from qdrant_client import QdrantClient, models
+
+COLLECTION = "crystal-chroma-fusion"
+
+VECTOR_NAMES = ["orb", "l_mm", "l_ofm", "esen"]
+
+VECTOR_SPEC = {
+    "orb":   {"dim": 1792, "distance": "Cosine"},
+    "l_mm":  {"dim": 758,  "distance": "Euclid"},
+    "l_ofm": {"dim": 188,  "distance": "Euclid"},
+    "esen":  {"dim": 128,  "distance": "Cosine"},
+}
+
+DEFAULT_WEIGHTS = {name: 1.0 / len(VECTOR_NAMES) for name in VECTOR_NAMES}
+
+
+def _search_params():
+    """SearchParams with rescore=True for INT8 quantization accuracy."""
+    return models.SearchParams(
+        quantization=models.QuantizationSearchParams(
+            rescore=True,
+            oversampling=2.0,
+        )
+    )
+
+
+def cosine_similarity(a, b):
+    """Cosine similarity between two vectors."""
+    a = np.asarray(a, dtype=np.float64)
+    b = np.asarray(b, dtype=np.float64)
+    dot = np.dot(a, b)
+    na = np.linalg.norm(a)
+    nb = np.linalg.norm(b)
+    if na == 0 or nb == 0:
+        return 0.0
+    return float(dot / (na * nb))
+
+
+def weighted_cosine_search(
+    client: QdrantClient,
+    collection: str,
+    query_point_id: int,
+    weights: dict[str, float] | None = None,
+    top_k: int = 10,
+    prefetch_k: int = 50,
+    vector_names: list[str] | None = None,
+) -> list[dict]:
+    """
+    Weighted cosine similarity fusion search.
+
+    1. Retrieve query point's named vectors
+    2. Query top-prefetch_k from each vector space (with rescore)
+    3. Pool all candidate IDs
+    4. Batch-retrieve full vectors for all candidates
+    5. Compute per-vector cosine similarity + weighted sum
+    6. Return top_k results sorted by weighted score
+
+    Returns list of dicts:
+        {"id", "mp_id", "formula", "band_gap", "scores": {...}, "weighted_score"}
+    """
+    if vector_names is None:
+        vector_names = VECTOR_NAMES
+    if weights is None:
+        weights = DEFAULT_WEIGHTS
+
+    # 1. Retrieve query vectors
+    pts = client.retrieve(collection, ids=[query_point_id], with_vectors=True)
+    if not pts:
+        return []
+    qpoint = pts[0]
+    query_vecs = {name: np.array(qpoint.vector[name]) for name in vector_names}
+
+    # 2. Gather candidates from each vector space
+    sp = _search_params()
+    candidate_ids = set()
+    for name in vector_names:
+        results = client.query_points(
+            collection_name=collection,
+            query=qpoint.vector[name],
+            using=name,
+            limit=prefetch_k,
+            search_params=sp,
+        )
+        for h in results.points:
+            candidate_ids.add(h.id)
+
+    # 3. Batch-retrieve full vectors for all candidates
+    candidate_list = sorted(candidate_ids)
+    all_candidates = {}
+    batch_size = 100
+    for i in range(0, len(candidate_list), batch_size):
+        batch_ids = candidate_list[i:i + batch_size]
+        batch_pts = client.retrieve(collection, ids=batch_ids, with_vectors=True)
+        for p in batch_pts:
+            all_candidates[p.id] = p
+
+    # 4. Compute weighted cosine similarity
+    scored = []
+    for cid, cpoint in all_candidates.items():
+        per_vec = {}
+        for name in vector_names:
+            cvec = np.array(cpoint.vector[name])
+            per_vec[name] = cosine_similarity(query_vecs[name], cvec)
+
+        weighted = sum(weights.get(name, 0.0) * per_vec[name] for name in vector_names)
+        scored.append({
+            "id": cid,
+            "mp_id": cpoint.payload.get("mp_id", ""),
+            "formula": cpoint.payload.get("formula", ""),
+            "band_gap": cpoint.payload.get("band_gap", 0.0),
+            "scores": per_vec,
+            "weighted_score": weighted,
+        })
+
+    scored.sort(key=lambda x: x["weighted_score"], reverse=True)
+    return scored[:top_k]