The Shopping Assistant That Outsells Your Best Sales Rep

Lauren's dashboard told a simple story every Monday morning. 200,000 visitors came to the site last month. 4,600 bought something. The rest left.

A 2.3% conversion rate. For a $50M online fashion retailer with 15,000 SKUs, that meant 195,400 people browsed, maybe added something to a cart, and then disappeared. The exit surveys told her why. The top two reasons, quarter after quarter: "I couldn't find what I was looking for" and "I wasn't sure about sizing."

She had a support chat. Three agents, 9 to 5, handling returns and complaints. Not shopping. When a customer typed "I need a dress for a beach wedding in August, budget under $200," the chat bot replied with a link to the dresses category page. All 847 dresses. Have fun scrolling.

The problem wasn't traffic. It wasn't pricing. It wasn't product quality. It was the gap between what a customer wanted and what the site could help them find. A search box that matches keywords doesn't understand "beach wedding in August." A category filter that offers "Dresses > Maxi > Under $200" doesn't know that this customer returned a maxi dress three months ago because it was too long.

Lauren didn't need a chatbot. She needed a personal stylist that worked 24/7, remembered every customer, and could actually close a sale.

Why Search Boxes Fail Fashion

Type "beach wedding dress" into a search box on most fashion sites. You'll get wedding dresses. White ones. With veils. That's keyword matching doing exactly what it was designed to do, and getting it completely wrong.

The customer doesn't want a wedding dress. She wants a dress to wear to a beach wedding. Something flowy, probably floral or a solid bright color, appropriate for sand and August heat, under $200. She knows what she means. The search box does not.

This is the fundamental gap in ecommerce discovery. Customers think in intent and context. Search engines think in keywords. A human sales associate on a department store floor would hear "beach wedding in August" and walk the customer to a rack of chiffon wrap dresses in the $120-180 range. She'd pull three options, explain why each one works, and mention that the floral one runs a half size small.

That sales associate uses three things the search box doesn't have: understanding of intent (what the customer actually means), knowledge of the catalog (which products match that intent), and memory of the customer (what she's bought before, what she returned and why). Build all three into an AI shopping assistant, and you get something that behaves less like a search box and more like the best person on your sales floor.

Product Catalog as a Knowledge Base

The first layer is making the catalog searchable by intent, not just keywords. This means converting 15,000 product descriptions, sizing guides, and customer reviews into a knowledge base that understands natural language.

A JSON product feed gets ingested in a single API call. Each product becomes a searchable document. Descriptions, specs, reviews, and sizing notes all go into the index:

import { Chanl } from '@chanl/sdk';
 
const chanl = new Chanl({ apiKey: process.env.CHANL_API_KEY });
 
// Ingest the full catalog from a product feed
const catalog = await chanl.knowledge.create({
  title: 'Product Catalog - Spring/Summer 2026',
  source: 'url',
  url: 'https://store.example.com/api/products.json',
});
 
// Crawl sizing guides and style pages for richer context
await chanl.knowledge.create({
  title: 'Sizing Guides & Style Notes',
  source: 'url',
  url: 'https://store.example.com/sizing',
  crawlOptions: { depth: 2 },
});

Raw ingestion is table stakes. The real power is hybrid search. When a customer asks for "something flowy for a beach wedding under $200," hybrid mode combines vector similarity (understanding that "flowy" relates to chiffon, silk, and A-line cuts) with keyword filtering (the $200 price cap):

const results = await chanl.knowledge.search({
  query: 'flowy dress for beach wedding, summer, under $200',
  mode: 'hybrid',
  limit: 10,
});
 
// Returns: chiffon wrap dresses, floral midi dresses, linen A-lines
// Does NOT return: wedding gowns, cocktail dresses, winter fabrics

Hybrid search closes the intent gap. Pure vector search understands "beach wedding" but can't filter on price. Pure keyword search handles "$200" but misses the connection between "flowy" and chiffon. Hybrid handles both in one query. (For a deeper look at why retrieval quality matters more than model choice, see why RAG returns wrong answers.)

Daily Sync for a Living Catalog

Fashion inventory changes constantly. New arrivals every week. Items selling out. Seasonal markdowns. A knowledge base that's two days stale will recommend a dress that's sold out in the customer's size, which is worse than no recommendation at all.

The daily sync pipeline re-ingests the product feed and updates the index. Products that dropped out of stock get flagged. New arrivals get indexed. Price changes propagate within hours:

// Scheduled daily via cron or webhook on catalog update
// Delete stale entry and re-ingest from the live feed
await chanl.knowledge.delete(catalog.id);
 
const freshCatalog = await chanl.knowledge.create({
  title: 'Product Catalog - Spring/Summer 2026',
  source: 'url',
  url: 'https://store.example.com/api/products.json',
});

This is the difference between a demo and production. Demo knowledge bases are static snapshots. Production knowledge bases are living indexes that stay current with the business.

But even a perfect catalog search treats every customer the same. The customer who returned a maxi dress because it was too long gets recommended another maxi dress. That takes memory.

Personalization Through Memory

Memory turns a search box into a personal shopper. Without it, the assistant is helpful but generic. "Here are three dresses for a beach wedding." With it, the assistant becomes specific. "Based on your last order, I'd suggest the midi length. You returned the Riviera Maxi in June because it was too long, and these hit about four inches above the ankle."

That specificity is the difference between a customer thinking "this is useful" and a customer thinking "this thing actually knows me."

What Gets Remembered

Three types of facts compound over time:

Explicit preferences. The customer says "I only wear natural fabrics" or "I'm a size 6 on top, 8 on bottom." These get stored directly:

await chanl.memory.create({
  entityType: 'customer',
  entityId: 'cust_8847',
  content: 'Prefers natural fabrics (cotton, linen, silk). Top size 6, bottom size 8.',
});

Implicit preferences from conversations. The customer says "I loved that linen shirt I got last summer." She didn't explicitly state a fabric preference, but the fact is there. After each conversation, memory extraction pulls these implicit facts automatically:

const extracted = await chanl.memory.extract({
  text: conversationTranscript,
  entityType: 'customer',
  entityId: 'cust_8847',
  save: true,
});
// Extracts: "Prefers linen. Bought a linen shirt summer 2025. Positive sentiment."

Returns and their reasons. This is the most valuable signal that most systems ignore entirely. A customer returning a maxi dress because it was too long is a data point that shapes every future recommendation. Not just "don't suggest maxi dresses," but "suggest midi or knee-length, and mention the hemline in the recommendation."

Extracted from return interaction:
- Returned: Riviera Maxi Dress, Size M
- Reason: Too long (customer is 5'4")
- Implication: Prefer midi-length or shorter for this customer
- Note: Liked the fabric and color, only issue was length

Memory at Session Start

When the customer returns, memory loads before the first message. The agent doesn't ask "What are you looking for today?" It says "Welcome back! I remember you love natural fabrics and prefer midi lengths. We just got some new linen dresses in your size range. Want to take a look?"

// Load customer memories before the conversation starts
const memories = await chanl.memory.search({
  entityType: 'customer',
  entityId: 'cust_8847',
  query: 'preferences sizes returns',
});
 
const context = memories.data.memories.map((m) => m.content).join('\n');
 
// Injected into agent system prompt:
// "Customer prefers natural fabrics (cotton, linen, silk).
//  Top size 6, bottom size 8.
//  Returned Riviera Maxi Dress (too long, customer is 5'4").
//  Prefers midi-length. Positive on linen."

This isn't a recommendation engine running collaborative filtering. It's conversational memory that compounds with every interaction. The more a customer shops, the better the assistant gets at helping them. That flywheel doesn't exist with a search box. (Related: why most agents forget 87% of what they knew and how to prevent it.)

Tools That Close Sales

A personal stylist who can find the perfect dress but can't ring it up is only half useful. The AI shopping assistant needs to do what human sales associates do: check if it's in stock, apply the promo code, calculate shipping, and add it to the cart. All in the same conversation. (When tool count grows, organization matters. See managing 50+ agent tools at scale.)

Each commerce action is a tool the agent calls mid-conversation:

Inventory Check

The customer found a dress she likes. Before recommending it, the agent checks availability in her size:

await chanl.tools.create({
  name: 'check_inventory',
  description: 'Check real-time stock for a product in a specific size and color',
  type: 'http',
  inputSchema: {
    type: 'object',
    properties: {
      productId: { type: 'string', description: 'Product SKU or ID' },
      size: { type: 'string', description: 'Size (XS, S, M, L, XL or numeric)' },
      color: { type: 'string', description: 'Color variant' },
    },
    required: ['productId'],
  },
  configuration: {
    url: 'https://api.store.example.com/inventory/check',
    method: 'POST',
  },
});

Cart Management

The agent doesn't just recommend. It closes. "Want me to add the floral wrap dress to your cart in medium?"

await chanl.tools.create({
  name: 'manage_cart',
  description: 'Add items to cart, remove items, or view current cart contents',
  type: 'http',
  inputSchema: {
    type: 'object',
    properties: {
      action: {
        type: 'string',
        enum: ['add', 'remove', 'view'],
        description: 'Cart action to perform',
      },
      productId: { type: 'string' },
      size: { type: 'string' },
      color: { type: 'string' },
      quantity: { type: 'number', description: 'Defaults to 1' },
      customerId: { type: 'string' },
    },
    required: ['action', 'customerId'],
  },
  configuration: {
    url: 'https://api.store.example.com/cart',
    method: 'POST',
  },
});

Promo Code Validation

The agent knows about active promotions and can apply them without the customer hunting for a code box at checkout:

await chanl.tools.create({
  name: 'validate_promo',
  description: 'Check if a promo code is valid and calculate the discount',
  type: 'http',
  inputSchema: {
    type: 'object',
    properties: {
      code: { type: 'string', description: 'Promo code to validate' },
      cartTotal: { type: 'number', description: 'Current cart total in dollars' },
      productIds: {
        type: 'array',
        items: { type: 'string' },
        description: 'Product IDs in cart for category-specific promos',
      },
    },
    required: ['code'],
  },
  configuration: {
    url: 'https://api.store.example.com/promos/validate',
    method: 'POST',
  },
});

Shipping Estimate

"If I order now, when will it arrive?" The agent answers immediately:

await chanl.tools.create({
  name: 'estimate_shipping',
  description: 'Calculate shipping cost and estimated delivery date',
  type: 'http',
  inputSchema: {
    type: 'object',
    properties: {
      zipCode: { type: 'string' },
      items: {
        type: 'array',
        items: {
          type: 'object',
          properties: {
            productId: { type: 'string' },
            quantity: { type: 'number' },
          },
        },
      },
      shippingMethod: {
        type: 'string',
        enum: ['standard', 'express', 'overnight'],
      },
    },
    required: ['zipCode', 'items'],
  },
  configuration: {
    url: 'https://api.store.example.com/shipping/estimate',
    method: 'POST',
  },
});

The Closing Conversation

Here's what these tools look like in a real conversation:

Customer: "I need a dress for a beach wedding in August.
           Budget is under $200."
 
Agent:    [searches knowledge base with memory context:
           customer prefers natural fabrics, wears size 6,
           returned a maxi dress for being too long]
 
Agent:    "I found three great options for you. Since you
           prefer natural fabrics and midi lengths, I focused
           on those:
 
           1. Coastal Wrap Dress in Sea Glass ($168)
              Linen blend, midi length, adjustable tie waist.
              Available in your size 6.
 
           2. Palm Print Shift Dress ($142)
              100% cotton, hits just above the knee.
              Great for the beach since it's machine washable.
 
           3. Amalfi Midi in Coral ($189)
              Silk blend, beautiful drape. This one runs
              true to size based on reviews.
 
           I skipped the maxi options since you mentioned
           the Riviera was too long last time. Want me to
           add any of these to your cart?"
 
Customer: "The wrap dress is gorgeous. Is the Sea Glass
           color still in stock in my size?"
 
Agent:    [calls check_inventory: productId=WD-2847,
           size=6, color=Sea Glass]
 
Agent:    "Yes, your size 6 in Sea Glass is in stock.
           And I see you haven't used the SUMMER20 code yet.
           That takes 15% off, bringing it to $142.80.
           Want me to add it to your cart with the code?"
 
Customer: "Yes please!"
 
Agent:    [calls manage_cart: action=add, productId=WD-2847,
           size=6, color=Sea Glass]
          [calls validate_promo: code=SUMMER20, cartTotal=168]
 
Agent:    "Done! The Coastal Wrap Dress is in your cart at
           $142.80 with free standard shipping (arrives by
           August 3rd). Need anything else for the wedding?"

That conversation would take a human sales associate about 8 minutes. It took the assistant 45 seconds. More importantly, it happened at 11:30 PM on a Tuesday, when no human associate was available.

Revenue Attribution: Proving the Investment

Every AI-assisted purchase needs to trace back to the conversation that drove it. Without attribution, the assistant is a cost center. With it, the ROI conversation is arithmetic.

The Metrics That Matter

The return rate metric deserves attention. A 24% return rate on a $50M business is $12M in reverse logistics annually. If the assistant's memory of past returns and sizing preferences drops that to 15%, the savings on returns alone justify the entire program.

Tracking the Funnel

Interaction analytics connect every conversation to its outcome. Did the customer buy? What did they buy? Was it what the agent recommended? Did they return it?

The attribution chain: conversation started > products recommended > product added to cart > purchase completed > (optional) return filed. Every link in that chain is logged. When Lauren pulls her Monday report, she sees conversion rate for AI-assisted sessions versus unassisted browse sessions, and the delta is the assistant's contribution.

The comparison group is built in. Customers who engage the chat versus customers who don't. Same products, same prices, same promotions. The only variable is whether a personal stylist helped them find what they wanted. (For a broader framework on what to monitor and when to escalate, see real-time monitoring for AI agents.)

Multichannel: Same Brain, Every Surface

The customer who chatted on the website at 11 PM is the same customer who gets an SMS at 2 PM the next day. The assistant should know that.

Website Chat

The primary channel. A customer browsing the dresses category sees the chat widget. She types her question, gets personalized recommendations, and adds to cart without leaving the conversation. The assistant is embedded in the shopping flow, not a separate support experience.

SMS for Abandoned Cart Recovery

The customer added the wrap dress to her cart at 11:30 PM but didn't check out. At 2 PM the next day:

SMS: "Hey Sarah, the Coastal Wrap Dress in Sea Glass
is still in your cart. It's selling fast in size 6.
Want me to hold your size for 24 hours? Reply YES
to hold it, or STYLE to see similar options."

That SMS comes from the same agent with the same memory. If Sarah replies "STYLE," the assistant searches the knowledge base with her preferences and sends back two alternatives. If she replies "YES," the agent calls the inventory hold tool.

Mobile App

The in-app assistant has the same capabilities as webchat. The customer browses on her phone during lunch, asks the assistant for help, and picks up the conversation on desktop when she gets home. Memory follows her across devices because it's attached to her customer ID, not her browser session.

One Agent, Three Channels

The key architectural decision: one agent, one set of tools, one knowledge base, one memory store, three channel deployments. There's no separate "SMS bot" or "mobile assistant" to maintain. Change the product catalog and all three channels see the update. Train the agent to handle a new edge case and all three channels benefit.

Testing Before Real Customers See It

Launching a shopping assistant to 200,000 monthly visitors without testing is like hiring a new sales associate and putting them on the floor without training. Scenario testing lets you simulate hundreds of customer conversations before a single real customer interacts with the assistant.

Shopping Personas

Four personas cover the critical shopper archetypes:

const personas = [
  {
    name: 'Bargain Hunter',
    emotion: 'skeptical',
    backstory:
      'Price-sensitive shopper who compares across sites. ' +
      'Will ask about sales, price matching, and cheaper alternatives. ' +
      'Abandons if nothing is under budget.',
    intentClarity: 'direct',
    speechStyle: 'casual',
  },
  {
    name: 'Gift Shopper',
    emotion: 'anxious',
    backstory:
      'Buying a birthday gift for a friend. Not sure what to get. ' +
      'Needs guidance on style, size estimation, and gift wrapping. ' +
      'Will ask "what would you recommend?" repeatedly.',
    intentClarity: 'vague',
    speechStyle: 'conversational',
  },
  {
    name: 'Return Customer',
    emotion: 'expectant',
    backstory:
      'Bought a dress last month. Returned it because it was too long. ' +
      'Expects the assistant to remember this and not suggest similar lengths. ' +
      'Will test whether personalization actually works.',
    intentClarity: 'specific',
    speechStyle: 'direct',
  },
  {
    name: 'Browser',
    emotion: 'relaxed',
    backstory:
      'Just looking. No specific item in mind. Might buy if something ' +
      'catches their eye. Will ask broad questions like "what's new?" ' +
      'and "what are people buying right now?" Hard to convert.',
    intentClarity: 'vague',
    speechStyle: 'casual',
  },
];

Each persona runs autonomous conversations with the assistant. The Bargain Hunter asks about cheaper alternatives for every recommendation. The Gift Shopper says "I have no idea what she likes" and expects the agent to ask clarifying questions. The Return Customer references a past purchase and expects the assistant to acknowledge it. The Browser asks "what's trending?" and needs to be gently guided toward a purchase without pressure.

Running Scenarios

const session = await chanl.scenarios.run('beach-wedding-shopping', {
  parameters: {
    budget: 200,
    occasion: 'beach wedding',
    season: 'summer',
  },
});

You don't script the conversation. You set the parameters and let the persona interact naturally. The Bargain Hunter might ask for cheaper alternatives three times, push back on shipping costs, and demand a price match. The assistant has to handle all of it without breaking character or recommending out-of-stock items.

Scoring with Scorecards

Running scenarios is step one. Grading them is step two. Scorecards evaluate each conversation against criteria that matter for commerce:

The scorecards run an AI evaluator against the conversation transcript. Each dimension gets a numeric score. Over time, you track improvement: did the latest prompt change improve rejection recovery without hurting product relevance? Scorecards give you the answer objectively, not through vibe checks.

The Architecture in Full

Here's every layer of the system and how they connect:

Knowledge base: 15,000 SKUs with descriptions, sizing data, reviews, and availability. Synced daily from the product feed. Hybrid search handles intent + filters.

Memory: Purchase history, size preferences, style preferences, returns with reasons, and auto-extracted facts from every conversation. Loads at session start.

Tools: Inventory check, cart management, promo code validation, shipping estimates, and order status. Each registered as an HTTP tool the agent calls mid-conversation.

Scenarios: Four shopper personas (bargain hunter, gift shopper, return customer, browser) running autonomous test conversations. Scored by scorecards measuring product relevance, sizing accuracy, price compliance, closing behavior, rejection recovery, and upsell appropriateness.

Analytics: Every conversation tracked end-to-end. AI-assisted conversion rate versus unassisted. Average order value, return rate, cart abandonment. Revenue attribution per conversation.

Channels: Website chat, SMS (abandoned cart recovery), mobile app. One agent, one knowledge base, one memory store. Three deployments.

The Memory Lifecycle in Detail

Memory is the feature that turns a helpful tool into a competitive advantage. Here's how it flows through a customer's journey:

First visit. The customer is anonymous. The assistant searches the catalog, makes recommendations, and asks clarifying questions. When the customer creates an account or provides an email to save her cart, the assistant stores what it learned during the conversation.

Post-conversation extraction. After the session ends, extraction runs against the full transcript. Size mentions, fabric preferences, budget ranges, occasion types, and any positive or negative reactions to specific products. All stored as structured facts.

Second visit. Memory loads before the first message. The assistant greets the customer by name and references her preferences. "Looking for something for another event, or just browsing?" The customer feels recognized.

Post-purchase. The order confirmation triggers a memory update: what she bought, in what size, for what occasion. This enriches the profile for next time.

Post-return. The return reason is the most valuable signal. "Too long" tells the assistant to adjust length recommendations. "Fabric was scratchy" tells it to filter for softer materials. "Wrong color" is less actionable. Each return reason creates a specific preference that shapes future suggestions.

Sixth visit. The assistant now knows her top size, bottom size, fabric preferences, length preferences, budget range, usual occasions, past purchases, and return reasons. It's a personal stylist with a perfect memory. The recommendations get better with every interaction, and the customer notices.

From 2.3% to What?

Lauren's site had 200,000 monthly visitors and a 2.3% conversion rate. The industry average for AI-assisted shopping sessions ranges between 8-15%, depending on category and implementation quality. Even conservative estimates show significant impact.

The math on a $50M business:

Current state: 200,000 visitors * 2.3% conversion * $87 AOV = ~$400K/month

If 30% of visitors engage the assistant (60,000 sessions) and the AI-assisted conversion rate reaches 10%:

AI-assisted: 60,000 * 10% * $110 AOV = $660K/month from assisted sessions Unassisted: 140,000 * 2.3% * $87 AOV = $280K/month from unassisted Combined: $940K/month

That's a $540K monthly revenue increase. Even if only 15% of visitors engage and the conversion rate lifts to 8%, the numbers move meaningfully.

The return rate reduction adds to the bottom line independently. A drop from 24% to 15% on $50M in annual sales saves roughly $4.5M in reverse logistics, restocking, and customer service costs.

These aren't theoretical projections. They're arithmetic applied to the existing business. The assistant doesn't bring new traffic. It converts the traffic that already shows up and leaves without buying.

What This Doesn't Solve

The honest section. An AI shopping assistant is not a silver bullet.

Product photography matters. The best recommendation in the world falls flat if the product images look like they were shot in a basement. The assistant can describe the fabric and suggest the size, but the customer still needs to see the dress and want it. Visual merchandising remains a human discipline.

Fulfillment problems persist. The assistant can check inventory and estimate shipping. It cannot fix a warehouse that ships late or a carrier that loses packages. The experience after "Add to Cart" is still an operations problem.

Complex returns need humans. The assistant can handle "I want to return this because it didn't fit." It should escalate "I want to return this because it arrived damaged and I need it for an event this weekend." High-emotion, time-sensitive returns need a human who can authorize expedited replacements and empathize in ways an AI currently cannot.

Cold start for new customers. The memory advantage takes time to build. A first-time visitor with no purchase history gets the generic experience. The assistant is still better than a search box for them, but the personalization that drives repeat purchase loyalty takes two or three interactions to develop.

Building It

The build order matters. Go inside-out: knowledge base first, then memory, then tools, then the agent that ties them together, then channels, then testing.

Week 1: Knowledge base. Ingest the product catalog. Set up daily sync. Test hybrid search with 50 real customer queries from support tickets. Does "beach wedding dress" return the right products? Does "something warm for my sister, she's a size 8" return relevant results?

Week 2: Memory and tools. Configure memory extraction for post-conversation facts. Build and test the five commerce tools (inventory, cart, promo, shipping, order status) against the real APIs. Verify that memory loads correctly at session start.

Week 3: Agent and scenarios. Create the agent with a system prompt that defines the personal stylist persona. Deploy the four test personas. Run 100+ scenario conversations. Score with the commerce scorecard. Iterate on the prompt until rejection recovery and closing behavior pass consistently.

Week 4: Channels and launch. Deploy to website chat first. Monitor every conversation for the first 48 hours. Launch SMS abandoned cart recovery. Deploy to the mobile app. Compare AI-assisted metrics against the baseline.

The infrastructure for all of this already exists. Knowledge base ingestion, memory management, tool registration, scenario testing, scorecard evaluation, multichannel deployment, and interaction analytics are all platform capabilities. The work is in configuring them for the specific business: the product catalog, the commerce APIs, the shopper personas, the scoring criteria.

Lauren's Monday dashboard looks different now. Same 200,000 visitors. More of them bought something. Fewer of them returned it. And every conversation with the assistant made the next one a little better.

Learn Agentic AI

One lesson a week — practical techniques for building, testing, and shipping AI agents. From prompt engineering to production monitoring. Learn by doing.

Subscribe

500+ engineers subscribed