AI в e-commerce: рекомендации, чат-боты и динамическое ценообразование

import numpy as np
from dataclasses import dataclass
from collections import defaultdict


@dataclass
class Interaction:
    """Взаимодействие пользователя с товаром."""
    user_id: str
    item_id: str
    event_type: str   # view, add_to_cart, purchase
    timestamp: float
    rating: float | None = None


# Веса для разных типов событий
EVENT_WEIGHTS = {
    "view": 1.0,
    "add_to_cart": 3.0,
    "purchase": 5.0,
    "review_positive": 4.0,
    "review_negative": -2.0,
}


def build_user_item_matrix(
    interactions: list[Interaction],
    decay_days: float = 30.0,
) -> tuple[np.ndarray, list[str], list[str]]:
    """
    Построить матрицу user × item с implicit feedback.

    Используем взвешенную сумму событий с temporal decay:
    более свежие взаимодействия весят больше.
    """
    users = sorted({i.user_id for i in interactions})
    items = sorted({i.item_id for i in interactions})
    user_idx = {u: i for i, u in enumerate(users)}
    item_idx = {it: i for i, it in enumerate(items)}

    matrix = np.zeros((len(users), len(items)))
    now = max(i.timestamp for i in interactions)

    for inter in interactions:
        weight = EVENT_WEIGHTS.get(inter.event_type, 1.0)
        # Temporal decay: экспоненциально уменьшаем вес старых событий
        age_days = (now - inter.timestamp) / 86400
        decay = np.exp(-age_days / decay_days)
        matrix[user_idx[inter.user_id], item_idx[inter.item_id]] += weight * decay

    return matrix, users, items


def cosine_similarity_matrix(matrix: np.ndarray) -> np.ndarray:
    """Матрица косинусного сходства между пользователями."""
    norms = np.linalg.norm(matrix, axis=1, keepdims=True)
    norms = np.where(norms == 0, 1, norms)  # избегаем деления на ноль
    normalized = matrix / norms
    return normalized @ normalized.T


def recommend(
    user_id: str,
    matrix: np.ndarray,
    users: list[str],
    items: list[str],
    top_k: int = 10,
    min_similarity: float = 0.1,
) -> list[dict]:
    """
    Рекомендации для пользователя через user-based CF.

    Алгоритм:
    1. Найти top-N похожих пользователей (по косинусному сходству)
    2. Взять их товары, взвешенные по сходству
    3. Исключить уже купленные товары
    4. Вернуть top-K
    """
    user_idx_map = {u: i for i, u in enumerate(users)}
    if user_id not in user_idx_map:
        return []  # cold start — fallback на популярные

    uid = user_idx_map[user_id]
    sim_matrix = cosine_similarity_matrix(matrix)
    similarities = sim_matrix[uid]

    # Исключаем самого себя
    similarities[uid] = 0

    # Товары, с которыми пользователь уже взаимодействовал
    already_interacted = set(np.where(matrix[uid] > 0)[0])

    # Взвешенная сумма оценок похожих пользователей
    scores = defaultdict(float)
    for other_uid in range(len(users)):
        sim = similarities[other_uid]
        if sim < min_similarity:
            continue
        for item_idx_val in range(len(items)):
            if item_idx_val not in already_interacted and matrix[other_uid, item_idx_val] > 0:
                scores[item_idx_val] += sim * matrix[other_uid, item_idx_val]

    # Сортируем и возвращаем top-K
    ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:top_k]

    return [
        {"item_id": items[idx], "score": round(score, 4)}
        for idx, score in ranked
    ]

import anthropic
from typing import Optional


# Системный промпт для e-commerce чатбота
ECOMMERCE_BOT_PROMPT = """Ты AI-консультант интернет-магазина.

Правила:
- Помогай с выбором товаров, отвечай на вопросы о характеристиках
- Рекомендуй конкретные товары из каталога (используй контекст ниже)
- Всегда указывай цены и наличие из предоставленных данных
- Если товара нет в контексте — честно скажи, что нужно уточнить
- Предлагай дополнительные товары (cross-sell), но не навязчиво
- Если пользователь жалуется — выражай сочувствие и предлагай решение
- Отвечай кратко (2-4 предложения), если не просят подробнее

ВАЖНО: Не выдумывай товары. Рекомендуй только то, что есть в контексте.
"""


def search_catalog(
    query: str,
    catalog_embeddings: dict,
    top_k: int = 5,
) -> list[dict]:
    """
    Поиск релевантных товаров в каталоге через vector search.
    В продакшене: Qdrant, Pinecone или pgvector.
    """
    # Упрощённый пример — в реальности здесь embedding search
    # catalog_embeddings = {item_id: {"embedding": [...], "metadata": {...}}}
    results = []
    query_lower = query.lower()
    for item_id, data in catalog_embeddings.items():
        meta = data["metadata"]
        text = f"{meta['name']} {meta.get('description', '')} {meta.get('category', '')}".lower()
        if any(word in text for word in query_lower.split()):
            results.append(meta)
    return results[:top_k]


def format_catalog_context(products: list[dict]) -> str:
    """Форматирует найденные товары для контекста LLM."""
    if not products:
        return "Товары по запросу не найдены в каталоге."

    lines = ["Найденные товары:"]
    for p in products:
        line = f"- {p['name']} | Цена: {p.get('price', 'N/A')} ₽"
        if p.get("in_stock"):
            line += " | В наличии"
        else:
            line += " | Нет в наличии"
        if p.get("rating"):
            line += f" | Рейтинг: {p['rating']}/5"
        if p.get("sizes"):
            line += f" | Размеры: {', '.join(p['sizes'])}"
        lines.append(line)

    return "\n".join(lines)


def chat_with_customer(
    message: str,
    conversation_history: list[dict],
    catalog_embeddings: dict,
    user_profile: Optional[dict] = None,
) -> dict:
    """
    Обработка сообщения покупателя с RAG по каталогу.

    Args:
        message: сообщение пользователя
        conversation_history: история диалога
        catalog_embeddings: индекс каталога для поиска
        user_profile: профиль пользователя (история, предпочтения)
    """
    # 1. Ищем релевантные товары в каталоге
    products = search_catalog(message, catalog_embeddings)
    catalog_context = format_catalog_context(products)

    # 2. Формируем контекст с профилем пользователя
    system = ECOMMERCE_BOT_PROMPT
    if user_profile:
        system += f"\n\nПрофиль покупателя:\n"
        system += f"- Предпочитаемые бренды: {', '.join(user_profile.get('brands', []))}\n"
        system += f"- Ценовой сегмент: {user_profile.get('price_segment', 'средний')}\n"
        system += f"- Размер одежды: {user_profile.get('size', 'не указан')}\n"

    system += f"\n\nКонтекст каталога:\n{catalog_context}"

    # 3. Запрос к LLM
    client = anthropic.Anthropic()
    messages = conversation_history + [{"role": "user", "content": message}]

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=500,
        system=system,
        messages=messages,
    )

    assistant_message = response.content[0].text

    return {
        "response": assistant_message,
        "products_shown": [p.get("id") for p in products],
        "tokens_used": response.usage.input_tokens + response.usage.output_tokens,
    }

from dataclasses import dataclass
from datetime import datetime
import numpy as np


@dataclass
class PricingContext:
    """Контекст для принятия решения о цене."""
    item_id: str
    base_cost: float          # себестоимость
    current_price: float      # текущая цена
    competitor_prices: list[float]  # цены конкурентов
    stock_level: int          # запас на складе
    stock_days_remaining: float  # дней до полного стока при текущем темпе
    daily_sales_avg: float    # средние продажи в день (30 дней)
    daily_sales_recent: float # средние продажи за 3 дня
    demand_trend: float       # тренд спроса: >1 растёт, <1 падает
    category_elasticity: float  # ценовая эластичность категории (обычно -1.5...-0.5)
    is_seasonal: bool         # сезонный товар
    days_since_launch: int    # дней с момента появления в каталоге


@dataclass
class PricingDecision:
    """Результат работы алгоритма ценообразования."""
    recommended_price: float
    min_price: float     # нижняя граница (>= cost + min margin)
    max_price: float     # верхняя граница
    confidence: float    # уверенность в рекомендации (0-1)
    reasoning: str       # объяснение решения


def calculate_dynamic_price(ctx: PricingContext) -> PricingDecision:
    """
    Алгоритм динамического ценообразования.

    Стратегия:
    - Если спрос высокий и запасы низкие → повышаем цену
    - Если спрос низкий и запасы высокие → снижаем цену
    - Учитываем цены конкурентов как ограничение
    - Никогда не опускаемся ниже себестоимости + мин. маржа
    """
    MIN_MARGIN = 0.10  # минимальная маржа 10%
    MAX_MARKUP = 3.0   # максимальная наценка 3x от себестоимости

    min_price = ctx.base_cost * (1 + MIN_MARGIN)
    max_price = ctx.base_cost * MAX_MARKUP

    # Конкурентное ограничение: не дороже медианы конкурентов + 15%
    if ctx.competitor_prices:
        competitor_median = np.median(ctx.competitor_prices)
        max_price = min(max_price, competitor_median * 1.15)
        # Не дешевле минимального конкурента - 5% (если это выше себестоимости)
        competitive_floor = min(ctx.competitor_prices) * 0.95
        if competitive_floor > min_price:
            min_price = competitive_floor

    reasons = []
    price = ctx.current_price

    # Фактор спроса
    demand_factor = ctx.daily_sales_recent / (ctx.daily_sales_avg + 1e-9)
    if demand_factor > 1.3:
        # Спрос выше среднего — можно повысить цену
        increase = min(0.10, (demand_factor - 1) * 0.15)
        price *= (1 + increase)
        reasons.append(f"Спрос выше среднего на {(demand_factor-1)*100:.0f}% → +{increase*100:.1f}%")
    elif demand_factor < 0.7:
        # Спрос ниже среднего — снижаем
        decrease = min(0.15, (1 - demand_factor) * 0.20)
        price *= (1 - decrease)
        reasons.append(f"Спрос ниже среднего на {(1-demand_factor)*100:.0f}% → -{decrease*100:.1f}%")

    # Фактор запасов
    if ctx.stock_days_remaining < 7:
        # Мало запасов — повышаем
        price *= 1.05
        reasons.append("Низкий запас (<7 дней) → +5%")
    elif ctx.stock_days_remaining > 90:
        # Overstock — снижаем для ликвидации
        price *= 0.90
        reasons.append("Overstock (>90 дней запаса) → -10%")

    # Фактор сезонности
    if ctx.is_seasonal and ctx.stock_days_remaining > 60:
        price *= 0.85
        reasons.append("Сезонный товар + высокий запас → -15% ликвидация")

    # Ограничения
    price = np.clip(price, min_price, max_price)

    # Уверенность в решении
    confidence = 0.7
    if len(ctx.competitor_prices) > 3:
        confidence += 0.1  # больше данных о рынке
    if ctx.daily_sales_avg > 5:
        confidence += 0.1  # стабильная статистика продаж
    if abs(price - ctx.current_price) / ctx.current_price < 0.05:
        confidence += 0.1  # малое изменение — выше уверенность

    return PricingDecision(
        recommended_price=round(price, 2),
        min_price=round(min_price, 2),
        max_price=round(max_price, 2),
        confidence=min(confidence, 1.0),
        reasoning="; ".join(reasons) if reasons else "Цена в оптимальном диапазоне, корректировка не требуется",
    )