Update app.py

app.py

@@ -1,550 +1,556 @@
+import os
+from typing import List, Dict, Any, Tuple
+
 import gradio as gr
+import numpy as np
 import torch
-from transformers import (
-    pipeline,
-    AutoTokenizer,
-    AutoModelForSeq2SeqLM,
-    BitsAndBytesConfig
-)
+from transformers import pipeline
 from sentence_transformers import SentenceTransformer
-import numpy as np
-from typing import List, Dict
-import PyPDF2
-import io
-import re
-import os
 
-# ==================== КОНФИГУРАЦИЯ ====================
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-MAX_CHUNK_SIZE = 512
-CACHE_DIR = "./models"
-
-# Создаем директорию для кэша
-os.makedirs(CACHE_DIR, exist_ok=True)
-
-# ==================== ЗАГРУЗКА МОДЕЛЕЙ ====================
-def load_models():
-    """Загрузка моделей с оптимизацией под HuggingFace Space"""
-    models = {}
-    
-    print("Загрузка энкодера для поиска...")
-    # Более легкая модель для эмбеддингов
-    models["encoder"] = SentenceTransformer(
-        "sentence-transformers/all-MiniLM-L6-v2",
-        device="cpu"
-    )
-    
-    print("Загрузка суммаризатора...")
-    # Используем более надежную модель для суммаризации
-    models["summarizer"] = {
-        "model_name": "sshleifer/distilbart-cnn-12-6",
-        "pipeline": None
+
+# ========= КОНСТАНТЫ И ОГРАНИЧЕНИЯ ==========
+
+# Общий лимит для хранимого текста (для чата/поиска) — можно увеличить,
+# но без фанатизма, чтобы не упираться в память.
+MAX_DOC_CHARS = 200_000
+
+# Лимит для текста, который отправляем на суммаризацию (самый дорогой шаг)
+MAX_SUMM_CHARS = 30_000
+
+# Размер чанка для индекса/суммаризации
+CHUNK_SIZE = 700
+CHUNK_OVERLAP = 150
+
+# Модели (все публичные и относительно лёгкие)
+EMB_MODEL_NAME = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"  # энкодер
+SUMM_MODEL_NAME = "d0rj/rut5-base-summ"                                         # суммаризация (RU T5)
+CHAT_MODEL_NAME = "google/flan-t5-small"                                        # чат/инструкции
+
+DEVICE = 0 if torch.cuda.is_available() else -1
+
+# Ограничим потоки
+torch.set_num_threads(4)
+
+
+# ========= ЗАГРУЗКА МОДЕЛЕЙ ==========
+
+print("Загружаем модели...")
+
+emb_model = SentenceTransformer(EMB_MODEL_NAME)
+if torch.cuda.is_available():
+    emb_model = emb_model.to("cuda")
+
+summarizer = pipeline(
+    "summarization",
+    model=SUMM_MODEL_NAME,
+    device=DEVICE,
+)
+
+chat_model = pipeline(
+    "text2text-generation",
+    model=CHAT_MODEL_NAME,
+    device=DEVICE,
+)
+
+print("Модели загружены.")
+
+
+# ========= ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ==========
+
+def normalize_whitespace(text: str) -> str:
+    """Убираем лишние пробелы и пустые строки."""
+    lines = [line.strip() for line in text.splitlines()]
+    cleaned = "\n".join(line for line in lines if line)
+    return cleaned
+
+
+def split_into_chunks(text: str, chunk_size: int = CHUNK_SIZE, overlap: int = CHUNK_OVERLAP) -> List[str]:
+    """
+    Делим текст на куски по символам с перекрытием.
+    Это дешево по памяти и позволяет обрабатывать длинные тексты по частям.
+    """
+    text = text.strip()
+    chunks: List[str] = []
+    start = 0
+    n = len(text)
+    while start < n:
+        end = min(start + chunk_size, n)
+        chunk = text[start:end].strip()
+        if chunk:
+            chunks.append(chunk)
+        start = end - overlap
+        if start < 0:
+            start = 0
+        if start >= n:
+            break
+    return chunks
+
+
+def build_index(text: str) -> Dict[str, Any]:
+    """
+    Строим векторный индекс для чанков текста.
+    Эмбеддинги храним в float16 для экономии памяти.
+    """
+    chunks = split_into_chunks(text)
+    if not chunks:
+        return {"text": text, "chunks": [], "embeddings": None}
+
+    embeddings = emb_model.encode(
+        chunks,
+        convert_to_numpy=True,
+        show_progress_bar=False,
+        batch_size=32,
+    ).astype(np.float16)
+
+    return {
+        "text": text,
+        "chunks": chunks,
+        "embeddings": embeddings,
     }
-    
-    print("Загрузка чат-модели...")
-    # Используем T5 для генерации
-    models["chat_tokenizer"] = AutoTokenizer.from_pretrained(
-        "google/flan-t5-base",
-        cache_dir=CACHE_DIR
-    )
-    
-    models["chat_model"] = AutoModelForSeq2SeqLM.from_pretrained(
-        "google/flan-t5-base",
-        cache_dir=CACHE_DIR,
-        torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
-        device_map="auto" if DEVICE == "cuda" else None,
-        low_cpu_mem_usage=True
-    )
-    
-    return models
 
-# ==================== ОБРАБОТКА ТЕКСТА ====================
-def extract_text_from_pdf(file) -> str:
-    """Извлечение текста из PDF"""
-    text = ""
+
+def retrieve_context(query: str, state: Dict[str, Any], top_k: int = 4) -> List[str]:
+    """
+    Находим top_k самых похожих чанков под запрос пользователя.
+    """
+    if not state or state.get("embeddings") is None:
+        return []
+
+    embeddings = state["embeddings"]
+    chunks = state["chunks"]
+    if embeddings is None or len(chunks) == 0:
+        return []
+
+    query_emb = emb_model.encode([query], convert_to_numpy=True)[0].astype(np.float16)
+
+    # косинусное сходство
+    emb_f = embeddings.astype(np.float32)
+    query_f = query_emb.astype(np.float32)
+
+    doc_norms = np.linalg.norm(emb_f, axis=1) + 1e-8
+    query_norm = np.linalg.norm(query_f) + 1e-8
+    sims = (emb_f @ query_f) / (doc_norms * query_norm)
+
+    top_idx = np.argsort(sims)[-top_k:][::-1]
+    result_chunks = []
+    for i in top_idx:
+        i = int(i)
+        if 0 <= i < len(chunks):
+            result_chunks.append(chunks[i])
+    return result_chunks
+
+
+def summarize_document(text: str) -> Tuple[str, str]:
+    """
+    Двухуровневая суммаризация:
+    - короткий конспект (более общий)
+    - длинный конспект (по частям, детальнее)
+    """
+    text = text.strip()
+    if not text:
+        return "", ""
+
+    text_for_summ = text[:MAX_SUMM_CHARS]
+
+    # Небольшой текст — одним заходом
+    if len(text_for_summ) <= CHUNK_SIZE:
+        result = summarizer(
+            text_for_summ,
+            max_length=220,
+            min_length=60,
+            do_sample=False,
+            truncation=True,
+        )[0]["summary_text"]
+        # для малых текстов делаем оба конспекта одинаковыми
+        return result, result
+
+    # Длинный текст — разбиваем на чанки и суммируем каждый
+    chunks = split_into_chunks(text_for_summ, chunk_size=CHUNK_SIZE, overlap=CHUNK_OVERLAP)
+    chunk_summaries: List[str] = []
+
+    for ch in chunks:
+        try:
+            s = summarizer(
+                ch,
+                max_length=160,
+                min_length=50,
+                do_sample=False,
+                truncation=True,
+            )[0]["summary_text"]
+        except Exception as e:
+            print("Ошибка суммаризации чанка:", e)
+            s = ch[:400]
+        chunk_summaries.append(s)
+
+    # Длинный конспект — конкатенация суммаризаций
+    long_summary = "\n\n".join(chunk_summaries)
+    # Чуть подрежем, чтобы не раздувать UI
+    long_summary = long_summary[:5000]
+
+    # Краткий конспект — дополнительная суммаризация первых N кусочков
+    short_source = " ".join(chunk_summaries[: max(1, len(chunk_summaries) // 2)])
+    short_source = short_source[:2500]
+
     try:
-        if hasattr(file, 'read'):
-            pdf_reader = PyPDF2.PdfReader(io.BytesIO(file.read()))
-        else:
-            pdf_reader = PyPDF2.PdfReader(file)
-        
-        for page in pdf_reader.pages:
-            page_text = page.extract_text()
-            if page_text:
-                text += page_text + "\n"
+        short_summary = summarizer(
+            short_source,
+            max_length=220,
+            min_length=80,
+            do_sample=False,
+            truncation=True,
+        )[0]["summary_text"]
     except Exception as e:
-        print(f"Ошибка чтения PDF: {e}")
+        print("Ошибка итоговой суммаризации:", e)
+        short_summary = short_source
+
+    return short_summary, long_summary
+
+
+def extract_text_from_file(file_obj) -> str:
+    """
+    Чтение текста из .txt или .pdf файла.
+    Для PDF читаем постранично и обрезаем по MAX_DOC_CHARS.
+    """
+    if file_obj is None:
         return ""
-    
-    return text.strip()
-
-def clean_text(text: str) -> str:
-    """Очистка текста"""
-    text = re.sub(r'\s+', ' ', text)
-    text = re.sub(r'[^\w\s.,!?;:()-]', '', text)
-    return text.strip()
-
-def chunk_text(text: str, chunk_size: int = MAX_CHUNK_SIZE) -> List[str]:
-    """Разбиение текста на чанки"""
-    sentences = re.split(r'(?<=[.!?])\s+', text)
-    
-    chunks = []
-    current_chunk = []
-    current_length = 0
-    
-    for sentence in sentences:
-        sentence_length = len(sentence)
-        if current_length + sentence_length > chunk_size and current_chunk:
-            chunks.append(' '.join(current_chunk))
-            current_chunk = [sentence]
-            current_length = sentence_length
-        else:
-            current_chunk.append(sentence)
-            current_length += sentence_length
-    
-    if current_chunk:
-        chunks.append(' '.join(current_chunk))
-    
-    return chunks
 
-# ==================== ПОИСК РЕЛЕВАНТНЫХ ЧАНКОВ ====================
-class SimpleSearch:
-    """Упрощенная система поиска"""
-    def __init__(self, encoder_model):
-        self.encoder = encoder_model
-        self.chunks = []
-        self.embeddings = None
-    
-    def build_index(self, chunks: List[str]):
-        """Создание эмбеддингов"""
-        self.chunks = chunks[:100]  # Ограничиваем количество
-        if self.chunks:
-            self.embeddings = self.encoder.encode(
-                self.chunks,
-                convert_to_numpy=True,
-                show_progress_bar=False
-            )
-    
-    def search(self, query: str, k: int = 3) -> List[str]:
-        """Поиск похожих чанков"""
-        if not self.embeddings or len(self.embeddings) == 0:
-            return self.chunks[:k] if self.chunks else []
-        
+    name = getattr(file_obj, "name", "")
+    ext = os.path.splitext(name)[1].lower()
+
+    # .txt
+    if ext == ".txt":
+        content = file_obj.read()
+        if isinstance(content, bytes):
+            content = content.decode("utf-8", errors="ignore")
+        content = normalize_whitespace(content)
+        if len(content) > MAX_DOC_CHARS:
+            content = content[:MAX_DOC_CHARS]
+        return content
+
+    # .pdf
+    if ext == ".pdf":
         try:
-            query_embedding = self.encoder.encode([query], convert_to_numpy=True)
-            similarities = np.dot(self.embeddings, query_embedding.T).flatten()
-            top_indices = np.argsort(similarities)[-k:][::-1]
-            
-            results = []
-            for idx in top_indices:
-                if similarities[idx] > 0.3:
-                    results.append(self.chunks[idx])
-            
-            return results if results else self.chunks[:k]
-        except:
-            return self.chunks[:k]
-
-# ==================== ФУНКЦИИ ГЕНЕРАЦИИ ====================
-def get_summarizer(models_dict: Dict):
-    """Ленивая загрузка суммаризатора"""
-    if models_dict["summarizer"]["pipeline"] is None:
-        print("Загрузка суммаризатора...")
-        models_dict["summarizer"]["pipeline"] = pipeline(
-            "summarization",
-            model=models_dict["summarizer"]["model_name"],
-            tokenizer=models_dict["summarizer"]["model_name"],
-            device=0 if DEVICE == "cuda" else -1,
-            model_kwargs={"cache_dir": CACHE_DIR}
+            import pypdf
+        except ImportError:
+            return "Ошибка: для PDF нужен пакет 'pypdf' (добавьте его в requirements.txt)."
+
+        reader = pypdf.PdfReader(file_obj)
+        pages_text = []
+        total_len = 0
+
+        for page in reader.pages:
+            t = page.extract_text() or ""
+            t = t.strip()
+            if not t:
+                continue
+
+            # добавляем постранично, пока не достигли лимита
+            to_add = "\n" + t
+            if total_len + len(to_add) > MAX_DOC_CHARS:
+                remaining = MAX_DOC_CHARS - total_len
+                if remaining > 0:
+                    pages_text.append(to_add[:remaining])
+                    total_len += remaining
+                break
+
+            pages_text.append(to_add)
+            total_len += len(to_add)
+
+            if total_len >= MAX_DOC_CHARS:
+                break
+
+        content = normalize_whitespace("".join(pages_text))
+        return content
+
+    # неизвестный формат — просто ничего
+    return ""
+
+
+# ========= ЛОГИКА ДЛЯ UI ==========
+
+def load_document(file, raw_text, prev_state):
+    """
+    Загрузка документа: файл или текст.
+    - Чистим и (при необходимости) обрезаем текст.
+    - Строим индекс.
+    - Делаем 2 уровня суммаризации.
+    """
+    if file is not None:
+        text = extract_text_from_file(file)
+    else:
+        text = raw_text or ""
+
+    if not isinstance(text, str) or not text.strip():
+        return (
+            "",
+            "",
+            prev_state,
+            "❗ Пожалуйста, загрузите файл (.txt/.pdf) или вставьте текст.",
         )
-    return models_dict["summarizer"]["pipeline"]
-
-def generate_summary(text: str, models_dict: Dict) -> Dict:
-    """Генерация конспекта"""
-    summarizer = get_summarizer(models_dict)
-    
-    # Ограничиваем длину текста
-    text = text[:3000]
-    
-    try:
-        summary = summarizer(
-            text,
-            max_length=200,
-            min_length=100,
-            do_sample=False,
-            truncation=True
-        )[0]['summary_text']
-        
-        sentences = summary.split('. ')
-        short_summary = '. '.join(sentences[:2]) + '.' if len(sentences) > 1 else summary
-        detailed_summary = summary
-        
-        return {
-            "short": short_summary,
-            "detailed": detailed_summary
-        }
-    except Exception as e:
-        print(f"Ошибка суммаризации: {e}")
-        return {
-            "short": text[:200] + "...",
-            "detailed": text[:500] + "..."
-        }
-
-def explain_simple(text: str, level: str, models_dict: Dict) -> str:
-    """Объяснение простым языком"""
-    prompt_templates = {
-        "school": "Объясни этот текст простыми словами, чтобы понял школьник:\n\n{text}\n\nОбъяснение:",
-        "student": "Объясни этот текст простым языком для студента:\n\n{text}\n\nОбъяснение:",
-        "expert": "Сделай профессиональное разъяснение этого текста:\n\n{text}\n\nРазъяснение:"
-    }
-    
-    prompt = prompt_templates[level].format(text=text[:800])
-    
-    inputs = models_dict["chat_tokenizer"](
-        prompt,
-        return_tensors="pt",
-        max_length=512,
-        truncation=True,
-        padding=True
-    )
-    
-    if DEVICE == "cuda":
-        inputs = inputs.to("cuda")
-    
-    outputs = models_dict["chat_model"].generate(
-        **inputs,
-        max_new_tokens=300,
-        temperature=0.7,
-        do_sample=True,
-        repetition_penalty=1.2
-    )
-    
-    explanation = models_dict["chat_tokenizer"].decode(
-        outputs[0],
-        skip_special_tokens=True
+
+    text = normalize_whitespace(text)
+    truncated = len(text) > MAX_DOC_CHARS
+    if truncated:
+        text = text[:MAX_DOC_CHARS]
+
+    state = build_index(text)
+    short_summary, long_summary = summarize_document(text)
+
+    status_msg = f"✅ Документ загружен. Использовано {len(text)} символов."
+    status_msg += f" Число чанков: {len(state['chunks'])}."
+    if truncated:
+        status_msg += f" Текст был обрезан до {MAX_DOC_CHARS} символов для стабильной работы."
+
+    return short_summary, long_summary, state, status_msg
+
+
+def explain_text_fn(passage: str, level: str, state):
+    """
+    Объяснение фрагмента простым языком.
+    Если фрагмент не задан — берём начало загруженного текста.
+    """
+    if (not passage or not passage.strip()) and state and state.get("text"):
+        passage = state["text"][:1500]
+
+    if not passage or not passage.strip():
+        return "Нет текста для объяснения. Сначала загрузите документ или введите фрагмент."
+
+    level_prompt = {
+        "Школьник": "Explain the following Russian text in simple Russian, so that a 9th grade student can understand it. Use short sentences and simple examples. Answer ONLY in Russian.",
+        "Студент": "Explain the following Russian text clearly and structurally for a first-year university student. Use Russian language. Answer ONLY in Russian.",
+        "Эксперт": "Explain the following Russian text briefly but in a professional, scientific manner. Use Russian language and appropriate terminology. Answer ONLY in Russian.",
+    }.get(level, "Explain the following Russian text in simple Russian. Answer ONLY in Russian.")
+
+    prompt = (
+        f"{level_prompt}\n\n"
+        f"Текст:\n{passage}\n\n"
+        f"Объяснение на русском:"
     )
-    
-    return explanation
-
-def generate_questions(text: str, difficulty: str, models_dict: Dict) -> str:
-    """Генерация тестовых вопросов"""
-    prompt = f"""Сгенерируй 3 тестовых вопроса по тексту. 
-Уровень сложности: {difficulty}
-
-Текст: {text[:1000]}
-
-Формат вывода:
-1. [Вопрос с вариантами ответов]
-a) Вариант 1
-b) Вариант 2
-c) Вариант 3
-d) Правильный вариант: [буква]
-
-2. [Открытый вопрос]
-Ответ: [краткий ответ]
-
-3. [Вопрос на понимание]
-Ответ: [объяснение]"""
-    
-    inputs = models_dict["chat_tokenizer"](
+
+    result = chat_model(
         prompt,
-        return_tensors="pt",
-        max_length=1024,
+        max_new_tokens=256,
+        do_sample=False,
         truncation=True,
-        padding=True
-    )
-    
-    if DEVICE == "cuda":
-        inputs = inputs.to("cuda")
-    
-    outputs = models_dict["chat_model"].generate(
-        **inputs,
-        max_new_tokens=500,
-        temperature=0.8,
-        do_sample=True,
-        repetition_penalty=1.1
-    )
-    
-    questions = models_dict["chat_tokenizer"].decode(
-        outputs[0],
-        skip_special_tokens=True
-    )
-    
-    return questions
+    )[0]["generated_text"]
+
+    return result
 
-def chat_with_document(query: str, search_system: SimpleSearch, models_dict: Dict) -> str:
-    """Чат с документом"""
-    if not search_system.chunks:
+
+def generate_questions_fn(difficulty: str, num_q: int, state):
+    """
+    Генерация экзаменационных вопросов по документу.
+    Принуждаем модель выдавать именно НУМЕРОВАННЫЙ СПИСОК
+    осмысленных вопросов-предложений на русском.
+    """
+    if not state or not state.get("text"):
         return "Сначала загрузите документ."
-    
-    relevant_chunks = search_system.search(query, k=3)
-    
-    if not relevant_chunks:
-        return "Не удалось найти информацию по вашему вопросу в документе."
-    
-    context = "\n".join(relevant_chunks[:2])
-    
-    prompt = f"""Ответь на вопрос на основе контекста из документа.
 
-Контекст: {context}
+    base_text = state["text"][:4000]
 
-Вопрос: {query}
+    difficulty_en = {
+        "easy": "easy (basic understanding)",
+        "medium": "medium (conceptual understanding)",
+        "hard": "hard (deep analytical understanding)",
+    }.get(difficulty, "medium (conceptual understanding)")
 
-Ответь четко и по делу. Если в контексте нет информации, скажи об этом.
+    prompt = (
+        "You are an assistant that creates exam questions in Russian.\n"
+        f"Difficulty level: {difficulty_en}.\n\n"
+        "Based on the Russian text below, create a numbered list of "
+        f"{num_q} exam questions in RUSSIAN.\n\n"
+        "Requirements:\n"
+        "- Each question MUST be a full sentence in Russian (not one word).\n"
+        "- Questions must be directly related to the text.\n"
+        "- Output ONLY the numbered list of questions, nothing else.\n\n"
+        f"Текст:\n{base_text}\n\n"
+        "Список вопросов на русском:\n"
+        "1."
+    )
 
-Ответ:"""
-    
-    inputs = models_dict["chat_tokenizer"](
+    result = chat_model(
         prompt,
-        return_tensors="pt",
-        max_length=1024,
+        max_new_tokens=384,
+        do_sample=False,
         truncation=True,
-        padding=True
-    )
-    
-    if DEVICE == "cuda":
-        inputs = inputs.to("cuda")
-    
-    outputs = models_dict["chat_model"].generate(
-        **inputs,
-        max_new_tokens=400,
-        temperature=0.7,
-        do_sample=True,
-        repetition_penalty=1.2
+    )[0]["generated_text"]
+
+    return result
+
+
+def chat_answer_fn(message: str, chat_history: List, state):
+    """
+    Чат по документу (RAG: поиск контекста + генерация ответа).
+    """
+    if not message or not message.strip():
+        return chat_history, ""
+
+    if not state or not state.get("chunks"):
+        bot_msg = "Сначала загрузите документ на вкладке «Документ»."
+        chat_history = chat_history + [(message, bot_msg)]
+        return chat_history, ""
+
+    # Берём релевантные чанки
+    context_chunks = retrieve_context(message, state, top_k=4)
+    context = "\n\n".join(context_chunks)
+
+    if not context.strip():
+        bot_msg = "В документе не нашлось подходящего фрагмента для ответа на этот вопрос."
+        chat_history = chat_history + [(message, bot_msg)]
+        return chat_history, ""
+
+    prompt = (
+        "You are a helpful assistant that answers questions ONLY based on the provided Russian context.\n"
+        "Rules:\n"
+        "- Answer strictly in Russian.\n"
+        "- If the answer is not present in the context, say explicitly in Russian that the document does not contain this information.\n\n"
+        f"Контекст (фрагменты из документа):\n{context}\n\n"
+        f"Вопрос пользователя: {message}\n\n"
+        "Ответ на русском:"
     )
-    
-    answer = models_dict["chat_tokenizer"].decode(
-        outputs[0],
-        skip_special_tokens=True
+
+    answer = chat_model(
+        prompt,
+        max_new_tokens=256,
+        do_sample=False,
+        truncation=True,
+    )[0]["generated_text"]
+
+    chat_history = chat_history + [(message, answer)]
+    return chat_history, ""
+
+
+def clear_chat():
+    return [], ""
+
+
+# ========= UI НА GRADIO ==========
+
+with gr.Blocks(title="EduMultiSpace — учебный помощник (устойчивая версия)") as demo:
+    gr.Markdown(
+        """
+        # 📚 EduMultiSpace (устойчивая версия)
+
+        Учебный помощник на базе компактных трансформеров:
+        1. Поиск по документу (эмбеддинги + RAG)  
+        2. Краткий и расширенный конспект  
+        3. Объяснение сложных фрагментов  
+        4. Генерация экзаменационных вопросов и чат по тексту  
+
+        Для стабильности:
+        * Храним не более 200 000 символов текста.
+        * Суммаризация делается по первым ~30 000 символов.
+        """
     )
-    
-    return answer
-
-# ==================== GRADIO ИНТЕРФЕЙС ====================
-def create_interface():
-    # Загружаем модели
-    models = load_models()
-    search_system = SimpleSearch(models["encoder"])
-    
-    # Состояние приложения
-    current_state = {
-        "text": "",
-        "processed": False
-    }
-    
-    def process_document(file, text_input):
-        """Обработка документа"""
-        text = ""
-        
-        if file is not None:
-            text = extract_text_from_pdf(file)
-        elif text_input:
-            text = text_input
-        
-        if not text:
-            return "❌ Пожалуйста, загрузите файл или введите текст", "", "", ""
-        
-        text = clean_text(text)
-        current_state["text"] = text
-        
-        chunks = chunk_text(text)
-        search_system.build_index(chunks)
-        
-        summary = generate_summary(text[:2000], models)
-        
-        word_count = len(text.split())
-        status = f"✅ Документ обработан ({word_count} слов)"
-        
-        preview = text[:500] + "..." if len(text) > 500 else text
-        
-        current_state["processed"] = True
-        
-        return status, summary["short"], summary["detailed"], preview
-    
-    def handle_explain(level):
-        """Обработка объяснения"""
-        if not current_state["processed"]:
-            return "Сначала загрузите и обработайте документ."
-        
-        return explain_simple(current_state["text"][:1000], level, models)
-    
-    def handle_questions(difficulty):
-        """Генерация вопросов"""
-        if not current_state["processed"]:
-            return "Сначала загрузите и обработайте документ."
-        
-        return generate_questions(current_state["text"][:1500], difficulty, models)
-    
-    def handle_chat(message, history):
-        """Обработчик чата"""
-        if not current_state["processed"]:
-            return "Сначала загрузите и обработайте документ."
-        
-        response = chat_with_document(message, search_system, models)
-        return response
-    
-    # Создание интерфейса
-    with gr.Blocks(title="EduMultiSpace", theme=gr.themes.Soft()) as app:
-        gr.Markdown("""
-        # 📚 EduMultiSpace: Умный помощник по учебным материалам
-        
-        *Загрузите учебный материал (PDF или текст) и получите:*
-        - 📝 Автоматический конспект
-        - 🎓 Объяснение простым языком
-        - ❓ Тестовые вопросы для проверки
-        - 💬 Чат с документом
-        """)
-        
-        # Вкладки
-        with gr.Tabs():
-            # Вкладка 1: Загрузка
-            with gr.Tab("📄 Загрузить документ"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("### Загрузите учебный материал")
-                        file_input = gr.File(
-                            label="PDF файл",
-                            file_types=[".pdf", ".txt"]
-                        )
-                        text_input = gr.Textbox(
-                            label="Или вставьте текст",
-                            lines=8,
-                            placeholder="Вставьте текст лекции, статьи, учебника..."
-                        )
-                        process_btn = gr.Button(
-                            "📊 Обработать документ",
-                            variant="primary",
-                            size="lg"
-                        )
-                    
-                    with gr.Column(scale=2):
-                        status = gr.Markdown("**Статус:** Ожид��ние документа")
-                        
-                        with gr.Accordion("Превью текста", open=False):
-                            preview_text = gr.Markdown()
-                        
-                        with gr.Row():
-                            with gr.Column():
-                                gr.Markdown("### 🎯 Краткий конспект")
-                                short_summary = gr.Textbox(
-                                    lines=4,
-                                    label="",
-                                    interactive=False
-                                )
-                            with gr.Column():
-                                gr.Markdown("### 📖 Подробный конспект")
-                                detailed_summary = gr.Textbox(
-                                    lines=6,
-                                    label="",
-                                    interactive=False
-                                )
-            
-            # Вкладка 2: Объяснение
-            with gr.Tab("🎓 Объяснить просто"):
-                gr.Markdown("### Объяснение материала разным уровнем сложности")
-                level = gr.Radio(
-                    choices=["school", "student", "expert"],
-                    label="Уровень объяснения",
-                    value="student",
-                    info="Выберите, для кого объяснять"
-                )
-                explain_btn = gr.Button("🤔 Объяснить текст", variant="primary")
-                explanation_output = gr.Textbox(
-                    label="Результат",
-                    lines=8,
-                    interactive=False
-                )
-            
-            # Вкладка 3: Вопросы
-            with gr.Tab("❓ Тесты и вопросы"):
-                gr.Markdown("### Сгенерируйте вопросы для самопроверки")
-                difficulty = gr.Radio(
-                    choices=["легкий", "средний", "сложный"],
-                    label="Сложность вопросов",
-                    value="средний"
-                )
-                questions_btn = gr.Button("📝 Создать вопросы", variant="primary")
-                questions_output = gr.Textbox(
-                    label="Вопросы для проверки знаний",
-                    lines=12,
-                    interactive=False
-                )
-            
-            # Вкладка 4: Чат
-            with gr.Tab("💬 Чат с документом"):
-                gr.Markdown("### Задавайте вопросы по содержанию документа")
-                
-                chatbot = gr.Chatbot(
-                    label="Диалог",
-                    height=400
-                )
-                
-                msg = gr.Textbox(
-                    label="Ваш вопрос",
-                    placeholder="Задайте вопрос о документе...",
-                    scale=4
-                )
-                
-                examples = gr.Examples(
-                    examples=[
-                        "В чем основная идея?",
-                        "Объясни ключевые термины",
-                        "Какие выводы можно сделать?",
-                        "Кратко перескажи содержание"
-                    ],
-                    inputs=msg,
-                    label="Примеры вопросов"
-                )
-                
-                with gr.Row():
-                    clear_btn = gr.Button("Очистить чат")
-                    submit_btn = gr.Button("Отправить", variant="primary")
-        
-        # Обработчики событий
-        process_btn.click(
-            process_document,
-            inputs=[file_input, text_input],
-            outputs=[status, short_summary, detailed_summary, preview_text]
+
+    # Состояние
+    state = gr.State({"text": "", "chunks": [], "embeddings": None})
+
+    # --- Вкладка: Документ ---
+    with gr.Tab("Документ"):
+        with gr.Row():
+            file_input = gr.File(
+                label="Загрузите файл (.txt или .pdf)",
+                file_types=[".txt", ".pdf"],
+            )
+            text_input = gr.Textbox(
+                label="Или вставьте текст вручную",
+                lines=10,
+                placeholder="Вставьте сюда ваш текст...",
+            )
+
+        load_btn = gr.Button("Загрузить и проанализировать")
+        status_md = gr.Markdown()
+
+        short_summary_box = gr.Textbox(
+            label="Краткий конспект",
+            lines=8,
+        )
+        long_summary_box = gr.Textbox(
+            label="Расширенный конспект",
+            lines=12,
         )
-        
+
+        load_btn.click(
+            load_document,
+            inputs=[file_input, text_input, state],
+            outputs=[short_summary_box, long_summary_box, state, status_md],
+        )
+
+    # --- Вкладка: Объяснение ---
+    with gr.Tab("Объяснение"):
+        explain_input = gr.Textbox(
+            label="Фрагмент для объяснения",
+            lines=8,
+            placeholder="Вставьте отрывок из документа. "
+                        "Если оставить пустым — будет взято начало загруженного текста.",
+        )
+        level_dd = gr.Dropdown(
+            label="Уровень объяснения",
+            choices=["Школьник", "Студент", "Эксперт"],
+            value="Студент",
+        )
+        explain_btn = gr.Button("Объяснить проще")
+        explain_out = gr.Textbox(
+            label="Объяснение",
+            lines=10,
+        )
+
         explain_btn.click(
-            handle_explain,
-            inputs=[level],
-            outputs=[explanation_output]
+            explain_text_fn,
+            inputs=[explain_input, level_dd, state],
+            outputs=[explain_out],
         )
-        
-        questions_btn.click(
-            handle_questions,
-            inputs=[difficulty],
-            outputs=[questions_output]
+
+    # --- Вкладка: Вопросы к тексту ---
+    with gr.Tab("Вопросы"):
+        diff_dd = gr.Dropdown(
+            label="Сложность",
+            choices=["easy", "medium", "hard"],
+            value="medium",
         )
-        
-        def respond(message, chat_history):
-            response = handle_chat(message, chat_history)
-            chat_history.append((message, response))
-            return "", chat_history
-        
-        submit_btn.click(
-            respond,
-            inputs=[msg, chatbot],
-            outputs=[msg, chatbot]
+        num_slider = gr.Slider(
+            label="Количество вопросов",
+            minimum=3,
+            maximum=10,
+            value=5,
+            step=1,
         )
-        
-        msg.submit(
-            respond,
-            inputs=[msg, chatbot],
-            outputs=[msg, chatbot]
+        gen_q_btn = gr.Button("Сгенерировать вопросы")
+        q_out = gr.Textbox(
+            label="Вопросы",
+            lines=12,
         )
-        
-        clear_btn.click(lambda: None, None, chatbot, queue=False)
-    
-    return app
 
-# ==================== ЗАПУСК ====================
+        gen_q_btn.click(
+            generate_questions_fn,
+            inputs=[diff_dd, num_slider, state],
+            outputs=[q_out],
+        )
+
+    # --- Вкладка: Чат с документом ---
+    with gr.Tab("Чат с документом"):
+        chatbot = gr.Chatbot(label="Чат по вашему документу")
+        msg = gr.Textbox(
+            label="Ваш вопрос",
+            lines=2,
+            placeholder="Задайте вопрос по загруженному тексту...",
+        )
+        send_btn = gr.Button("Отправить")
+        clear_btn = gr.Button("Очистить чат")
+
+        send_btn.click(
+            chat_answer_fn,
+            inputs=[msg, chatbot, state],
+            outputs=[chatbot, msg],
+        )
+
+        clear_btn.click(
+            clear_chat,
+            inputs=None,
+            outputs=[chatbot, msg],
+        )
+
+
 if __name__ == "__main__":
-    app = create_interface()
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        debug=False
-    )
+    demo.launch()