AI Agents for E-Commerce — 6 critical jobs, end-to-end

You are a developer building an 'AI product content factory' for an e-commerce business.

Goal: /src/ecommerce/productContent/ folder.

Components:
1. /src/ecommerce/productContent/types.ts — Zod schemas:
   - ProductAttributes (name, brand, category, attributes Record, price, currency)
   - GeneratedContent (title, metaDescription, shortDesc, longDesc, bullets[],
     crossSellCopy, altText, social: { instagram, tiktok }, translations: Record<lang, ...>)

2. /src/ecommerce/productContent/generator.ts — generateContent(attrs, languages)
   - Call Anthropic Claude Sonnet, system prompt with brand voice (from brandVoice.md).
   - Structured output matching GeneratedContent.
   - languages param: ['en', 'es', 'de'] etc.

3. /src/ecommerce/productContent/shopify.ts
   - listenWebhook(): handle Shopify 'products/create' and 'products/update'
   - fetchProductAttrs(productId)
   - updateProductContent(productId, content) — write back via Storefront API
   - HMAC signature verification (Shopify-Hmac-Sha256)

4. /src/ecommerce/productContent/reviewQueue.ts
   - Postgres 'content_review_queue': id, product_id, generated_content,
     status ('pending'|'approved'|'rejected'), created_at, reviewer
   - Web UI (/admin/content-review): pending list + side-by-side comparison
     (current vs generated) + Approve/Edit/Reject buttons
   - On approve → PATCH Shopify

Category-based templates at /src/ecommerce/productContent/templates/
  - cosmetics.md, electronics.md, apparel.md
  - tonal rules + must-have keywords per category

5. Cost controls:
   - Generate at most once per product (idempotency: product_id + content_hash)
   - Daily budget cap (env var). On exceed mark queue items 'budget_exceeded.'

Plan first.

You are a developer building a multi-channel support bot for an e-commerce business.

Goal: /src/ecommerce/support/ folder.

Components:
1. /src/ecommerce/support/agent.ts
   - customerSupportAgent({ message, channel, userId, attachments })
   - System prompt = brandVoice.md + supportRules.md
   - Memory: Postgres session_id = channel:external_id ('whatsapp:90...').
   - Vector retrieve: top_k=5 from product_kb (specs) + policy_kb (return rules)

2. /src/ecommerce/support/tools/
   - getOrderStatus.ts — Shopify GraphQL: order status + tracking number
   - startReturn.ts — Shopify Returns API based on policy
   - searchKnowledge.ts — pgvector hybrid search
   - escalateToHuman.ts — post to Slack 'support-escalations'

3. /src/ecommerce/support/channels/
   - whatsapp.ts — Meta Cloud API, 24-hour window, template message support
   - instagram.ts — Meta Graph API IG Messenger
   - webWidget.ts — Express endpoint + JS widget script
   - all: HMAC verify + rate limit (IP + session)

4. /src/ecommerce/support/ingestion.ts
   - Nightly cron: index Shopify product feed into pgvector
   - Markdown files in /policy: chunk + embed return/shipping policies

5. /src/ecommerce/support/monitoring.ts
   - Per interaction: { session_id, channel, intent, tool_called, resolved, escalated, latency_ms, tokens }
   - Postgres 'support_events'
   - Weekly Slack report: resolution rate, avg latency, top intents, escalation reasons

Plan first.

You are a developer building a 'visual generation agent' for an e-commerce brand.

Goal: /src/ecommerce/visuals/ folder.

Components:
1. /src/ecommerce/visuals/promptBuilder.ts
   - Input: { productAttrs, sceneType, format, brandStyle }
   - Templates/scenes: 'studio', 'lifestyle-home', 'outdoor', 'flat-lay'
   - Format presets: instagram-square, instagram-portrait, story-vertical, banner-horizontal
   - Output: provider-specific prompt (Midjourney args + Flux negative prompts)

2. /src/ecommerce/visuals/providers/
   - midjourney.ts — via Discord bot
   - flux.ts — Replicate or Together AI API
   - dalle.ts — OpenAI Images API
   - runway.ts — video variants
   - All implement generate(prompt, n_variants)

3. /src/ecommerce/visuals/pipeline.ts
   - generateBatch(product, sceneTypes[], formats[]) — parallel for all combos
   - Cost controls: daily budget cap (env var)
   - Output: Google Drive 'visuals/<sku>/<date>/'
   - Per visual metadata: prompt, model, seed (if any), generated_at

4. /src/ecommerce/visuals/approval.ts
   - Slack Block Kit: 4 visuals side-by-side + Approve/Reject/Regenerate buttons
   - Approve → 'approved/' subfolder + auto-attach to Shopify OR upload to Meta Ads Library
   - Regenerate → new seed retry

5. /src/ecommerce/visuals/abTest.ts
   - For a campaign: generate 5 variants, push all 5 as ad sets via Meta Ads API
   - After 48h pull CTR/CPM/CPA, flag the winner

Plan first.

You are a developer building a 'cart recovery agent system' for an e-commerce brand.

Goal: /src/ecommerce/recovery/ folder.

Components:
1. /src/ecommerce/recovery/sessionTracker.ts
   - Listen to Shopify 'checkouts/create' and 'checkouts/update' webhooks
   - On 'checkout_completed' mark session 'recovered'
   - If not completed within 1h mark 'abandoned' and trigger recovery pipeline

2. /src/ecommerce/recovery/customerEnrichment.ts
   - Pull customer profile (Shopify customer + previous_orders + tier)
   - Pull product attributes for items in cart
   - Build context: { customer, cart, brand_voice, coupon_authority }

3. /src/ecommerce/recovery/copywriter.ts
   - Claude Sonnet, structured output: 3 emails + 1 WhatsApp + 1 IG DM
   - Each: subject, preview_text, html, plain_text, suggested_send_time
   - Brand voice (brandVoice.md) + customer tier + cart amount (coupon thresholds)

4. /src/ecommerce/recovery/scheduler.ts
   - 1h: email 1 + IG DM (if user follows brand)
   - 24h: email 2 + WhatsApp template
   - 72h: email 3 + 10% coupon (if tier allows)
   - At each stage check 'recovered?' — cancel the rest if so

5. /src/ecommerce/recovery/retargeting.ts
   - 4h: push the customer audience to Meta Ads Custom Audience
   - Build a dynamic ad using cart-product visuals (from the Visuals module)
   - Remove from audience after 7 days (privacy)

6. /src/ecommerce/recovery/analytics.ts
   - For each recovery: opens, clicks, recovered (true/false), revenue
   - Weekly report: ROI per campaign, best template, best send time

Plan first.

You are a developer building a 'competitor price monitor + dynamic-pricing recommender' for an e-commerce brand.

Goal: /src/ecommerce/pricing/ folder.

Components:
1. /src/ecommerce/pricing/competitors.config.ts
   - List: { name, domain, sitemap_url, scraping_strategy: 'shopify-json'|'html'|'apify-actor' }
   - Meta for 50 competitors

2. /src/ecommerce/pricing/scraper.ts
   - 4× daily schedule: fetch product URLs from sitemap
   - Strategy: Shopify JSON endpoint, HTML parsing, or Apify actor
   - Output: { competitor, sku_seen, url, title, price, currency, in_stock, scraped_at }

3. /src/ecommerce/pricing/skuMatcher.ts
   - Match our SKU ↔ competitor SKU
   - Strategy 1: Barcode/MPN (exact)
   - Strategy 2: Title embedding + price band + brand match
   - Confidence (0-1); < 0.7 → manual review queue

4. /src/ecommerce/pricing/storage.ts
   - Postgres + TimescaleDB hypertable 'price_history'
   - Aggregations: avg/min/max per day/week, % change

5. /src/ecommerce/pricing/alerts.ts
   - Rule: our price 15%+ above max competitor → critical alert
   - Rule: competitor dropped 20%+ in 24h → info alert
   - Rule: we're out of stock + competitor in stock → opportunity alert
   - Slack #pricing Block Kit

6. /src/ecommerce/pricing/analyst.ts
   - Weekly schedule: feed last 7 days to Claude Sonnet
   - Structured output: top 10 SKUs with situation + recommendation + risk
   - PDF report: pdfkit, upload to Drive, link to Slack

IMPORTANT: NEVER auto-change price. Only recommend; human approves before Shopify API update.

Plan first.

You are a developer building a 'demand forecasting + inventory planning' engine for an e-commerce brand.

Goal: /src/ecommerce/inventory/ folder.

Components:
1. /scripts/forecast.py (Python)
   - Pull 24 months from Shopify orders (sku, day, qty)
   - For each active SKU run Facebook Prophet
   - Seasonality components: weekly, yearly, holidays (e-com specific: black-friday, mother's-day, valentines)
   - Output: /tmp/forecast.json: { sku, monthly: [{ month, yhat, yhat_lower, yhat_upper }] }

2. /src/ecommerce/inventory/forecast.ts (TypeScript)
   - Spawn the Python script via child_process
   - Send forecast.json with context to Claude Sonnet: { campaigns_next_12mo,
     supplier_lead_times, new_b2b_pipeline, holiday_calendar }
   - Structured output:
     {
       sku_recommendations: [{
         sku, monthly_forecast, order_calendar: [{ month, order_qty, place_order_by, reasoning }],
         supplier_alerts: string[], risks: string[]
       }],
       executive_summary, top_actions: string[5]
     }

3. /src/ecommerce/inventory/storage.ts
   - Postgres 'forecasts' table: weekly snapshots — for historical comparison
   - 'reorder_calendar' table: planned orders

4. /src/ecommerce/inventory/reordering.ts
   - On reorder time alert Slack #procurement + a Notion order card
   - Supplier capacity-warning draft (reuse the template from the Procurement page)
   - On approval connect to the Procurement module (see AI for Procurement page)

5. /src/ecommerce/inventory/cold-start.ts
   - New SKUs have no history
   - Strategy: find 5 most-similar SKUs (embedding + category), average their first-90-day sales → new SKU initial forecast

6. /src/ecommerce/inventory/dashboard.tsx (Next.js)
   - Per SKU: current stock, last 30d sales, 30d forecast, reorder point, days remaining
   - Colour: green ≥ 60 days, yellow 30-60, red < 30 (urgent)

Plan first.