What a Virtual Shopping Assistant actually does
Handles pre-purchase product discovery, sizing guidance, and shipping questions for Shopify shoppers through a branded conversational AI grounded in the live product catalog.
A white-label AI virtual shopping assistant is a catalog-grounded conversational AI deployed as a chat widget on a Shopify storefront. It answers 'does this run small?', 'what's the difference between the Pro and Standard models?', and 'will this arrive before Christmas?' without pulling the shopper into a support ticket. The core architecture is Retrieval-Augmented Generation (RAG): the product catalog is chunked and embedded with text-embedding-3-small ($0.02/M tokens), stored in pgvector on Supabase, and retrieved at query time to ground Claude Haiku 4.5's responses in actual inventory — not hallucinated product details. The AI handles the discovery, sizing, and FAQ layer; Shopify Checkout handles the cart.
This is distinct from post-purchase customer support (that's the ai-chatbot-for-e-commerce-support slug) and from visual AI styling (that's the ai-powered-virtual-stylist slug). This tool's job is pre-purchase conversion: reducing the 'I have a question I can't find the answer to' cart abandonment moment that kills DTC conversion rates. In 2026 the standalone chatbot-for-ecommerce market has consolidated around Tidio Lyro AI, Gorgias, and Zendesk — none of which offer a real white-label tier. A Lovable build on Supabase + Claude Haiku 4.5 + pgvector at $0.002 per 3-turn conversation is the only path to a fully rebrandable shopping assistant at $49–$99/mo per brand that a DTC agency can build a recurring-revenue product around.
AI capabilities involved
Catalog-grounded product recommendations via RAG
Conversational sizing and fit guidance
Inventory and shipping status queries
Cart-abandonment recovery via in-chat nudge
Who uses this
- DTC Shopify agencies serving 5–30 mid-market brands ($1M–$20M GMV) who want a branded conversational commerce add-on to resell at $49–$149/mo per brand
- Conversational commerce consultants who specialize in Shopify Plus and want a proprietary AI product rather than reselling Tidio or Gorgias
- Shopify Plus partners who want to differentiate their retainer offering with a proprietary AI chat widget on their clients' storefronts
- DTC brand operators who run their own multi-brand portfolio and want one consistent AI shopping assistant platform across all brands
SaaS alternatives on the market
Real products you can sign up for today — with current 2026 pricing, honest pros and cons.
Tidio Lyro AI
Individual brands who want a quick AI chat deployment and are fine with basic Tidio branding removal, without needing live inventory grounding
Free (50 conversations/mo, Tidio branding)
$749/mo (Tidio+, Lyro AI included)
Custom quote
Pros
- +Fastest time-to-deploy: plug in the Shopify app, train on FAQ content, and Lyro AI is answering questions within 30 minutes.
- +Highest G2 rating in the live-chat/AI chatbot category for small-to-midsize ecommerce.
- +Basic branding removal available on Tidio+ — removes 'Powered by Tidio' from the widget.
- +Handles both AI chat (Lyro) and human handoff in one platform — good for brands that still want human agents available.
Cons
- −Basic branding removal is not full white-label — Tidio brand is still visible in page metadata, email notifications, and Shopify app store listing.
- −$749/mo for Lyro AI is a steep monthly commitment per brand client — hard to resell at a meaningful markup.
- −Lyro AI is trained on your FAQ content but is not grounded in live inventory — it can't answer 'do you have this in size L in stock right now?'
- −No API for programmatic control — you cannot integrate Lyro AI into a multi-tenant management dashboard.
Intercom Fin
Enterprise brands with $50M+ GMV that have complex support workflows and can absorb unpredictable per-resolution costs
14-day trial
$0.99 per resolution (plus Intercom seat costs)
Custom quote
Pros
- +Best AI resolution rate in the enterprise support category — Fin resolves 50%+ of queries without human intervention on well-documented products.
- +Deep integration with Intercom's full customer data platform (conversation history, customer attributes, segments).
- +Supports complex multi-step workflows and escalation to human agents.
- +Strong pre-purchase and post-purchase hybrid capability.
Cons
- −No white-label at any tier — every customer sees 'Powered by Intercom' in the widget and receives emails from the Intercom domain.
- −Per-resolution pricing ($0.99) is dangerously unpredictable — a flash sale or PR moment that drives 20,000 AI-resolved queries costs $19,800 in one month.
- −Intercom's seat pricing ($39–$99/agent/mo) adds significant cost for brands with human agents alongside the AI.
- −Designed for post-purchase customer support, not pre-purchase product discovery — product catalog grounding requires custom integrations.
Gorgias Automate
Shopify brands that want a best-in-class post-purchase support automation platform and are fine with Gorgias branding throughout the customer experience
No
$360/mo (Pro with AI add-on)
Custom quote
Pros
- +Purpose-built for Shopify ecommerce — native order lookup, return initiation, and discount code issuance from within the chat.
- +Strong automation rules for common DTC flows (WISMO, cancel order, refund).
- +Good agency program with reseller margin on referred clients.
- +Integrates with Shopify, Klaviyo, Loop Returns, and other DTC stack staples.
Cons
- −No white-label — Gorgias branding is visible throughout; agency program is referral-based, not reseller.
- −AI Automate ($300+/mo addon) automates common ticket types but is not a pre-purchase shopping assistant — it's a post-purchase deflection tool.
- −Ticket-volume pricing means high GMV brands pay more, compressing agency margin.
- −Not designed for catalog-grounded pre-purchase conversations — product recommendation requires custom macro rules, not AI.
Octane AI
Shopify brands that want structured product-quiz funnels (not conversational AI) and integrate tightly with Klaviyo email flows
No
$50/mo (Starter, basic quiz)
$300+/mo (Plus, AI chat + quizzes)
Pros
- +Best-in-class product quiz functionality for Shopify — branded quizzes that route shoppers to the right product based on answers.
- +Native Shopify integration with product tag filtering.
- +Strong BFCM (Black Friday/Cyber Monday) quiz templates for seasonal campaigns.
- +Integrates with Klaviyo for quiz-response-based email segments.
Cons
- −No white-label — Octane AI branding present; no reseller tier.
- −Product quizzes and AI chat are distinct features — the $300+/mo Plus tier is required for both.
- −Quiz-based product recommendation is not conversational — it's a structured decision tree, not a natural-language dialogue.
- −AI chat feature is newer and less mature than the core quiz product.
The AI stack
The shopping assistant pipeline has three layers: a catalog embedding and retrieval layer (near-zero cost), a conversation generation layer (Claude Haiku 4.5 at $0.002 per 3-turn conversation), and an optional premium escalation layer (Claude Sonnet 4.6 for complex multi-turn queries). The catalog grounding layer is the engineering investment; the LLM cost is trivially cheap at scale.
Catalog embedding and retrieval (RAG foundation)
Converts the Shopify product catalog into searchable vector embeddings so the AI can retrieve accurate product information before answering any shopper question
text-embedding-3-small (OpenAI)
$0.02 per M tokensAll standard DTC catalogs with product descriptions, sizes, and materials in text form
Gemini 3.1 Flash-Lite
$0.25/$1.50 per M tokens in/outBrands with image-heavy catalogs where visual similarity matters for recommendations (fashion, home décor)
Our pick: text-embedding-3-small with pgvector on Supabase for all standard DTC catalogs. At $0.02/M tokens, a 10,000-SKU catalog with 200-word descriptions each = 2M tokens = $0.04 to embed the full catalog initially, with incremental updates on product webhook events at near-zero recurring cost.
Conversational response generation
Generates natural-language responses to shopper questions, grounded in the retrieved catalog chunks and brand-specific context
Claude Haiku 4.5
$1/$5 per M tokens in/outAll shopper-facing conversations where brand voice and accuracy matter
Claude Sonnet 4.6
$3/$15 per M tokens in/outEscalated conversations that combine product questions with order-management actions
GPT-5.4 mini
$0.75/$4.50 per M tokens in/outAgencies standardizing on OpenAI for all implementations who want a single API key
Our pick: Claude Haiku 4.5 as the default for all shopper conversations. Route conversations to Claude Sonnet 4.6 only when the conversation depth exceeds 6 turns or the query involves order-management actions. The cost difference at scale is $0.002 vs $0.006 per conversation — a rounding error versus the $49/mo per tenant revenue.
Out-of-scope detection and escalation routing
Detects when a shopper query exceeds the AI's scope (e.g., 'I want to file a complaint about a damaged delivery') and routes cleanly to a human agent or email fallback
GPT-5.4 nano
$0.20/$1.25 per M tokens in/outHigh-volume deployments where routing accuracy is less critical than cost
Claude Haiku 4.5 (inline detection)
$1/$5 per M tokens in/out (shared with main conversation call)Simple escalation logic where the same Haiku call handles both detection and response
Our pick: Embed escalation detection in the Claude Haiku 4.5 system prompt — a single API call handles both detection and response. Add a GPT-5.4 nano pre-filter only if you see >10% false escalation rate in production.
Reference architecture
The assistant is a Shopify-embedded chat widget backed by a RAG pipeline: product catalog is embedded nightly via a webhook-driven Supabase worker, shopper queries retrieve the top-5 relevant catalog chunks via pgvector cosine similarity, and Claude Haiku 4.5 generates grounded responses. The architecture is stateless per request (conversation history is stored client-side and passed in each API call) to keep Supabase Edge Function complexity low.
Shopify product catalog is indexed into pgvector
Supabase Edge Function (catalog-ingest) + Shopify Admin Webhook + text-embedding-3-smallOn brand onboarding, a full catalog sync fetches all products from the Shopify Admin API (products.json) and generates embeddings for each product's title + description + variant details. Stored in a tenant-isolated catalog_embeddings table in Supabase with pgvector. Shopify product/update webhooks trigger incremental re-embedding for changed products.
Shopper opens chat widget on brand storefront
Next.js chat widget (embedded via Shopify Theme App Extension or script tag)The chat widget loads with the tenant's brand colors, logo, and assistant name from the tenant configuration table. Conversation history is stored in localStorage for the session. No shopper login required — anonymous sessions identified by a UUID cookie.
Shopper submits a question
Supabase Edge Function (chat-respond)The Edge Function receives the shopper's message and recent conversation history. Generates an embedding of the shopper's query using text-embedding-3-small. Runs a pgvector cosine similarity search against the tenant's catalog_embeddings to retrieve the top 5 most relevant product chunks.
Claude Haiku 4.5 generates a grounded response
Supabase Edge Function (chat-respond) + Claude Haiku 4.5 APIThe retrieved product chunks are injected into the system prompt: 'You are [Brand Name]'s shopping assistant. Answer only using the product information below. If the answer is not in the product information, say so and offer to connect the shopper with the brand's team.' Claude Haiku 4.5 generates a response in ≤1 second. Cost: ~$0.002 per 3-turn conversation.
Cart-abandonment nudge is triggered
Next.js widget + Shopify Storefront APIIf the shopper has items in cart and the conversation goes idle for 3 minutes, the widget surfaces a soft nudge: 'Your cart is still waiting — anything I can help you with before you check out?' The nudge copy is generated by Claude Haiku 4.5 on a per-brand basis at widget configuration time (not per-session).
Out-of-scope query triggers escalation
Claude Haiku 4.5 (inline detection) + Resend or Zendesk webhookIf Claude detects the query requires order lookup, complaint handling, or return initiation (topics outside the pre-purchase scope), it responds with a handoff message ('I'll connect you with the [Brand] team for this — expect an email within 2 hours') and POSTs the conversation context to the brand's support email via Resend or a Zendesk ticket webhook.
Estimated cost per request
~$0.002 per 3-turn shopping conversation (Claude Haiku 4.5, ~600 input + 200 output tokens per turn); ~$0.00002 per catalog embedding lookup (pgvector)
Cost calculator
Drag the sliders to model your actual usage. The numbers update in real time so you can stress-test economics before writing a single line of code.
Model assumes one agency operating a white-label shopping assistant across multiple DTC brand tenants. The dominant variable cost is Claude Haiku 4.5 conversation generation — catalog embedding is a one-time cost that amortizes to near-zero.
Estimated monthly cost
$66.40
≈ $797 per year
Calculator notes
- At 20 tenants × 500 conversations/mo, Claude Haiku 4.5 cost = $20/mo. At $49/mo per tenant ($980/mo revenue), AI + infra costs ≈ $85/mo — 91% gross margin.
- Catalog embedding is a one-time cost per catalog update, not a per-conversation cost. A 5,000-SKU catalog with 150-word descriptions re-embedded monthly costs ~$0.015/brand/month — effectively free.
- The Shopify Storefront API (product and inventory queries) is free — no additional API cost for live inventory lookups.
- Calculator does not include the optional Zendesk or email escalation webhook costs — these are typically near-zero (Resend free tier: 3,000 emails/mo).
Build it yourself with vibe-coding tools
Build a working catalog-grounded shopping assistant chat widget in one weekend. By Sunday night you'll have a widget that can answer real product questions from a real Shopify catalog — demo-ready for your first brand client.
Time to MVP
12–16 hours (1 weekend)
Total cost to MVP
$25 Lovable Pro + ~$25 LLM/embedding credits + Shopify dev store (free)
You'll need
Starter prompt
Build a multi-tenant white-label AI shopping assistant platform called [YOUR BRAND NAME] using Next.js, Supabase, and Tailwind CSS. Core schema (Supabase, all tables RLS-isolated by tenant_id): - tenants(id, name, shopify_store_url, shopify_storefront_token, brand_color_primary, brand_color_secondary, assistant_name, logo_url, created_at) - catalog_chunks(id, tenant_id, product_id, product_title, variant_title, description_chunk TEXT, price, available BOOLEAN, embedding vector(1536)) - conversations(id, tenant_id, session_id UUID, messages JSONB, created_at, last_message_at) Enable pgvector on Supabase and create an index: CREATE INDEX ON catalog_chunks USING ivfflat (embedding vector_cosine_ops). Pages: 1. /operator — operator dashboard listing all brand tenants, their conversation counts (last 30 days), and catalog SKU counts. 'Add Brand' button. 2. /operator/brand/[id] — brand setup: name, Shopify store URL + storefront token, brand colors, assistant name, logo upload. 'Sync Catalog' button. Embed code snippet (a script tag for the brand's Shopify theme). 3. /widget/[tenant_id] — the embeddable chat widget (rendered in an iframe or as a standalone page for the script embed). Shows: brand logo + assistant name header, conversation thread, text input. On message submit, calls the chat-respond Edge Function. Edge Functions (supabase/functions/): - catalog-sync: receives {tenant_id}. Fetches products from Shopify Storefront API (products query with title, description, variants.price, variants.availableForSale). Chunks each product into 200-word segments. Generates text-embedding-3-small embeddings for each chunk. Upserts into catalog_chunks with tenant_id isolation. - chat-respond: receives {tenant_id, session_id, messages: [{role, content}]}. Embeds the latest user message with text-embedding-3-small. Queries catalog_chunks using pgvector cosine similarity (top 5 results). Calls Claude Haiku 4.5 with a system prompt: 'You are [tenant.assistant_name], the shopping assistant for [tenant.name]. Answer only using the product information provided. Be friendly and concise. If the question is outside your scope (orders, returns, complaints), offer to connect the shopper with the brand team.' Returns AI response. Saves conversation to conversations table. Widget embed: the operator dashboard shows a copyable script tag (<script src='https://yourplatform.com/widget/[tenant_id]'></script>) that brands paste into their Shopify theme's theme.liquid before </body>. The script renders the chat bubble in the bottom-right corner. Auth: Supabase Auth for operators only. Widget sessions are anonymous (UUID cookie, no login).
Paste this into Lovable
Follow-up prompts (run in order)
- 1
Add Shopify product webhook handling: in the operator dashboard, add a 'Register Webhooks' button that calls the Shopify Admin API to register product/create and product/update webhooks pointing to a new Edge Function (webhook-product-update). This function re-embeds the updated product's chunks and upserts into catalog_chunks. Show 'Catalog last synced: X ago' in the operator brand view.
- 2
Add live inventory awareness: modify the catalog-sync Edge Function to include variants.availableForSale and variants.quantityAvailable in each chunk. Update the chat-respond system prompt to include: 'If asked about availability, use the available field in the product data. If available=false, say the item is currently out of stock and offer to notify the shopper when it's back.' Add an 'Notify me' button in the widget that captures the shopper's email.
- 3
Add conversation analytics for operators: a /operator/brand/[id]/analytics page showing: total conversations (last 30 days), most frequently asked product categories (NLP topic extraction from conversations JSONB), escalation rate (% of conversations that ended with [ESCALATE] in the AI response), and average conversation length (turns). Use Recharts for the trend lines.
- 4
Add brand customization to the widget: load the tenant's brand_color_primary, brand_color_secondary, assistant_name, and logo_url from the tenants table and apply them to the widget UI via inline CSS variables. The operator should be able to preview the branded widget in real time on the brand settings page.
- 5
Add cart-abandonment nudge: the widget JavaScript should check if the current Shopify page has items in the cart (using Shopify's cart.js endpoint: /cart.json). If cart items > 0 and the chat widget has been idle for 180 seconds, show a soft message: '[assistant_name]: Your cart looks good — anything I can help clarify before you check out?' Log this nudge event separately in the conversations JSONB.
Expected output
A working multi-tenant chat widget platform where brands can plug their Shopify catalog in, get AI embeddings generated, and embed a branded shopping assistant on their storefront — all from a single agency-operated platform at 90%+ margin.
Known gotchas
- !pgvector's ivfflat index requires a minimum of 100 rows before it returns meaningful cosine similarity results — on small catalogs (under 100 product chunks), use an exact cosine search (no index) and add the ivfflat index once the catalog grows.
- !The Shopify Storefront API token is a public token (not the private Admin API key) — it's safe to use in server-side Edge Functions but never expose it client-side in the widget JavaScript bundle.
- !Claude Haiku 4.5's context window is 200K tokens — a product catalog with 10,000+ SKUs chunked into the context directly (not via RAG) would exceed this. Always use pgvector retrieval to select the top 5 relevant chunks; never inject the full catalog.
- !Shopify Theme App Extension or script tag embedding requires the widget to use https (not http) and must handle cross-origin iframe policies correctly — the Lovable Vercel URL works for testing but you'll need a custom domain for production client deployments.
- !PCI-DSS scope avoidance requires that the chat widget NEVER renders, stores, or passes credit card data. Add an explicit instruction in the system prompt: 'Never ask for payment information. If a shopper offers card details, tell them you cannot accept payment information and redirect to the checkout page.'
Compliance & risk reality check
A pre-purchase shopping assistant handles shopper conversation data and may process browsing behavior — triggering consent and data-retention obligations under GDPR and CCPA.
GDPR and CCPA conversation data logging
Storing conversation transcripts (even anonymous) in Supabase triggers GDPR Article 5 data minimization and retention obligations for EU shoppers, and CCPA Section 1798.100 for California shoppers. Anonymous session IDs are technically personal data under GDPR's broad definition if they can be linked to a device or IP address.
Mitigation: Add a cookie-consent banner to the chat widget that discloses conversation logging. Set a maximum retention period for conversation data (90 days is defensible for debugging; delete older records via a pg_cron job). Include the shopping assistant as a data processor in each brand's privacy policy. Offer a DSAR (data subject access request) deletion endpoint in the operator dashboard.
PCI-DSS scope avoidance
If the shopping assistant's chat interface ever intercepts, stores, or processes payment card data — even if a shopper types it by mistake — the platform enters PCI-DSS scope requiring a QSA audit. This is especially risky in a chat interface where shoppers might assume they can 'pay through chat.'
Mitigation: Add explicit instructions in the Claude system prompt to refuse and redirect any payment-related inputs. Add a client-side JavaScript filter that detects 16-digit number sequences in user inputs and blocks submission with a message: 'Please complete your purchase through our secure checkout — I can't accept payment information.' Never log shopper messages that contain potential card data.
AI-generated product information accuracy
If the shopping assistant makes factually incorrect claims about a product (wrong price, wrong material, wrong compatibility) that the shopper relies on when making a purchase, the brand may face consumer-protection claims under FTC Act Section 5 (deceptive practices) or state consumer protection statutes. The RAG architecture mitigates but does not eliminate this risk — Claude can still misinterpret or combine catalog chunks incorrectly.
Mitigation: Add a disclaimer in the chat widget header: '[Assistant Name] provides product information to help you shop — always verify details on the product page before purchasing.' Implement an accuracy-testing suite before each brand launch that validates the assistant's responses to your 20 most common product questions against the actual product page data.
Build vs buy: the real math
5–8 weeks
Custom build time
$13,000–$25,000
One-time investment
5–12 months (at $49/mo per brand, 10+ brands)
Breakeven vs buying
Tidio Lyro AI at $749/mo is the closest white-label-adjacent competitor. At 10 brand clients, an agency paying Tidio would spend $7,490/mo — $89,880/yr — with no white-label and no inventory grounding. A $13K–$25K RapidDev build serving 10 clients at $49/mo generates $490/mo revenue against $85/mo in infra costs — the $13K build breaks even in 27 months, but scales: 50 clients generate $2,450/mo (95% margin) with no incremental build cost. At 200 clients (the brief's decision-hook scale), the $25K build breaks even in month 5 and generates $9,400+/mo thereafter. Build-yourself first at $50 total cost to validate 10 paying clients, then engage RapidDev for the production multi-tenant hardening.
Skip the DIY — RapidDev builds the production version
A Lovable MVP gets you a demo. Production needs auth that doesn't leak data, AI calls that don't bankrupt you, observability when models drift, and code you can audit. That's what we ship.
Discovery call (free)
30 minWe map your exact Virtual Shopping Assistant use case: who uses it, target volume, AI model choice, integrations, compliance scope. You get a detailed scope document and fixed-price quote within 48 hours.
AI-accelerated build
5–8 weeksOur engineers use Claude Code, Lovable, and custom tooling to ship 3–5x faster than agencies. You see weekly progress in a staging environment — not a black box.
Launch + handoff
1 weekWe deploy to your infrastructure, transfer the GitHub repo, set up CI/CD and monitoring, and train your team. You own 100% of the source code, prompts, and model configurations.
What you get
Timeline
5–8 weeks
Investment
$13,000–$25,000
vs SaaS
ROI in 5–12 months (at $49/mo per brand, 10+ brands)
30-min call. Fixed-price quote within 48 hours. No commitment.
Frequently asked questions
How much does it cost to build a white-label AI virtual shopping assistant?
A Lovable weekend build costs $25 (Lovable Pro) + ~$25 in API credits = $50 total and produces a working demo. RapidDev's production-grade multi-tenant build is $13,000–$25,000, covering the Shopify Storefront API catalog sync, pgvector RAG pipeline, Claude Haiku 4.5 integration, multi-tenant isolation, the Shopify Theme App Extension widget embed, and an operator dashboard for managing brand clients.
How long does it take to ship an AI shopping assistant?
A Lovable MVP takes one weekend. A production-ready multi-tenant platform takes 5–8 weeks with RapidDev. The critical path items are the Shopify webhook-driven catalog re-indexing pipeline (2 weeks), the pgvector retrieval-augmented generation architecture (1 week), the widget embed cross-origin handling (1 week), and the multi-tenant RLS and operator dashboard (2–3 weeks).
Can RapidDev build this for my agency?
Yes. RapidDev has shipped 600+ applications including Shopify integrations, conversational AI platforms, and multi-tenant SaaS tools. If you have 5+ DTC brand clients you want to deploy branded shopping assistants for, book a free 30-minute consultation at rapidevelopers.com to scope the right build tier.
Will the assistant hallucinate incorrect product information?
RAG grounding (retrieving product chunks before generating) dramatically reduces hallucination compared to a vanilla chatbot. The assistant can only reference products that appear in its top-5 retrieved results — it won't invent products that don't exist. However, it can still misinterpret ambiguous catalog descriptions or incorrectly combine two products' features. Mitigate this with a pre-launch accuracy test suite (validate 20+ common product questions against actual product pages) and include a widget disclaimer directing shoppers to the product page for authoritative details.
How is this different from just installing Tidio or Intercom?
Tidio and Intercom are branded SaaS platforms — your clients' shoppers see 'Powered by Tidio' or Intercom's widget design, which means the agency cannot resell a branded product or control the roadmap. A custom-built assistant is fully branded to your agency's product (or each client's brand), you own the codebase, you control feature development, and the economics improve as you add clients — Tidio charges $749/mo regardless of whether you have 1 client or 50.
Can the assistant handle returns and order status queries?
The pre-purchase shopping assistant (this slug) is intentionally scoped to product discovery, sizing, and availability questions. Order status and return initiation require Shopify Admin API access (not just Storefront API) and introduce more complex edge cases around order disputes and refund flows. Those use cases are covered by the ai-chatbot-for-e-commerce-support slug. You can deploy both on the same platform — the pre-purchase assistant handles top-of-funnel, the support assistant handles post-purchase.
How do catalog updates get reflected in the assistant?
Two mechanisms: (1) a Shopify product/update webhook that triggers incremental re-embedding of changed products within seconds of a catalog update; and (2) a nightly full-catalog resync as a failsafe. New products appear in the assistant's knowledge base as soon as their embeddings are generated — typically 10–30 seconds after a Shopify product save. Price and availability data is refreshed on the same webhook cycle, so the assistant always reflects the current Shopify state.
Want the production version?
- Delivered in 5–8 weeks
- You own 100% of the code
- AI cost monitoring built in
30-min call. No commitment.