Update app.py

app.py

@@ -1,231 +1,238 @@
 #!/usr/bin/env python3
 """
-HuggingFace Spaces приложение для RAG системы анализа отчета Сбера 2023
+Демо RAG система для HuggingFace Spaces
+Использует предварительно обработанные чанки отчета Сбера
+Оптимизирована для быстрого запуска без тяжелых зависимостей
 """
 
 import os
 import sys
+import json
+import pickle
 import tempfile
-import base64
-from io import BytesIO
 from pathlib import Path
 from typing import Optional, Dict, Any, List, Tuple
+import traceback
+import re
+
 import gradio as gr
-import openai
-import pandas as pd
 import numpy as np
-from PIL import Image
-
-# Конфигурация
-class Config:
-    """Конфигурация для HuggingFace Spaces"""
-    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
-    GENERATION_MODEL = "gpt-4o"
-    RERANKING_MODEL = "gpt-4o-mini"
-    EMBEDDING_MODEL = "text-embedding-3-large"
-    MAX_CHARACTERS = 4000
-    CHUNK_OVERLAP = 200
-    RETRIEVAL_K = 5
-    RERANKING_K = 3
 
-config = Config()
+# OpenAI для генерации ответов
+from openai import OpenAI
 
-class SimpleRAGSystem:
-    """Упрощенная RAG система для HuggingFace Spaces"""
+class LightweightRAGSystem:
+    """Легковесная RAG система с предзагруженными чанками"""
     
     def __init__(self):
+        self.chunks = []
+        self.word_index = {}
+        self.metadata = {}
         self.client = None
-        self.documents = []
-        self.embeddings = []
         self.is_initialized = False
         
-    def initialize_openai(self, api_key: str) -> bool:
-        """Инициализация OpenAI клиента"""
-        try:
-            if not api_key:
-                return False
-            self.client = openai.OpenAI(api_key=api_key)
-            # Тестовый запрос
-            test_response = self.client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[{"role": "user", "content": "Test"}],
-                max_tokens=1
-            )
-            return True
-        except Exception as e:
-            print(f"Ошибка инициализации OpenAI: {e}")
-            return False
+        # Конфигурация
+        self.generation_model = "gpt-4o"
+        self.reranking_model = "gpt-4o-mini"
+        self.max_chunks_for_rerank = 15
+        self.final_chunks_count = 5
     
-    def extract_text_from_pdf(self, pdf_file) -> List[str]:
-        """Извлечение текста из PDF (упрощенная версия)"""
+    def load_preprocessed_data(self) -> bool:
+        """Загрузка предварительно обработанных данных"""
         try:
-            import pypdf
-            
-            reader = pypdf.PdfReader(pdf_file)
-            texts = []
-            
-            for page_num, page in enumerate(reader.pages):
-                text = page.extract_text()
-                if text.strip():
-                    # Простое разбиение на чанки
-                    chunks = self.split_text(text, config.MAX_CHARACTERS)
-                    for i, chunk in enumerate(chunks):
-                        texts.append({
-                            'content': chunk,
-                            'page': page_num + 1,
-                            'chunk': i + 1,
-                            'type': 'text'
-                        })
-            
-            return texts
+            print("🔄 Загрузка предварительно обработанных данных...")
             
-        except Exception as e:
-            print(f"Ошибка обработки PDF: {e}")
-            return []
-    
-    def split_text(self, text: str, max_size: int) -> List[str]:
-        """Простое разбиение текста на чанки"""
-        words = text.split()
-        chunks = []
-        current_chunk = []
-        current_size = 0
-        
-        for word in words:
-            if current_size + len(word) + 1 > max_size and current_chunk:
-                chunks.append(' '.join(current_chunk))
-                current_chunk = [word]
-                current_size = len(word)
-            else:
-                current_chunk.append(word)
-                current_size += len(word) + 1
-        
-        if current_chunk:
-            chunks.append(' '.join(current_chunk))
-        
-        return chunks
-    
-    def create_embeddings(self, texts: List[Dict]) -> bool:
-        """Создание эмбеддингов для текстов"""
-        try:
-            if not self.client:
+            # Загружаем улучшенный индекс с таблицами
+            index_file = "enhanced_sber_index.pkl"
+            if not os.path.exists(index_file):
+                print(f"❌ Файл индекса не найден: {index_file}")
                 return False
             
-            contents = [doc['content'] for doc in texts]
+            with open(index_file, 'rb') as f:
+                index_data = pickle.load(f)
             
-            # Создаем эмбеддинги батчами
-            batch_size = 100
-            all_embeddings = []
+            self.chunks = index_data["chunks"]
+            self.word_index = index_data["word_index"]
+            self.metadata = index_data["metadata"]
             
-            for i in range(0, len(contents), batch_size):
-                batch = contents[i:i + batch_size]
-                response = self.client.embeddings.create(
-                    model=config.EMBEDDING_MODEL,
-                    input=batch
-                )
-                batch_embeddings = [item.embedding for item in response.data]
-                all_embeddings.extend(batch_embeddings)
-            
-            self.documents = texts
-            self.embeddings = np.array(all_embeddings)
-            self.is_initialized = True
+            print(f"✅ Загружено {len(self.chunks)} чанков")
+            print(f"✅ Создан словарный индекс из {len(self.word_index)} слов")
             
             return True
             
         except Exception as e:
-            print(f"Ошибка создания эмбеддингов: {e}")
+            print(f"❌ Ошибка загрузки данных: {e}")
+            traceback.print_exc()
             return False
     
-    def search_documents(self, query: str, k: int = 5) -> List[Dict]:
-        """Поиск релевантных документов"""
+    def initialize_with_api_key(self, api_key: str) -> Tuple[str, str]:
+        """Инициализация системы с API ключом"""
         try:
-            if not self.is_initialized or not self.client:
-                return []
+            if not api_key.strip():
+                return "❌ Введите OpenAI API ключ", ""
             
-            # Создаем эмбеддинг для запроса
-            query_response = self.client.embeddings.create(
-                model=config.EMBEDDING_MODEL,
-                input=[query]
-            )
-            query_embedding = np.array(query_response.data[0].embedding)
+            # Инициализация OpenAI клиента
+            self.client = OpenAI(api_key=api_key.strip())
             
-            # Вычисляем косинусное сходство
-            similarities = np.dot(self.embeddings, query_embedding) / (
-                np.linalg.norm(self.embeddings, axis=1) * np.linalg.norm(query_embedding)
-            )
+            # Загрузка данных
+            if not self.load_preprocessed_data():
+                return "❌ Ошибка загрузки данных", ""
             
-            # Получаем топ-k результатов
-            top_indices = np.argsort(similarities)[-k:][::-1]
+            self.is_initialized = True
             
-            results = []
-            for idx in top_indices:
-                doc = self.documents[idx].copy()
-                doc['similarity'] = float(similarities[idx])
-                results.append(doc)
+            # Генерация статистики
+            stats = self._generate_stats()
             
-            return results
+            return "✅ Система инициализирована успешно", stats
             
         except Exception as e:
-            print(f"Ошибка поиска: {e}")
+            return f"❌ Ошибка инициализации: {str(e)}", ""
+    
+    def _generate_stats(self) -> str:
+        """Генерация статистики системы"""
+        total_chunks = self.metadata.get("total_chunks", 0)
+        avg_length = self.metadata.get("avg_chunk_length", 0)
+        avg_tokens = self.metadata.get("avg_token_count", 0)
+        pages = self.metadata.get("pages_processed", 0)
+        
+        # Добавим информацию о таблицах
+        text_chunks = self.metadata.get("text_chunks", 0)
+        table_chunks = self.metadata.get("table_chunks", 0)
+        table_pages = self.metadata.get("table_pages", 0)
+        
+        stats = f"""✅ **Улучшенная система готова к работе!**
+
+📊 **Статистика:**
+- 📦 Загружено чанков: {total_chunks}
+- 📝 Текстовых чанков: {text_chunks}
+- 📋 Табличных чанков: {table_chunks}
+- 📏 Средняя длина чанка: {avg_length:.0f} символов
+- 🔢 Средний размер: {avg_tokens:.0f} токенов
+- 📖 Страниц отчета: {pages}
+- 📊 Страниц с таблицами: {table_pages}
+
+🔍 **Возможности:**
+- 🔎 Быстрый поиск по ключевым словам
+- 📋 Извлечение структурированных таблиц
+- 🧠 LLM реранкинг результатов (GPT-4o-mini)
+- 📝 Интеллектуальная генерация ответов (GPT-4o)
+- 📊 Анализ годового отчета ПАО Сбербанк 2023
+
+🚀 **Готова отвечать на вопросы с поддержкой таблиц!**"""
+        
+        return stats
+    
+    def search_by_keywords(self, query: str, max_results: int = 30) -> List[Dict]:
+        """Поиск по ключевым словам"""
+        if not query.strip():
             return []
+        
+        # Извлекаем ключевые слова из запроса
+        query_words = set(re.findall(r'\b\w+\b', query.lower()))
+        
+        # Находим чанки, содержащие эти слова
+        chunk_scores = {}
+        
+        for word in query_words:
+            if word in self.word_index:
+                for chunk_idx in self.word_index[word]:
+                    if chunk_idx not in chunk_scores:
+                        chunk_scores[chunk_idx] = 0
+                    chunk_scores[chunk_idx] += 1
+        
+        # Сортируем по количеству совпадений
+        sorted_chunks = sorted(chunk_scores.items(), key=lambda x: x[1], reverse=True)
+        
+        # Возвращаем результаты
+        results = []
+        for chunk_idx, score in sorted_chunks[:max_results]:
+            if chunk_idx < len(self.chunks):
+                chunk = self.chunks[chunk_idx].copy()
+                chunk["keyword_score"] = score
+                chunk["similarity"] = score / len(query_words)  # Нормализованный score
+                results.append(chunk)
+        
+        return results
     
-    def rerank_documents(self, query: str, documents: List[Dict]) -> List[Dict]:
-        """Реранкинг документов с помощью LLM"""
+    def rerank_with_llm(self, query: str, chunks: List[Dict]) -> List[Dict]:
+        """LLM реранкинг результатов"""
+        if not chunks or not self.client:
+            return chunks
+        
         try:
-            if not documents or not self.client:
-                return documents
+            # Ограничиваем количество чанков для реранкинга
+            chunks_to_rerank = chunks[:self.max_chunks_for_rerank]
             
-            # Формируем промпт для реранкинга
+            # Подготавливаем документы для реранкинга
             docs_text = ""
-            for i, doc in enumerate(documents):
-                docs_text += f"\nДокумент {i+1}:\n{doc['content'][:500]}...\n"
+            for i, chunk in enumerate(chunks_to_rerank):
+                preview = chunk['text'][:300] + "..." if len(chunk['text']) > 300 else chunk['text']
+                docs_text += f"\nДокумент {i+1} (стр. {chunk['page']}):\n{preview}\n"
             
-            prompt = f"""
-Вопрос пользователя: {query}
+            prompt = f"""Оцени релевантность каждого документа для ответа на вопрос по шкале 1-10.
 
-Документы для анализа:{docs_text}
+Вопрос: {query}
 
-Оцени релевантность каждого документа для ответа на вопрос по шкале 1-10.
-Верни только список чисел через запятую (например: 8,6,9,4,7).
-"""
+Документы:{docs_text}
+
+Инструкции:
+1. Оценивай точность и полноту информации для ответа
+2. Высшие баллы (8-10) - прямой ответ на вопрос
+3. Средние баллы (5-7) - частично релевантная информация
+4. Низкие баллы (1-4) - слабо связано с вопросом
+
+Верни только числа через запятую (например: 8,6,9,4,7):"""
             
             response = self.client.chat.completions.create(
-                model=config.RERANKING_MODEL,
+                model=self.reranking_model,
                 messages=[{"role": "user", "content": prompt}],
-                max_tokens=50,
+                max_tokens=100,
                 temperature=0
             )
             
             # Парсим оценки
             scores_text = response.choices[0].message.content.strip()
-            scores = [float(s.strip()) for s in scores_text.split(',')]
-            
-            # Добавляем оценки и сортируем
-            for i, doc in enumerate(documents):
+            scores = []
+            
+            numbers = re.findall(r'\d+\.?\d*', scores_text)
+            for num in numbers:
+                score = float(num)
+                score = max(0, min(10, score))  # Ограничиваем 0-10
+                scores.append(score)
+            
+            # Применяем оценки
+            reranked = []
+            for i, chunk in enumerate(chunks):
+                chunk_copy = chunk.copy()
                 if i < len(scores):
-                    doc['rerank_score'] = scores[i]
+                    chunk_copy["rerank_score"] = scores[i]
                 else:
-                    doc['rerank_score'] = 0
+                    chunk_copy["rerank_score"] = 0
+                reranked.append(chunk_copy)
+            
+            # Сортируем по реранк скору
+            reranked.sort(key=lambda x: x["rerank_score"], reverse=True)
             
-            return sorted(documents, key=lambda x: x['rerank_score'], reverse=True)
+            return reranked
             
         except Exception as e:
-            print(f"Ошибка реранкинга: {e}")
-            return documents
+            print(f"❌ Ошибка реранкинга: {e}")
+            return chunks
     
-    def generate_answer(self, query: str, context_docs: List[Dict]) -> str:
+    def generate_answer(self, query: str, context_chunks: List[Dict]) -> str:
         """Генерация ответа на основе контекста"""
+        if not self.client:
+            return "❌ OpenAI API не настроен"
+        
         try:
-            if not self.client:
-                return "Ошибка: OpenAI API не инициализирован"
+            # Подготавливаем контекст
+            context_parts = []
+            for i, chunk in enumerate(context_chunks[:self.final_chunks_count]):
+                context_parts.append(f"Фрагмент {i+1} (страница {chunk['page']}):\n{chunk['text']}")
             
-            # Формируем контекст
-            context = ""
-            for doc in context_docs[:config.RERANKING_K]:
-                context += f"\nСтраница {doc['page']}: {doc['content']}\n"
+            context = "\n\n".join(context_parts)
             
-            # Промпт для генерации ответа
-            prompt = f"""
-Ты - эксперт по анализу финансовых отчетов. Ответь на вопрос пользователя на основе предоставленной информации из годового отчета ПАО Сбербанк 2023.
+            prompt = f"""Ты - эксперт по анализу финансовых отчетов. Ответь на вопрос пользователя на основе предоставленного контекста из годового отчета ПАО Сбербанк 2023.
 
 ВОПРОС: {query}
 
@@ -234,262 +241,210 @@ class SimpleRAGSystem:
 
 ИНСТРУКЦИИ:
 1. Отвечай только на основе предоставленной информации
-2. Если информации недостаточно, честно скажи об этом
+2. Если информации недостаточно, честно об этом скажи
 3. Используй конкретные данные и цифры из отчета
-4. Отвечай на русском языке
-5. Структурируй ответ четко и понятно
+4. Структурируй ответ четко и понятно
+5. Указывай номера страниц при цитировании
+6. Отвечай на русском языке
 
 ОТВЕТ:"""
-
+            
             response = self.client.chat.completions.create(
-                model=config.GENERATION_MODEL,
+                model=self.generation_model,
                 messages=[{"role": "user", "content": prompt}],
-                max_tokens=1000,
-                temperature=0.3
+                max_tokens=1500,
+                temperature=0.1
             )
             
             return response.choices[0].message.content.strip()
             
         except Exception as e:
-            return f"Ошибка генерации ответа: {e}"
+            return f"❌ Ошибка генерации ответа: {str(e)}"
     
     def process_query(self, query: str) -> Dict[str, Any]:
-        """Полная обработка запроса"""
+        """Обработка пользовательского запроса"""
         if not self.is_initialized:
             return {
-                "answer": "Система не инициализирована. Загрузите PDF файл и введите API ключ.",
-                "sources": []
+                "answer": "❌ Система не инициализирована. Введите API ключ.",
+                "sources": [],
+                "debug_info": {}
             }
         
         if not query.strip():
             return {
                 "answer": "Пожалуйста, введите ваш вопрос.",
-                "sources": []
+                "sources": [],
+                "debug_info": {}
             }
         
-        # Поиск документов
-        search_results = self.search_documents(query, config.RETRIEVAL_K)
-        
-        if not search_results:
+        try:
+            # Шаг 1: Поиск по ключевым словам
+            initial_results = self.search_by_keywords(query, max_results=30)
+            
+            if not initial_results:
+                return {
+                    "answer": "К сожалению, не удалось найти релевантную информацию по вашему вопросу.",
+                    "sources": [],
+                    "debug_info": {"step": "keyword_search", "results_count": 0}
+                }
+            
+            # Шаг 2: LLM реранкинг
+            reranked_results = self.rerank_with_llm(query, initial_results)
+            
+            # Шаг 3: Генерация ответа
+            top_chunks = reranked_results[:self.final_chunks_count]
+            answer = self.generate_answer(query, top_chunks)
+            
+            # Подготовка источников
+            sources = []
+            for chunk in top_chunks:
+                sources.append({
+                    "page": chunk["page"],
+                    "keyword_score": chunk.get("keyword_score", 0),
+                    "rerank_score": chunk.get("rerank_score", 0),
+                    "preview": chunk["text"][:200] + "..." if len(chunk["text"]) > 200 else chunk["text"]
+                })
+            
+            debug_info = {
+                "initial_results": len(initial_results),
+                "reranked_results": len(reranked_results),
+                "final_chunks": len(top_chunks),
+                "avg_keyword_score": np.mean([s["keyword_score"] for s in sources]) if sources else 0,
+                "avg_rerank_score": np.mean([s["rerank_score"] for s in sources]) if sources else 0
+            }
+            
             return {
-                "answer": "К сожалению, не удалось найти релевантную информацию по вашему запросу.",
-                "sources": []
+                "answer": answer,
+                "sources": sources,
+                "debug_info": debug_info
+            }
+            
+        except Exception as e:
+            print(f"❌ Ошибка обработки запроса: {e}")
+            traceback.print_exc()
+            return {
+                "answer": f"❌ Ошибка обработки запроса: {str(e)}",
+                "sources": [],
+                "debug_info": {"error": str(e)}
             }
-        
-        # Реранкинг
-        reranked_docs = self.rerank_documents(query, search_results)
-        
-        # Генерация ответа
-        answer = self.generate_answer(query, reranked_docs)
-        
-        # Формируем информацию об источниках
-        sources = []
-        for doc in reranked_docs[:config.RERANKING_K]:
-            sources.append({
-                "page": doc['page'],
-                "similarity": doc.get('similarity', 0),
-                "rerank_score": doc.get('rerank_score', 0),
-                "preview": doc['content'][:200] + "..."
-            })
-        
-        return {
-            "answer": answer,
-            "sources": sources
-        }
-
-# Глобальная переменная для RAG системы
-rag_system = SimpleRAGSystem()
 
-def initialize_system(api_key: str, pdf_file) -> Tuple[str, str]:
-    """Инициализация системы с API ключом и PDF файлом"""
-    if not api_key:
-        return "❌ Введите OpenAI API ключ", ""
-    
-    if pdf_file is None:
-        return "❌ Загрузите PDF файл", ""
-    
-    try:
-        # Инициализация OpenAI
-        if not rag_system.initialize_openai(api_key):
-            return "❌ Неверный API ключ OpenAI", ""
-        
-        # Обработка PDF
-        texts = rag_system.extract_text_from_pdf(pdf_file)
-        
-        if not texts:
-            return "❌ Не удалось извлечь текст из PDF", ""
-        
-        # Создание эмбеддингов
-        if not rag_system.create_embeddings(texts):
-            return "❌ Ошибка создания эмбеддингов", ""
-        
-        stats = f"""✅ Система инициализирована!
-        
-📊 Статистика:
-- Обработано страниц: {len(set(doc['page'] for doc in texts))}
-- Создано фрагментов: {len(texts)}
-- Средний размер фрагмента: {np.mean([len(doc['content']) for doc in texts]):.0f} символов
+# Глобальная переменная системы
+rag_system = LightweightRAGSystem()
 
-🚀 Готова к ответам на вопросы!"""
-        
-        return "✅ Инициализация завершена", stats
-        
-    except Exception as e:
-        return f"❌ Ошибка: {e}", ""
+def initialize_system(api_key: str) -> Tuple[str, str]:
+    """Инициализация системы"""
+    return rag_system.initialize_with_api_key(api_key)
 
 def ask_question(question: str) -> Tuple[str, str]:
-    """Обработка вопроса пользователя"""
-    try:
-        result = rag_system.process_query(question)
-        
-        answer = result["answer"]
-        
-        # Формируем информацию об источниках
-        sources_info = ""
-        if result["sources"]:
-            sources_info = "\n📚 Источники:\n"
-            for i, source in enumerate(result["sources"], 1):
-                sources_info += f"\n{i}. Страница {source['page']} (релевантность: {source['similarity']:.2f})\n"
-                sources_info += f"   {source['preview']}\n"
-        
-        return answer, sources_info
-        
-    except Exception as e:
-        return f"Ошибка обработки запроса: {e}", ""
+    """Обработка вопроса"""
+    result = rag_system.process_query(question)
+    
+    answer = result["answer"]
+    
+    # Форматируем информацию об источниках
+    sources_info = ""
+    if result["sources"]:
+        sources_info = "\n📚 **Источники:**\n"
+        for i, source in enumerate(result["sources"], 1):
+            sources_info += f"\n**{i}.** Страница {source['page']} "
+            sources_info += f"(ключевые слова: {source['keyword_score']}, "
+            sources_info += f"релевантность: {source['rerank_score']:.1f}/10)\n"
+            sources_info += f"*Превью:* {source['preview']}\n"
+    
+    # Добавляем отладочную информацию
+    if result.get("debug_info"):
+        debug = result["debug_info"]
+        sources_info += f"\n🔍 **Статистика поиска:**\n"
+        sources_info += f"- Найдено по ключевым словам: {debug.get('initial_results', 0)}\n"
+        sources_info += f"- После реранкинга: {debug.get('reranked_results', 0)}\n"
+        sources_info += f"- Использовано в ответе: {debug.get('final_chunks', 0)}\n"
+        if debug.get('avg_rerank_score'):
+            sources_info += f"- Средняя релевантность: {debug.get('avg_rerank_score', 0):.1f}/10\n"
+    
+    return answer, sources_info
 
-def create_interface():
-    """Создание Gradio интерфейса"""
+def create_demo_interface():
+    """Создание демо интерфейса для HF"""
     
     with gr.Blocks(
-        title="RAG Система Сбер 2023",
+        title="RAG Demo - Сбер 2023",
         theme=gr.themes.Soft(),
         css="""
         .main-header { text-align: center; margin-bottom: 2rem; }
-        .status-box { margin: 1rem 0; padding: 1rem; border-radius: 8px; }
-        .success { background-color: #d4edda; border: 1px solid #c3e6cb; }
-        .error { background-color: #f8d7da; border: 1px solid #f5c6cb; }
+        .feature-box { background-color: #f8f9fa; padding: 1rem; border-radius: 8px; margin: 1rem 0; }
         """
     ) as demo:
         
         gr.Markdown("""
         <div class="main-header">
-        <h1>🏦 RAG Система для анализа отчета Сбера 2023</h1>
-        <p>Интеллектуальная система для анализа годового отчета ПАО Сбербанк 2023</p>
+        <h1>🏆 Enhanced RAG Demo: Анализ отчета Сбера 2023</h1>
+        <p>Улучшенная система поиска с поддержкой таблиц</p>
+        <p><strong>84 извлеченные таблицы • 2009 чанков • pdfplumber обработка</strong></p>
         </div>
         """)
         
-        with gr.Tab("🚀 Главная"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### ⚙️ Настройка системы")
-                    
-                    api_key_input = gr.Textbox(
-                        label="OpenAI API Key",
-                        placeholder="sk-...",
-                        type="password"
-                    )
-                    gr.Markdown("*Введите ваш OpenAI API ключ*")
-                    
-                    pdf_upload = gr.File(
-                        label="PDF файл отчета",
-                        file_types=[".pdf"]
-                    )
-                    gr.Markdown("*Загрузите PDF файл годового отчета*")
-                    
-                    init_btn = gr.Button("🔧 Инициализировать систему", variant="primary")
-                    
-                    status_text = gr.Textbox(
-                        label="Статус",
-                        interactive=False,
-                        lines=2
-                    )
-                    
-                with gr.Column(scale=1):
-                    stats_text = gr.Markdown("### 📊 Статистика системы")
-            
-            gr.Markdown("### 💬 Задайте вопрос")
-            
-            with gr.Row():
-                with gr.Column(scale=3):
-                    question_input = gr.Textbox(
-                        label="Ваш вопрос",
-                        placeholder="Например: Каковы основные финансовые показатели Сбера за 2023 год?",
-                        lines=3
-                    )
-                with gr.Column(scale=1):
-                    ask_btn = gr.Button("📝 Задать вопрос", variant="primary")
-            
-            with gr.Row():
-                with gr.Column():
-                    answer_output = gr.Textbox(
-                        label="Ответ системы",
-                        lines=10,
-                        interactive=False
-                    )
-                with gr.Column():
-                    sources_output = gr.Textbox(
-                        label="Источники",
-                        lines=10,
-                        interactive=False
-                    )
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### ⚙️ Настройка")
+                
+                api_key_input = gr.Textbox(
+                    label="OpenAI API Key",
+                    placeholder="sk-...",
+                    type="password",
+                    info="Введите ваш OpenAI API ключ для работы системы"
+                )
+                
+                init_btn = gr.Button("🚀 Инициализировать", variant="primary")
+                
+                status_output = gr.Textbox(
+                    label="Статус",
+                    interactive=False,
+                    lines=2
+                )
+                
+            with gr.Column(scale=1):
+                stats_output = gr.Markdown("### 📊 Ожидание инициализации...")
+        
+        gr.Markdown("### 💬 Задайте вопрос")
+        
+        with gr.Row():
+            question_input = gr.Textbox(
+                label="Ваш вопрос",
+                placeholder="Например: Каковы основные финансовые показатели Сбера за 2023 год?",
+                lines=2,
+                scale=4
+            )
+            ask_btn = gr.Button("📝 Спросить", variant="primary", scale=1)
         
-        with gr.Tab("📖 Примеры"):
-            gr.Markdown("""
-            ### 💡 Примеры вопросов для анализа отчета:
-            
-            **📊 Финансовые показатели:**
-            - "Каковы основные финансовые показатели Сбера за 2023 год?"
-            - "Какова чистая прибыль банка в 2023 году?"
-            - "Расскажите о рентабельности Сбербанка"
-            
-            **🏦 Бизнес и стратегия:**
-            - "Какие технологические инновации развивает Сбер?"
-            - "Каковы планы развития банка на будущее?"
-            - "Расскажите об ESG-инициативах Сбербанка"
-            
-            **⚠️ Риски и управление:**
-            - "Какие основные риски упоминаются в отчете?"
-            - "Как Сбер управляет кредитными рисками?"
-            - "Какова система корпоративного управления?"
-            
-            **📈 Показатели деятельности:**
-            - "Каков объем активов Сбербанка?"
-            - "Расскажите о кредитном портфеле банка"
-            - "Какова динамика развития цифровых сервисов?"
-            """)
+        with gr.Row():
+            with gr.Column(scale=2):
+                answer_output = gr.Textbox(
+                    label="Ответ системы",
+                    lines=12,
+                    interactive=False
+                )
+            with gr.Column(scale=1):
+                sources_output = gr.Textbox(
+                    label="Источники и статистика",
+                    lines=12,
+                    interactive=False
+                )
         
-        with gr.Tab("ℹ️ О системе"):
-            gr.Markdown("""
-            ### 🎯 О RAG системе
-            
-            Эта система использует технологию **Retrieval-Augmented Generation (RAG)** для интеллектуального анализа документов.
-            
-            **🏗️ Архитектура:**
-            1. **Обработка PDF** - извлечение и сегментация текста
-            2. **Векторизация** - создание семантических представлений
-            3. **Поиск** - нахождение релевантных фрагментов
-            4. **Реранкинг** - улучшение качества результатов
-            5. **Генерация** - создание финального ответа
-            
-            **🤖 Используемые модели:**
-            - **GPT-4o** - генерация ответов
-            - **GPT-4o-mini** - реранкинг результатов  
-            - **text-embedding-3-large** - векторные представления
-            
-            **🔧 Технологии:**
-            - Gradio - веб-интерфейс
-            - LangChain - RAG пайплайн
-            - OpenAI API - языковые модели
-            - NumPy - математические операции
-            
-            *Разработано в рамках курсового проекта*
-            """)
+        # Примеры вопросов
+        gr.Markdown("""
+        ### 💡 Примеры вопросов:
+        - Каковы основные финансовые показатели Сбера за 2023 год?
+        - Какова чистая прибыль банка в 2023 году?
+        - Расскажите о кредитном портфеле Сбербанка
+        - Какие технологические инициативы развивает Сбер?
+        - Каковы показатели рентабельности банка?
+        """)
         
-        # Обработчики событий
+        # Event handlers
         init_btn.click(
             fn=initialize_system,
-            inputs=[api_key_input, pdf_upload],
-            outputs=[status_text, stats_text]
+            inputs=[api_key_input],
+            outputs=[status_output, stats_output]
         )
         
         ask_btn.click(
@@ -498,7 +453,6 @@ def create_interface():
             outputs=[answer_output, sources_output]
         )
         
-        # Обработка Enter в поле вопроса
         question_input.submit(
             fn=ask_question,
             inputs=[question_input],
@@ -507,9 +461,8 @@ def create_interface():
     
     return demo
 
-# Запуск приложения
 if __name__ == "__main__":
-    demo = create_interface()
+    demo = create_demo_interface()
     demo.launch(
         share=False,
         server_name="0.0.0.0",