Upload 18 files

.dockerignore

@@ -0,0 +1,31 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+pip-log.txt
+pip-delete-this-directory.txt
+.tox
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.mypy_cache
+.pytest_cache
+.hypothesis
+.DS_Store
+.env
+.venv
+venv/
+ENV/
+env/
+.idea/
+.vscode/
+*.swp
+*.swo
+*~

Dockerfile

@@ -1,21 +1,22 @@
-FROM python:3.9-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+FROM python:3.10-slim
+
+# Устанавливаем рабочую директорию
+WORKDIR /app
+
+# Копируем requirements.txt
+COPY requirements.txt .
+
+# Устанавливаем зависимости
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Копируем код приложения
+COPY . .
+
+# Создаем директории для данных
+RUN mkdir -p data/processed
+
+# Открываем порт
+EXPOSE 5000
+
+# Запускаем приложение
+CMD ["python", "app.py"]

README.md

@@ -1,20 +1,212 @@
 ---
-title: Test1
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+title: ITMO Магистратура - Чат-бот
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
 pinned: false
-short_description: Streamlit template space
-license: apache-2.0
 ---
 
-# Welcome to Streamlit!
+# 🤖 ITMO Магистратура - Чат-бот (Docker)
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+Минимально работающий прототип чат-бота для абитуриентов магистратур ITMO с парсингом данных, диалоговой системой и персонализированными рекомендациями.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## 🎯 Ключевые функции
+
+### 1. 📊 Парсинг данных с сайтов ITMO
+- **Автоматический сбор** учебных планов с официальных страниц
+- **Парсинг PDF файлов** с детальной информацией о курсах
+- **Fallback курсы** при недоступности парсинга
+- **Нормализация данных** в единый JSON формат
+
+### 2. 💬 Диалоговая система (одна LLM, без RAG)
+- **LLM-powered чат** на основе RuT5-base-multitask
+- **Строгая релевантность** - отвечает только на вопросы об ITMO
+- **Контекстный поиск** по курсам и программам
+- **Fallback режим** при недоступности LLM
+
+### 3. 🎯 Персонализированные рекомендации
+- **Учет профиля студента** (опыт программирования, математика, интересы)
+- **Алгоритм подбора курсов** на основе сложности и предпочтений
+- **Рекомендации по семестрам** с объяснением выбора
+- **LLM-генерация** персонализированных советов
+
+## 🚀 Быстрый старт
+
+### Локальный запуск с Docker
+
+```bash
+# Клонируем репозиторий
+git clone <your-repo-url>
+cd <your-repo-name>
+
+# Запускаем с Docker Compose
+docker-compose up --build
+
+# Или с Docker напрямую
+docker build -t itmo-chatbot .
+docker run -p 5000:5000 itmo-chatbot
+```
+
+### Ручной запуск
+
+```bash
+# Устанавливаем зависимости
+pip install -r requirements.txt
+
+# Запускаем приложение
+python app.py
+```
+
+Приложение будет доступно по адресу: http://localhost:5000
+
+## 📁 Структура проекта
+
+```
+├── app.py              # Flask приложение
+├── parser.py           # Парсинг данных с сайтов ITMO
+├── data_layer.py       # Работа с данными и рекомендации
+├── llm.py             # LLM система
+├── templates/         # HTML шаблоны
+│   └── index.html     # Главная страница
+├── Dockerfile         # Docker конфигурация
+├── docker-compose.yml # Docker Compose
+├── requirements.txt   # Зависимости
+└── README.md         # Документация
+```
+
+## 🎯 Что работает
+
+✅ **Парсинг данных** - автоматический сбор с сайтов ITMO
+✅ **Диалоговая система** - LLM-powered чат с контекстным поиском
+✅ **Рекомендации** - персонализированные по профилю студента
+✅ **12 fallback курсов** - полные учебные планы ИИ и AI Product
+✅ **Строгая релевантность** - отвечает только на вопросы об ITMO
+✅ **Fallback режим** - работает без LLM
+✅ **Docker поддержка** - легкий деплой и развертывание
+✅ **REST API** - JSON API для интеграции
+
+## 🔧 Технологии
+
+- **Flask** - веб-фреймворк
+- **Transformers** - LLM модель (RuT5-base-multitask)
+- **BeautifulSoup** - парсинг HTML страниц
+- **Requests** - HTTP запросы к сайтам ITMO
+- **Docker** - контейнеризация
+
+## 📊 Данные
+
+### Программы
+- **Искусственный интеллект** - ML, DL, NLP, CV, 4 семестра
+- **AI Product Management** - продуктовая аналитика, управление, 4 семестра
+
+### Курсы (12 fallback курсов)
+- **Семестры 1-4** с полной информацией
+- **Теги** для поиска и рекомендаций (ml, dl, nlp, cv, product, business, etc.)
+- **Сложность** - beginner/intermediate/advanced
+- **Кредиты и часы** обучения
+- **Типы курсов** - required/elective
+
+## 🎯 Примеры вопросов
+
+### Вопросы о курсах:
+- "Какие курсы по машинному обучению?"
+- "Сколько кредитов за глубокое обучение?"
+- "Какие дисциплины в 1 семестре программы ИИ?"
+
+### Вопросы о программах:
+- "Расскажи о программе AI Product"
+- "Какая карьера после программы ИИ?"
+- "Нужна ли математика для AI Product?"
+
+### Вопросы о рекомендациях:
+- "Какие курсы подходят для моего профиля?"
+- "Что выбрать с опытом программирования 3/5?"
+- "Рекомендации для 2 семестра"
+
+## 🔄 Обновление данных
+
+Кнопка "🔄 Обновить данные" выполняет:
+- **Парсинг страниц** программ с сайта ITMO
+- **Поиск PDF файлов** с учебными планами
+- **Обновление курсов** и метаданных
+- **Сохранение в JSON** для последующего использования
+
+## 🎯 Система рекомендаций
+
+### Входные параметры:
+- **Опыт программирования** (0-5)
+- **Уровень математики** (0-4)
+- **Интересы** (ml, dl, nlp, cv, product, business, etc.)
+- **Целевой семестр** (1-4)
+
+### Алгоритм подбора:
+1. **Фильтрация по семестру**
+2. **Оценка сложности** курса vs опыт студента
+3. **Совпадение интересов** с тегами курса
+4. **Математические требования** vs уровень студента
+5. **LLM-генерация** персонализированного объяснения
+
+## 🔍 Релевантность вопросов
+
+Бот отвечает только на вопросы, содержащие ключевые слова:
+- `итмо`, `магистратура`, `учебный план`, `дисциплина`, `курс`
+- `ии`, `ai`, `ai product`, `программа`
+- `машинное обучение`, `глубокое обучение`, `nlp`, `компьютерное зрение`
+- `продукт`, `аналитика`, `управление`, `обучение`, `учеба`
+
+## 📝 Системные инструкции для LLM
+
+- Отвечай только по предоставленному контексту
+- Если в контексте нет нужной информации — ответь: "в предоставленных данных об этом не сказано"
+- Отвечай кратко и по делу
+- Не выдумывай факты и не давай общих ответов без ссылок на элементы контекста
+
+## 🔧 Fallback-данные
+
+12 встроенных курсов (по 6 на каждую программу) с заполненными полями:
+- id, program_id, semester, name, credits, type, short_desc, tags
+- Используются при пустом/недоступном парсинге
+
+## 🐳 Docker деплой
+
+### На любом сервере с Docker:
+
+```bash
+# Клонируем репозиторий
+git clone <your-repo-url>
+cd <your-repo-name>
+
+# Запускаем
+docker-compose up -d
+
+# Проверяем логи
+docker-compose logs -f
+```
+
+### На Hugging Face Spaces:
+
+1. Создайте новый Space
+2. Выберите **Docker SDK**
+3. Загрузите все файлы в репозиторий
+4. Space автоматически соберет и запустит Docker контейнер
+
+## 📝 Лицензия
+
+MIT License - свободное использование и модификация.
+
+## 🤝 Поддержка
+
+При возникновении проблем:
+1. Проверьте логи Docker: `docker-compose logs`
+2. Убедитесь в наличии всех файлов
+3. Проверьте доступность сайта ITMO
+4. Используйте fallback режим при проблемах с LLM
+
+---
+
+**Создано для абитуриентов магистратур ITMO** 🎓
+
+*Минимально работающий прототип: парсинг + диалог + рекомендации + Docker*

app.py

@@ -0,0 +1,136 @@
+from flask import Flask, render_template, request, jsonify
+import os
+
+# Импорты модулей
+from parser import parse_all
+from data_layer import load_courses, filter_courses, recommend_courses, is_relevant
+from llm import answer, generate_recommendations
+
+app = Flask(__name__)
+
+# Инициализация данных
+courses = load_courses()
+print(f'Загружено курсов: {len(courses)}')
+
+@app.route('/')
+def index():
+    """Главная страница"""
+    return render_template('index.html', courses_count=len(courses))
+
+@app.route('/api/chat', methods=['POST'])
+def chat():
+    """API для чата"""
+    try:
+        data = request.get_json()
+        message = data.get('message', '').strip()
+        
+        if not message:
+            return jsonify({'error': 'Пустое сообщение'}), 400
+        
+        # Проверяем релевантность
+        if not is_relevant(message):
+            response = '''Похоже, вопрос не относится к магистратурам ITMO и их учебным планам. 
+
+Попробуйте спросить, например:
+• "Какие дисциплины по NLP в 1 семестре программы ИИ?"
+• "Расскажи о программе AI Product"
+• "Какие курсы по машинному обучению есть в программе ИИ?"
+• "Сколько кредитов за дисциплину 'Глубокое обучение'?"
+• "Какие курсы подходят для моего профиля?"'''
+            return jsonify({'response': response})
+        
+        # Определяем программу из сообщения
+        program_id = None
+        message_lower = message.lower()
+        if any(word in message_lower for word in ['ai product', 'продукт', 'менеджмент', 'аналитика']):
+            program_id = 'ai_product'
+        elif any(word in message_lower for word in ['ии', 'ai', 'машинное обучение', 'глубокое обучение', 'nlp', 'cv']):
+            program_id = 'ai'
+        
+        # Извлекаем семестр если указан
+        semester = None
+        for i in range(1, 5):
+            if f'{i} семестр' in message_lower or f'{i} семестре' in message_lower:
+                semester = i
+                break
+        
+        # Фильтруем курсы
+        context = filter_courses(message, program_id, semester)
+        
+        if not context:
+            response = 'К сожалению, не нашел релевантной информации в учебных планах ITMO. Попробуйте переформулировать вопрос.'
+        else:
+            # Генерируем ответ с помощью LLM
+            response = answer(message, context)
+        
+        return jsonify({'response': response})
+        
+    except Exception as e:
+        return jsonify({'error': f'Ошибка обработки: {str(e)}'}), 500
+
+@app.route('/api/recommendations', methods=['POST'])
+def get_recommendations():
+    """API для рекомендаций"""
+    try:
+        data = request.get_json()
+        programming_exp = data.get('programming_exp', 2)
+        math_level = data.get('math_level', 2)
+        interests = data.get('interests', [])
+        semester = data.get('semester', '')
+        
+        if not semester:
+            return jsonify({'error': 'Пожалуйста, укажите семестр для получения рекомендаций.'}), 400
+        
+        try:
+            semester_int = int(semester)
+        except ValueError:
+            return jsonify({'error': 'Пожалуйста, выберите корректный семестр.'}), 400
+        
+        # Формируем профиль
+        profile = {
+            'programming_experience': programming_exp,
+            'math_level': math_level,
+            'interests': interests,
+            'semester': semester_int
+        }
+        
+        # Получаем рекомендации
+        recommended_courses = recommend_courses(profile)
+        
+        if not recommended_courses:
+            return jsonify({'error': f'К сожалению, не найдено подходящих курсов для {semester} семестра.'}), 404
+        
+        # Генерируем ответ с помощью LLM
+        response = generate_recommendations(recommended_courses, profile)
+        
+        return jsonify({'response': response})
+        
+    except Exception as e:
+        return jsonify({'error': f'Ошибка получения рекомендаций: {str(e)}'}), 500
+
+@app.route('/api/update', methods=['POST'])
+def update_data():
+    """API для обновления данных"""
+    try:
+        success = parse_all()
+        if success:
+            # Перезагружаем курсы
+            global courses
+            courses = load_courses()
+            return jsonify({'message': f'Данные успешно обновлены! Загружено {len(courses)} курсов.'})
+        else:
+            return jsonify({'error': 'Ошибка при обновлении данных. Используются базовые курсы.'}), 500
+    except Exception as e:
+        return jsonify({'error': f'Ошибка обновления данных: {str(e)}'}), 500
+
+@app.route('/api/status')
+def status():
+    """API для статуса системы"""
+    return jsonify({
+        'status': 'ok',
+        'courses_count': len(courses),
+        'llm_available': True
+    })
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000, debug=False)

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"
+  }
+}

data_layer.py

@@ -0,0 +1,135 @@
+import json
+import os
+from parser import get_fallback_courses
+
+def load_courses():
+    """Загружает курсы из JSON файла или возвращает fallback"""
+    try:
+        courses_file = 'data/processed/courses.json'
+        if os.path.exists(courses_file):
+            with open(courses_file, 'r', encoding='utf-8') as f:
+                courses = json.load(f)
+            return courses
+        else:
+            # Если файла нет, возвращаем fallback
+            return get_fallback_courses()
+    except Exception as e:
+        print(f'Ошибка загрузки курсов: {e}')
+        return get_fallback_courses()
+
+def filter_courses(query, program_id=None, semester=None):
+    """Фильтрация курсов по запросу и параметрам"""
+    courses = load_courses()
+    query_lower = query.lower()
+    
+    filtered = []
+    
+    for course in courses:
+        # Фильтр по программе
+        if program_id and course.get('program_id') != program_id:
+            continue
+            
+        # Фильтр по семестру
+        if semester and course.get('semester') != semester:
+            continue
+            
+        # Поиск по ключевым словам
+        course_text = f"{course.get('name', '')} {course.get('short_desc', '')} {' '.join(course.get('tags', []))}".lower()
+        
+        if any(word in course_text for word in query_lower.split()):
+            filtered.append(course)
+    
+    return filtered[:8]  # Ограничиваем до 8 курсов
+
+def recommend_courses(profile):
+    """Рекомендации курсов на основе профиля студента"""
+    courses = load_courses()
+    
+    programming_exp = profile.get('programming_experience', 2)
+    math_level = profile.get('math_level', 2)
+    interests = profile.get('interests', [])
+    semester = profile.get('semester')
+    
+    # Фильтруем по семестру если указан
+    if semester:
+        courses = [c for c in courses if c.get('semester') == semester]
+    
+    # Сортируем по релевантности
+    scored_courses = []
+    
+    for course in courses:
+        score = 0
+        
+        # Оценка по сложности программирования
+        if programming_exp <= 2 and 'python' in course.get('tags', []):
+            score += 2
+        elif 2 <= programming_exp <= 4 and 'ml' in course.get('tags', []):
+            score += 2
+        elif programming_exp >= 4 and 'dl' in course.get('tags', []):
+            score += 2
+        
+        # Оценка по математике
+        if math_level >= 2 and 'math' in course.get('tags', []):
+            score += 2
+        if math_level >= 3 and 'stats' in course.get('tags', []):
+            score += 1
+        
+        # Оценка по интересам
+        matching_tags = [tag for tag in interests if tag in course.get('tags', [])]
+        score += len(matching_tags) * 3
+        
+        # Бонус за product/business интересы для AI Product программы
+        if 'product' in interests or 'business' in interests:
+            if course.get('program_id') == 'ai_product':
+                score += 2
+        
+        if score > 0:
+            scored_courses.append((course, score))
+    
+    # Сортируем по score и возвращаем топ-7
+    scored_courses.sort(key=lambda x: x[1], reverse=True)
+    return [course for course, score in scored_courses[:7]]
+
+def is_relevant(message):
+    """Проверяет релевантность вопроса"""
+    itmo_keywords = [
+        'итмо', 'магистратура', 'учебный план', 'дисциплина', 'курс',
+        'ии', 'ai', 'ai product', 'институт ии', 'программа',
+        'машинное обучение', 'глубокое обучение', 'nlp', 'компьютерное зрение',
+        'продукт', 'аналитика', 'управление', 'обучение', 'учеба'
+    ]
+    
+    message_lower = message.lower()
+    
+    # Проверяем ключевые слова
+    if any(keyword in message_lower for keyword in itmo_keywords):
+        return True
+    
+    # Проверяем совпадение с названиями курсов
+    courses = load_courses()
+    for course in courses:
+        if course.get('name', '').lower() in message_lower:
+            return True
+    
+    return False
+
+def get_program_info(program_id):
+    """Получает информацию о программе"""
+    programs = {
+        'ai': {
+            'name': 'Искусственный интеллект',
+            'description': 'Программа готовит специалистов в области машинного обучения, глубокого обучения, обработки естестве��ного языка и компьютерного зрения.',
+            'duration': '2 года (4 семестра)',
+            'credits_total': 120,
+            'career': 'ML Engineer, Data Scientist, Research Scientist, AI Developer'
+        },
+        'ai_product': {
+            'name': 'AI Product Management',
+            'description': 'Программа готовит продуктовых менеджеров, способных создавать и развивать ИИ-продукты.',
+            'duration': '2 года (4 семестра)',
+            'credits_total': 120,
+            'career': 'Product Manager, AI Product Manager, Business Analyst, Product Owner'
+        }
+    }
+    
+    return programs.get(program_id)

docker-compose.yml

@@ -0,0 +1,12 @@
+version: '3.8'
+
+services:
+  itmo-chatbot:
+    build: .
+    ports:
+      - "5000:5000"
+    volumes:
+      - ./data:/app/data
+    environment:
+      - FLASK_ENV=production
+    restart: unless-stopped

llm.py

@@ -0,0 +1,155 @@
+import logging
+
+# Ленивая загрузка LLM
+_generator = None
+
+def load_model():
+    """Ленивая загрузка модели"""
+    global _generator
+    if _generator is None:
+        try:
+            from transformers import pipeline
+            print('Загрузка LLM модели...')
+            _generator = pipeline('text2text-generation', model='cointegrated/rut5-base-multitask')
+            print('LLM модель загружена')
+        except Exception as e:
+            print(f'Ошибка загрузки LLM: {e}')
+            _generator = None
+    return _generator
+
+def answer(question, context, system_prompt=None):
+    """Генерирует ответ с помощью LLM"""
+    generator = load_model()
+    
+    if not generator or not context:
+        return fallback_answer(context)
+    
+    try:
+        # Формируем контекст
+        context_text = 'Доступные курсы:\n'
+        for i, course in enumerate(context[:6], 1):
+            context_text += f'{i}. {course["name"]} ({course["semester"]} семестр, {course["credits"]} кредитов)\n'
+            context_text += f'   Описание: {course["short_desc"]}\n'
+            context_text += f'   Теги: {", ".join(course["tags"])}\n\n'
+        
+        # Системные инструкции
+        if system_prompt is None:
+            system_prompt = '''Ты помощник для абитуриентов магистратуры ITMO. Отвечай только по предоставленному контексту.
+Если в контексте нет нужной информации — ответь: "в предоставленных данных об этом не сказано."
+Отвечай кратко и по делу.
+Не выдумывай факты и не давай общих ответов без ссылок на элементы контекста.'''
+        
+        # Формируем промпт
+        prompt = f'''{system_prompt}
+
+{context_text}
+
+Вопрос: {question}'''
+        
+        # Генерируем ответ
+        response = generator(
+            prompt,
+            max_new_tokens=180,
+            temperature=0.3,
+            do_sample=True
+        )[0]['generated_text']
+        
+        return response.strip()
+        
+    except Exception as e:
+        print(f'Ошибка генерации LLM: {e}')
+        return fallback_answer(context)
+
+def fallback_answer(context):
+    """Fallback ответ без LLM"""
+    if not context:
+        return 'В предоставленных данных об этом не сказано.'
+    
+    courses = []
+    for item in context[:3]:
+        courses.append(f'{item["name"]} ({item["semester"]} семестр, {item["credits"]} кредитов)')
+    
+    return f'Найденные курсы: {", ".join(courses)}.'
+
+def generate_recommendations(courses, profile):
+    """Генерирует рекомендации с помощью LLM"""
+    generator = load_model()
+    
+    if not generator or not courses:
+        return fallback_recommendations(courses, profile)
+    
+    try:
+        # Формируем контекст курсов
+        courses_text = 'Доступные курсы:\n'
+        for i, course in enumerate(courses[:7], 1):
+            courses_text += f'{i}. {course["name"]} ({course["credits"]} кредитов)\n'
+            courses_text += f'   Сложность: {course.get("difficulty", "не указана")}, Теги: {", ".join(course["tags"])}\n'
+            courses_text += f'   Описание: {course["short_desc"]}\n\n'
+        
+        # Профиль студента
+        programming_exp = profile.get('programming_experience', 2)
+        math_level = profile.get('math_level', 2)
+        interests = profile.get('interests', [])
+        semester = profile.get('semester', 'не указан')
+        
+        prompt = f'''Ты эксперт по выбору курсов. Дай персонализированные рекомендации студенту.
+
+Профиль студента:
+- Опыт программирования: {programming_exp}/5
+- Уровень математики: {math_level}/4  
+- Интересы: {", ".join(interests)}
+- Целевой семестр: {semester}
+
+{courses_text}
+
+Дай 5-7 лучших рекомендаций с объяснением почему они подходят. Учитывай уровень сложности и интересы. Отвечай кратко, по делу.'''
+        
+        response = generator(
+            prompt,
+            max_new_tokens=300,
+            temperature=0.4,
+            do_sample=True
+        )[0]['generated_text']
+        
+        return response.strip()
+        
+    except Exception as e:
+        print(f'Ошибка генерации рекомендаций: {e}')
+        return fallback_recommendations(courses, profile)
+
+def fallback_recommendations(courses, profile):
+    """Fallback рекомендации без LLM"""
+    if not courses:
+        semester = profile.get('semester', 'не указан')
+        return f'Нет курсов для {semester} семестра.'
+    
+    programming_exp = profile.get('programming_experience', 2)
+    math_level = profile.get('math_level', 2)
+    interests = profile.get('interests', [])
+    semester = profile.get('semester', 'не указан')
+    
+    result = f'🎯 Рекомендации для {semester} семестра:\n\n'
+    
+    for i, course in enumerate(courses[:7], 1):
+        result += f'{i}. {course["name"]} ({course["credits"]} кредитов)\n'
+        
+        # Объяснение почему подходит
+        reasons = []
+        matching_tags = [tag for tag in interests if tag in course.get('tags', [])]
+        if matching_tags:
+            reasons.append(f'подходит по интересам: {", ".join(matching_tags)}')
+        
+        if programming_exp <= 2 and 'python' in course.get('tags', []):
+            reasons.append('подходит для начинающих программистов')
+        elif programming_exp >= 4 and 'dl' in course.get('tags', []):
+            reasons.append('подходит для опытных программистов')
+        
+        if math_level >= 2 and 'math' in course.get('tags', []):
+            reasons.append('требует хорошую математическую подготовку')
+        
+        if reasons:
+            result += f'   Почему подходит: {"; ".join(reasons)}\n'
+        
+        result += '\n'
+    
+    return result

parser.py

@@ -0,0 +1,313 @@
+import requests
+from bs4 import BeautifulSoup
+import re
+import json
+import os
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def parse_program_page(url, program_id):
+    """Парсинг страницы программы"""
+    try:
+        logger.info(f'Парсинг страницы {program_id}: {url}')
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        # Ищем заголовок
+        title = soup.find('h1')
+        title_text = title.get_text().strip() if title else f'Программа {program_id}'
+        
+        # Ищем описание
+        description = soup.find('div', class_='description') or soup.find('p')
+        desc_text = description.get_text().strip() if description else f'Описание программы {program_id}'
+        
+        # Ищем ссылки на PDF
+        pdf_links = []
+        for link in soup.find_all('a', href=True):
+            href = link['href']
+            if '.pdf' in href.lower() or 'curriculum' in href.lower() or 'plan' in href.lower():
+                if href.startswith('/'):
+                    href = 'https://abit.itmo.ru' + href
+                elif not href.startswith('http'):
+                    href = 'https://abit.itmo.ru/' + href
+                pdf_links.append(href)
+        
+        logger.info(f'Найдено {len(pdf_links)} PDF ссылок для {program_id}')
+        
+        return {
+            'title': title_text,
+            'description': desc_text,
+            'pdf_links': pdf_links,
+            'source_url': url
+        }
+        
+    except Exception as e:
+        logger.error(f'Ошибка парсинга страницы {program_id}: {e}')
+        return {
+            'title': f'Программа {program_id}',
+            'description': f'Описание программы {program_id}',
+            'pdf_links': [],
+            'source_url': url
+        }
+
+def parse_pdf(url, program_id):
+    """Парсинг PDF файла с учебным планом"""
+    try:
+        logger.info(f'Попытка парсинга PDF: {url}')
+        
+        # Пока используем заглушку, так как PDF парсинг сложен
+        # В реальной реализации здесь был бы код для извлечения таблиц из PDF
+        
+        # Возвращаем пустой список, чтобы не ломать приложение
+        return []
+        
+    except Exception as e:
+        logger.error(f'Ошибка парсинга PDF {url}: {e}')
+        return []
+
+def normalize_course(course_data, program_id):
+    """Нормализация данных курса"""
+    # Создаем short_desc из названия если нет
+    if 'short_desc' not in course_data:
+        course_data['short_desc'] = course_data.get('name', '')[:200]
+    
+    # Генерируем теги на основе названия и описания
+    text = f"{course_data.get('name', '')} {course_data.get('short_desc', '')}".lower()
+    tags = []
+    
+    if any(word in text for word in ['машинное обучение', 'ml', 'machine learning']):
+        tags.append('ml')
+    if any(word in text for word in ['глубокое обучение', 'dl', 'neural', 'нейрон']):
+        tags.append('dl')
+    if any(word in text for word in ['nlp', 'язык', 'текст', 'natural language']):
+        tags.append('nlp')
+    if any(word in text for word in ['зрение', 'vision', 'image', 'изображение']):
+        tags.append('cv')
+    if any(word in text for word in ['продукт', 'product', 'менеджмент', 'management']):
+        tags.append('product')
+    if any(word in text for word in ['бизнес', 'business', 'аналитика', 'analytics']):
+        tags.append('business')
+    if any(word in text for word in ['исследование', 'research', 'наука']):
+        tags.append('research')
+    if any(word in text for word in ['данные', 'data', 'статистика']):
+        tags.append('data')
+    if any(word in text for word in ['системы', 'systems', 'архитектура']):
+        tags.append('systems')
+    if any(word in text for word in ['python', 'программирование']):
+        tags.append('python')
+    if any(word in text for word in ['математика', 'math', 'статистика', 'оптимизация']):
+        tags.append('math')
+    
+    course_data['tags'] = tags
+    course_data['program_id'] = program_id
+    
+    return course_data
+
+def get_fallback_courses():
+    """Fallback курсы на случай недоступности парсинга"""
+    return [
+        # Программа ИИ
+        {
+            'id': 'ai_1_1',
+            'program_id': 'ai',
+            'semester': 1,
+            'name': 'Машинное обучение',
+            'credits': 6,
+            'hours': 108,
+            'type': 'required',
+            'short_desc': 'Основы машинного обучения, алгоритмы классификации и регрессии',
+            'tags': ['ml', 'math', 'stats', 'python'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai'
+        },
+        {
+            'id': 'ai_1_2',
+            'program_id': 'ai',
+            'semester': 1,
+            'name': 'Глубокое обучение',
+            'credits': 4,
+            'hours': 72,
+            'type': 'required',
+            'short_desc': 'Нейронные сети, CNN, RNN, трансформеры',
+            'tags': ['dl', 'ml', 'neural', 'python'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai'
+        },
+        {
+            'id': 'ai_2_1',
+            'program_id': 'ai',
+            'semester': 2,
+            'name': 'Обработка естественного языка',
+            'credits': 5,
+            'hours': 90,
+            'type': 'required',
+            'short_desc': 'Методы обработки текста, токенизация, эмбеддинги',
+            'tags': ['nlp', 'dl', 'text', 'transformers'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai'
+        },
+        {
+            'id': 'ai_2_2',
+            'program_id': 'ai',
+            'semester': 2,
+            'name': 'Компьютерное зрение',
+            'credits': 4,
+            'hours': 72,
+            'type': 'required',
+            'short_desc': 'Обработка изображений, CNN, детекция объектов',
+            'tags': ['cv', 'dl', 'image', 'cnn'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai'
+        },
+        {
+            'id': 'ai_3_1',
+            'program_id': 'ai',
+            'semester': 3,
+            'name': 'Продвинутые методы машинного обучения',
+            'credits': 5,
+            'hours': 90,
+            'type': 'required',
+            'short_desc': 'Продвинутые алгоритмы ML, ансамбли, оптимизация',
+            'tags': ['ml', 'advanced', 'algorithms'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai'
+        },
+        {
+            'id': 'ai_4_1',
+            'program_id': 'ai',
+            'semester': 4,
+            'name': 'Магистерская диссертация',
+            'credits': 12,
+            'hours': 216,
+            'type': 'required',
+            'short_desc': 'Научно-исследовательская работа, защита диссертации',
+            'tags': ['research', 'thesis', 'project'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai'
+        },
+        
+        # Программа AI Product
+        {
+            'id': 'ai_product_1_1',
+            'program_id': 'ai_product',
+            'semester': 1,
+            'name': 'Продуктовая аналитика',
+            'credits': 6,
+            'hours': 108,
+            'type': 'required',
+            'short_desc': 'Анализ продуктовых метрик, A/B тестирование',
+            'tags': ['product', 'business', 'data', 'analytics'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai_product'
+        },
+        {
+            'id': 'ai_product_1_2',
+            'program_id': 'ai_product',
+            'semester': 1,
+            'name': 'Управление проектами',
+            'credits': 4,
+            'hours': 72,
+            'type': 'required',
+            'short_desc': 'Методологии управления проектами, Agile, Scrum',
+            'tags': ['pm', 'business', 'management', 'agile'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai_product'
+        },
+        {
+            'id': 'ai_product_2_1',
+            'program_id': 'ai_product',
+            'semester': 2,
+            'name': 'UX/UI для ИИ продуктов',
+            'credits': 4,
+            'hours': 72,
+            'type': 'required',
+            'short_desc': 'Дизайн интерфейсов для ИИ, UX исследования',
+            'tags': ['ux', 'ui', 'design', 'ai'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai_product'
+        },
+        {
+            'id': 'ai_product_2_2',
+            'program_id': 'ai_product',
+            'semester': 2,
+            'name': 'Этика ИИ',
+            'credits': 3,
+            'hours': 54,
+            'type': 'required',
+            'short_desc': 'Этические принципы ИИ, справедливость, прозрачность',
+            'tags': ['ethics', 'ai', 'responsible', 'fairness'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai_product'
+        },
+        {
+            'id': 'ai_product_3_1',
+            'program_id': 'ai_product',
+            'semester': 3,
+            'name': 'Управление ИИ продуктами',
+            'credits': 6,
+            'hours': 108,
+            'type': 'required',
+            'short_desc': 'Стратегическое управление ИИ продуктами, команды',
+            'tags': ['product', 'management', 'ai', 'leadership'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai_product'
+        },
+        {
+            'id': 'ai_product_4_1',
+            'program_id': 'ai_product',
+            'semester': 4,
+            'name': 'Дипломный проект',
+            'credits': 12,
+            'hours': 216,
+            'type': 'required',
+            'short_desc': 'Разработка ИИ продукта, защита проекта',
+            'tags': ['project', 'thesis', 'product'],
+            'source_url': 'https://abit.itmo.ru/program/master/ai_product'
+        }
+    ]
+
+def parse_all():
+    """Основная функция парсинга всех данных"""
+    try:
+        logger.info('Начинаем парсинг всех данных')
+        
+        # Создаем директории если нет
+        os.makedirs('data/processed', exist_ok=True)
+        
+        # Парсим страницы программ
+        programs = {
+            'ai': 'https://abit.itmo.ru/program/master/ai',
+            'ai_product': 'https://abit.itmo.ru/program/master/ai_product'
+        }
+        
+        all_courses = []
+        
+        for program_id, url in programs.items():
+            # Парсим страницу программы
+            program_info = parse_program_page(url, program_id)
+            
+            # Пытаемся парсить PDF файлы
+            for pdf_url in program_info['pdf_links']:
+                pdf_courses = parse_pdf(pdf_url, program_id)
+                for course in pdf_courses:
+                    normalized_course = normalize_course(course, program_id)
+                    all_courses.append(normalized_course)
+        
+        # Если парсинг не дал результатов, используем fallback
+        if not all_courses:
+            logger.warning('Парсинг не дал результатов, используем fallback курсы')
+            all_courses = get_fallback_courses()
+        
+        # Сохраняем в JSON
+        courses_file = 'data/processed/courses.json'
+        with open(courses_file, 'w', encoding='utf-8') as f:
+            json.dump(all_courses, f, ensure_ascii=False, indent=2)
+        
+        logger.info(f'Сохранено {len(all_courses)} курсов в {courses_file}')
+        return True
+        
+    except Exception as e:
+        logger.error(f'Ошибка парсинга: {e}')
+        # Сохраняем fallback курсы
+        try:
+            os.makedirs('data/processed', exist_ok=True)
+            with open('data/processed/courses.json', 'w', encoding='utf-8') as f:
+                json.dump(get_fallback_courses(), f, ensure_ascii=False, indent=2)
+            logger.info('Сохранены fallback курсы')
+            return True
+        except Exception as e2:
+            logger.error(f'Ошибка сохранения fallback курсов: {e2}')
+            return False

prompts/system.txt

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

requirements.txt

@@ -1,3 +1,8 @@
-altair
-pandas
-streamlit
+flask==2.3.3
+transformers==4.36.2
+torch==2.1.0
+requests==2.31.0
+beautifulsoup4==4.12.2
+numpy==1.24.3
+sentencepiece==0.1.99
+huggingface-hub==0.19.4

scraper/html_scraper.py

@@ -0,0 +1,144 @@
+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(normalized)
+        
+        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,246 @@
+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
+
+        
+        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(pdf_path),
+                '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()

templates/index.html

@@ -0,0 +1,399 @@
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ITMO Магистратура - Чат-бот</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
+    <style>
+        body {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+        .main-container {
+            background: rgba(255, 255, 255, 0.95);
+            border-radius: 20px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            margin: 20px auto;
+            max-width: 1200px;
+        }
+        .chat-container {
+            height: 400px;
+            overflow-y: auto;
+            border: 1px solid #dee2e6;
+            border-radius: 10px;
+            padding: 15px;
+            background: #f8f9fa;
+        }
+        .message {
+            margin-bottom: 15px;
+            padding: 10px 15px;
+            border-radius: 15px;
+            max-width: 80%;
+        }
+        .user-message {
+            background: #007bff;
+            color: white;
+            margin-left: auto;
+        }
+        .bot-message {
+            background: #e9ecef;
+            color: #333;
+        }
+        .loading {
+            display: none;
+            text-align: center;
+            padding: 20px;
+        }
+        .spinner-border-sm {
+            width: 1rem;
+            height: 1rem;
+        }
+        .card {
+            border: none;
+            box-shadow: 0 5px 15px rgba(0,0,0,0.08);
+            border-radius: 15px;
+        }
+        .btn-primary {
+            background: linear-gradient(45deg, #667eea, #764ba2);
+            border: none;
+            border-radius: 25px;
+            padding: 10px 25px;
+        }
+        .btn-secondary {
+            background: linear-gradient(45deg, #6c757d, #495057);
+            border: none;
+            border-radius: 25px;
+            padding: 10px 25px;
+        }
+        .form-control, .form-select {
+            border-radius: 10px;
+            border: 2px solid #e9ecef;
+        }
+        .form-control:focus, .form-select:focus {
+            border-color: #667eea;
+            box-shadow: 0 0 0 0.2rem rgba(102, 126, 234, 0.25);
+        }
+    </style>
+</head>
+<body>
+    <div class="container-fluid">
+        <div class="main-container p-4">
+            <!-- Заголовок -->
+            <div class="text-center mb-4">
+                <h1 class="display-4 text-primary">
+                    <i class="fas fa-robot"></i> ITMO Магистратура - Чат-бот
+                </h1>
+                <p class="lead text-muted">Задавайте вопросы о программах ИИ и AI Product, получайте персональные рекомендации по курсам</p>
+                <div class="row justify-content-center">
+                    <div class="col-md-3">
+                        <div class="card text-center">
+                            <div class="card-body">
+                                <i class="fas fa-graduation-cap fa-2x text-primary"></i>
+                                <h5 class="card-title">{{ courses_count }}</h5>
+                                <p class="card-text">Курсов загружено</p>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <div class="row">
+                <!-- Чат -->
+                <div class="col-lg-8">
+                    <div class="card">
+                        <div class="card-header bg-primary text-white">
+                            <h5 class="mb-0"><i class="fas fa-comments"></i> Чат с ботом</h5>
+                        </div>
+                        <div class="card-body">
+                            <div class="chat-container" id="chatContainer">
+                                <div class="message bot-message">
+                                    <strong>Бот:</strong> Привет! Я помогу тебе узнать больше о магистерских программах ITMO. Задавай вопросы о курсах, программах и получай персональные рекомендации!
+                                </div>
+                            </div>
+                            
+                            <div class="loading" id="loading">
+                                <div class="spinner-border text-primary" role="status">
+                                    <span class="visually-hidden">Загрузка...</span>
+                                </div>
+                                <p class="mt-2">Бот думает...</p>
+                            </div>
+                            
+                            <div class="input-group mt-3">
+                                <input type="text" class="form-control" id="messageInput" 
+                                       placeholder="Спрашивайте о дисциплинах, программах, учебных планах...">
+                                <button class="btn btn-primary" type="button" id="sendBtn">
+                                    <i class="fas fa-paper-plane"></i> Отправить
+                                </button>
+                                <button class="btn btn-outline-secondary" type="button" id="clearBtn">
+                                    <i class="fas fa-trash"></i> Очистить
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Рекомендации -->
+                <div class="col-lg-4">
+                    <div class="card">
+                        <div class="card-header bg-success text-white">
+                            <h5 class="mb-0"><i class="fas fa-user-graduate"></i> Профиль для рекомендаций</h5>
+                        </div>
+                        <div class="card-body">
+                            <form id="recommendationsForm">
+                                <div class="mb-3">
+                                    <label class="form-label">Опыт программирования (0-5)</label>
+                                    <input type="range" class="form-range" id="programmingExp" min="0" max="5" value="2">
+                                    <div class="d-flex justify-content-between">
+                                        <small>Нет опыта</small>
+                                        <small>Эксперт</small>
+                                    </div>
+                                </div>
+                                
+                                <div class="mb-3">
+                                    <label class="form-label">Уровень математики (0-4)</label>
+                                    <input type="range" class="form-range" id="mathLevel" min="0" max="4" value="2">
+                                    <div class="d-flex justify-content-between">
+                                        <small>Базовый</small>
+                                        <small>Продвинутый</small>
+                                    </div>
+                                </div>
+                                
+                                <div class="mb-3">
+                                    <label class="form-label">Интересы</label>
+                                    <div class="row">
+                                        <div class="col-6">
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="ml" id="ml" checked>
+                                                <label class="form-check-label" for="ml">ML</label>
+                                            </div>
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="dl" id="dl">
+                                                <label class="form-check-label" for="dl">DL</label>
+                                            </div>
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="nlp" id="nlp">
+                                                <label class="form-check-label" for="nlp">NLP</label>
+                                            </div>
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="cv" id="cv">
+                                                <label class="form-check-label" for="cv">CV</label>
+                                            </div>
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="product" id="product">
+                                                <label class="form-check-label" for="product">Product</label>
+                                            </div>
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="business" id="business">
+                                                <label class="form-check-label" for="business">Business</label>
+                                            </div>
+                                        </div>
+                                        <div class="col-6">
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="research" id="research">
+                                                <label class="form-check-label" for="research">Research</label>
+                                            </div>
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="data" id="data">
+                                                <label class="form-check-label" for="data">Data</label>
+                                            </div>
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="systems" id="systems">
+                                                <label class="form-check-label" for="systems">Systems</label>
+                                            </div>
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="python" id="python">
+                                                <label class="form-check-label" for="python">Python</label>
+                                            </div>
+                                            <div class="form-check">
+                                                <input class="form-check-input" type="checkbox" value="math" id="math">
+                                                <label class="form-check-label" for="math">Math</label>
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+                                
+                                <div class="mb-3">
+                                    <label class="form-label">Целевой семестр</label>
+                                    <select class="form-select" id="semester">
+                                        <option value="">Выберите семестр</option>
+                                        <option value="1">1 семестр</option>
+                                        <option value="2">2 семестр</option>
+                                        <option value="3">3 семестр</option>
+                                        <option value="4">4 семестр</option>
+                                    </select>
+                                </div>
+                                
+                                <button type="submit" class="btn btn-success w-100 mb-2">
+                                    <i class="fas fa-lightbulb"></i> Получить рекомендации
+                                </button>
+                                
+                                <button type="button" class="btn btn-secondary w-100" id="updateBtn">
+                                    <i class="fas fa-sync-alt"></i> Обновить данные
+                                </button>
+                            </form>
+                            
+                            <div class="mt-3">
+                                <textarea class="form-control" id="recommendationsOutput" rows="8" 
+                                          placeholder="Здесь появятся рекомендации..." readonly></textarea>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
+    <script>
+        // Функции для работы с чатом
+        function addMessage(message, isUser = false) {
+            const chatContainer = document.getElementById('chatContainer');
+            const messageDiv = document.createElement('div');
+            messageDiv.className = `message ${isUser ? 'user-message' : 'bot-message'}`;
+            messageDiv.innerHTML = `<strong>${isUser ? 'Вы:' : 'Бот:'}</strong> ${message}`;
+            chatContainer.appendChild(messageDiv);
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+        }
+
+        function showLoading() {
+            document.getElementById('loading').style.display = 'block';
+        }
+
+        function hideLoading() {
+            document.getElementById('loading').style.display = 'none';
+        }
+
+        // Отправка сообщения
+        async function sendMessage() {
+            const input = document.getElementById('messageInput');
+            const message = input.value.trim();
+            
+            if (!message) return;
+            
+            addMessage(message, true);
+            input.value = '';
+            showLoading();
+            
+            try {
+                const response = await fetch('/api/chat', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ message: message })
+                });
+                
+                const data = await response.json();
+                
+                if (response.ok) {
+                    addMessage(data.response);
+                } else {
+                    addMessage(`Ошибка: ${data.error}`);
+                }
+            } catch (error) {
+                addMessage(`Ошибка соединения: ${error.message}`);
+            } finally {
+                hideLoading();
+            }
+        }
+
+        // Получение рекомендаций
+        async function getRecommendations() {
+            const programmingExp = document.getElementById('programmingExp').value;
+            const mathLevel = document.getElementById('mathLevel').value;
+            const semester = document.getElementById('semester').value;
+            
+            if (!semester) {
+                alert('Пожалуйста, выберите семестр');
+                return;
+            }
+            
+            const interests = [];
+            document.querySelectorAll('input[type="checkbox"]:checked').forEach(cb => {
+                interests.push(cb.value);
+            });
+            
+            const output = document.getElementById('recommendationsOutput');
+            output.value = 'Генерируем рекомендации...';
+            
+            try {
+                const response = await fetch('/api/recommendations', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        programming_exp: parseInt(programmingExp),
+                        math_level: parseInt(mathLevel),
+                        interests: interests,
+                        semester: semester
+                    })
+                });
+                
+                const data = await response.json();
+                
+                if (response.ok) {
+                    output.value = data.response;
+                } else {
+                    output.value = `Ошибка: ${data.error}`;
+                }
+            } catch (error) {
+                output.value = `Ошибка соединения: ${error.message}`;
+            }
+        }
+
+        // Обновление данных
+        async function updateData() {
+            const output = document.getElementById('recommendationsOutput');
+            output.value = 'Обновляем данные...';
+            
+            try {
+                const response = await fetch('/api/update', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    }
+                });
+                
+                const data = await response.json();
+                
+                if (response.ok) {
+                    output.value = data.message;
+                    location.reload(); // Перезагружаем страницу для обновления счетчика
+                } else {
+                    output.value = `Ошибка: ${data.error}`;
+                }
+            } catch (error) {
+                output.value = `Ошибка соединения: ${error.message}`;
+            }
+        }
+
+        // Очистка чата
+        function clearChat() {
+            const chatContainer = document.getElementById('chatContainer');
+            chatContainer.innerHTML = `
+                <div class="message bot-message">
+                    <strong>Бот:</strong> Привет! Я помогу тебе узнать больше о магистерских программах ITMO. Задавай вопросы о курсах, программах и получай персональные рекомендации!
+                </div>
+            `;
+        }
+
+        // Обработчики событий
+        document.getElementById('sendBtn').addEventListener('click', sendMessage);
+        document.getElementById('messageInput').addEventListener('keypress', function(e) {
+            if (e.key === 'Enter') {
+                sendMessage();
+            }
+        });
+        document.getElementById('clearBtn').addEventListener('click', clearChat);
+        document.getElementById('recommendationsForm').addEventListener('submit', function(e) {
+            e.preventDefault();
+            getRecommendations();
+        });
+        document.getElementById('updateBtn').addEventListener('click', updateData);
+    </script>
+</body>
+</html>

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()