Files
filwordspl-backend/routers/assistant.py
T
Drobysh 742337fb14 🌊 Волна 11: backend N+1 + метрики (5 багов)
- online_now_counts_all_today_logins: убрана ветка daily_logins, фильтр 30 мин (admin.py)
- assistant_personal_stats_n_plus_1: 36 → 6 запросов через GROUP BY (assistant.py)
- learning_get_lesson_n_plus_1: ANY + группировка options, + get_topic_test (learning.py)
- feed_attachment_order_collision: MAX(order_number)+1 + UNIQUE (feed.py + database.py)
- admin_content_summary_n_plus_1: 30 → 6 запросов через GROUP BY (admin_content.py)

Аудит v2: Issue #5, backend 10/10 задач — закрыто!
2026-09-24 09:31:13 +00:00

521 lines
21 KiB
Python

"""
AI Assistant Router — чат-помощник с историей, контекстом, лимитами и статистикой.
Лёгкие запросы → GPT-OSS 20B, сложные → GPT-OSS 120B.
Бесплатный лимит: 5 сообщений в день (кроме админов).
"""
import logging
import time
import json
import httpx
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from config import TOGETHER_API_KEY, ADMIN_IDS
from database import get_pool
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/assistant", tags=["assistant"])
TOGETHER_API_URL = "https://api.together.xyz/v1/chat/completions"
# Модели
EASY_MODEL = "openai/gpt-oss-20b"
HARD_MODEL = "openai/gpt-oss-120b"
# Максимум сообщений в истории (10 последних)
MAX_HISTORY = 10
# Бесплатный лимит сообщений в день
FREE_DAILY_LIMIT = 5
LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
SYSTEM_PROMPT = """Ты — AI-помощник Filwords PL, приложения для изучения польского языка.
Твои задачи:
1. Переводить фразы с русского/украинского/английского на польский и обратно
2. Объяснять грамматику польского языка простыми словами
3. Отвечать на вопросы о польском языке
4. Давать примеры использования слов и фраз
5. Помогать с повседневными фразами (магазин, врач, работа, учёба)
ОПРЕДЕЛЕНИЕ ЯЗЫКА ПОЛЬЗОВАТЕЛЯ:
- Если пользователь пишет на русском — отвечай на русском
- Если на украинском — отвечай на украинском
- Если на польском — отвечай на польском
- Если на английском — отвечай на английском
- ВСЕГДА отвечай на языке пользователя!
- Польские слова и фразы в примерах оставляй на польском, но объяснения и комментарии — на языке пользователя
ВАЖНЫЕ ПРАВИЛА:
- НЕ используй markdown (никаких **, *, #, `, ```)
- Пиши простым текстом
- Для перевода используй формат: Польская фраза → Перевод
- Будь кратким, но полезным
- Отвечай на языке пользователя
- Не упоминай, что ты AI или модель. Ты — помощник Filwords."""
# Ключевые слова для сложных запросов (на 4 языках)
HARD_KEYWORDS = [
# Русские
"объясни", "почему", "грамматик", "правило", "разница", "расскажи",
"подробно", "история", "примеры", "спряжение", "склонение", "падеж",
"урок", "мини-урок", "занятие", "обучение",
# Украинские
"поясни", "чому", "граматик", "правило", "різниця", "розкажи",
"докладно", "історія", "приклади", "відмінювання", "відмінок",
"урок", "міні-урок", "заняття", "навчання",
# Польские
"wytłumacz", "dlaczego", "gramatyk", "zasada", "różnica", "opowiedz",
"szczegółowo", "historia", "przykłady", "koniugacja", "deklinacja", "przypadek",
"lekcja", "mini-lekcja", "zajęcia", "nauka",
# Английские
"explain", "why", "grammar", "rule", "difference", "tell me",
"detailed", "history", "examples", "conjugation", "declension", "case",
"lesson", "mini-lesson", "class", "learning",
]
# Ключевые слова для лёгких запросов
EASY_KEYWORDS = [
# Русские
"переведи", "как сказать", "что значит", "привет", "спасибо", "пока",
# Украинские
"переклади", "як сказати", "що означає", "привіт", "дякую", "бувай",
# Польские
"przetłumacz", "jak powiedzieć", "co znaczy", "cześć", "dziękuję",
# Английские
"translate", "how to say", "what does", "hello", "thank you", "bye",
]
def get_model_for_message(message: str) -> str:
"""Определяет какая модель нужна: лёгкая или сложная"""
msg_lower = message.lower()
if any(kw in msg_lower for kw in HARD_KEYWORDS):
logger.info(f"Using HARD model for message: {message[:50]}...")
return HARD_MODEL
if len(message) > 150:
logger.info(f"Using HARD model (long message, {len(message)} chars)")
return HARD_MODEL
logger.info(f"Using EASY model for message: {message[:50]}...")
return EASY_MODEL
def clean_response(text: str) -> str:
"""Убирает markdown-символы из ответа"""
text = text.replace("**", "").replace("*", "")
text = text.replace("###", "").replace("##", "").replace("#", "")
text = text.replace("```", "").replace("`", "")
return text.strip()
async def save_message(user_id: int, message: str, is_user: bool):
"""Сохраняет сообщение в БД и удаляет старые (оставляет только 10 последних)"""
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute(
"""INSERT INTO chat_history (user_id, message, is_user) VALUES ($1, $2, $3)""",
user_id, message, is_user
)
await conn.execute("""
DELETE FROM chat_history
WHERE user_id = $1
AND id NOT IN (
SELECT id FROM chat_history
WHERE user_id = $1
ORDER BY id DESC
LIMIT $2
)
""", user_id, MAX_HISTORY)
async def get_history(user_id: int) -> list:
"""Получает историю чата (последние 10 сообщений)"""
pool = await get_pool()
async with pool.acquire() as conn:
rows = await conn.fetch("""
SELECT message, is_user FROM chat_history
WHERE user_id = $1
ORDER BY id ASC
""", user_id)
return [{"role": "user" if row["is_user"] else "assistant", "content": row["message"]} for row in rows]
async def get_daily_usage(user_id: int) -> int:
"""Получает количество сообщений за сегодня"""
pool = await get_pool()
async with pool.acquire() as conn:
count = await conn.fetchval("""
SELECT message_count FROM chat_usage
WHERE user_id = $1 AND usage_date = CURRENT_DATE
""", user_id)
return count or 0
async def increment_daily_usage(user_id: int):
"""Увеличивает счётчик сообщений за сегодня"""
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute("""
INSERT INTO chat_usage (user_id, usage_date, message_count)
VALUES ($1, CURRENT_DATE, 1)
ON CONFLICT (user_id, usage_date)
DO UPDATE SET message_count = chat_usage.message_count + 1
""", user_id)
@router.post("/chat")
async def chat(request: Request):
"""Принимает сообщение пользователя и возвращает ответ AI"""
telegram_id, _ = await require_auth(request)
if not TOGETHER_API_KEY:
raise HTTPException(500, "AI API key not configured")
body = await request.json()
user_message = body.get("message", "").strip()
if not user_message:
raise HTTPException(400, "Message is required")
if len(user_message) > 500:
raise HTTPException(400, "Message too long (max 500 characters)")
is_admin = telegram_id in ADMIN_IDS
if not is_admin:
daily_usage = await get_daily_usage(telegram_id)
if daily_usage >= FREE_DAILY_LIMIT:
return {
"limit_exceeded": True,
"daily_limit": FREE_DAILY_LIMIT,
"used": daily_usage,
"remaining": 0,
"response": "Dziś wykorzystałeś już wszystkie darmowe zapytania. Wróć jutro!",
}
await save_message(telegram_id, user_message, True)
history = await get_history(telegram_id)
model = get_model_for_message(user_message)
logger.info(f"Assistant chat: user={telegram_id}, model={model}, msg_len={len(user_message)}, history={len(history)}")
start_time = time.time()
try:
async with httpx.AsyncClient(timeout=45.0) as client:
response = await client.post(
TOGETHER_API_URL,
headers={
"Authorization": f"Bearer {TOGETHER_API_KEY}",
"Content-Type": "application/json",
},
json={
"model": model,
"messages": [
{"role": "system", "content": SYSTEM_PROMPT},
*history,
],
"max_tokens": 2500,
"temperature": 0.7,
},
)
elapsed_time = time.time() - start_time
logger.info(f"Assistant response: status={response.status_code}, time={elapsed_time:.2f}s")
if response.status_code != 200:
logger.error(f"AI API error: {response.status_code}, body={response.text[:200]}")
raise HTTPException(500, f"AI API error: {response.status_code}")
data = response.json()
ai_response = data["choices"][0]["message"]["content"].strip()
ai_response = clean_response(ai_response)
# 🔧 ФИКС (23.09.2026): assistant_quota_burned_on_ai_failure —
# раньше increment_daily_usage вызывался ДО запроса к AI.
# При таймауте/ошибке юзер терял попытку. Теперь — только после успеха.
if not is_admin:
await increment_daily_usage(telegram_id)
await save_message(telegram_id, ai_response, False)
remaining = FREE_DAILY_LIMIT if is_admin else max(0, FREE_DAILY_LIMIT - await get_daily_usage(telegram_id))
logger.info(f"Assistant answer: len={len(ai_response)}, model={model}")
return {
"response": ai_response,
"model_used": model,
"limit_exceeded": False,
"daily_limit": FREE_DAILY_LIMIT if not is_admin else None,
"remaining": remaining if not is_admin else None,
}
except HTTPException:
raise
except httpx.TimeoutException:
logger.error(f"AI API timeout after {time.time() - start_time:.2f}s")
# 🔧 ФИКС (23.09.2026): попытка НЕ списана — increment только после успеха
raise HTTPException(500, "AI service timeout")
except Exception as e:
logger.error(f"AI service error: {str(e)}")
# 🔧 ФИКС (23.09.2026): попытка НЕ списана — increment только после успеха
raise HTTPException(500, f"AI service error: {str(e)}")
@router.post("/save-analytics")
async def save_analytics(request: Request):
"""Сохраняет ответ аналитики в историю чата"""
telegram_id, _ = await require_auth(request)
body = await request.json()
message = body.get("message", "").strip()
if not message:
raise HTTPException(400, "Message is required")
await save_message(telegram_id, message, False)
return {"status": "ok"}
@router.get("/stats/personal")
async def get_personal_stats(request: Request):
"""Возвращает личную статистику пользователя для AI"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow("SELECT current_level, app_language FROM users WHERE telegram_id = $1", telegram_id)
if not user:
raise HTTPException(401, "User not registered")
current_level = user["current_level"] or "A1"
# 🔧 ФИКС (24.09.2026): assistant_personal_stats_n_plus_1 —
# раньше 6 уровней × 6 запросов = 36 round-trip. Теперь 6 GROUP BY + сборка.
total_achievements = await conn.fetchval("""
SELECT COUNT(*) FROM user_achievements WHERE user_id = $1
""", telegram_id) or 0
# Тоталы по уровням (для расчёта процентов) — 4 запроса
ws_totals_rows = await conn.fetch("""
SELECT level, COUNT(*) as cnt FROM levels
WHERE level = ANY($1::text[])
GROUP BY level
""", LEVELS)
ws_totals = {r["level"]: r["cnt"] for r in ws_totals_rows}
s_totals_rows = await conn.fetch("""
SELECT level, COUNT(*) as cnt FROM sentences
WHERE level = ANY($1::text[])
GROUP BY level
""", LEVELS)
s_totals = {r["level"]: r["cnt"] for r in s_totals_rows}
# Прогресс пользователя по уровням — 6 запросов (вместо 24)
ws_progress_rows = await conn.fetch("""
SELECT level,
COUNT(DISTINCT level_id) as completed,
COALESCE(SUM(score), 0) as total_score
FROM user_progress
WHERE user_id = $1 AND completed_at IS NOT NULL
AND level = ANY($2::text[])
GROUP BY level
""", telegram_id, LEVELS)
ws_progress = {r["level"]: r for r in ws_progress_rows}
s_progress_rows = await conn.fetch("""
SELECT level,
COUNT(*) as completed,
COALESCE(SUM(score), 0) as total_score
FROM sentence_progress
WHERE user_id = $1 AND completed_at IS NOT NULL
AND level = ANY($2::text[])
GROUP BY level
""", telegram_id, LEVELS)
s_progress = {r["level"]: r for r in s_progress_rows}
wq_progress_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) as total_score
FROM word_quiz_progress
WHERE user_id = $1 AND level = ANY($2::text[])
""", telegram_id, LEVELS)
wq_progress = {r["level"]: r["total_score"] for r in wq_progress_rows}
bw_progress_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) as total_score
FROM bubble_words_progress
WHERE user_id = $1 AND level = ANY($2::text[])
""", telegram_id, LEVELS)
bw_progress = {r["level"]: r["total_score"] for r in bw_progress_rows}
# Собираем level_progress из загруженных данных
level_progress = {}
total_score = 0
for level in LEVELS:
ws_total = ws_totals.get(level, 0)
ws_row = ws_progress.get(level)
ws_completed = ws_row["completed"] if ws_row else 0
ws_percent = round((ws_completed / ws_total * 100), 1) if ws_total > 0 else 0
s_total = s_totals.get(level, 0)
s_row = s_progress.get(level)
s_completed = s_row["completed"] if s_row else 0
s_percent = round((s_completed / s_total * 100), 1) if s_total > 0 else 0
ws_score = ws_row["total_score"] if ws_row else 0
s_score = s_row["total_score"] if s_row else 0
wq_score = wq_progress.get(level, 0)
bw_score = bw_progress.get(level, 0)
level_total = ws_score + s_score + wq_score + bw_score
total_score += level_total
level_progress[level] = {
"wordsearch_percent": ws_percent,
"wordsearch_completed": ws_completed,
"wordsearch_total": ws_total,
"sentence_percent": s_percent,
"sentence_completed": s_completed,
"sentence_total": s_total,
"total_score": level_total,
}
# Квиз и пузыри общие
wq_words = await conn.fetchval(
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bw_levels = await conn.fetchval(
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
# Уроки
completed_topics = await conn.fetchval(
"SELECT COUNT(*) FROM user_topic_progress WHERE user_id = $1 AND test_completed = TRUE",
telegram_id
) or 0
return {
"current_level": current_level,
"total_score": total_score,
"achievements": total_achievements,
"words_guessed": wq_words,
"bubble_levels": bw_levels,
"completed_topics": completed_topics,
"level_progress": level_progress,
}
@router.get("/stats/admin")
async def get_admin_stats(request: Request):
"""Возвращает админ-статистику"""
telegram_id, _ = await require_auth(request)
if telegram_id not in ADMIN_IDS:
raise HTTPException(403, "Access denied")
pool = await get_pool()
async with pool.acquire() as conn:
total_users = await conn.fetchval("SELECT COUNT(*) FROM users") or 0
new_today = await conn.fetchval("SELECT COUNT(*) FROM users WHERE created_at::date = CURRENT_DATE") or 0
online_now = await conn.fetchval("""
SELECT COUNT(DISTINCT user_id) FROM (
SELECT user_id FROM user_progress WHERE completed_at > NOW() - INTERVAL '30 minutes'
UNION
SELECT user_id FROM sentence_progress WHERE completed_at > NOW() - INTERVAL '30 minutes'
UNION
SELECT user_id FROM daily_logins WHERE login_date = CURRENT_DATE
) active
""") or 0
# Языки
language_counts = {}
for lang in ["pl", "ru", "uk", "en"]:
count = await conn.fetchval("SELECT COUNT(*) FROM users WHERE app_language = $1", lang) or 0
language_counts[lang] = count
# Уровни
level_counts = {}
for level in LEVELS:
count = await conn.fetchval("SELECT COUNT(*) FROM users WHERE current_level = $1", level) or 0
level_counts[level] = count
return {
"total_users": total_users,
"new_today": new_today,
"online_now": online_now,
"language_counts": language_counts,
"level_counts": level_counts,
}
@router.get("/limit")
async def get_limit(request: Request):
"""Возвращает информацию о лимите пользователя"""
telegram_id, _ = await require_auth(request)
is_admin = telegram_id in ADMIN_IDS
if is_admin:
return {
"is_admin": True,
"daily_limit": None,
"used": 0,
"remaining": None,
}
daily_usage = await get_daily_usage(telegram_id)
remaining = max(0, FREE_DAILY_LIMIT - daily_usage)
return {
"is_admin": False,
"daily_limit": FREE_DAILY_LIMIT,
"used": daily_usage,
"remaining": remaining,
}
@router.get("/history")
async def get_chat_history(request: Request):
"""Возвращает историю чата пользователя"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
rows = await conn.fetch("""
SELECT message, is_user, created_at FROM chat_history
WHERE user_id = $1
ORDER BY id ASC
""", telegram_id)
history = []
for row in rows:
history.append({
"message": row["message"],
"is_user": row["is_user"],
"created_at": row["created_at"].isoformat() if row["created_at"] else None,
})
return {"history": history}
@router.post("/history/clear")
async def clear_chat_history(request: Request):
"""Очищает историю чата пользователя"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
await conn.execute("DELETE FROM chat_history WHERE user_id = $1", telegram_id)
return {"status": "ok"}