Update app.py

app.py

@@ -40,6 +40,8 @@ class VectorRAGSystem:
         self.metadata = {}
         self.client = None
         self.is_initialized = False
+        self.pdf_doc = None
+        self.page_texts = {}  # Кеш текстов страниц
         
         # Модели и параметры
         self.embedding_model = "text-embedding-3-large"
@@ -77,14 +79,14 @@ class VectorRAGSystem:
             return f"❌ Ошибка инициализации: {str(e)}", ""
     
     def load_data(self) -> bool:
-        """Загрузка данных (векторных или обычных)"""
+        """Загрузка векторных данных"""
         try:
-            # Сначала пробуем загрузить векторные данные
+            # Загружаем только векторные данные
             if self.vector_mode and self.load_vector_data():
                 return True
             
-            # Если не удалось, загружаем обычные данные
-            return self.load_fallback_data()
+            print("❌ Векторные данные не найдены или не удалось загрузить")
+            return False
             
         except Exception as e:
             print(f"❌ Ошибка загрузки данных: {e}")
@@ -103,28 +105,38 @@ class VectorRAGSystem:
                 print("📁 Файлы векторных данных не найдены")
                 return False
             
-            # Загружаем метаданные с чанками
+            # Загружаем метаданные (список с page и chunk_id)
             with open(metadata_file, 'r', encoding='utf-8') as f:
-                full_data = json.load(f)
+                metadata_list = json.load(f)
             
-            # Извлекаем чанки
-            chunks_data = full_data.get("chunks", [])
+            # Создаем структуру чанков без текстов (получим из PDF по требованию)
             self.chunks = []
-            for chunk_data in chunks_data:
+            for i, item in enumerate(metadata_list):
                 self.chunks.append({
-                    "text": chunk_data["text"],
-                    "page": chunk_data["page"],
-                    "chunk_index": chunk_data.get("chunk_index", len(self.chunks)),
-                    "metadata": chunk_data.get("metadata", {})
+                    "page": item["page"],
+                    "chunk_id": item["chunk_id"],
+                    "chunk_index": i,
+                    "text": "",  # Получим из PDF по требованию
+                    "metadata": {}
                 })
             
-            # Сохраняем остальные метаданные
-            self.metadata = full_data
+            # Сохраняем метаданные
+            self.metadata = {"total_chunks": len(self.chunks)}
             
             # Загружаем FAISS индекс
             if HAS_FAISS:
                 self.faiss_index = faiss.read_index(faiss_file)
             
+            # Загружаем PDF для parent-page enrichment
+            pdf_path = "data/Сбер 2023.pdf"
+            if os.path.exists(pdf_path):
+                import fitz  # PyMuPDF
+                self.pdf_doc = fitz.open(pdf_path)
+                print(f"✅ PDF загружен: {self.pdf_doc.page_count} страниц")
+            else:
+                print("❌ PDF файл не найден для parent-page enrichment")
+                self.pdf_doc = None
+            
             print(f"✅ Загружены векторные данные: {len(self.chunks)} чанков")
             return True
             
@@ -132,46 +144,25 @@ class VectorRAGSystem:
             print(f"❌ Ошибка загрузки векторных данных: {e}")
             return False
     
-    def load_fallback_data(self) -> bool:
-        """Загрузка обычных данных"""
+    def get_page_text(self, page_num: int) -> str:
+        """Получение полного текста страницы с кешированием"""
+        if page_num in self.page_texts:
+            return self.page_texts[page_num]
+        
         try:
-            print("🔄 Загрузка резервных данных...")
-            
-            index_file = "enhanced_sber_index.pkl"
-            if not os.path.exists(index_file):
-                print(f"❌ Файл резервных данных не найден: {index_file}")
-                return False
-            
-            with open(index_file, 'rb') as f:
-                index_data = pickle.load(f)
-            
-            # Конвертируем в формат чанков
-            self.chunks = []
-            chunk_texts = index_data.get("chunks", [])
-            
-            for i, chunk_text in enumerate(chunk_texts):
-                chunk = {
-                    "text": chunk_text,
-                    "page": index_data.get("metadata", {}).get("chunk_pages", {}).get(str(i), 1),
-                    "chunk_index": i,
-                    "embedding": None,
-                    "metadata": {},
-                    "full_page_text": chunk_text
-                }
-                self.chunks.append(chunk)
-            
-            # Создаем словарный индекс для поиска
-            self.word_index = index_data.get("word_index", {})
-            self.metadata = index_data.get("metadata", {})
+            if not self.pdf_doc or page_num < 1 or page_num > self.pdf_doc.page_count:
+                return ""
             
-            self.vector_mode = False  # Отключаем векторный режим
+            page = self.pdf_doc[page_num - 1]  # PyMuPDF использует 0-based индексы
+            text = page.get_text()
             
-            print(f"✅ Загружены резервные данные: {len(self.chunks)} чанков")
-            return True
+            # Кешируем текст
+            self.page_texts[page_num] = text
+            return text
             
         except Exception as e:
-            print(f"❌ Ошибка загрузки резервных данных: {e}")
-            return False
+            print(f"❌ Ошибка получения текста страницы {page_num}: {e}")
+            return ""
     
     def _generate_stats(self) -> str:
         """Генерация статистики системы"""
@@ -202,12 +193,14 @@ class VectorRAGSystem:
         if self.vector_mode and self.faiss_index and self.client:
             return self.vector_search(query, k)
         else:
-            return self.keyword_search(query, k)
+            print("⚠️ Векторный режим отключен")
+            return []
     
     def vector_search(self, query: str, k: int = 20) -> List[Tuple[Dict, float]]:
         """Векторный поиск по запросу"""
         if not self.faiss_index or not self.client:
-            return self.keyword_search(query, k)
+            print("⚠️ FAISS индекс или OpenAI клиент недоступны")
+            return []
         
         try:
             # Создаем эмбеддинг для запроса
@@ -225,51 +218,22 @@ class VectorRAGSystem:
             # Поиск в FAISS индексе
             scores, indices = self.faiss_index.search(query_embedding, k)
             
-            # Формируем результаты
+            # Формируем результаты с parent-page enrichment
             results = []
             for score, idx in zip(scores[0], indices[0]):
                 if 0 <= idx < len(self.chunks):
-                    chunk = self.chunks[idx]
+                    chunk = self.chunks[idx].copy()
+                    # Получаем полный текст страницы для parent-page enrichment
+                    page_text = self.get_page_text(chunk["page"])
+                    chunk["text"] = page_text if page_text else chunk["text"]
                     results.append((chunk, float(score)))
             
             return results
             
         except Exception as e:
             print(f"❌ Ошибка векторного поиска: {e}")
-            return self.keyword_search(query, k)
-    
-    def keyword_search(self, query: str, k: int = 20) -> List[Tuple[Dict, float]]:
-        """Поиск по ключевым словам"""
-        query_words = set(re.findall(r'\b\w+\b', query.lower()))
-        
-        if self.word_index:
-            # Используем готовый индекс
-            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
-        else:
-            # Создаем индекс на лету
-            chunk_scores = {}
-            for i, chunk in enumerate(self.chunks):
-                text_words = set(re.findall(r'\b\w+\b', chunk["text"].lower()))
-                score = len(query_words.intersection(text_words))
-                if score > 0:
-                    chunk_scores[i] = score
-        
-        # Сортируем по скору
-        sorted_chunks = sorted(chunk_scores.items(), key=lambda x: x[1], reverse=True)
-        
-        results = []
-        for chunk_idx, score in sorted_chunks[:k]:
-            if chunk_idx < len(self.chunks):
-                chunk = self.chunks[chunk_idx]
-                results.append((chunk, float(score)))
-        
-        return results
+            print("⚠️ Переход на поиск без векторов невозможен")
+            return []
     
     def rerank_with_llm(self, query: str, chunks: List[Tuple[Dict, float]]) -> List[Tuple[Dict, float]]:
         """LLM реранкинг результатов"""