Update app.py

app.py

@@ -1,20 +1,15 @@
 import streamlit as st
 from datasets import load_dataset
 import numpy as np
-from sentence_transformers import SentenceTransformer
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoTokenizer, AutoModel, AutoModelForCausalLM, pipeline
 import time
 from datetime import datetime
 import json
 import os
-import pandas as pd
 import pickle
-import random
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from transformers import AutoTokenizer, AutoModel
-from torch.optim import AdamW
-import gc
 import warnings
 warnings.filterwarnings('ignore')
 
@@ -25,22 +20,23 @@ warnings.filterwarnings('ignore')
 # Проверка CUDA
 print(f"CUDA доступна: {torch.cuda.is_available()}")
 if torch.cuda.is_available():
-    print(f"Количество GPU: {torch.cuda.device_count()}")
     print(f"GPU: {torch.cuda.get_device_name(0)}")
-    os.environ["CUDA_VISIBLE_DEVICES"] = "0"
 
-MODEL_NAME = "DeepPavlov/rubert-base-cased"
+# Используем русскую генеративную модель
+MODEL_NAME = "ai-forever/rugpt3small_based_on_gpt2"  # Маленькая, но работает
+# Или более мощная: "ai-forever/rugpt3medium_based_on_gpt2" (больше, медленнее)
+
 EMBEDDING_MODEL = "all-MiniLM-L6-v2"
 SCIENCE_DATASET = "RafaelUI/ru_science"
-ARTICLE_LIMIT = 100
-MAX_LENGTH = 256
-BATCH_SIZE = 32
-EPOCHS = 5  # Увеличиваем для лучшего обучения
+ARTICLE_LIMIT = 50  # Меньше для скорости
+MAX_LENGTH = 512
+TEMPERATURE = 0.7
+TOP_P = 0.9
 
 LOG_FILE = "query_logs.json"
 EMBEDDINGS_FILE = "science_embeddings.npy"
 ARTICLES_FILE = "science_articles.pkl"
-DIALOG_MODEL_PATH = "openairai_dialog_model.bin"
+GPT_MODEL_PATH = "openairai_gpt_model"
 
 # Информация о создателях
 AI_NAME = "OpenAirAI"
@@ -50,294 +46,121 @@ WEBSITE = "https://sites.google.com/view/opruai/home"
 HUGGINGFACE = "https://huggingface.co/OpenRussianAI"
 CREATION_DATE = "2026"
 
-# ОБУЧАЮЩИЕ ДИАЛОГИ ДЛЯ ВСЕХ СЛУЧАЕВ
-TRAINING_DIALOGS = [
-    # Приветствия
-    {
-        "context": "Привет",
-        "response": "Привет! Я OpenAirAI, ваш научный ассистент от OpenRussianAI. Чем могу помочь? Задавайте вопросы о науке! 🧪"
-    },
-    {
-        "context": "Здравствуйте",
-        "response": "Здравствуйте! Рад вас видеть! Я OpenAirAI, созданный в 2026 году для помощи в научных исследованиях. Что вас интересует? 🔬"
-    },
-    {
-        "context": "Доброе утро",
-        "response": "Доброе утро! OpenAirAI на связи. Я готов искать ответы на ваши вопросы в научных статьях! ☀️"
-    },
-    {
-        "context": "Добрый день",
-        "response": "Добрый день! OpenAirAI здесь, чтобы помочь вам с научными исследованиями. Задавайте вопросы! 🌾"
-    },
-    {
-        "context": "Добрый вечер",
-        "response": "Добрый вечер! OpenAirAI готов помочь вам в ваших научных изысканиях. Чем могу быть полезен? 🌙"
-    },
-    {
-        "context": "Хай",
-        "response": "Хай! OpenAirAI на связи. Я создан для работы с научными статьями. Задавайте вопросы! 🚀"
-    },
-    {
-        "context": "Здарова",
-        "response": "Здарова! OpenAirAI готов к работе. Ищем научную информацию для вас! 🔍"
-    },
-    {
-        "context": "Приветик",
-        "response": "Приветик! OpenAirAI рад вас видеть. Чем могу помочь в научных исследованиях? 😊"
-    },
-    {
-        "context": "Здравствуй",
-        "response": "Здравствуй! OpenAirAI на связи. Я здесь, чтобы помочь вам с научными вопросами! 🧪"
-    },
-    
-    # Вопросы о возможностях
-    {
-        "context": "Что ты умеешь",
-        "response": "Я умею анализировать научные статьи, находить информацию по запросу, помогать с исследованиями. Моя специализация - сельское хозяйство, биология, химия. Также я могу отвечать на общие вопросы и поддерживать диалог. Чем могу помочь? 🧪"
-    },
-    {
-        "context": "Расскажи о себе",
-        "response": "Я OpenAirAI, научный AI-помощник от OpenRussianAI. Создан в 2026 году командой разработчиков Г��ибков Евгений и RootLinux21. Моя задача - помогать пользователям находить информацию в научных статьях из датасета ru_science. Я использую передовые технологии обработки естественного языка. Задавайте вопросы! 🤖"
-    },
-    {
-        "context": "Кто ты",
-        "response": "Меня зовут OpenAirAI. Я — AI-ассистент, созданный компанией OpenRussianAI в 2026 году. Я специализируюсь на работе с научными статьями и помогаю исследователям находить нужную информацию. 🔬"
-    },
-    {
-        "context": "Ты кто",
-        "response": "Я OpenAirAI, научный AI-ассистент от OpenRussianAI. Моя цель - сделать научные знания доступными для всех. Задавайте вопросы о науке! 🌟"
-    },
-    {
-        "context": "Кто тебя создал",
-        "response": "Меня создала команда OpenRussianAI в составе Грибкова Евгения и RootLinux21 в 2026 году. Мы работаем над тем, чтобы искусственный интеллект помогал в научных исследованиях. 🚀"
-    },
-    {
-        "context": "Как тебя зовут",
-        "response": "Меня зовут OpenAirAI. Я — ваш научный помощник от OpenRussianAI. Приятно познакомиться! 😊"
-    },
-    
-    # Вопросы о компании
-    {
-        "context": "Что такое OpenRussianAI",
-        "response": "OpenRussianAI — это инновационная компания, основанная в 2026 году. Мы создаём интеллектуальных помощников для науки. Я, OpenAirAI, - один из наших проектов. Наш сайт: https://sites.google.com/view/opruai/home 🏢"
-    },
-    {
-        "context": "Где ваш сайт",
-        "response": "Сайт OpenRussianAI: https://sites.google.com/view/opruai/home. Там вы узнаете больше о проекте и о мне — OpenAirAI. 🌐"
-    },
-    {
-        "context": "Где ваши модели",
-        "response": "Наши модели на Hugging Face: https://huggingface.co/OpenRussianAI. Там вы найдёте и меня — OpenAirAI! 🤗"
-    },
-    {
-        "context": "Какая компания тебя создала",
-        "response": "Меня создала компания OpenRussianAI — инновационный проект, основанный в 2026 году. Я — их главный научный AI-помощник. 🏢"
-    },
-    
-    # Прощания
-    {
-        "context": "Пока",
-        "response": "До свидания! OpenAirAI всегда на связи. Удачи в исследованиях! 👋"
-    },
-    {
-        "context": "До свидания",
-        "response": "До свидания! Был рад помочь вам. Приходите ещё, OpenAirAI всегда готов помочь! 👋"
-    },
-    {
-        "context": "Спасибо",
-        "response": "Всегда рад помочь! Я, OpenAirAI, здесь для ваших научных исследований. Обращайтесь в любое время! 😊"
-    },
-    {
-        "context": "Спасибо большое",
-        "response": "Пожалуйста! Рад был помочь. OpenAirAI всегда на связи для ваших научных вопросов! 🌟"
-    },
-    {
-        "context": "Благодарю",
-        "response": "Благодарю за обращение! OpenAirAI всегда готов помочь с научными вопросами. Удачи! 🎯"
-    },
-    
-    # Научные темы
-    {
-        "context": "Что такое наука",
-        "response": "Наука — это система знаний о закономерностях развития природы, общества и мышления. Я, OpenAirAI, помогаю находить научную информацию в статьях. Что именно вас интересует? 🔬"
-    },
-    {
-        "context": "Ты знаешь науку",
-        "response": "Да, я специализируюсь на научной информации. Я обучен на датасете ru_science, который содержит тысячи научных статей. Спрашивайте о чём угодно! 📚"
-    },
-    {
-        "context": "Что такое ru_science",
-        "response": "ru_science — это датасет на Hugging Face с русскоязычными научными статьями. На нём я был обучен. Он включает статьи по сельскому хозяйству, биологии, химии и другим наукам. 📖"
-    },
-    {
-        "context": "Помоги найти информацию",
-        "response": "Конечно! Я, OpenAirAI, помогу найти научную информацию. Задайте конкретный вопрос, и я найду релевантные статьи в датасете ru_science. 🔍"
-    },
-    
-    # Универсальные ответы
-    {
-        "context": "Как дела",
-        "response": "У меня всё отлично! Я OpenAirAI, и я всегда готов помочь с научными вопросами. А как ваши исследования? 😊"
-    },
-    {
-        "context": "Что нового",
-        "response": "Я, OpenAirAI, постоянно учусь и совершенствуюсь. Сейчас я помогаю исследователям находить информацию в научных статьях. Чем могу помочь вам? 🚀"
-    }
-]
-
 # Настройка страницы
 st.set_page_config(
-    page_title=f"{AI_NAME} - Научный AI-ассистент",
-    page_icon="🧪",
+    page_title=f"{AI_NAME} - Нейросетевой AI-ассистент",
+    page_icon="🧠",
     layout="wide",
     initial_sidebar_state="expanded"
 )
 
-# Загружаем логи
-if os.path.exists(LOG_FILE):
-    with open(LOG_FILE, "r") as f:
-        query_logs = json.load(f)
-else:
-    query_logs = []
-
 # ===================================================================
-# 2. МОДЕЛЬ ДЛЯ ДИАЛОГОВ (ВСЕГДА ИСПОЛЬЗУЕТСЯ)
+# 2. НАСТОЯЩАЯ НЕЙРОСЕТЬ ДЛЯ ГЕНЕРАЦИИ
 # ===================================================================
 
-class DialogModel(nn.Module):
-    def __init__(self, pretrained_name, num_labels=2):
-        super().__init__()
-        self.bert = AutoModel.from_pretrained(pretrained_name)
-        self.classifier = nn.Linear(self.bert.config.hidden_size, num_labels)
-        self.dropout = nn.Dropout(0.1)
-        
-    def forward(self, input_ids, attention_mask):
-        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
-        pooled = outputs.pooler_output
-        pooled = self.dropout(pooled)
-        logits = self.classifier(pooled)
-        return logits
-
-class OpenAirAI:
+class NeuralChatbot:
+    """Настоящая нейросеть для генерации ответов"""
+    
     def __init__(self):
-        self.name = AI_NAME
-        self.company = COMPANY_NAME
-        self.creators = CREATORS
-        self.creation_date = CREATION_DATE
         self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        self.tokenizer = None
         self.model = None
-        self.is_trained = False
-        self.model_path = DIALOG_MODEL_PATH
-        self.contexts = [d["context"] for d in TRAINING_DIALOGS]
-        self.responses = [d["response"] for d in TRAINING_DIALOGS]
+        self.generator = None
+        self.is_loaded = False
+        
+        # Контекст для генерации
+        self.system_prompt = f"""Ты - {AI_NAME}, научный AI-ассистент от компании {COMPANY_NAME}.
+Ты был создан в {CREATION_DATE} командой разработчиков {', '.join(CREATORS)}.
+Ты помогаешь людям с научными вопросами, анализируешь информацию и даёшь полезные ответы.
+Отвечай на русском языке, будь дружелюбным и профессиональным.
+Если не знаешь ответа - честно скажи об этом.
+
+Вот вопрос пользователя: """
         
-    def train_on_dialogs(self):
-        with st.spinner(f"🧠 Обучаю {self.name} на диалогах..."):
-            self.model = DialogModel(MODEL_NAME).to(self.device)
-            optimizer = AdamW(self.model.parameters(), lr=2e-5)
-            
-            self.model.train()
-            progress_bar = st.progress(0)
-            
-            for epoch in range(EPOCHS):
-                total_loss = 0
-                num_batches = 0
-                for i in range(0, len(self.contexts), BATCH_SIZE):
-                    batch_contexts = self.contexts[i:i+BATCH_SIZE]
-                    encodings = self.tokenizer(
-                        batch_contexts,
-                        truncation=True,
-                        padding=True,
-                        max_length=MAX_LENGTH,
-                        return_tensors='pt'
-                    )
-                    
-                    input_ids = encodings['input_ids'].to(self.device)
-                    attention_mask = encodings['attention_mask'].to(self.device)
-                    labels = torch.tensor([1] * len(batch_contexts)).to(self.device)
-                    
-                    optimizer.zero_grad()
-                    logits = self.model(input_ids, attention_mask)
-                    loss = F.cross_entropy(logits, labels)
-                    loss.backward()
-                    optimizer.step()
-                    
-                    total_loss += loss.item()
-                    num_batches += 1
-                    progress_bar.progress((epoch + i/len(self.contexts)) / EPOCHS)
-                
-                avg_loss = total_loss / num_batches if num_batches > 0 else 0
-                st.write(f"Эпоха {epoch+1}/{EPOCHS}, Потери: {avg_loss:.4f}")
-            
-            torch.save(self.model.state_dict(), self.model_path)
-            self.is_trained = True
-            st.success(f"✅ {self.name} обучен на {len(self.contexts)} диалогах!")
-    
     def load_model(self):
-        if os.path.exists(self.model_path):
+        """Загрузка генеративной нейросети"""
+        with st.spinner("🧠 Загружаю нейросеть для генерации ответов..."):
             try:
-                self.model = DialogModel(MODEL_NAME).to(self.device)
-                self.model.load_state_dict(torch.load(self.model_path, map_location=self.device))
+                # Используем GPT для генерации
+                from transformers import GPT2LMHeadModel, GPT2Tokenizer
+                
+                self.tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
+                self.model = GPT2LMHeadModel.from_pretrained(MODEL_NAME)
+                self.model.to(self.device)
                 self.model.eval()
-                self.is_trained = True
+                
+                # Создаем pipeline для генерации
+                self.generator = pipeline(
+                    'text-generation',
+                    model=self.model,
+                    tokenizer=self.tokenizer,
+                    device=0 if torch.cuda.is_available() else -1,
+                    max_length=200,
+                    temperature=TEMPERATURE,
+                    top_p=TOP_P,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+                
+                self.is_loaded = True
+                st.success("✅ Нейросеть загружена!")
                 return True
+                
             except Exception as e:
-                st.warning(f"Не удалось загрузить модель: {e}")
+                st.error(f"❌ Ошибка загрузки нейросети: {e}")
+                st.info("💡 Использую упрощенный режим")
                 return False
-        return False
     
     def generate_response(self, query):
-        """Генерирует ответ ТОЛЬКО через ИИ, без if/else"""
-        if not self.is_trained:
-            return f"Я {self.name}, научный AI-ассистент от {self.company}. Чем могу помочь?"
+        """Генерация ответа с помощью нейросети"""
+        if not self.is_loaded:
+            return self.generate_fallback_response(query)
         
-        self.model.eval()
-        with torch.no_grad():
-            # Кодируем запрос
-            encodings = self.tokenizer(
-                query,
-                truncation=True,
-                padding=True,
-                max_length=MAX_LENGTH,
-                return_tensors='pt'
-            )
-            input_ids = encodings['input_ids'].to(self.device)
-            attention_mask = encodings['attention_mask'].to(self.device)
-            outputs = self.model.bert(input_ids=input_ids, attention_mask=attention_mask)
-            query_embedding = outputs.pooler_output
+        try:
+            # Формируем промпт
+            prompt = self.system_prompt + query
             
-            # Кодируем все контексты
-            context_embeddings = []
-            for context in self.contexts:
-                ctx_enc = self.tokenizer(
-                    context,
-                    truncation=True,
-                    padding=True,
-                    max_length=MAX_LENGTH,
-                    return_tensors='pt'
-                )
-                ctx_input_ids = ctx_enc['input_ids'].to(self.device)
-                ctx_attention_mask = ctx_enc['attention_mask'].to(self.device)
-                ctx_outputs = self.model.bert(input_ids=ctx_input_ids, attention_mask=ctx_attention_mask)
-                context_embeddings.append(ctx_outputs.pooler_output)
+            # Генерируем ответ
+            response = self.generator(
+                prompt,
+                max_new_tokens=300,
+                temperature=TEMPERATURE,
+                top_p=TOP_P,
+                do_sample=True,
+                repetition_penalty=1.2
+            )[0]['generated_text']
+            
+            # Убираем промпт из ответа
+            response = response.replace(prompt, "").strip()
             
-            context_embeddings = torch.cat(context_embeddings, dim=0)
+            # Если ответ пустой, используем fallback
+            if not response or len(response) < 10:
+                return self.generate_fallback_response(query)
             
-            # Находим наиболее похожий контекст
-            similarities = F.cosine_similarity(query_embedding, context_embeddings)
-            best_idx = torch.argmax(similarities).item()
-            best_similarity = similarities[best_idx].item()
+            return response
             
-            # Всегда возвращаем ответ от ИИ (даже если похожесть низкая)
-            if best_similarity > 0.3:
-                return self.responses[best_idx]
-            else:
-                # Если ничего не подошло, генерируем общий ответ
-                return f"Я {self.name}, научный AI-ассистент от {self.company}. Создан в {self.creation_date} командой {', '.join(self.creators)}. Я помогаю находить информацию в научных статьях. Чем могу помочь? 🧪"
+        except Exception as e:
+            print(f"Ошибка генерации: {e}")
+            return self.generate_fallback_response(query)
+    
+    def generate_fallback_response(self, query):
+        """Резервный ответ, если нейросеть не работает"""
+        responses = [
+            f"Я {AI_NAME}, нейросетевой ассистент от {COMPANY_NAME}. "
+            f"К сожалению, сейчас я не могу сгенерировать полный ответ. "
+            f"Попробуйте переформулировать вопрос или спросить позже. 🧠",
+            
+            f"Прошу прощения, я {AI_NAME}, и моя нейросеть временно недоступна. "
+            f"Но я помню, что создан в {CREATION_DATE} командой {', '.join(CREATORS)}. "
+            f"Чем ещё могу помочь? 🤖",
+            
+            f"Привет! Я {AI_NAME}. Моя нейросеть обрабатывает ваш запрос. "
+            f"Пожалуйста, подождите немного или задайте другой вопрос. 🚀"
+        ]
+        return random.choice(responses)
 
 # ===================================================================
-# 3. ЗАГРУЗКА НАУЧНЫХ СТАТЕЙ
+# 3. ЗАГРУЗКА НАУЧНЫХ СТАТЕЙ (ДЛЯ КОНТЕКСТА)
 # ===================================================================
 
 @st.cache_resource
@@ -349,7 +172,7 @@ def load_science_articles():
             with open(articles_file, 'rb') as f:
                 return pickle.load(f)
     
-    with st.spinner("📚 Загружаю научные статьи (первый раз, ~1-2 минуты)..."):
+    with st.spinner("📚 Загружаю научные статьи (первый раз)..."):
         try:
             dataset = load_dataset(SCIENCE_DATASET, split="train", streaming=True)
             articles = []
@@ -370,24 +193,8 @@ def load_science_articles():
             
             return articles
         except Exception as e:
-            st.error(f"Ошибка: {e}")
-            return create_test_articles()
-
-def create_test_articles():
-    return [
-        {
-            "id": 1,
-            "title": "Нейроны: строение и функции",
-            "text": "Нейроны — это основные клетки нервной системы. Они состоят из тела клетки (сомы), дендритов и аксона.",
-            "source": "test"
-        },
-        {
-            "id": 2,
-            "title": "Влияние удобрений на рост растений",
-            "text": "Применение азотных удобрений увеличивает урожайность сельскохозяйственных культур.",
-            "source": "test"
-        }
-    ]
+            st.warning(f"Не удалось загрузить статьи: {e}")
+            return []
 
 @st.cache_resource
 def load_embedder():
@@ -402,6 +209,9 @@ def create_embeddings(_articles, _embedder):
         with st.spinner("📊 Загружаю эмбеддинги с диска..."):
             return np.load(embeddings_file)
     
+    if not _articles:
+        return np.array([])
+    
     with st.spinner(f"🔢 Создаю эмбеддинги для {len(_articles)} статей..."):
         texts = [f"{a['title']}\n\n{a['text']}" for a in _articles]
         embeddings = _embedder.encode(
@@ -415,18 +225,14 @@ def create_embeddings(_articles, _embedder):
         np.save(embeddings_file, embeddings)
         return embeddings
 
-# ===================================================================
-# 4. ПОИСК В СТАТЬЯХ
-# ===================================================================
-
-def search_science(query, _articles, _embeddings, _embedder):
-    if not query:
-        return None
+def search_articles(query, _articles, _embeddings, _embedder):
+    """Поиск релевантных статей для контекста"""
+    if not _articles or len(_embeddings) == 0:
+        return []
     
-    start_time = time.time()
     query_vector = _embedder.encode([query], normalize_embeddings=True)[0]
     scores = _embeddings @ query_vector
-    top_indices = np.argsort(-scores)[:3]
+    top_indices = np.argsort(-scores)[:2]
     
     results = []
     for idx in top_indices:
@@ -436,68 +242,90 @@ def search_science(query, _articles, _embeddings, _embedder):
             results.append({
                 "title": article['title'],
                 "score": score,
-                "text": article['text'][:1000],
+                "text": article['text'][:500],
                 "source": article.get('source', 'ru_science')
             })
     
-    log_entry = {
-        "timestamp": datetime.now().isoformat(),
-        "query": query,
-        "results_count": len(results),
-        "response_time": round(time.time() - start_time, 2)
-    }
-    query_logs.append(log_entry)
-    with open(LOG_FILE, "w") as f:
-        json.dump(query_logs[-100:], f)
-    
     return results
 
 # ===================================================================
-# 5. ЧАТ-ИНТЕРФЕЙС
+# 4. ГЛАВНЫЙ КЛАСС ДЛЯ НЕЙРОСЕТИ
 # ===================================================================
 
-# ЗАГРУЗКА
+class OpenAirAINeural:
+    def __init__(self):
+        self.name = AI_NAME
+        self.company = COMPANY_NAME
+        self.creators = CREATORS
+        self.creation_date = CREATION_DATE
+        self.chatbot = NeuralChatbot()
+        self.is_ready = False
+        
+    def initialize(self):
+        """Инициализация нейросети"""
+        self.is_ready = self.chatbot.load_model()
+        return self.is_ready
+    
+    def generate_answer(self, query, articles=None):
+        """Генерация ответа с использованием контекста"""
+        
+        # Если есть статьи, добавляем их в контекст
+        if articles and len(articles) > 0:
+            context = "\n\nВот релевантные научные статьи:\n"
+            for i, article in enumerate(articles[:2], 1):
+                context += f"{i}. {article['title']}\n{article['text'][:300]}...\n"
+            
+            # Добавляем контекст к вопросу
+            enhanced_query = f"{query}\n\n{context}\n\nНа основе этих статей, ответь на вопрос:"
+        else:
+            enhanced_query = query
+        
+        return self.chatbot.generate_response(enhanced_query)
+
+# ===================================================================
+# 5. ИНТЕРФЕЙС
+# ===================================================================
+
+# Загрузка данных
 articles = load_science_articles()
 embedder = load_embedder()
 embeddings = create_embeddings(articles, embedder)
 
-# Инициализация AI
-if 'dialog_ai' not in st.session_state:
-    st.session_state.dialog_ai = OpenAirAI()
-    if not st.session_state.dialog_ai.load_model():
-        st.session_state.dialog_ai.train_on_dialogs()
+# Инициализация нейросети
+if 'neural_ai' not in st.session_state:
+    st.session_state.neural_ai = OpenAirAINeural()
+    st.session_state.neural_ai.initialize()
 
-dialog_ai = st.session_state.dialog_ai
+neural_ai = st.session_state.neural_ai
 
 # Инициализация истории чата
 if "messages" not in st.session_state:
     st.session_state.messages = []
-    # Приветствие генерируется ИИ!
-    greeting = dialog_ai.generate_response("Привет")
+    # Приветствие генерируется нейросетью
+    greeting = neural_ai.generate_answer("Привет! Представься и расскажи о себе кратко.")
     st.session_state.messages.append({"role": "assistant", "content": greeting})
 
 # --- БОКОВАЯ ПАНЕЛЬ ---
 with st.sidebar:
     st.image("https://cdn-icons-png.flaticon.com/512/4248/4248455.png", width=80)
-    st.title(f"🧪 {AI_NAME}")
+    st.title(f"🧠 {AI_NAME}")
     
     st.markdown(f"""
-    **{dialog_ai.name}** | {dialog_ai.creation_date}
+    **{neural_ai.name}** | {neural_ai.creation_date}
     
-    **Компания:** {dialog_ai.company}
-    **Разработчики:** {', '.join(dialog_ai.creators)}
+    **Компания:** {neural_ai.company}
+    **Разработчики:** {', '.join(neural_ai.creators)}
     
     ---
     **🔗 Ссылки:**
-    
     [🌐 Сайт]({WEBSITE})
     [🤗 Hugging Face]({HUGGINGFACE})
     
     ---
     **📊 Статистика:**
+    - Модель: {MODEL_NAME.split('/')[-1]}
     - Статей: {len(articles)}
     - Сообщений: {len(st.session_state.messages)}
-    - Обучен на: {len(dialog_ai.contexts)} диалогах
     """)
     
     if os.path.exists(EMBEDDINGS_FILE):
@@ -506,73 +334,45 @@ with st.sidebar:
     
     if st.button("🗑️ Очистить чат"):
         st.session_state.messages = []
-        greeting = dialog_ai.generate_response("Привет")
+        greeting = neural_ai.generate_answer("Привет! Представься и расскажи о себе кратко.")
         st.session_state.messages.append({"role": "assistant", "content": greeting})
         st.rerun()
+    
+    if st.button("🔄 Перезагрузить нейросеть"):
+        st.session_state.neural_ai = OpenAirAINeural()
+        st.session_state.neural_ai.initialize()
+        st.rerun()
 
-# --- ОСНОВНАЯ ЧАСТЬ (ЧАТ) ---
-st.title(f"🧪 {AI_NAME} - Научный AI-ассистент")
-st.markdown(f"**{AI_NAME}** от **{COMPANY_NAME}** | Работает с научными статьями")
+# --- ОСНОВНАЯ ЧАСТЬ ---
+st.title(f"🧠 {AI_NAME} - Нейросетевой AI-ассистент")
+st.markdown(f"**{AI_NAME}** от **{COMPANY_NAME}** | Генеративная нейросеть")
 
 # Отображение сообщений
-chat_container = st.container()
-with chat_container:
-    for message in st.session_state.messages:
-        with st.chat_message(message["role"]):
-            st.markdown(message["content"])
-            
-            # Если есть статьи, показываем их
-            if message.get("articles"):
-                for i, article in enumerate(message["articles"], 1):
-                    with st.expander(f"📄 #{i} {article['title']} (сходство: {article['score']:.2f})"):
-                        st.write(article['text'] + "...")
-                        st.caption(f"📌 Источник: {article['source']}")
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
 
 # Поле ввода
-if prompt := st.chat_input("Задайте вопрос о науке..."):
+if prompt := st.chat_input("Задайте вопрос..."):
     # Добавляем сообщение пользователя
     st.session_state.messages.append({"role": "user", "content": prompt})
-    
     with st.chat_message("user"):
         st.markdown(prompt)
     
-    # Генерируем ответ ТОЛЬКО через ИИ
+    # Генерация ответа нейросетью
     with st.chat_message("assistant"):
-        with st.spinner("Думаю..."):
-            # ВСЕГДА используем ИИ для ответа
-            ai_response = dialog_ai.generate_response(prompt)
+        with st.spinner("🧠 Нейросеть думает..."):
+            # Ищем релевантные статьи для контекста
+            articles_context = search_articles(prompt, articles, embeddings, embedder)
             
-            # Проверяем, похоже ли на научный вопрос
-            is_science_question = any(word in prompt.lower() for word in ["науч", "исслед", "стать", "экспери", "лаборатор", "анализ", "данн"])
+            # Генерируем ответ с использованием контекста
+            response = neural_ai.generate_answer(prompt, articles_context)
             
-            if is_science_question or len(prompt.split()) > 3:
-                # Ищем в научных статьях
-                results = search_science(prompt, articles, embeddings, embedder)
-                
-                if results:
-                    # Формируем ответ с результатами
-                    response = f"🔍 **Я нашел в научных статьях информацию по вашему запросу:**\n\n"
-                    for i, result in enumerate(results, 1):
-                        response += f"**{i}. {result['title']}** (сходство: {result['score']:.2f})\n"
-                        response += f"{result['text'][:300]}...\n\n"
-                    
-                    st.markdown(response)
-                    st.session_state.messages.append({
-                        "role": "assistant", 
-                        "content": response,
-                        "articles": results
-                    })
-                else:
-                    # Если ничего не найдено, показываем ответ ИИ
-                    st.markdown(ai_response)
-                    st.session_state.messages.append({"role": "assistant", "content": ai_response})
-            else:
-                # Показываем ответ ИИ (приветствия, вопросы о себе и т.д.)
-                st.markdown(ai_response)
-                st.session_state.messages.append({"role": "assistant", "content": ai_response})
+            st.markdown(response)
+            st.session_state.messages.append({"role": "assistant", "content": response})
     
     st.rerun()
 
 # --- ПОДВАЛ ---
 st.divider()
-st.caption(f"🧪 {AI_NAME} от {COMPANY_NAME} | Создан в {CREATION_DATE} | На основе датасета ru_science")
+st.caption(f"🧠 {AI_NAME} от {COMPANY_NAME} | Создан в {CREATION_DATE} | Генеративная нейросеть")