Initial commit: SEO AI Editor MVP with BERT, BM25 and N-gram analysis

.gitignore

@@ -0,0 +1,55 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Environment variables
+.env
+.env.local
+
+# Temporary files
+pip_temp/
+*.log
+*.tmp
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# PyTorch models cache (опционально, если хотите кэшировать модели локально)
+# .cache/
+
+# OS
+Thumbs.db
+.DS_Store

README.md

@@ -0,0 +1,253 @@
+# SEO AI Editor
+
+Веб-приложение для анализа и оптимизации SEO-текстов с использованием искусственного интеллекта. Проект использует лингвистический анализ (spaCy), частотный анализ (BM25) и семантический анализ (BERT) для сравнения вашего текста с текстами конкурентов.
+
+## 🚀 Возможности
+
+- **Многоязычный анализ**: Поддержка русского, английского, немецкого, испанского и итальянского языков
+- **N-граммный анализ**: Статистика по униграммам, биграммам, триграммам и квадриграммам
+- **BM25 рекомендации**: Автоматические рекомендации по добавлению/удалению слов и фраз
+- **BERT семантический анализ**: Глубокий анализ релевантности текста ключевым фразам с использованием нейронных сетей
+- **Сравнение с конкурентами**: Детальное сравнение вашего текста с текстами конкурентов
+- **GPU ускорение**: Автоматическое использование GPU для ускорения BERT-анализа
+
+## 📋 Требования
+
+- Python 3.8+
+- CUDA (опционально, для GPU ускорения)
+- 4+ GB RAM (рекомендуется 8+ GB)
+
+## 🔧 Установка
+
+1. Клонируйте репозиторий или перейдите в папку проекта:
+```bash
+cd seo_ai_editor
+```
+
+2. Создайте виртуальное окружение:
+```bash
+python -m venv venv
+```
+
+3. Активируйте виртуальное окружение:
+   - Windows:
+   ```bash
+   venv\Scripts\activate
+   ```
+   - Linux/Mac:
+   ```bash
+   source venv/bin/activate
+   ```
+
+4. Установите зависимости:
+```bash
+pip install -r requirements.txt
+```
+
+5. Установите языковые модели spaCy:
+```bash
+python -m spacy download en_core_web_sm
+python -m spacy download ru_core_news_sm
+python -m spacy download de_core_news_sm
+python -m spacy download es_core_news_sm
+python -m spacy download it_core_news_sm
+```
+
+## 🏃 Запуск
+
+Запустите приложение:
+```bash
+python main.py
+```
+
+Или используйте uvicorn напрямую:
+```bash
+uvicorn main:app --host 127.0.0.1 --port 8001 --reload
+```
+
+Приложение будет доступно по адресу: `http://127.0.0.1:8001`
+
+## 📖 Использование
+
+1. Откройте браузер и перейдите на `http://127.0.0.1:8001`
+2. Выберите язык анализа
+3. Введите ваш текст в поле "Ваш текст (Target)"
+4. Введите ключевые фразы (каждая фраза с новой строки)
+5. Добавьте тексты конкурентов (можно добавить несколько)
+6. Нажмите кнопку "⚡ Анализировать (GPU)"
+
+### Интерфейс результатов
+
+Приложение предоставляет три вкладки с результатами:
+
+#### 🧠 BERT Семантика
+- **Общий рейтинг релевантности**: Сравнение вашего текста и конкурентов по среднему сходству с ключевыми фразами
+- **Детальный анализ**: Для каждой ключевой фразы показывается:
+  - Максимальный score в вашем тексте
+  - Максимальный score у конкурентов
+  - Топ-5 наиболее релевантных предложений из вашего текста
+  - Топ-5 наиболее релевантных предложений у конкурентов
+  - Рекомендации по улучшению
+
+#### 📊 BM25 Баланс
+- Рекомендации по добавлению/удалению слов и фраз
+- Показывает частотные различия между вашим текстом и конкурентами
+- **Полная декомпозиция фраз**: Автоматически анализирует все возможные комбинации слов из ключевых фраз
+  - Например, для фразы "chicken road casino" анализируются: "chicken", "road", "casino", "chicken road", "road casino", "chicken road casino"
+- Учитывает униграммы, биграммы и триграммы
+- Умная сортировка: сначала показываются проблемные рекомендации, затем по длине фразы
+
+#### 🔠 N-граммы
+- Детальная статистика по частоте слов и фраз
+- Сравнение с конкурентами
+- Подсветка важных различий
+
+## 🏗️ Архитектура проекта
+
+```
+seo_ai_editor/
+├── main.py              # FastAPI приложение и роутинг
+├── logic.py             # Основная бизнес-логика анализа
+├── models.py            # Pydantic модели для API
+├── requirements.txt     # Зависимости проекта
+├── templates/
+│   └── index.html       # Frontend интерфейс
+└── README.md            # Документация
+```
+
+### Основные компоненты
+
+#### `main.py`
+- FastAPI приложение
+- Роутинг: `/` (главная страница) и `/analyze` (API анализа)
+- Предзагрузка моделей при старте
+
+#### `logic.py`
+Содержит три основных модуля:
+
+1. **SPACY (Лингвистика)**
+   - `load_models()` - загрузка языковых моделей
+   - `get_doc()` - обработка текста через spaCy
+   - `get_lemmas_flat()` - получение лемматизированных токенов
+   - `generate_ngrams_safe()` - генерация N-грамм
+
+2. **ANALYTICS (N-grams & BM25)**
+   - `calculate_ngram_stats()` - статистика N-грамм
+   - `parse_keywords()` - парсинг ключевых фраз
+   - `calculate_bm25_recommendations()` - BM25 рекомендации
+
+3. **BERT / VECTOR ANALYSIS**
+   - `get_bert_model()` - загрузка BERT модели
+   - `perform_bert_analysis()` - семантический анализ
+
+#### `models.py`
+Pydantic модели:
+- `AnalysisRequest` - запрос на анализ
+- `AnalysisResponse` - ответ с результатами анализа
+
+## 🔬 Технологии
+
+- **FastAPI** - веб-фреймворк
+- **spaCy** - лингвистический анализ
+- **rank-bm25** - алгоритм BM25 для ранжирования
+- **sentence-transformers** - BERT модели для семантического анализа
+- **PyTorch** - глубокое обучение (для BERT)
+- **Jinja2** - шаблонизация HTML
+- **Bootstrap 5** - UI фреймворк
+
+## 📝 API Документация
+
+После запуска приложения доступна автоматическая документация API:
+- Swagger UI: `http://127.0.0.1:8001/docs`
+- ReDoc: `http://127.0.0.1:8001/redoc`
+
+### Endpoint: `/analyze`
+
+**Метод:** POST
+
+**Тело запроса:**
+```json
+{
+  "target_text": "Ваш текст для анализа",
+  "competitors": ["Текст конкурента 1", "Текст конкурента 2"],
+  "keywords": ["ключевая фраза 1", "ключевая фраза 2"],
+  "language": "ru"
+}
+```
+
+**Ответ:**
+```json
+{
+  "ngram_stats": {
+    "unigrams": [...],
+    "bigrams": [...],
+    "trigrams": [...],
+    "quadgrams": [...]
+  },
+  "bm25_recommendations": [
+    {
+      "word": "слово",
+      "type": "1-gram",
+      "my_score": 2.5,
+      "avg_comp_score": 3.0,
+      "action": "add",
+      "count": 2
+    }
+  ],
+  "bert_analysis": {
+    "global_scores": [...],
+    "detailed": [...]
+  }
+}
+```
+
+## ⚙️ Настройки
+
+### Языки
+Поддерживаемые языки задаются в `logic.py` в словаре `MODEL_NAMES`:
+- `en` - английский
+- `ru` - русский
+- `de` - немецкий
+- `es` - испанский
+- `it` - итальянский
+
+### BERT модель
+По умолчанию используется `paraphrase-multilingual-MiniLM-L12-v2`. Модель можно изменить в функции `get_bert_model()` в файле `logic.py`.
+
+### Пороги BM25
+Пороги для рекомендаций можно настроить в функции `calculate_bm25_recommendations()`:
+- Униграммы: `threshold = 0.5`
+- Биграммы: `threshold = 0.25`
+- Триграммы: `threshold = 0.15`
+
+**Примечание:** Алгоритм BM25 автоматически выполняет полную декомпозицию ключевых фраз на все возможные под-н-граммы (1-3 слова). Это позволяет находить не только точные совпадения, но и частичные вхождения ключевых фраз в тексте.
+
+## 🐛 Решение проблем
+
+### Ошибка загрузки spaCy модели
+Убедитесь, что модель установлена:
+```bash
+python -m spacy download <model_name>
+```
+
+### Медленная работа BERT
+- Убедитесь, что CUDA установлена и доступна (��ля GPU ускорения)
+- При первом запуске модель загружается, это может занять время
+- Используйте GPU для значительного ускорения
+
+### Проблемы с памятью
+- Уменьшите количество конкурентов
+- Разбейте длинные тексты на части
+- Используйте более легкую BERT модель
+
+## 📄 Лицензия
+
+Проект создан для образовательных и коммерческих целей.
+
+## 🤝 Вклад
+
+Приветствуются улучшения и предложения! Создавайте issues и pull requests.
+
+## 📧 Контакты
+
+Для вопросов и предложений создавайте issues в репозитории проекта.

docs/API.md

@@ -0,0 +1,257 @@
+# API Документация
+
+## Обзор
+
+SEO AI Editor предоставляет REST API для анализа текстов. API построен на FastAPI и автоматически генерирует интерактивную документацию.
+
+## Базовый URL
+
+```
+http://127.0.0.1:8001
+```
+
+## Endpoints
+
+### GET `/`
+
+Возвращает главную страницу приложения (HTML).
+
+**Ответ:** HTML страница с интерфейсом
+
+---
+
+### POST `/analyze`
+
+Выполняет комплексный анализ текста с использованием N-грамм, BM25 и BERT.
+
+#### Запрос
+
+**Content-Type:** `application/json`
+
+**Тело запроса:**
+
+```json
+{
+  "target_text": "string (обязательно)",
+  "competitors": ["string"] (обязательно, может быть пустым массивом),
+  "keywords": ["string"] (обязательно, может быть пустым массивом),
+  "language": "string" (опционально, по умолчанию "en")
+}
+```
+
+**Параметры:**
+
+| Параметр | Тип | Обязательный | Описание |
+|----------|-----|--------------|----------|
+| `target_text` | string | Да | Текст пользователя для анализа |
+| `competitors` | array[string] | Да | Массив текстов конкурентов |
+| `keywords` | array[string] | Да | Массив ключевых фраз (каждая фраза - отдельный элемент) |
+| `language` | string | Нет | Код языка: `en`, `ru`, `de`, `es`, `it` |
+
+#### Ответ
+
+**Статус:** 200 OK
+
+**Content-Type:** `application/json`
+
+```json
+{
+  "ngram_stats": {
+    "unigrams": [
+      {
+        "ngram": "string",
+        "target_count": 0,
+        "competitor_avg": 0.0
+      }
+    ],
+    "bigrams": [...],
+    "trigrams": [...],
+    "quadgrams": [...]
+  },
+  "bm25_recommendations": [
+    {
+      "word": "string",
+      "type": "1-gram" | "2-gram" | "3-gram",
+      "my_score": 0.0,
+      "avg_comp_score": 0.0,
+      "action": "ok" | "add" | "remove",
+      "count": 0
+    }
+  ],
+  "bert_analysis": {
+    "global_scores": [
+      {
+        "name": "string",
+        "score": 0.0,
+        "is_me": true
+      }
+    ],
+    "detailed": [
+      {
+        "phrase": "string",
+        "my_max_score": 0.0,
+        "comp_max_score": 0.0,
+        "status": "ok" | "good" | "warning" | "bad",
+        "recommendation": "string",
+        "my_top_chunks": [
+          {
+            "text": "string",
+            "score": 0.0
+          }
+        ],
+        "comp_top_chunks": [
+          {
+            "text": "string",
+            "score": 0.0,
+            "source": "string"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+#### Структура ответа
+
+##### ngram_stats
+
+Статистика по N-граммам (1-4 слова).
+
+**Поля:**
+- `ngram` - текст N-граммы (лемматизированный)
+- `target_count` - количество вхождений в целевом тексте
+- `competitor_avg` - среднее количество вхождений у конкурентов
+
+**Сортировка:** По максимальному значению (target_count или competitor_avg)
+
+##### bm25_recommendations
+
+Рекомендации по оптимизации частоты слов/фраз с использованием алгоритма BM25.
+
+**Особенности алгоритма:**
+- **Полная декомпозиция фраз**: Каждая ключевая фраза автоматически разбивается на все возможные под-н-граммы длиной от 1 до 3 слов
+  - Пример: фраза "chicken road casino" анализируется как:
+    - Униграммы: "chicken", "road", "casino"
+    - Биграммы: "chicken road", "road casino"
+    - Триграммы: "chicken road casino"
+  - Это позволяет находить не только точные совпадения, но и частичные вхождения ключевых фраз
+  - Дубликаты автоматически удаляются
+
+**Поля:**
+- `word` - слово или фраза (лемматизированная)
+- `type` - тип: "1-gram", "2-gram", "3-gram"
+- `my_score` - BM25 score в целевом тексте
+- `avg_comp_score` - средний BM25 score у конкурентов
+- `action` - рекомендуемое действие:
+  - `"ok"` - частота в норме
+  - `"add"` - нужно добавить (ваш score ниже среднего конкурентов)
+  - `"remove"` - нужно убрать (ваш score значительно выше среднего конкурентов)
+- `count` - рекомендуемое количество добавлений/удалений (рассчитывается на основе разницы скоров)
+
+**Пороги для действий:**
+- Униграммы: порог 0.5
+- Биграммы: порог 0.25
+- Триграммы: порог 0.15
+
+**Сортировка:** 
+1. Сначала проблемные рекомендации (add/remove)
+2. Затем по длине фразы (длинные фразы важнее)
+3. Затем алфавитно
+
+##### bert_analysis
+
+Семантический анализ с использованием BERT.
+
+**global_scores:**
+- `name` - название текста ("Мой текст" или "Конкурент #N")
+- `score` - средний максимальный score по всем ключевым фразам (0.0 - 1.0)
+- `is_me` - флаг, является ли это целевым текстом
+
+**detailed:**
+Для каждой ключевой фразы:
+- `phrase` - исходная ключевая фраза
+- `my_max_score` - максимальный score в целевом тексте (0.0 - 1.0)
+- `comp_max_score` - максимальный score у конкурентов
+- `status` - статус:
+  - `"good"` - score >= 0.7
+  - `"ok"` - 0.5 <= score < 0.7
+  - `"warning"` - score < 0.5 или конкуренты лучше на 0.1+
+  - `"bad"` - score < 0.5
+- `recommendation` - текстовое описание рекомендации
+- `my_top_chunks` - топ-5 наиболее релевантных предложений из целевого текста
+- `comp_top_chunks` - топ-5 наиболее релевантных предложений у конкурентов (с указанием источника)
+
+#### Примеры запросов
+
+**cURL:**
+```bash
+curl -X POST "http://127.0.0.1:8001/analyze" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "target_text": "Это мой текст для анализа SEO.",
+    "competitors": ["Текст конкурента номер один.", "Текст конкурента номер два."],
+    "keywords": ["SEO анализ", "текст"],
+    "language": "ru"
+  }'
+```
+
+**Python:**
+```python
+import requests
+
+response = requests.post(
+    "http://127.0.0.1:8001/analyze",
+    json={
+        "target_text": "Это мой текст для анализа SEO.",
+        "competitors": ["Текст конкурента номер один.", "Текст конкурента номер два."],
+        "keywords": ["SEO анализ", "текст"],
+        "language": "ru"
+    }
+)
+
+data = response.json()
+print(data)
+```
+
+**JavaScript:**
+```javascript
+fetch('http://127.0.0.1:8001/analyze', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    target_text: "Это мой текст для анализа SEO.",
+    competitors: ["Текст конкурента номер один.", "Текст конкурента номер два."],
+    keywords: ["SEO анализ", "текст"],
+    language: "ru"
+  })
+})
+.then(response => response.json())
+.then(data => console.log(data));
+```
+
+#### Ошибки
+
+**400 Bad Request**
+Неверный формат запроса или отсутствуют обязательные поля.
+
+**422 Unprocessable Entity**
+Ошибка валидации данных (например, неверный код языка).
+
+**500 Internal Server Error**
+Внутренняя ошибка сервера (проблемы с моделями, памятью и т.д.).
+
+## Интерактивная документация
+
+После запуска приложения доступны:
+
+- **Swagger UI**: `http://127.0.0.1:8001/docs`
+- **ReDoc**: `http://127.0.0.1:8001/redoc`
+
+Эти интерфейсы позволяют:
+- Просматривать все endpoints
+- Тестировать API прямо в браузере
+- Видеть схемы данных
+- Просматривать примеры запросов и ответов

docs/ARCHITECTURE.md

@@ -0,0 +1,290 @@
+# Архитектура проекта
+
+## Обзор
+
+SEO AI Editor построен на архитектуре клиент-сервер с использованием FastAPI для backend и простого HTML/JavaScript для frontend.
+
+## Структура проекта
+
+```
+seo_ai_editor/
+├── main.py              # Точка входа, FastAPI приложение
+├── logic.py             # Бизнес-логика и алгоритмы анализа
+├── models.py            # Pydantic модели данных
+├── requirements.txt     # Python зависимости
+├── templates/
+│   └── index.html       # Frontend интерфейс
+├── docs/                # Документация
+│   ├── API.md
+│   ├── ARCHITECTURE.md
+│   └── DEVELOPMENT.md
+└── README.md            # Основная документация
+```
+
+## Компоненты системы
+
+### 1. Backend (FastAPI)
+
+#### `main.py` - Веб-сервер
+
+**Ответственность:**
+- Инициализация FastAPI приложения
+- Роутинг HTTP запросов
+- Предзагрузка моделей при старте
+- Обработка запросов и формирование ответов
+
+**Ключевые функции:**
+- `startup_event()` - загрузка моделей при старте
+- `read_root()` - отдача главной страницы
+- `analyze_text()` - обработка запроса на анализ
+
+#### `logic.py` - Бизнес-логика
+
+Разделен на три модуля:
+
+##### A. SPACY (Лингвистический анализ)
+
+**Модели:**
+- Глобальный словарь `LoadedModels` для кэширования загруженных spaCy моделей
+- Поддержка 5 языков: en, ru, de, es, it
+
+**Функции:**
+- `load_model_if_missing(lang)` - ленивая загрузка моделей
+- `load_models()` - предзагрузка всех моделей
+- `get_doc(text, lang)` - получение spaCy документа
+- `is_valid_token(t)` - фильтрация токенов (удаление мусора)
+- `get_lemmas_flat(text, lang)` - получение списка лемм
+- `generate_ngrams_safe(text, lang, n)` - генерация N-грамм с умной фильтрацией
+
+**Особенности:**
+- Сохранение стоп-слов внутри фраз для читаемости
+- Фильтрация N-грамм, состоящих только из стоп-слов
+- Обработка больших текстов (max_length = 2,000,000)
+
+##### B. ANALYTICS (N-граммы и BM25)
+
+**Функции:**
+- `calculate_ngram_stats()` - статистика по N-граммам (1-4)
+- `parse_keywords()` - парсинг ключевых фраз
+- `calculate_bm25_recommendations()` - многоуровневый BM25 анализ
+
+**Алгоритм BM25 (с полной декомпозицией фраз):**
+1. **Декомпозиция ключевых фраз**: Для каждой ключевой фразы генерируются все возможные под-н-граммы длиной от 1 до 3 слов
+   - Пример: фраза "chicken road casino" разбивается на:
+     - Униграммы: "chicken", "road", "casino"
+     - Биграммы: "chicken road", "road casino"
+     - Триграммы: "chicken road casino"
+   - Используется скользящее окно по токенам фразы
+   - Дубликаты отслеживаются через set для оптимизации
+2. Генерация N-грамм для целевого текста и конкурентов (униграммы, биграммы, триграммы)
+3. Обучение BM25 модели на корпусе N-грамм для каждого уровня (1, 2, 3)
+4. Расчет BM25 скоров для каждой декомпозированной фразы
+5. Сравнение скоров целевого текста со средним скором конкурентов
+6. Генерация рекомендаций (add/remove/ok) на основе пороговых значений
+7. Сортировка результатов: сначала проблемные (add/remove), затем по длине фразы, затем алфавитно
+
+**Пороги:**
+- Униграммы: 0.5
+- Биграммы: 0.25
+- Триграммы: 0.15
+
+**Особенности:**
+- Полная декомпозиция позволяет анализировать не только целые фразы, но и их части
+- Это особенно полезно для длинных ключевых фраз, которые могут встречаться в тексте частично
+- Автоматическое удаление дубликатов при декомпозиции
+
+##### C. BERT / VECTOR ANALYSIS
+
+**Модель:**
+- Глобальная переменная `BertModel` для кэширования
+- Модель: `paraphrase-multilingual-MiniLM-L12-v2`
+- Автоматическое определение устройства (CPU/GPU)
+
+**Функции:**
+- `get_bert_model()` - загрузка BERT модели
+- `perform_bert_analysis()` - семантический анализ
+
+**Алгоритм BERT анализа:**
+1. Разбиение текстов на предложения (chunks)
+2. Генерация эмбеддингов для всех chunks и ключевых фраз
+3. Расчет косинусного сходства между ключевыми фразами и chunks
+4. Global Score: средний максимальный score по всем ключам
+5. Detailed Analysis: топ-5 наиболее релевантных chunks для каждой фразы
+
+#### `models.py` - Модели данных
+
+**Pydantic модели:**
+- `AnalysisRequest` - входные данные для анализа
+- `AnalysisResponse` - структура ответа API
+
+### 2. Frontend
+
+#### `templates/index.html`
+
+**Технологии:**
+- Bootstrap 5 для UI
+- Vanilla JavaScript (без фреймворков)
+- AJAX для взаимодействия с API
+
+**Компоненты:**
+- Форма ввода данных
+- Табы для отображения результатов
+- Динамическое добавление полей конкурентов
+- Визуализация результатов анализа
+
+## Поток данных
+
+```
+1. Пользователь вводит данные в форму
+   ↓
+2. JavaScript собирает данные и отправляет POST /analyze
+   ↓
+3. FastAPI получает запрос, валидирует через Pydantic
+   ↓
+4. main.py вызывает функции из logic.py:
+   - calculate_ngram_stats()
+   - parse_keywords()
+   - calculate_bm25_recommendations()
+   - perform_bert_analysis()
+   ↓
+5. Каждая функция использует:
+   - spaCy для лингвистики
+   - BM25 для частотного анализа
+   - BERT для семантики
+   ↓
+6. Результаты собираются в AnalysisResponse
+   ↓
+7. JSON ответ отправляется клиенту
+   ↓
+8. JavaScript рендерит результаты в UI
+```
+
+## Управление состоянием
+
+### Backend
+
+**Глобальные переменные:**
+- `LoadedModels` - кэш загруженных spaCy моделей
+- `BertModel` - кэш BERT модели
+
+**Стратегия:**
+- Модели загружаются один раз при первом использовании
+- Предзагрузка spaCy моделей при старте (опционально)
+- BERT модель загружается лениво при первом запросе
+
+### Frontend
+
+**Состояние:**
+- `currentData` - последние результаты анализа
+- DOM состояние для табов и форм
+
+## Производительность
+
+### Оптимизации
+
+1. **Кэширование моделей:**
+   - spaCy модели загружаются один раз
+   - BERT модель загружается один раз
+
+2. **Ленивая загрузка:**
+   - spaCy модели загружаются только для используемых языков
+   - BERT модель загружается при первом запросе
+
+3. **GPU ускорение:**
+   - Автоматическое использование CUDA для BERT
+   - Значительное ускорение на GPU
+
+4. **Ограничения:**
+   - N-граммы ограничены 150 элементами на тип
+   - Топ-5 chunks для BERT анализа
+
+### Ограничения
+
+- Максимальная длина текста для spaCy: 2,000,000 символов
+- Память: зависит от размера моделей и длины текстов
+- Время обработки: зависит от длины текстов и наличия GPU
+
+## Масштабируемость
+
+### Текущие ограничения
+
+- Однопоточная обработка запросов
+- Модели загружаются в память
+- Нет кэширования результатов
+
+### Возможные улучшения
+
+1. **Асинхронность:**
+   - Использование async/await для I/O операций
+   - Параллельная обработка конкурентов
+
+2. **Кэширование:**
+   - Redis для кэширования результатов
+   - Кэширование эмбеддингов
+
+3. **Микросервисы:**
+   - Отдельный сервис для BERT
+   - Отдельный сервис для spaCy
+
+4. **База данных:**
+   - Сохранение истории анализов
+   - Статистика использования
+
+## Безопасность
+
+### Текущее состояние
+
+- Нет аутентификации
+- Нет ограничений на размер запросов
+- Нет валидации входных данных (кроме Pydantic)
+
+### Рекомендации
+
+1. **Валидация:**
+   - Ограничение размера текстов
+   - Санитизация входных данных
+
+2. **Аутентификация:**
+   - API ключи
+   - OAuth 2.0
+
+3. **Rate Limiting:**
+   - Ограничение количества запросов
+   - Защита от DDoS
+
+## Зависимости
+
+### Критические
+
+- `fastapi` - веб-фреймворк
+- `spacy` - NLP библиотека
+- `sentence-transformers` - BERT модели
+- `rank-bm25` - BM25 алгоритм
+- `torch` - глубокое обучение
+
+### Вспомогательные
+
+- `uvicorn` - ASGI сервер
+- `pydantic` - валидация данных
+- `jinja2` - шаблонизация
+- `numpy` - численные вычисления
+
+## Расширяемость
+
+### Добавление нового языка
+
+1. Установить spaCy модель для языка
+2. Добавить в `MODEL_NAMES` в `logic.py`
+3. Добавить опцию в UI (`templates/index.html`)
+
+### Добавление новой модели BERT
+
+1. Изменить модель в `get_bert_model()`
+2. Убедиться в совместимости с `sentence-transformers`
+
+### Добавление нового типа анализа
+
+1. Создать функцию в `logic.py`
+2. Добавить вызов в `analyze_text()` в `main.py`
+3. Добавить поле в `AnalysisResponse`
+4. Обновить UI для отображения результатов

docs/DEVELOPMENT.md

@@ -0,0 +1,333 @@
+# Руководство для разработчиков
+
+## Начало работы
+
+### Настройка окружения разработки
+
+1. Клонируйте репозиторий
+2. Создайте виртуальное окружение:
+```bash
+python -m venv venv
+venv\Scripts\activate  # Windows
+# или
+source venv/bin/activate  # Linux/Mac
+```
+
+3. Установите зависимости:
+```bash
+pip install -r requirements.txt
+```
+
+4. Установите spaCy модели:
+```bash
+python -m spacy download en_core_web_sm
+python -m spacy download ru_core_news_sm
+python -m spacy download de_core_news_sm
+python -m spacy download es_core_news_sm
+python -m spacy download it_core_news_sm
+```
+
+### Запуск в режиме разработки
+
+```bash
+python main.py
+```
+
+Или с автоматической перезагрузкой:
+```bash
+uvicorn main:app --host 127.0.0.1 --port 8001 --reload
+```
+
+## Структура кода
+
+### Стиль кода
+
+- Следуйте PEP 8 для Python
+- Используйте type hints где возможно
+- Документируйте функции docstrings
+- Используйте понятные имена переменных
+
+### Организация кода
+
+**main.py:**
+- Только роутинг и обработка HTTP запросов
+- Минимум бизнес-логики
+- Делегирование в `logic.py`
+
+**logic.py:**
+- Вся бизнес-логика
+- Разделение на модули (SPACY, ANALYTICS, BERT)
+- Глобальные переменные для кэширования моделей
+
+**models.py:**
+- Только Pydantic модели
+- Валидация данных
+- Документация полей
+
+## Тестирование
+
+### Ручное тестирование
+
+1. Используйте Swagger UI: `http://127.0.0.1:8001/docs`
+2. Тестируйте через веб-интерфейс
+3. Проверяйте различные языки и размеры текстов
+
+### Примеры тестовых данных
+
+**Русский язык:**
+```json
+{
+  "target_text": "Это пример текста для анализа SEO оптимизации.",
+  "competitors": ["Конкурентный текст номер один с похожим содержанием.", "Второй конкурентный текст."],
+  "keywords": ["SEO анализ", "оптимизация текста"],
+  "language": "ru"
+}
+```
+
+**Английский язык:**
+```json
+{
+  "target_text": "This is an example text for SEO analysis.",
+  "competitors": ["Competitor text number one.", "Second competitor text."],
+  "keywords": ["SEO analysis", "text optimization"],
+  "language": "en"
+}
+```
+
+## Отладка
+
+### Логирование
+
+Добавьте логирование в ключевых местах:
+
+```python
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+logger.info("Loading model...")
+```
+
+### Проверка моделей
+
+Проверьте загрузку моделей:
+```python
+# В Python консоли
+import logic
+logic.load_models()
+print(logic.LoadedModels.keys())
+```
+
+### Проверка BERT
+
+```python
+import logic
+model = logic.get_bert_model()
+print(model.device)  # Должно показать 'cuda' или 'cpu'
+```
+
+## Производительность
+
+### Профилирование
+
+Используйте `cProfile` для профилирования:
+```python
+import cProfile
+import pstats
+
+profiler = cProfile.Profile()
+profiler.enable()
+
+# Ваш код
+
+profiler.disable()
+stats = pstats.Stats(profiler)
+stats.sort_stats('cumulative')
+stats.print_stats(10)
+```
+
+### Оптимизация
+
+1. **Кэширование:**
+   - Модели уже кэшируются
+   - Рассмотрите кэширование результатов для одинаковых запросов
+
+2. **Параллелизация:**
+   - Обработка конкурентов может быть параллельной
+   - Используйте `asyncio` или `multiprocessing`
+
+3. **Батчинг:**
+   - BERT может обрабатывать несколько текстов одновременно
+   - Используйте батчи для эмбеддингов
+
+## Добавление новых функций
+
+### Добавление нового типа анализа
+
+1. Создайте функцию в `logic.py`:
+```python
+def my_new_analysis(target_text: str, competitors: List[str], lang: str) -> Dict:
+    # Ваша логика
+    return {"result": "data"}
+```
+
+2. Добавьте вызов в `main.py`:
+```python
+my_result = logic.my_new_analysis(
+    request.target_text,
+    request.competitors,
+    request.language
+)
+```
+
+3. Добавьте поле в `AnalysisResponse`:
+```python
+class AnalysisResponse(BaseModel):
+    # ... существующие поля
+    my_new_analysis: Dict
+```
+
+4. Обновите UI в `templates/index.html`
+
+### Добавление нового языка
+
+1. Установите spaCy модель:
+```bash
+python -m spacy download <lang>_core_news_sm
+```
+
+2. Добавьте в `MODEL_NAMES`:
+```python
+MODEL_NAMES = {
+    # ... существующие
+    "new_lang": "new_lang_core_news_sm"
+}
+```
+
+3. Добавьте опцию в UI:
+```html
+<option value="new_lang">🇺🇸 New Language</option>
+```
+
+## Работа с зависимостями
+
+### Обновление зависимостей
+
+1. Обновите версии в `requirements.txt`
+2. Установите:
+```bash
+pip install -r requirements.txt --upgrade
+```
+
+3. Протестируйте приложение
+
+### Добавление новой зависимости
+
+1. Установите пакет:
+```bash
+pip install new-package
+```
+
+2. Добавьте в `requirements.txt`:
+```bash
+pip freeze > requirements.txt
+```
+
+3. Или добавьте вручную:
+```
+new-package==1.0.0
+```
+
+## Git workflow
+
+### Коммиты
+
+Используйте понятные сообщения коммитов:
+```
+feat: добавлен анализ тональности
+fix: исправлена ошибка в BM25 расчетах
+docs: обновлена документация API
+refactor: рефакторинг функции analyze_text
+```
+
+### Ветки
+
+- `main` - стабильная версия
+- `develop` - разработка
+- `feature/название` - новая функция
+- `fix/название` - исправление бага
+
+## Развертывание
+
+### Production настройки
+
+1. Отключите debug режим:
+```python
+app = FastAPI(title="SEO AI Editor", debug=False)
+```
+
+2. Используйте production сервер:
+```bash
+uvicorn main:app --host 0.0.0.0 --port 8001 --workers 4
+```
+
+3. Настройте переменные окружения:
+```python
+import os
+DEBUG = os.getenv("DEBUG", "False") == "True"
+```
+
+### Docker (опционально)
+
+Создайте `Dockerfile`:
+```dockerfile
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8001"]
+```
+
+## Известные проблемы
+
+### Память
+
+- Большие тексты могут потреблять много памяти
+- BERT модель занимает ~400MB RAM
+- spaCy модели занимают ~50-100MB каждая
+
+**Решение:** Ограничьте размер входных текстов или используйте потоковую обработку
+
+### Производительность
+
+- Первый запрос медленнее (загрузка BERT)
+- Длинные тексты обрабатываются дольше
+
+**Решение:** Предзагрузка BERT модели, оптимизация алгоритмов
+
+### Языковые модели
+
+- Некоторые языки могут иметь ограниченную поддержку
+- Качество анализа зависит от качества моделей
+
+**Решение:** Используйте более качественные модели или обучите свои
+
+## Полезные ресурсы
+
+- [FastAPI документация](https://fastapi.tiangolo.com/)
+- [spaCy документация](https://spacy.io/usage)
+- [Sentence Transformers](https://www.sbert.net/)
+- [BM25 алгоритм](https://en.wikipedia.org/wiki/Okapi_BM25)
+
+## Контакты и поддержка
+
+Для вопросов и предложений:
+- Создавайте issues в репозитории
+- Предлагайте улучшения через pull requests
+- Документируйте найденные баги

logic.py

@@ -0,0 +1,464 @@
+import spacy
+from collections import Counter
+from typing import List, Dict
+import numpy as np
+from rank_bm25 import BM25Okapi
+
+# Новые импорты для BERT
+import torch
+from sentence_transformers import SentenceTransformer, util
+
+# --- Глобальные переменные ---
+LoadedModels = {}       # spaCy модели
+BertModel = None        # BERT модель (одна на все языки)
+
+MODEL_NAMES = {
+    "en": "en_core_web_sm",
+    "ru": "ru_core_news_sm",
+    "de": "de_core_news_sm",
+    "es": "es_core_news_sm",
+    "it": "it_core_news_sm"
+}
+
+# --- SPACY (Лингвистика) ---
+
+def load_model_if_missing(lang: str):
+    if lang in LoadedModels: return
+    model_name = MODEL_NAMES.get(lang)
+    if not model_name: return
+
+    print(f"⏳ Loading spaCy model for {lang}...")
+    try:
+        LoadedModels[lang] = spacy.load(model_name)
+        print(f"✅ Loaded spaCy: {lang}")
+    except Exception as e:
+        print(f"❌ Failed to load spaCy {lang}: {e}")
+        
+def load_models():
+    """
+    Функция для предзагрузки всех моделей при старте (вызывается из main.py).
+    """
+    print("🚀 Pre-loading all spaCy models...")
+    for lang in MODEL_NAMES.keys():
+        load_model_if_missing(lang)
+
+def get_doc(text: str, lang: str):
+    load_model_if_missing(lang)
+    nlp = LoadedModels.get(lang)
+    if not nlp:
+        load_model_if_missing("en")
+        nlp = LoadedModels.get("en")
+    
+    if not nlp: raise RuntimeError("No NLP models loaded.")
+    nlp.max_length = 2000000 
+    return nlp(text.lower())
+
+# --- НОВАЯ ФУНКЦИЯ ФИЛЬТРАЦИИ ---
+def is_valid_token(t):
+    """
+    Проверяет, является ли токен полезным словом.
+    Исправленная версия: не удаляет слова из букв, даже если AI пометил их как символы.
+    """
+    # 1. Базовые проверки spaCy (Стоп-слова, пунктуация, пробелы)
+    if t.is_stop or t.is_punct or t.is_space:
+        return False
+    
+    # 2. Числа (удаляем "18", "2023", "5")
+    if t.is_digit or t.like_num:
+        return False
+        
+    # 3. СИМВОЛЫ (ИСПРАВЛЕНИЕ)
+    # Если spaCy говорит, что это символ (SYM), мы верим, ТОЛЬКО если это не буквы.
+    # Это спасет слова типа "cross", "apk", "bet", которые могут быть ложно помечены.
+    if t.pos_ == "SYM" and not t.text.isalpha():
+        return False
+        
+    # 4. Дополнительная страховка (явный мусор)
+    garbage_chars = {'|', '+', '-', '—', '–', '>', '<', '=', '/', '\\', '★', '▶', '●', '•', '€', '$', '£'}
+    if t.text.strip() in garbage_chars:
+        return False
+        
+    # 5. Длина: Удаляем одиночные буквы, которые не являются словами
+    # (опционально, но помогает чистить мусор типа "v", "s" если они не стоп-слова)
+    if len(t.text) == 1 and not t.text.isalpha():
+        return False
+
+    return True
+
+def get_lemmas_flat(text: str, lang: str) -> List[str]:
+    """
+    Возвращает плоский список лемм для всего текста (нужен для BM25).
+    """
+    if not text: return []
+    doc = get_doc(text, lang)
+    # Используем нашу новую функцию фильтрации
+    return [t.lemma_ for t in doc if is_valid_token(t)]
+
+def generate_ngrams_safe(text: str, lang: str, n: int) -> List[str]:
+    """
+    Генерирует n-граммы.
+    ИЗМЕНЕНИЕ: Оставляет стоп-слова внутри фраз, чтобы сохранить читаемость (gioco del pollo),
+    но фильтрует n-граммы, состоящие ТОЛЬКО из стоп-слов.
+    """
+    if not text: return []
+    doc = get_doc(text, lang)
+    all_ngrams = []
+    
+    for sent in doc.sents:
+        # 1. Собираем токены предложения. 
+        # Мы НЕ удаляем стоп-слова сразу, чтобы не рвать связность фразы.
+        # Но мы все еще чистим пунктуацию и явный мусор.
+        
+        sent_tokens = []
+        for t in sent:
+            # Пропускаем пунктуацию, пробелы и символы
+            if t.is_punct or t.is_space or t.pos_ == "SYM":
+                continue
+            # Пропускаем явный мусор из нашего списка
+            garbage_chars = {'|', '+', '-', '—', '–', '>', '<', '=', '/', '\\', '★', '▶', '●', '•', '€', '$', '£'}
+            if t.text.strip() in garbage_chars:
+                continue
+            
+            # Сохраняем токен: (Лемма, Является_ли_стоп_словом)
+            sent_tokens.append({
+                "lemma": t.lemma_,
+                "is_stop": t.is_stop
+            })
+        
+        # 2. Генерируем N-граммы из очищенного списка
+        if len(sent_tokens) >= n:
+            # Скользящее окно
+            for i in range(len(sent_tokens) - n + 1):
+                window = sent_tokens[i : i+n]
+                
+                # 3. ФИЛЬТР: Если ВСЕ слова в N-грамме - стоп-слова, пропускаем её.
+                # Пример: "e la" (биграмма из стоп-слов) -> мусор.
+                # Пример: "gioco del" (сущ + стоп) -> полезно.
+                if all(t["is_stop"] for t in window):
+                    continue
+                
+                # Склеиваем леммы
+                ngram_str = " ".join([t["lemma"] for t in window])
+                all_ngrams.append(ngram_str)
+            
+    return all_ngrams
+
+# --- ANALYTICS (N-grams & BM25) ---
+
+def calculate_ngram_stats(target_text: str, competitor_texts: List[str], lang: str) -> Dict:
+    stats = {}
+    
+    for n in range(1, 5):
+        key = {1: "unigrams", 2: "bigrams", 3: "trigrams", 4: "quadgrams"}[n]
+        
+        target_ngrams = generate_ngrams_safe(target_text, lang, n)
+        target_counts = Counter(target_ngrams)
+        
+        comp_counts_total = Counter()
+        for t in competitor_texts:
+            c_ngrams = generate_ngrams_safe(t, lang, n)
+            comp_counts_total.update(c_ngrams)
+            
+        all_unique = set(target_counts.keys()) | set(comp_counts_total.keys())
+        ngram_data = []
+        num_competitors = max(len(competitor_texts), 1)
+        
+        for ngram in all_unique:
+            cnt_target = target_counts.get(ngram, 0)
+            avg_comp = round(comp_counts_total.get(ngram, 0) / num_competitors, 1)
+            
+            # Фильтр мусора: если слово встречается крайне редко везде (<0.5 в среднем), не показываем.
+            # Но если у нас оно есть (cnt_target > 0) - показываем всегда.
+            if cnt_target > 0 or avg_comp >= 0.5: 
+                ngram_data.append({
+                    "ngram": ngram,
+                    "target_count": cnt_target,
+                    "competitor_avg": avg_comp
+                })
+        
+        # --- СОРТИРОВКА (ГЛАВНОЕ ИЗМЕНЕНИЕ) ---
+        # Сортируем по "Важности". Важность = Максимум из (частота у нас, частота у них).
+        # Это значит:
+        # 1. Если у нас слово 10 раз -> оно наверху.
+        # 2. Если у нас 0, а у них 10 раз -> оно ТОЖЕ наверху.
+        ngram_data.sort(key=lambda x: max(x["target_count"], x["competitor_avg"]), reverse=True)
+        
+        stats[key] = ngram_data[:150] 
+        
+    return stats
+
+def parse_keywords(raw_phrases: List[str], lang: str):
+    key_phrases = []
+    keywords = set()
+    for phrase in raw_phrases:
+        if not phrase.strip(): continue
+        lemmas = get_lemmas_flat(phrase, lang)
+        if lemmas:
+            key_phrases.append(phrase.strip()) # Для BERT храним исходную фразу, а не леммы!
+            for w in lemmas: keywords.add(w)
+    return list(key_phrases), list(keywords)
+
+def calculate_bm25_recommendations(target_text: str, competitor_texts: List[str], raw_keywords: List[str], lang: str):
+    """
+    BM25 с полной декомпозицией фраз.
+    Если на входе "chicken road casino", мы анализируем:
+    1. chicken, road, casino (Unigrams)
+    2. chicken road, road casino (Bigrams)
+    3. chicken road casino (Trigram)
+    """
+    if not target_text or not raw_keywords:
+        return []
+
+    recommendations = []
+    
+    # 1. СБОР ВСЕХ ВОЗМОЖНЫХ КОМБИНАЦИЙ ИЗ КЛЮЧЕВЫХ ФРАЗ
+    analyzed_keys = []
+    
+    # Используем set для отслеживания дубликатов на лету
+    seen_terms = set()
+
+    for phrase in raw_keywords:
+        if not phrase.strip(): continue
+        
+        # Получаем токены (уже в нижнем регистре, без лемматизации, как мы исправили ранее)
+        tokens = get_lemmas_flat(phrase, lang) 
+        if not tokens: continue
+        
+        # Генерируем все под-н-граммы длиной от 1 до 3
+        # Если фраза длинная (5 слов), мы всё равно разобьем её на куски по 1, 2, 3 слова.
+        max_n = min(len(tokens), 3) # Анализируем не более чем триграммы
+        
+        for n in range(1, max_n + 1):
+            # Скользящее окно по токенам фразы
+            for i in range(len(tokens) - n + 1):
+                window = tokens[i : i+n]
+                term = " ".join(window)
+                
+                if term not in seen_terms:
+                    analyzed_keys.append({
+                        "n": n,
+                        "term": term,
+                        "original": phrase # Просто для справки, откуда пришло
+                    })
+                    seen_terms.add(term)
+
+    # 2. МНОГОУРОВНЕВЫЙ РАСЧЕТ BM25
+    for n in range(1, 4):
+        # Отбираем ключи текущей длины
+        current_n_keys = [k['term'] for k in analyzed_keys if k['n'] == n]
+        if not current_n_keys:
+            continue
+            
+        # Строим корпус из N-грамм (Наш текст + Конкуренты)
+        target_ngrams = generate_ngrams_safe(target_text, lang, n)
+        comp_ngrams_list = [generate_ngrams_safe(t, lang, n) for t in competitor_texts]
+        
+        corpus = [target_ngrams] + comp_ngrams_list
+        
+        # Обучаем BM25
+        bm25 = BM25Okapi(corpus)
+        
+        for term in current_n_keys:
+            scores = bm25.get_scores([term])
+            score_target = scores[0]
+            score_avg_comp = np.mean(scores[1:]) if len(scores) > 1 else 0
+            
+            # --- Динамический порог ---
+            if n == 1:
+                threshold = 0.5
+            elif n == 2:
+                threshold = 0.25
+            else:
+                threshold = 0.15 
+            
+            action = "ok"
+            count_rec = 0
+            
+            # Логика рекомендаций
+            if score_target < score_avg_comp - threshold:
+                action = "add"
+                factor = 0.5 if n == 1 else 0.4 
+                count_rec = max(1, int((score_avg_comp - score_target) * factor)) 
+            elif score_target > score_avg_comp + threshold * 2: 
+                action = "remove"
+                factor = 0.5
+                count_rec = max(1, int((score_target - score_avg_comp) * factor))
+                
+            recommendations.append({
+                "word": term,
+                "type": f"{n}-gram",
+                "my_score": round(score_target, 2),
+                "avg_comp_score": round(score_avg_comp, 2),
+                "action": action,
+                "count": count_rec
+            })
+
+    # 3. СОРТИРОВКА
+    # 1. Сначала действия (ADD/REMOVE)
+    # 2. Потом по длине фразы (длинные интереснее: "gioco del pollo" выше чем "pollo")
+    # 3. Потом алфавит
+    recommendations.sort(key=lambda x: (
+        0 if x["action"] != "ok" else 1, 
+        -len(x["word"].split()),         
+        x["word"]
+    ))
+            
+    return recommendations
+
+# --- BERT / VECTOR ANALYSIS ---
+
+def get_bert_model():
+    """Загружает BERT на GPU, если он доступен"""
+    global BertModel
+    if BertModel is None:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"🚀 Loading BERT model on {device}...")
+        # Используем легкую и мощную мультиязычную модель
+        BertModel = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2', device=device)
+        print("✅ BERT Loaded successfully.")
+    return BertModel
+
+def perform_bert_analysis(target_text: str, competitor_texts: List[str], key_phrases: List[str], lang: str):
+    if not key_phrases:
+        return {"detailed": [], "global_scores": []}
+    
+    model = get_bert_model()
+    
+    # 1. Функция-помощник: Получить чанки и их эмбеддинги
+    def process_text(text):
+        if not text.strip(): return [], None
+        doc = get_doc(text, lang)
+        # Разбиваем на предложения > 10 символов
+        chunks = [sent.text.strip() for sent in doc.sents if len(sent.text.strip()) > 10]
+        if not chunks: return [], None
+        embeddings = model.encode(chunks, convert_to_tensor=True)
+        return chunks, embeddings
+
+    # 2. Обрабатываем Наш текст
+    target_chunks, target_emb = process_text(target_text)
+    
+    # 3. Обрабатываем Конкурентов (сохраняем структуру)
+    competitors_data = []
+    for idx, comp_text in enumerate(competitor_texts):
+        chunks, emb = process_text(comp_text)
+        competitors_data.append({
+            "id": idx + 1,
+            "chunks": chunks,
+            "embeddings": emb
+        })
+
+    # Эмбеддинги ключей
+    keys_emb = model.encode(key_phrases, convert_to_tensor=True)
+
+    # --- РАСЧЕТ GLOBAL SCORE ---
+    # Global Score - это средний Max Score ��о всем ключевым словам.
+    # То есть, насколько хорошо текст покрывает ВСЕ ключи в среднем.
+    
+    global_scores = []
+    
+    # Считаем для нас
+    if target_emb is not None:
+        # Матрица [Key x Chunk]
+        sims = util.cos_sim(keys_emb, target_emb)
+        # Берем макс. сходство для каждого ключа (values), потом среднее по всем ключам
+        # torch.max возвращает (values, indices)
+        max_scores_per_key, _ = torch.max(sims, dim=1) 
+        avg_relevance = torch.mean(max_scores_per_key).item()
+        global_scores.append({"name": "Мой текст", "score": round(avg_relevance, 3), "is_me": True})
+    else:
+        global_scores.append({"name": "Мой текст", "score": 0, "is_me": True})
+
+    # Считаем для конкурентов
+    for comp in competitors_data:
+        if comp["embeddings"] is not None:
+            sims = util.cos_sim(keys_emb, comp["embeddings"])
+            max_scores_per_key, _ = torch.max(sims, dim=1)
+            avg_relevance = torch.mean(max_scores_per_key).item()
+            global_scores.append({"name": f"Конкурент #{comp['id']}", "score": round(avg_relevance, 3), "is_me": False})
+        else:
+            global_scores.append({"name": f"Конкурент #{comp['id']}", "score": 0, "is_me": False})
+
+    # Сортируем глобальный рейтинг (победитель сверху)
+    global_scores.sort(key=lambda x: x["score"], reverse=True)
+
+    # --- ДЕТАЛЬНЫЙ АНАЛИЗ ПО ФРАЗАМ ---
+    detailed_results = []
+    
+    for i, phrase in enumerate(key_phrases):
+        # 1. Анализ моего текста
+        my_top = []
+        my_max = 0
+        if target_emb is not None:
+            # Считаем снова локально или берем из матрицы (тут проще локально для чистоты кода)
+            # scores_target[i] уже посчитано выше в sims, но выше переменная sims переписывалась.
+            # Для надежности пересчитаем векторную близость для одной фразы (это мгновенно)
+            phrase_emb = keys_emb[i]
+            scores = util.cos_sim(phrase_emb, target_emb)[0] # вектор [chunks]
+            
+            k = min(5, len(target_chunks))
+            vals, idxs = torch.topk(scores, k)
+            my_max = vals[0].item() if k > 0 else 0
+            
+            for rank in range(k):
+                my_top.append({
+                    "text": target_chunks[idxs[rank].item()],
+                    "score": round(vals[rank].item(), 3)
+                })
+
+        # 2. Анализ конкурентов (Сборная солянка)
+        # Собираем все чанки всех конкурентов с их скорами и ID
+        all_comp_candidates = []
+        
+        for comp in competitors_data:
+            if comp["embeddings"] is not None:
+                phrase_emb = keys_emb[i]
+                scores = util.cos_sim(phrase_emb, comp["embeddings"])[0]
+                
+                # Берем топ-3 от каждого конкурента, чтобы добавить в общий пул
+                k = min(3, len(comp["chunks"]))
+                vals, idxs = torch.topk(scores, k)
+                
+                for rank in range(k):
+                    all_comp_candidates.append({
+                        "text": comp["chunks"][idxs[rank].item()],
+                        "score": vals[rank].item(),
+                        "source": f"Конкурент #{comp['id']}" # <-- АТРИБУЦИЯ
+                    })
+        
+        # Сортируем общий пул конкурентов и берем ТОП-5 абсолютных лидеров
+        all_comp_candidates.sort(key=lambda x: x["score"], reverse=True)
+        comp_top_5 = all_comp_candidates[:5]
+        
+        # Округляем скоры для вывода
+        for item in comp_top_5:
+            item["score"] = round(item["score"], 3)
+            
+        comp_max = comp_top_5[0]["score"] if comp_top_5 else 0
+
+        # Статус
+        status = "ok"
+        rec = "Тема раскрыта хорошо."
+        if my_max < 0.5:
+            status = "bad"
+            rec = "Тема не раскрыта."
+        elif comp_max > my_max + 0.1:
+            status = "warning"
+            rec = "Конкуренты раскрыли тему заметно лучше."
+        elif my_max >= 0.7:
+            status = "good"
+            rec = "Отлично."
+
+        detailed_results.append({
+            "phrase": phrase,
+            "my_max_score": round(my_max, 2),
+            "comp_max_score": round(comp_max, 2),
+            "status": status,
+            "recommendation": rec,
+            "my_top_chunks": my_top,
+            "comp_top_chunks": comp_top_5
+        })
+
+    return {
+        "global_scores": global_scores,
+        "detailed": detailed_results
+    }

main.py

@@ -0,0 +1,62 @@
+# main.py
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+import uvicorn
+import torch
+
+from models import AnalysisRequest, AnalysisResponse
+import logic 
+
+app = FastAPI(title="SEO AI Editor MVP")
+
+# Подключаем папку с шаблонами
+templates = Jinja2Templates(directory="templates")
+
+@app.on_event("startup")
+async def startup_event():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"🚀 Application starting. ML Device: {device}")
+    logic.load_models() # spaCy preload (optional)
+
+# --- НОВЫЙ РОУТ ДЛЯ ГЛАВНОЙ СТРАНИЦЫ ---
+@app.get("/", response_class=HTMLResponse)
+async def read_root(request: Request):
+    # Рендерим файл index.html
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.post("/analyze", response_model=AnalysisResponse)
+async def analyze_text(request: AnalysisRequest):
+    # Логика та же самая, что и была
+    ngram_stats_result = logic.calculate_ngram_stats(
+        request.target_text, 
+        request.competitors, 
+        request.language
+    )
+    
+    key_phrases, key_words_unigrams = logic.parse_keywords(request.keywords, request.language)
+    
+    bm25_recs = logic.calculate_bm25_recommendations(
+        request.target_text,
+        request.competitors,
+        request.keywords,  # <-- ИЗМЕНЕНИЕ ЗДЕСЬ (было key_words_unigrams)
+        request.language
+    )
+    
+    bert_results = logic.perform_bert_analysis(
+        request.target_text,
+        request.competitors,  # <-- ДОБАВИЛИ ЭТОТ АРГУМЕНТ
+        key_phrases, 
+        request.language
+    )
+
+    return AnalysisResponse(
+        ngram_stats=ngram_stats_result,
+        bm25_recommendations=bm25_recs,
+        bert_analysis=bert_results
+    )
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="127.0.0.1", port=8001, reload=True)

models.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+from typing import List, Optional
+from typing import List, Dict, Optional, Any
+
+
+class CompetitorText(BaseModel):
+    id: int
+    text: str
+
+class AnalysisRequest(BaseModel):
+    target_text: str                # Текст пользователя
+    competitors: List[str]          # Список текстов конкурентов
+    keywords: List[str]             # Список ключевых фраз (сырых)
+    language: str = "en"            # en, ru, de, es, it
+
+class AnalysisResponse(BaseModel):
+    ngram_stats: dict               # Статистика униграм/биграм
+    bm25_recommendations: List[dict] # Рекомендации "добавить/убрать"
+    bert_analysis: Dict[str, Any]   # Векторный анализ

ps.sh

@@ -0,0 +1,2 @@
+$env:temp = "D:\seo_ai_editor\pip_temp"
+$env:tmp = "D:\seo_ai_editor\pip_temp"

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+pydantic
+numpy
+scikit-learn
+rank-bm25
+sentence-transformers
+spacy
+python-multipart
+jinja2

templates/index.html

@@ -0,0 +1,427 @@
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>SEO AI Editor (GPU Powered)</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+    <style>
+        body { background-color: #f8f9fa; }
+        .editor-box { min-height: 300px; font-family: 'Georgia', serif; font-size: 1.1rem; }
+        .stat-card { background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.05); padding: 20px; margin-bottom: 20px; }
+        .loading-overlay { 
+            display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; 
+            background: rgba(255,255,255,0.8); z-index: 9999; text-align: center; padding-top: 20%; 
+        }
+        /* Стили для скролла в таблицах */
+        .scrollable-table { max-height: 500px; overflow-y: auto; }
+    </style>
+</head>
+<body>
+
+<!-- Лоадер -->
+<div id="loader" class="loading-overlay">
+    <div class="spinner-border text-primary" style="width: 3rem; height: 3rem;" role="status"></div>
+    <h3 class="mt-3">AI анализирует текст...</h3>
+    <p class="text-muted">Первый запуск BERT может занять пару секунд</p>
+</div>
+
+<nav class="navbar navbar-dark bg-dark mb-4">
+    <div class="container-fluid">
+        <span class="navbar-brand mb-0 h1">🚀 SEO AI Editor <small class="text-secondary" style="font-size: 0.6em;">v1.2 BERT+Comparisons</small></span>
+    </div>
+</nav>
+
+<div class="container-fluid">
+    <div class="row">
+        <!-- ЛЕВАЯ КОЛОНКА: ВВОД ДАННЫХ -->
+        <div class="col-md-5">
+            <div class="stat-card">
+                <div class="mb-3">
+                    <label class="form-label fw-bold">Язык анализа</label>
+                    <select class="form-select" id="languageSelect">
+                        <option value="ru">🇷🇺 Русский</option>
+                        <option value="en">🇺🇸 English</option>
+                        <option value="de">🇩🇪 Deutsch</option>
+                        <option value="it">🇮🇹 Italiano</option>
+                        <option value="es">🇪🇸 Español</option>
+                    </select>
+                </div>
+
+                <div class="mb-3">
+                    <label class="form-label fw-bold">Ваш текст (Target)</label>
+                    <textarea class="form-control editor-box" id="targetText" placeholder="Пишите текст здесь..."></textarea>
+                </div>
+
+                <div class="mb-3">
+                    <label class="form-label fw-bold">Ключевые фразы</label>
+                    <small class="text-muted d-block mb-1">Каждая фраза с новой строки</small>
+                    <textarea class="form-control" id="keywordsInput" rows="5" placeholder="купить слона&#10;лучшие цены"></textarea>
+                </div>
+
+                <div class="mb-3">
+                    <label class="form-label fw-bold">Тексты конкурентов</label>
+                    <div id="competitorsList">
+                        <!-- Поля добавляются сюда -->
+                        <textarea class="form-control mb-2" rows="3" placeholder="Текст конкурента 1..."></textarea>
+                    </div>
+                    <button class="btn btn-sm btn-outline-secondary mt-1" onclick="addCompetitorField()">+ Добавить конкурента</button>
+                </div>
+
+                <div class="d-grid gap-2">
+                    <button class="btn btn-primary btn-lg" onclick="runAnalysis()">⚡ Анализировать (GPU)</button>
+                </div>
+            </div>
+        </div>
+
+        <!-- ПРАВАЯ КОЛОНКА: РЕЗУЛЬТАТЫ -->
+        <div class="col-md-7">
+            
+            <!-- Табы -->
+            <ul class="nav nav-tabs mb-3" id="resultsTab" role="tablist">
+                <li class="nav-item">
+                    <button class="nav-link active" id="bert-tab" data-bs-toggle="tab" data-bs-target="#bert" type="button">🧠 BERT Семантика</button>
+                </li>
+                <li class="nav-item">
+                    <button class="nav-link" id="bm25-tab" data-bs-toggle="tab" data-bs-target="#bm25" type="button">📊 BM25 Баланс</button>
+                </li>
+                <li class="nav-item">
+                    <button class="nav-link" id="ngrams-tab" data-bs-toggle="tab" data-bs-target="#ngrams" type="button">🔠 N-граммы</button>
+                </li>
+            </ul>
+
+            <div class="tab-content" id="resultsContent">
+                
+                <!-- BERT TAB (НОВЫЙ) -->
+                <div class="tab-pane fade show active" id="bert" role="tabpanel">
+                    <div class="stat-card">
+                        <h5 class="card-title">Семантический анализ (BERT)</h5>
+                        <p class="text-muted small">Сравнение глубины раскрытия темы у вас и у конкурентов.</p>
+                        <div id="bertResultsContainer">
+                            <div class="text-center text-muted py-5">Нажмите "Анализировать", чтобы увидеть результаты.</div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- BM25 TAB -->
+                <div class="tab-pane fade" id="bm25" role="tabpanel">
+                    <div class="stat-card">
+                        <h5 class="card-title">Частотный баланс (BM25)</h5>
+                        <p class="text-muted small">Рекомендации по добавлению/удалению слов.</p>
+                        <div class="scrollable-table">
+                            <table class="table table-hover">
+                                <thead>
+                                    <tr>
+                                        <th>Слово</th>
+                                        <th>Действие</th>
+                                        <th>Кол-во</th>
+                                        <th>Мой Score</th>
+                                        <th>Avg Comp</th>
+                                    </tr>
+                                </thead>
+                                <tbody id="bm25TableBody">
+                                </tbody>
+                            </table>
+                        </div>
+                        <div id="bm25EmptyMsg" class="text-center text-muted py-3">Нет критических рекомендаций.</div>
+                    </div>
+                </div>
+
+                <!-- N-GRAMS TAB -->
+                <div class="tab-pane fade" id="ngrams" role="tabpanel">
+                    <div class="stat-card">
+                        <h5 class="card-title">Статистика слов</h5>
+                        <div class="mb-3">
+                            <div class="btn-group" role="group">
+                                <button type="button" class="btn btn-outline-primary active" onclick="showNgramTable('unigrams')">1 слово</button>
+                                <button type="button" class="btn btn-outline-primary" onclick="showNgramTable('bigrams')">2 слова</button>
+                                <button type="button" class="btn btn-outline-primary" onclick="showNgramTable('trigrams')">3 слова</button>
+                            </div>
+                        </div>
+                        <div class="scrollable-table">
+                            <table class="table table-sm">
+                                <thead>
+                                    <tr>
+                                        <th>Фраза</th>
+                                        <th>У меня</th>
+                                        <th>У конкурентов (avg)</th>
+                                    </tr>
+                                </thead>
+                                <tbody id="ngramTableBody"></tbody>
+                            </table>
+                        </div>
+                    </div>
+                </div>
+
+            </div>
+        </div>
+    </div>
+</div>
+
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
+<script>
+    let currentData = null;
+
+    // --- ФУНКЦИИ ИНТЕРФЕЙСА ---
+
+    function addCompetitorField() {
+        const div = document.createElement('div');
+        div.innerHTML = '<textarea class="form-control mb-2 competitor-input" rows="3" placeholder="Ещё конкурент..."></textarea>';
+        document.getElementById('competitorsList').appendChild(div);
+    }
+
+    async function runAnalysis() {
+        // Сбор данных
+        const targetText = document.getElementById('targetText').value;
+        const lang = document.getElementById('languageSelect').value;
+        const keywordsRaw = document.getElementById('keywordsInput').value.split('\n').filter(k => k.trim() !== '');
+        
+        // Сбор конкурентов
+        const compInputs = document.querySelectorAll('#competitorsList textarea');
+        const competitors = [];
+        compInputs.forEach(input => {
+            if(input.value.trim() !== '') competitors.push(input.value);
+        });
+
+        if(!targetText) { alert("Введите ваш текст!"); return; }
+
+        // UI Loading
+        document.getElementById('loader').style.display = 'block';
+
+        const payload = {
+            target_text: targetText,
+            competitors: competitors,
+            keywords: keywordsRaw,
+            language: lang
+        };
+
+        try {
+            const response = await fetch('/analyze', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+
+            if (!response.ok) throw new Error("Ошибка сервера: " + response.statusText);
+
+            const data = await response.json();
+            currentData = data;
+            renderResults(data);
+
+        } catch (error) {
+            alert("Ошибка: " + error.message);
+            console.error(error);
+        } finally {
+            document.getElementById('loader').style.display = 'none';
+        }
+    }
+
+    function renderResults(data) {
+        // 1. BERT Render (ИСПРАВЛЕННЫЙ ПОД НОВУЮ СТРУКТУРУ)
+        const bertContainer = document.getElementById('bertResultsContainer');
+        bertContainer.innerHTML = '';
+        
+        // Получаем объект данных. Теперь это объект, а не массив!
+        const bertData = data.bert_analysis;
+        
+        // Проверяем, есть ли поле detailed (список фраз)
+        if (!bertData || !bertData.detailed || bertData.detailed.length === 0) {
+            bertContainer.innerHTML = '<div class="alert alert-warning">Добавьте ключевые фразы для анализа.</div>';
+        } else {
+            
+            // А. Рендерим ГЛОБАЛЬНЫЙ СЧЕТ (Global Score)
+            if (bertData.global_scores && bertData.global_scores.length > 0) {
+                let globalHtml = '<div class="card mb-4 border-primary"><div class="card-body">';
+                globalHtml += '<h6 class="card-title text-primary fw-bold mb-3">🏆 Общий рейтинг релевантности (Global Score)</h6>';
+                
+                bertData.global_scores.forEach(gs => {
+                    const scorePct = Math.round(gs.score * 100);
+                    const isMe = gs.is_me;
+                    const barColor = isMe ? 'bg-primary' : 'bg-secondary';
+                    const rowBg = isMe ? 'bg-light border-start border-primary border-3' : '';
+                    const nameLabel = isMe ? `<strong>${gs.name} (Вы)</strong>` : gs.name;
+
+                    globalHtml += `
+                    <div class="d-flex align-items-center mb-2 p-2 rounded ${rowBg}">
+                        <div style="width: 150px;">${nameLabel}</div>
+                        <div class="flex-grow-1 mx-3">
+                            <div class="progress" style="height: 20px;">
+                                <div class="progress-bar ${barColor}" role="progressbar" style="width: ${scorePct}%">${scorePct}%</div>
+                            </div>
+                        </div>
+                        <div class="fw-bold">${gs.score}</div>
+                    </div>`;
+                });
+                globalHtml += '</div></div>';
+                bertContainer.insertAdjacentHTML('beforeend', globalHtml);
+            }
+
+            // Б. Рендерим ДЕТАЛИЗАЦИЮ (Аккордеоны)
+            // Итерируемся именно по .detailed, так как это массив
+            bertData.detailed.forEach((item, index) => {
+                let badgeClass = 'bg-secondary';
+                if(item.status === 'good') badgeClass = 'bg-success';
+                if(item.status === 'warning') badgeClass = 'bg-warning text-dark';
+                if(item.status === 'bad') badgeClass = 'bg-danger';
+
+                const collapseId = `collapseBert${index}`;
+
+                // Мои чанки
+                const myChunksHtml = item.my_top_chunks.map(c => 
+                    `<li class="list-group-item d-flex justify-content-between align-items-start border-0 border-bottom">
+                        <div class="small me-2">"${c.text}"</div>
+                        <span class="badge bg-primary rounded-pill opacity-75">${c.score}</span>
+                    </li>`
+                ).join('');
+
+                // Чанки конкурентов (С АТРИБУЦИЕЙ ИСТОЧНИКА)
+                const compChunksHtml = (item.comp_top_chunks && item.comp_top_chunks.length > 0) 
+                    ? item.comp_top_chunks.map(c => 
+                        `<li class="list-group-item d-flex justify-content-between align-items-start border-0 border-bottom list-group-item-light">
+                            <div class="me-2">
+                                <span class="badge bg-secondary mb-1" style="font-size: 0.7em;">${c.source}</span>
+                                <div class="small text-muted">"${c.text}"</div>
+                            </div>
+                            <span class="badge bg-dark rounded-pill opacity-50">${c.score}</span>
+                        </li>`
+                    ).join('')
+                    : '<li class="list-group-item text-muted small border-0">Нет данных</li>';
+
+                const html = `
+                <div class="card mb-3 border">
+                    <div class="card-header bg-white d-flex justify-content-between align-items-center" style="cursor: pointer;" data-bs-toggle="collapse" data-bs-target="#${collapseId}">
+                        <div>
+                            <div class="fw-bold text-dark">${item.phrase}</div>
+                            <div class="text-muted small">
+                                My: <b>${item.my_max_score}</b> vs Best Comp: <b>${item.comp_max_score}</b>
+                            </div>
+                        </div>
+                        <span class="badge ${badgeClass}">${item.status.toUpperCase()}</span>
+                    </div>
+                    
+                    <div id="${collapseId}" class="collapse">
+                        <div class="card-body bg-light">
+                            <p class="small mb-3"><strong>Совет:</strong> ${item.recommendation}</p>
+                            <div class="row">
+                                <div class="col-md-6">
+                                    <h6 class="small fw-bold text-primary">Мой текст</h6>
+                                    <ul class="list-group shadow-sm mb-3">${myChunksHtml || '<li class="list-group-item small">Нет вхождений</li>'}</ul>
+                                </div>
+                                <div class="col-md-6 border-start">
+                                    <h6 class="small fw-bold text-secondary">Лучшее у конкурентов</h6>
+                                    <ul class="list-group shadow-sm">${compChunksHtml}</ul>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>`;
+                bertContainer.insertAdjacentHTML('beforeend', html);
+            });
+        }
+
+        // 2. BM25 Render (ОБНОВЛЕННЫЙ v2 - Полный список)
+        const bm25Body = document.getElementById('bm25TableBody');
+        bm25Body.innerHTML = '';
+        const bm25Msg = document.getElementById('bm25EmptyMsg');
+        
+        // Теперь мы ожидаем, что список не пуст, если были введены ключи
+        if (data.bm25_recommendations && data.bm25_recommendations.length > 0) {
+            bm25Msg.style.display = 'none';
+            
+            data.bm25_recommendations.forEach(item => {
+                let colorClass = '';
+                let actionText = '';
+                let countText = '';
+                let rowBg = '';
+                
+                // Определяем стили в зависимости от действия
+                if (item.action === 'add') {
+                    colorClass = 'text-success';
+                    actionText = 'ДОБАВИТЬ';
+                    countText = `+${item.count}`;
+                    rowBg = 'table-success'; // Легкая зеленая подсветка всей строки (Bootstrap класс)
+                    // Но лучше не красить всю строку, чтобы не рябило, покрасим только текст действия
+                    rowBg = ''; 
+                } else if (item.action === 'remove') {
+                    colorClass = 'text-danger';
+                    actionText = 'УБРАТЬ';
+                    countText = `-${item.count}`;
+                } else {
+                    colorClass = 'text-muted'; // Серый цвет
+                    actionText = 'НОРМА'; // Или OK
+                    countText = '<span class="text-muted">-</span>';
+                }
+                
+                // Жирный шрифт для важных действий
+                const weight = item.action === 'ok' ? 'fw-normal' : 'fw-bold';
+
+                const row = `
+                <tr>
+                    <td class="fw-bold text-dark">${item.word}</td>
+                    <td class="${colorClass} ${weight}">${actionText}</td>
+                    <td class="${colorClass} ${weight}">${countText}</td>
+                    <td>${item.my_score}</td>
+                    <td>${item.avg_comp_score}</td>
+                </tr>`;
+                bm25Body.insertAdjacentHTML('beforeend', row);
+            });
+        } else {
+            // Если список пуст (например, не ввели ключевые слова)
+            bm25Msg.style.display = 'block';
+            bm25Msg.textContent = "Введите ключевые фразы для расчета BM25.";
+        }
+
+        // 3. N-grams (ОСТАВЛЯЕМ КАК ЕСТЬ)
+        showNgramTable('unigrams');
+    }
+
+    function showNgramTable(type) {
+        if(!currentData) return;
+        
+        // Логика переключения кнопок (visual state)
+        document.querySelectorAll('#ngrams .btn').forEach(b => {
+            // Простая проверка по тексту кнопки ("1 слово", "2 слова"...)
+            if(type === 'unigrams' && b.innerText.includes('1')) b.classList.add('active');
+            else if(type === 'bigrams' && b.innerText.includes('2')) b.classList.add('active');
+            else if(type === 'trigrams' && b.innerText.includes('3')) b.classList.add('active');
+            else b.classList.remove('active');
+        });
+        
+        const tbody = document.getElementById('ngramTableBody');
+        tbody.innerHTML = '';
+        
+        const list = currentData.ngram_stats[type];
+        
+        if(list && list.length > 0) {
+            list.forEach(item => {
+                let rowClass = "";
+                let countClass = "";
+                let icon = "";
+
+                // Логика подсветки
+                if (item.target_count === 0 && item.competitor_avg > 0) {
+                    // У НИХ ЕСТЬ, У НАС НЕТ -> ВАЖНО!
+                    rowClass = "table-warning"; // Желтоватый фон (Bootstrap)
+                    countClass = "text-danger fw-bold";
+                    icon = "⚠️"; // Предупреждение
+                } else if (item.target_count > 0 && item.competitor_avg === 0) {
+                    // У нас есть, у них нет (наша уникальность)
+                    // Можно выделить зеленым, но не обязательно, это не проблема.
+                    countClass = "text-success";
+                }
+
+                const row = `
+                <tr class="${rowClass}">
+                    <td>${item.ngram} ${icon}</td>
+                    <td class="fw-bold ${countClass}">${item.target_count}</td>
+                    <td>${item.competitor_avg}</td>
+                </tr>`;
+                tbody.insertAdjacentHTML('beforeend', row);
+            });
+        } else {
+             tbody.innerHTML = '<tr><td colspan="3" class="text-center text-muted">Нет данных</td></tr>';
+        }
+    }
+</script>
+</body>
+</html>