Update app.py

app.py

@@ -119,60 +119,53 @@ class VectorRAGSystem:
             return False
     
     def load_vector_data(self) -> bool:
-        """Загрузка векторных данных"""
+        """Загрузка векторных данных и сохранение полной metadata_list с caption."""
         try:
             print("🔄 Попытка загрузки векторных данных...")
             
-            # Файлы векторных данных
-            faiss_file     = "chunks_flatip.faiss"
-            metadata_file  = "metadata.json"
-            
+            faiss_file    = "chunks_flatip.faiss"
+            metadata_file = "metadata.json"
             if not all(os.path.exists(f) for f in [faiss_file, metadata_file]):
-                print("📁 Файлы векторных данных не найдены")
+                print("📁 Векторные файлы не найдены")
                 return False
             
-            # Загружаем метаданные
+            # 1) Читаем весь список метаданных, сохраняем его
             with open(metadata_file, 'r', encoding='utf-8') as f:
                 metadata_list = json.load(f)
+            self.metadata_list = metadata_list
             
-            # Собираем self.chunks для всех типов элементов
+            # 2) Строим self.chunks, сохраняя каждый item целиком
             self.chunks = []
             for i, item in enumerate(metadata_list):
-                # унифицируем идентификатор чанка
                 chunk_id = item.get("chunk_id",
                             item.get("table_id",
                             item.get("img_id", None)))
-                
                 self.chunks.append({
                     "page":        item["page"],
                     "chunk_id":    chunk_id,
                     "chunk_index": i,
-                    "text":        "",   # подгрузим из PDF при выдаче
-                    "metadata":    {}
+                    "text":        "",     # заполним в vector_search
+                    "metadata":    item   # здесь есть caption, type и т.д.
                 })
             
-            # Сохраняем общую статистику
-            self.metadata = {"total_chunks": len(self.chunks)}
-            
-            # Загружаем FAISS-индекс
+            # 3) Загружаем FAISS-индекс
             if HAS_FAISS:
                 self.faiss_index = faiss.read_index(faiss_file)
             
-            # Загружаем PDF для parent-page enrichment
+            # 4) Загружаем PDF для parent-page enrichment
             pdf_path = "data/Сбер 2023.pdf"
             if os.path.exists(pdf_path):
-                import fitz  # PyMuPDF
+                import fitz
                 self.pdf_doc = fitz.open(pdf_path)
                 print(f"✅ PDF загружен: {self.pdf_doc.page_count} страниц")
             else:
-                print("❌ PDF файл не найден для parent-page enrichment")
+                print("❌ PDF не найден для enrichment")
                 self.pdf_doc = None
             
-            print(f"✅ Загружены векторные данные: {len(self.chunks)} чанков")
+            print(f"✅ Загружены векторы: {len(self.chunks)} чанков")
             return True
-            
         except Exception as e:
-            print(f"❌ Ошибка загрузки векторных данных: {e}")
+            print(f"❌ Ошибка load_vector_data: {e}")
             return False
  
     def get_page_text(self, page_num: int) -> str:
@@ -234,42 +227,37 @@ class VectorRAGSystem:
             return []
     
     def vector_search(self, query: str, k: int = 20) -> List[Tuple[Dict, float]]:
-        """Векторный поиск по запросу"""
-        if not self.faiss_index or not self.client:
-            print("⚠️ FAISS индекс или OpenAI клиент недоступны")
-            return []
-        
+        """Векторный поиск + enrichment с caption из metadata_list."""
         try:
-            # Создаем эмбеддинг для запроса
             response = self.client.embeddings.create(
                 model=self.embedding_model,
                 input=[query]
             )
+            q_emb = np.array(response.data[0].embedding, dtype=np.float32).reshape(1, -1)
+            faiss.normalize_L2(q_emb)
+            scores, indices = self.faiss_index.search(q_emb, k)
             
-            query_embedding = np.array(response.data[0].embedding, dtype=np.float32)
-            query_embedding = query_embedding.reshape(1, -1)
-            
-            # Нормализуем для Inner Product
-            faiss.normalize_L2(query_embedding)
-            
-            # Поиск в 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].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)))
-            
+                    record    = self.chunks[idx].copy()
+                    meta_item = self.metadata_list[idx]
+                    
+                    # базовый текст страницы
+                    page_text = self.get_page_text(record["page"]) or ""
+                    
+                    # если это картинка и есть caption — добавляем его сверху
+                    if meta_item.get("type") == "image" and meta_item.get("caption"):
+                        caption = meta_item["caption"]
+                        record["text"] = caption + "\n\n" + page_text
+                    else:
+                        record["text"] = page_text
+                    
+                    results.append((record, float(score)))
             return results
-            
+        
         except Exception as e:
-            print(f"❌ Ошибка векторного поиска: {e}")
-            print("⚠️ Переход на поиск без векторов невозможен")
+            print(f"❌ Ошибка vector_search: {e}")
             return []
     
     def rerank_with_llm(self, query: str, chunks: List[Tuple[Dict, float]]) -> List[Tuple[Dict, float]]: