Upload 8 files

.env.example

@@ -0,0 +1,12 @@
+SUPABASE_URL=https://sfajtyvvoyjunjwuenbk.supabase.co
+SUPABASE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InNmYWp0eXZ2b3lqdW5qd3VlbmJrIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA4Mzg0MDQsImV4cCI6MjA4NjQxNDQwNH0.5ZjLsnIGJOXjm-pnWx3cgLPdXN0IIJpKWEPO9xxPAYk
+SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InNmYWp0eXZ2b3lqdW5qd3VlbmJrIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc3MDgzODQwNCwiZXhwIjoyMDg2NDE0NDA0fQ.CbHsXnBwJwQGtKNcoTuXtFofF2p5sAr_f_Hzyf4uQd0
+
+# Настройки парсера
+MAX_PAGES=5
+DELAY_MIN=2
+DELAY_MAX=5
+
+# Трансформеры кэш
+TRANSFORMERS_CACHE=/tmp/transformers
+HF_HOME=/tmp/huggingface

DEPLOY_HF.md

@@ -0,0 +1,216 @@
+# 🚀 Деплой на Hugging Face Spaces
+
+## Инструкция по запуску
+
+### Шаг 1: Создайте Space
+
+1. Перейдите на https://huggingface.co/spaces
+2. Нажмите **"Create new Space"**
+3. Заполните:
+   - **Name**: `fipi-parser-ege` (или любое другое)
+   - **License**: MIT
+   - **SDK**: **Docker**
+   - **Visibility**: Public (или Private)
+4. Нажмите **"Create Space"**
+
+### Шаг 2: Загрузите файлы
+
+**Вариант A: Через Git**
+```bash
+cd refined
+git init
+git add .
+git commit -m "Initial commit"
+git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE
+git push -u origin main
+```
+
+**Вариант B: Через веб-интерфейс**
+1. Откройте ваш Space на Hugging Face
+2. Перейдите в **"Files"**
+3. Нажмите **"Add file"** → **"Upload files"**
+4. Загрузите все файлы из проекта
+
+### Шаг 3: Настройте переменные окружения
+
+1. В панели Space перейдите в **"Settings"**
+2. Найдите **"Variables and secrets"**
+3. Добавьте:
+   - `SUPABASE_URL`: `https://your-project.supabase.co`
+   - `SUPABASE_KEY`: `your-anon-key`
+
+### Шаг 4: Запуск
+
+Space автоматически соберётся и запустится!
+
+**Время сборки:** 5-10 минут (загружается ruBERT модель)
+
+### Шаг 5: Использование API
+
+После запуска ваш API будет доступен по адресу:
+```
+https://YOUR_USERNAME-YOUR_SPACE.hf.space
+```
+
+## 📡 API Эндпоинты
+
+### 1. Проверка сочинения
+
+```bash
+curl -X POST "https://YOUR_USERNAME-YOUR_SPACE.hf.space/grade" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "essay": "В тексте поднимается проблема...",
+    "source": "Исходный текст..."
+  }'
+```
+
+**Ответ:**
+```json
+{
+  "total_score": 8,
+  "max_score": 9,
+  "percentage": 89,
+  "criteria": {
+    "k1": {"score": 1, "comment": "..."},
+    "k2": {"score": 3, "comment": "..."},
+    "k3": {"score": 2, "comment": "..."},
+    "k4": {"score": 1, "comment": "..."},
+    "k5": {"score": 1, "comment": "..."}
+  }
+}
+```
+
+### 2. Получить задания из Supabase
+
+```bash
+curl "https://YOUR_USERNAME-YOUR_SPACE.hf.space/tasks"
+```
+
+### 3. Запустить парсер
+
+```bash
+curl -X POST "https://YOUR_USERNAME-YOUR_SPACE.hf.space/parse" \
+  -H "Content-Type: application/json" \
+  -d '{"max_pages": 3}'
+```
+
+## 🏠 Главная страница
+
+Откройте в браузере:
+```
+https://YOUR_USERNAME-YOUR_SPACE.hf.space/docs
+```
+
+Там будет Swagger UI с документацией API!
+
+## 📊 Структура проекта для HF
+
+```
+refined/
+├── Dockerfile              # Конфигурация Docker
+├── app.py                  # Основное API (FastAPI + ruBERT)
+├── requirements.txt        # Python зависимости
+├── .env.example            # Пример переменных
+├── fipi_ai_scraper.py     # Парсер ФИПИ
+├── supabase_client.py     # Клиент Supabase
+└── README_HF.md           # Эта инструкция
+```
+
+## ⚙️ Конфигурация
+
+### Dockerfile
+- Python 3.10
+- FastAPI + Uvicorn
+- transformers (ruBERT)
+- Порт: 7860
+
+### Переменные окружения
+```bash
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your-anon-key
+TRANSFORMERS_CACHE=/tmp/transformers
+HF_HOME=/tmp/huggingface
+```
+
+## 💰 Тарифы
+
+**Бесплатный план:**
+- ✅ CPU (2 vCPU)
+- ✅ 16GB RAM
+- ✅ 500MB хранилище
+- ⚠️ Засыпает через 48 часов без активности
+
+**Pro план ($9/мес):**
+- ✅ Не засыпает
+- ✅ Больше ресурсов
+- ✅ Приватные Spaces
+
+## 🔧 Troubleshooting
+
+### Space не запускается
+1. Проверьте логи в панели **"Logs"**
+2. Убедитесь, что Dockerfile корректен
+3. Проверьте зависимости в requirements.txt
+
+### Ошибка памяти
+ruBERT требует ~2GB RAM. Если не хватает:
+- Используйте Pro план
+- Или уберите transformers из requirements.txt
+
+### Supabase не подключается
+1. Проверьте переменные в Settings → Variables
+2. Убедитесь, что таблица tasks создана
+3. Проверьте URL и ключ
+
+## 📝 Примеры использования
+
+### Python клиент
+```python
+import requests
+
+API_URL = "https://YOUR_USERNAME-YOUR_SPACE.hf.space"
+
+# Проверка сочинения
+response = requests.post(
+    f"{API_URL}/grade",
+    json={
+        "essay": "В тексте подн��мается проблема...",
+        "source": "Исходный текст..."
+    }
+)
+print(response.json())
+
+# Получить задания
+response = requests.get(f"{API_URL}/tasks")
+print(response.json())
+```
+
+### JavaScript клиент
+```javascript
+const API_URL = "https://YOUR_USERNAME-YOUR_SPACE.hf.space";
+
+// Проверка сочинения
+const response = await fetch(`${API_URL}/grade`, {
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({
+    essay: "В тексте поднимается проблема...",
+    source: "Исходный текст..."
+  })
+});
+
+const result = await response.json();
+console.log(result);
+```
+
+## 🎉 Готово!
+
+Ваш сервис для проверки сочинений ЕГЭ и парсинга заданий ФИПИ работает на Hugging Face Spaces!
+
+---
+
+**Ссылки:**
+- Документация HF Spaces: https://huggingface.co/docs/hub/spaces
+- Docker SDK: https://huggingface.co/docs/hub/spaces-sdks-docker
+- FastAPI: https://fastapi.tiangolo.com/

Dockerfile

@@ -0,0 +1,64 @@
+# Dockerfile для ЕГЭ Парсера ФИПИ
+# Multi-stage build для оптимизации размера
+
+FROM python:3.10-slim as base
+
+# Рабочая директория
+WORKDIR /app
+
+# Переменные окружения
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    TRANSFORMERS_CACHE=/tmp/transformers \
+    HF_HOME=/tmp/huggingface
+
+# Установка системных зависимостей
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Копирование requirements
+COPY requirements.txt .
+
+# Установка Python зависимостей (кэширование слоя)
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Копирование кода
+COPY . .
+
+# Загрузка spaCy модели
+RUN python -m spacy download ru_core_news_md || true
+
+# Порт по умолчанию
+EXPOSE 7860
+
+# Команда запуска
+CMD ["python", "app.py"]
+
+# ============================================================
+# Development stage (опционально)
+# ============================================================
+
+FROM base as dev
+
+# Установка dev зависимостей
+RUN pip install pytest pytest-cov black flake8 mypy
+
+# Команда для разработки
+CMD ["python", "-m", "uvicorn", "app:app", "--reload", "--host", "0.0.0.0", "--port", "7860"]
+
+# ============================================================
+# Production stage (опционально)
+# ============================================================
+
+FROM base as prod
+
+# Создание не-root пользователя
+RUN useradd -m -u 1000 appuser && \
+    chown -R appuser:appuser /app
+USER appuser
+
+# Production команда
+CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "4"]

README.md

@@ -0,0 +1,9 @@
+---
+title: ФИПИ Скрапер API
+emoji: 📝
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+license: mit
+---

app.py

@@ -0,0 +1,297 @@
+"""
+ЕГЭ Эксперт - API для проверки сочинений и парсинга заданий
+Объединяет ruBERT scraper и ФИПИ парсер
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List, Dict
+import torch
+from transformers import AutoTokenizer, AutoModel
+import re
+import json
+import os
+from dotenv import load_dotenv
+
+# Загружаем переменные окружения
+load_dotenv()
+
+app = FastAPI(
+    title="ЕГЭ Эксперт API",
+    description="Проверка сочинений ЕГЭ + парсинг заданий ФИПИ",
+    version="2.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ============================================================
+# ЗАГРУЗКА ruBERT
+# ============================================================
+
+MODEL_NAME = "DeepPavlov/rubert-base-cased-sentence"
+tokenizer = None
+model = None
+
+def load_model():
+    global tokenizer, model
+    print("Loading ruBERT model...")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+    model = AutoModel.from_pretrained(MODEL_NAME)
+    model.eval()
+    print("ruBERT loaded!")
+
+@app.on_event("startup")
+async def startup():
+    load_model()
+
+# ============================================================
+# МОДЕЛИ ДАННЫХ
+# ============================================================
+
+class EssayRequest(BaseModel):
+    essay: str
+    source: Optional[str] = ""
+
+class TaskRequest(BaseModel):
+    url: Optional[str] = ""
+    max_pages: int = 3
+
+class SupabaseConfig(BaseModel):
+    supabase_url: str
+    supabase_key: str
+
+# ============================================================
+# УТИЛИТЫ
+# ============================================================
+
+def normalize(text: str) -> str:
+    return text.lower().replace("ё", "е").strip()
+
+def count_words(text: str) -> int:
+    return len([w for w in text.strip().split() if w])
+
+def get_paragraphs(text: str) -> list:
+    return [p.strip() for p in re.split(r'\n+', text) if p.strip()]
+
+def get_sentences(text: str) -> list:
+    return [s.strip() for s in re.split(r'[.!?]+', text) if s.strip()]
+
+def get_embedding(text: str) -> torch.Tensor:
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512, padding=True)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    token_embeddings = outputs.last_hidden_state
+    attention_mask = inputs["attention_mask"]
+    mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+    embedding = torch.sum(token_embeddings * mask_expanded, 1) / torch.clamp(mask_expanded.sum(1), min=1e-9)
+    return embedding[0]
+
+def cosine_similarity(a: torch.Tensor, b: torch.Tensor) -> float:
+    return torch.nn.functional.cosine_similarity(a.unsqueeze(0), b.unsqueeze(0)).item()
+
+# ============================================================
+# КРИТЕРИИ ЕГЭ
+# ============================================================
+
+K1_PHRASES = ["проблем", "автор поднимает", "автор рассматривает", "текст посвящен"]
+K2_EXAMPLE_PHRASES = ["например", "автор пишет", "автор описывает", "в тексте"]
+K2_LINK_PHRASES = ["таким образом", "следовательно", "оба примера", "кроме того"]
+K3_OPINION_PHRASES = ["я считаю", "я думаю", "по моему мнению", "я согласен"]
+K3_ARG_PHRASES = ["потому что", "так как", "литература", "в романе", "в повести"]
+
+def check_k1(essay: str, has_source: bool, relevance: float = 0.5) -> dict:
+    n = normalize(essay)
+    found = [p for p in K1_PHRASES if p in n]
+    
+    if has_source:
+        if len(found) >= 1 or relevance > 0.4:
+            return {"score": 1, "comment": "Позиция автора сформулирована."}
+        return {"score": 0, "comment": "Позиция автора не сформулирована."}
+    else:
+        if len(found) >= 1:
+            return {"score": 1, "comment": "Проблема сформулирована."}
+        return {"score": 0, "comment": "Проблема не сформулирована."}
+
+def check_k2(essay: str, has_source: bool) -> dict:
+    n = normalize(essay)
+    sentences = get_sentences(essay)
+    
+    example_sentences = [s for s in sentences if any(p in normalize(s) for p in K2_EXAMPLE_PHRASES)]
+    has_link = any(p in n for p in K2_LINK_PHRASES)
+    
+    if len(example_sentences) >= 2 and has_link:
+        return {"score": 3, "comment": "Два примера с пояснением и связью."}
+    elif len(example_sentences) >= 2:
+        return {"score": 2, "comment": "Два примера без связи."}
+    elif len(example_sentences) >= 1:
+        return {"score": 1, "comment": "Один пример."}
+    return {"score": 0, "comment": "Нет примеров."}
+
+def check_k3(essay: str) -> dict:
+    n = normalize(essay)
+    
+    has_opinion = any(p in n for p in K3_OPINION_PHRASES)
+    has_arg = any(p in n for p in K3_ARG_PHRASES)
+    
+    if has_opinion and has_arg:
+        return {"score": 2, "comment": "Позиция выражена и обоснована."}
+    elif has_opinion:
+        return {"score": 1, "comment": "Позиция выражена."}
+    return {"score": 0, "comment": "Позиция не выражена."}
+
+def check_k4(essay: str) -> dict:
+    if count_words(essay) < 50:
+        return {"score": 0, "comment": "Текст слишком короткий."}
+    return {"score": 1, "comment": "Ошибок нет."}
+
+def check_k5(essay: str) -> dict:
+    paragraphs = get_paragraphs(essay)
+    
+    if len(paragraphs) >= 5:
+        return {"score": 2, "comment": "Структура соблюдена."}
+    elif len(paragraphs) >= 3:
+        return {"score": 1, "comment": "Структура частична."}
+    return {"score": 0, "comment": "Нет абзацев."}
+
+# ============================================================
+# API ЭНДПОИНТЫ
+# ============================================================
+
+@app.get("/")
+async def root():
+    return {
+        "message": "ЕГЭ Эксперт API",
+        "version": "2.0.0",
+        "endpoints": [
+            "POST /grade - Проверка сочинения",
+            "GET /tasks - Получить задания из БД",
+            "POST /parse - Запустить парсер"
+        ]
+    }
+
+@app.post("/grade")
+async def grade_essay(request: EssayRequest):
+    """Проверка сочинения ЕГЭ"""
+    
+    essay = request.essay
+    source = request.source or ""
+    has_source = len(source) > 10
+    
+    # Семантическая близость
+    relevance = 0.5
+    if has_source:
+        try:
+            emb_essay = get_embedding(essay[:512])
+            emb_source = get_embedding(source[:512])
+            relevance = cosine_similarity(emb_essay, emb_source)
+        except:
+            pass
+    
+    # Проверка по критериям
+    k1 = check_k1(essay, has_source, relevance)
+    k2 = check_k2(essay, has_source)
+    k3 = check_k3(essay)
+    k4 = check_k4(essay)
+    k5 = check_k5(essay)
+    
+    total = k1["score"] + k2["score"] + k3["score"] + k4["score"] + k5["score"]
+    max_score = 9
+    
+    return {
+        "total_score": total,
+        "max_score": max_score,
+        "percentage": round(total / max_score * 100),
+        "criteria": {
+            "k1": k1,
+            "k2": k2,
+            "k3": k3,
+            "k4": k4,
+            "k5": k5
+        },
+        "stats": {
+            "words": count_words(essay),
+            "paragraphs": len(get_paragraphs(essay)),
+            "sentences": len(get_sentences(essay))
+        }
+    }
+
+@app.get("/tasks")
+async def get_tasks():
+    """Получить задания из Supabase"""
+    
+    supabase_url = os.getenv("SUPABASE_URL")
+    supabase_key = os.getenv("SUPABASE_KEY")
+    
+    if not supabase_url or not supabase_key:
+        return {"error": "Supabase не настроен", "tasks": []}
+    
+    try:
+        import requests
+        response = requests.get(
+            f"{supabase_url}/rest/v1/tasks?limit=100",
+            headers={
+                "apikey": supabase_key,
+                "Authorization": f"Bearer {supabase_key}"
+            },
+            timeout=10
+        )
+        
+        if response.status_code == 200:
+            tasks = response.json()
+            return {"count": len(tasks), "tasks": tasks}
+        else:
+            return {"error": f"Ошибка {response.status_code}", "tasks": []}
+    except Exception as e:
+        return {"error": str(e), "tasks": []}
+
+@app.post("/parse")
+async def parse_tasks(request: TaskRequest):
+    """Запустить парсер заданий"""
+    
+    supabase_url = os.getenv("SUPABASE_URL")
+    supabase_key = os.getenv("SUPABASE_KEY")
+    
+    if not supabase_url or not supabase_key:
+        return {"error": "Supabase не настроен"}
+    
+    # Импортируем парсер
+    try:
+        from fipi_ai_scraper import parse_all_sources
+        tasks = parse_all_sources(max_pages=request.max_pages)
+        
+        # Сохраняем в Supabase
+        if tasks:
+            import requests
+            saved = 0
+            for task in tasks:
+                resp = requests.post(
+                    f"{supabase_url}/rest/v1/tasks",
+                    headers={
+                        "apikey": supabase_key,
+                        "Authorization": f"Bearer {supabase_key}",
+                        "Content-Type": "application/json"
+                    },
+                    json=task,
+                    timeout=10
+                )
+                if resp.status_code in [200, 201]:
+                    saved += 1
+            
+            return {"message": f"Сохранено {saved} заданий", "count": saved}
+        return {"message": "Задания не найдены"}
+    except Exception as e:
+        return {"error": str(e)}
+
+# ============================================================
+# ЗАПУСК
+# ============================================================
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

fipi_ai_scraper.py

@@ -0,0 +1,515 @@
+"""
+AI Scraper для заданий ЕГЭ по русскому языку
+Использует ScrapeGraphAI для интеллектуального парсинга
+"""
+
+import asyncio
+import json
+import time
+from typing import List, Dict, Optional
+from datetime import datetime
+import requests
+from bs4 import BeautifulSoup
+from dotenv import load_dotenv
+import os
+
+# Загружаем переменные окружения
+load_dotenv()
+
+# ============================================================
+# КОНФИГУРАЦИЯ
+# ============================================================
+
+SOURCES = {
+    "fipi": {
+        "name": "ФИПИ",
+        "base_url": "https://fipi.ru/ege/demonstracionnye-varianty-i-specifikacii",
+        "enabled": False  # ФИПИ блокирует запросы
+    },
+    "examer": {
+        "name": "Examer",
+        "base_url": "https://examer.ru/ege_po_russkomu_yazyku/zadanie",
+        "enabled": True
+    },
+    "neofamily": {
+        "name": "Neofamily",
+        "base_url": "https://neofamily.ru/ege-russkiy-yazyk",
+        "enabled": True
+    }
+}
+
+MAX_PAGES = 5
+DELAY_MIN = 2
+DELAY_MAX = 5
+
+# ============================================================
+# МОДЕЛИ ДАННЫХ (Pydantic schemas)
+# ============================================================
+
+from pydantic import BaseModel, Field
+
+
+class TaskSchema(BaseModel):
+    """Схема задания ЕГЭ"""
+    task_id: str = Field(..., description="Уникальный ID задания")
+    topic: str = Field(default="Русский язык", description="Тема задания")
+    condition: str = Field(..., description="Условие задания")
+    content: str = Field(..., description="Содержимое задания")
+    answer_format: str = Field(default="не определено", description="Формат ответа")
+    source_name: str = Field(..., description="Источник")
+    structure: Dict = Field(default_factory=dict, description="Структура задания")
+    parsed_at: str = Field(default_factory=lambda: datetime.now().isoformat())
+
+
+class TopicSchema(BaseModel):
+    """Схема темы"""
+    name: str
+    confidence: float
+    keywords: List[str] = []
+
+
+# ============================================================
+# NLP ПРОЦЕССОР (spaCy + Hugging Face)
+# ============================================================
+
+class NLPProcessor:
+    """Обработка текста с помощью NLP"""
+
+    def __init__(self):
+        self.nlp = None
+        self.classifier = None
+        self._loaded = False
+
+    def load_models(self):
+        """Загрузка моделей"""
+        try:
+            import spacy
+            print("Загрузка spaCy модели для русского языка...")
+            self.nlp = spacy.load("ru_core_news_md")
+            print("[OK] spaCy загружен")
+        except Exception as e:
+            print(f"[WARN] spaCy не загружен: {e}")
+
+        try:
+            from transformers import pipeline
+            print("Загрузка классификатора ruBERT...")
+            self.classifier = pipeline(
+                "text-classification",
+                model="DeepPavlov/rubert-base-cased-sentence",
+                top_k=None
+            )
+            print("[OK] ruBERT загружен")
+        except Exception as e:
+            print(f"[WARN] ruBERT не загружен: {e}")
+
+        self._loaded = True
+
+    def analyze_topic(self, text: str) -> TopicSchema:
+        """Определение темы задания"""
+        topics_keywords = {
+            "Орфография": ["правопис", "орфограм", "корень", "приставк", "суффикс", "окончани"],
+            "Пунктуация": ["запят", "тире", "двоеточ", "пунктуаци", "знак"],
+            "Морфология": ["морфем", "морфолог", "часть речи", "падеж", "число", "род"],
+            "Синтаксис": ["синтаксис", "предложени", "подлежащ", "сказуем", "член"],
+            "Культура речи": ["норм", "ударени", "произнош", "литератур"],
+            "Лексика": ["лексическ", "значени", "синоним", "антоним", "фразеолог"],
+            "Грамматика": ["грамматик", "ошибк", "постро", "форм"]
+        }
+
+        text_lower = text.lower()
+        best_topic = "Русский язык"
+        best_count = 0
+
+        for topic, keywords in topics_keywords.items():
+            count = sum(1 for kw in keywords if kw in text_lower)
+            if count > best_count:
+                best_topic = topic
+                best_count = count
+
+        return TopicSchema(
+            name=best_topic,
+            confidence=min(best_count / 3.0, 1.0),
+            keywords=[kw for kw in topics_keywords.get(best_topic, []) if kw in text_lower]
+        )
+
+    def analyze_structure(self, text: str) -> Dict:
+        """Анализ структуры текста"""
+        doc = self.nlp(text) if self.nlp else None
+
+        sentences = [s.text.strip() for s in doc.sents] if doc else text.split('.')
+        words = text.split()
+
+        return {
+            "sentences_count": len(sentences),
+            "words_count": len(words),
+            "unique_words": len(set(w.lower() for w in words)),
+            "avg_sentence_length": len(words) / max(len(sentences), 1),
+            "has_paragraphs": "\n\n" in text
+        }
+
+    def determine_answer_format(self, text: str) -> str:
+        """Определение формата ответа"""
+        text_lower = text.lower()
+
+        if any(x in text_lower for x in ["одно слово", "одним словом", "слово"]):
+            return "слово"
+        elif any(x in text_lower for x in ["цифра", "число", "ответ"]):
+            return "цифра"
+        elif any(x in text_lower for x in ["последователь", "цифр", "порядк"]):
+            return "последовательность"
+        elif any(x in text_lower for x in ["соответств", "соотнес", "пар"]):
+            return "соответствие"
+        elif any(x in text_lower for x in ["выбор", "вариант", "отметь"]):
+            return "выбор"
+        elif any(x in text_lower for x in ["запиш", "встав", "пропущ"]):
+            return "вставка"
+        else:
+            return "не определено"
+
+
+# ============================================================
+# FEEDER ROBOT (Навигация по каталогу)
+# ============================================================
+
+class FeederRobot:
+    """Робот для обхода страниц каталога заданий"""
+
+    def __init__(self, source: str, config: Dict):
+        self.source = source
+        self.config = config
+        self.urls_queue = []
+        self.session = requests.Session()
+        self.session.headers.update({
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        })
+
+    def collect_urls(self, max_pages: int = MAX_PAGES) -> List[str]:
+        """Сбор URL-адресов заданий"""
+        print(f"\n[Feeder] Сбор URL с {self.config['name']}...")
+
+        if self.source == "examer":
+            return self._collect_examer_urls(max_pages)
+        elif self.source == "neofamily":
+            return self._collect_neofamily_urls(max_pages)
+
+        return []
+
+    def _collect_examer_urls(self, max_pages: int) -> List[str]:
+        """Сбор URL с examer.ru"""
+        urls = []
+        base_url = self.config["base_url"]
+
+        for page in range(1, max_pages + 1):
+            url = f"{base_url}/{page}"
+            try:
+                print(f"  Страница {page}: {url}")
+                response = self.session.get(url, timeout=10)
+
+                if response.status_code == 200:
+                    soup = BeautifulSoup(response.text, 'lxml')
+
+                    # Ищем ссылки на задания
+                    links = soup.select('a[href*="/zadanie/"]')
+                    for link in links:
+                        href = link.get('href', '')
+                        if href and href not in urls:
+                            urls.append(href)
+
+                    time.sleep(DELAY_MIN)
+                else:
+                    print(f"  [WARN] Статус {response.status_code}")
+                    break
+
+            except Exception as e:
+                print(f"  [ERROR] Ошибка: {e}")
+                break
+
+        print(f"  [OK] Найдено {len(urls)} URL")
+        return urls
+
+    def _collect_neofamily_urls(self, max_pages: int) -> List[str]:
+        """Сбор URL с neofamily.ru"""
+        urls = []
+        base_url = self.config["base_url"]
+
+        # Neofamily использует другую структуру
+        try:
+            response = self.session.get(base_url, timeout=10)
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.text, 'lxml')
+                links = soup.select('a[href*="/task/"]')
+                for link in links[:max_pages * 10]:
+                    href = link.get('href', '')
+                    if href and href.startswith('http'):
+                        urls.append(href)
+        except Exception as e:
+            print(f"  [ERROR] Neofamily: {e}")
+
+        print(f"  [OK] Найдено {len(urls)} URL")
+        return urls
+
+
+# ============================================================
+# FINISHER ROBOT (Глубокий парсинг)
+# ============================================================
+
+class FinisherRobot:
+    """Робот для глубокого парсинга заданий"""
+
+    def __init__(self, nlp_processor: NLPProcessor):
+        self.nlp = nlp_processor
+        self.session = requests.Session()
+        self.session.headers.update({
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        })
+
+    def parse_task(self, url: str, source: str) -> Optional[Dict]:
+        """Парсинг одного задания"""
+        try:
+            print(f"  [Finisher] Парсинг: {url[:80]}...")
+            response = self.session.get(url, timeout=10)
+
+            if response.status_code != 200:
+                return None
+
+            soup = BeautifulSoup(response.text, 'lxml')
+
+            # Извлекаем условие и контент
+            condition = self._extract_condition(soup, source)
+            content = self._extract_content(soup, source)
+
+            if not condition and not content:
+                return None
+
+            # Генерируем ID
+            task_id = f"{source}_{abs(hash(url)) % 100000}"
+
+            # NLP анализ
+            full_text = f"{condition} {content}"
+            topic_info = self.nlp.analyze_topic(full_text)
+            structure = self.nlp.analyze_structure(full_text)
+            answer_format = self.nlp.determine_answer_format(full_text)
+
+            return {
+                "task_id": task_id,
+                "topic": topic_info.name,
+                "condition": condition[:2000] if condition else "",
+                "content": content[:2000] if content else "",
+                "answer_format": answer_format,
+                "source_name": source,
+                "structure": structure,
+                "parsed_at": datetime.now().isoformat(),
+                "url": url
+            }
+
+        except Exception as e:
+            print(f"  [ERROR] Ошибка парсинга: {e}")
+            return None
+
+    def _extract_condition(self, soup: BeautifulSoup, source: str) -> str:
+        """Извлечение условия задания"""
+        if source == "examer":
+            # Examer использует специфичные классы
+            condition_blocks = soup.select('.task-description, .condition, p:first-child')
+            if condition_blocks:
+                return condition_blocks[0].get_text(strip=True)
+
+        if source == "neofamily":
+            task_blocks = soup.select('.task-text, .question-text')
+            if task_blocks:
+                return task_blocks[0].get_text(strip=True)
+
+        # fallback
+        paragraphs = soup.find_all('p')
+        return paragraphs[0].get_text(strip=True) if paragraphs else ""
+
+    def _extract_content(self, soup: BeautifulSoup, source: str) -> str:
+        """Извлечение содержимого задания"""
+        if source == "examer":
+            content_blocks = soup.select('.task-content, .example, .text-block')
+            if content_blocks:
+                return '\n'.join([b.get_text(strip=True) for b in content_blocks[:3]])
+
+        if source == "neofamily":
+            content_blocks = soup.select('.content, .passage')
+            if content_blocks:
+                return '\n'.join([b.get_text(strip=True) for b in content_blocks[:3]])
+
+        return ""
+
+
+# ============================================================
+# SCRAPEGRAPH AI ИНТЕГРАЦИЯ
+# ============================================================
+
+class ScrapeGraphAIProcessor:
+    """Интеграция со ScrapeGraphAI для умного парсинга"""
+
+    def __init__(self):
+        self.enabled = False
+        try:
+            from scrapegraphai.graphs import SmartScraperGraph
+            self.SmartScraperGraph = SmartScraperGraph
+            self.enabled = True
+            print("[OK] ScrapeGraphAI доступен")
+        except ImportError:
+            print("[WARN] ScrapeGraphAI не установлен")
+
+    def parse_with_ai(self, url: str, prompt: str) -> Optional[Dict]:
+        """Парсинг с использованием AI"""
+        if not self.enabled:
+            return None
+
+        try:
+            graph_config = {
+                "llm": {
+                    "model": "ollama/llama2",
+                    "temperature": 0,
+                    "format": "json"
+                },
+                "embeddings": {
+                    "model": "ollama/nomic-embed-text"
+                }
+            }
+
+            smart_scraper = self.SmartScraperGraph(
+                prompt=prompt,
+                source=url,
+                config=graph_config
+            )
+
+            result = smart_scraper.run()
+            return result
+
+        except Exception as e:
+            print(f"  [ERROR] ScrapeGraphAI: {e}")
+            return None
+
+
+# ============================================================
+# ОСНОВНОЙ ПАРСЕР
+# ============================================================
+
+class FipiAIParser:
+    """Основной парсер с интеграцией всех компонентов"""
+
+    def __init__(self):
+        self.nlp = NLPProcessor()
+        self.nlp.load_models()
+
+        self.feeder = None
+        self.finisher = FinisherRobot(self.nlp)
+        self.scrapegraph = ScrapeGraphAIProcessor()
+
+        self.parsed_tasks = []
+
+    def parse_source(self, source: str, max_pages: int = MAX_PAGES) -> List[Dict]:
+        """Парсинг одного источника"""
+        if source not in SOURCES or not SOURCES[source]["enabled"]:
+            print(f"[SKIP] {source} отключен")
+            return []
+
+        config = SOURCES[source]
+        print(f"\n{'='*50}")
+        print(f"Парсинг источника: {config['name']}")
+        print(f"{'='*50}")
+
+        # Feeder: сбор URL
+        self.feeder = FeederRobot(source, config)
+        urls = self.feeder.collect_urls(max_pages)
+
+        if not urls:
+            print(f"[WARN] URL не найдены")
+            return []
+
+        # Finisher: парсинг заданий
+        tasks = []
+        for i, url in enumerate(urls[:20], 1):  # Ограничим 20 для теста
+            print(f"\n[{i}/{len(urls)}]")
+            task = self.finisher.parse_task(url, source)
+            if task:
+                tasks.append(task)
+                self.parsed_tasks.append(task)
+
+            time.sleep(DELAY_MIN)
+
+        print(f"\n[OK] {config['name']}: найдено {len(tasks)} заданий")
+        return tasks
+
+    def parse_all_sources(self, max_pages: int = MAX_PAGES) -> List[Dict]:
+        """Парсинг всех источников"""
+        all_tasks = []
+
+        for source in SOURCES:
+            tasks = self.parse_source(source, max_pages)
+            all_tasks.extend(tasks)
+
+        return all_tasks
+
+    def save_to_jsonl(self, tasks: List[Dict], filename: str = "fipi_ai_tasks.jsonl"):
+        """Сохранение в JSONL формат"""
+        with open(filename, 'w', encoding='utf-8') as f:
+            for task in tasks:
+                f.write(json.dumps(task, ensure_ascii=False) + '\n')
+        print(f"[OK] Сохранено {len(tasks)} заданий в {filename}")
+
+    def save_to_supabase(self, tasks: List[Dict]) -> Dict:
+        """Сохранение в Supabase"""
+        from supabase_client import save_tasks_batch
+        return save_tasks_batch(tasks)
+
+
+# ============================================================
+# ЗАПУСК
+# ============================================================
+
+def main():
+    """Точка входа"""
+    print("="*60)
+    print("AI Scraper для заданий ЕГЭ по русскому языку")
+    print("="*60)
+
+    parser = FipiAIParser()
+
+    # Парсинг
+    tasks = parser.parse_all_sources(max_pages=MAX_PAGES)
+
+    if not tasks:
+        print("\n[WARN] Задания не найдены. Используем тестовые данные...")
+        from generate_sample_data import generate_sample_tasks
+        tasks = generate_sample_tasks()
+
+    # Сохранение
+    parser.save_to_jsonl(tasks)
+
+    # Supabase (если настроен)
+    if os.getenv("SUPABASE_URL"):
+        parser.save_to_supabase(tasks)
+
+    # Статистика
+    print("\n" + "="*60)
+    print("СТАТИСТИКА")
+    print("="*60)
+    print(f"Всего заданий: {len(tasks)}")
+
+    topics = {}
+    for task in tasks:
+        topic = task.get("topic", "Русский язык")
+        topics[topic] = topics.get(topic, 0) + 1
+
+    print("\nТемы:")
+    for topic, count in sorted(topics.items(), key=lambda x: -x[1]):
+        print(f"  {topic}: {count}")
+
+    formats = {}
+    for task in tasks:
+        fmt = task.get("answer_format", "не определено")
+        formats[fmt] = formats.get(fmt, 0) + 1
+
+    print("\nФорматы ответов:")
+    for fmt, count in sorted(formats.items(), key=lambda x: -x[1]):
+        print(f"  {fmt}: {count}")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,34 @@
+# Web Scraping
+requests>=2.31.0
+beautifulsoup4>=4.12.0
+lxml>=4.9.0
+selenium>=4.15.0
+webdriver-manager>=4.0.1
+
+# AI Scraping
+scrapegraphai>=1.0.0
+langchain>=0.1.0
+langchain-community>=0.0.10
+
+# NLP
+transformers>=4.35.0
+torch>=2.0.0
+spacy>=3.7.0
+https://github.com/explosion/spacy-models/releases/download/ru_core_news_md-3.7.0/ru_core_news_md-3.7.0-py3-none-any.whl
+
+# Data Processing
+pydantic>=2.5.0
+jsonlines>=4.0.0
+
+# Supabase
+python-dotenv>=1.0.0
+supabase>=2.0.0
+psycopg2-binary>=2.9.9
+
+# API
+fastapi>=0.100.0
+uvicorn>=0.23.0
+
+# Utilities
+aiohttp>=3.9.0
+asyncio>=3.4.3

supabase_client.py

@@ -0,0 +1,483 @@
+"""
+Расширенный клиент Supabase с поддержкой векторного поиска и embeddings
+"""
+
+import os
+import json
+import requests
+import torch
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+from dotenv import load_dotenv
+
+# Загружаем переменные окружения
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+SUPABASE_ENABLED = bool(SUPABASE_URL and SUPABASE_KEY)
+
+
+class SupabaseEmbeddings:
+    """Генерация embeddings с помощью ruBERT"""
+
+    def __init__(self):
+        self.tokenizer = None
+        self.model = None
+        self._loaded = False
+
+    def load_model(self):
+        """Загрузка модели ruBERT"""
+        if self._loaded:
+            return
+
+        try:
+            from transformers import AutoTokenizer, AutoModel
+            print("Загрузка ruBERT для embeddings...")
+            self.tokenizer = AutoTokenizer.from_pretrained("DeepPavlov/rubert-base-cased")
+            self.model = AutoModel.from_pretrained("DeepPavlov/rubert-base-cased")
+            self.model.eval()
+            self._loaded = True
+            print("[OK] ruBERT загружен")
+        except Exception as e:
+            print(f"[WARN] ruBERT не загружен: {e}")
+
+    def get_embedding(self, text: str, max_length: int = 512) -> Optional[List[float]]:
+        """Получение векторного представления текста"""
+        if not self._loaded:
+            self.load_model()
+
+        if not self._loaded:
+            return None
+
+        try:
+            inputs = self.tokenizer(
+                text,
+                return_tensors="pt",
+                truncation=True,
+                max_length=max_length,
+                padding=True
+            )
+
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+
+            # Mean pooling
+            token_embeddings = outputs.last_hidden_state
+            attention_mask = inputs["attention_mask"]
+            mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+            embedding = torch.sum(token_embeddings * mask_expanded, 1) / torch.clamp(mask_expanded.sum(1), min=1e-9)
+
+            # Нормализация
+            embedding = torch.nn.functional.normalize(embedding, p=2, dim=1)
+
+            return embedding[0].tolist()
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка генерации embeddings: {e}")
+            return None
+
+
+class SupabaseClient:
+    """Расширенный клиент Supabase с векторным поиском"""
+
+    def __init__(self):
+        self.embeddings = SupabaseEmbeddings()
+        self.session = requests.Session()
+
+        if SUPABASE_ENABLED:
+            print(f"[OK] Supabase подключен: {SUPABASE_URL}")
+        else:
+            print("[WARN] Supabase не настроен")
+
+    # ============================================================
+    # CRUD ОПЕРАЦИИ
+    # ============================================================
+
+    def create_task(self, task_data: Dict) -> Optional[int]:
+        """Создание задания"""
+        if not SUPABASE_ENABLED:
+            return None
+
+        try:
+            url = f"{SUPABASE_URL}/rest/v1/tasks"
+            headers = self._get_headers()
+
+            # Генерируем embeddings для контента
+            content_text = f"{task_data.get('condition', '')} {task_data.get('content', '')}"
+            embedding = self.embeddings.get_embedding(content_text)
+
+            if embedding:
+                task_data['embeddings'] = json.dumps(embedding)
+
+            # Извлекаем ключевые слова
+            if 'keywords' not in task_data:
+                task_data['keywords'] = self._extract_keywords(content_text)
+
+            response = self.session.post(url, headers=headers, json=task_data, timeout=10)
+
+            if response.status_code in [200, 201]:
+                result = response.json()
+                if result:
+                    return result[0].get("id")
+
+            print(f"[ERROR] Ошибка создания: {response.status_code}")
+            return None
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка: {e}")
+            return None
+
+    def get_task(self, task_id: str) -> Optional[Dict]:
+        """Получение задания по ID"""
+        if not SUPABASE_ENABLED:
+            return None
+
+        try:
+            url = f"{SUPABASE_URL}/rest/v1/tasks?task_id=eq.{task_id}"
+            headers = self._get_headers()
+
+            response = self.session.get(url, headers=headers, timeout=10)
+
+            if response.status_code == 200:
+                tasks = response.json()
+                return tasks[0] if tasks else None
+
+            return None
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка: {e}")
+            return None
+
+    def get_tasks(
+        self,
+        topic: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0
+    ) -> List[Dict]:
+        """Получение списка заданий с фильтрацией"""
+        if not SUPABASE_ENABLED:
+            return []
+
+        try:
+            url = f"{SUPABASE_URL}/rest/v1/tasks?limit={limit}&offset={offset}"
+            headers = self._get_headers()
+
+            if topic:
+                url += f"&topic=eq.{topic}"
+
+            response = self.session.get(url, headers=headers, timeout=10)
+
+            if response.status_code == 200:
+                return response.json()
+
+            return []
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка: {e}")
+            return []
+
+    def update_task(self, task_id: str, updates: Dict) -> bool:
+        """Обновление задания"""
+        if not SUPABASE_ENABLED:
+            return False
+
+        try:
+            url = f"{SUPABASE_URL}/rest/v1/tasks?task_id=eq.{task_id}"
+            headers = self._get_headers()
+
+            response = self.session.patch(url, headers=headers, json=updates, timeout=10)
+
+            return response.status_code in [200, 204]
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка: {e}")
+            return False
+
+    def delete_task(self, task_id: str) -> bool:
+        """Удаление задания"""
+        if not SUPABASE_ENABLED:
+            return False
+
+        try:
+            url = f"{SUPABASE_URL}/rest/v1/tasks?task_id=eq.{task_id}"
+            headers = self._get_headers()
+
+            response = self.session.delete(url, headers=headers, timeout=10)
+
+            return response.status_code in [200, 204]
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка: {e}")
+            return False
+
+    # ============================================================
+    # ВЕКТОРНЫЙ ПОИСК
+    # ============================================================
+
+    def search_similar_tasks(
+        self,
+        query_text: str,
+        threshold: float = 0.7,
+        limit: int = 10
+    ) -> List[Dict]:
+        """Поиск похожих заданий с помощью векторного поиска"""
+        if not SUPABASE_ENABLED:
+            return []
+
+        # Генерируем embeddings для запроса
+        query_embedding = self.embeddings.get_embedding(query_text)
+
+        if not query_embedding:
+            # Fallback: текстовый поиск
+            return self._text_search(query_text, limit)
+
+        try:
+            # Используем RPC функцию для векторного поиска
+            url = f"{SUPABASE_URL}/rest/v1/rpc/find_similar_tasks"
+            headers = self._get_headers()
+
+            payload = {
+                "search_text": query_text,
+                "match_threshold": threshold,
+                "match_count": limit
+            }
+
+            response = self.session.post(url, headers=headers, json=payload, timeout=10)
+
+            if response.status_code == 200:
+                return response.json()
+
+            return []
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка векторного поиска: {e}")
+            return self._text_search(query_text, limit)
+
+    def _text_search(self, query: str, limit: int = 10) -> List[Dict]:
+        """Текстовый поиск (fallback)"""
+        if not SUPABASE_ENABLED:
+            return []
+
+        try:
+            # Поиск по ключевым словам и теме
+            url = f"{SUPABASE_URL}/rest/v1/tasks?or=(topic.ilike.%{query}%,condition.ilike.%{query}%)&limit={limit}"
+            headers = self._get_headers()
+
+            response = self.session.get(url, headers=headers, timeout=10)
+
+            if response.status_code == 200:
+                return response.json()
+
+            return []
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка текстового поиска: {e}")
+            return []
+
+    # ============================================================
+    # МАССОВЫЕ ОПЕРАЦИИ
+    # ============================================================
+
+    def save_tasks_batch(self, tasks: List[Dict]) -> Dict:
+        """Массовое сохранение заданий"""
+        if not SUPABASE_ENABLED:
+            return {"saved": 0, "failed": 0, "total": len(tasks), "error": "Supabase не подключен"}
+
+        stats = {"saved": 0, "failed": 0, "total": len(tasks)}
+
+        print(f"\nСохранение {len(tasks)} заданий в Supabase...")
+
+        for i, task in enumerate(tasks, 1):
+            print(f"  [{i}/{len(tasks)}]")
+            result = self.create_task(task)
+            if result:
+                stats["saved"] += 1
+            else:
+                stats["failed"] += 1
+
+        print(f"\n[OK] Сохранено: {stats['saved']}, Ошибок: {stats['failed']}")
+
+        return stats
+
+    # ============================================================
+    # АНАЛИТИКА
+    # ============================================================
+
+    def get_topic_stats(self) -> List[Dict]:
+        """Статистика по темам"""
+        if not SUPABASE_ENABLED:
+            return []
+
+        try:
+            url = f"{SUPABASE_URL}/rest/v1/rpc/get_topic_stats"
+            headers = self._get_headers()
+
+            response = self.session.post(url, headers=headers, json={}, timeout=10)
+
+            if response.status_code == 200:
+                return response.json()
+
+            return []
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка статистики: {e}")
+            return []
+
+    def get_random_tasks(self, topic: Optional[str] = None, limit: int = 10) -> List[Dict]:
+        """Получение случайных заданий"""
+        if not SUPABASE_ENABLED:
+            return []
+
+        try:
+            url = f"{SUPABASE_URL}/rest/v1/rpc/get_random_tasks"
+            headers = self._get_headers()
+
+            payload = {"limit_count": limit}
+            if topic:
+                payload["topic_filter"] = topic
+
+            response = self.session.post(url, headers=headers, json=payload, timeout=10)
+
+            if response.status_code == 200:
+                return response.json()
+
+            return []
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка: {e}")
+            return []
+
+    # ============================================================
+    # УТИЛИТЫ
+    # ============================================================
+
+    def _get_headers(self) -> Dict:
+        """Получение заголовков для API запросов"""
+        return {
+            "apikey": SUPABASE_KEY,
+            "Authorization": f"Bearer {SUPABASE_KEY}",
+            "Content-Type": "application/json",
+            "Prefer": "return=representation"
+        }
+
+    def _extract_keywords(self, text: str, max_keywords: int = 10) -> List[str]:
+        """Извлечение ключевых слов (простая реализация)"""
+        # Стоп-слова для русского языка
+        stop_words = {
+            'и', 'в', 'во', 'не', 'что', 'он', 'на', 'я', 'с', 'со', 'как', 'а', 'то',
+            'все', 'она', 'так', 'его', 'но', 'да', 'ты', 'к', 'у', 'же', 'вы', 'за',
+            'бы', 'по', 'только', 'ее', 'мне', 'было', 'вот', 'от', 'меня', 'еще',
+            'нет', 'о', 'из', 'ему', 'теперь', 'когда', 'даже', 'ну', 'вдруг', 'ли',
+            'если', 'уже', 'или', 'ни', 'быть', 'был', 'него', 'до', 'вас', 'нибудь',
+            'опять', 'уж', 'вам', 'вед', 'пусть', 'тогда', 'кто', 'этой', 'того',
+            'потому', 'этот', 'какой', 'совсем', 'ним', 'здесь', 'этом', 'один',
+            'почти', 'мой', 'тем', 'чтобы', 'нее', 'сейчас', 'были', 'куда', 'зачем',
+            'всех', 'никогда', 'можно', 'при', 'наконец', 'два', 'об', 'другой',
+            'хоть', 'после', 'над', 'больше', 'тот', 'через', 'эти', 'нас', 'про',
+            'всего', 'них', 'какая', 'много', 'разве', 'три', 'эту', 'моя', 'впрочем',
+            'хорошо', 'у', 'для', 'че', 'лет', 'который', 'правда', 'место', 'слово'
+        }
+
+        words = text.lower().split()
+        keywords = []
+
+        for word in words:
+            # Очищаем от знаков препинания
+            word = ''.join(c for c in word if c.isalpha())
+
+            if len(word) > 3 and word not in stop_words and word not in keywords:
+                keywords.append(word)
+
+            if len(keywords) >= max_keywords:
+                break
+
+        return keywords
+
+    def test_connection(self) -> bool:
+        """Проверка подключения"""
+        if not SUPABASE_ENABLED:
+            return False
+
+        try:
+            url = f"{SUPABASE_URL}/rest/v1/tasks?limit=1"
+            headers = self._get_headers()
+
+            response = self.session.get(url, headers=headers, timeout=10)
+
+            return response.status_code == 200
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка подключения: {e}")
+            return False
+
+
+# ============================================================
+# ДЕКОРАТОР ДЛЯ АСИНХРОННОЙ ОЧЕРЕДИ
+# ============================================================
+
+class EmbeddingsQueue:
+    """Очередь для асинхронной генерации embeddings"""
+
+    def __init__(self, supabase_client: SupabaseClient):
+        self.client = supabase_client
+
+    def enqueue(self, task_id: str, text: str) -> bool:
+        """Добавление задачи в очередь"""
+        if not SUPABASE_ENABLED:
+            return False
+
+        try:
+            url = f"{SUPABASE_URL}/rest/v1/rpc/pgmq_send"
+            headers = self.client._get_headers()
+
+            payload = {
+                "queue_name": "embeddings_queue",
+                "message": {
+                    "task_id": task_id,
+                    "text": text,
+                    "created_at": datetime.now().isoformat()
+                }
+            }
+
+            response = self.client.session.post(url, headers=headers, json=payload, timeout=10)
+
+            return response.status_code in [200, 201]
+
+        except Exception as e:
+            print(f"[ERROR] Ошибка очереди: {e}")
+            return False
+
+
+# ============================================================
+# ЗАПУСК
+# ============================================================
+
+if __name__ == "__main__":
+    print("="*60)
+    print("Тестирование Supabase клиента")
+    print("="*60)
+
+    client = SupabaseClient()
+
+    if client.test_connection():
+        print("\n[OK] Подключение к Supabase успешно!")
+
+        # Тест получения заданий
+        tasks = client.get_tasks(limit=5)
+        print(f"\nПолучено заданий: {len(tasks)}")
+
+        # Тест статистики
+        stats = client.get_topic_stats()
+        print(f"\nСтатистика по темам: {stats}")
+
+        # Тест векторного поиска
+        similar = client.search_similar_tasks("орфография корни слов", limit=3)
+        print(f"\nПохожие задания: {len(similar)}")
+
+    else:
+        print("\n[WARN] Supabase не подключен")
+        print("Настройте переменные окружения:")
+        print("  SUPABASE_URL=https://your-project.supabase.co")
+        print("  SUPABASE_KEY=your-anon-key")