From Product Grids to Personal Stylists: Conversational Upselling with AI

This is a submission for the Algolia Agent Studio Challenge: Consumer-Facing Conversational Experiences

What I Built

I built a Conversational Upselling Agent for e-commerce. Its goal is to turn static “Customers Also Like” sections into timely, contextual suggestions delivered through natural conversation.

On most online stores, complementary products are shown in grids at the bottom of the page. These recommendations often lack context and appear at the wrong place in the buying journey, so they’re easy to ignore.

This project explores a different approach:

Instead of passively showing products, a conversational agent acts like a helpful stylist, introducing complementary items after a shopper shows clear purchase intent.

Example:

“Great choice on that jacket. To complete the look, these leather loafers pair nicely with it—they balance the streetwear vibe with something more refined. Want to see them?”

The focus of this project is not just search, but how and when related products are introduced during a shopping conversation.

Demo

Live Demo: https://lumen-collection.vercel.app/
Video Walkthrough: https://youtu.be/hjU9DyoVsSc
GitHub Repository: https://github.com/gervais-amoah/lumen-collection

Note: The live demo runs on limited API quotas. If you encounter errors, it may be due to usage limits being reached rather than a system failure. The video walkthrough shows the intended experience.

The Core Idea

E-commerce databases often contain structured relationships between products (e.g., items that go well together). However, this data is usually surfaced as static UI blocks with little explanation.

This agent activates that dormant relational data by:

Helping users find a primary product through conversation
Waiting until the user adds it to their cart
Suggesting complementary items with a clear, human-style rationale

The emphasis is on timing, tone, and context, not just recommendation algorithms.

How I Used Algolia Agent Studio

Algolia Agent Studio powers both product discovery and the relational upselling flow.

1. Relational Product Data

Products are stored in Supabase and indexed in Algolia. Each product contains a related_items field that links to complementary products using UUIDs:

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "name": "Black Bomber Jacket",
  "related_items": {
    "similar": ["uuid-1", "uuid-2"],
    "clothing": ["uuid-3"],
    "accessories": ["uuid-4"]
  }
}

These category groupings (like clothing or accessories) indicate the type of complementary product. The agent combines this structure with conversational context to decide what to suggest next.

2. Conversational Upselling Workflow

The upselling flow is triggered after an item is added to the cart.

Step 1 — Confirmation
The agent immediately acknowledges the action:

“Perfect! That’s in your cart.”

Step 2 — Suggest a Complementary Category
The agent looks at the product’s related_items and uses the ongoing conversation to infer what type of item might help complete the look (for example, suggesting accessories after clothing).

Step 3 — Styled Recommendation
Instead of generic phrasing, the agent explains why the item works:

❌ “You might also like this bag.”
✅ “To complete the look, this leather backpack pairs well with that jacket—it keeps the outfit cohesive while adding a practical edge.”

Step 4 — Loop or Stop
If the user accepts, the agent fetches and presents the product, then may suggest another category. The flow stops when:

The user declines further suggestions
The user asks to stop
The agent believes a “complete look” has been formed (one item from each of the three broad categories)

Prompt – Cross-Sell After Purchase:

When addToCart succeeds:

1. Quick win: "Perfect! That's in your cart."
2. Suggest ONE complementary item from related_items with clear connection

If user wants to see it → Show ProductCard → Ask if they want to add it
If user declines → "No problem! Your [item] is ready to go. Need anything else?"

Currently, the agent does not read the cart directly. It infers progress from the conversation and what has already been suggested. Adding real cart-state awareness would be a strong future improvement.

3. Conversational Product Search

Before upselling begins, the agent helps users find products through intent-based search.

Process:

Extract intent from natural language (item type, style hints)
Search Algolia with the most specific interpretation
If no results appear, progressively broaden the query
Present results with short, helpful explanations
Use the similar UUID list for fast alternative suggestions when users ask for other options

Prompt – Smart Search:

On any product request, search immediately using this 3-attempt hierarchy:

1. Map user intent to your inventory structure:
   - Infer category (clothing/accessories/footwear) first
   - Then subcategory (shirts, bags, boots, etc.)
   - Extract relevant tags from user's words that match your tag list

2. 3-Attempt Search (max per turn):
   - Attempt 1: subcategory + relevant tags (most specific):
   - Attempt 2: subcategory only (if Attempt 1 returns nothing):
   - Attempt 3: category only (if Attempt 2 returns nothing):

3. Reason with the results:
   - Analyze all returned product data (tags, descriptions, popularity_score)
   - Pick the hero item that best matches user's original intent
   - If you had to broaden the search (dropped tags/subcategory), acknowledge it naturally in your pitch

4. Show top 3 results (curated from up to 10). Keep the rest for pivots.

Search is the entry point — upselling activates once a product is added to the cart.

Why Fast Retrieval Matters in Conversation

Conversational experiences feel natural only if responses follow user actions immediately. Delays can make suggestions feel disconnected or overly “salesy.”

This system uses Algolia for ID-based product retrieval (via UUIDs in related_items and similar).

PS: I haven’t run formal latency benchmarks, but in practice retrieval is fast enough to keep the interaction feeling continuous within the chat flow.

Business Perspective (Hypothesis)

This project is based on a product hypothesis:

If complementary products are introduced at the right moment, with clear contextual explanations, customers may be more open to discovering additional items than when shown static recommendation grids.

The goal of this prototype is to explore interaction design and system architecture, not to present validated revenue improvements.

Technical Stack

Frontend: Next.js + TypeScript (using Algolia’s InstantSearch Chat widget as the conversational UI for the agent)
Database: Supabase (PostgreSQL)
Search & Agent Logic: Algolia Agent Studio
Deployment: Vercel

Architecture Overview:

Products stored in Supabase with relational UUID references
Algolia index synced from Supabase
Agent retrieves products and related items directly from Algolia
Product cards are rendered inside the chat interface

Prototype Limitations

This is an early-stage prototype, and several limitations remain:

The catalog contains ~30 products
No scalability or load testing has been performed
Product relationships are manually curated
The agent does not read real cart state (it infers progress from conversation)
Some demo sessions may fail due to API usage limits

These constraints make this a design and architecture exploration rather than a production-ready system.

Future Enhancements

Real-time cart awareness instead of conversational inference
Larger catalog with automated relationship generation
Semantic search for occasion-based shopping (e.g., “I need something for a gallery opening”)
More advanced reasoning about outfit completeness and style consistency

Try It

Navigate to the Agent Mode and try prompts like:

“I need a jacket for streetwear”
“Show me minimalist backpacks”
“Add that to my cart”

Then notice how the agent introduces complementary items through conversation rather than static product grids.

Built with Algolia Agent Studio for the Consumer-Facing Conversational Experiences Challenge