Dynamic E-commerce FAQ: Generate Contextual Answers

Static FAQs are outdated. Your customers ask specific questions about specific products in specific contexts. A dynamic FAQ powered by RAG generates personalized answers in real-time. This guide shows you how to transform your e-commerce support.

The Problem with Traditional FAQs

Limitations of Static FAQs

What Customers Really Want

Customers don't want to read 50 questions to find their answer. They want to:

• Ask their question in their own words
• Get an immediate and precise answer
• Have the answer concern their specific product
• Get up-to-date information (stock, price, delivery times)

Dynamic FAQ Architecture

Data Sources

┌─────────────────────────────────────────────────────────────┐
│                    FAQ SOURCES                               │
├─────────────┬─────────────┬─────────────┬──────────────────┤
│  Existing   │    Store    │   Product   │    Support       │
│    FAQ      │   Policies  │   Catalog   │    History       │
└──────┬──────┴──────┬──────┴──────┬──────┴────────┬─────────┘
       │             │             │               │
       └─────────────┴──────┬──────┴───────────────┘
                            ▼
                   ┌─────────────────┐
                   │   Multi-source  │
                   │    Indexing     │
                   └────────┬────────┘
                            ▼
                   ┌─────────────────┐
                   │   Contextual    │
                   │   Generation    │
                   └─────────────────┘

Multi-source Indexing

DEVELOPERpython
class EcommerceFAQIndexer:
    """Index all sources for dynamic FAQ."""

    def __init__(self, vector_db, embedder):
        self.vector_db = vector_db
        self.embedder = embedder

    async def index_all_sources(self):
        """Index FAQ, policies, and products."""
        documents = []

        # Existing FAQ
        faq_docs = await self.process_faq()
        documents.extend(faq_docs)

        # Store policies
        policy_docs = await self.process_policies()
        documents.extend(policy_docs)

        # Product information (for specific questions)
        product_docs = await self.process_products()
        documents.extend(product_docs)

        # Support history (resolved questions)
        support_docs = await self.process_support_history()
        documents.extend(support_docs)

        # Index
        await self.vector_db.upsert(
            collection="faq_knowledge",
            documents=documents
        )

    async def process_faq(self) -> list:
        """Process existing Q&As."""
        faq_items = await self.load_faq()
        documents = []

        for item in faq_items:
            # Format optimized for retrieval
            content = f"""
            Question: {item['question']}
            Answer: {item['answer']}
            Keywords: {', '.join(item.get('keywords', []))}
            """

            documents.append({
                "id": f"faq_{item['id']}",
                "content": content,
                "metadata": {
                    "type": "faq",
                    "category": item.get('category'),
                    "question": item['question'],
                    "answer": item['answer']
                }
            })

        return documents

    async def process_policies(self) -> list:
        """Process store policies."""
        policies = {
            "shipping": await self.load_shipping_policy(),
            "returns": await self.load_return_policy(),
            "payment": await self.load_payment_info(),
            "warranty": await self.load_warranty_info()
        }

        documents = []
        for policy_type, content in policies.items():
            # Split into sections
            sections = self.split_policy(content)
            for i, section in enumerate(sections):
                documents.append({
                    "id": f"policy_{policy_type}_{i}",
                    "content": section,
                    "metadata": {
                        "type": "policy",
                        "policy_type": policy_type
                    }
                })

        return documents

Contextual Generation

Dynamic FAQ Prompt

DEVELOPERpython
DYNAMIC_FAQ_PROMPT = """You are the FAQ assistant for {shop_name}.
You answer customer questions based on our knowledge base.

## Rules
1. ONLY respond with the provided information
2. If the question concerns a specific product, use its information
3. Adapt your response to context (current page, cart)
4. Be concise but complete
5. If you can't find the information, say so clearly

## Customer context
- Current page: {current_page}
- Product viewed: {current_product}
- Items in cart: {cart_items}

## Knowledge base
{context}

## Customer question
{question}

## Your response
"""

Context-Adapted Responses

DEVELOPERpython
class DynamicFAQGenerator:
    """Generate contextual FAQ responses."""

    def __init__(self, retriever, llm):
        self.retriever = retriever
        self.llm = llm

    async def answer(
        self,
        question: str,
        context: dict
    ) -> dict:
        """Generate a contextual response."""
        # Enrich query with context
        enriched_query = self._enrich_query(question, context)

        # Retrieve relevant information
        docs = await self.retriever.search(
            query=enriched_query,
            top_k=5,
            filters=self._build_filters(context)
        )

        # If question about specific product, add its info
        if context.get('current_product'):
            product_info = await self._get_product_info(
                context['current_product']
            )
            docs.append(product_info)

        # Generate response
        response = await self.llm.generate(
            prompt=DYNAMIC_FAQ_PROMPT,
            context=self._format_context(docs),
            question=question,
            current_page=context.get('page_type', 'unknown'),
            current_product=context.get('current_product', {}).get('name', 'None'),
            cart_items=len(context.get('cart', []))
        )

        return {
            "answer": response,
            "sources": [d['metadata']['type'] for d in docs],
            "confidence": self._calculate_confidence(docs, response)
        }

    def _enrich_query(self, question: str, context: dict) -> str:
        """Enrich query with context."""
        parts = [question]

        if context.get('current_product'):
            parts.append(f"Product: {context['current_product']['name']}")

        if context.get('page_type'):
            page_keywords = {
                'product': 'product page',
                'cart': 'shopping cart',
                'checkout': 'payment checkout',
                'category': 'catalog'
            }
            parts.append(page_keywords.get(context['page_type'], ''))

        return ' '.join(parts)

Dynamic Question Types

Contextual Product Questions

DEVELOPERpython
async def handle_product_faq(question: str, product: dict) -> str:
    """Answer questions about a specific product."""
    # Common product questions
    question_patterns = {
        "size": "size_guide",
        "color": "color_options",
        "stock": "availability",
        "shipping": "shipping",
        "compatible": "compatibility",
        "warranty": "warranty",
        "care": "care_instructions"
    }

    # Identify question type
    question_type = None
    for keyword, qtype in question_patterns.items():
        if keyword in question.lower():
            question_type = qtype
            break

    # Build response with product info
    if question_type == "availability":
        stock = product.get('stock_quantity', 0)
        if stock > 10:
            return f"The {product['name']} is in stock and available immediately."
        elif stock > 0:
            return f"Only {stock} left of the {product['name']}. Order quickly!"
        else:
            return f"The {product['name']} is temporarily out of stock. Want to be notified?"

    elif question_type == "shipping":
        return f"""
        For **{product['name']}**:
        - Standard shipping (3-5 days): {get_shipping_cost(product)}
        - Express shipping (24-48h): {get_express_cost(product)}

        Order before 2pm for same-day dispatch.
        """

    # Generic RAG-based response
    return await generate_product_answer(question, product)

Adapted Policy Questions

DEVELOPERpython
async def handle_policy_faq(question: str, context: dict) -> str:
    """Answer policy questions with context."""
    # Product-specific returns
    if "return" in question.lower() and context.get('current_product'):
        product = context['current_product']
        category = product.get('category')

        # Category-specific rules
        if category in ['cosmetics', 'underwear']:
            return """
            For hygiene reasons, items in this category
            can only be returned if unopened and
            in their original packaging.

            Return period: 14 days after receipt.
            """

    # Return for current order
    if context.get('recent_order'):
        order = context['recent_order']
        days_since = (datetime.now() - order['date']).days

        if days_since <= 30:
            return f"""
            Your order #{order['id']} from {order['date'].strftime('%m/%d')}
            is still within the return period (30 days).

            To initiate a return:
            1. Go to "My orders"
            2. Select items to return
            3. Print the prepaid label

            You'll be refunded within 48h of receipt.
            """

    # Standard response
    return await get_standard_policy_answer(question)

Predictive FAQ

DEVELOPERpython
class PredictiveFAQ:
    """Suggest relevant questions based on context."""

    def get_suggested_questions(self, context: dict) -> list:
        """Return questions likely to be asked."""
        suggestions = []

        page_type = context.get('page_type')
        product = context.get('current_product')
        cart = context.get('cart', [])

        # Product page
        if page_type == 'product' and product:
            suggestions.extend([
                f"What size should I choose for {product['name']}?",
                "Is this product available in other colors?",
                "What are the delivery times?",
                "Can I return this product if it doesn't fit?"
            ])

            # Technical product
            if product.get('category') in ['electronics', 'appliances']:
                suggestions.append("What's the warranty?")
                suggestions.append("Is it compatible with...?")

        # Cart page
        elif page_type == 'cart' and cart:
            cart_total = sum(item['price'] * item['qty'] for item in cart)

            suggestions.extend([
                "How do I use a promo code?",
                "What are the shipping costs?"
            ])

            # Close to free shipping threshold
            if 40 <= cart_total < 50:
                suggestions.insert(0, "How much for free shipping?")

        # Checkout page
        elif page_type == 'checkout':
            suggestions.extend([
                "What payment methods do you accept?",
                "Is my order secure?",
                "Can I change my address after ordering?",
                "How do I track my order?"
            ])

        return suggestions[:4]  # Max 4 suggestions

Widget Integration

Inline FAQ Widget

DEVELOPERjavascript
// Dynamic FAQ component
class DynamicFAQWidget {
    constructor(config) {
        this.config = config;
        this.context = this.buildContext();
        this.init();
    }

    buildContext() {
        return {
            page_type: this.detectPageType(),
            current_product: this.getCurrentProduct(),
            cart: this.getCartItems(),
            recent_order: this.getRecentOrder()
        };
    }

    async getSuggestedQuestions() {
        const response = await fetch('/api/faq/suggestions', {
            method: 'POST',
            body: JSON.stringify(this.context)
        });
        return response.json();
    }

    async askQuestion(question) {
        const response = await fetch('/api/faq/answer', {
            method: 'POST',
            body: JSON.stringify({
                question,
                context: this.context
            })
        });

        const data = await response.json();
        this.displayAnswer(data.answer);

        // Feedback
        this.showFeedback(data.id);
    }

    render() {
        return `
            <div class="dynamic-faq">
                <h3>Frequently Asked Questions</h3>

                <div class="suggested-questions">
                    ${this.suggestedQuestions.map(q => `
                        <button onclick="faq.askQuestion('${q}')">
                            ${q}
                        </button>
                    `).join('')}
                </div>

                <div class="ask-custom">
                    <input
                        type="text"
                        placeholder="Ask your question..."
                        onkeyup="if(event.key==='Enter') faq.askQuestion(this.value)"
                    />
                </div>

                <div class="answer-container"></div>
            </div>
        `;
    }
}

Measuring Effectiveness

Dynamic FAQ KPIs

Tracking and Improvement

DEVELOPERpython
class FAQAnalytics:
    """Analyze FAQ effectiveness."""

    def track_interaction(
        self,
        question: str,
        answer: str,
        feedback: int = None,
        escalated: bool = False
    ):
        """Record a FAQ interaction."""
        self.db.insert({
            "question": question,
            "answer_preview": answer[:200],
            "feedback": feedback,
            "escalated": escalated,
            "timestamp": datetime.now()
        })

    def identify_gaps(self, period_days: int = 30) -> list:
        """Identify questions without good answers."""
        return self.db.query("""
            SELECT question, COUNT(*) as count
            FROM faq_interactions
            WHERE (feedback < 3 OR escalated = true)
            AND timestamp > NOW() - INTERVAL :days DAY
            GROUP BY question
            ORDER BY count DESC
            LIMIT 20
        """, {"days": period_days})

    def suggest_new_faq_entries(self) -> list:
        """Suggest new FAQ entries."""
        # Frequent well-resolved questions
        return self.db.query("""
            SELECT question, answer_preview, COUNT(*) as frequency
            FROM faq_interactions
            WHERE feedback >= 4
            AND escalated = false
            GROUP BY question, answer_preview
            HAVING COUNT(*) > 10
            ORDER BY frequency DESC
        """)

Related Resources

• E-commerce AI Chatbot - E-commerce pillar guide
• PrestaShop Automated Support - Support automation
• Introduction to RAG - Fundamentals
• RAG Prompt Engineering - Optimize prompts

---

Intelligent FAQ with Ailog

Transform your static FAQ into a dynamic assistant. With Ailog:

• Contextual answers: Adapted to product and customer
• Multi-source: FAQ + policies + catalog
• Smart suggestions: Predictive questions
• Built-in analytics: Identify gaps
• Zero maintenance: Automatic updates

Try Ailog for free and offer an FAQ that truly answers your customers' questions.