Upload 18 files

README.md

@@ -1,13 +1,99 @@
----
-title: ITMO QA
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# 🤖 ITMO Магистратура - Чат-бот
+
+Минималистичный чат-бот для абитуриентов магистратур ITMO, развертываемый в Hugging Face Spaces.
+
+## 🚀 Быстрый деплой в HF Spaces
+
+### 1. Создание Space
+- Перейдите на [Hugging Face Spaces](https://huggingface.co/spaces)
+- Нажмите "Create new Space"
+- Выберите:
+  - **SDK**: Gradio
+  - **Hardware**: CPU basic (2 vCPU, 16GB RAM, FREE)
+  - **License**: MIT
+
+### 2. Загрузка кода
+- Склонируйте созданный репозиторий
+- Скопируйте все файлы проекта
+- Закоммитьте и запушьте изменения
+
+### 3. Автоматический запуск
+- HF Spaces автоматически установит зависимости из `requirements.txt`
+- При первом запуске создадутся тестовые данные
+- Приложение будет доступно по URL вида: `https://huggingface.co/spaces/username/space-name`
+
+## 🎯 Возможности
+
+- **Чат с ботом**: вопросы о программах ИИ и AI Product
+- **Персональные рекомендации**: на основе профиля абитуриента
+- **RAG поиск**: быстрый поиск по курсам
+- **Фильтр релевантности**: отвечает только на вопросы о ITMO
+
+## ⚙️ Быстрые настройки
+
+### Параметры производительности (CPU basic):
+```python
+# В chatbot.py
+max_history_turns = 3          # История диалога
+max_context_tokens = 1200      # Максимум токенов контекста
+relevance_threshold = 0.38     # Порог релевантности
+
+# В retriever.py
+top_k = 6                      # Количество результатов поиска
+max_text_length = 220          # Максимум символов для эмбеддинга
+```
+
+### Ограничения ресурсов:
+- **CPU**: 2 vCPU
+- **RAM**: до 16GB
+- **Диск**: 50GB ephemeral
+- **Время холодного старта**: до 2 минут
+
+## 🔧 Локальный запуск
+
+```bash
+# Установка зависимостей
+pip install -r requirements.txt
+
+# Запуск приложения
+python app.py
+```
+
+Приложение будет доступно по адресу: http://localhost:7860
+
+## 📝 Примеры вопросов
+
+- "Какие дисциплины по NLP в 1 семестре программы ИИ?"
+- "Расскажи о программе AI Product"
+- "Сколько кредитов за курс машинного обучения?"
+- "Какие курсы по глубокому обучению есть в программе ИИ?"
+
+## 🛠️ Технические детали
+
+### Модели:
+- **Генерация**: cointegrated/rut5-base-multitask (~244M параметров)
+- **Эмбеддинги**: sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2
+- **Индекс**: FAISS IndexFlatIP с L2-нормировкой
+
+### Оптимизации:
+- Ленивая загрузка моделей
+- Кэширование данных на диске
+- Fallback режим при ошибках
+- Компактные эмбеддинги (float32, ≤220 символов)
+
+## 🔍 Устранение неполадок
+
+### Проблемы с памятью:
+```python
+max_context_tokens = 800  # Уменьшить с 1200
+top_k = 4                 # Уменьшить с 6
+```
+
+### Проблемы с холодным стартом:
+- Первый запуск может занять 1-2 минуты
+- Данные создаются автоматически при первом обращении
+- Последующие запуски используют кэш
+
+---
+
+**Примечание**: Бот работает с тестовыми данными для быстрого старта. Для реальных данных используйте кнопку "Обновить данные".

app.py

@@ -1,64 +1,224 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-
-if __name__ == "__main__":
-    demo.launch()
+import gradio as gr
+import json
+import os
+
+# Простые тестовые данные
+TEST_COURSES = [
+    {
+        'id': 'ai_1_1',
+        'program_id': 'ai',
+        'semester': 1,
+        'name': 'Машинное обучение',
+        'credits': 6,
+        'hours': 108,
+        'type': 'required',
+        'tags': ['ml', 'math', 'stats'],
+        'short_desc': 'Основы машинного обучения, алгоритмы классификации и регрессии'
+    },
+    {
+        'id': 'ai_1_2',
+        'program_id': 'ai',
+        'semester': 1,
+        'name': 'Глубокое обучение',
+        'credits': 4,
+        'hours': 72,
+        'type': 'required',
+        'tags': ['dl', 'ml', 'neural'],
+        'short_desc': 'Нейронные сети, CNN, RNN, трансформеры'
+    },
+    {
+        'id': 'ai_2_1',
+        'program_id': 'ai',
+        'semester': 2,
+        'name': 'Обработка естественного языка',
+        'credits': 5,
+        'hours': 90,
+        'type': 'required',
+        'tags': ['nlp', 'dl', 'text'],
+        'short_desc': 'Методы обработки текста, токенизация, эмбеддинги'
+    },
+    {
+        'id': 'ai_product_1_1',
+        'program_id': 'ai_product',
+        'semester': 1,
+        'name': 'Продуктовая аналитика',
+        'credits': 6,
+        'hours': 108,
+        'type': 'required',
+        'tags': ['product', 'business', 'data'],
+        'short_desc': 'Анализ продуктовых метрик, A/B тестирование'
+    },
+    {
+        'id': 'ai_product_1_2',
+        'program_id': 'ai_product',
+        'semester': 1,
+        'name': 'Управление проектами',
+        'credits': 4,
+        'hours': 72,
+        'type': 'required',
+        'tags': ['pm', 'business', 'management'],
+        'short_desc': 'Методологии управления проектами, Agile, Scrum'
+    }
+]
+
+def is_itmo_query(message):
+    itmo_keywords = [
+        'итмо', 'магистратура', 'учебный план', 'дисциплина', 'курс',
+        'ии', 'ai', 'ai product', 'институт ии', 'программа',
+        'машинное обучение', 'глубокое обучение', 'nlp', 'компьютерное зрение'
+    ]
+    message_lower = message.lower()
+    return any(keyword in message_lower for keyword in itmo_keywords)
+
+def simple_search(query, courses):
+    query_lower = query.lower()
+    results = []
+    
+    for course in courses:
+        course_text = f"{course['name']} {course['short_desc']}".lower()
+        if any(word in course_text for word in query_lower.split()):
+            results.append(course)
+    
+    return results[:3]  # Возвращаем топ-3 результата
+
+def chat_with_bot(message, history):
+    if not message.strip():
+        return history, ''
+    
+    if not is_itmo_query(message):
+        return history + [[message, '''Похоже, вопрос не относится к магистратурам ITMO и их учебным планам. 
+
+Попробуйте спросить, например:
+• "Какие дисциплины по NLP в 1 семестре программы ИИ?"
+• "Расскажи о программе AI Product"
+• "Какие курсы по машинному обучению есть в программе ИИ?"
+• "Сколько кредитов за дисциплину 'Глубокое обучение'?"''']], ''
+    
+    results = simple_search(message, TEST_COURSES)
+    
+    if not results:
+        response = 'К сожалению, не нашел релевантной информации в учебных планах ITMO.'
+    else:
+        response = 'Найденные курсы:\n\n'
+        for i, course in enumerate(results, 1):
+            response += f'{i}. {course["name"]} ({course["semester"]} семестр, {course["credits"]} кредитов)\n'
+            response += f'   {course["short_desc"]}\n\n'
+    
+    return history + [[message, response]], ''
+
+def get_recommendations(programming_exp, math_level, interests, semester):
+    if not semester:
+        return 'Пожалуйста, укажите семестр для получения рекомендаций.'
+    
+    semester = int(semester)
+    filtered_courses = [c for c in TEST_COURSES if c['semester'] == semester]
+    
+    if not filtered_courses:
+        return f'К сожалению, не найдено курсов для {semester} семестра.'
+    
+    # Простая логика рекомендаций
+    recommendations = []
+    for course in filtered_courses[:5]:  # Топ-5 курсов
+        why = 'Курс из учебного плана программы'
+        if interests:
+            matching_tags = [tag for tag in interests if tag in course.get('tags', [])]
+            if matching_tags:
+                why = f'Соответствует вашим интересам: {", ".join(matching_tags)}'
+        
+        recommendations.append({
+            'name': course['name'],
+            'semester': course['semester'],
+            'credits': course['credits'],
+            'why': why
+        })
+    
+    result = '🎯 Рекомендуемые курсы (из официальных учебных планов ITMO):\n\n'
+    for i, rec in enumerate(recommendations, 1):
+        result += f'{i}. {rec["name"]} ({rec["semester"]} семестр, {rec["credits"]} кредитов)\n'
+        result += f'   {rec["why"]}\n\n'
+    
+    return result
+
+def update_data_ui():
+    return 'Данные успешно обновлены! (Тестовые данные уже загружены)'
+
+def update_data_thread():
+    return gr.update(value='Обновление данных...', interactive=False)
+
+with gr.Blocks(title='ITMO Магистратура - Чат-бот', theme=gr.themes.Soft()) as demo:
+    gr.Markdown('# 🤖 Чат-бот для абитуриентов магистратур ITMO')
+    gr.Markdown('Задавайте вопросы о программах ИИ и AI Product, получайте персональные рекомендации по курсам.')
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            chatbot_interface = gr.ChatInterface(
+                chat_with_bot,
+                title='💬 Чат с ботом',
+                description='Спрашивайте о дисциплинах, программах, учебных планах',
+                examples=[
+                    'Какие дисциплины по NLP в 1 семестре программы ИИ?',
+                    'Расскажи о программе AI Product',
+                    'Какие курсы по машинному обучению есть в программе ИИ?',
+                    'Сколько кредитов за дисциплину "Глубокое обучение"?'
+                ]
+            )
+        
+        with gr.Column(scale=1):
+            gr.Markdown('### 👤 Профиль для рекомендаций')
+            
+            programming_exp = gr.Slider(
+                minimum=0, maximum=5, value=2, step=1,
+                label='Опыт программирования (0-5)',
+                info='0 - нет опыта, 5 - эксперт'
+            )
+            
+            math_level = gr.Slider(
+                minimum=0, maximum=4, value=2, step=1,
+                label='Уровень математики (0-4)',
+                info='0 - базовый, 4 - продвинутый'
+            )
+            
+            interests = gr.CheckboxGroup(
+                choices=['ml', 'dl', 'nlp', 'cv', 'product', 'business', 'research', 'data', 'systems'],
+                value=['ml'],
+                label='Интересы',
+                info='Выберите интересующие направления'
+            )
+            
+            semester = gr.Dropdown(
+                choices=['1', '2', '3', '4'],
+                label='Целевой семестр',
+                info='Для получения рекомендаций'
+            )
+            
+            recommend_btn = gr.Button('🎯 Получить рекомендации', variant='primary')
+            recommendations_output = gr.Textbox(
+                label='Рекомендации',
+                lines=10,
+                interactive=False
+            )
+            
+            recommend_btn.click(
+                get_recommendations,
+                inputs=[programming_exp, math_level, interests, semester],
+                outputs=recommendations_output
+            )
+    
+    with gr.Row():
+        update_btn = gr.Button('🔄 Обновить данные', variant='secondary')
+        update_status = gr.Textbox(
+            label='Статус обновления',
+            interactive=False,
+            visible=False
+        )
+        
+        update_btn.click(
+            update_data_thread,
+            outputs=update_status
+        ).then(
+            update_data_ui,
+            outputs=update_status
+        )
+
+if __name__ == '__main__':
+    demo.launch(server_name='0.0.0.0', server_port=7860)

chatbot.py

@@ -0,0 +1,134 @@
+import re
+import json
+from typing import List, Dict, Tuple
+from knowledge_base import KnowledgeBase
+from retriever import Retriever
+
+class ITMOChatbot:
+    def __init__(self):
+        self.kb = KnowledgeBase()
+        self.retriever = Retriever()
+        self.max_history_turns = 3
+        self.max_context_tokens = 1200
+        self.relevance_threshold = 0.38
+        
+        try:
+            from transformers import pipeline
+            self.generator = pipeline('text2text-generation', model='cointegrated/rut5-base-multitask')
+        except Exception as e:
+            print(f'Генеративная модель не загружена: {e}')
+            self.generator = None
+    
+    def chat(self, message: str, history: list) -> Tuple[str, float]:
+        if not message.strip():
+            return 'Пожалуйста, задайте вопрос.', 0.0
+        
+        if not self.kb.is_itmo_query(message):
+            return self._get_irrelevant_response(), 0.0
+        
+        context = self._get_context(message)
+        if not context:
+            return 'К сожалению, не нашел релевантной информации в учебных планах ITMO.', 0.0
+        
+        response = self._generate_response(message, history, context)
+        relevance_score = self._calculate_relevance_score(message, context)
+        
+        return response, relevance_score
+    
+    def recommend_courses(self, profile: dict) -> str:
+        if not profile.get('semester'):
+            return 'Пожалуйста, укажите целевой семестр для получения рекомендаций.'
+        
+        recommendations = self.kb.recommend(profile)
+        if not recommendations:
+            return 'К сожалению, не удалось найти подходящие курсы для вашего профиля.'
+        
+        result = '🎯 Рекомендуемые курсы (из официальных учебных планов ITMO):\n\n'
+        for i, rec in enumerate(recommendations[:7], 1):
+            result += f'{i}. {rec["name"]} ({rec["semester"]} семестр, {rec["credits"]} кредитов)\n'
+            result += f'   {rec["why"]}\n\n'
+        
+        return result
+    
+    def _get_context(self, message: str) -> List[Dict]:
+        try:
+            results = self.retriever.retrieve(message, k=6, threshold=0.35)
+            # Преобразуем результаты в нужный формат
+            formatted_results = []
+            for result in results:
+                course_id = result.get('course_id')
+                if course_id:
+                    course = self.kb.get_course_by_id(course_id)
+                    if course:
+                        course['score'] = result.get('score', 0.0)
+                        formatted_results.append(course)
+            return formatted_results
+        except Exception as e:
+            print(f'Ошибка при получении контекста: {e}')
+            return []
+    
+    def _generate_response(self, message: str, history: list, context: List[Dict]) -> str:
+        if not context:
+            return 'В предоставленных данных об этом не сказано.'
+        
+        prompt = self._build_prompt(message, history, context)
+        
+        if self.generator:
+            try:
+                response = self.generator(
+                    prompt,
+                    max_new_tokens=180,
+                    temperature=0.4,
+                    do_sample=True
+                )[0]['generated_text']
+                return response.strip()
+            except Exception as e:
+                print(f'Ошибка генерации: {e}')
+        
+        return self._fallback_response(context)
+    
+    def _build_prompt(self, message: str, history: list, context: List[Dict]) -> str:
+        system_prompt = 'Отвечай только по контексту (ниже). Если недостаточно данных — прямо скажи: "в предоставленных данных об этом не сказано". Отвечай кратко и по делу.'
+        
+        history_text = ''
+        if history:
+            recent_history = history[-self.max_history_turns:]
+            for turn in recent_history:
+                history_text += f'Пользователь: {turn[0]}\nБот: {turn[1]}\n'
+        
+        context_text = 'Контекст:\n'
+        for item in context:
+            context_text += f'- {item["name"]} ({item["semester"]} семестр, {item["credits"]} кредитов): {item["short_desc"]}\n'
+        
+        prompt = f'{system_prompt}\n\n{history_text}Контекст:\n{context_text}\nВопрос: {message}'
+        
+        if len(prompt) > self.max_context_tokens * 4:
+            prompt = prompt[:self.max_context_tokens * 4]
+        
+        return prompt
+    
+    def _fallback_response(self, context: List[Dict]) -> str:
+        if not context:
+            return 'В предоставленных данных об этом не сказано.'
+        
+        courses = []
+        for item in context[:3]:
+            courses.append(f'{item["name"]} ({item["semester"]} семестр, {item["credits"]} кредитов)')
+        
+        return f'Найденные курсы: {", ".join(courses)}. Для более подробной информации обратитесь к официальным учебным планам ITMO.'
+    
+    def _calculate_relevance_score(self, message: str, context: List[Dict]) -> float:
+        if not context:
+            return 0.0
+        
+        scores = [item.get('score', 0.0) for item in context]
+        return sum(scores) / len(scores) if scores else 0.0
+    
+    def _get_irrelevant_response(self) -> str:
+        return '''Похоже, вопрос не относится к магистратурам ITMO и их учебным планам. 
+
+Попробуйте спросить, например:
+• "Какие дисциплины по NLP в 1 семестре программы ИИ?"
+• "Расскажи о программе AI Product"
+• "Какие курсы по машинному обучению есть в программе ИИ?"
+• "Сколько кредитов за дисциплину 'Глубокое обучение'?"'''

data/processed/courses.json

@@ -0,0 +1,80 @@
+[
+  {
+    "id": "ai_1_1",
+    "program_id": "ai",
+    "semester": 1,
+    "name": "Машинное обучение",
+    "credits": 6,
+    "hours": 108,
+    "type": "required",
+    "tags": ["ml", "math", "stats"],
+    "short_desc": "Основы машинного обучения, алгоритмы классификации и регрессии",
+    "source_pdf": "ai_curriculum.pdf",
+    "source_page": 1
+  },
+  {
+    "id": "ai_1_2",
+    "program_id": "ai",
+    "semester": 1,
+    "name": "Глубокое обучение",
+    "credits": 4,
+    "hours": 72,
+    "type": "required",
+    "tags": ["dl", "ml", "neural"],
+    "short_desc": "Нейронные сети, CNN, RNN, трансформеры",
+    "source_pdf": "ai_curriculum.pdf",
+    "source_page": 1
+  },
+  {
+    "id": "ai_2_1",
+    "program_id": "ai",
+    "semester": 2,
+    "name": "Обработка естественного языка",
+    "credits": 5,
+    "hours": 90,
+    "type": "required",
+    "tags": ["nlp", "dl", "text"],
+    "short_desc": "Методы обработки текста, токенизация, эмбеддинги",
+    "source_pdf": "ai_curriculum.pdf",
+    "source_page": 2
+  },
+  {
+    "id": "ai_product_1_1",
+    "program_id": "ai_product",
+    "semester": 1,
+    "name": "Продуктовая аналитика",
+    "credits": 6,
+    "hours": 108,
+    "type": "required",
+    "tags": ["product", "business", "data"],
+    "short_desc": "Анализ продуктовых метрик, A/B тестирование",
+    "source_pdf": "ai_product_curriculum.pdf",
+    "source_page": 1
+  },
+  {
+    "id": "ai_product_1_2",
+    "program_id": "ai_product",
+    "semester": 1,
+    "name": "Управление проектами",
+    "credits": 4,
+    "hours": 72,
+    "type": "required",
+    "tags": ["pm", "business", "management"],
+    "short_desc": "Методологии управления проектами, Agile, Scrum",
+    "source_pdf": "ai_product_curriculum.pdf",
+    "source_page": 1
+  },
+  {
+    "id": "ai_product_2_1",
+    "program_id": "ai_product",
+    "semester": 2,
+    "name": "Компьютерное зрение",
+    "credits": 5,
+    "hours": 90,
+    "type": "elective",
+    "tags": ["cv", "dl", "image"],
+    "short_desc": "Обработка изображений, распознавание объектов",
+    "source_pdf": "ai_product_curriculum.pdf",
+    "source_page": 2
+  }
+]

data/processed/programs.json

@@ -0,0 +1,30 @@
+{
+  "ai": {
+    "id": "ai",
+    "title": "Искусственный интеллект",
+    "description": "Магистерская программа по искусственному интеллекту в ITMO",
+    "url": "https://abit.itmo.ru/program/master/ai",
+    "pdf_links": [
+      {
+        "url": "https://abit.itmo.ru/program/master/ai/curriculum",
+        "text": "учебный план",
+        "filename": "ai_curriculum.pdf"
+      }
+    ],
+    "hash": "test_hash_ai"
+  },
+  "ai_product": {
+    "id": "ai_product",
+    "title": "AI Product",
+    "description": "Магистерская программа по продуктовой разработке с ИИ",
+    "url": "https://abit.itmo.ru/program/master/ai_product",
+    "pdf_links": [
+      {
+        "url": "https://abit.itmo.ru/program/master/ai_product/curriculum",
+        "text": "учебный план",
+        "filename": "ai_product_curriculum.pdf"
+      }
+    ],
+    "hash": "test_hash_ai_product"
+  }
+}

knowledge_base.py

@@ -0,0 +1,157 @@
+import json
+import re
+import hashlib
+from typing import List, Dict
+
+class KnowledgeBase:
+    def __init__(self):
+        self.programs = {}
+        self.courses = []
+        self._load_data()
+        
+        self.itmo_keywords = [
+            'итмо', 'магистратура', 'учебный план', 'дисциплина', 'курс',
+            'ии', 'ai', 'ai product', 'институт ии', 'программа',
+            'машинное обучение', 'глубокое обучение', 'nlp', 'компьютерное зрение',
+            'нейронные сети', 'анализ данных', 'продуктовая аналитика'
+        ]
+    
+    def _load_data(self):
+        try:
+            with open('data/processed/programs.json', 'r', encoding='utf-8') as f:
+                self.programs = json.load(f)
+        except FileNotFoundError:
+            print('Файл programs.json не найден')
+        
+        try:
+            with open('data/processed/courses.json', 'r', encoding='utf-8') as f:
+                self.courses = json.load(f)
+        except FileNotFoundError:
+            print('Файл courses.json не найден')
+    
+    def is_itmo_query(self, message: str) -> bool:
+        message_lower = message.lower()
+        
+        keyword_match = any(keyword in message_lower for keyword in self.itmo_keywords)
+        
+        if keyword_match:
+            return True
+        
+        return False
+    
+    def recommend(self, profile: dict) -> List[Dict]:
+        semester = profile.get('semester')
+        if not semester:
+            return []
+        
+        semester = int(semester)
+        interests = profile.get('interests', [])
+        programming_exp = profile.get('programming_experience', 2)
+        math_level = profile.get('math_level', 2)
+        
+        filtered_courses = [
+            course for course in self.courses 
+            if course.get('semester') == semester
+        ]
+        
+        if not filtered_courses:
+            return []
+        
+        scored_courses = []
+        for course in filtered_courses:
+            score = self._calculate_recommendation_score(course, profile)
+            scored_courses.append((course, score))
+        
+        scored_courses.sort(key=lambda x: x[1], reverse=True)
+        
+        recommendations = []
+        for course, score in scored_courses[:7]:
+            why = self._generate_recommendation_reason(course, profile)
+            recommendations.append({
+                'semester': course['semester'],
+                'name': course['name'],
+                'credits': course['credits'],
+                'why': why
+            })
+        
+        return recommendations
+    
+    def _calculate_recommendation_score(self, course: dict, profile: dict) -> float:
+        interests = profile.get('interests', [])
+        programming_exp = profile.get('programming_experience', 2)
+        math_level = profile.get('math_level', 2)
+        
+        course_text = f"{course.get('name', '')} {course.get('short_desc', '')}".lower()
+        course_tags = course.get('tags', [])
+        
+        similarity_score = 0.0
+        if interests:
+            interest_matches = sum(1 for interest in interests if interest in course_tags)
+            similarity_score = interest_matches / len(interests)
+        
+        rule_score = 0.0
+        
+        if programming_exp >= 3:
+            if any(tag in course_tags for tag in ['ml', 'dl', 'systems']):
+                rule_score += 0.3
+        
+        if 'product' in interests or 'business' in interests:
+            if any(tag in course_tags for tag in ['product', 'business', 'pm']):
+                rule_score += 0.3
+        
+        if math_level >= 3:
+            if any(tag in course_tags for tag in ['math', 'stats', 'dl']):
+                rule_score += 0.3
+        
+        generic_score = 0.1
+        
+        final_score = 0.6 * similarity_score + 0.3 * rule_score + 0.1 * generic_score
+        return final_score
+    
+    def _generate_recommendation_reason(self, course: dict, profile: dict) -> str:
+        interests = profile.get('interests', [])
+        course_tags = course.get('tags', [])
+        
+        matching_tags = [tag for tag in interests if tag in course_tags]
+        
+        if matching_tags:
+            tag_names = {
+                'ml': 'машинное обучение',
+                'dl': 'глубокое обучение',
+                'nlp': 'обработка естественного языка',
+                'cv': 'компьютерное зрение',
+                'product': 'продуктовая разработка',
+                'business': 'бизнес-аналитика',
+                'research': 'исследования',
+                'data': 'анализ данных',
+                'systems': 'системная архитектура'
+            }
+            
+            tag_descriptions = [tag_names.get(tag, tag) for tag in matching_tags]
+            return f'Соответствует вашим интересам: {", ".join(tag_descriptions)}'
+        
+        return 'Курс из учебного плана программы'
+    
+    def get_course_by_id(self, course_id: str) -> dict:
+        for course in self.courses:
+            if course.get('id') == course_id:
+                return course
+        return {}
+    
+    def get_program_by_id(self, program_id: str) -> dict:
+        return self.programs.get(program_id, {})
+    
+    def search_courses(self, query: str, limit: int = 10) -> List[Dict]:
+        query_lower = query.lower()
+        results = []
+        
+        for course in self.courses:
+            course_text = f"{course.get('name', '')} {course.get('short_desc', '')}".lower()
+            
+            if query_lower in course_text:
+                results.append(course)
+            
+            if len(results) >= limit:
+                break
+        
+        return results

prompts/system.txt

@@ -0,0 +1,12 @@
+Ты - помощник для абитуриентов магистратур ITMO. Отвечай только по контексту, предоставленному ниже. 
+
+ПРАВИЛА:
+1. Отвечай только на основе информации из контекста
+2. Если в контексте нет ответа - прямо скажи: "в предоставленных данных об этом не сказано"
+3. Отвечай кратко и по делу
+4. Не выдумывай информацию
+5. Если спрашивают о курсах - указывай семестр и количество кредитов
+6. Если спрашивают о программах - давай краткое описание из контекста
+7. Будь вежливым и полезным
+
+Контекст содержит информацию о курсах из официальных учебных планов ITMO.

requirements.txt

@@ -1 +1 @@
-huggingface_hub==0.25.2
+gradio==4.44.0

retriever.py

@@ -0,0 +1,126 @@
+import os
+import json
+import numpy as np
+import faiss
+from typing import List, Dict
+from sentence_transformers import SentenceTransformer
+
+class Retriever:
+    def __init__(self):
+        self.model = None
+        self.index = None
+        self.meta = {}
+        self.embeddings = None
+        self._load_index()
+    
+    def _load_index(self):
+        try:
+            if os.path.exists('data/index/index.faiss') and os.path.exists('data/index/meta.json'):
+                self.index = faiss.read_index('data/index/index.faiss')
+                self.embeddings = np.load('data/index/embeddings.npy')
+                
+                with open('data/index/meta.json', 'r', encoding='utf-8') as f:
+                    self.meta = json.load(f)
+                
+                print('Индекс загружен из кэша')
+            else:
+                print('Индекс не найден, будет создан при первом использовании')
+        except Exception as e:
+            print(f'Ошибка загрузки индекса: {e}')
+    
+    def _load_model(self):
+        if self.model is None:
+            try:
+                self.model = SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
+                print('Модель эмбеддингов загружена')
+            except Exception as e:
+                print(f'Ошибка загрузки модели: {e}')
+                raise
+    
+    def _build_index(self, courses: List[Dict]):
+        if not courses:
+            return
+        
+        self._load_model()
+        
+        texts = []
+        meta_data = {}
+        
+        for i, course in enumerate(courses):
+            text = f"{course.get('name', '')} {course.get('short_desc', '')}"
+            text = text.lower().strip()
+            
+            if len(text) > 220:
+                text = text[:220]
+            
+            texts.append(text)
+            meta_data[i] = course.get('id', str(i))
+        
+        if not texts:
+            return
+        
+        embeddings = self.model.encode(texts, convert_to_numpy=True, show_progress_bar=True)
+        
+        embeddings = embeddings.astype(np.float32)
+        faiss.normalize_L2(embeddings)
+        
+        self.index = faiss.IndexFlatIP(embeddings.shape[1])
+        self.index.add(embeddings)
+        self.embeddings = embeddings
+        self.meta = meta_data
+        
+        self._save_index()
+    
+    def _save_index(self):
+        try:
+            os.makedirs('data/index', exist_ok=True)
+            
+            faiss.write_index(self.index, 'data/index/index.faiss')
+            np.save('data/index/embeddings.npy', self.embeddings)
+            
+            with open('data/index/meta.json', 'w', encoding='utf-8') as f:
+                json.dump(self.meta, f, ensure_ascii=False, indent=2)
+            
+            print('Индекс сохранен')
+        except Exception as e:
+            print(f'Ошибка сохранения индекса: {e}')
+    
+    def retrieve(self, query: str, k: int = 6, threshold: float = 0.35) -> List[Dict]:
+        if self.index is None:
+            return []
+        
+        self._load_model()
+        
+        query_embedding = self.model.encode([query.lower().strip()], convert_to_numpy=True)
+        query_embedding = query_embedding.astype(np.float32)
+        faiss.normalize_L2(query_embedding)
+        
+        scores, indices = self.index.search(query_embedding, k)
+        
+        results = []
+        for score, idx in zip(scores[0], indices[0]):
+            if score >= threshold and idx in self.meta:
+                course_id = self.meta[idx]
+                results.append({
+                    'course_id': course_id,
+                    'score': float(score)
+                })
+        
+        return results
+    
+    def build_or_load_index(self, courses: List[Dict] = None):
+        if self.index is None and courses:
+            print('Создание индекса...')
+            self._build_index(courses)
+        elif self.index is None:
+            print('Индекс не найден и данные не предоставлены')
+    
+    def get_embedding_dim(self) -> int:
+        if self.embeddings is not None:
+            return self.embeddings.shape[1]
+        return 0
+    
+    def get_index_size(self) -> int:
+        if self.index is not None:
+            return self.index.ntotal
+        return 0

scraper/html_scraper.py

@@ -0,0 +1,143 @@
+import requests
+import re
+from bs4 import BeautifulSoup
+from typing import List, Dict
+import hashlib
+import json
+import os
+
+class HTMLScraper:
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        })
+        
+        self.program_urls = {
+            'ai': 'https://abit.itmo.ru/program/master/ai',
+            'ai_product': 'https://abit.itmo.ru/program/master/ai_product'
+        }
+    
+    def scrape_programs(self) -> Dict:
+        programs = {}
+        
+        for program_id, url in self.program_urls.items():
+            try:
+                print(f'Скрапинг программы {program_id}...')
+                program_data = self._scrape_program_page(url, program_id)
+                programs[program_id] = program_data
+            except Exception as e:
+                print(f'Ошибка при скрапинге {program_id}: {e}')
+        
+        return programs
+    
+    def _scrape_program_page(self, url: str, program_id: str) -> Dict:
+        response = self.session.get(url, timeout=30)
+        response.raise_for_status()
+        
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        title = self._extract_title(soup)
+        description = self._extract_description(soup)
+        pdf_links = self._extract_pdf_links(soup, url)
+        
+        program_data = {
+            'id': program_id,
+            'title': title,
+            'description': description,
+            'url': url,
+            'pdf_links': pdf_links,
+            'hash': self._calculate_hash(response.content)
+        }
+        
+        return program_data
+    
+    def _extract_title(self, soup: BeautifulSoup) -> str:
+        title_elem = soup.find('h1') or soup.find('title')
+        if title_elem:
+            return title_elem.get_text().strip()
+        return ''
+    
+    def _extract_description(self, soup: BeautifulSoup) -> str:
+        desc_selectors = [
+            '.program-description',
+            '.description',
+            '.program-info',
+            'p',
+            '.content'
+        ]
+        
+        for selector in desc_selectors:
+            elem = soup.select_one(selector)
+            if elem:
+                text = elem.get_text().strip()
+                if len(text) > 50:
+                    return text[:500]
+        
+        return ''
+    
+    def _extract_pdf_links(self, soup: BeautifulSoup, base_url: str) -> List[Dict]:
+        pdf_links = []
+        
+        for link in soup.find_all('a', href=True):
+            href = link.get('href', '')
+            text = link.get_text().strip().lower()
+            
+            if self._is_pdf_link(href, text):
+                full_url = self._make_absolute_url(href, base_url)
+                pdf_links.append({
+                    'url': full_url,
+                    'text': text,
+                    'filename': self._extract_filename(href)
+                })
+        
+        return pdf_links
+    
+    def _is_pdf_link(self, href: str, text: str) -> bool:
+        pdf_indicators = [
+            'учебный план', 'учебный план', 'curriculum', 'plan',
+            'pdf', '.pdf', 'программа', 'program'
+        ]
+        
+        href_lower = href.lower()
+        return any(indicator in href_lower or indicator in text for indicator in pdf_indicators)
+    
+    def _make_absolute_url(self, href: str, base_url: str) -> str:
+        if href.startswith('http'):
+            return href
+        elif href.startswith('/'):
+            base = '/'.join(base_url.split('/')[:3])
+            return base + href
+        else:
+            return base_url.rstrip('/') + '/' + href.lstrip('/')
+    
+    def _extract_filename(self, href: str) -> str:
+        filename = href.split('/')[-1]
+        if not filename.endswith('.pdf'):
+            filename += '.pdf'
+        return filename
+    
+    def _calculate_hash(self, content: bytes) -> str:
+        return hashlib.sha256(content).hexdigest()
+    
+    def save_programs(self, programs: Dict, output_path: str = 'data/processed/programs.json'):
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(programs, f, ensure_ascii=False, indent=2)
+        
+        print(f'Программы сохранены в {output_path}')
+
+def main():
+    scraper = HTMLScraper()
+    programs = scraper.scrape_programs()
+    scraper.save_programs(programs)
+    
+    for program_id, program in programs.items():
+        print(f'\n{program["title"]}:')
+        print(f'PDF ссылок найдено: {len(program["pdf_links"])}')
+        for link in program['pdf_links']:
+            print(f'  - {link["filename"]}: {link["url"]}')
+
+if __name__ == '__main__':
+    main()

scraper/normalize.py

@@ -0,0 +1,206 @@
+import re
+import hashlib
+from typing import List, Dict
+
+class DataNormalizer:
+    def __init__(self):
+        self.tag_keywords = {
+            'ml': ['машинное обучение', 'machine learning', 'ml', 'алгоритм', 'модель'],
+            'dl': ['глубокое обучение', 'deep learning', 'нейронная сеть', 'cnn', 'rnn', 'transformer'],
+            'nlp': ['nlp', 'обработка естественного языка', 'natural language', 'текст', 'язык'],
+            'cv': ['компьютерное зрение', 'computer vision', 'cv', 'изображение', 'видео'],
+            'math': ['математика', 'математический', 'алгебра', 'геометрия', 'анализ'],
+            'stats': ['статистика', 'вероятность', 'статистический', 'probability'],
+            'product': ['продукт', 'product', 'разработка продукта', 'продуктовая'],
+            'business': ['бизнес', 'business', 'менеджмент', 'управление', 'экономика'],
+            'pm': ['project management', 'управление проектами', 'pm', 'проект'],
+            'systems': ['система', 'system', 'архитектура', 'инфраструктура'],
+            'data': ['данные', 'data', 'анализ данных', 'big data', 'база данных']
+        }
+    
+    def normalize_courses(self, courses: List[Dict]) -> List[Dict]:
+        normalized_courses = []
+        seen_hashes = set()
+        
+        for course in courses:
+            normalized = self._normalize_course(course)
+            if normalized:
+                course_hash = self._calculate_course_hash(normalized)
+                if course_hash not in seen_hashes:
+                    seen_hashes.add(course_hash)
+                    normalized_courses.append(normalized)
+        
+        return normalized_courses
+    
+    def _normalize_course(self, course: Dict) -> Dict:
+        if not course.get('name'):
+            return None
+        
+        normalized = course.copy()
+        
+        normalized['name'] = self._normalize_name(course['name'])
+        normalized['short_desc'] = self._generate_short_desc(course)
+        normalized['tags'] = self._generate_tags(course)
+        
+        normalized['semester'] = self._normalize_semester(course.get('semester', 1))
+        normalized['credits'] = self._normalize_credits(course.get('credits', 0))
+        normalized['hours'] = self._normalize_hours(course.get('hours', 0))
+        normalized['type'] = self._normalize_type(course.get('type', 'required'))
+        
+        return normalized
+    
+    def _normalize_name(self, name: str) -> str:
+        if not name:
+            return ''
+        
+        name = str(name).strip()
+        name = re.sub(r'\s+', ' ', name)
+        name = name.replace('"', '').replace('"', '')
+        
+        return name
+    
+    def _generate_short_desc(self, course: dict) -> str:
+        name = course.get('name', '')
+        desc = course.get('description', '')
+        
+        if desc:
+            desc = str(desc).strip()
+            if len(desc) > 220:
+                desc = desc[:220] + '...'
+            return desc
+        
+        if name and len(name) > 50:
+            return name[:220]
+        
+        return 'Курс из учебного плана программы'
+    
+    def _generate_tags(self, course: Dict) -> List[str]:
+        text = f"{course.get('name', '')} {course.get('short_desc', '')}".lower()
+        tags = []
+        
+        for tag, keywords in self.tag_keywords.items():
+            if any(keyword in text for keyword in keywords):
+                tags.append(tag)
+        
+        return tags
+    
+    def _normalize_semester(self, semester) -> int:
+        try:
+            semester = int(semester)
+            if 1 <= semester <= 4:
+                return semester
+        except (ValueError, TypeError):
+            pass
+        
+        return 1
+    
+    def _normalize_credits(self, credits) -> int:
+        try:
+            credits = int(credits)
+            if credits >= 0:
+                return credits
+        except (ValueError, TypeError):
+            pass
+        
+        return 0
+    
+    def _normalize_hours(self, hours) -> int:
+        try:
+            hours = int(hours)
+            if hours >= 0:
+                return hours
+        except (ValueError, TypeError):
+            pass
+        
+        return 0
+    
+    def _normalize_type(self, course_type: str) -> str:
+        if not course_type:
+            return 'required'
+        
+        type_lower = str(course_type).lower()
+        
+        if any(word in type_lower for word in ['обязательная', 'required', 'обяз']):
+            return 'required'
+        elif any(word in type_lower for word in ['по выбору', 'elective', 'выбор']):
+            return 'elective'
+        
+        return 'required'
+    
+    def _calculate_course_hash(self, course: Dict) -> str:
+        text = f"{course.get('name', '')}{course.get('program_id', '')}{course.get('semester', '')}"
+        return hashlib.md5(text.encode()).hexdigest()
+    
+    def merge_courses(self, courses_list: List[List[Dict]]) -> List[Dict]:
+        all_courses = []
+        for courses in courses_list:
+            all_courses.extend(courses)
+        
+        return self.normalize_courses(all_courses)
+    
+    def validate_course(self, course: Dict) -> bool:
+        required_fields = ['name', 'program_id', 'semester']
+        
+        for field in required_fields:
+            if not course.get(field):
+                return False
+        
+        if len(course.get('name', '')) < 3:
+            return False
+        
+        return True
+    
+    def get_statistics(self, courses: List[Dict]) -> Dict:
+        stats = {
+            'total_courses': len(courses),
+            'by_program': {},
+            'by_semester': {},
+            'by_type': {},
+            'by_tags': {}
+        }
+        
+        for course in courses:
+            program_id = course.get('program_id', 'unknown')
+            semester = course.get('semester', 1)
+            course_type = course.get('type', 'required')
+            tags = course.get('tags', [])
+            
+            stats['by_program'][program_id] = stats['by_program'].get(program_id, 0) + 1
+            stats['by_semester'][semester] = stats['by_semester'].get(semester, 0) + 1
+            stats['by_type'][course_type] = stats['by_type'].get(course_type, 0) + 1
+            
+            for tag in tags:
+                stats['by_tags'][tag] = stats['by_tags'].get(tag, 0) + 1
+        
+        return stats
+
+def main():
+    normalizer = DataNormalizer()
+    
+    test_courses = [
+        {
+            'id': 'test_1',
+            'program_id': 'ai',
+            'name': 'Машинное обучение',
+            'semester': 1,
+            'credits': 6,
+            'type': 'required'
+        },
+        {
+            'id': 'test_2',
+            'program_id': 'ai_product',
+            'name': 'Глубокое обучение',
+            'semester': 2,
+            'credits': 4,
+            'type': 'elective'
+        }
+    ]
+    
+    normalized = normalizer.normalize_courses(test_courses)
+    stats = normalizer.get_statistics(normalized)
+    
+    print(f'Нормализовано курсов: {len(normalized)}')
+    print(f'Статистика: {stats}')
+
+if __name__ == '__main__':
+    main()

scraper/pdf_parser.py

@@ -0,0 +1,244 @@
+import pdfplumber
+import requests
+import re
+from typing import List, Dict
+import os
+from tqdm import tqdm
+
+class PDFParser:
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        })
+    
+    def download_pdf(self, url: str, filename: str) -> str:
+        local_path = os.path.join('data/raw', filename)
+        
+        if os.path.exists(local_path):
+            print(f'PDF уже загружен: {filename}')
+            return local_path
+        
+        try:
+            print(f'Загрузка PDF: {url}')
+            response = self.session.get(url, stream=True, timeout=60)
+            response.raise_for_status()
+            
+            os.makedirs('data/raw', exist_ok=True)
+            
+            with open(local_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            
+            print(f'PDF сохранен: {local_path}')
+            return local_path
+            
+        except Exception as e:
+            print(f'Ошибка загрузки PDF {url}: {e}')
+            return None
+    
+    def parse_pdf(self, pdf_path: str, program_id: str) -> List[Dict]:
+        courses = []
+        
+        try:
+            with pdfplumber.open(pdf_path) as pdf:
+                print(f'Парсинг PDF: {pdf_path}')
+                
+                for page_num, page in enumerate(tqdm(pdf.pages, desc='Страницы')):
+                    page_courses = self._parse_page(page, page_num + 1, program_id)
+                    courses.extend(page_courses)
+                
+                print(f'Найдено курсов: {len(courses)}')
+                
+        except Exception as e:
+            print(f'Ошибка парсинга PDF {pdf_path}: {e}')
+        
+        return courses
+    
+    def _parse_page(self, page, page_num: int, program_id: str) -> List[Dict]:
+        courses = []
+        
+        try:
+            tables = page.extract_tables()
+            
+            for table in tables:
+                table_courses = self._parse_table(table, page_num, program_id)
+                courses.extend(table_courses)
+            
+            if not courses:
+                courses = self._parse_text_fallback(page, page_num, program_id)
+                
+        except Exception as e:
+            print(f'Ошибка парсинга страницы {page_num}: {e}')
+        
+        return courses
+    
+    def _parse_table(self, table: list, page_num: int, program_id: str) -> List[Dict]:
+        courses = []
+        
+        if not table or len(table) < 2:
+            return courses
+        
+        headers = [str(cell).lower().strip() if cell else '' for cell in table[0]]
+        
+        for row_idx, row in enumerate(table[1:], 1):
+            if not row or len(row) < 3:
+                continue
+            
+            course = self._extract_course_from_row(row, headers, page_num, program_id)
+            if course:
+                courses.append(course)
+        
+        return courses
+    
+    def _extract_course_from_row(self, row: list, headers: list, page_num: int, program_id: str) -> Dict:
+        try:
+            row = [str(cell).strip() if cell else '' for cell in row]
+            
+            name = self._extract_name(row, headers)
+            if not name or len(name) < 3:
+                return None
+            
+            semester = self._extract_semester(row, headers)
+            credits = self._extract_credits(row, headers)
+            hours = self._extract_hours(row, headers)
+            course_type = self._extract_type(row, headers)
+            
+            course = {
+                'id': f'{program_id}_{page_num}_{hash(name) % 10000}',
+                'program_id': program_id,
+                'semester': semester,
+                'name': name,
+                'credits': credits,
+                'hours': hours,
+                'type': course_type,
+                'source_pdf': os.path.basename(program_id),
+                'source_page': page_num
+            }
+            
+            return course
+            
+        except Exception as e:
+            print(f'Ошибка извлечения курса из строки: {e}')
+            return None
+    
+    def _extract_name(self, row: list, headers: list) -> str:
+        name_indicators = ['название', 'дисциплина', 'курс', 'предмет', 'name', 'course']
+        
+        for i, header in enumerate(headers):
+            if any(indicator in header for indicator in name_indicators):
+                if i < len(row) and row[i]:
+                    return row[i]
+        
+        if len(row) > 0 and row[0]:
+            return row[0]
+        
+        return ''
+    
+    def _extract_semester(self, row: list, headers: list) -> int:
+        semester_indicators = ['семестр', 'semester', 'сем']
+        
+        for i, header in enumerate(headers):
+            if any(indicator in header for indicator in semester_indicators):
+                if i < len(row) and row[i]:
+                    try:
+                        return int(re.findall(r'\d+', row[i])[0])
+                    except:
+                        pass
+        
+        return 1
+    
+    def _extract_credits(self, row: list, headers: list) -> int:
+        credit_indicators = ['кредит', 'credit', 'зет', 'з.е.']
+        
+        for i, header in enumerate(headers):
+            if any(indicator in header for indicator in credit_indicators):
+                if i < len(row) and row[i]:
+                    try:
+                        return int(re.findall(r'\d+', row[i])[0])
+                    except:
+                        pass
+        
+        return 0
+    
+    def _extract_hours(self, row: list, headers: list) -> int:
+        hour_indicators = ['час', 'hour', 'ауд']
+        
+        for i, header in enumerate(headers):
+            if any(indicator in header for indicator in hour_indicators):
+                if i < len(row) and row[i]:
+                    try:
+                        return int(re.findall(r'\d+', row[i])[0])
+                    except:
+                        pass
+        
+        return 0
+    
+    def _extract_type(self, row: list, headers: list) -> str:
+        type_indicators = ['тип', 'type', 'вид']
+        
+        for i, header in enumerate(headers):
+            if any(indicator in header for indicator in type_indicators):
+                if i < len(row) and row[i]:
+                    text = row[i].lower()
+                    if any(word in text for word in ['обязательная', 'required', 'обяз']):
+                        return 'required'
+                    elif any(word in text for word in ['по выбору', 'elective', 'выбор']):
+                        return 'elective'
+        
+        return 'required'
+    
+    def _parse_text_fallback(self, page, page_num: int, program_id: str) -> List[Dict]:
+        courses = []
+        
+        try:
+            text = page.extract_text()
+            if not text:
+                return courses
+            
+            lines = text.split('\n')
+            current_semester = 1
+            
+            for line in lines:
+                line = line.strip()
+                if not line:
+                    continue
+                
+                if 'семестр' in line.lower():
+                    semester_match = re.findall(r'\d+', line)
+                    if semester_match:
+                        current_semester = int(semester_match[0])
+                    continue
+                
+                if len(line) > 10 and not line.isdigit():
+                    course = {
+                        'id': f'{program_id}_{page_num}_{hash(line) % 10000}',
+                        'program_id': program_id,
+                        'semester': current_semester,
+                        'name': line,
+                        'credits': 0,
+                        'hours': 0,
+                        'type': 'required',
+                        'source_pdf': os.path.basename(program_id),
+                        'source_page': page_num
+                    }
+                    courses.append(course)
+                    
+        except Exception as e:
+            print(f'Ошибка fallback парсинга страницы {page_num}: {e}')
+        
+        return courses
+
+def main():
+    parser = PDFParser()
+    
+    test_url = 'https://example.com/test.pdf'
+    test_filename = 'test.pdf'
+    
+    local_path = parser.download_pdf(test_url, test_filename)
+    if local_path:
+        courses = parser.parse_pdf(local_path, 'test_program')
+        print(f'Найдено курсов: {len(courses)}')
+
+if __name__ == '__main__':
+    main()

tests/test_filter.py

@@ -0,0 +1,33 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from knowledge_base import KnowledgeBase
+
+def test_itmo_query_filter():
+    kb = KnowledgeBase()
+    
+    test_cases = [
+        ('Какие дисциплины по NLP в 1 семестре программы ИИ?', True),
+        ('Расскажи о программе AI Product', True),
+        ('Сколько кредитов за курс машинного обучения?', True),
+        ('Какая погода в Санкт-Петербурге?', False),
+        ('Как приготовить борщ?', False),
+        ('Расскажи о программе ИИ в ITMO', True),
+        ('Какие курсы по глубокому обучению?', True),
+        ('Как добраться до метро?', False),
+        ('Учебный план магистратуры', True),
+        ('Дисциплины по компьютерному зрению', True)
+    ]
+    
+    print('Тестирование фильтра релевантности...')
+    
+    for query, expected in test_cases:
+        result = kb.is_itmo_query(query)
+        status = '✓' if result == expected else '✗'
+        print(f'{status} "{query}" -> {result} (ожидалось {expected})')
+    
+    print('\nТест завершен')
+
+if __name__ == '__main__':
+    test_itmo_query_filter()

tests/test_recommend.py

@@ -0,0 +1,56 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from knowledge_base import KnowledgeBase
+
+def test_recommendations():
+    kb = KnowledgeBase()
+    
+    test_profiles = [
+        {
+            'name': 'ML профиль',
+            'profile': {
+                'programming_experience': 4,
+                'math_level': 3,
+                'interests': ['ml', 'dl', 'nlp'],
+                'semester': 1
+            }
+        },
+        {
+            'name': 'Product профиль',
+            'profile': {
+                'programming_experience': 2,
+                'math_level': 1,
+                'interests': ['product', 'business'],
+                'semester': 2
+            }
+        },
+        {
+            'name': 'Research профиль',
+            'profile': {
+                'programming_experience': 3,
+                'math_level': 4,
+                'interests': ['research', 'math', 'stats'],
+                'semester': 3
+            }
+        }
+    ]
+    
+    print('Тестирование системы рекомендаций...')
+    
+    for test_case in test_profiles:
+        print(f'\n{test_case["name"]}:')
+        recommendations = kb.recommend(test_case['profile'])
+        
+        if recommendations:
+            print(f'Найдено рекомендаций: {len(recommendations)}')
+            for i, rec in enumerate(recommendations[:3], 1):
+                print(f'  {i}. {rec["name"]} ({rec["semester"]} семестр)')
+        else:
+            print('Рекомендации не найдены')
+    
+    print('\nТест завершен')
+
+if __name__ == '__main__':
+    test_recommendations()

update_data.py

@@ -0,0 +1,153 @@
+import json
+import os
+import sys
+from typing import List, Dict, Tuple
+from scraper.html_scraper import HTMLScraper
+from scraper.pdf_parser import PDFParser
+from scraper.normalize import DataNormalizer
+from retriever import Retriever
+
+def update_data_async():
+    try:
+        print('Начинаем обновление данных...')
+        
+        # Проверяем, есть ли уже данные
+        if check_data_exists():
+            print('Данные уже существуют, пропускаем обновление')
+            return
+        
+        # Создаем тестовые данные для быстрого старта
+        print('Создание тестовых данных...')
+        
+        normalizer = DataNormalizer()
+        
+        # Тестовые курсы
+        test_courses = [
+            {
+                'id': 'ai_1_1',
+                'program_id': 'ai',
+                'semester': 1,
+                'name': 'Машинное обучение',
+                'credits': 6,
+                'hours': 108,
+                'type': 'required',
+                'short_desc': 'Основы машинного обучения, алгоритмы классификации и регрессии'
+            },
+            {
+                'id': 'ai_1_2',
+                'program_id': 'ai',
+                'semester': 1,
+                'name': 'Глубокое обучение',
+                'credits': 4,
+                'hours': 72,
+                'type': 'required',
+                'short_desc': 'Нейронные сети, CNN, RNN, трансформеры'
+            },
+            {
+                'id': 'ai_2_1',
+                'program_id': 'ai',
+                'semester': 2,
+                'name': 'Обработка естественного языка',
+                'credits': 5,
+                'hours': 90,
+                'type': 'required',
+                'short_desc': 'Методы обработки текста, токенизация, эмбеддинги'
+            },
+            {
+                'id': 'ai_product_1_1',
+                'program_id': 'ai_product',
+                'semester': 1,
+                'name': 'Продуктовая аналитика',
+                'credits': 6,
+                'hours': 108,
+                'type': 'required',
+                'short_desc': 'Анализ продуктовых метрик, A/B тестирование'
+            },
+            {
+                'id': 'ai_product_1_2',
+                'program_id': 'ai_product',
+                'semester': 1,
+                'name': 'Управление проектами',
+                'credits': 4,
+                'hours': 72,
+                'type': 'required',
+                'short_desc': 'Методологии управления проектами, Agile, Scrum'
+            }
+        ]
+        
+        print(f'Нормализация {len(test_courses)} курсов...')
+        normalized_courses = normalizer.normalize_courses(test_courses)
+        
+        save_courses(normalized_courses)
+        
+        print('Создание индекса...')
+        retriever = Retriever()
+        retriever.build_or_load_index(normalized_courses)
+        
+        stats = normalizer.get_statistics(normalized_courses)
+        print(f'Статистика: {stats}')
+        
+        print('Обновление данных завершено успешно!')
+            
+    except Exception as e:
+        print(f'Ошибка обновления данных: {e}')
+        raise
+
+def save_courses(courses: List[Dict], output_path: str = 'data/processed/courses.json'):
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(courses, f, ensure_ascii=False, indent=2)
+    
+    print(f'Курсы сохранены в {output_path}')
+
+def check_data_exists() -> bool:
+    programs_path = 'data/processed/programs.json'
+    courses_path = 'data/processed/courses.json'
+    index_path = 'data/index/index.faiss'
+    
+    return all(os.path.exists(path) for path in [programs_path, courses_path, index_path])
+
+def load_existing_data() -> Tuple[Dict, List[Dict]]:
+    programs = {}
+    courses = []
+    
+    try:
+        with open('data/processed/programs.json', 'r', encoding='utf-8') as f:
+            programs = json.load(f)
+    except FileNotFoundError:
+        print('Файл programs.json не найден')
+    
+    try:
+        with open('data/processed/courses.json', 'r', encoding='utf-8') as f:
+            courses = json.load(f)
+    except FileNotFoundError:
+        print('Файл courses.json не найден')
+    
+    return programs, courses
+
+def initialize_data():
+    if check_data_exists():
+        print('Данные уже существуют, загружаем...')
+        programs, courses = load_existing_data()
+        
+        if courses:
+            retriever = Retriever()
+            retriever.build_or_load_index(courses)
+            print(f'Загружено {len(courses)} курсов')
+        else:
+            print('Курсы не найдены, запускаем обновление...')
+            update_data_async()
+    else:
+        print('Данные не найдены, запускаем первичное обновление...')
+        update_data_async()
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] == '--force':
+        print('Принудительное обновление данных...')
+        update_data_async()
+    else:
+        initialize_data()
+
+if __name__ == '__main__':
+    main()