Разработка AI-системы автоматической генерации описаний товаров

Разработка системы AI-генерации описаний товаров

Автоматическая генерация описаний товаров для e-commerce: маркетплейсы (Wildberries, Ozon, Amazon), интернет-магазины, B2B-каталоги. Производительность: 1000–10000 описаний в день против 50–200 у копирайтера.

Архитектура системы

from openai import AsyncOpenAI
from dataclasses import dataclass
from typing import Optional
import asyncio

client = AsyncOpenAI()

@dataclass
class ProductData:
    name: str
    category: str
    brand: str
    sku: str
    attributes: dict          # {color: "red", size: "M", material: "cotton"}
    images: list[str] = None  # URL изображений
    price: float = None
    target_audience: str = ""

@dataclass
class GeneratedDescription:
    title: str              # SEO заголовок
    short_description: str  # 150–200 символов (превью на маркетплейсе)
    full_description: str   # HTML с форматированием
    bullet_points: list[str]  # 3–7 ключевых преимуществ
    seo_keywords: list[str]
    meta_description: str   # 160 символов для SEO

class ProductDescriptionGenerator:
    def __init__(self, platform: str = "general"):
        self.platform = platform
        self.platform_configs = {
            "wildberries": {"max_title": 60, "max_desc": 4000, "bullet_count": 5},
            "ozon": {"max_title": 100, "max_desc": 6000, "bullet_count": 7},
            "amazon": {"max_title": 200, "max_desc": 2000, "bullet_count": 5},
            "general": {"max_title": 80, "max_desc": 3000, "bullet_count": 5},
        }

    async def generate(
        self,
        product: ProductData,
        tone: str = "professional",
        language: str = "ru"
    ) -> GeneratedDescription:
        config = self.platform_configs.get(self.platform, self.platform_configs["general"])

        # Если есть изображения — используем GPT-4 Vision
        if product.images:
            return await self.generate_from_images(product, config, tone, language)
        else:
            return await self.generate_from_text(product, config, tone, language)

    async def generate_from_text(
        self,
        product: ProductData,
        config: dict,
        tone: str,
        language: str
    ) -> GeneratedDescription:
        attributes_str = "\n".join([f"- {k}: {v}" for k, v in product.attributes.items()])

        response = await client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": f"""Ты — эксперт по написанию продающих описаний для {self.platform}.
                Тон: {tone}.
                Язык: {language}.
                Ограничения: заголовок до {config['max_title']} символов,
                описание до {config['max_desc']} символов,
                {config['bullet_count']} буллетов преимуществ.

                Создай описание товара. Верни JSON с полями:
                title, short_description, full_description (HTML),
                bullet_points (массив), seo_keywords (массив), meta_description."""
            }, {
                "role": "user",
                "content": f"""Товар: {product.name}
                Бренд: {product.brand}
                Категория: {product.category}
                Характеристики:
                {attributes_str}
                ЦА: {product.target_audience or 'не указана'}"""
            }],
            response_format={"type": "json_object"}
        )

        data = json.loads(response.choices[0].message.content)
        return GeneratedDescription(**data)

    async def generate_from_images(
        self,
        product: ProductData,
        config: dict,
        tone: str,
        language: str
    ) -> GeneratedDescription:
        """Используем Vision для анализа фото товара"""
        import base64

        image_contents = [
            {"type": "image_url", "image_url": {"url": url}}
            for url in product.images[:3]  # Максимум 3 изображения
        ]

        response = await client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": f"""Проанализируй изображения товара и создай описание.
                    Платформа: {self.platform}. Тон: {tone}. Язык: {language}.
                    Дополнительные данные: Категория: {product.category}, Бренд: {product.brand}.
                    Верни JSON: title, short_description, full_description, bullet_points, seo_keywords, meta_description."""},
                ] + image_contents
            }],
            response_format={"type": "json_object"}
        )

        data = json.loads(response.choices[0].message.content)
        return GeneratedDescription(**data)

Batch-генерация из Excel/CSV

import pandas as pd
import asyncio

async def process_product_catalog(
    catalog_path: str,
    platform: str = "wildberries",
    batch_size: int = 20
) -> pd.DataFrame:
    df = pd.read_csv(catalog_path)
    generator = ProductDescriptionGenerator(platform=platform)
    results = []

    for i in range(0, len(df), batch_size):
        batch = df.iloc[i:i+batch_size]
        tasks = []

        for _, row in batch.iterrows():
            product = ProductData(
                name=row["name"],
                category=row["category"],
                brand=row.get("brand", ""),
                sku=row.get("sku", ""),
                attributes={k: row[k] for k in row.index if k not in ["name", "category", "brand", "sku"]}
            )
            tasks.append(generator.generate(product))

        batch_results = await asyncio.gather(*tasks, return_exceptions=True)
        for j, result in enumerate(batch_results):
            if isinstance(result, GeneratedDescription):
                row_data = batch.iloc[j].to_dict()
                row_data.update({
                    "generated_title": result.title,
                    "generated_short_desc": result.short_description,
                    "generated_full_desc": result.full_description,
                    "generated_bullets": " | ".join(result.bullet_points),
                    "seo_keywords": ", ".join(result.seo_keywords),
                })
                results.append(row_data)

    return pd.DataFrame(results)

Адаптация под площадки

class WildberriesFormatter:
    def format(self, desc: GeneratedDescription) -> dict:
        return {
            "наименование": desc.title[:60],
            "описание": desc.full_description[:4000],
            "характеристики": "\n".join(desc.bullet_points),
        }

class OzonFormatter:
    def format(self, desc: GeneratedDescription) -> dict:
        return {
            "name": desc.title[:100],
            "description": desc.full_description,
            "short_description": desc.short_description,
            "keywords": desc.seo_keywords,
        }

Сроки: базовый генератор описаний с batch-обработкой CSV — 1–2 недели. Интеграция с API Wildberries/Ozon для прямой загрузки — дополнительно 1–2 недели.