Update app.py

app.py

@@ -7,25 +7,28 @@ from huggingface_hub import HfApi
 
 api = HfApi()
 
-# -----------------------
+# =======================
 # i18n
-# -----------------------
+# =======================
 I18N: Dict[str, Dict[str, str]] = {
     "EN": {
         "title": "Model Fit Finder (CPU)",
         "intro": (
-            "Pick your NLP task and constraints. The Space will recommend an appropriate model type "
-            "and list at least 3 concrete Hugging Face models. Recommendations change based on your settings."
+            "Pick an NLP task and constraints. The Space recommends an appropriate model type and returns "
+            "at least 3 concrete Hugging Face models. Recommendations change based on your settings."
         ),
         "ui_lang": "UI language",
         "tab_main": "Model advisor",
         "task": "What do you want to do?",
         "has_docs": "Do you have your own documents/text to analyze?",
         "data_lang": "Data language",
-        "cpu_only": "CPU only",
         "priority": "Priority",
+        "budget": "Compute budget",
+        "source": "Model source",
+        "refresh": "Refresh HF cache",
         "recommend_btn": "Recommend",
         "result": "Result",
+        "status": "Status",
         "yes": "Yes",
         "no": "No",
         "en": "EN",
@@ -33,6 +36,11 @@ I18N: Dict[str, Dict[str, str]] = {
         "mixed": "Mixed",
         "speed": "Speed",
         "quality": "Quality",
+        "budget_low": "Low (fast/small models)",
+        "budget_med": "Medium (allow larger models)",
+        "source_curated": "Curated (stable baseline)",
+        "source_live": "HF Live (fresh from Hub)",
+        "source_hybrid": "Hybrid (curated + live)",
         "task_chat": "Chat / instructions / generation",
         "task_qa": "Answer questions from a document (input text)",
         "task_sim": "Semantic similarity / duplicates / search",
@@ -43,26 +51,31 @@ I18N: Dict[str, Dict[str, str]] = {
         "why_these": "Why these models:",
         "warning": "Warning:",
         "qa_need_docs": "Extractive QA needs a context document/text. With no documents, consider an instruction model or embeddings-based search.",
-        "note_emb": "Embedding models do not generate text; they produce vectors for similarity/search.",
-        "note_qa": "Extractive QA finds answers in the provided context.",
-        "note_instr": "Instruction-tuned models follow prompts; smaller variants are CPU-friendly.",
-        "bonus_note": "Popular model from Hub (selected by task tag and downloads).",
+        "note_emb": "Note: embedding models do not generate text; they produce vectors for similarity/search.",
+        "note_qa": "Note: extractive QA finds answers in the provided context.",
+        "note_instr": "Note: instruction-tuned models follow prompts; smaller variants are CPU-friendly.",
+        "live_note": "Live candidates pulled from Hub using pipeline tag and downloads ranking.",
+        "refreshed": "HF cache refreshed at {ts}.",
+        "refresh_failed": "Refresh failed; using cached/curated lists.",
     },
     "PL": {
         "title": "Model Fit Finder (CPU)",
         "intro": (
-            "Wybierz zadanie NLP i ograniczenia. Space zarekomenduje typ modelu "
-            "i pokaże co najmniej 3 modele. Rekomendacje zmieniają się zależnie od ustawień."
+            "Wybierz zadanie NLP i ograniczenia. Space rekomenduje typ modelu i zwraca "
+            "co najmniej 3 konkretne modele z Hugging Face. Rekomendacje zmieniają się zależnie od ustawień."
         ),
         "ui_lang": "Język interfejsu",
         "tab_main": "Doradca modeli",
         "task": "Co chcesz zrobić?",
         "has_docs": "Czy masz własne dokumenty/teksty do analizy?",
         "data_lang": "Język danych",
-        "cpu_only": "CPU only",
         "priority": "Priorytet",
+        "budget": "Budżet obliczeniowy",
+        "source": "Źródło modeli",
+        "refresh": "Odśwież cache HF",
         "recommend_btn": "Zarekomenduj",
         "result": "Wynik",
+        "status": "Status",
         "yes": "Tak",
         "no": "Nie",
         "en": "EN",
@@ -70,6 +83,11 @@ I18N: Dict[str, Dict[str, str]] = {
         "mixed": "Mieszany",
         "speed": "Szybkość",
         "quality": "Jakość",
+        "budget_low": "Niski (szybkie/małe modele)",
+        "budget_med": "Średni (pozwól na większe modele)",
+        "source_curated": "Kuratorskie (stabilna baza)",
+        "source_live": "HF Live (świeże z Hub)",
+        "source_hybrid": "Hybryda (baza + live)",
         "task_chat": "Chat / polecenia / generowanie",
         "task_qa": "Odpowiedzi na pytania z dokumentu (tekst wejściowy)",
         "task_sim": "Semantyczne podobieństwo / duplikaty / wyszukiwanie",
@@ -80,23 +98,39 @@ I18N: Dict[str, Dict[str, str]] = {
         "why_these": "Dlaczego te modele:",
         "warning": "Ostrzeżenie:",
         "qa_need_docs": "QA extractive wymaga kontekstu (dokumentu/tekstu). Bez dokumentów rozważ model instrukcyjny albo wyszukiwanie embeddingowe.",
-        "note_emb": "Modele embeddingowe nie generują tekstu; produkują wektory do podobieństwa/wyszukiwania.",
-        "note_qa": "QA extractive znajduje odpowiedzi w podanym kontekście.",
-        "note_instr": "Modele instrukcyjne wykonują polecenia; mniejsze warianty są przyjazne dla CPU.",
-        "bonus_note": "Popularny model z Hub (dobrany po tagu zadania i pobraniach).",
+        "note_emb": "Uwaga: modele embeddingowe nie generują tekstu; produkują wektory do podobieństwa/wyszukiwania.",
+        "note_qa": "Uwaga: QA extractive znajduje odpowiedzi w podanym kontekście.",
+        "note_instr": "Uwaga: modele instrukcyjne wykonują polecenia; mniejsze warianty są przyjazne dla CPU.",
+        "live_note": "Kandydaci live pobierani z Hub po pipeline tag i rankingu pobrań.",
+        "refreshed": "Cache HF odświeżony: {ts}.",
+        "refresh_failed": "Nie udało się odświeżyć; używam cache/list kuratorskich.",
     },
 }
 
 def t(ui_lang: str, key: str) -> str:
     return I18N.get(ui_lang, I18N["EN"]).get(key, I18N["EN"].get(key, key))
 
-# -----------------------
-# Internal stable values
-# -----------------------
+# =======================
+# Stable internal values
+# =======================
 TASK_CHAT = "CHAT"
 TASK_QA = "QA"
 TASK_SIM = "SIM"
 
+DATA_EN = "EN"
+DATA_PL = "PL"
+DATA_MIXED = "MIXED"
+
+PRIO_SPEED = "SPEED"
+PRIO_QUALITY = "QUALITY"
+
+BUDGET_LOW = "LOW"
+BUDGET_MED = "MED"
+
+SRC_CURATED = "CURATED"
+SRC_LIVE = "LIVE"
+SRC_HYBRID = "HYBRID"
+
 def task_choices(ui_lang: str) -> List[Tuple[str, str]]:
     return [
         (t(ui_lang, "task_chat"), TASK_CHAT),
@@ -108,122 +142,197 @@ def yesno_choices(ui_lang: str) -> List[Tuple[str, str]]:
     return [(t(ui_lang, "yes"), "YES"), (t(ui_lang, "no"), "NO")]
 
 def data_lang_choices(ui_lang: str) -> List[Tuple[str, str]]:
-    return [(t(ui_lang, "en"), "EN"), (t(ui_lang, "pl"), "PL"), (t(ui_lang, "mixed"), "MIXED")]
+    return [(t(ui_lang, "en"), DATA_EN), (t(ui_lang, "pl"), DATA_PL), (t(ui_lang, "mixed"), DATA_MIXED)]
 
 def priority_choices(ui_lang: str) -> List[Tuple[str, str]]:
-    return [(t(ui_lang, "speed"), "SPEED"), (t(ui_lang, "quality"), "QUALITY")]
+    return [(t(ui_lang, "speed"), PRIO_SPEED), (t(ui_lang, "quality"), PRIO_QUALITY)]
+
+def budget_choices(ui_lang: str) -> List[Tuple[str, str]]:
+    return [(t(ui_lang, "budget_low"), BUDGET_LOW), (t(ui_lang, "budget_med"), BUDGET_MED)]
+
+def source_choices(ui_lang: str) -> List[Tuple[str, str]]:
+    return [
+        (t(ui_lang, "source_curated"), SRC_CURATED),
+        (t(ui_lang, "source_live"), SRC_LIVE),
+        (t(ui_lang, "source_hybrid"), SRC_HYBRID),
+    ]
 
-# -----------------------
-# Candidate pool with metadata so settings can affect ranking
-# -----------------------
+# =======================
+# Curated candidates (stable baseline)
+# =======================
 @dataclass(frozen=True)
 class Candidate:
     model_id: str
-    # heuristics / tags:
-    size: str        # "small" | "base" | "large"
-    languages: str   # "EN" | "MULTI"
-    cpu_ok: bool
+    size: str         # "small" | "base" | "large" (heuristic)
+    languages: str    # "EN" | "MULTI"
     note_en: str
     note_pl: str
+    origin: str       # "curated" | "live"
 
-CANDIDATES: Dict[str, List[Candidate]] = {
+CURATED: Dict[str, List[Candidate]] = {
     "instruction": [
-        Candidate("google/flan-t5-small", "small", "EN", True,
-                  "Very light instruction-following text2text model.", "Bardzo lekki model text2text do poleceń."),
-        Candidate("google/flan-t5-base", "base", "EN", True,
-                  "Better quality than small; slower on CPU.", "Lepsza jakość niż small; wolniejszy na CPU."),
-        Candidate("google-t5/t5-small", "small", "EN", True,
-                  "Fast fallback text2text baseline.", "Szybki fallback text2text."),
-        # multilingual-ish option (not perfect, but helps when user insists on PL/mixed for generation)
-        Candidate("google/mt5-small", "small", "MULTI", True,
-                  "Multilingual T5 small for mixed-language tasks.", "Wielojęzyczny mT5 small dla zadań mix języków."),
-        Candidate("google/mt5-base", "base", "MULTI", True,
-                  "Multilingual, higher quality than mt5-small; slower.", "Wielojęzyczny, lepsza jakość niż mt5-small; wolniejszy."),
+        Candidate("google/flan-t5-small", "small", "EN",
+                  "Very light instruction-following text2text model.",
+                  "Bardzo lekki model text2text do poleceń.", "curated"),
+        Candidate("google/flan-t5-base", "base", "EN",
+                  "Better quality than small; slower on CPU.",
+                  "Lepsza jakość niż small; wolniejszy na CPU.", "curated"),
+        Candidate("google-t5/t5-small", "small", "EN",
+                  "Fast text2text fallback baseline.",
+                  "Szybki fallback text2text.", "curated"),
+        Candidate("google/mt5-small", "small", "MULTI",
+                  "Multilingual text2text (useful for mixed-language prompts).",
+                  "Wielojęzyczny text2text (przydatny dla mieszanych języków).", "curated"),
+        Candidate("google/mt5-base", "base", "MULTI",
+                  "Multilingual, higher quality than mt5-small; slower.",
+                  "Wielojęzyczny, lepsza jakość niż mt5-small; wolniejszy.", "curated"),
     ],
     "qa": [
-        Candidate("distilbert/distilbert-base-cased-distilled-squad", "small", "EN", True,
-                  "Fast extractive QA; classic CPU choice.", "Szybki QA extractive; klasyk na CPU."),
-        Candidate("distilbert/distilbert-base-uncased-distilled-squad", "small", "EN", True,
-                  "Popular extractive QA default.", "Popularny domyślny QA extractive."),
-        Candidate("deepset/bert-base-cased-squad2", "base", "EN", True,
-                  "SQuAD2 variant; better 'no answer' behavior.", "Wariant SQuAD2; lepiej obsługuje 'brak odpowiedzi'."),
-        # multilingual QA is trickier; we provide one common multilingual baseline
-        Candidate("deepset/xlm-roberta-base-squad2", "base", "MULTI", True,
-                  "Multilingual extractive QA baseline (XLM-R).", "Wielojęzyczny QA extractive (XLM-R)."),
+        Candidate("distilbert/distilbert-base-cased-distilled-squad", "small", "EN",
+                  "Fast extractive QA; classic CPU choice.",
+                  "Szybki QA extractive; klasyk na CPU.", "curated"),
+        Candidate("distilbert/distilbert-base-uncased-distilled-squad", "small", "EN",
+                  "Popular extractive QA default.",
+                  "Popularny domyślny QA extractive.", "curated"),
+        Candidate("deepset/bert-base-cased-squad2", "base", "EN",
+                  "SQuAD2 variant; better 'no answer' behavior.",
+                  "Wariant SQuAD2; lepiej obsługuje 'brak odpowiedzi'.", "curated"),
+        Candidate("deepset/xlm-roberta-base-squad2", "base", "MULTI",
+                  "Multilingual extractive QA baseline (XLM-R).",
+                  "Wielojęzyczny QA extractive (XLM-R).", "curated"),
     ],
     "embeddings": [
-        Candidate("sentence-transformers/all-MiniLM-L6-v2", "small", "EN", True,
-                  "Very fast sentence embeddings; great for similarity on CPU.", "Bardzo szybkie embeddingi; świetne do podobieństwa na CPU."),
-        Candidate("sentence-transformers/all-mpnet-base-v2", "base", "EN", True,
-                  "Higher quality embeddings than MiniLM; slower.", "Lepsza jakość niż MiniLM; wolniejsze."),
-        Candidate("intfloat/e5-small-v2", "small", "EN", True,
-                  "Strong retrieval embeddings, good speed/quality balance.", "Mocne embeddingi do wyszukiwania; dobry balans."),
-        Candidate("intfloat/e5-base-v2", "base", "EN", True,
-                  "Higher quality e5; heavier on CPU.", "Lepsza jakość e5; cięższy na CPU."),
-        Candidate("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2", "base", "MULTI", True,
-                  "Multilingual embeddings; good for PL/mixed.", "Wielojęzyczne embeddingi; dobre dla PL/mix."),
+        Candidate("sentence-transformers/all-MiniLM-L6-v2", "small", "EN",
+                  "Very fast sentence embeddings; great for similarity on CPU.",
+                  "Bardzo szybkie embeddingi; świetne do podobieństwa na CPU.", "curated"),
+        Candidate("sentence-transformers/all-mpnet-base-v2", "base", "EN",
+                  "Higher quality embeddings than MiniLM; slower.",
+                  "Lepsza jakość niż MiniLM; wolniejsze.", "curated"),
+        Candidate("intfloat/e5-small-v2", "small", "EN",
+                  "Strong retrieval embeddings, good speed/quality balance.",
+                  "Mocne embeddingi do wyszukiwania; dobry balans.", "curated"),
+        Candidate("intfloat/e5-base-v2", "base", "EN",
+                  "Higher quality e5; heavier on CPU.",
+                  "Lepsza jakość e5; cięższy na CPU.", "curated"),
+        Candidate("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2", "base", "MULTI",
+                  "Multilingual embeddings; good for Polish/mixed.",
+                  "Wielojęzyczne embeddingi; dobre dla PL/mix.", "curated"),
     ],
 }
 
-# -----------------------
-# Hub bonus models (cache)
-# -----------------------
-_HUB_CACHE: Dict[Tuple[str, str], Tuple[float, List[str]]] = {}
-CACHE_TTL_SEC = 6 * 60 * 60  # 6h
+# =======================
+# HF Live cache (in-memory TTL) + refresh button
+# =======================
+CACHE_TTL_SEC = 24 * 60 * 60  # 24h
+# cache key: (pipeline_tag, data_lang_value, library_hint, budget)
+_HUB_CACHE: Dict[Tuple[str, str, str, str], Tuple[float, List[str]]] = {}
 
 def _language_tag_predicate(tags: List[str], data_lang_value: str) -> bool:
-    if data_lang_value == "MIXED":
+    if data_lang_value == DATA_MIXED:
         return True
-    target = "en" if data_lang_value == "EN" else "pl"
+    target = "en" if data_lang_value == DATA_EN else "pl"
     candidates = {target, f"language:{target}", f"lang:{target}"}
     tags_lower = {str(x).lower() for x in (tags or [])}
     return any(c in tags_lower for c in candidates)
 
-def hub_bonus_models(pipeline_tag: str, data_lang_value: str, limit: int = 20) -> List[str]:
-    key = (pipeline_tag, data_lang_value)
+def _library_predicate(tags: List[str], library_hint: str) -> bool:
+    # Best-effort: many models have tags like "library:sentence-transformers" or "library:transformers"
+    tags_lower = {str(x).lower() for x in (tags or [])}
+    if not library_hint:
+        return True
+    return (f"library:{library_hint.lower()}" in tags_lower) or (library_hint.lower() in tags_lower)
+
+def _budget_predicate(model_id: str, tags: List[str], budget: str) -> bool:
+    # Heuristic to keep "Low" budget models lightweight.
+    # We avoid explicit "large" and certain common huge families by name heuristics.
+    # This is intentionally conservative.
+    mid = model_id.lower()
+    if budget == BUDGET_MED:
+        return True
+
+    # Low budget: prefer smaller-ish names and avoid obvious large ones.
+    if any(x in mid for x in ["-large", "large-", "xxl", "xl", "13b", "30b", "70b", "mixtral", "llama-2-70b", "llama-3-70b"]):
+        return False
+    # Keep common small cues
+    # If it doesn't contain small cues, we still allow it, but overall ranking will prefer small/base from curated anyway.
+    return True
+
+def fetch_live_model_ids(
+    pipeline_tag: str,
+    data_lang_value: str,
+    library_hint: str,
+    budget: str,
+    limit: int = 30,
+) -> List[str]:
+    key = (pipeline_tag, data_lang_value, library_hint or "", budget)
     now = time.time()
+
     if key in _HUB_CACHE:
         ts, cached = _HUB_CACHE[key]
         if now - ts < CACHE_TTL_SEC:
             return cached
+
+    models = api.list_models(filter=pipeline_tag, sort="downloads", direction=-1, limit=limit)
+    out: List[str] = []
+    for m in models:
+        mid = getattr(m, "modelId", None)
+        tags = getattr(m, "tags", []) or []
+        if not mid:
+            continue
+        if not _language_tag_predicate(tags, data_lang_value):
+            continue
+        if not _library_predicate(tags, library_hint):
+            continue
+        if not _budget_predicate(mid, tags, budget):
+            continue
+        out.append(mid)
+
+    _HUB_CACHE[key] = (now, out)
+    return out
+
+def refresh_cache() -> None:
+    _HUB_CACHE.clear()
+
+def refresh_button(ui_lang: str) -> str:
     try:
-        models = api.list_models(filter=pipeline_tag, sort="downloads", direction=-1, limit=limit)
-        out = []
-        for m in models:
-            mid = getattr(m, "modelId", None)
-            tags = getattr(m, "tags", []) or []
-            if mid and _language_tag_predicate(tags, data_lang_value):
-                out.append(mid)
-        _HUB_CACHE[key] = (now, out)
-        return out
+        refresh_cache()
+        ts = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+        return t(ui_lang, "refreshed").format(ts=ts)
     except Exception:
-        return []
-
-# -----------------------
-# Ranking rules (this is what makes settings matter)
-# -----------------------
-def score_candidate(c: Candidate, data_lang_value: str, cpu_only: bool, priority: str) -> Tuple[int, List[str]]:
+        return t(ui_lang, "refresh_failed")
+
+# =======================
+# Ranking (settings must matter)
+# =======================
+def _infer_size_from_id(model_id: str) -> str:
+    mid = model_id.lower()
+    if any(x in mid for x in ["-large", "large-", "xxl", "xl"]):
+        return "large"
+    if any(x in mid for x in ["-base", "base-", "mpnet", "xlm-roberta-base", "bert-base"]):
+        return "base"
+    if any(x in mid for x in ["small", "mini", "minilm", "distil", "tiny"]):
+        return "small"
+    return "base"
+
+def _infer_lang_from_tags_or_id(model_id: str) -> str:
+    mid = model_id.lower()
+    if "multilingual" in mid or "xlm" in mid or "mt5" in mid:
+        return "MULTI"
+    return "EN"
+
+def score_candidate(c: Candidate, data_lang_value: str, priority: str, budget: str) -> Tuple[int, List[str]]:
     score = 0
     reasons: List[str] = []
 
-    # CPU constraint
-    if cpu_only:
-        if c.cpu_ok:
-            score += 2
-            reasons.append("CPU-friendly" if True else "")
-        else:
-            score -= 100  # effectively exclude
-            reasons.append("Not CPU-friendly")
-
     # Language preference
-    if data_lang_value in ("PL", "MIXED"):
+    if data_lang_value in (DATA_PL, DATA_MIXED):
         if c.languages == "MULTI":
             score += 4
-            reasons.append("Multilingual (better for PL/mixed)")
+            reasons.append("Multilingual")
         else:
             score -= 1
             reasons.append("EN-focused")
-    else:  # EN
+    else:
         if c.languages == "EN":
             score += 3
             reasons.append("EN-optimized")
@@ -231,17 +340,39 @@ def score_candidate(c: Candidate, data_lang_value: str, cpu_only: bool, priority
             score += 1
             reasons.append("Multilingual")
 
+    # Compute budget constraint
+    if budget == BUDGET_LOW:
+        if c.size == "small":
+            score += 5
+            reasons.append("Low budget friendly")
+        elif c.size == "base":
+            score += 1
+            reasons.append("May be slower on low budget")
+        else:
+            score -= 6
+            reasons.append("Too heavy for low budget")
+    else:  # MED
+        if c.size == "small":
+            score += 2
+            reasons.append("Fast")
+        elif c.size == "base":
+            score += 4
+            reasons.append("Allowed by medium budget")
+        else:
+            score += 1
+            reasons.append("Heavier option")
+
     # Priority: speed vs quality
-    if priority == "SPEED":
+    if priority == PRIO_SPEED:
         if c.size == "small":
             score += 4
-            reasons.append("Smaller/faster")
+            reasons.append("Faster")
         elif c.size == "base":
             score += 1
-            reasons.append("Medium size")
+            reasons.append("Medium")
         else:
-            score -= 1
-            reasons.append("Heavier/slower")
+            score -= 2
+            reasons.append("Slower")
     else:  # QUALITY
         if c.size == "base":
             score += 4
@@ -253,13 +384,78 @@ def score_candidate(c: Candidate, data_lang_value: str, cpu_only: bool, priority
             score += 3
             reasons.append("High capacity")
 
+    # Prefer curated slightly for stability (unless source is live-only)
+    if c.origin == "curated":
+        score += 1
+        reasons.append("Curated/stable")
+
     return score, reasons
 
-def pick_models(model_type: str, data_lang_value: str, cpu_only: bool, priority: str, k: int = 4) -> Tuple[List[Candidate], Dict[str, List[str]]]:
-    candidates = CANDIDATES[model_type]
+def select_models(
+    model_type: str,
+    data_lang_value: str,
+    priority: str,
+    budget: str,
+    source_mode: str,
+    ui_lang: str,
+    k: int = 4,
+) -> Tuple[List[Candidate], Dict[str, List[str]], bool]:
+    """
+    Returns chosen candidates, reasons map, and whether live candidates were used.
+    """
+    pool: List[Candidate] = []
+    used_live = False
+
+    if source_mode in (SRC_CURATED, SRC_HYBRID):
+        pool.extend(CURATED[model_type])
+
+    if source_mode in (SRC_LIVE, SRC_HYBRID):
+        # Map our types to pipeline tags and library hints
+        if model_type == "embeddings":
+            pipeline_tag = "sentence-similarity"
+            library_hint = "sentence-transformers"
+        elif model_type == "qa":
+            pipeline_tag = "question-answering"
+            library_hint = "transformers"
+        else:
+            pipeline_tag = "text-generation"
+            library_hint = "transformers"
+
+        live_ids = fetch_live_model_ids(
+            pipeline_tag=pipeline_tag,
+            data_lang_value=data_lang_value,
+            library_hint=library_hint,
+            budget=budget,
+            limit=35,
+        )
+
+        # Convert to Candidates (notes are generic because we don't parse model card here)
+        for mid in live_ids:
+            c = Candidate(
+                model_id=mid,
+                size=_infer_size_from_id(mid),
+                languages=_infer_lang_from_tags_or_id(mid),
+                note_en="Live candidate from Hub (ranked by downloads).",
+                note_pl="Kandydat live z Hub (ranking po pobraniach).",
+                origin="live",
+            )
+            pool.append(c)
+        used_live = True
+
+    # Deduplicate pool by model_id, keeping curated version if present
+    dedup: Dict[str, Candidate] = {}
+    for c in pool:
+        if c.model_id not in dedup:
+            dedup[c.model_id] = c
+        else:
+            # prefer curated notes
+            if dedup[c.model_id].origin == "live" and c.origin == "curated":
+                dedup[c.model_id] = c
+    pool = list(dedup.values())
+
     scored: List[Tuple[int, Candidate, List[str]]] = []
-    for c in candidates:
-        s, reasons = score_candidate(c, data_lang_value, cpu_only, priority)
+    for c in pool:
+        s, reasons = score_candidate(c, data_lang_value, priority, budget)
         scored.append((s, c, reasons))
 
     scored.sort(key=lambda x: x[0], reverse=True)
@@ -267,30 +463,36 @@ def pick_models(model_type: str, data_lang_value: str, cpu_only: bool, priority:
     chosen: List[Candidate] = []
     why: Dict[str, List[str]] = {}
     for s, c, reasons in scored:
-        if s < -50:
+        if c.model_id in why:
             continue
-        if c.model_id not in {x.model_id for x in chosen}:
-            chosen.append(c)
-            why[c.model_id] = reasons
+        chosen.append(c)
+        why[c.model_id] = reasons
         if len(chosen) >= k:
             break
 
     # ensure min 3
     if len(chosen) < 3:
-        # fallback: take top regardless of language
         for s, c, reasons in scored:
-            if c.model_id not in {x.model_id for x in chosen} and s > -50:
+            if c.model_id not in why:
                 chosen.append(c)
                 why[c.model_id] = reasons
             if len(chosen) >= 3:
                 break
 
-    return chosen, why
-
-# -----------------------
-# Main recommend function (now settings drive different outputs)
-# -----------------------
-def recommend(ui_lang: str, task_id: str, has_docs: str, data_lang_value: str, cpu_only: bool, priority: str) -> str:
+    return chosen, why, used_live
+
+# =======================
+# Main recommend function
+# =======================
+def recommend(
+    ui_lang: str,
+    task_id: str,
+    has_docs: str,
+    data_lang_value: str,
+    priority: str,
+    budget: str,
+    source_mode: str,
+) -> str:
     warning: Optional[str] = None
 
     if task_id == TASK_SIM:
@@ -300,7 +502,6 @@ def recommend(ui_lang: str, task_id: str, has_docs: str, data_lang_value: str, c
             if ui_lang == "EN"
             else "Chcesz podobieństwo semantyczne / deduplikację / wyszukiwanie. Najlepsze są embeddingi + cosine similarity."
         )
-        pipeline_tag = "sentence-similarity"
         note_key = "note_emb"
     elif task_id == TASK_QA:
         model_type = "qa"
@@ -309,7 +510,6 @@ def recommend(ui_lang: str, task_id: str, has_docs: str, data_lang_value: str, c
             if ui_lang == "EN"
             else "Masz kontekst (dokument/tekst) i pytanie. QA extractive znajduje odpowiedzi w kontekście."
         )
-        pipeline_tag = "question-answering"
         note_key = "note_qa"
         if has_docs == "NO":
             warning = t(ui_lang, "qa_need_docs")
@@ -320,19 +520,18 @@ def recommend(ui_lang: str, task_id: str, has_docs: str, data_lang_value: str, c
             if ui_lang == "EN"
             else "Chcesz odpowiedzi sterowane poleceniem (chat/wyjaśnianie/streszczanie). Najlepsze są modele instrukcyjne."
         )
-        pipeline_tag = "text-generation"
         note_key = "note_instr"
 
-    # Pick models based on settings
-    chosen, why_map = pick_models(model_type, data_lang_value, cpu_only, priority, k=4)
-
-    # Add 1–2 hub bonus models, but only if they diversify beyond chosen
-    bonus = hub_bonus_models(pipeline_tag, data_lang_value, limit=25)
-    chosen_ids = {c.model_id for c in chosen}
-    bonus = [m for m in bonus if m not in chosen_ids]
-    bonus = bonus[:2]
+    chosen, why_map, used_live = select_models(
+        model_type=model_type,
+        data_lang_value=data_lang_value,
+        priority=priority,
+        budget=budget,
+        source_mode=source_mode,
+        ui_lang=ui_lang,
+        k=5,
+    )
 
-    # Build output
     lines: List[str] = []
     lines.append(t(ui_lang, "rec_type").format(model_type=model_type))
     lines.append("")
@@ -342,7 +541,8 @@ def recommend(ui_lang: str, task_id: str, has_docs: str, data_lang_value: str, c
     lines.append(t(ui_lang, "settings"))
     lines.append(f"- data language: {data_lang_value}")
     lines.append(f"- priority: {priority}")
-    lines.append(f"- cpu only: {cpu_only}")
+    lines.append(f"- budget: {budget}")
+    lines.append(f"- source: {source_mode}")
     lines.append(f"- has documents: {has_docs}")
     lines.append("")
 
@@ -351,40 +551,41 @@ def recommend(ui_lang: str, task_id: str, has_docs: str, data_lang_value: str, c
         lines.append(f"- {warning}")
         lines.append("")
 
+    if used_live and source_mode in (SRC_LIVE, SRC_HYBRID):
+        lines.append(t(ui_lang, "live_note"))
+        lines.append("")
+
     lines.append(t(ui_lang, "models_min3"))
-    for c in chosen:
+    for c in chosen[:5]:
         note = c.note_en if ui_lang == "EN" else c.note_pl
         lines.append(f"- {c.model_id} — {note}")
 
-    for mid in bonus:
-        lines.append(f"- {mid} — {t(ui_lang, 'bonus_note')}")
-
     lines.append("")
     lines.append(t(ui_lang, "why_these"))
-    for c in chosen:
+    for c in chosen[:5]:
         reasons = why_map.get(c.model_id, [])
-        # Localize reason snippets lightly
         if ui_lang == "PL":
             localized = []
             for r in reasons:
-                if r == "CPU-friendly":
-                    localized.append("Działa na CPU")
-                elif r == "Multilingual (better for PL/mixed)":
-                    localized.append("Wielojęzyczny (lepszy dla PL/mix)")
-                elif r == "EN-optimized":
-                    localized.append("Optymalny dla EN")
-                elif r == "Smaller/faster":
-                    localized.append("Mniejszy/szybszy")
-                elif r == "Better quality baseline":
-                    localized.append("Lepsza jakość (baseline)")
-                elif r == "Fast but may be lower quality":
-                    localized.append("Szybki, ale może gorsza jakość")
-                elif r == "Medium size":
-                    localized.append("Średni rozmiar")
-                elif r == "Heavier/slower":
-                    localized.append("Cięższy/wolniejszy")
-                else:
-                    localized.append(r)
+                mapping = {
+                    "Multilingual": "Wielojęzyczny",
+                    "EN-focused": "Skupiony na EN",
+                    "EN-optimized": "Optymalny dla EN",
+                    "Low budget friendly": "Dobry dla niskiego budżetu",
+                    "May be slower on low budget": "Może być wolniejszy przy niskim budżecie",
+                    "Too heavy for low budget": "Za ciężki dla niskiego budżetu",
+                    "Allowed by medium budget": "Dozwolony przy średnim budżecie",
+                    "Heavier option": "Cięższa opcja",
+                    "Fast": "Szybki",
+                    "Faster": "Szybszy",
+                    "Medium": "Średni",
+                    "Slower": "Wolniejszy",
+                    "Better quality baseline": "Lepsza jakość (baseline)",
+                    "Fast but may be lower quality": "Szybki, ale może gorsza jakość",
+                    "High capacity": "Duża pojemność",
+                    "Curated/stable": "Kuratorski/stabilny",
+                }
+                localized.append(mapping.get(r, r))
             reasons_txt = ", ".join(localized)
         else:
             reasons_txt = ", ".join(reasons)
@@ -394,26 +595,29 @@ def recommend(ui_lang: str, task_id: str, has_docs: str, data_lang_value: str, c
     lines.append(t(ui_lang, note_key))
     return "\n".join(lines)
 
-# -----------------------
-# Dynamic UI language updates
-# -----------------------
+# =======================
+# UI language dynamic updates
+# =======================
 def apply_language(ui_lang: str) -> Tuple[Any, ...]:
     return (
-        gr.update(value=f"# {t(ui_lang, 'title')}\n{t(ui_lang, 'intro')}"),  # header
-        gr.update(label=t(ui_lang, "ui_lang")),                             # ui lang label
-        gr.update(label=t(ui_lang, "task"), choices=task_choices(ui_lang)), # task choices localized
+        gr.update(value=f"# {t(ui_lang, 'title')}\n{t(ui_lang, 'intro')}"),
+        gr.update(label=t(ui_lang, "ui_lang")),
+        gr.update(label=t(ui_lang, "task"), choices=task_choices(ui_lang)),
         gr.update(label=t(ui_lang, "has_docs"), choices=yesno_choices(ui_lang)),
         gr.update(label=t(ui_lang, "data_lang"), choices=data_lang_choices(ui_lang)),
-        gr.update(label=t(ui_lang, "cpu_only")),
         gr.update(label=t(ui_lang, "priority"), choices=priority_choices(ui_lang)),
+        gr.update(label=t(ui_lang, "budget"), choices=budget_choices(ui_lang)),
+        gr.update(label=t(ui_lang, "source"), choices=source_choices(ui_lang)),
+        gr.update(value=t(ui_lang, "refresh")),
         gr.update(value=t(ui_lang, "recommend_btn")),
         gr.update(label=t(ui_lang, "result")),
+        gr.update(label=t(ui_lang, "status")),
         gr.update(label=t(ui_lang, "tab_main")),
     )
 
-# -----------------------
-# UI
-# -----------------------
+# =======================
+# Build UI
+# =======================
 with gr.Blocks(title=I18N["EN"]["title"]) as demo:
     header_md = gr.Markdown(f"# {t('EN', 'title')}\n{t('EN', 'intro')}")
 
@@ -422,23 +626,33 @@ with gr.Blocks(title=I18N["EN"]["title"]) as demo:
     with gr.Tab(t("EN", "tab_main")) as tab_main:
         task = gr.Dropdown(choices=task_choices("EN"), value=TASK_SIM, label=t("EN", "task"))
         has_docs = gr.Radio(choices=yesno_choices("EN"), value="YES", label=t("EN", "has_docs"))
-        data_lang = gr.Radio(choices=data_lang_choices("EN"), value="MIXED", label=t("EN", "data_lang"))
-        cpu_only = gr.Checkbox(value=True, label=t("EN", "cpu_only"))
-        priority = gr.Radio(choices=priority_choices("EN"), value="SPEED", label=t("EN", "priority"))
+        data_lang = gr.Radio(choices=data_lang_choices("EN"), value=DATA_MIXED, label=t("EN", "data_lang"))
+        priority = gr.Radio(choices=priority_choices("EN"), value=PRIO_SPEED, label=t("EN", "priority"))
+        budget = gr.Radio(choices=budget_choices("EN"), value=BUDGET_LOW, label=t("EN", "budget"))
+        source_mode = gr.Radio(choices=source_choices("EN"), value=SRC_HYBRID, label=t("EN", "source"))
+
+        with gr.Row():
+            refresh_btn = gr.Button(t("EN", "refresh"))
+            status = gr.Textbox(lines=1, label=t("EN", "status"))
 
         recommend_btn = gr.Button(t("EN", "recommend_btn"))
-        out = gr.Textbox(lines=22, label=t("EN", "result"))
+        out = gr.Textbox(lines=24, label=t("EN", "result"))
+
+        refresh_btn.click(fn=refresh_button, inputs=[ui_lang], outputs=[status])
 
         recommend_btn.click(
             fn=recommend,
-            inputs=[ui_lang, task, has_docs, data_lang, cpu_only, priority],
+            inputs=[ui_lang, task, has_docs, data_lang, priority, budget, source_mode],
             outputs=[out],
         )
 
     ui_lang.change(
         fn=apply_language,
         inputs=[ui_lang],
-        outputs=[header_md, ui_lang, task, has_docs, data_lang, cpu_only, priority, recommend_btn, out, tab_main],
+        outputs=[
+            header_md, ui_lang, task, has_docs, data_lang, priority, budget, source_mode,
+            refresh_btn, recommend_btn, out, status, tab_main
+        ],
     )
 
 demo.launch()