Update app.py

app.py

@@ -1,251 +1,218 @@
 import os
 import re
-import time
-import math
-import threading
+import hashlib
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
+from collections import OrderedDict
+from typing import List, Tuple, Optional, Dict, Any
 
 import numpy as np
 import torch
 import gradio as gr
 
-from huggingface_hub import HfApi
 from transformers import (
     AutoTokenizer,
     AutoModel,
-    AutoModelForQuestionAnswering,
-    AutoModelForSeq2SeqLM,
+    pipeline,
 )
 from transformers.utils import logging as hf_logging
 
 
-# ============================================================
-# CPU-only + timeouts + quiet logs
-# ============================================================
+# =========================
+# CPU-only + quieter logs
+# =========================
 os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
 os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
 os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1")
-os.environ.setdefault("HF_HUB_ETAG_TIMEOUT", "5")
-os.environ.setdefault("HF_HUB_DOWNLOAD_TIMEOUT", "30")
-
 hf_logging.set_verbosity_error()
 
-DEVICE = torch.device("cpu")
 torch.set_grad_enabled(False)
 torch.set_num_threads(int(os.getenv("TORCH_NUM_THREADS", "4")))
 
-# ============================================================
-# Hard limits (RAM + speed)
-# ============================================================
-MAX_INPUT_CHARS = 80_000
-MAX_CHUNKS = 120
-CHUNK_TARGET_CHARS = 900
-EMBED_BATCH = 16
-
-GEN_MAX_NEW_TOKENS = 240
-GEN_MIN_NEW_TOKENS = 80
-
-QA_MAX_LENGTH = 384
-QA_STRIDE = 128
-MAX_CONTEXT_CHARS = 4_000
-MAX_ANSWER_LEN_TOKENS = 40
-
-# ============================================================
-# 3+ Transformers:
-#   1) Generator (RU-friendly): mT5-small
-#   2) Embeddings: multilingual-e5-small
-#   3) Extractive QA: mBERT xquad
-# ============================================================
-GEN_CANDIDATES = [
-    "google/mt5-small",
-    "google/flan-t5-small",
+# =========================
+# Models (3 transformers)
+# =========================
+SUM_MODEL_CANDIDATES = [
+    "d0rj/rut5-base-summ",           # RU summarization
+    "cointegrated/rut5-base-absum",  # RU summarization fallback
 ]
 
-EMB_CANDIDATES = [
-    "intfloat/multilingual-e5-small",
-    "intfloat/e5-small-v2",
+QA_MODEL_CANDIDATES = [
+    "mrm8488/bert-multi-cased-finetuned-xquadv1",  # multilingual QA
+    "mrm8488/bert-multi-cased-finedtuned-xquad-tydiqa-goldp",
 ]
 
-QA_CANDIDATES = [
-    "mrm8488/bert-multi-cased-finetuned-xquadv1",
-    "timopixel/bert-base-multilingual-cased-finetuned-squad",
+EMB_MODEL_CANDIDATES = [
+    "intfloat/multilingual-e5-small",  # retrieval embeddings
+    "intfloat/e5-small-v2",
 ]
 
-
-def hf_exists(model_id: str) -> bool:
-    """
-    Fast availability check. If no network, we assume it exists and will try to load.
-    """
-    try:
-        api = HfApi()
-        api.model_info(model_id)
-        return True
-    except Exception:
-        return True
-
-
-def pick_model(candidates: List[str]) -> str:
-    for mid in candidates:
-        if hf_exists(mid):
-            return mid
-    return candidates[0]
-
-
-GEN_ID = pick_model(GEN_CANDIDATES)
-EMB_ID = pick_model(EMB_CANDIDATES)
-QA_ID = pick_model(QA_CANDIDATES)
-
-
-# ============================================================
-# Lazy loaders (avoid loading everything on start)
-# ============================================================
-_load_lock = threading.Lock()
-
-_GEN_TOK = None
-_GEN_MODEL = None
-
-_EMB_TOK = None
-_EMB_MODEL = None
-
-_QA_TOK = None
-_QA_MODEL = None
-
-
-def load_gen():
-    global _GEN_TOK, _GEN_MODEL
-    with _load_lock:
-        if _GEN_TOK is not None and _GEN_MODEL is not None:
-            return _GEN_TOK, _GEN_MODEL
-        tok = AutoTokenizer.from_pretrained(GEN_ID, use_fast=True)
-        model = AutoModelForSeq2SeqLM.from_pretrained(
-            GEN_ID,
-            torch_dtype=torch.float32,
-            low_cpu_mem_usage=True,
-        ).eval()
-        _GEN_TOK, _GEN_MODEL = tok, model
-        return tok, model
-
-
-def load_emb():
-    global _EMB_TOK, _EMB_MODEL
-    with _load_lock:
-        if _EMB_TOK is not None and _EMB_MODEL is not None:
-            return _EMB_TOK, _EMB_MODEL
-        tok = AutoTokenizer.from_pretrained(EMB_ID, use_fast=True)
-        model = AutoModel.from_pretrained(
-            EMB_ID,
-            torch_dtype=torch.float32,
-            low_cpu_mem_usage=True,
-        ).eval()
-        _EMB_TOK, _EMB_MODEL = tok, model
-        return tok, model
-
-
-def load_qa():
-    global _QA_TOK, _QA_MODEL
-    with _load_lock:
-        if _QA_TOK is not None and _QA_MODEL is not None:
-            return _QA_TOK, _QA_MODEL
-        tok = AutoTokenizer.from_pretrained(QA_ID, use_fast=True)
-        model = AutoModelForQuestionAnswering.from_pretrained(
-            QA_ID,
-            torch_dtype=torch.float32,
-            low_cpu_mem_usage=True,
-        ).eval()
-        _QA_TOK, _QA_MODEL = tok, model
-        return tok, model
-
-
-# ============================================================
-# Utilities
-# ============================================================
-def safe_trunc(s: str, max_chars: int) -> str:
+DEVICE = -1  # CPU for pipelines
+
+# =========================
+# Limits (memory & speed)
+# =========================
+MAX_TEXT_CHARS = 120_000
+CHUNK_CHARS = 1400
+MAX_CHUNKS = 140
+EMB_BATCH = 16
+
+TOPK_DEFAULT = 5
+CTX_MAX_CHARS = 4500
+
+# =========================
+# Helpers
+# =========================
+RU_STOP = {
+    "и","в","во","на","но","а","что","это","как","к","ко","из","за","по","у","от","до","при","для","над",
+    "под","же","ли","бы","не","ни","то","его","ее","их","мы","вы","они","она","он","оно","этот","эта","эти",
+    "там","тут","здесь","так","такие","такой","есть","быть","был","была","были","будет","будут"
+}
+
+def safe_text(s: str, max_chars: int = MAX_TEXT_CHARS) -> str:
     s = (s or "").strip()
     if len(s) > max_chars:
-        return s[:max_chars].rstrip() + "\n\n[Обрезано по лимиту длины]"
+        s = s[:max_chars].rstrip() + "\n\n[Обрезано по лимиту длины]"
     return s
 
-
-def norm_space(s: str) -> str:
+def normalize_space(s: str) -> str:
     return re.sub(r"\s+", " ", (s or "")).strip()
 
-
-def split_chunks(text: str) -> List[str]:
-    text = safe_trunc(text, MAX_INPUT_CHARS)
+def split_into_chunks(text: str) -> List[str]:
+    text = safe_text(text)
     paras = [p.strip() for p in re.split(r"\n\s*\n+", text) if p.strip()]
-
-    chunks: List[str] = []
+    chunks = []
     buf = ""
+
     for p in paras:
         if not buf:
             buf = p
-            continue
-        if len(buf) + 2 + len(p) <= CHUNK_TARGET_CHARS:
+        elif len(buf) + 2 + len(p) <= CHUNK_CHARS:
             buf = buf + "\n\n" + p
         else:
             chunks.append(buf.strip())
             buf = p
         if len(chunks) >= MAX_CHUNKS:
             break
+
     if buf and len(chunks) < MAX_CHUNKS:
         chunks.append(buf.strip())
 
-    # if single paragraph is too big, split by sentences
-    sent_split = re.compile(r"(?<=[\.\!\?…])\s+")
-    fixed: List[str] = []
+    # If still too big, split long chunks by sentences
+    sent_re = re.compile(r"(?<=[\.\!\?…])\s+")
+    final_chunks = []
     for c in chunks:
-        if len(c) <= CHUNK_TARGET_CHARS * 1.6:
-            fixed.append(c)
+        if len(c) <= int(CHUNK_CHARS * 1.6):
+            final_chunks.append(c)
             continue
-        sents = [s.strip() for s in sent_split.split(c) if s.strip()]
+        sents = [x.strip() for x in sent_re.split(c) if x.strip()]
         b = ""
         for s in sents:
             if not b:
                 b = s
-                continue
-            if len(b) + 1 + len(s) <= CHUNK_TARGET_CHARS:
+            elif len(b) + 1 + len(s) <= CHUNK_CHARS:
                 b = b + " " + s
             else:
-                fixed.append(b.strip())
+                final_chunks.append(b.strip())
                 b = s
-            if len(fixed) >= MAX_CHUNKS:
+            if len(final_chunks) >= MAX_CHUNKS:
                 break
-        if b and len(fixed) < MAX_CHUNKS:
-            fixed.append(b.strip())
-        if len(fixed) >= MAX_CHUNKS:
+        if b and len(final_chunks) < MAX_CHUNKS:
+            final_chunks.append(b.strip())
+        if len(final_chunks) >= MAX_CHUNKS:
             break
 
-    return fixed[:MAX_CHUNKS]
+    return final_chunks[:MAX_CHUNKS]
+
+def sha_key(text: str) -> str:
+    h = hashlib.sha1(text.encode("utf-8")).hexdigest()
+    return h[:12]
+
+
+# =========================
+# Global model holders
+# =========================
+_SUM_PIPE = None
+_SUM_ID = None
 
+_QA_PIPE = None
+_QA_ID = None
 
+_EMB_TOK = None
+_EMB_MODEL = None
+_EMB_ID = None
+
+
+def _try_load_summarizer() -> Tuple[Any, str]:
+    last_err = None
+    for mid in SUM_MODEL_CANDIDATES:
+        try:
+            pipe = pipeline("summarization", model=mid, device=DEVICE)
+            return pipe, mid
+        except Exception as e:
+            last_err = e
+    raise RuntimeError(f"Cannot load summarization model. Last error: {last_err}")
+
+def _try_load_qa() -> Tuple[Any, str]:
+    last_err = None
+    for mid in QA_MODEL_CANDIDATES:
+        try:
+            pipe = pipeline("question-answering", model=mid, device=DEVICE)
+            return pipe, mid
+        except Exception as e:
+            last_err = e
+    raise RuntimeError(f"Cannot load QA model. Last error: {last_err}")
+
+def _try_load_emb() -> Tuple[Any, Any, str]:
+    last_err = None
+    for mid in EMB_MODEL_CANDIDATES:
+        try:
+            tok = AutoTokenizer.from_pretrained(mid, use_fast=True)
+            model = AutoModel.from_pretrained(mid, torch_dtype=torch.float32, low_cpu_mem_usage=True).eval()
+            return tok, model, mid
+        except Exception as e:
+            last_err = e
+    raise RuntimeError(f"Cannot load embedding model. Last error: {last_err}")
+
+def get_models():
+    global _SUM_PIPE, _SUM_ID, _QA_PIPE, _QA_ID, _EMB_TOK, _EMB_MODEL, _EMB_ID
+
+    if _SUM_PIPE is None:
+        _SUM_PIPE, _SUM_ID = _try_load_summarizer()
+    if _QA_PIPE is None:
+        _QA_PIPE, _QA_ID = _try_load_qa()
+    if _EMB_MODEL is None:
+        _EMB_TOK, _EMB_MODEL, _EMB_ID = _try_load_emb()
+
+    return _SUM_PIPE, _SUM_ID, _QA_PIPE, _QA_ID, _EMB_TOK, _EMB_MODEL, _EMB_ID
+
+
+# =========================
+# Embeddings + retrieval
+# =========================
 @torch.inference_mode()
-def mean_pool(last_hidden: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+def _mean_pool(last_hidden: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
     m = mask.unsqueeze(-1).bool()
     x = last_hidden.masked_fill(~m, 0.0)
     summed = x.sum(dim=1)
     denom = mask.sum(dim=1).clamp(min=1).unsqueeze(-1)
     return summed / denom
 
-
 @torch.inference_mode()
 def embed_texts(texts: List[str], is_query: bool) -> np.ndarray:
-    tok, model = load_emb()
-
-    # E5 prefix convention improves retrieval
+    _, _, _, _, tok, model, _ = get_models()
     prefix = "query: " if is_query else "passage: "
-    batch_texts = [prefix + norm_space(t) for t in texts]
+    batch_texts = [prefix + normalize_space(t) for t in texts]
 
     vecs = []
-    for i in range(0, len(batch_texts), EMBED_BATCH):
-        batch = batch_texts[i:i + EMBED_BATCH]
+    for i in range(0, len(batch_texts), EMB_BATCH):
+        batch = batch_texts[i:i + EMB_BATCH]
         enc = tok(batch, padding=True, truncation=True, max_length=512, return_tensors="pt")
         out = model(**enc)
-        pooled = mean_pool(out.last_hidden_state, enc["attention_mask"])
+        pooled = _mean_pool(out.last_hidden_state, enc["attention_mask"])
         pooled = torch.nn.functional.normalize(pooled, p=2, dim=1)
         vecs.append(pooled.cpu().numpy().astype(np.float32))
-    return np.vstack(vecs)
 
+    return np.vstack(vecs) if vecs else np.zeros((0, 384), dtype=np.float32)
 
 def topk_cosine(q: np.ndarray, mat: np.ndarray, k: int) -> List[Tuple[int, float]]:
     scores = (mat @ q.reshape(-1, 1)).squeeze(1)
@@ -258,394 +225,335 @@ def topk_cosine(q: np.ndarray, mat: np.ndarray, k: int) -> List[Tuple[int, float
 
 
 @dataclass
-class IndexState:
+class Index:
+    key: str
     text: str
     chunks: List[str]
-    emb: Optional[np.ndarray]
+    emb: np.ndarray
 
 
-def build_index(text: str) -> IndexState:
-    text = safe_trunc(text, MAX_INPUT_CHARS)
-    chunks = split_chunks(text)
-    if not chunks:
-        return IndexState(text=text, chunks=[], emb=None)
-    emb = embed_texts(chunks, is_query=False)
-    return IndexState(text=text, chunks=chunks, emb=emb)
+# Small LRU cache (keeps RAM bounded)
+_INDEX_CACHE: "OrderedDict[str, Index]" = OrderedDict()
+CACHE_MAX = 4
 
+def get_index(text: str) -> Index:
+    text = safe_text(text)
+    k = sha_key(text)
+    if k in _INDEX_CACHE:
+        _INDEX_CACHE.move_to_end(k)
+        return _INDEX_CACHE[k]
 
-def ensure_index(state: Optional[Dict[str, Any]], text: str) -> IndexState:
-    text = safe_trunc(text, MAX_INPUT_CHARS)
-    if not state or state.get("text") != text:
-        st = build_index(text)
-        return st
-    return IndexState(text=state["text"], chunks=state["chunks"], emb=state["emb"])
+    chunks = split_into_chunks(text)
+    emb = embed_texts(chunks, is_query=False) if chunks else np.zeros((0, 384), dtype=np.float32)
+    idx = Index(key=k, text=text, chunks=chunks, emb=emb)
 
+    _INDEX_CACHE[k] = idx
+    _INDEX_CACHE.move_to_end(k)
+    while len(_INDEX_CACHE) > CACHE_MAX:
+        _INDEX_CACHE.popitem(last=False)
 
-def retrieve(st: IndexState, query: str, k: int = 5) -> List[Tuple[float, str]]:
+    return idx
+
+def retrieve(idx: Index, query: str, k: int) -> List[Tuple[float, str]]:
     query = (query or "").strip()
-    if not query or not st.chunks or st.emb is None:
+    if not query or idx.emb.shape[0] == 0:
         return []
     qv = embed_texts([query], is_query=True)[0]
-    hits = topk_cosine(qv, st.emb, k=k)
-    return [(score, st.chunks[idx]) for idx, score in hits]
-
-
-# ============================================================
-# Generator (mT5 / flan)
-# ============================================================
-@torch.inference_mode()
-def generate_text(prompt: str,
-                  max_new_tokens: int = GEN_MAX_NEW_TOKENS,
-                  min_new_tokens: int = 0,
-                  do_sample: bool = False) -> str:
-    tok, model = load_gen()
-    enc = tok(prompt, return_tensors="pt", truncation=True, max_length=512)
-
-    out = model.generate(
-        **enc,
-        max_new_tokens=max_new_tokens,
-        min_new_tokens=min_new_tokens,
-        num_beams=4 if not do_sample else 1,
-        do_sample=do_sample,
-        temperature=0.9 if do_sample else None,
-        top_p=0.95 if do_sample else None,
-        repetition_penalty=1.05,
-        no_repeat_ngram_size=3,
-        early_stopping=True,
-    )
-    s = tok.decode(out[0], skip_special_tokens=True).strip()
-    return s
+    hits = topk_cosine(qv, idx.emb, k=k)
+    return [(score, idx.chunks[i]) for i, score in hits]
 
 
-def robust_summary(selected_text: str) -> Tuple[str, str]:
-    """
-    Returns (title, summary). Retries if model outputs too short.
-    """
-    selected_text = safe_trunc(selected_text, 4500)
-
-    title_prompt = (
-        "Сформулируй короткий заголовок (до 12 слов) для текста.\n\n"
-        f"Текст:\n{selected_text}\n\n"
-        "Заголовок:"
-    )
-    title = generate_text(title_prompt, max_new_tokens=32, min_new_tokens=8, do_sample=False)
-    title = title.strip().strip('"').strip()
-
-    sum_prompt = (
-        "Сделай связный пересказ текста на русском языке. "
-        "Требования: 6–10 предложений, без воды, сохранить ключевые причины, эффекты и вывод.\n\n"
-        f"Текст:\n{selected_text}\n\n"
-        "Пересказ:"
-    )
-    summary = generate_text(sum_prompt, max_new_tokens=GEN_MAX_NEW_TOKENS, min_new_tokens=GEN_MIN_NEW_TOKENS, do_sample=False)
-
-    # If too short -> retry with bullet format
-    if len(summary) < 120 and len(selected_text) > 600:
-        sum_prompt2 = (
-            "Сделай конспект текста на русском: 6–10 пунктов, каждый пункт 1 строка. "
-            "Пункты должны покрывать весь текст.\n\n"
-            f"Текст:\n{selected_text}\n\n"
-            "Конспект:"
-        )
-        summary2 = generate_text(sum_prompt2, max_new_tokens=GEN_MAX_NEW_TOKENS, min_new_tokens=80, do_sample=True)
-        if len(summary2) > len(summary):
-            summary = summary2
+# =========================
+# Summarization (hierarchical, stable)
+# =========================
+def summarize_one(text: str, out_max: int, out_min: int) -> str:
+    sum_pipe, _, _, _, _, _, _ = get_models()
+    text = normalize_space(text)
+    if not text:
+        return ""
+    # pipeline expects token lengths; we keep conservative values
+    res = sum_pipe(text, max_length=out_max, min_length=out_min, do_sample=False)
+    if isinstance(res, list) and res:
+        return (res[0].get("summary_text") or "").strip()
+    return ""
+
+def smart_summary(text: str) -> str:
+    text = safe_text(text)
+    if not text:
+        return "Нет текста."
+
+    chunks = split_into_chunks(text)
+    if not chunks:
+        return "Нет текста."
+
+    # For short text: direct
+    if len(text) < 2500 and len(chunks) <= 2:
+        s = summarize_one(text, out_max=220, out_min=80)
+        return s if s else summarize_one(text, out_max=160, out_min=50)
+
+    # For long text: summarize chunks then summarize the combined summaries
+    parts = chunks[:8]
+    partial = []
+    for p in parts:
+        sp = summarize_one(p, out_max=140, out_min=40)
+        if sp:
+            partial.append(sp)
+
+    combined = " ".join(partial).strip()
+    if not combined:
+        combined = " ".join(parts)[:4000]
+
+    final = summarize_one(combined, out_max=240, out_min=90)
+    if not final:
+        final = summarize_one(combined, out_max=180, out_min=60)
+
+    return final if final else "Не удалось получить пересказ."
+
+def make_title(text: str, summary: str) -> str:
+    # heuristic title: first 8–12 words of summary, else first sentence of text
+    src = summary.strip() if summary.strip() else normalize_space(text[:500])
+    words = [w for w in re.split(r"\s+", src) if w]
+    title = " ".join(words[:12]).strip(" .,:;—-")
+    return title if title else "Краткий пересказ"
+
+
+# =========================
+# QA Chat (retrieval + pipeline QA)
+# =========================
+def qa_answer(question: str, context: str) -> Tuple[str, str, float]:
+    _, _, qa_pipe, _, _, _, _ = get_models()
+    question = (question or "").strip()
+    context = (context or "").strip()
+    if not question or not context:
+        return "", "", 0.0
+
+    context = context[:CTX_MAX_CHARS]
+    out = qa_pipe(question=question, context=context)
+    ans = (out.get("answer") or "").strip()
+    score = float(out.get("score") or 0.0)
+    start = int(out.get("start") or 0)
+    end = int(out.get("end") or 0)
+
+    # evidence snippet
+    left = max(0, start - 140)
+    right = min(len(context), end + 220)
+    snippet = context[left:right].strip()
+    if left > 0:
+        snippet = "…" + snippet
+    if right < len(context):
+        snippet = snippet + "…"
 
-    return title, summary
+    return ans, snippet, score
 
 
-def generate_questions(text: str, n: int) -> List[str]:
-    n = int(max(1, min(n, 12)))
-    text = safe_trunc(text, 3000)
-
-    prompt = (
-        f"Сгенерируй {n} вопросов для самопроверки по тексту. "
-        "Вопросы должны проверять понимание причинно-следственных связей и выводов. "
-        "Формат: нумерова��ный список.\n\n"
-        f"Текст:\n{text}\n\n"
-        "Вопросы:\n"
-    )
-    raw = generate_text(prompt, max_new_tokens=220, min_new_tokens=80, do_sample=True)
-
-    # parse numbered list
-    qs = []
-    for line in raw.splitlines():
-        line = line.strip()
-        m = re.match(r"^\d+[\)\.\-]\s*(.+)$", line)
-        if m:
-            q = m.group(1).strip()
-            if q and not q.endswith("?"):
-                q += "?"
-            qs.append(q)
-    # fallback: split by '?'
-    if not qs:
-        parts = [p.strip() for p in re.split(r"\?\s*", raw) if p.strip()]
-        qs = [(p + "?") for p in parts[:n]]
-    # unique + cap
-    seen = set()
+# =========================
+# Quiz (heuristic questions; answers via retrieval+QA)
+# =========================
+def _sentences(text: str) -> List[str]:
+    # very simple sentence splitter
+    text = normalize_space(text)
+    if not text:
+        return []
+    parts = re.split(r"(?<=[\.\!\?…])\s+", text)
     out = []
-    for q in qs:
-        ql = q.lower()
-        if ql in seen:
-            continue
-        seen.add(ql)
-        out.append(q)
-        if len(out) >= n:
-            break
+    for p in parts:
+        p = p.strip()
+        if 40 <= len(p) <= 240:
+            out.append(p)
     return out
 
-
-# ============================================================
-# Extractive QA (FIXED: remove overflow_to_sample_mapping)
-# ============================================================
-@torch.inference_mode()
-def extractive_qa(question: str, context: str) -> Tuple[str, str]:
-    question = (question or "").strip()
-    context = (context or "").strip()
-    if not question or not context:
-        return "", ""
-
-    tok, model = load_qa()
-    context = safe_trunc(context, MAX_CONTEXT_CHARS)
-
-    enc = tok(
-        question,
-        context,
-        truncation="only_second",
-        max_length=QA_MAX_LENGTH,
-        stride=QA_STRIDE,
-        return_overflowing_tokens=True,
-        return_offsets_mapping=True,
-        padding=True,
-        return_tensors="pt",
-    )
-
-    offset_mapping = enc.pop("offset_mapping")
-    # IMPORTANT: do not pass these to model
-    enc.pop("overflow_to_sample_mapping", None)
-    enc.pop("num_truncated_tokens", None)
-    enc.pop("special_tokens_mask", None)
-
-    # Only model inputs
-    model_inputs = {k: v for k, v in enc.items() if k in ("input_ids", "attention_mask", "token_type_ids")}
-    outputs = model(**model_inputs)
-
-    start = outputs.start_logits.detach().cpu().numpy()
-    end = outputs.end_logits.detach().cpu().numpy()
-
-    best_score = -1e9
-    best_span = (0, 0)
-    best_ctx = context
-
-    for i in range(start.shape[0]):
-        seq_ids = tok.sequence_ids(i)
-        offsets = offset_mapping[i].detach().cpu().numpy()
-
-        # context token indices
-        ctx_idxs = [j for j, sid in enumerate(seq_ids) if sid == 1 and not (offsets[j][0] == 0 and offsets[j][1] == 0)]
-        if not ctx_idxs:
+def _keywords(text: str) -> Dict[str, int]:
+    words = re.findall(r"[А-Яа-яЁёA-Za-z\-]{3,}", text.lower())
+    freq: Dict[str, int] = {}
+    for w in words:
+        if w in RU_STOP:
             continue
+        freq[w] = freq.get(w, 0) + 1
+    return freq
 
-        s_logits = start[i]
-        e_logits = end[i]
-
-        # Take top candidates to avoid O(n^2)
-        top_s = sorted(ctx_idxs, key=lambda j: s_logits[j], reverse=True)[:20]
-        top_e = sorted(ctx_idxs, key=lambda j: e_logits[j], reverse=True)[:20]
-
-        for s_idx in top_s:
-            for e_idx in top_e:
-                if e_idx < s_idx:
-                    continue
-                if (e_idx - s_idx) > MAX_ANSWER_LEN_TOKENS:
-                    continue
-                score = float(s_logits[s_idx] + e_logits[e_idx])
-                if score > best_score:
-                    a = int(offsets[s_idx][0])
-                    b = int(offsets[e_idx][1])
-                    if b > a:
-                        best_score = score
-                        best_span = (a, b)
-
-    ans = best_ctx[best_span[0]:best_span[1]].strip()
-    if not ans:
-        return "", ""
-
-    left = max(0, best_span[0] - 120)
-    right = min(len(best_ctx), best_span[1] + 180)
-    snippet = best_ctx[left:right].strip()
-    if left > 0:
-        snippet = "…" + snippet
-    if right < len(best_ctx):
-        snippet = snippet + "…"
+def generate_quiz_questions(text: str, n: int) -> List[str]:
+    n = int(max(1, min(n, 12)))
+    sents = _sentences(text)
+    if not sents:
+        return []
 
-    return ans, snippet
+    freq = _keywords(text)
+    if not freq:
+        # fallback: use first sentences
+        sents = sents[:n]
+        return [f"О чем говорится в утверждении: «{s}»?" for s in sents]
+
+    scored = []
+    for s in sents:
+        ws = re.findall(r"[А-Яа-яЁёA-Za-z\-]{3,}", s.lower())
+        score = sum(freq.get(w, 0) for w in ws if w not in RU_STOP)
+        scored.append((score, s))
+    scored.sort(key=lambda x: x[0], reverse=True)
+
+    questions = []
+    for _, s in scored[: min(len(scored), n * 2)]:
+        ws = [w for w in re.findall(r"[А-Яа-яЁёA-Za-z\-]{3,}", s.lower()) if w not in RU_STOP]
+        if not ws:
+            continue
+        # choose "keyword" to blank
+        kw = max(ws, key=lambda w: freq.get(w, 0))
+        # blank first occurrence (case-insensitive)
+        blanked = re.sub(re.escape(kw), "____", s, count=1, flags=re.IGNORECASE)
+        q = f"Заполните пропуск: {blanked}"
+        questions.append(q)
+        if len(questions) >= n:
+            break
 
+    return questions[:n]
 
-# ============================================================
-# Features
-# ============================================================
-def select_central_text(st: IndexState, level: str) -> str:
-    if not st.chunks or st.emb is None:
-        return ""
-    emb = st.emb
-    centroid = emb.mean(axis=0)
-    centroid = centroid / (np.linalg.norm(centroid) + 1e-12)
-    sims = (emb @ centroid.reshape(-1, 1)).squeeze(1)
-
-    k = 3 if level == "Коротко" else 6
-    k = min(k, len(st.chunks))
-    idx = np.argpartition(-sims, k - 1)[:k]
-    idx = idx[np.argsort(-sims[idx])]
-    return "\n\n".join(st.chunks[i] for i in idx.tolist())
-
-
-def do_summary(text: str, state: Optional[Dict[str, Any]], level: str) -> Tuple[str, Dict[str, Any]]:
-    st = ensure_index(state, text)
-    selected = select_central_text(st, level)
-    if not selected:
-        return "Нет текста для пересказа.", st.__dict__
-    title, summ = robust_summary(selected)
-    md = f"### Заголовок\n{title}\n\n### Пересказ\n{summ}"
-    return md, st.__dict__
-
-
-def do_search(text: str, state: Optional[Dict[str, Any]], query: str, k: int) -> Tuple[str, Dict[str, Any]]:
-    st = ensure_index(state, text)
-    query = (query or "").strip()
-    if not query:
-        return "Введите запрос.", st.__dict__
-    hits = retrieve(st, query, k=int(max(1, min(k, 10))))
-    if not hits:
-        return "Ничего не найдено.", st.__dict__
-    out = ["### Результаты\n"]
-    for i, (score, chunk) in enumerate(hits, 1):
-        out.append(f"**{i}. score={score:.3f}**\n{chunk}\n")
-    return "\n".join(out).strip(), st.__dict__
-
-
-def do_quiz(text: str, state: Optional[Dict[str, Any]], n: int) -> Tuple[str, Dict[str, Any]]:
-    st = ensure_index(state, text)
-    if not st.chunks:
-        return "Нет текста.", st.__dict__
-
-    # build a compact source for question generation (central passages)
-    central = select_central_text(st, "Подробнее")
-    if not central:
-        central = safe_trunc(st.text, 3000)
-
-    questions = generate_questions(central, int(n))
-    if not questions:
-        return "Не удалось сгенерировать вопросы.", st.__dict__
-
-    # answer each question from retrieved context
-    lines = ["### Вопросы и ответы\n"]
-    for i, q in enumerate(questions, 1):
-        hits = retrieve(st, q, k=4)
-        ctx = "\n\n".join([c for _, c in hits]) if hits else central
-        ctx = safe_trunc(ctx, MAX_CONTEXT_CHARS)
-
-        ans, ev = extractive_qa(q, ctx)
-        if not ans:
-            # fallback: generator open-book answer
-            prompt = (
-                "Ответь на вопрос, используя ТОЛЬКО данный текст. "
-                "Если ответа нет, скажи 'В тексте это не указано'.\n\n"
-                f"Текст:\n{ctx}\n\n"
-                f"Вопрос: {q}\nОтвет:"
-            )
-            ans = generate_text(prompt, max_new_tokens=120, min_new_tokens=20, do_sample=False).strip()
-            ev = ctx[:320].strip()
-
-        lines.append(f"**{i}. {q}**")
-        lines.append(f"- Ответ: {ans}")
-        lines.append(f"- Фрагмент: {ev}")
-        lines.append("")
-    return "\n".join(lines).strip(), st.__dict__
-
-
-def do_chat(text: str, state: Optional[Dict[str, Any]], chat: List[Tuple[str, str]], user_q: str):
-    st = ensure_index(state, text)
-    user_q = (user_q or "").strip()
-    if not user_q:
-        return chat, st.__dict__, ""
-
-    hits = retrieve(st, user_q, k=5)
-    ctx = "\n\n".join([c for _, c in hits]) if hits else safe_trunc(st.text, 2500)
-    ctx = safe_trunc(ctx, MAX_CONTEXT_CHARS)
-
-    ans, ev = extractive_qa(user_q, ctx)
-    if not ans:
-        prompt = (
-            "Ответь на вопрос по тексту. "
-            "Если ответа нет, скажи 'В тексте это не указано'.\n\n"
-            f"Текст:\n{ctx}\n\n"
-            f"Вопрос: {user_q}\nОтвет:"
+
+# =========================
+# Gradio actions
+# =========================
+def on_load_models() -> str:
+    try:
+        sum_pipe, sum_id, qa_pipe, qa_id, emb_tok, emb_model, emb_id = get_models()
+        return (
+            "Модели загружены.\n"
+            f"- Summarization: {sum_id}\n"
+            f"- QA: {qa_id}\n"
+            f"- Embeddings: {emb_id}\n"
         )
-        ans = generate_text(prompt, max_new_tokens=140, min_new_tokens=20, do_sample=False).strip()
-        ev = ctx[:360].strip()
+    except Exception as e:
+        return f"Ошибка загрузки моделей: {e}"
 
-    reply = f"**Ответ:** {ans}\n\n**Доказательство:**\n{ev}"
-    chat = (chat or []) + [(user_q, reply)]
-    return chat, st.__dict__, ""
+def on_summary(text: str) -> str:
+    try:
+        text = safe_text(text)
+        if not text:
+            return "Нет текста."
+        s = smart_summary(text)
+        title = make_title(text, s)
+        return f"### Заголовок\n{title}\n\n### Пересказ\n{s}"
+    except Exception as e:
+        return f"Ошибка: {e}"
+
+def on_search(text: str, query: str, k: int) -> str:
+    try:
+        text = safe_text(text)
+        query = (query or "").strip()
+        if not text:
+            return "Нет текста."
+        if not query:
+            return "Введите запрос."
+        idx = get_index(text)
+        hits = retrieve(idx, query, int(max(1, min(k, 10))))
+        if not hits:
+            return "Ничего не найдено."
+        out = ["### Результаты"]
+        for i, (score, chunk) in enumerate(hits, 1):
+            out.append(f"**{i}. score={score:.3f}**\n{chunk}\n")
+        return "\n".join(out).strip()
+    except Exception as e:
+        return f"Ошибка: {e}"
+
+def on_quiz(text: str, n: int) -> str:
+    try:
+        text = safe_text(text)
+        if not text:
+            return "Нет текста."
+        idx = get_index(text)
+
+        questions = generate_quiz_questions(text, int(n))
+        if not questions:
+            return "Не удалось сгенерировать вопросы."
+
+        lines = ["### Вопросы и ответы (с доказательством)"]
+        for i, q in enumerate(questions, 1):
+            # For cloze question, try to answer via QA using retrieved context.
+            # We convert cloze to a QA-style question by removing "Заполните пропуск:"
+            qa_q = re.sub(r"^Заполните пропуск:\s*", "", q).strip()
+            hits = retrieve(idx, qa_q, k=5)
+            ctx = "\n\n".join([c for _, c in hits]) if hits else text[:CTX_MAX_CHARS]
+            ctx = ctx[:CTX_MAX_CHARS]
+
+            ans, ev, score = qa_answer(qa_q, ctx)
+            if not ans or score < 0.08:
+                ans = "В тексте это не указано (или требуется переформулировать вопрос)."
+
+            lines.append(f"**{i}. {q}**")
+            lines.append(f"- Ответ: {ans}")
+            lines.append(f"- Фрагмент: {ev}")
+            lines.append("")
+        return "\n".join(lines).strip()
+    except Exception as e:
+        return f"Ошибка: {e}"
+
+def on_chat(text: str, history: List[Tuple[str, str]], user_q: str):
+    try:
+        text = safe_text(text)
+        user_q = (user_q or "").strip()
+        history = history or []
 
+        if not text:
+            history.append((user_q, "Нет текста. Вставьте текст слева."))
+            return history, ""
 
-def model_info_text() -> str:
-    return (
-        "Используемые модели (3 трансформера):\n"
-        f"1) Генерация (пересказ/вопросы): {GEN_ID}\n"
-        f"2) Эмбеддинги (поиск): {EMB_ID}\n"
-        f"3) Extractive QA (ответ+фрагмент): {QA_ID}\n"
-        "\nCPU-only, без GPU. Память обычно < 16GB."
-    )
+        if not user_q:
+            return history, ""
 
+        idx = get_index(text)
+        hits = retrieve(idx, user_q, k=5)
+        ctx = "\n\n".join([c for _, c in hits]) if hits else text[:CTX_MAX_CHARS]
+        ctx = ctx[:CTX_MAX_CHARS]
 
-# ============================================================
-# UI
-# ============================================================
-with gr.Blocks(title="RU Text Study Assistant (CPU, 3 Transformers)") as demo:
-    gr.Markdown("## RU Text Study Assistant\nПересказ, вопросы, чат по тексту и семантический поиск. CPU-only, 3 трансформера.")
+        ans, ev, score = qa_answer(user_q, ctx)
+        if not ans or score < 0.08:
+            reply = "Ответ по тексту не найден. Попробуйте переформулировать вопрос или уточнить термин."
+        else:
+            reply = f"Ответ: {ans}\n\nДоказательство:\n{ev}"
+
+        history.append((user_q, reply))
+        return history, ""
+    except Exception as e:
+        history = history or []
+        history.append((user_q, f"Ошибка: {e}"))
+        return history, ""
 
-    state = gr.State({"text": "", "chunks": [], "emb": None})
 
+# =========================
+# UI (minimal)
+# =========================
+with gr.Blocks(title="RU Text Assistant (CPU, 3 Transformers)") as demo:
     with gr.Row():
         with gr.Column(scale=2):
-            src_text = gr.Textbox(label="Текст", lines=12, placeholder="Вставьте русский текст (лекция, статья, конспект).")
-            with gr.Accordion("Модели", open=False):
-                gr.Textbox(value=model_info_text(), lines=6, interactive=False, show_label=False)
+            text_in = gr.Textbox(label="Текст (русский)", lines=16, placeholder="Вставьте текст для анализа…")
+            load_btn = gr.Button("Загрузить модели", variant="secondary")
+            model_status = gr.Textbox(label="Статус", lines=5, interactive=False)
 
         with gr.Column(scale=3):
             with gr.Tabs():
                 with gr.Tab("Пересказ"):
-                    sum_level = gr.Radio(["Коротко", "Подробнее"], value="Коротко", label="Уровень")
                     sum_btn = gr.Button("Сделать пересказ", variant="primary")
                     sum_out = gr.Markdown()
 
-                with gr.Tab("Вопросы"):
-                    q_n = gr.Slider(1, 12, value=6, step=1, label="Количество вопросов")
-                    q_btn = gr.Button("Сгенерировать вопросы", variant="primary")
-                    q_out = gr.Markdown()
-
-                with gr.Tab("Чат по тексту"):
-                    chat = gr.Chatbot(height=380)
-                    with gr.Row():
-                        user_q = gr.Textbox(label="Вопрос", placeholder="Задайте вопрос по тексту…", lines=1)
-                        send = gr.Button("Отправить")
-                    gr.Markdown("Ответ: поиск по чанкам → extractive QA с доказательством → fallback на генерацию.")
-
                 with gr.Tab("Поиск"):
-                    s_q = gr.Textbox(label="Запрос", placeholder="Например: 'вывод', 'метод', 'ограничения'")
-                    s_k = gr.Slider(1, 10, value=5, step=1, label="Топ-K")
-                    s_btn = gr.Button("Найти фрагменты", variant="primary")
-                    s_out = gr.Markdown()
-
-    sum_btn.click(do_summary, inputs=[src_text, state, sum_level], outputs=[sum_out, state])
-    q_btn.click(do_quiz, inputs=[src_text, state, q_n], outputs=[q_out, state])
+                    query_in = gr.Textbox(label="Запрос", placeholder="Например: стандартизация, вариабельность, вывод…")
+                    k_in = gr.Slider(1, 10, value=TOPK_DEFAULT, step=1, label="Top-K")
+                    search_btn = gr.Button("Найти фрагменты", variant="primary")
+                    search_out = gr.Markdown()
 
-    send.click(do_chat, inputs=[src_text, state, chat, user_q], outputs=[chat, state, user_q])
-    user_q.submit(do_chat, inputs=[src_text, state, chat, user_q], outputs=[chat, state, user_q])
+                with gr.Tab("Вопросы"):
+                    n_in = gr.Slider(1, 12, value=6, step=1, label="Количество вопросов")
+                    quiz_btn = gr.Button("Сгенерировать и проверить", variant="primary")
+                    quiz_out = gr.Markdown()
 
-    s_btn.click(do_search, inputs=[src_text, state, s_q, s_k], outputs=[s_out, state])
+                with gr.Tab("Чат по тексту"):
+                    chat = gr.Chatbot(height=420)
+                    user_q = gr.Textbox(label="Вопрос", lines=1, placeholder="Задайте вопрос по тексту…")
+                    send_btn = gr.Button("Отправить", variant="primary")
+
+    load_btn.click(on_load_models, outputs=[model_status])
+    sum_btn.click(on_summary, inputs=[text_in], outputs=[sum_out])
+    search_btn.click(on_search, inputs=[text_in, query_in, k_in], outputs=[search_out])
+    quiz_btn.click(on_quiz, inputs=[text_in, n_in], outputs=[quiz_out])
+    send_btn.click(on_chat, inputs=[text_in, chat, user_q], outputs=[chat, user_q])
+    user_q.submit(on_chat, inputs=[text_in, chat, user_q], outputs=[chat, user_q])
 
 if __name__ == "__main__":
     demo.queue(max_size=32).launch(server_name="0.0.0.0", server_port=7860, show_error=True)