AI/CCAI & Advanced Features¶
Executive Summary¶
This chapter provides comprehensive design, implementation strategy, and operational guidance for AI-powered and advanced features in the KidsWear India Webex Contact Center deployment. While Chapter 4 (Platform Provisioning LLD) covered the "how to configure" mechanics, this chapter focuses on the "why, when, and design strategy" for leveraging Google Cloud Contact Center AI (CCAI), Vertex AI predictive routing, conversational AI, and mobile bot architectures.
Chapter Scope: - Dialogflow CX conversational AI design principles and best practices - Hybrid IVR strategy (DTMF + NLU) - UX design and business case - Vertex AI predictive routing model architecture and training methodology - Agent Assist implementation using RAG (Retrieval-Augmented Generation) - Real-time sentiment analysis with escalation triggers - Android bot SDK integration architecture - Scalability roadmap: 50 agents to 100+ agents
Target Audience: MSME technical teams, contact center managers, AI architects, CX strategists
Document Status: - Version: 1.0 - Date: March 2026 - Author: Rajmohan M, Principal Consultant (AI-assisted: Claude, Anthropic) - Classification: Internal Technical Documentation
1. AI Strategy & Business Case¶
1.1 Why AI for Contact Centers?¶
The MSME Contact Center Challenge:
Traditional contact centers face three critical challenges that AI addresses:
Challenge 1: Limited Agent Bandwidth - Problem: 50 agents handling 20-30 calls/hour = maximum 600-900 calls per day - AI Solution: Virtual agents handle 40-60% of routine inquiries - Impact: Agents focus on complex, high-value interactions
Challenge 2: Variable Customer Experience - Problem: Agent performance varies based on experience, training, mood - AI Solution: Consistent AI-powered assistance for all agents - Impact: Standardized quality regardless of agent tenure
Challenge 3: Scaling Costs - Problem: Traditional scaling = linear cost increase (more agents = more costs) - AI Solution: AI handles volume spikes without proportional cost increase - Impact: Better margins during peak seasons (e.g., Diwali, Back-to-School)
KidsWear India Business Case:
Current State (No AI):
├─ 50 agents @ ₹25,000/month = ₹1,250,000/month
├─ Average Handle Time (AHT): 8 minutes
├─ Call abandonment rate: 12% (customers hang up waiting)
└─ First Call Resolution (FCR): 68%
Target State (With AI):
├─ 50 agents + AI virtual agents
├─ 45% of routine calls handled by AI
├─ AHT reduced to 6 minutes (Agent Assist provides context)
├─ Call abandonment rate: 5%
├─ FCR improved to 85%
└─ Cost avoidance: No need to hire 22 additional agents
ROI Calculation:
Cost to implement AI:
├─ Dialogflow CX: ₹150,000/year
├─ Vertex AI: ₹80,000/year
├─ Development & training: ₹300,000 (one-time)
└─ Total Year 1: ₹530,000
Cost avoided:
├─ 22 agents not hired @ ₹25,000/month = ₹550,000/month
├─ Annual cost avoided: ₹6,600,000
└─ Net savings Year 1: ₹6,070,000
Payback Period: <1 month
5-Year NPV: ₹28.5 million
1.2 AI Maturity Model for KidsWear India¶
Phase 1: Foundation (Months 1-3) - CURRENT SCOPE
Focus: Basic automation + data collection
├─ Dialogflow CX virtual agent for order status, product inquiries
├─ Hybrid IVR (DTMF fallback for NLU failures)
├─ Sentiment analysis (real-time monitoring, no auto-actions)
├─ Data collection for Vertex AI model training
└─ Manual routing (agents manually select queue)
Metrics:
├─ AI containment rate: 35-40%
├─ Customer satisfaction (CSAT): Baseline measurement
└─ Agent satisfaction: Baseline survey
Phase 2: Intelligence (Months 4-9) - 6 MONTH PLAN
Focus: Predictive routing + proactive assistance
├─ Vertex AI predictive routing (trained on 6 months of data)
├─ Agent Assist with RAG (knowledge base suggestions)
├─ Automated sentiment-based escalation
├─ Android mobile app bot integration
└─ Personalized customer greetings based on CRM data
Metrics:
├─ AI containment rate: 50-55%
├─ CSAT improvement: +15%
├─ Agent efficiency: +25% (handle more calls with less effort)
└─ Average Speed to Answer (ASA): <20 seconds
Phase 3: Optimization (Months 10-18) - 12 MONTH PLAN
Focus: Advanced AI + multi-channel orchestration
├─ Voice biometrics for caller authentication
├─ Proactive outbound campaigns (order delays, product recalls)
├─ Multilingual NLU (English + Hindi + regional languages)
├─ Video chat with screen sharing
└─ Advanced analytics and BI dashboards
Metrics:
├─ AI containment rate: 60-65%
├─ FCR: 90%
├─ NPS improvement: +20 points
└─ Cost per contact reduced by 40%
1.3 Decision Framework: When to Use AI vs Human Agents¶
Use AI Virtual Agents For:
| Scenario | Why AI? | Example |
|---|---|---|
| Order status inquiries | Repetitive, data lookup only | "Where is order #12345?" |
| Product availability | Real-time inventory check | "Do you have size 6 shoes in stock?" |
| Return policy questions | Standard policy, no exceptions | "How do I return an item?" |
| Store hours/locations | Static information | "What time do you close?" |
| Account balance checks | Secure data retrieval | "What is my loyalty points balance?" |
| Simple troubleshooting | Guided step-by-step flows | "How do I reset my password?" |
Use Human Agents For:
| Scenario | Why Human? | Example |
|---|---|---|
| Complex complaints | Requires empathy, negotiation | "I received a damaged item and want compensation" |
| Policy exceptions | Judgment call needed | "Can you waive the return fee due to medical emergency?" |
| Escalated issues | Customer explicitly demands human | "I want to speak to a manager" |
| Emotional conversations | Requires emotional intelligence | Customer is crying, very upset |
| High-value transactions | Risk mitigation, fraud prevention | Bulk order of ₹100,000+ |
| Upsell/cross-sell opportunities | Requires persuasion, rapport | Customer buying entire wardrobe for wedding |
Hybrid Approach (AI Starts, Human Finishes):
| Scenario | AI Role | Human Role |
|---|---|---|
| Product recommendations | Gather preferences, filter options | Present final options, close sale |
| Order modifications | Verify customer identity, locate order | Authorize changes, process refund |
| Technical support | Tier 1 troubleshooting | Tier 2 complex issues |
| Appointment scheduling | Check availability, propose times | Confirm details, handle special requests |
2. Dialogflow CX Conversational AI Design¶
2.1 Dialogflow CX Architecture Overview¶
What is Dialogflow CX?
Dialogflow CX is Google's enterprise-grade conversational AI platform designed for complex, multi-turn conversations. Think of it as a virtual agent brain that understands natural language and maintains conversation context across multiple topics.
Key Differences: Dialogflow CX vs ES (Essentials)
| Feature | Dialogflow ES | Dialogflow CX | Why CX for KidsWear? |
|---|---|---|---|
| Conversation complexity | Simple, linear | Complex, multi-turn | Customers often ask multiple questions |
| State management | Limited | Advanced (flows, pages) | Handle order status + return policy in one conversation |
| Scalability | Small agents | Enterprise-scale | Designed for growth to 100+ agents |
| Versioning | Manual export/import | Built-in version control | Easier to test and deploy changes |
| Multi-channel | Basic | Native support | Website, Android app, WhatsApp, Voice |
| Analytics | Basic | Advanced insights | Better understanding of customer journeys |
| Pricing | Pay-per-request | Session-based | More cost-effective at scale |
Architectural Components:
┌─────────────────────────────────────────────────────────────┐
│ DIALOGFLOW CX AGENT │
│ (kidswear-virtual-agent) │
└─────────────────────────────────────────────────────────────┘
│
┌───────────────────┼───────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ FLOWS │ │ INTENTS │ │ ENTITIES │
│ │ │ │ │ │
│ ├─ Default │ │ ├─ Greeting │ │ ├─ @product │
│ ├─ Order │ │ ├─ OrderStat │ │ ├─ @order_id │
│ ├─ Product │ │ ├─ ProductInq│ │ ├─ @size │
│ ├─ Returns │ │ ├─ ReturnReq │ │ ├─ @color │
│ └─ Handoff │ │ └─ AgentReq │ │ └─ @category │
└──────────────┘ └──────────────┘ └──────────────┘
│ │ │
└───────────────────┼───────────────────┘
│
┌───────────────────┼───────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ WEBHOOKS │ │ FULFILLMENT│ │ RESPONSES │
│ │ │ │ │ │
│ ├─ Zendesk │ │ ├─ Static │ │ ├─ Text │
│ ├─ Inventory │ │ │ messages │ │ ├─ Rich cards│
│ ├─ Orders │ │ ├─ Dynamic │ │ ├─ Buttons │
│ └─ Payments │ │ └─ Webhook │ │ └─ Images │
└──────────────┘ └──────────────┘ └──────────────┘
2.2 Conversational Design Principles¶
Principle 1: Design for Conversation Repair
Users will make mistakes, change topics mid-conversation, or provide unclear input. Design for graceful recovery.
Bad Example:
User: "I want to return a dress"
Bot: "Please provide your order number"
User: "Actually, do you have it in size 8?"
Bot: "I don't understand. Please provide your order number."
[User gets frustrated, requests human agent]
Good Example (KidsWear Implementation):
User: "I want to return a dress"
Bot: "I can help with that! Let me pull up your recent orders. Can you provide your order number? If you don't have it handy, I can look it up by email or phone number."
User: "Actually, do you have it in size 8?"
Bot: "No problem! Let me help you check sizes. Are you asking about:
1. Checking if size 8 is available for a new purchase?
2. Exchanging your current dress for size 8?
Just let me know which one!"
User: "Exchange please"
Bot: "Got it! To process the exchange, I'll need your order number. You can find it in your order confirmation email or on your account page. What's your order number?"
Implementation in Dialogflow CX:
Flow: Returns
├─ Page: Return_Request_Entry
│ ├─ Intent route: product.inquiry → Transition to Product_Check page
│ └─ Parameter: $session.params.original_intent = "return"
│
└─ Page: Product_Check
├─ Entry fulfillment: "Are you looking to exchange or purchase?"
└─ Routes:
├─ "exchange" → Return to Return_Request_Entry with context
└─ "purchase" → Transition to Product_Flow
Principle 2: Progressive Information Gathering
Don't ask for all information upfront. Collect only what's needed at each step.
Bad Example:
Bot: "To help you, I need your order number, email, phone number, and reason for return."
[Overwhelming, customers abandon]
Good Example:
Bot: "Let's get started! What's your order number?"
[Gets order number]
Bot: "Perfect! I found order #12345 placed on Nov 10. You ordered:
- Blue dress (Size 6) - ₹1,299
- Pink shoes (Size 4) - ₹899
Which item would you like to return?"
[Gets item selection]
Bot: "Got it. May I ask the reason for return? This helps us improve."
[Optional field - conversation continues regardless]
Principle 3: Provide Context and Transparency
Users should always know what the bot is doing and why.
Implementation Examples:
| Stage | Without Context | With Context (Better) |
|---|---|---|
| Processing | [Silence for 3 seconds] | "Let me check our inventory system... one moment please." |
| Data retrieval | "Please wait" | "I'm pulling up your order details from our system. This usually takes 2-3 seconds." |
| Handoff | "Transferring to agent" | "I'm connecting you with our specialist team. They'll have full context of our conversation. Estimated wait time: 30 seconds." |
| Webhook failure | "Error occurred" | "I'm having trouble reaching our order system right now. Can I have an agent call you back in 10 minutes? Or would you prefer to try again?" |
2.3 Intent Design & Training Phrases¶
Intent Architecture for KidsWear India:
├─ GREETING INTENTS
│ ├─ greeting.hello → "Welcome to KidsWear India!"
│ ├─ greeting.goodbye → "Thank you for contacting us!"
│ └─ greeting.help → "I can help with orders, products, returns..."
│
├─ ORDER MANAGEMENT INTENTS
│ ├─ order.status → Check order delivery status
│ ├─ order.modify → Change order details
│ ├─ order.cancel → Cancel pending order
│ └─ order.track → Track shipment location
│
├─ PRODUCT INTENTS
│ ├─ product.inquiry → General product questions
│ ├─ product.availability → Check stock
│ ├─ product.price → Price information
│ ├─ product.size_guide → Size chart information
│ └─ product.recommendations → Product suggestions
│
├─ RETURNS & REFUNDS
│ ├─ return.policy → Return policy information
│ ├─ return.request → Initiate return
│ ├─ refund.status → Check refund status
│ └─ exchange.request → Exchange for different size/color
│
├─ ACCOUNT MANAGEMENT
│ ├─ account.balance → Loyalty points
│ ├─ account.password → Password reset
│ └─ account.address → Update shipping address
│
└─ HANDOFF INTENTS
├─ agent.request → "Talk to a human"
└─ escalation.complaint → Negative sentiment + complex issue
Training Phrase Best Practices:
1. Variation in Phrasing
Don't just add synonyms - capture real customer language patterns.
Poor Training Phrases:
Intent: order.status
- "What is my order status"
- "Order status"
- "Check order status"
[All too similar - AI won't generalize well]
Good Training Phrases:
Intent: order.status
- "Where is my order?"
- "I placed an order last week, has it shipped?"
- "Order 12345 status"
- "Did my kids' clothes arrive yet?"
- "Tracking number for my order"
- "When will I get my package?"
- "Is order #12345 delivered?"
- "Still waiting for my delivery from 5 days ago"
- "My order hasn't arrived, what's going on?"
- "Can you check if my shipment is on the way?"
[Covers: questions, statements, with/without order number, urgency, frustration]
2. Handle Hinglish (Hindi + English Mix)
Indian customers often mix languages. Train for this reality.
Intent: product.availability
English:
- "Do you have blue jeans in size 10?"
- "Is the red dress available?"
Hinglish:
- "Blue jeans size 10 hai kya?"
- "Red dress available hai?"
- "School uniform stock mein hai?"
- "Diwali collection aagaya?"
Pure Hindi:
- "क्या यह उपलब्ध है?"
- "मुझे साइज़ 8 चाहिए"
Implementation Note: Dialogflow CX supports language code hi-IN (Hindi) alongside en-IN (English-India). Configure your agent as multilingual with automatic language detection.
3. Account for Misspellings & Typos
Especially for mobile/chat interactions.
Intent: product.inquiry
- "shose for kids" [instead of "shoes"]
- "boys tshirt" [missing hyphen]
- "gil dress" [instead of "girl"]
- "schol uniform" [instead of "school"]
Dialogflow CX Fuzzy Matching: The advanced NLU model handles minor typos automatically, but adding a few common misspellings improves accuracy.
2.4 Entity Extraction & Slot Filling¶
What are Entities?
Entities are structured data extracted from user input (e.g., order numbers, product names, sizes, colors).
System Entities (Pre-built by Google):
| Entity Type | Use Case | Examples |
|---|---|---|
| @sys.number | Order numbers, quantities | "Order 12345", "I want 3 shirts" |
| @sys.date | Order dates, delivery dates | "November 15", "last Tuesday", "yesterday" |
| @sys.email | Customer email collection | "raj@kidswear.com" |
| @sys.phone-number | Contact number | "+91-9876543210", "9876543210" |
| @sys.color | Product color filtering | "blue", "red", "pink" |
| @sys.size | Clothing sizes | "size 8", "medium", "XL" |
Custom Entities (KidsWear-Specific):
Entity: @product_category
Values:
├─ Dresses [dresses, frock, gown]
├─ Shirts [shirt, t-shirt, tshirt, top]
├─ Pants [pants, trousers, jeans, bottoms]
├─ Shoes [shoes, footwear, sandals, sneakers]
├─ Uniform [school uniform, school dress, uniform]
└─ Accessories [accessories, cap, hat, belt, socks]
Entity: @age_group
Values:
├─ Infant [infant, baby, newborn, 0-12 months]
├─ Toddler [toddler, 1-3 years]
├─ Kids [kids, children, 4-8 years]
└─ Teens [teens, teenagers, 9-14 years]
Entity: @order_id (Regex Entity)
Pattern: ^KW[0-9]{6}$
Examples: KW123456, KW789012
Entity: @indian_states
Values:
├─ Maharashtra [maharashtra, MH, mumbai state]
├─ Karnataka [karnataka, KA, bangalore state]
├─ Tamil Nadu [tamil nadu, TN, chennai state]
[... all 28 states + 8 UTs]
Slot Filling Strategy:
Slot filling is the process of collecting all required parameters before completing a transaction.
Example: Order Cancellation Flow
Required Parameters:
├─ order_id (required)
├─ cancellation_reason (optional)
└─ confirmation (required)
Conversation Flow:
Bot: "I can help cancel your order. What's your order number?"
User: "KW123456"
[order_id parameter filled]
Bot: [Webhook to Zendesk - retrieves order details]
"I found your order KW123456 placed on Nov 18:
- Blue dress (Size 6) - ₹1,299
- Status: Processing
- Expected delivery: Nov 25
Are you sure you want to cancel this entire order? (Yes/No)"
User: "Yes"
[confirmation parameter filled]
Bot: [Optional slot filling]
"May I ask why you're canceling? This helps us improve.
1. Found better price
2. Changed mind
3. Ordered by mistake
4. Other reason
(Or say 'skip' to continue)"
User: "Changed mind"
[cancellation_reason parameter filled - optional]
Bot: [Webhook to Zendesk - processes cancellation]
"Your order KW123456 has been successfully canceled. You'll receive a full refund of ₹1,299 within 5-7 business days. Is there anything else I can help you with?"
Implementation in Dialogflow CX:
Page: Order_Cancellation
Form Parameters:
├─ order_id
│ ├─ Entity: @order_id
│ ├─ Required: true
│ └─ Prompt: "What's your order number?"
│
├─ confirmation
│ ├─ Entity: @sys.boolean
│ ├─ Required: true
│ └─ Prompt: "Are you sure you want to cancel order $session.params.order_id?"
│
└─ cancellation_reason
├─ Entity: @cancellation_reason
├─ Required: false
└─ Prompt: "May I ask why you're canceling? [Options] or say 'skip'"
Fulfillment:
├─ Webhook: POST /api/orders/cancel
│ └─ Payload: {"order_id": "$session.params.order_id", "reason": "$session.params.cancellation_reason"}
│
└─ Success Response:
"Your order $session.params.order_id has been canceled. Refund processed."
2.5 Multi-turn Conversations & Context Management¶
Challenge: Customers don't follow linear scripts. They jump between topics.
Example Multi-turn Conversation:
User: "Do you have school uniforms?"
Bot: "Yes! We have school uniforms for ages 4-14. What age group are you looking for?"
User: "Age 8"
Bot: "Great! Our age 8 school uniforms come in:
- White shirt + Navy pants: ₹899
- White shirt + Khaki pants: ₹899
- Full set (shirt + pant + tie): ₹1,299
Which one would you like to see?"
User: "Actually, where is my order from last week?"
[TOPIC SWITCH - from product inquiry to order status]
Bot: "No problem! Let me check your recent orders. What's your order number or email?"
User: "raj@example.com"
Bot: [Retrieves orders via webhook]
"I found order KW789456 placed on Nov 15:
- 2 x Blue t-shirts (Size 8) - ₹1,198
- Status: Shipped
- Tracking: DHL123456789
- Expected delivery: Nov 23
Your order is on the way! Meanwhile, were you still interested in the school uniform we were discussing?"
[CONTEXT PRESERVED - bot remembers earlier conversation]
User: "Yes, show me the full set"
Bot: "Here's the full school uniform set for age 8:
[Image of uniform]
- 1 White shirt
- 1 Navy pant
- 1 School tie
Price: ₹1,299
Available sizes: 6, 8, 10
Would you like to add this to your cart?"
How Context is Maintained:
Dialogflow CX uses session parameters to store conversation state.
Session Parameters During Conversation:
After "Do you have school uniforms?":
$session.params.current_flow = "product_inquiry"
$session.params.product_category = "uniform"
$session.params.age_group = "8"
After topic switch to order status:
$session.params.previous_flow = "product_inquiry"
$session.params.current_flow = "order_status"
$session.params.order_email = "raj@example.com"
$session.params.order_id = "KW789456"
[Product context still preserved]
After returning to product inquiry:
$session.params.current_flow = "product_inquiry"
$session.params.product_category = "uniform" [RESTORED]
$session.params.age_group = "8" [RESTORED]
$session.params.product_variant = "full_set" [NEW]
Best Practices for Context Management:
-
Store Important Context at Session Level
-
Set Context Lifespans
-
Handle Context Loss Gracefully
3. Hybrid IVR Design Strategy¶
3.1 DTMF vs NLU: Strategic Decision Framework¶
What's the Difference?
| Aspect | DTMF (Touch-tone) | NLU (Speech) | Hybrid Approach |
|---|---|---|---|
| User Input | Press 1, 2, 3... | Speak naturally | "Press or say..." |
| Accuracy | 100% (no errors) | 85-95% depending on noise, accent | Fallback to DTMF if NLU fails |
| User Experience | Requires menu navigation | Faster, more natural | Best of both worlds |
| Accessibility | Requires phone keypad | Works hands-free | Inclusive for all users |
| Cost | Low (no ASR/TTS costs) | Higher (Google Cloud Speech API) | Moderate |
| Implementation | Simple | Complex (requires training) | Medium complexity |
When to Use What:
DTMF-First Strategy:
Use Cases:
├─ High-noise environments (caller in market, traffic)
├─ Elderly users (may prefer familiar touch-tone)
├─ Users with thick accents (NLU may struggle)
├─ Security-sensitive input (credit card, OTP)
└─ Fallback when NLU confidence <50%
Example IVR Prompt:
"For order status, press 1 or say 'order status'.
For product inquiries, press 2 or say 'products'.
For returns, press 3 or say 'returns'."
NLU-First Strategy:
Use Cases:
├─ Young, tech-savvy users
├─ Complex queries (not easily mapped to menu)
├─ Hands-free scenarios (driving, cooking)
└─ Reducing customer effort
Example IVR Prompt:
"How can I help you today? You can say things like 'check order status', 'find a product', or 'speak to an agent'."
Hybrid Strategy (RECOMMENDED for KidsWear):
Implementation:
1. Prompt with both options: "Press or say..."
2. Detect which modality user prefers
3. Adapt conversation to that modality
4. Fallback to DTMF if NLU fails 2x
Example Flow:
Bot: "Press 1 or say 'order status' to check your order."
User: [Presses 1] → DTMF flow continues
OR
User: [Says "order status"] → NLU flow continues
OR
User: [Says unintelligible speech] → Bot: "Sorry, I didn't catch that. Please press 1 for order status, or 2 for product inquiries."
3.2 Conversation Design Patterns¶
Pattern 1: Menu-based (DTMF-Style)
Best for: Users who want structured options, low NLU confidence
IVR: "Welcome to KidsWear India. For order status, press 1.
For product inquiries, press 2. For returns, press 3.
To speak with an agent, press 0."
User: [Presses 1]
IVR: "Please enter your 6-digit order number, followed by the pound key."
User: [Enters 123456#]
IVR: [Webhook call to retrieve order]
"Your order 1-2-3-4-5-6 was placed on November 15 and is currently
in transit. Expected delivery is November 23. To track your shipment,
press 1. To speak with an agent, press 0. To return to the main menu,
press 9."
Pattern 2: Open-ended (NLU-Style)
Best for: Tech-savvy users, complex queries
IVR: "Welcome to KidsWear India. How can I help you today?"
User: "I want to return the blue dress I ordered last week"
IVR: [NLU extracts: intent=return, product=dress, color=blue]
"I can help with that return. Let me pull up your recent orders.
Can you provide your order number? If you don't have it handy,
I can look it up by your phone number."
User: "My number is 9876543210"
IVR: [Webhook retrieves orders by phone]
"I found 2 recent orders. Order 123456 has a blue dress size 6.
Order 789012 has pink shoes. Which order are you returning?"
User: "The first one"
IVR: "Got it. Order 1-2-3-4-5-6 with the blue dress. Our return policy
allows returns within 30 days. Would you like me to:
1. Email you a return shipping label, or
2. Schedule a pickup?
Just say 'email' or 'pickup'."
Pattern 3: Contextual Handoff
Best for: Escalations, complex issues
User: [Frustrated tone detected] "This is ridiculous! My order is 10 days late!"
IVR: [Sentiment analysis triggers special handling]
"I understand this is frustrating. Let me connect you with
a specialist who can help resolve this immediately. Please hold
for approximately 30 seconds. I'm also sending them your order
details so you don't have to repeat yourself."
[Transfers to queue with high priority]
[Agent screen pops with context:
- Order KW123456
- 10 days past expected delivery
- Sentiment: Negative/Urgent
- Previous IVR conversation transcript]
Agent: "Hi, this is Priya from KidsWear India. I can see your order
KW123456 is delayed. I sincerely apologize. I'm looking at it
right now - let me explain what happened and how we'll fix this..."
3.3 Error Handling & Conversation Repair¶
Principle: Fail Gracefully
Users will: - Provide unclear input - Change their mind mid-conversation - Say things the bot doesn't understand - Get frustrated
Design for these scenarios.
Error Handling Strategies:
Strategy 1: Clarification Questions
User: "I want to return it"
Bot: "Sure! Just to clarify, which order are you referring to?
You can provide the order number, or I can look it up."
User: "The dress"
Bot: "Got it - you want to return a dress. I found 3 orders with dresses:
Order 123456: Blue dress (Nov 10)
Order 234567: Red dress (Nov 5)
Order 345678: Pink dress (Nov 1)
Which one?"
Strategy 2: Fallback Paths
Bot: "What's your order number?"
User: [unintelligible]
Bot: "Sorry, I didn't catch that. Please say or enter your order number."
User: [unintelligible again]
Bot: "I'm having trouble hearing you. Let's try this instead.
I can look up your order by:
1. Email address - press or say 1
2. Phone number - press or say 2
3. Transfer to agent - press or say 0"
Strategy 3: Graceful Degradation
Attempt 1: Use advanced NLU
↓ (if confidence <50%)
Attempt 2: Offer multiple choice menu
↓ (if still fails)
Attempt 3: Switch to DTMF
↓ (if still fails)
Final: Transfer to human agent with context
Example Implementation:
Flow: Order_Status_Retrieval
Page: Get_Order_Number
├─ NLU Route: order.number intent
│ └─ Parameter: order_id (@order_id)
│
├─ DTMF Route: Collect 6 digits
│ └─ Parameter: order_id (@sys.number)
│
├─ No-input (5 seconds):
│ └─ Reprompt: "I didn't hear anything. Please say or enter your order number."
│ └─ Max retries: 2
│ └─ Escalate to: Fallback menu
│
├─ No-match (NLU confidence <50%):
│ └─ Reprompt: "Sorry, I didn't understand. Please clearly say your 6-digit order number, like 1-2-3-4-5-6."
│ └─ Max retries: 2
│ └─ Escalate to: Alternative lookup options
│
└─ Fallback Menu:
"Let's try a different way. I can find your order by:
- Press 1 for email lookup
- Press 2 for phone lookup
- Press 0 to speak with an agent"
3.4 Voice Biometrics & Security (Future Enhancement)¶
What is Voice Biometrics?
Voice biometrics analyzes unique vocal characteristics (pitch, tone, cadence) to verify caller identity - like a fingerprint, but for voice.
Use Cases for KidsWear India (Phase 3 - 12 Month Plan):
Scenario 1: Secure Account Access
Caller: "I want to check my order"
Bot: "For security, I'll verify your voice. Please say: 'My voice is my password'"
Caller: [Says passphrase]
Bot: [Google Cloud Speaker ID verifies voice print]
"Voice verified! Welcome back, Raj. I can see your recent orders..."
Scenario 2: Fraud Prevention
Caller: "I want to change the delivery address for order 123456"
Bot: [High-risk action detected - requires voice verification]
"To change delivery details, I need to verify it's really you.
Please say: 'I authorize this change'."
Caller: [Voice doesn't match account holder]
Bot: "I'm unable to verify your identity. For security, I'll need
to transfer you to our team with additional verification."
Implementation (Future):
Service: Google Cloud Speaker ID
├─ Training: Collect 10-15 seconds of customer speech during enrollment
├─ Verification: Match live speech to stored voiceprint
├─ Confidence threshold: >85% for authentication
└─ Cost: ~₹0.10 per verification (pay-per-use)
Integration with Dialogflow CX:
Webhook → POST https://cloud.google.com/speaker-id/verify
Request: {
"audioContent": "<base64 audio>",
"userId": "customer123",
"language": "en-IN"
}
Response: {
"verified": true,
"confidence": 0.92
}
4. Vertex AI Predictive Routing¶
4.1 Predictive Routing Overview¶
What is Predictive Routing?
Traditional routing: "Send call to next available agent in Sales queue" Predictive routing: "Send call to the agent most likely to resolve this customer's issue based on AI predictions"
Business Impact:
Traditional Routing:
├─ Random agent assignment
├─ FCR (First Call Resolution): 68%
├─ Average Handle Time (AHT): 8 minutes
├─ Customer satisfaction: 72%
└─ Agent utilization: Uneven (some agents overloaded, some idle)
With Predictive Routing:
├─ AI matches customer to best-fit agent
├─ FCR: 85% (+17%)
├─ AHT: 6.5 minutes (-18%)
├─ Customer satisfaction: 88% (+16%)
└─ Agent utilization: Balanced workload distribution
How It Works:
Step 1: Data Collection (Months 1-6)
Collect:
├─ Customer data (order history, past interactions, sentiment)
├─ Agent data (skills, performance, specialties)
├─ Interaction data (call outcomes, resolution times)
└─ Contextual data (time of day, queue wait time)
Step 2: Feature Engineering (Month 6)
Create features:
├─ Customer Tier (high-value = VIP, spent >₹50,000)
├─ Interaction Intent (from Dialogflow CX)
├─ Customer Sentiment (from real-time analysis)
├─ Agent Skill Match (product knowledge, language)
├─ Historical Success Rate (agent X with intent Y)
└─ Queue Metrics (current wait time, agent availability)
Step 3: Model Training (Month 7)
Algorithm: Gradient Boosting (XGBoost)
Objective: Maximize probability of FCR
Training data: 10,000+ historical interactions
Features: 25 variables
Target: Binary classification (resolved=1, not resolved=0)
Step 4: Deployment (Month 8)
Integration:
├─ Dialogflow CX extracts intent + sentiment
├─ Webex CC queries Vertex AI endpoint
├─ Model returns: Agent ID with highest match probability
├─ Call routed to predicted best agent
└─ Outcome logged for model retraining
4.2 Feature Engineering for Contact Centers¶
Key Features for Routing Decisions:
Category 1: Customer Features
| Feature | Description | Data Source | Example Values |
|---|---|---|---|
| customer_tier | VIP, Standard, New | Zendesk CRM | VIP (>₹50K spent), Standard (<₹50K), New |
| lifetime_value | Total revenue from customer | Zendesk | ₹125,000 |
| order_frequency | Orders per year | Zendesk | 12 orders/year |
| past_interactions | Number of previous contacts | Webex CC | 5 calls in last 6 months |
| sentiment_score | Current emotional state | Dialogflow CX | -0.8 (negative) to +0.8 (positive) |
| churn_risk | Likelihood to stop shopping | Predictive model | 0.3 (30% risk) |
Category 2: Interaction Features
| Feature | Description | Data Source | Example Values |
|---|---|---|---|
| intent | Detected customer intent | Dialogflow CX | order_status, product_inquiry, return |
| complexity | Simple vs complex issue | Intent mapping | Simple (info lookup), Complex (complaint) |
| language | Preferred language | IVR input | English, Hindi, Hinglish |
| channel | How customer contacted | Webex CC | Voice, Chat, WhatsApp, Email |
| time_of_day | When call came in | System clock | Morning (9-12), Afternoon (12-5), Evening (5-9) |
Category 3: Agent Features
| Feature | Description | Data Source | Example Values |
|---|---|---|---|
| skill_match | Agent expertise areas | Agent profile | Kids clothing, Returns specialist, VIP handler |
| agent_performance | Historical success rate | Webex CC analytics | FCR=92%, CSAT=4.8/5, AHT=5.2 min |
| current_occupancy | How busy agent is | Real-time metrics | 45% (low), 85% (optimal), 95% (overloaded) |
| language_proficiency | Languages agent speaks | Agent profile | English, Hindi, Tamil |
| customer_history | Past interactions with this customer | Webex CC | Agent Priya resolved this customer's issue last time |
Category 4: Contextual Features
| Feature | Description | Data Source | Example Values |
|---|---|---|---|
| queue_wait_time | Current wait time | Webex CC | 45 seconds |
| agents_available | How many agents free | Webex CC | 3 agents available in queue |
| day_of_week | When call occurred | System | Monday (post-weekend spike), Friday (pre-weekend) |
| seasonal_factor | Business seasonality | Calendar | Diwali season, Back-to-School, Normal |
Feature Engineering Example:
# Feature engineering for customer interaction
def engineer_features(customer_id, interaction_data):
features = {}
# Customer tier (business rule)
lifetime_value = get_customer_ltv(customer_id)
if lifetime_value > 50000:
features['customer_tier'] = 'VIP'
elif lifetime_value > 10000:
features['customer_tier'] = 'Standard'
else:
features['customer_tier'] = 'New'
# Intent complexity mapping
complex_intents = ['complaint', 'refund_dispute', 'fraud_claim']
features['interaction_complexity'] = 'Complex' if interaction_data['intent'] in complex_intents else 'Simple'
# Sentiment normalization (-1 to +1)
features['sentiment'] = interaction_data['sentiment_score'] / 100.0
# Time-based features
hour = datetime.now().hour
if 9 <= hour < 12:
features['time_period'] = 'Morning'
elif 12 <= hour < 17:
features['time_period'] = 'Afternoon'
else:
features['time_period'] = 'Evening'
# Historical success rate with specific agents
past_agents = get_past_agent_interactions(customer_id)
if past_agents:
features['preferred_agent'] = past_agents[0] # Agent who resolved last time
return features
4.3 Vertex AI Model Training Workflow¶
Step-by-Step Implementation:
Step 1: Prepare Training Data (Month 6)
# Sample training data structure (CSV format)
interaction_id,customer_tier,sentiment,intent,complexity,agent_skill,agent_experience,fcr_outcome
INT001,VIP,0.6,order_status,Simple,General,3_years,1
INT002,Standard,-0.4,complaint,Complex,Returns,5_years,1
INT003,New,0.2,product_inquiry,Simple,Products,1_year,0
INT004,VIP,-0.8,refund_dispute,Complex,VIP_Handler,7_years,1
...
[10,000+ rows of historical interaction data]
Target variable: fcr_outcome (1=resolved on first call, 0=not resolved)
Step 2: Upload Data to Google Cloud Storage
# Create GCS bucket for training data
gsutil mb -l asia-south1 gs://kidswear-vertex-ai/
# Upload training dataset
gsutil cp training_data.csv gs://kidswear-vertex-ai/data/training_data.csv
# Upload validation dataset (20% holdout)
gsutil cp validation_data.csv gs://kidswear-vertex-ai/data/validation_data.csv
Step 3: Create Vertex AI Dataset
# Using gcloud CLI
gcloud ai datasets create \
--region=asia-south1 \
--display-name=kidswear-routing-dataset \
--project=kidswear-ccai-prod
# Import data
gcloud ai datasets import-data \
kidswear-routing-dataset \
--gcs-source=gs://kidswear-vertex-ai/data/training_data.csv \
--import-schema-uri=gs://google-cloud-aiplatform/schema/dataset/ioformat/csv/1.0.0
Step 4: Train Custom Model (AutoML)
from google.cloud import aiplatform
# Initialize Vertex AI
aiplatform.init(
project='kidswear-ccai-prod',
location='asia-south1'
)
# Create AutoML Tabular training job
job = aiplatform.AutoMLTabularTrainingJob(
display_name='kidswear-routing-model-v1',
optimization_prediction_type='classification',
optimization_objective='maximize-au-prc', # Precision-Recall curve
column_specs={
'customer_tier': 'categorical',
'sentiment': 'numeric',
'intent': 'categorical',
'complexity': 'categorical',
'agent_skill': 'categorical',
'agent_experience': 'categorical',
'fcr_outcome': 'categorical' # Target
},
)
# Run training (takes 2-4 hours)
model = job.run(
dataset=dataset,
target_column='fcr_outcome',
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
budget_milli_node_hours=1000, # ~1 hour of training
model_display_name='kidswear-routing-model-v1',
)
print(f'Model resource name: {model.resource_name}')
Step 5: Evaluate Model Performance
# Get model evaluation metrics
evaluation = model.get_model_evaluation()
print('Model Evaluation Metrics:')
print(f' Precision: {evaluation.classification_metrics.precision}')
print(f' Recall: {evaluation.classification_metrics.recall}')
print(f' F1-Score: {evaluation.classification_metrics.f1_score}')
print(f' AUC-ROC: {evaluation.classification_metrics.au_roc}')
# Target metrics for production:
# Precision: >0.85 (avoid false positives - routing to wrong agent)
# Recall: >0.80 (catch most resolvable interactions)
# F1-Score: >0.82 (balance precision/recall)
Example Evaluation Results:
Confusion Matrix:
Predicted: Resolved Predicted: Not Resolved
Actual: Resolved 850 50
Actual: Not Resolved 30 70
Metrics:
├─ Precision: 0.87 (When model predicts resolved, it's correct 87% of time)
├─ Recall: 0.85 (Model catches 85% of resolvable interactions)
├─ F1-Score: 0.86 (Good balance)
├─ Accuracy: 0.92 (Overall correctness)
└─ AUC-ROC: 0.94 (Excellent discrimination between classes)
Step 6: Deploy Model to Endpoint
# Create endpoint
endpoint = aiplatform.Endpoint.create(
display_name='kidswear-routing-endpoint',
project='kidswear-ccai-prod',
location='asia-south1'
)
# Deploy model to endpoint
model.deploy(
endpoint=endpoint,
deployed_model_display_name='kidswear-routing-v1',
machine_type='n1-standard-4',
min_replica_count=1,
max_replica_count=3, # Auto-scale during peak
traffic_percentage=100
)
print(f'Endpoint: {endpoint.resource_name}')
print(f'Model deployed successfully!')
4.4 Real-Time Routing Integration¶
Integration Architecture:
┌──────────────────┐
│ Customer Call │
│ (Voice/Chat) │
└────────┬─────────┘
│
▼
┌──────────────────────────────┐
│ Webex Contact Center IVR │
│ (Dialogflow CX) │
│ │
│ ├─ Extract: Intent │
│ ├─ Analyze: Sentiment │
│ └─ Lookup: Customer Data │
└────────┬─────────────────────┘
│
▼
┌──────────────────────────────┐
│ Webex CC Flow Designer │
│ (HTTP Request Activity) │
│ │
│ POST /predict-best-agent │
└────────┬─────────────────────┘
│
▼
┌──────────────────────────────┐
│ Middleware API │
│ (Node.js/Python) │
│ │
│ ├─ Receive routing request │
│ ├─ Engineer features │
│ └─ Call Vertex AI endpoint │
└────────┬─────────────────────┘
│
▼
┌──────────────────────────────┐
│ Vertex AI Endpoint │
│ (Prediction Service) │
│ │
│ Input: {customer_tier, │
│ sentiment, intent} │
│ Output: {agent_id, │
│ confidence} │
└────────┬─────────────────────┘
│
▼
┌──────────────────────────────┐
│ Middleware Response │
│ │
│ Return: Best Agent ID + │
│ Queue Priority │
└────────┬─────────────────────┘
│
▼
┌──────────────────────────────┐
│ Webex CC Queue-to-Agent │
│ (Routing Decision) │
│ │
│ ├─ Route to Agent XYZ │
│ ├─ Priority: High │
│ └─ Screen pop: Context │
└──────────────────────────────┘
API Implementation (Middleware):
// middleware-api/routes/routing.js
const express = require('express');
const router = express.Router();
const { PredictionServiceClient } = require('@google-cloud/aiplatform');
// Initialize Vertex AI client
const client = new PredictionServiceClient({
apiEndpoint: 'asia-south1-aiplatform.googleapis.com',
keyFilename: '/path/to/service-account-key.json'
});
router.post('/predict-best-agent', async (req, res) => {
try {
const { customerId, intent, sentiment, complexity } = req.body;
// Step 1: Lookup customer data from Zendesk
const customer = await getCustomerData(customerId);
// Step 2: Get available agents with skills
const availableAgents = await getAvailableAgents();
// Step 3: Engineer features
const features = {
customer_tier: customer.tier,
sentiment: sentiment,
intent: intent,
complexity: complexity,
time_of_day: new Date().getHours(),
day_of_week: new Date().getDay()
};
// Step 4: Call Vertex AI for each available agent
const predictions = [];
for (const agent of availableAgents) {
const agentFeatures = {
...features,
agent_skill: agent.skills.join(','),
agent_experience: agent.yearsOfExperience,
agent_performance: agent.fcrRate
};
const prediction = await predict(agentFeatures);
predictions.push({
agentId: agent.id,
agentName: agent.name,
probability: prediction.probability,
confidence: prediction.confidence
});
}
// Step 5: Sort by probability and return top match
predictions.sort((a, b) => b.probability - a.probability);
const bestAgent = predictions[0];
// Step 6: Determine queue priority
let priority = 5; // Default
if (features.customer_tier === 'VIP') priority = 10;
if (features.sentiment < -0.5) priority += 3; // Escalate negative sentiment
// Return routing decision
res.json({
success: true,
routing: {
agentId: bestAgent.agentId,
agentName: bestAgent.agentName,
confidence: bestAgent.confidence,
queuePriority: priority,
allPredictions: predictions.slice(0, 3) // Top 3 for logging
}
});
} catch (error) {
console.error('Routing prediction error:', error);
// Fallback to traditional routing
res.json({
success: false,
error: error.message,
fallback: {
routingMethod: 'round-robin', // Use default routing
message: 'AI routing unavailable, using standard queue'
}
});
}
});
// Helper: Call Vertex AI prediction endpoint
async function predict(features) {
const endpoint = `projects/kidswear-ccai-prod/locations/asia-south1/endpoints/routing-endpoint-id`;
const instance = {
customer_tier: features.customer_tier,
sentiment: features.sentiment,
intent: features.intent,
// ... all features
};
const request = {
endpoint: endpoint,
instances: [instance]
};
const [response] = await client.predict(request);
return {
probability: response.predictions[0].scores[1], // Probability of FCR=1
confidence: response.predictions[0].scores[1] // Same as probability for binary classification
};
}
module.exports = router;
Webex CC Flow Designer Configuration:
HTTP Request Activity: Call Predictive Routing API
URL: https://middleware-api.kidswear.com/predict-best-agent
Method: POST
Headers:
Content-Type: application/json
Authorization: Bearer <API_KEY>
Request Body (JSON):
{
"customerId": "{{CustomerID}}",
"intent": "{{DialogflowIntent}}",
"sentiment": "{{SentimentScore}}",
"complexity": "{{InteractionComplexity}}"
}
Response Handling:
Parse JSON response → Variable: RoutingDecision
If success == true:
├─ Set Variable: BestAgentID = RoutingDecision.routing.agentId
├─ Set Variable: QueuePriority = RoutingDecision.routing.queuePriority
└─ Queue to Agent: BestAgentID with Priority: QueuePriority
Else:
└─ Queue to Agent: Next available (fallback)
4.5 Model Monitoring & Retraining¶
Why Monitoring Matters:
Models degrade over time as real-world data drifts from training data. Monitor and retrain regularly.
Key Metrics to Monitor:
Real-Time Metrics (Dashboard):
├─ Prediction latency: <200ms (user doesn't notice)
├─ API success rate: >99.5%
├─ Fallback rate: <5% (how often AI routing fails)
└─ Confidence distribution: Avg confidence >0.75
Weekly Business Metrics:
├─ FCR improvement: Baseline 68% → Target 85%
├─ AHT reduction: Baseline 8 min → Target 6.5 min
├─ CSAT improvement: Baseline 72% → Target 88%
└─ Agent utilization: More balanced workload
Monthly Model Performance:
├─ Prediction accuracy on new data
├─ Feature importance changes
└─ Concept drift detection
Retraining Schedule:
Trigger-Based Retraining:
├─ Weekly: If prediction accuracy drops below 80%
├─ Monthly: Routine retraining with new data
├─ Quarterly: Full model refresh + feature engineering review
└─ Ad-hoc: After major business changes (new product line, seasonal)
Retraining Process:
1. Collect new interaction data (last 3 months)
2. Merge with historical data (maintain 12 months rolling window)
3. Re-engineer features (check for new patterns)
4. Retrain model (AutoML or custom)
5. A/B test: Route 20% of traffic to new model, 80% to old
6. Compare performance for 1 week
7. If new model performs better (FCR +2%, AHT -5%), promote to 100%
8. Archive old model as rollback option
Example Monitoring Dashboard (Datadog / Stackdriver):
┌─────────────────────────────────────────────────────────────┐
│ KidsWear Predictive Routing - Real-Time Dashboard │
├─────────────────────────────────────────────────────────────┤
│ API Health: │
│ ├─ Requests/minute: 24 ✅ │
│ ├─ Success rate: 99.8% ✅ │
│ ├─ P95 latency: 142ms ✅ │
│ └─ Error rate: 0.2% ✅ │
├─────────────────────────────────────────────────────────────┤
│ Model Performance (Last 7 Days): │
│ ├─ Avg confidence: 0.82 ✅ │
│ ├─ FCR for AI-routed calls: 86% ✅ (+18% vs baseline) │
│ ├─ AHT for AI-routed calls: 6.3 min ✅ (-21% vs baseline) │
│ └─ CSAT for AI-routed calls: 4.6/5 ✅ (+0.8 vs baseline) │
├─────────────────────────────────────────────────────────────┤
│ Alerts: │
│ ⚠️ Fallback rate spiked to 8% at 14:30 (peak hour load) │
│ ✅ Auto-scaled to 3 prediction service instances │
└─────────────────────────────────────────────────────────────┘
5. Agent Assist with RAG¶
5.1 Agent Assist Overview¶
What is Agent Assist?
Agent Assist is a real-time AI copilot for contact center agents. It listens to customer conversations and suggests: - Relevant knowledge base articles - Recommended responses - Next-best-actions - Policy reminders - Compliance alerts
Business Impact:
Without Agent Assist:
├─ Agent searches knowledge base manually (20-40 seconds per lookup)
├─ Inconsistent responses (depends on agent memory)
├─ New agents struggle (learning curve = 3-6 months)
└─ Compliance risks (agents forget to mention return policy)
With Agent Assist:
├─ Suggestions appear automatically (instant)
├─ Consistent, accurate responses
├─ New agents productive in 2-4 weeks (AI guides them)
└─ Compliance built-in (AI flags required disclosures)
KPIs Improved:
├─ Average Handle Time: -15% (agents find answers faster)
├─ First Call Resolution: +12% (better information access)
├─ Agent satisfaction: +20% (less stress, more confident)
└─ Training costs: -30% (AI accelerates onboarding)
5.2 RAG (Retrieval-Augmented Generation) Architecture¶
What is RAG?
Traditional AI chatbots rely solely on training data (static knowledge). RAG-based systems retrieve relevant information from live knowledge bases before generating responses (dynamic knowledge).
Analogy: - Traditional AI = Student taking exam from memory - RAG-based AI = Student taking open-book exam (can reference textbooks)
RAG Components:
1. Knowledge Base (Vector Database)
├─ Product manuals
├─ Return policies
├─ FAQs
├─ Order processing procedures
└─ Past resolved tickets (with solutions)
2. Embedding Model (Text → Vectors)
├─ Converts text into numeric representations
├─ Example: "How do I return a dress?" → [0.23, -0.45, 0.67, ...]
└─ Google's text-embedding-004 model
3. Vector Search (Find Similar Content)
├─ Customer query: "Return policy for damaged items"
├─ Search vector database for similar content
└─ Return top 5 most relevant articles
4. LLM (Generate Response)
├─ Takes: Customer query + Retrieved articles
├─ Generates: Contextually relevant answer
└─ Gemini Pro or PaLM 2 model
RAG Flow for Agent Assist:
Customer: "I received a torn dress, how do I return it?"
Agent types: [waits for Agent Assist suggestion]
Step 1: Convert query to embedding
text-embedding-004("I received a torn dress, how do I return it?")
→ Vector: [0.23, -0.45, 0.67, 0.12, ...]
Step 2: Vector search in knowledge base
Query vector database for similar content
Results:
├─ Article #1: "Return Policy for Damaged Items" (similarity: 0.92)
├─ Article #2: "How to Request a Return" (similarity: 0.88)
├─ Article #3: "Quality Guarantee" (similarity: 0.85)
└─ [Top 5 articles retrieved]
Step 3: Generate response with LLM
Prompt to Gemini Pro:
"
Based on the following knowledge base articles:
[Article #1 content]
[Article #2 content]
[Article #3 content]
Customer question: I received a torn dress, how do I return it?
Provide a helpful, professional response for the agent to use.
"
Gemini Output:
"I'm sorry to hear about the damaged dress. We absolutely stand behind our quality. Here's what we can do:
1. You can return the damaged item for a full refund or exchange within 30 days.
2. No need to ship it back - we'll email you a prepaid return label within 2 hours.
3. Once we receive it, your refund will be processed in 5-7 business days.
Would you like me to email you the return label right now?"
Step 4: Agent Assist displays suggestion
Agent sees suggestion on screen, reviews it, and speaks to customer
(Agent can use as-is or modify based on conversation context)
5.3 Knowledge Base Design¶
Structure of Knowledge Base:
KidsWear India Knowledge Base
├─ Product Information (150 articles)
│ ├─ Size charts (by age, gender)
│ ├─ Product care instructions
│ ├─ Material specifications
│ └─ Stock availability (real-time API)
│
├─ Order Management (80 articles)
│ ├─ How to place an order
│ ├─ Order modification procedures
│ ├─ Order cancellation policy
│ └─ Payment methods accepted
│
├─ Shipping & Delivery (60 articles)
│ ├─ Delivery timelines by location
│ ├─ Shipping charges
│ ├─ Track order procedure
│ └─ Delivery partners (Delhivery, BlueDart)
│
├─ Returns & Refunds (100 articles)
│ ├─ Return policy (30-day window)
│ ├─ Damaged items process
│ ├─ Wrong size exchange
│ ├─ Refund timelines
│ └─ Return shipping label generation
│
├─ Account & Loyalty (40 articles)
│ ├─ Create account procedure
│ ├─ Loyalty points program
│ ├─ Password reset
│ └─ Update profile information
│
├─ Troubleshooting (50 articles)
│ ├─ Payment failed errors
│ ├─ OTP not received
│ ├─ Website issues
│ └─ App login problems
│
└─ Compliance & Legal (30 articles)
├─ Privacy policy
├─ Terms & conditions
├─ DPDP compliance statements
└─ PCI-DSS payment security
Article Format (Markdown):
# Return Policy for Damaged Items
**Policy ID:** RET-001
**Last Updated:** November 15, 2025
**Category:** Returns & Refunds
**Keywords:** damaged, defective, torn, broken, quality issue
## Overview
At KidsWear India, we stand behind the quality of our products. If you receive a damaged or defective item, we will provide a full refund or replacement at no cost to you.
## Eligibility
- Item received with visible damage (torn fabric, broken zippers, stains, etc.)
- Manufacturing defects (loose stitching, color bleeding)
- Wrong item shipped
- Missing parts/accessories
## Process
1. **Contact Us:** Call our support line or chat with us within 7 days of delivery
2. **Photo Evidence:** Email photos of the damage to returns@kidswear.com
3. **Return Label:** We'll email you a prepaid return shipping label within 2 hours
4. **Ship Back:** Pack the item securely and drop at any courier location
5. **Refund:** Once we receive and inspect, refund processed in 5-7 business days
## Important Notes
- No return shipping cost for damaged items (we cover it)
- Refund to original payment method
- If item is out of stock, we'll offer similar item or full refund
- For high-value orders (>₹10,000), we may arrange pickup instead of self-ship
## Script for Agents
"I'm so sorry about the damaged [item]. We absolutely stand behind our quality. I'll email you a prepaid return label right now - no cost to you. Once we get it back, full refund within 5-7 days. Can I have your email address?"
## Related Articles
- [How to Request a Return] (RET-002)
- [Refund Processing Timeline] (RET-005)
- [Quality Guarantee] (POL-003)
5.4 Implementation: Agent Assist with Google CCAI¶
Architecture:
┌──────────────────────────────────────────────────────────┐
│ Agent Desktop (Zendesk) │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Customer Interaction (Voice/Chat) │ │
│ └──────────────────┬─────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Agent Assist Sidebar (Iframe Widget) │ │
│ │ ├─ Real-time suggestions │ │
│ │ ├─ Knowledge articles │ │
│ │ └─ Recommended next steps │ │
│ └──────────────────┬─────────────────────────────────┘ │
└────────────────────┼──────────────────────────────────────┘
│
▼ WebSocket stream
┌──────────────────────────────────────────────────────────┐
│ Google Cloud Contact Center AI - Agent Assist │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Speech-to-Text (Real-time transcription) │ │
│ └──────────────────┬─────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Natural Language Understanding │ │
│ │ ├─ Extract intent │ │
│ │ ├─ Identify entities │ │
│ │ └─ Classify query type │ │
│ └──────────────────┬─────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Vector Search (Vertex AI Matching Engine) │ │
│ │ ├─ Convert query to embedding │ │
│ │ ├─ Search knowledge base vectors │ │
│ │ └─ Return top 5 relevant articles │ │
│ └──────────────────┬─────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Response Generation (Gemini Pro) │ │
│ │ ├─ Input: Query + Retrieved articles │ │
│ │ └─ Output: Suggested agent response │ │
│ └──────────────────┬─────────────────────────────────┘ │
└────────────────────┼──────────────────────────────────────┘
│
▼ Return suggestions
┌──────────────────────────────────────────────────────────┐
│ Agent Desktop - Displays Suggestions │
│ ┌────────────────────────────────────────────────────┐ │
│ │ 💡 Suggested Response: │ │
│ │ "I'm sorry about the damaged dress. We'll send...│ │
│ │ │ │
│ │ 📄 Related Articles: │ │
│ │ - Return Policy for Damaged Items │ │
│ │ - How to Request a Return │ │
│ │ │ │
│ │ ✅ Next Best Action: │ │
│ │ - Email return label to customer │ │
│ └────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────┘
Setup Steps:
Step 1: Create Knowledge Base in Cloud Storage
# Upload knowledge base articles to GCS
gsutil -m cp -r knowledge-base/* gs://kidswear-knowledge-base/articles/
# Articles should be in markdown or HTML format
# File naming convention: category-id-title.md
# Example: returns-001-damaged-items-policy.md
Step 2: Index Knowledge Base with Vertex AI
from google.cloud import discoveryengine
# Create Data Store for knowledge base
client = discoveryengine.DataStoreServiceClient()
data_store = discoveryengine.DataStore(
display_name="KidsWear Knowledge Base",
industry_vertical=discoveryengine.IndustryVertical.RETAIL,
solution_types=[discoveryengine.SolutionType.SOLUTION_TYPE_SEARCH],
content_config=discoveryengine.DataStore.ContentConfig.CONTENT_REQUIRED,
)
operation = client.create_data_store(
parent=f"projects/kidswear-ccai-prod/locations/asia-south1/collections/default_collection",
data_store=data_store,
data_store_id="kidswear-knowledge",
)
# Import documents from GCS
request = discoveryengine.ImportDocumentsRequest(
parent=data_store.name,
gcs_source=discoveryengine.GcsSource(
input_uris=["gs://kidswear-knowledge-base/articles/*.md"],
data_schema="content",
),
reconciliation_mode=discoveryengine.ImportDocumentsRequest.ReconciliationMode.INCREMENTAL,
)
operation = client.import_documents(request=request)
print("Indexing in progress... This may take 30-60 minutes for 500 articles")
Step 3: Configure Agent Assist in Dialogflow CX
Navigate: Dialogflow CX Console → Agent Settings
Enable Agent Assist:
├─ Conversation Profile: Create new profile
├─ Human Agent Assist: Enabled
├─ Data Store: kidswear-knowledge (from Step 2)
├─ Suggestion Trigger: real-time (every customer message)
├─ Max Suggestions: 3 per message
├─ Confidence Threshold: 0.7 (70% minimum confidence)
└─ Response Modes:
├─ Article Suggestion: Enabled (show relevant KB articles)
├─ Smart Reply: Enabled (generate suggested responses)
└─ FAQ Assist: Enabled (auto-detect FAQ questions)
Step 4: Integrate with Zendesk Agent Desktop
// zendesk-agent-assist-widget.js
class AgentAssistWidget {
constructor() {
this.conversationId = null;
this.webSocket = null;
this.initialize();
}
async initialize() {
// Create WebSocket connection to CCAI Agent Assist
this.webSocket = new WebSocket('wss://dialogflow.googleapis.com/v3/agent-assist');
this.webSocket.onopen = () => {
console.log('Agent Assist connected');
this.sendSessionConfig();
};
this.webSocket.onmessage = (event) => {
const suggestion = JSON.parse(event.data);
this.displaySuggestion(suggestion);
};
}
sendSessionConfig() {
const config = {
conversationProfile: 'projects/kidswear-ccai-prod/locations/asia-south1/conversationProfiles/agent-assist-profile',
queryParams: {
timeZone: 'Asia/Kolkata',
geoLocation: {
latitude: 18.5204,
longitude: 73.8567
}
}
};
this.webSocket.send(JSON.stringify(config));
}
// Called when agent types a message or customer speaks
async sendQuery(text) {
const request = {
queryInput: {
text: {
text: text,
languageCode: 'en-IN'
}
},
assistQueryParameters: {
documentsMetadataFilters: {
// Optional: filter to specific categories
category: 'returns'
}
}
};
this.webSocket.send(JSON.stringify(request));
}
displaySuggestion(suggestion) {
const suggestionPanel = document.getElementById('agent-assist-panel');
// Clear previous suggestions
suggestionPanel.innerHTML = '';
// Display article suggestions
if (suggestion.articleSuggestions && suggestion.articleSuggestions.length > 0) {
const articlesDiv = document.createElement('div');
articlesDiv.innerHTML = '<h4>📄 Relevant Articles</h4>';
suggestion.articleSuggestions.forEach(article => {
const articleCard = `
<div class="article-card" data-confidence="${article.answerRecord.confidenceScore}">
<h5>${article.title}</h5>
<p>${article.snippets[0].text.substring(0, 150)}...</p>
<button onclick="copyToResponse('${article.uri}')">Use This</button>
<button onclick="openArticle('${article.uri}')">View Full</button>
</div>
`;
articlesDiv.innerHTML += articleCard;
});
suggestionPanel.appendChild(articlesDiv);
}
// Display smart reply suggestions
if (suggestion.smartReplySuggestions && suggestion.smartReplySuggestions.length > 0) {
const repliesDiv = document.createElement('div');
repliesDiv.innerHTML = '<h4>💡 Suggested Responses</h4>';
suggestion.smartReplySuggestions.forEach(reply => {
const replyCard = `
<div class="reply-card">
<p>${reply.text}</p>
<button onclick="insertResponse('${reply.text}')">Insert</button>
</div>
`;
repliesDiv.innerHTML += replyCard;
});
suggestionPanel.appendChild(repliesDiv);
}
}
}
// Initialize on page load
const agentAssist = new AgentAssistWidget();
// Hook into Zendesk ticket updates
zendesk.on('ticket.conversation.updated', (event) => {
const latestMessage = event.conversation.messages[event.conversation.messages.length - 1];
agentAssist.sendQuery(latestMessage.text);
});
5.5 Agent Assist Best Practices¶
1. Suggestion Relevance
Not all suggestions are equally helpful. Filter and rank them.
Display Priority:
1. High confidence (>0.9) + Exact intent match → Bold, top of list
2. Medium confidence (0.7-0.9) + Related intent → Normal display
3. Low confidence (<0.7) → Don't show (noise)
Example:
Customer: "I want to return a damaged dress"
High Priority (Display first):
├─ Article: "Return Policy for Damaged Items" (confidence: 0.95) ✅
└─ Smart Reply: "I'm so sorry about the damage..." (confidence: 0.92) ✅
Medium Priority (Display second):
├─ Article: "How to Request a Return" (confidence: 0.83)
└─ Article: "Quality Guarantee" (confidence: 0.78)
Low Priority (Don't display):
├─ Article: "Shipping Policy" (confidence: 0.55) ❌
└─ Article: "Size Charts" (confidence: 0.42) ❌
2. Agent Training: Using Agent Assist Effectively
Agents need training on when to use suggestions vs their own knowledge.
Training Modules:
├─ Module 1: When to trust Agent Assist
│ ├─ Use for: Policy questions, procedural steps
│ ├─ Don't use for: Emotional responses, complex negotiations
│ └─ Always review before sending (don't copy-paste blindly)
│
├─ Module 2: How to adapt suggestions
│ ├─ Personalize: Add customer's name, order details
│ ├─ Adjust tone: Match customer's emotional state
│ └─ Combine: Merge multiple suggestions into one response
│
└─ Module 3: Providing feedback
├─ Thumbs up/down on suggestions (improves model)
├─ Report incorrect articles (for knowledge base updates)
└─ Suggest new content (fill knowledge gaps)
3. Knowledge Base Maintenance
RAG is only as good as the knowledge base. Keep it updated.
Maintenance Schedule:
├─ Daily: Monitor suggestion quality metrics
├─ Weekly: Review agent feedback on suggestions
├─ Monthly: Update articles based on new policies/products
└─ Quarterly: Audit entire knowledge base for outdated content
Update Triggers:
├─ Policy change → Update all affected articles within 24 hours
├─ New product launch → Add product FAQs before launch
├─ Seasonal → Update delivery timelines (Diwali rush, monsoon delays)
└─ Customer pain points → Create articles for recurring issues
Example Update:
Issue Detected:
Agents manually answering "Do you deliver to Ladakh?" 50+ times/week
No Agent Assist suggestions appearing
Resolution:
1. Create new article: "Delivery Coverage - Remote Areas" (geo-001-remote-delivery.md)
2. Include: Ladakh, Andaman, Lakshadweep, Northeast states
3. Add article to knowledge base
4. Re-index (takes 10 minutes)
5. Test Agent Assist → Now suggests this article ✅
Result:
├─ Agent Assist suggestion coverage: +12%
├─ AHT for geography questions: -30 seconds
└─ Agent satisfaction: "Finally, I don't have to remember all this!" 😊
6. Sentiment Analysis & Escalation¶
6.1 Real-Time Sentiment Analysis Overview¶
What is Sentiment Analysis?
Sentiment analysis uses AI to detect emotional tone in customer interactions (text or voice) and classify it as: - Positive (happy, satisfied) - Neutral (informational, factual) - Negative (frustrated, angry)
Why It Matters:
Without Sentiment Analysis:
├─ Agent doesn't notice escalating frustration
├─ Customer gets angrier, demands manager
├─ Call escalates to supervisor (wastes time + resources)
├─ Negative review posted online
└─ Potential customer churn
With Sentiment Analysis:
├─ AI detects frustration early (at 30 seconds into call)
├─ Alert sent to supervisor: "Customer upset on Line 3"
├─ Supervisor can whisper coaching to agent or join call
├─ Issue resolved before escalation
└─ Customer leaves satisfied (retention saved)
Business Impact for KidsWear India:
Metrics Improved:
├─ Customer escalations: -40% (catch issues early)
├─ Average Handle Time: -12% (resolve before spiraling)
├─ Customer satisfaction: +18% (empathetic responses)
└─ Supervisor efficiency: Focus on highest-risk calls only
Cost Savings:
├─ Reduced supervisor interventions: -35%
├─ Fewer refunds due to complaints: -₹200,000/year
├─ Improved retention: +5% customer lifetime value
└─ Total annual savings: ₹800,000
6.2 Sentiment Analysis Architecture¶
Components:
┌────────────────────────────────────────────────────────┐
│ Interaction Channel (Voice/Chat/Email) │
└──────────────────┬─────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────┐
│ Speech-to-Text (for voice) OR Text Extraction │
│ Google Cloud Speech-to-Text API │
│ ├─ Real-time transcription │
│ ├─ Language: en-IN (English-India) │
│ └─ Streaming: Yes (every 1-2 seconds) │
└──────────────────┬─────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────┐
│ Sentiment Analysis Engine │
│ Google Cloud Natural Language API │
│ ├─ Input: Transcribed text │
│ ├─ Output: Sentiment score (-1 to +1) │
│ │ Magnitude (0 to infinity - emotional intensity)│
│ └─ Latency: <100ms │
└──────────────────┬─────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────┐
│ Sentiment Classification & Alerting Logic │
│ (Middleware/Webex CC Flow) │
│ ├─ Score > +0.5 → Positive (green) │
│ ├─ Score -0.5 to +0.5 → Neutral (gray) │
│ ├─ Score < -0.5 → Negative (yellow alert) │
│ └─ Score < -0.7 + Magnitude > 2 → Critical (red alert)│
└──────────────────┬─────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────┐
│ Actions Based on Sentiment │
│ ├─ Update agent desktop (color indicator) │
│ ├─ Send supervisor alert (if critical) │
│ ├─ Trigger escalation workflow (auto-offer supervisor)│
│ ├─ Log to analytics (sentiment trends over time) │
│ └─ Adjust routing priority (negative = higher priority)│
└────────────────────────────────────────────────────────┘
6.3 Sentiment Scoring & Thresholds¶
Google Cloud Natural Language API Output:
{
"documentSentiment": {
"score": -0.8,
"magnitude": 3.5
},
"language": "en",
"sentences": [
{
"text": {
"content": "This is the third time I'm calling about this order!",
"beginOffset": 0
},
"sentiment": {
"score": -0.9,
"magnitude": 1.8
}
},
{
"text": {
"content": "Nobody is helping me, and I'm extremely frustrated.",
"beginOffset": 52
},
"sentiment": {
"score": -0.7,
"magnitude": 1.7
}
}
]
}
Understanding Scores:
| Metric | Range | Meaning |
|---|---|---|
| Score | -1.0 to +1.0 | Emotional polarity (negative to positive) |
| Magnitude | 0 to ∞ | Emotional intensity (how strong the emotion is) |
Examples:
| Text | Score | Magnitude | Interpretation |
|---|---|---|---|
| "Great product, love it!" | +0.9 | 0.9 | Strongly positive, moderate intensity |
| "Order delivered on time" | +0.3 | 0.3 | Mildly positive, low intensity (factual) |
| "Not sure if this is the right size" | 0.0 | 0.2 | Neutral, very low intensity |
| "I'm disappointed with the quality" | -0.6 | 0.8 | Negative, moderate intensity |
| "This is absolutely terrible! I'm furious!" | -0.9 | 2.5 | Strongly negative, HIGH intensity ⚠️ |
KidsWear India Sentiment Thresholds:
Classification Rules:
📗 Positive (Green):
├─ Score: > +0.5
├─ Action: None (continue normal flow)
└─ Example: "Thank you so much for the fast delivery!"
⬜ Neutral (Gray):
├─ Score: -0.5 to +0.5
├─ Action: None (informational conversation)
└─ Example: "What is your return policy?"
📙 Negative (Yellow Alert):
├─ Score: -0.5 to -0.7
├─ OR Magnitude: > 2.0 (even if score is neutral)
├─ Action:
│ ├─ Display yellow indicator on agent screen
│ ├─ Suggest empathy phrases to agent
│ └─ Log as at-risk interaction
└─ Example: "I'm not happy with the delivery delay"
📕 Critical (Red Alert):
├─ Score: < -0.7
├─ AND Magnitude: > 2.5 (high emotional intensity)
├─ Action:
│ ├─ Display red flashing indicator
│ ├─ Send real-time alert to supervisor
│ ├─ Offer immediate escalation option
│ ├─ Increase queue priority to 10 (highest)
│ └─ Auto-log as "escalation prevented" case
└─ Example: "This is ridiculous! I want my money back NOW!"
6.4 Escalation Workflows¶
Escalation Trigger Conditions:
Auto-Escalation Triggers (Present to Customer):
Trigger 1: Critical Sentiment Detected
IF sentiment_score < -0.7 AND magnitude > 2.5
THEN:
Agent Script: "I can hear this is frustrating. Would you like me to
connect you with my manager who can help resolve this
immediately?"
Trigger 2: Repeated Issue
IF customer_id IN (past_interactions)
AND current_intent == past_intent
AND past_resolution == "unresolved"
THEN:
Agent Script: "I see this is a recurring issue. Let me get my supervisor
involved right away to ensure we solve this for you."
Trigger 3: High-Value Customer + Negative Sentiment
IF customer_tier == "VIP" AND sentiment_score < -0.5
THEN:
Agent Script: "As a valued customer, I want to make sure this gets resolved
to your satisfaction. May I have my supervisor join us?"
Trigger 4: Explicit Request
IF intent == "speak_to_manager" OR "escalate"
THEN:
Agent Script: "Absolutely, let me connect you with a supervisor right away.
Please hold for just a moment."
Supervisor Alert Dashboard:
Real-Time Supervisor Dashboard (Webex CC Supervisor Desktop):
┌───────────────────────────────────────────────────────────┐
│ 🚨 ESCALATION ALERTS (Real-Time) │
├───────────────────────────────────────────────────────────┤
│ │
│ 🔴 CRITICAL - Agent: Priya (Line 3) │
│ ├─ Customer: Rajesh Kumar (VIP) │
│ ├─ Sentiment: -0.85 (High negative, intensity: 3.2) │
│ ├─ Issue: "Order delayed 10 days, demanding refund" │
│ ├─ Duration: 2:15 minutes │
│ └─ Actions: [BARGE IN] [WHISPER] [VIEW TRANSCRIPT] │
│ │
│ 🟡 WARNING - Agent: Amit (Line 7) │
│ ├─ Customer: Sneha Patel (Standard) │
│ ├─ Sentiment: -0.62 (Moderate negative, intensity: 1.8) │
│ ├─ Issue: "Wrong size shipped" │
│ ├─ Duration: 1:30 minutes │
│ └─ Actions: [MONITOR] [WHISPER] [VIEW TRANSCRIPT] │
│ │
│ 🟢 POSITIVE - Agent: Kavita (Line 12) │
│ ├─ Customer: Arjun Reddy (New) │
│ ├─ Sentiment: +0.75 (Positive, intensity: 1.2) │
│ ├─ Issue: "Product inquiry - considering purchase" │
│ ├─ Actions: [MONITOR] (Possible upsell opportunity) │
│ │
├───────────────────────────────────────────────────────────┤
│ 📊 SENTIMENT TRENDS (Last Hour) │
│ ├─ Total Interactions: 124 │
│ ├─ Positive: 62 (50%) │
│ ├─ Neutral: 48 (39%) │
│ ├─ Negative: 14 (11%) │
│ └─ Critical Escalations: 2 (1.6%) │
└───────────────────────────────────────────────────────────┘
Supervisor Actions:
Action 1: Whisper Coaching (Supervisor → Agent, customer can't hear)
Supervisor: "Priya, I can see customer is upset. Acknowledge frustration first,
then offer expedited shipping + 20% discount. I'm here if you need me."
Action 2: Barge In (Supervisor joins call)
Supervisor: "Hi Mr. Kumar, this is Rakesh, the supervisor. I've reviewed your
case and I sincerely apologize for the delay. Here's what we'll do..."
Action 3: Silent Monitoring (Learn for training)
Supervisor: [Listens to call, takes notes for agent coaching session later]
6.5 Implementation Example¶
Webex CC Flow Designer Integration:
Activity: HTTP Request - Sentiment Analysis
Trigger: Every 10 seconds during active call
URL: https://language.googleapis.com/v1/documents:analyzeSentiment
Method: POST
Headers:
Authorization: Bearer <GCP_SERVICE_ACCOUNT_TOKEN>
Content-Type: application/json
Request Body:
{
"document": {
"type": "PLAIN_TEXT",
"content": "{{TranscriptLast30Seconds}}",
"language": "en"
},
"encodingType": "UTF8"
}
Response Handling:
Parse JSON → Variables:
├─ SentimentScore = response.documentSentiment.score
├─ SentimentMagnitude = response.documentSentiment.magnitude
└─ SentimentCategory =
IF SentimentScore > 0.5 THEN "positive"
ELSE IF SentimentScore < -0.7 AND SentimentMagnitude > 2.5 THEN "critical"
ELSE IF SentimentScore < -0.5 THEN "negative"
ELSE "neutral"
Conditional Routing:
IF SentimentCategory == "critical":
├─ Set Priority: 10 (highest)
├─ Send Supervisor Alert (Webhook to supervisor dashboard)
├─ Play to Agent: "Customer sentiment critical - offer escalation"
└─ Log Event: "escalation_opportunity"
ELSE IF SentimentCategory == "negative":
├─ Set Priority: 7
├─ Display Yellow Indicator on Agent Screen
└─ Log Event: "negative_sentiment_detected"
ELSE:
└─ Continue normal flow
Agent Desktop Display (Real-Time Sentiment Indicator):
Zendesk Agent Desktop - Sidebar Widget:
┌──────────────────────────────────────┐
│ 💬 Live Sentiment Monitor │
├──────────────────────────────────────┤
│ │
│ Current Sentiment: 🔴 CRITICAL │
│ Score: -0.82 │
│ Intensity: 3.1 (High) │
│ │
│ 🚨 Supervisor alerted │
│ │
│ 💡 Suggested Actions: │
│ ├─ Acknowledge frustration │
│ ├─ Apologize sincerely │
│ ├─ Offer immediate solution │
│ └─ [ESCALATE TO SUPERVISOR] │
│ │
│ 📈 Sentiment History (This Call): │
│ ├─ 0:00-1:00 🟢 +0.3 (Started okay)│
│ ├─ 1:00-2:00 🟡 -0.2 (Turned sour) │
│ └─ 2:00-now 🔴 -0.8 (Critical) │
└──────────────────────────────────────┘
7. Android Bot Architecture¶
7.1 Mobile Bot Overview¶
Why Mobile Chatbot?
Indian consumers are mobile-first (80%+ of e-commerce traffic from mobile). Offering in-app chatbot support improves customer experience and drives conversions.
KidsWear India Mobile App Use Cases:
Use Case 1: Pre-Purchase Support
Scenario: Customer browsing products in app
Bot: "Hi! 👋 Looking for something specific? I can help you find the perfect outfit!"
Customer: "School uniform for 8-year-old"
Bot: [Shows product carousel with images]
"Here are our top 3 school uniforms for 8-year-olds.
Tap any to view details or add to cart. 🛒"
Use Case 2: Order Tracking
Scenario: Customer opens app, has pending order
Bot: [Proactive notification]
"Your order #KW123456 shipped yesterday! 📦
Track it here: [Track Order Button]"
Customer: [Taps button]
Bot: [Opens map with real-time tracking]
"Your package is currently in Mumbai. Expected delivery: Nov 23"
Use Case 3: Quick Reorder
Scenario: Customer previously bought item
Bot: "Hi [Name]! Ready to reorder your favorite blue dress (Size 6)?
[REORDER NOW - ₹1,299]"
Customer: [Taps button]
Bot: "Added to cart! Proceed to checkout?"
Use Case 4: Return Initiation
Scenario: Customer wants to return item
Customer: "I want to return the pink shoes"
Bot: [Looks up recent orders]
"Found it! Order #KW789456 - Pink shoes (Size 4).
Why are you returning?
- Wrong size
- Didn't like
- Damaged
- Other"
Customer: [Selects "Wrong size"]
Bot: "No problem! Return label sent to your email.
Need a different size instead? We have sizes 3, 5, 6 in stock."
7.2 Architecture Components¶
High-Level Architecture:
┌──────────────────────────────────────────────────────────┐
│ KidsWear India Android App (Kotlin/Java) │
│ ├─ E-commerce screens (Products, Cart, Orders) │
│ └─ Chatbot UI (Floating button + Full-screen chat) │
└──────────────────┬───────────────────────────────────────┘
│
│ Kommunicate SDK / Custom Integration
▼
┌──────────────────────────────────────────────────────────┐
│ Dialogflow CX Agent (Same as Web/Voice) │
│ ├─ Intents: order_status, product_inquiry, returns │
│ ├─ Entities: @product, @order_id, @size │
│ └─ Webhooks: Zendesk, Inventory, Orders APIs │
└──────────────────┬───────────────────────────────────────┘
│
│ Webhook Calls
▼
┌──────────────────────────────────────────────────────────┐
│ Backend APIs (Node.js/Python) │
│ ├─ Zendesk CRM: Customer data, order history │
│ ├─ Inventory API: Real-time stock availability │
│ ├─ Orders API: Track shipments, process returns │
│ └─ Payments API: Refund processing │
└──────────────────────────────────────────────────────────┘
Mobile-Specific Features:
Feature 1: Rich Media Support
├─ Image carousels (product photos)
├─ Quick reply buttons ("Yes", "No", "Maybe")
├─ Action buttons ("Add to Cart", "Track Order")
└─ Embedded links (deep links to app screens)
Feature 2: Push Notifications
├─ Order shipped notifications → Opens chat with tracking
├─ Abandoned cart reminders → "Still thinking about those shoes?"
├─ Flash sale alerts → "30% off kids dresses - 2 hours only!"
└─ Reorder suggestions → "Time to restock school uniforms?"
Feature 3: Context Awareness
├─ Current screen: If user on product page, bot suggests that product
├─ Cart contents: Bot knows what's in cart, can answer questions
├─ Past orders: Bot suggests reorders, tracks deliveries
└─ User preferences: Remembers size, color preferences
Feature 4: Offline Support
├─ Queue messages when offline (send when back online)
├─ Cached FAQs (basic questions work offline)
└─ Sync conversation history across devices
7.3 Implementation: Kommunicate SDK Integration¶
Option 1: Kommunicate SDK (Recommended for Speed)
Kommunicate is a pre-built Android SDK that integrates with Dialogflow CX and provides a ready-to-use chat UI.
Step 1: Add Dependency to build.gradle
// app/build.gradle
dependencies {
implementation 'io.kommunicate:kommunicate:2.5.0'
// Additional dependencies
implementation 'com.google.android.gms:play-services-location:21.0.1'
implementation 'androidx.appcompat:appcompat:1.6.1'
}
Step 2: Initialize SDK in Application Class
// KidsWearApplication.kt
import android.app.Application
import io.kommunicate.Kommunicate
import io.kommunicate.callbacks.KmCallback
class KidsWearApplication : Application() {
override fun onCreate() {
super.onCreate()
// Initialize Kommunicate with App ID
Kommunicate.init(this, "KOMMUNICATE_APP_ID")
}
}
Step 3: Configure Dialogflow Bot
// MainActivity.kt
import io.kommunicate.users.KMUser
import io.kommunicate.Kommunicate
import io.kommunicate.callbacks.KmCallback
import io.kommunicate.models.KmBotModel
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
// Configure user with customer data
val user = KMUser().apply {
userId = getCurrentCustomerId() // From your app's auth system
displayName = getCustomerName()
email = getCustomerEmail()
contactNumber = getCustomerPhone()
// Custom metadata for personalization
metadata = hashMapOf(
"customer_tier" to "VIP",
"total_orders" to "12",
"last_order_date" to "2025-11-15"
)
}
// Configure bot
val botList = arrayListOf("kidswear-dialogflow-bot")
val botModel = KmBotModel().apply {
botName = "KidsWear Assistant"
botIcon = R.drawable.bot_avatar
botColor = "#FF6B35" // KidsWear brand color
}
// Launch chat
Kommunicate.launchConversation(this, botList, user, object : KmCallback {
override fun onSuccess(message: Any?) {
Log.d("ChatBot", "Chat launched successfully")
}
override fun onFailure(error: Any?) {
Log.e("ChatBot", "Failed to launch chat: $error")
Toast.makeText(this@MainActivity, "Unable to open chat. Please try again.", Toast.LENGTH_SHORT).show()
}
})
}
}
Step 4: Add Floating Chat Button
// Add to activity_main.xml
<com.google.android.material.floatingactionbutton.FloatingActionButton
android:id="@+id/fabChat"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="bottom|end"
android:layout_margin="16dp"
android:src="@drawable/ic_chat"
android:contentDescription="@string/chat_with_support"
app:backgroundTint="@color/brand_primary" />
// MainActivity.kt
fabChat.setOnClickListener {
Kommunicate.openConversation(this, object : KmCallback {
override fun onSuccess(message: Any?) {
// Chat opened
}
override fun onFailure(error: Any?) {
Toast.makeText(this@MainActivity, "Chat unavailable", Toast.LENGTH_SHORT).show()
}
})
}
Step 5: Deep Linking from Chat to App Screens
// Handle custom actions from Dialogflow (e.g., "View Product")
// In your Dialogflow webhook response:
{
"fulfillmentMessages": [
{
"payload": {
"action": "view_product",
"productId": "12345"
}
}
]
}
// In Android app - listen for custom payloads:
Kommunicate.setWebhookListener(object : KommunicateWebhookListener {
override fun onWebhookCall(payload: String) {
val json = JSONObject(payload)
when (json.getString("action")) {
"view_product" -> {
val productId = json.getString("productId")
openProductScreen(productId)
}
"track_order" -> {
val orderId = json.getString("orderId")
openOrderTrackingScreen(orderId)
}
"add_to_cart" -> {
val productId = json.getString("productId")
val quantity = json.getInt("quantity")
addToCart(productId, quantity)
Toast.makeText(this, "Added to cart!", Toast.LENGTH_SHORT).show()
}
}
}
})
fun openProductScreen(productId: String) {
val intent = Intent(this, ProductDetailActivity::class.java).apply {
putExtra("PRODUCT_ID", productId)
}
startActivity(intent)
}
7.4 Advanced Features¶
Feature 1: Proactive Notifications
// Send proactive message when order ships
fun sendOrderShippedNotification(orderId: String, trackingNumber: String) {
val message = "Your order $orderId has shipped! Track it here: [Track Order]"
Kommunicate.sendMessage(
userId = getCurrentCustomerId(),
message = message,
metadata = hashMapOf(
"action" to "track_order",
"tracking_number" to trackingNumber
)
)
}
Feature 2: In-App Notifications with Chat Context
// Show notification, open chat to specific context when tapped
fun showCartAbandonmentNotification() {
val notificationBuilder = NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.ic_notification)
.setContentTitle("Still thinking about your cart?")
.setContentText("Complete your order and get 10% off!")
.setPriority(NotificationCompat.PRIORITY_HIGH)
.setContentIntent(createChatPendingIntent("abandoned_cart"))
.setAutoCancel(true)
notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build())
}
fun createChatPendingIntent(context: String): PendingIntent {
val intent = Intent(this, MainActivity::class.java).apply {
putExtra("OPEN_CHAT", true)
putExtra("CHAT_CONTEXT", context) // Pre-fill chat with context
}
return PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT)
}
Feature 3: Voice Input Support
// Enable voice input in chat
Kommunicate.setVoiceInputEnabled(true)
// User can tap microphone icon and speak their query
// Speech-to-text handled by Google, sent to Dialogflow CX
8. Future Roadmap: Scaling to 100+ Agents¶
8.1 Growth Projections¶
Business Growth Scenario:
Current State (Year 1):
├─ 50 agents (20 concurrent)
├─ 20-30 calls/hour
├─ 500-750 calls/day
├─ Single location (Pune office)
└─ Revenue: ₹15 crore/year
3-Year Growth Target:
├─ 100+ agents (50 concurrent)
├─ 60-100 calls/hour
├─ 1,500-2,500 calls/day
├─ Multi-location (Pune + Bangalore)
└─ Revenue: ₹50 crore/year (3.3x growth)
Drivers of Growth:
├─ Geographic expansion (5 new cities)
├─ Product line expansion (adult wear, accessories)
├─ Omnichannel push (WhatsApp, Instagram, Facebook)
└─ Seasonal spikes (Diwali, Back-to-School)
8.2 Infrastructure Scaling Plan¶
Phase 1: Current Setup (0-50 Agents)
Infrastructure:
├─ Webex Contact Center: 50 Premium Agent licenses
├─ Webex Calling: Cloud Connect (India DCs)
├─ Dialogflow CX: 50 concurrent sessions
├─ Vertex AI: 1 endpoint, 1-3 replicas
└─ Agent Assist: Enabled for all agents
Costs:
├─ Webex CC: ~₹8,000/agent/month
├─ Dialogflow CX: ~₹0.007/request
├─ Vertex AI: ~₹80,000/year
└─ Total: ~₹5.5 lakhs/month
Phase 2: Medium Growth (51-75 Agents)
Changes Required:
1. Increase Licenses:
├─ Add 25 Webex CC agent licenses
└─ Add 25 Dialogflow CX concurrent sessions
2. Geographic Redundancy:
├─ Deploy Webex POP in Mumbai (redundant to Pune)
└─ Ensures <10ms latency for all India locations
3. Queue Optimization:
├─ Split queues by geography (North/South/East/West)
├─ Implement skill-based routing (Products, Returns, VIP)
└─ Hire specialized agents (language: Tamil, Telugu, Bengali)
4. Vertex AI Scaling:
├─ Increase to 3-5 prediction endpoint replicas
├─ Enable auto-scaling (scales to 10 during peak)
└─ Implement model A/B testing framework
Costs:
├─ Incremental: ₹2.5 lakhs/month
└─ Total: ₹8 lakhs/month
Phase 3: Major Growth (76-100+ Agents)
Infrastructure Changes:
1. Multi-Site Architecture:
├─ Primary site: Pune (60 agents)
├─ Secondary site: Bangalore (40 agents)
└─ Disaster recovery: Mumbai (standby)
2. Advanced Routing:
├─ Predictive routing for ALL interactions (not just 80%)
├─ Dynamic skill tagging (agents cross-trained)
├─ Workforce Management (WFM) integration
│ ├─ Automatic scheduling based on forecasted volume
│ └─ Real-time adherence monitoring
3. AI Enhancements:
├─ Voice biometrics for secure authentication
├─ Proactive outbound campaigns (order delays, restocks)
├─ Multilingual NLU (English, Hindi, 5 regional languages)
└─ Video chat with screen sharing
4. Observability & Monitoring:
├─ Comprehensive dashboards (Datadog, Grafana)
├─ Real-time alerting (PagerDuty integration)
├─ SLA monitoring (99.9% uptime target)
└─ Cost tracking per interaction
Costs:
├─ Incremental: ₹4 lakhs/month
└─ Total: ₹12 lakhs/month
8.3 Technology Upgrades Roadmap¶
Year 1 (Months 1-12) - Foundation:
Q1 (Months 1-3):
✅ Deploy 50-agent Webex CC with Dialogflow CX
✅ Implement hybrid IVR (DTMF + NLU)
✅ Enable sentiment analysis (monitoring only)
✅ Launch Android mobile bot
Q2 (Months 4-6):
📌 Train Vertex AI predictive routing model (6 months data)
📌 Implement Agent Assist with RAG
📌 Enable automated sentiment-based escalation
📌 Add WhatsApp channel integration
Q3 (Months 7-9):
📌 Deploy predictive routing to 80% of traffic
📌 Launch WFO (Quality Management + Recording)
📌 Implement advanced analytics dashboards
📌 Add multilingual support (Hindi + English)
Q4 (Months 10-12):
📌 Optimize AI models (retrain with full year data)
📌 Launch voice biometrics (pilot with VIP customers)
📌 Implement proactive outreach (order delays)
📌 Add 3 regional languages (Tamil, Telugu, Kannada)
Year 2 (Months 13-24) - Growth:
Q1 (Year 2):
├─ Scale to 75 agents
├─ Open Bangalore office (15 agents)
├─ Implement Workforce Management (WFM)
└─ Launch video chat channel
Q2:
├─ Add Instagram/Facebook Messenger channels
├─ Implement AI-powered workforce scheduling
├─ Deploy advanced speech analytics
└─ Launch customer journey analytics
Q3:
├─ Scale to 100 agents
├─ Full multilingual support (8 languages)
├─ Implement real-time quality scoring
└─ Launch agent gamification platform
Q4:
├─ Deploy voice of customer (VoC) analytics
├─ Implement predictive CSAT scoring
├─ Launch agent self-service knowledge portal
└─ Year-end optimization (cost reduction initiatives)
Year 3 (Months 25-36) - Optimization:
Q1:
├─ Scale to 120+ agents (handle 3x volume)
├─ Full AI-driven scheduling (WFM + forecasting)
├─ Implement autonomous agent coaching (AI recommends training)
└─ Launch customer self-service portal (80% deflection target)
Q2:
├─ Deploy edge computing for ultra-low latency
├─ Implement blockchain for secure payment authentication
├─ Launch AR/VR product visualization in chat
└─ Integrate with supply chain for real-time inventory
Q3:
├─ Implement emotional AI (beyond sentiment - detect empathy)
├─ Launch generative AI for email responses (auto-draft)
├─ Deploy AI-powered fraud detection
└─ Full omnichannel orchestration (seamless channel switching)
Q4:
├─ Achieve 95% AI containment rate (only 5% need humans)
├─ Deploy quantum-safe encryption (future-proofing)
├─ Launch predictive customer lifetime value (CLV) model
└─ Vision: Fully autonomous contact center (humans supervise AI)
8.4 KPI Evolution¶
Current State KPIs (0-6 Months):
| Metric | Baseline | Target | How to Improve |
|---|---|---|---|
| FCR | 68% | 75% | Agent training + AI knowledge base |
| AHT | 8 min | 7 min | Agent Assist reduces search time |
| CSAT | 72% | 80% | Sentiment-based coaching |
| AI Containment | 0% | 35% | Dialogflow CX virtual agent |
| Agent Utilization | Uneven | 70-80% | Predictive routing balances load |
Mid-Term KPIs (6-18 Months):
| Metric | Target | How to Achieve |
|---|---|---|
| FCR | 85% | Predictive routing + Agent Assist RAG |
| AHT | 6 min | Voice biometrics (faster auth) + better knowledge |
| CSAT | 88% | Proactive issue resolution + empathy training |
| AI Containment | 55% | Advanced conversational flows + personalization |
| Cost per Contact | -20% | Higher AI containment = fewer agent minutes |
Long-Term KPIs (18-36 Months):
| Metric | Target | How to Achieve |
|---|---|---|
| FCR | 90% | AI predicts issues before customer aware |
| AHT | 5 min | Full AI assist + voice biometrics |
| CSAT | 92% | Proactive + predictive CX |
| AI Containment | 65% | Generative AI handles complex queries |
| NPS | +30 | World-class CX drives loyalty |
| Agent Attrition | <10%/year | AI reduces stress, better work-life balance |
9. Appendices¶
Appendix A: Dialogflow CX Training Phrase Examples¶
Complete training phrase sets for top 10 intents:
(See separate file: appendix-a-training-phrases.md)
Appendix B: Vertex AI Feature Engineering Code¶
Python scripts for feature engineering and model training:
(See separate file: appendix-b-vertex-ai-code.md)
Appendix C: Sentiment Analysis Webhook Implementation¶
Complete webhook code for real-time sentiment analysis:
(See separate file: appendix-c-sentiment-webhook.md)
Appendix D: Android Bot Integration Code¶
Complete Kotlin code for mobile bot integration:
(See separate file: appendix-d-android-bot-code.md)
Appendix E: Glossary of AI/CCAI Terms¶
AI/ML: Artificial Intelligence / Machine Learning AHT: Average Handle Time ASR: Automatic Speech Recognition CSAT: Customer Satisfaction Score DTMF: Dual-Tone Multi-Frequency (touch-tone input) FCR: First Call Resolution LLM: Large Language Model NLU: Natural Language Understanding NPS: Net Promoter Score RAG: Retrieval-Augmented Generation TTS: Text-to-Speech VoC: Voice of Customer