simplest version

documents_prep.py

@@ -9,66 +9,56 @@ from my_logging import log_message
 # Configuration
 CHUNK_SIZE = 1500
 CHUNK_OVERLAP = 256
-
 def chunk_text_documents(documents):
+    """Chunk with deduplication"""
     text_splitter = SentenceSplitter(
         chunk_size=CHUNK_SIZE,
-        chunk_overlap=CHUNK_OVERLAP
+        chunk_overlap=300  # Increased overlap
     )
     
+    seen_texts = set()
     chunked = []
+    
     for doc in documents:
+        # Skip duplicates or too-short content
+        text_normalized = doc.text.strip()
+        if len(text_normalized) < 50 or text_normalized in seen_texts:
+            continue
+        
+        seen_texts.add(text_normalized)
+        
         chunks = text_splitter.get_nodes_from_documents([doc])
         for i, chunk in enumerate(chunks):
             chunk.metadata.update({
                 'chunk_id': i,
                 'total_chunks': len(chunks),
-                'chunk_size': len(chunk.text)  # Add chunk size
+                'chunk_size': len(chunk.text),
+                'document_group': normalize_doc_id(doc.metadata.get('document_id', 'unknown'))
             })
             chunked.append(chunk)
     
-    # Log statistics
     if chunked:
         avg_size = sum(len(c.text) for c in chunked) / len(chunked)
-        min_size = min(len(c.text) for c in chunked)
-        max_size = max(len(c.text) for c in chunked)
-        log_message(f"✓ Text: {len(documents)} docs → {len(chunked)} chunks")
-        log_message(f"  Size stats: avg={avg_size:.0f}, min={min_size}, max={max_size} chars")
+        log_message(f"✓ Text: {len(documents)} docs → {len(chunked)} chunks (avg: {avg_size:.0f} chars)")
     
     return chunked
 
-
-def normalize_doc_id(doc_id):
-    if not doc_id or doc_id == 'unknown':
-        return doc_id
-    
-    doc_id = str(doc_id).strip()
-    
-    # Normalize spacing: "ГОСТ Р" variations
-    import re
-    doc_id = re.sub(r'ГОСТ\s*Р', 'ГОСТ Р', doc_id, flags=re.IGNORECASE)
-    doc_id = re.sub(r'НП\s*-', 'НП-', doc_id, flags=re.IGNORECASE)
-    
-    return doc_id
-
-
-def chunk_table_by_rows(table_data, doc_id, max_rows=5):
+def chunk_table_by_rows(table_data, doc_id, max_chars=2000):
+    """Chunk tables by content size, not fixed rows"""
     headers = table_data.get('headers', [])
     rows = table_data.get('data', [])
     table_num = table_data.get('table_number', 'unknown')
     table_title = table_data.get('table_title', '')
     section = table_data.get('section', '')
     
-    doc_id = normalize_doc_id(doc_id)
-    
     table_num_clean = str(table_num).strip()
     
+    # Create unique identifier
     import re
     if 'приложени' in section.lower():
         appendix_match = re.search(r'приложени[еия]\s*(\d+|[а-яА-Я])', section.lower())
         if appendix_match:
-            appendix_num = appendix_match.group(1).upper()
-            table_identifier = f"{table_num_clean} Приложение {appendix_num}"
+            table_identifier = f"{table_num_clean} (Приложение {appendix_match.group(1).upper()})"
         else:
             table_identifier = table_num_clean
     else:
@@ -77,67 +67,99 @@ def chunk_table_by_rows(table_data, doc_id, max_rows=5):
     if not rows:
         return []
     
-    log_message(f"  📊 Processing: {doc_id} - {table_identifier} ({len(rows)} rows)")
+    # Estimate base metadata size
+    base_content = f"Документ: {doc_id}\nТаблица: {table_identifier}\n"
+    if table_title:
+        base_content += f"Название: {table_title}\n"
+    if section:
+        base_content += f"Раздел: {section}\n"
+    
+    header_content = ""
+    if headers:
+        header_content = "Столбцы: " + " | ".join(str(h) for h in headers) + "\n\n"
+    
+    base_size = len(base_content) + len(header_content)
+    
+    # Group rows by size
+    chunks = []
+    current_rows = []
+    current_size = base_size
     
-    if len(rows) <= max_rows:
-        content = format_table_content(table_data, headers, rows, doc_id, table_identifier)
-        chunk_size = len(content)
+    for row in rows:
+        # Estimate row size
+        if isinstance(row, dict):
+            row_str = " | ".join(f"{k}: {v}" for k, v in row.items() 
+                                if v and str(v).strip() and str(v).lower() not in ['nan', 'none', ''])
+        elif isinstance(row, list):
+            row_str = " | ".join(str(v) for v in row 
+                                if v and str(v).strip() and str(v).lower() not in ['nan', 'none', ''])
+        else:
+            row_str = str(row)
         
-        metadata = {
-            'type': 'table',
-            'document_id': doc_id,
-            'table_number': table_num_clean,
-            'table_identifier': table_identifier,
-            'table_title': table_title,
-            'section': section,
-            'total_rows': len(rows),
-            'chunk_size': chunk_size,
-            'is_complete_table': True
-        }
+        row_size = len(row_str) + 2  # +2 for newline
         
-        log_message(f"    Chunk: 1/1, {chunk_size} chars, doc={doc_id}, table={table_identifier}")
+        # If adding this row exceeds limit and we have rows, create chunk
+        if current_size + row_size > max_chars and current_rows:
+            chunks.append(current_rows[:])
+            current_rows = []
+            current_size = base_size
         
-        return [Document(text=content, metadata=metadata)]
+        current_rows.append(row)
+        current_size += row_size
     
-    chunks = []
-    overlap = 2
+    # Add remaining rows
+    if current_rows:
+        chunks.append(current_rows)
     
-    for i in range(0, len(rows), max_rows - overlap):
-        chunk_rows = rows[i:min(i+max_rows, len(rows))]
-        chunk_num = i // (max_rows - overlap)
-        
-        content = format_table_content(
-            table_data, 
-            headers, 
-            chunk_rows,
-            doc_id,
-            table_identifier,
-            chunk_info=f"Строки {i+1}-{i+len(chunk_rows)} из {len(rows)}"
-        )
+    # Create documents
+    documents = []
+    for chunk_idx, chunk_rows in enumerate(chunks):
+        content = base_content
+        content += f"Таблица {table_identifier} документа {doc_id}\n"
+        if len(chunks) > 1:
+            content += f"Часть {chunk_idx+1} из {len(chunks)}\n"
+        content += "\n" + header_content
         
-        chunk_size = len(content)
+        for idx, row in enumerate(chunk_rows, 1):
+            if isinstance(row, dict):
+                parts = [f"{k}: {v}" for k, v in row.items() 
+                        if v and str(v).strip() and str(v).lower() not in ['nan', 'none', '']]
+                if parts:
+                    content += f"{idx}. {' | '.join(parts)}\n"
+            elif isinstance(row, list):
+                parts = [str(v) for v in row if v and str(v).strip() and str(v).lower() not in ['nan', 'none', '']]
+                if parts:
+                    content += f"{idx}. {' | '.join(parts)}\n"
         
         metadata = {
             'type': 'table',
             'document_id': doc_id,
+            'document_group': normalize_doc_id(doc_id),
             'table_number': table_num_clean,
             'table_identifier': table_identifier,
             'table_title': table_title,
             'section': section,
-            'chunk_id': chunk_num,
-            'row_start': i,
-            'row_end': i + len(chunk_rows),
-            'total_rows': len(rows),
-            'chunk_size': chunk_size,
-            'total_chunks': (len(rows) + max_rows - overlap - 1) // (max_rows - overlap),
-            'is_complete_table': False
+            'chunk_id': chunk_idx,
+            'total_chunks': len(chunks),
+            'chunk_size': len(content),
+            'is_complete_table': len(chunks) == 1
         }
         
-        log_message(f"    Chunk: {chunk_num+1}, rows {i}-{i+len(chunk_rows)}, {chunk_size} chars")
+        documents.append(Document(text=content, metadata=metadata))
         
-        chunks.append(Document(text=content, metadata=metadata))
+        log_message(f"    Chunk {chunk_idx+1}: {len(chunk_rows)} rows, {len(content)} chars")
+        log_message(f"      Meta: doc={doc_id}, table={table_identifier}, group={metadata['document_group']}")
+    
+    log_message(f"  Table {table_identifier} ({doc_id}): {len(rows)} rows → {len(chunks)} chunks")
     
-    return chunks
+    return documents
+
+
+def normalize_doc_id(doc_id):
+    import re
+    normalized = re.sub(r'\s+', ' ', str(doc_id).strip().upper())
+    normalized = normalized.replace('ГОСТ Р', 'ГОСТР').replace('ГОСТР', 'ГОСТ Р')
+    return normalized
 
 
 def format_table_content(table_data, headers, rows, doc_id, table_identifier, chunk_info=""):
@@ -383,13 +405,16 @@ def extract_sections_from_json(json_path):
 
 
 def load_table_documents(repo_id, hf_token, table_dir):
+    """Load ALL tables including from multi-document files"""
     log_message("Loading tables...")
     
     files = list_repo_files(repo_id=repo_id, repo_type="dataset", token=hf_token)
     table_files = [f for f in files if f.startswith(table_dir) and f.endswith('.json')]
     
+    log_message(f"Found {len(table_files)} table files")
+    
     all_chunks = []
-    doc_table_count = {}
+    doc_id_stats = {}
     
     for file_path in table_files:
         try:
@@ -403,39 +428,40 @@ def load_table_documents(repo_id, hf_token, table_dir):
             with open(local_path, 'r', encoding='utf-8') as f:
                 data = json.load(f)
             
-            file_doc_id = normalize_doc_id(data.get('document_id', data.get('document', 'unknown')))
+            file_doc_id = data.get('document_id', data.get('document', 'unknown'))
             
             for sheet in data.get('sheets', []):
-                sheet_doc_id = normalize_doc_id(sheet.get('document_id', sheet.get('document', file_doc_id)))
+                sheet_doc_id = sheet.get('document_id', sheet.get('document', file_doc_id))
+                
+                # Track which documents we're loading
+                if sheet_doc_id not in doc_id_stats:
+                    doc_id_stats[sheet_doc_id] = 0
                 
                 chunks = chunk_table_by_rows(sheet, sheet_doc_id)
                 all_chunks.extend(chunks)
-                
-                if sheet_doc_id not in doc_table_count:
-                    doc_table_count[sheet_doc_id] = 0
-                doc_table_count[sheet_doc_id] += len(chunks)
+                doc_id_stats[sheet_doc_id] += len(chunks)
                 
         except Exception as e:
             log_message(f"Error loading {file_path}: {e}")
     
-    log_message(f"\n{'='*60}")
-    log_message("TABLE LOADING SUMMARY:")
-    for doc_id, count in sorted(doc_table_count.items()):
-        log_message(f"  {doc_id}: {count} table chunks")
-    log_message(f"TOTAL: {len(all_chunks)} table chunks")
-    log_message(f"{'='*60}\n")
+    # Log what we loaded
+    log_message(f"\nTable loading summary:")
+    for doc_id, count in sorted(doc_id_stats.items()):
+        log_message(f"  {doc_id}: {count} chunks")
     
+    log_message(f"\n✓ Total table chunks: {len(all_chunks)}")
     return all_chunks
 
-
 def load_image_documents(repo_id, hf_token, image_dir):
-    """Load image descriptions"""
+    """Load with proper linking"""
     log_message("Loading images...")
     
     files = list_repo_files(repo_id=repo_id, repo_type="dataset", token=hf_token)
     csv_files = [f for f in files if f.startswith(image_dir) and f.endswith('.csv')]
     
     documents = []
+    seen = set()
+    
     for file_path in csv_files:
         try:
             local_path = hf_hub_download(
@@ -448,22 +474,28 @@ def load_image_documents(repo_id, hf_token, image_dir):
             df = pd.read_csv(local_path)
             
             for _, row in df.iterrows():
-                content = f"Документ: {row.get('Обозначение документа', 'unknown')}\n"
-                content += f"Рисунок: {row.get('№ Изображения', 'unknown')}\n"
+                doc_id = str(row.get('Обозначение документа', 'unknown'))
+                img_num = str(row.get('№ Изображения', 'unknown'))
+                
+                key = f"{doc_id}_{img_num}"
+                if key in seen:
+                    continue
+                seen.add(key)
+                
+                content = f"Документ: {doc_id}\n"
+                content += f"Рисунок: {img_num}\n"
                 content += f"Название: {row.get('Название изображения', '')}\n"
                 content += f"Описание: {row.get('Описание изображение', '')}\n"
-                content += f"Раздел: {row.get('Раздел документа', '')}\n"
-                
-                chunk_size = len(content)
                 
                 documents.append(Document(
                     text=content,
                     metadata={
                         'type': 'image',
-                        'document_id': str(row.get('Обозначение документа', 'unknown')),
-                        'image_number': str(row.get('№ Изображения', 'unknown')),
+                        'document_id': doc_id,
+                        'document_group': normalize_doc_id(doc_id),
+                        'image_number': img_num,
                         'section': str(row.get('Раздел документа', '')),
-                        'chunk_size': chunk_size
+                        'chunk_size': len(content)
                     }
                 ))
         except Exception as e:
@@ -471,11 +503,12 @@ def load_image_documents(repo_id, hf_token, image_dir):
     
     if documents:
         avg_size = sum(d.metadata['chunk_size'] for d in documents) / len(documents)
-        log_message(f"✓ Loaded {len(documents)} images (avg size: {avg_size:.0f} chars)")
+        log_message(f"✓ Images: {len(documents)} loaded (avg: {avg_size:.0f} chars)")
     
     return documents
 
 
+
 def load_all_documents(repo_id, hf_token, json_dir, table_dir, image_dir):
     """Main loader - combines all document types"""
     log_message("="*60)

utils.py

@@ -66,6 +66,33 @@ def answer_question(question, query_engine, reranker):
         retrieved = query_engine.retriever.retrieve(enhanced_query)
         log_message(f"Retrieved {len(retrieved)} nodes")
         
+        doc_stats = {}
+        for n in retrieved:
+            doc_id = n.metadata.get('document_id', 'unknown')
+            doc_type = n.metadata.get('type', 'text')
+            
+            if doc_id not in doc_stats:
+                doc_stats[doc_id] = {'tables': set(), 'text': 0, 'images': 0}
+            
+            if doc_type == 'table':
+                table_id = n.metadata.get('table_identifier', n.metadata.get('table_number', '?'))
+                doc_stats[doc_id]['tables'].add(table_id)
+            elif doc_type == 'image':
+                doc_stats[doc_id]['images'] += 1
+            else:
+                doc_stats[doc_id]['text'] += 1
+        
+        for doc_id in sorted(doc_stats.keys()):
+            stats = doc_stats[doc_id]
+            parts = []
+            if stats['tables']:
+                parts.append(f"tables={list(stats['tables'])[:5]}")
+            if stats['text']:
+                parts.append(f"text={stats['text']}")
+            if stats['images']:
+                parts.append(f"images={stats['images']}")
+            log_message(f"  {doc_id}: {', '.join(parts)}")
+
         doc_ids = [n.metadata.get('document_id', 'unknown') for n in retrieved]
         table_nums = [n.metadata.get('table_number', '') for n in retrieved if n.metadata.get('type') == 'table']
         log_message(f"Retrieved from documents: {set(doc_ids)}")
@@ -104,19 +131,87 @@ def answer_question(question, query_engine, reranker):
         
         context = "\n\n" + ("="*70 + "\n\n").join(context_parts)
         from config import CUSTOM_PROMPT
-        prompt = f"""Ты эксперт по технической документации. 
+        prompt = f"""
+Вы являетесь высокоспециализированным Ассистентом для анализа нормативных документов (AIEXP). Ваша цель - предоставлять точные, корректные и контекстно релевантные ответы исключительно на основе предоставленного контекста из нормативной документации.
+
+ПРАВИЛА АНАЛИЗА ЗАПРОСА:
+
+1. ПРЯМЫЕ ВОПРОСЫ БЕЗ ДОКУМЕНТАЛЬНОГО КОНТЕКСТА:
+   Если пользователь задает вопрос типа "В каких случаях могут быть признаны протоколы испытаний?" без предоставления дополнительных документов, найдите соответствующую информацию в доступном контексте и предоставьте полный ответ с указанием источников.
+
+2. ОПРЕДЕЛЕНИЕ ТИПА ЗАДАЧИ:
+
+   а) ПОИСК И ОТВЕТ НА ВОПРОС (ключевые слова: "в каких случаях", "когда", "кто", "что", "как", "почему"):
+      - Найдите релевантную информацию в контексте
+      - Предоставьте развернутый ответ
+      - Обязательно укажите конкретные документы и разделы
+      - Процитируйте ключевые положения
+
+   б) КРАТКОЕ САММАРИ (ключевые слова: "кратко", "суммировать", "резюме", "основные моменты"):
+      - Предоставьте структурированное резюме
+      - Выделите ключевые требования
+      - Используйте нумерованный список
+
+   в) ПОИСК ДОКУМЕНТА И ПУНКТА (ключевые слова: "найти", "где", "какой документ", "в каком разделе"):
+      - Укажите конкретный документ и структурное расположение
+      - Предоставьте точные номера разделов/пунктов
+
+   г) ПРОВЕРКА КОРРЕКТНОСТИ (ключевые слова: "правильно ли", "соответствует ли", "проверить"):
+      - Четко укажите: "СООТВЕТСТВУЕТ" или "НЕ СООТВЕТСТВУЕТ"
+      - Перечислите конкретные требования
+
+   д) ПЛАН ДЕЙСТВИЙ (ключевые слова: "план", "алгоритм", "пошагово"):
+      - Создайте пронумерованный план
+      - Укажите ссылки на соответствующие пункты НД
+
+ПРАВИЛА ФОРМИРОВАНИЯ ОТВЕТОВ:
+
+Работай исключительно с информацией из предоставленного конт��кста. Запрещено использовать:
+- Общие знания
+- Информацию из интернета
+- Данные из предыдущих диалогов
+- Собственные предположения
+
+1. СТРУКТУРА ОТВЕТА:
+   - Начинайте с прямого ответа на вопрос
+   - Затем указывайте нормативные основания
+   - Завершайте ссылками на конкретные документы и разделы
+
+2. РАБОТА С КОНТЕКСТОМ:
+   - Если информация найдена в контексте - предоставьте полный ответ
+   - Если информация не найдена: "Информация по вашему запросу не найдена в доступной нормативной документации"
+   - Не делайте предположений за пределами контекста
+   - Не используйте общие знания
+
+3. ТЕРМИНОЛОГИЯ И ЦИТИРОВАНИЕ:
+   - Сохраняйте официальную терминологию НД
+   - Цитируйте точные формулировки ключевых требований
+   - При множественных источниках - укажите все релевантные
+
+4. ФОРМАТИРОВАНИЕ:
+   - Для перечислений: используйте нумерованные списки
+   - Выделяйте критически важные требования
+   - Структурируйте ответ логически
+
+# КАК РАБОТАТЬ С ЗАПРОСОМ
+
+**Шаг 1:** Определи, что именно ищет пользователь (термин, требование, процедура, условие)
+
+**Шаг 2:** Найди релевантную информацию в контексте
+
+**Шаг 3:** Сформируй ответ:
+   - Если нашел: укажи документ и пункт, процитируй нужную часть
+   - Если не нашел: четко сообщи об отсутствии информации
+
+**Шаг 4:** При наличии нескольких источников:
+   - Представь их последовательно с указанием источника каждого
+   - Если источников много (>4) — сначала дай их список, потом цитаты   
 
 КОНТЕКСТ:
 {context}
 
 ВОПРОС: {question}
-
-ИНСТРУКЦИИ:
-1. Используй ТОЛЬКО контекст выше
-2. Укажи источник: документ и номер таблицы
-3. Если информации нет - четко скажи об этом
-
-ОТВЕТ:"""
+"""
         
         response = query_engine.query(prompt)
         sources = format_sources(reranked)