Development of AI Product Description Generation System
Manual copywriting for a catalog of 10,000 products takes 3–4 months. An AI system reduces this to a week, generating up to 10,000 descriptions per day — 50–100 times faster than manual work. We use GPT-4o, asynchronous batch processing, and adapters for Wildberries, Ozon, Amazon. In one project for an online store with 15,000 SKUs, we reduced the copywriting budget by an order of magnitude and cut the time to launch on marketplaces from 3 months to 2 weeks.
Why Automation of Descriptions Is Critical for E-commerce
Manual writing does not scale: when the assortment grows from 1,000 to 10,000 SKUs, copywriting costs multiply, and timelines reach 3–4 months. An LLM-based system solves this: once the architecture is developed, you get an unlimited stream of SEO-optimized texts for any platform. LLMs guarantee a consistent style and eliminate typical errors — typos, duplication, mismatched attributes.
What Problems Does the AI Generator Solve?
High cost and long timelines. Manual writing has a high cost per description, and for a catalog of 10,000 products it takes months. Our system reduces cost by an order of magnitude: cost per description becomes negligible, and time drops to 2 seconds.
Inconsistent quality. Different copywriters write differently, harming brand perception. The LLM generator uses a single prompt and rules for each platform, ensuring uniformly high quality for all products.
Limited SEO optimization. Copywriters rarely consider all key queries and search engine requirements. The system automatically generates meta tags, titles, and descriptions optimized for the specific marketplace.
System Architecture
Core Generator Code (GPT-4o)
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)
How the System Processes Catalogs from CSV/Excel
For loading products from CSV, we use batch processing: process_product_catalog reads the file, splits it into batches of 20 products, and generates descriptions in parallel via asyncio. Errors are handled with return_exceptions — a failure on one product does not stop the entire flow.
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)
| Parameter | Manual Copywriting | AI System |
|---|---|---|
| Throughput | 50–200 descriptions/day | 1,000–10,000 descriptions/day |
| Cost per description (at 10,000 volume) | High | Significantly lower |
| Time for 10,000 SKU catalog | 3–4 months | 1–2 weeks |
| SEO optimization | Depends on copywriter | Built-in rules for each platform |
| Multilingual | Needs translator | Generation in any language |
Adaptation for Platforms
For each marketplace (Wildberries, Ozon, Amazon), we provide separate formatter classes. They handle character limits, structure requirements, and keywords. Example formatters:
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,
}
How Is SEO Optimization Ensured?
The system uses SEO rules for each platform: character limits, keywords, title structure. The prompt receives category, brand, and attributes, enabling relevant descriptions. Additionally, we apply few-shot and chain-of-thought techniques to improve quality. For Wildberries, the system automatically inserts popular queries into the title and meta description.
What Is Included in a Turnkey System Development?
- Architecture and code — core generator, support for text and images (GPT-4 Vision), batch CSV/Excel processing.
- Marketplace integration — adapters for Wildberries, Ozon, Amazon, direct API upload.
- Documentation — API description, instructions for adding new platforms, model card.
- Team training — 2 online sessions for configuration and operation.
- 2-week post-launch support — bug fixes, prompt fine-tuning.
Timeline and How We Work
| Stage | Duration |
|---|---|
| Analysis and design | 2–4 days |
| Generator development | 5–10 days |
| Marketplace API integration | 5–10 days |
| Testing and refinement | 3–5 days |
| Deployment and training | 2–3 days |
Cost is calculated individually after analyzing your catalog and integration requirements. Our team has specialized in AI solutions for e-commerce for over 5 years and has completed over 30 projects. We guarantee quality: each description undergoes validation against platform SEO rules.
Contact us to evaluate your project. Get a consultation on architecture and a preliminary timeline estimate.