Add 899999999999999999999999999999

CONVERSATIONAL_ENHANCEMENT.md

@@ -0,0 +1,197 @@
+# 🎯 Conversational Voice Bot Enhancement
+
+## Problem Identified
+Your friend's voice bot is **conversational and interactive** - when it doesn't understand context, it asks for more information instead of giving generic responses. Your current bot gives generic answers even when the query is unclear.
+
+## 🚀 Conversational Features Implemented
+
+### 1. **Smart Clarity Detection** (`conversational_service.py`)
+The bot now analyzes queries and detects when they need clarification:
+
+```python
+# Examples of queries that trigger clarification:
+"pension" → "What specifically about pension?"
+"what" → "Could you be more specific?"
+"help" → "What topic can I help you with?"
+```
+
+### 2. **Context-Aware Clarification Questions**
+Different types of unclear queries get different clarification approaches:
+
+#### **Vague Pension Queries:**
+```
+User: "pension"
+Bot: "I can help with pension-related questions! To give you the most accurate information, could you specify:
+
+📋 What specifically about pension?
+• How to calculate pension amount?
+• Pension eligibility criteria?
+• How to apply for pension?
+• Family pension benefits?
+• Commutation of pension?
+• Required documents for pension?"
+```
+
+#### **Generic Procurement Queries:**
+```
+User: "tender"
+Bot: "I can help with procurement and tendering! To provide the right information, could you clarify:
+
+🏢 What specifically about procurement?
+• How to participate in tenders?
+• Procurement rules and thresholds?
+• GeM portal registration?
+• MSME benefits in procurement?
+
+Are you a vendor looking to participate, or an officer managing procurement?"
+```
+
+### 3. **Follow-Up Context Handling**
+The bot remembers clarification requests and uses enhanced queries:
+
+```python
+# Original unclear query: "pension"
+# User clarification: "calculation"
+# Enhanced query: "pension calculation formula amount computation"
+```
+
+### 4. **Conversational Response Enhancement**
+Responses now include encouraging follow-up questions:
+
+```
+"Here's the pension calculation formula...
+
+Is there anything specific about this topic you'd like me to explain further?"
+```
+
+## 🎯 Enhanced User Experience
+
+### **Before (Generic Responses):**
+```
+User: "What about pension?"
+Bot: [Returns random training/salary information] ❌
+```
+
+### **After (Conversational Interaction):**
+```
+User: "What about pension?"
+Bot: "I can help with pension-related questions! To give you the most accurate information, could you specify:
+
+📋 What specifically about pension?
+• How to calculate pension amount?
+• Pension eligibility criteria? 
+• How to apply for pension?
+• Family pension benefits?
+
+Please let me know which aspect interests you most!" ✅
+
+User: "How to calculate"
+Bot: "Here's the pension calculation formula:
+(Last drawn basic pay + DA) × service years ÷ 70
+
+The minimum pension is ₹9,000 per month...
+
+Would you like me to walk through a specific calculation example?" ✅
+```
+
+## 🔧 Technical Implementation
+
+### **1. Query Clarity Analysis**
+```python
+def analyze_query_clarity(query, search_results):
+    # Detects vague patterns
+    # Checks pension/procurement ambiguity
+    # Analyzes search result relevance
+    # Returns clarification questions if needed
+```
+
+### **2. Enhanced WebSocket Handler**
+```python
+# Before processing search results, check for clarity
+conversational_analysis = conversational_service.generate_conversational_response(
+    user_message, docs, session_id
+)
+
+if conversational_analysis['needs_clarification']:
+    # Send clarification request instead of generic response
+    return clarification_response
+```
+
+### **3. Frontend Clarification Handling**
+```javascript
+// Handle clarification requests in frontend
+if (msg.type === "streaming_response" && msg.needs_clarification) {
+    // Display clarification questions
+    // Keep mic active for user response
+    // Mark as clarification in conversation history
+}
+```
+
+### **4. Session Management**
+```python
+# Remember conversation context
+conversation_history[session_id] = {
+    'last_query': query,
+    'awaiting_clarification': True,
+    'clarification_type': 'pension_generic'
+}
+```
+
+## 🎯 Specific Improvements
+
+### **1. Vague Query Detection**
+- ✅ Single word queries: "pension", "tender", "help"
+- ✅ Too generic: "what", "how", "tell me about"
+- ✅ Unclear pronouns: "this", "that", "it"
+
+### **2. Domain-Specific Clarification**
+- ✅ **Pension queries**: Asks about calculation, eligibility, application, etc.
+- ✅ **Procurement queries**: Asks about vendor vs officer role, specific process
+- ✅ **Finance queries**: Asks about budget, approval, audit context
+
+### **3. Conversational Flow**
+- ✅ **Friendly tone**: "I'd be happy to help!"
+- ✅ **Structured options**: Bullet-pointed choices
+- ✅ **Follow-up encouragement**: "Please let me know..."
+- ✅ **Context retention**: Remembers what user is asking about
+
+### **4. Enhanced Search Integration**
+- ��� **Low relevance detection**: Asks for clarification when search results don't match
+- ✅ **Enhanced follow-up queries**: Combines original + clarification
+- ✅ **Better document targeting**: Uses improved search terms
+
+## 🎉 Expected Results
+
+Your voice bot will now behave like your friend's bot:
+
+1. **🤔 Asks for clarification** when queries are unclear
+2. **💬 Provides structured options** for user to choose from
+3. **🔄 Remembers context** from clarification requests
+4. **✅ Gives precise answers** after understanding intent
+5. **🎯 Encourages conversation** with follow-up questions
+
+## 📋 Testing the Enhancement
+
+Try these scenarios:
+
+### **Scenario 1: Vague Query**
+```
+Say: "pension"
+Expected: Bot asks for specific pension topic
+```
+
+### **Scenario 2: Follow-up**
+```
+Say: "pension"
+Bot: "What specifically about pension?"
+Say: "calculation"
+Expected: Bot gives pension calculation details
+```
+
+### **Scenario 3: Unclear Context**
+```
+Say: "what"
+Expected: Bot asks what topic you want help with
+```
+
+Your voice bot is now **conversational and interactive** just like your friend's! 🎉

app.py

@@ -8,6 +8,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, FileResponse
 from websocket_handler import handle_websocket_connection
 from enhanced_websocket_handler import handle_enhanced_websocket_connection
+from conversational_websocket_handler import handle_conversational_websocket
 from hybrid_llm_service import HybridLLMService
 from voice_service import VoiceService
 from groq_voice_service import groq_voice_service  # Import the new Groq voice service
@@ -257,6 +258,14 @@ async def websocket_stream_endpoint(websocket: WebSocket):
     finally:
         await groq_websocket_handler.disconnect(session_id)
 
+@app.websocket("/ws/conversational")
+async def websocket_conversational_endpoint(websocket: WebSocket):
+    """
+    Enhanced Conversational WebSocket endpoint with session memory and personalization
+    Based on friend's conversational implementation for better user experience
+    """
+    await handle_conversational_websocket(websocket)
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

conversational_audio_service.py

@@ -0,0 +1,194 @@
+"""
+Enhanced Audio Services for Conversational Voice Bot
+Based on friend's implementation with Murf TTS and Groq ASR
+"""
+from groq import AsyncGroq
+from config import GROQ_API_KEY, MURF_API_KEY
+import asyncio
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+# Initialize Groq client
+groq_client = AsyncGroq(api_key=GROQ_API_KEY)
+
+# Initialize Murf client
+try:
+    from murf import AsyncMurf
+    murf_client = AsyncMurf(api_key=MURF_API_KEY)
+    MURF_AVAILABLE = True
+except ImportError:
+    logger.warning("Murf package not available. Install with: pip install murf")
+    MURF_AVAILABLE = False
+
+def clean_markdown_for_tts(text: str) -> str:
+    """
+    Clean markdown and formatting from text to make it suitable for TTS
+    """
+    if not text:
+        return ""
+    
+    # Remove markdown links [text](url) -> text
+    text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)
+    
+    # Remove markdown emphasis **bold** and *italic* -> text
+    text = re.sub(r'\*\*([^\*]+)\*\*', r'\1', text)
+    text = re.sub(r'\*([^\*]+)\*', r'\1', text)
+    
+    # Remove markdown headers ### -> 
+    text = re.sub(r'^#+\s*', '', text, flags=re.MULTILINE)
+    
+    # Remove code blocks ```code``` -> code
+    text = re.sub(r'```[^`]*```', '', text)
+    text = re.sub(r'`([^`]+)`', r'\1', text)
+    
+    # Remove HTML tags
+    text = re.sub(r'<[^>]+>', '', text)
+    
+    # Clean up bullet points and lists
+    text = re.sub(r'^\s*[-\*\+]\s*', '', text, flags=re.MULTILINE)
+    text = re.sub(r'^\s*\d+\.\s*', '', text, flags=re.MULTILINE)
+    
+    # Remove extra whitespace and line breaks
+    text = re.sub(r'\n\s*\n', '. ', text)
+    text = re.sub(r'\s+', ' ', text)
+    
+    # Remove special characters that TTS might struggle with
+    text = re.sub(r'[#\*_~`]', '', text)
+    
+    return text.strip()
+
+async def groq_asr_bytes(audio_bytes: bytes, model: str = "whisper-large-v3", language: str = "en") -> str:
+    """
+    Transcribe audio using Groq Whisper ASR
+    Enhanced version similar to friend's implementation
+    """
+    try:
+        logger.info(f"🎤 Transcribing audio with Groq ASR (model: {model}, language: {language})")
+        
+        # Groq client is async, so we can use it directly
+        response = await groq_client.audio.transcriptions.create(
+            model=model,
+            file=("audio.wav", audio_bytes, "audio/wav"),
+            response_format="text",
+            language=language,
+            temperature=0.0  # For more consistent results
+        )
+        
+        transcription = response.strip() if response else ""
+        logger.info(f"🎯 Transcription result: {transcription}")
+        
+        return transcription
+        
+    except Exception as e:
+        logger.error(f"❌ Groq ASR failed: {e}")
+        return ""
+
+async def murf_tts(text: str, voice_id: str = "en-IN-isha", format: str = "MP3") -> bytes:
+    """
+    Convert text to speech using Murf TTS
+    Enhanced version similar to friend's implementation
+    """
+    if not MURF_AVAILABLE:
+        logger.error("❌ Murf TTS not available")
+        return b""
+    
+    if not text or not text.strip():
+        logger.warning("⚠️ Empty text provided to TTS")
+        return b""
+    
+    try:
+        # Clean text for TTS
+        clean_text = clean_markdown_for_tts(text)
+        if not clean_text:
+            logger.warning("⚠️ Text became empty after cleaning")
+            return b""
+        
+        logger.info(f"🔊 Generating speech with Murf TTS (voice: {voice_id})")
+        logger.debug(f"TTS text: {clean_text}")
+        
+        # Generate speech using async streaming
+        response = murf_client.text_to_speech.stream(
+            text=clean_text,
+            voice_id=voice_id,
+            format=format,
+            sample_rate=44100.0
+        )
+        
+        # Collect all chunks
+        chunks = [chunk async for chunk in response]
+        full_audio = b''.join(chunks)
+        
+        logger.info(f"✅ Generated {len(full_audio)} bytes of audio")
+        return full_audio
+        
+    except Exception as e:
+        logger.error(f"❌ Murf TTS failed: {e}")
+        return b""
+
+async def edge_tts_fallback(text: str, voice: str = "en-IN-Neerja") -> bytes:
+    """
+    Fallback TTS using edge-tts if Murf is not available
+    """
+    try:
+        import edge_tts
+        
+        clean_text = clean_markdown_for_tts(text)
+        if not clean_text:
+            return b""
+        
+        logger.info(f"🔊 Using Edge TTS fallback (voice: {voice})")
+        
+        communicate = edge_tts.Communicate(clean_text, voice)
+        audio_chunks = []
+        
+        async for chunk in communicate.stream():
+            if chunk["type"] == "audio":
+                audio_chunks.append(chunk["data"])
+        
+        audio_data = b"".join(audio_chunks)
+        logger.info(f"✅ Generated {len(audio_data)} bytes of audio with Edge TTS")
+        return audio_data
+        
+    except ImportError:
+        logger.error("❌ Edge TTS not available. Install with: pip install edge-tts")
+        return b""
+    except Exception as e:
+        logger.error(f"❌ Edge TTS failed: {e}")
+        return b""
+
+class ConversationalAudioService:
+    """
+    Main audio service class for conversational voice bot
+    """
+    
+    def __init__(self):
+        self.groq_client = groq_client
+        self.murf_available = MURF_AVAILABLE
+        self.default_voice = "en-IN-isha"  # Indian English voice
+        
+    async def transcribe_audio(self, audio_bytes: bytes, language: str = "en") -> str:
+        """Transcribe audio to text using Groq ASR"""
+        return await groq_asr_bytes(audio_bytes, language=language)
+    
+    async def synthesize_speech(self, text: str, voice_id: str = None) -> bytes:
+        """Convert text to speech using best available TTS"""
+        voice = voice_id or self.default_voice
+        
+        if self.murf_available:
+            # Try Murf TTS first
+            audio = await murf_tts(text, voice_id=voice)
+            if audio:
+                return audio
+        
+        # Fallback to Edge TTS
+        return await edge_tts_fallback(text, voice="en-IN-Neerja")
+    
+    def set_default_voice(self, voice_id: str):
+        """Set default voice for TTS"""
+        self.default_voice = voice_id
+        logger.info(f"🎵 Default voice set to: {voice_id}")
+
+# Global audio service instance
+conversational_audio_service = ConversationalAudioService()

conversational_service.py

@@ -0,0 +1,332 @@
+"""
+Conversational Voice Bot Service
+Makes the bot more interactive by asking for clarification when context is unclear
+"""
+
+import logging
+from typing import Dict, Any, List, Optional
+import re
+
+logger = logging.getLogger("voicebot")
+
+class ConversationalService:
+    def __init__(self):
+        self.conversation_history = {}
+        
+    def analyze_query_clarity(self, query: str, search_results: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Analyze if the query is clear enough or needs clarification
+        Returns clarification questions if needed
+        """
+        query_lower = query.lower().strip()
+        
+        # Remove filler words
+        filler_words = ['um', 'uh', 'like', 'you know', 'actually', 'basically']
+        clean_query = query_lower
+        for filler in filler_words:
+            clean_query = clean_query.replace(filler, '')
+        
+        clarity_analysis = {
+            'is_clear': True,
+            'confidence': 1.0,
+            'clarification_needed': False,
+            'clarification_questions': [],
+            'suggested_responses': [],
+            'query_type': 'specific'
+        }
+        
+        # Check for vague queries
+        vague_patterns = [
+            r'\b(what|how|tell me|explain)\s+(about|regarding)?\s*$',
+            r'^(help|info|information)$',
+            r'^(what|how)$',
+            r'\b(anything|something|stuff)\b',
+            r'^(yes|no|okay|ok)$',
+            r'\b(this|that|it)\b.*\?$'
+        ]
+        
+        is_vague = any(re.search(pattern, clean_query) for pattern in vague_patterns)
+        
+        # Check for ambiguous pension queries
+        if 'pension' in query_lower:
+            pension_ambiguity = self._check_pension_ambiguity(query_lower)
+            if pension_ambiguity['needs_clarification']:
+                clarity_analysis.update(pension_ambiguity)
+                return clarity_analysis
+        
+        # Check for ambiguous procurement queries
+        elif any(word in query_lower for word in ['tender', 'procurement', 'bid']):
+            procurement_ambiguity = self._check_procurement_ambiguity(query_lower)
+            if procurement_ambiguity['needs_clarification']:
+                clarity_analysis.update(procurement_ambiguity)
+                return clarity_analysis
+        
+        # Check for too generic queries
+        elif is_vague or len(clean_query.split()) <= 2:
+            clarity_analysis.update({
+                'is_clear': False,
+                'confidence': 0.3,
+                'clarification_needed': True,
+                'query_type': 'vague',
+                'clarification_questions': [
+                    "I'd be happy to help! Could you be more specific about what you're looking for?",
+                    "Are you asking about:",
+                    "• Pension rules and benefits?",
+                    "• Leave policies and applications?", 
+                    "• Procurement and tender processes?",
+                    "• Salary and allowances?",
+                    "• Or something else?"
+                ],
+                'suggested_responses': [
+                    "Please let me know which topic interests you most, and I'll provide detailed information."
+                ]
+            })
+            return clarity_analysis
+        
+        # Check if search results are relevant
+        if search_results:
+            relevance_score = self._calculate_relevance_score(query_lower, search_results)
+            if relevance_score < 0.3:  # Low relevance
+                clarity_analysis.update({
+                    'is_clear': False,
+                    'confidence': relevance_score,
+                    'clarification_needed': True,
+                    'query_type': 'low_relevance',
+                    'clarification_questions': [
+                        f"I found some information, but I want to make sure I understand your question correctly.",
+                        f"When you asked '{query}', did you mean:",
+                        "• Something specific about government policies?",
+                        "• A particular process or procedure?",
+                        "• Information for a specific situation?",
+                        "",
+                        "Could you provide a bit more context about what you're trying to accomplish?"
+                    ]
+                })
+        
+        return clarity_analysis
+    
+    def _check_pension_ambiguity(self, query: str) -> Dict[str, Any]:
+        """Check if pension query needs clarification"""
+        
+        # Specific pension queries that are clear
+        clear_pension_terms = [
+            'pension calculation', 'pension formula', 'pension eligibility', 
+            'pension application', 'family pension', 'commutation', 
+            'pension documents', 'pension process'
+        ]
+        
+        if any(term in query for term in clear_pension_terms):
+            return {'needs_clarification': False}
+        
+        # Generic pension queries that need clarification
+        generic_pension_patterns = [
+            r'^pension\??$',
+            r'^what.*pension\??$',
+            r'^tell me.*pension\??$',
+            r'^pension.*rules?\??$',
+            r'^how.*pension\??$'
+        ]
+        
+        if any(re.search(pattern, query) for pattern in generic_pension_patterns):
+            return {
+                'needs_clarification': True,
+                'is_clear': False,
+                'confidence': 0.4,
+                'clarification_needed': True,
+                'query_type': 'pension_generic',
+                'clarification_questions': [
+                    "I can help with pension-related questions! To give you the most accurate information, could you specify:",
+                    "",
+                    "📋 **What specifically about pension?**",
+                    "• How to calculate pension amount?",
+                    "• Pension eligibility criteria?", 
+                    "• How to apply for pension?",
+                    "• Family pension benefits?",
+                    "• Commutation of pension?",
+                    "• Required documents for pension?",
+                    "",
+                    "Or do you have a specific pension situation you need help with?"
+                ],
+                'suggested_responses': [
+                    "Please let me know which aspect of pension you're interested in, and I'll provide detailed guidance."
+                ]
+            }
+        
+        return {'needs_clarification': False}
+    
+    def _check_procurement_ambiguity(self, query: str) -> Dict[str, Any]:
+        """Check if procurement query needs clarification"""
+        
+        clear_procurement_terms = [
+            'tender process', 'bid submission', 'gem portal', 'msme benefits',
+            'vendor registration', 'procurement threshold', 'tender documents'
+        ]
+        
+        if any(term in query for term in clear_procurement_terms):
+            return {'needs_clarification': False}
+        
+        generic_procurement_patterns = [
+            r'^tender\??$',
+            r'^procurement\??$', 
+            r'^bid\??$',
+            r'^what.*tender\??$',
+            r'^how.*procurement\??$'
+        ]
+        
+        if any(re.search(pattern, query) for pattern in generic_procurement_patterns):
+            return {
+                'needs_clarification': True,
+                'is_clear': False,
+                'confidence': 0.4,
+                'clarification_needed': True,
+                'query_type': 'procurement_generic',
+                'clarification_questions': [
+                    "I can help with procurement and tendering! To provide the right information, could you clarify:",
+                    "",
+                    "🏢 **What specifically about procurement?**",
+                    "• How to participate in tenders?",
+                    "• Procurement rules and thresholds?",
+                    "• GeM portal registration?",
+                    "• MSME benefits in procurement?",
+                    "• Vendor empanelment process?",
+                    "• Bid preparation and submission?",
+                    "",
+                    "Are you a vendor looking to participate, or an officer managing procurement?"
+                ],
+                'suggested_responses': [
+                    "Please specify your role and what aspect of procurement you need help with."
+                ]
+            }
+        
+        return {'needs_clarification': False}
+    
+    def _calculate_relevance_score(self, query: str, search_results: List[Dict[str, Any]]) -> float:
+        """Calculate how relevant search results are to the query"""
+        if not search_results:
+            return 0.0
+        
+        query_words = set(query.lower().split())
+        query_words = {word for word in query_words if len(word) > 2}  # Remove short words
+        
+        total_relevance = 0.0
+        for result in search_results:
+            content = result.get('content', '').lower()
+            filename = result.get('filename', '').lower()
+            
+            # Count query word matches in content
+            content_matches = sum(1 for word in query_words if word in content)
+            filename_matches = sum(1 for word in query_words if word in filename)
+            
+            # Calculate relevance score for this result
+            max_possible_matches = len(query_words)
+            if max_possible_matches > 0:
+                relevance = (content_matches + filename_matches * 2) / (max_possible_matches * 2)
+                total_relevance += relevance
+        
+        # Average relevance across all results
+        return total_relevance / len(search_results) if search_results else 0.0
+    
+    def generate_conversational_response(self, 
+                                       query: str, 
+                                       search_results: List[Dict[str, Any]],
+                                       session_id: str = None) -> Dict[str, Any]:
+        """
+        Generate a conversational response that asks for clarification when needed
+        """
+        clarity = self.analyze_query_clarity(query, search_results)
+        
+        if clarity['clarification_needed']:
+            # Generate clarification response
+            clarification_text = "\n".join(clarity['clarification_questions'])
+            
+            response = {
+                'needs_clarification': True,
+                'response': clarification_text,
+                'type': 'clarification_request',
+                'suggested_follow_ups': clarity.get('suggested_responses', []),
+                'query_type': clarity.get('query_type', 'unclear'),
+                'confidence': clarity.get('confidence', 0.5)
+            }
+            
+            # Store conversation context for follow-up
+            if session_id:
+                self.conversation_history[session_id] = {
+                    'last_query': query,
+                    'awaiting_clarification': True,
+                    'clarification_type': clarity.get('query_type', 'unclear'),
+                    'timestamp': __import__('time').time()
+                }
+            
+            return response
+        
+        else:
+            # Query is clear, proceed with normal response
+            return {
+                'needs_clarification': False,
+                'response': None,  # Will be filled by normal RAG processing
+                'type': 'information_request',
+                'confidence': clarity.get('confidence', 1.0)
+            }
+    
+    def handle_follow_up(self, query: str, session_id: str) -> Dict[str, Any]:
+        """Handle follow-up queries after clarification request"""
+        if session_id not in self.conversation_history:
+            return {'is_follow_up': False}
+        
+        context = self.conversation_history[session_id]
+        
+        if not context.get('awaiting_clarification', False):
+            return {'is_follow_up': False}
+        
+        # Check if this is a clarification response
+        query_lower = query.lower().strip()
+        
+        # Clear clarification state
+        context['awaiting_clarification'] = False
+        
+        # Enhanced query based on clarification
+        clarification_type = context.get('clarification_type', '')
+        original_query = context.get('last_query', '')
+        
+        enhanced_query = f"{original_query} {query}"
+        
+        return {
+            'is_follow_up': True,
+            'enhanced_query': enhanced_query,
+            'context_type': clarification_type,
+            'original_query': original_query
+        }
+    
+    def generate_friendly_greeting(self) -> str:
+        """Generate a friendly greeting that encourages conversation"""
+        greetings = [
+            "Hello! I'm here to help you with government policies and procedures. What would you like to know about?",
+            "Hi there! I can assist you with information about pensions, procurement, leave policies, and more. What's on your mind?",
+            "Welcome! I'm your government assistant. Feel free to ask me about any policies, rules, or procedures you need help with.",
+            "Hello! I'm ready to help you navigate government policies and processes. What information are you looking for today?"
+        ]
+        
+        import random
+        return random.choice(greetings)
+    
+    def generate_helpful_response(self, response_text: str, sources: List[Dict[str, Any]]) -> str:
+        """Make responses more helpful and conversational"""
+        
+        # Add conversational elements
+        if response_text:
+            # Add follow-up encouragement
+            follow_up_phrases = [
+                "\n\nIs there anything specific about this topic you'd like me to explain further?",
+                "\n\nDo you have any follow-up questions about this information?",
+                "\n\nWould you like me to provide more details on any particular aspect?",
+                "\n\nIs there a specific situation you're dealing with that I can help you navigate?"
+            ]
+            
+            import random
+            follow_up = random.choice(follow_up_phrases)
+            response_text += follow_up
+        
+        return response_text
+
+# Global instance
+conversational_service = ConversationalService()

conversational_websocket_handler.py

@@ -0,0 +1,274 @@
+"""
+Enhanced Conversational WebSocket Handler
+Based on friend's implementation with session memory, personalization, and better conversational flow
+"""
+from fastapi import WebSocket, WebSocketDisconnect
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
+import logging
+import json
+import asyncio
+import uuid
+from typing import Dict, Any, List
+from session_service import session_service
+from conversational_audio_service import conversational_audio_service
+from enhanced_search_service import enhanced_pension_search
+from llm_service import create_graph, create_basic_graph
+
+logger = logging.getLogger("conversational_voicebot")
+
+async def handle_conversational_websocket(websocket: WebSocket):
+    """
+    Enhanced conversational websocket handler similar to friend's implementation
+    """
+    await websocket.accept()
+    logger.info("🔌 Conversational WebSocket client connected.")
+
+    # Initialize conversation variables
+    initial_data = await websocket.receive_json()
+    messages = []
+    conversation_history = []
+    
+    # Check if user authentication is provided
+    flag = "user_id" in initial_data
+    if flag:
+        thread_id = initial_data.get("user_id")
+        
+        # Get user session context and preferences
+        conversation_context = await session_service.get_conversation_context(thread_id)
+        user_preferences = await session_service.get_user_preferences(thread_id)
+        
+        # Create graph with RAG capabilities
+        graph = await create_graph(kb_tool=True, mcp_config=None)
+        
+        # Set conversational audio service voice based on preferences
+        voice_id = user_preferences.get('voice_id', 'en-IN-isha')
+        conversational_audio_service.set_default_voice(voice_id)
+        
+        language_code = user_preferences.get('language', 'english')
+        lang_map = {
+            'english': 'en',
+            'hindi': 'hi',
+            'hinglish': 'en'
+        }
+        lang_code = lang_map.get(language_code, 'en')
+        
+        config = {
+            "configurable": {
+                "thread_id": thread_id,
+                "knowledge_base": "pension_docs",
+            }
+        }
+        
+        # Enhanced conversational system prompt with personalization
+        base_prompt = """You are a warm, friendly, and knowledgeable PWC Pension Assistant. Your responses should be:
+
+        - Conversational and natural, as if speaking to a trusted friend
+        - Concise and informative - aim for 1-3 sentences unless more detail is specifically requested
+        - Clear and easy to understand when spoken aloud
+        - Professional yet personable and approachable
+        - Avoid overly complex jargon or long lists that are hard to follow in audio format
+
+        When responding about pension policies:
+        - Use a warm, reassuring tone appropriate for financial guidance
+        - Speak in a natural rhythm suitable for text-to-speech
+        - Break complex information into digestible, conversational chunks
+        - Ask clarifying questions to better understand their specific situation
+        - Remember this is voice interaction - structure responses to be easily understood when heard
+        - Reference specific pension documents when relevant
+        - If uncertain, clearly state limitations and suggest authoritative sources
+
+        Keep responses short and conversational. Don't use abbreviations or complex numerical content in your responses.
+        Focus on being helpful, accurate, and easy to understand through voice."""
+        
+        # Add conversation context if available
+        if conversation_context:
+            system_message = f"{base_prompt}\n\nPersonalization context: {conversation_context}"
+        else:
+            system_message = base_prompt
+            
+        messages.append(SystemMessage(content=system_message))
+        
+    else:
+        # Anonymous user
+        graph = create_basic_graph()
+        thread_id = str(uuid.uuid4())
+        voice_id = "en-IN-isha"
+        lang_code = "en"
+        config = {"configurable": {"thread_id": thread_id}}
+
+    # Generate personalized greeting
+    if flag:
+        greeting_response = await session_service.generate_personalized_greeting(thread_id, messages)
+    else:
+        greeting_response = "Hello! I'm your PWC Pension Assistant. I'm here to help you navigate pension policies, calculations, and retirement planning. What pension question can I help you with today?"
+    
+    # Add greeting to conversation
+    messages.append(AIMessage(content=greeting_response))
+    conversation_history.append({
+        'type': 'assistant',
+        'content': greeting_response,
+        'timestamp': asyncio.get_event_loop().time()
+    })
+    
+    # Generate and send greeting audio
+    try:
+        greeting_audio = await conversational_audio_service.synthesize_speech(greeting_response, voice_id)
+        await websocket.send_json({"type": "connection_successful"})
+        if greeting_audio:
+            await websocket.send_bytes(greeting_audio)
+    except Exception as e:
+        logger.error(f"❌ Error sending greeting: {e}")
+        await websocket.send_json({"type": "connection_successful"})
+
+    try:
+        while True:
+            try:
+                # Handle different message types
+                data = await websocket.receive_json()
+                
+                if data.get("type") == "end_call":
+                    logger.info("📞 Call ended by client")
+                    await websocket.close()
+                    break
+
+                # Get language preference
+                lang = data.get("lang", "english").lower()
+                
+                # Receive audio data
+                audio_bytes = await websocket.receive_bytes()
+
+                # --- Enhanced ASR with Groq ---
+                if flag:
+                    transcription = await conversational_audio_service.transcribe_audio(
+                        audio_bytes, language=lang_code
+                    )
+                else:
+                    transcription = await conversational_audio_service.transcribe_audio(audio_bytes)
+
+                if not transcription or not transcription.strip():
+                    logger.warning("⚠️ Empty transcription received")
+                    continue
+
+                # Send transcription to client
+                await websocket.send_json(
+                    {"type": "transcription", "text": transcription}
+                )
+                
+                # Add to conversation history
+                messages.append(HumanMessage(content=transcription))
+                conversation_history.append({
+                    'type': 'user',
+                    'content': transcription,
+                    'timestamp': asyncio.get_event_loop().time()
+                })
+
+                # --- Enhanced Document Search ---
+                search_results = None
+                try:
+                    search_results = await enhanced_pension_search(transcription, limit=3)
+                    logger.info(f"🔍 Found {len(search_results) if search_results else 0} relevant documents")
+                except Exception as search_error:
+                    logger.warning(f"⚠️ Document search failed: {search_error}")
+
+                # --- Enhanced LLM Response with Context ---
+                try:
+                    if search_results and len(search_results) > 0:
+                        # Enrich the message with search context
+                        context_message = f"User query: {transcription}\n\nRelevant pension documents found:\n"
+                        for i, doc in enumerate(search_results[:2], 1):
+                            content_preview = doc.get('content', '')[:300]
+                            context_message += f"\n{i}. {doc.get('source', 'Document')}: {content_preview}...\n"
+                        
+                        context_message += f"\nBased on the above pension documents, provide a helpful and conversational response to: {transcription}"
+                        
+                        # Replace user message with enriched version for LLM
+                        messages[-1] = HumanMessage(content=context_message)
+                    
+                    # Get LLM response
+                    result = await graph.ainvoke({"messages": messages}, config=config)
+                    llm_response = result["messages"][-1].content
+                    
+                    # Send LLM response to client
+                    await websocket.send_json(
+                        {"type": "llm_response", "text": llm_response}
+                    )
+                    
+                    # Add to conversation
+                    messages.append(AIMessage(content=llm_response))
+                    conversation_history.append({
+                        'type': 'assistant',
+                        'content': llm_response,
+                        'timestamp': asyncio.get_event_loop().time()
+                    })
+                    
+                    # --- Enhanced TTS with Murf ---
+                    try:
+                        if flag:
+                            audio_stream = await conversational_audio_service.synthesize_speech(
+                                llm_response, voice_id=voice_id
+                            )
+                        else:
+                            audio_stream = await conversational_audio_service.synthesize_speech(llm_response)
+                        
+                        await websocket.send_json({"type": "tts_start"})
+                        if audio_stream:
+                            await websocket.send_bytes(audio_stream)
+                        await websocket.send_json({"type": "tts_end"})
+                        
+                    except Exception as tts_error:
+                        logger.error(f"❌ TTS failed: {tts_error}")
+                        await websocket.send_json({"type": "tts_error", "message": "Audio generation failed"})
+
+                except Exception as llm_error:
+                    logger.error(f"❌ LLM processing failed: {llm_error}")
+                    error_response = "I apologize, but I encountered an issue processing your question. Could you please try rephrasing it?"
+                    
+                    await websocket.send_json(
+                        {"type": "llm_response", "text": error_response}
+                    )
+                    
+                    # Try to generate error audio
+                    try:
+                        error_audio = await conversational_audio_service.synthesize_speech(error_response)
+                        await websocket.send_json({"type": "tts_start"})
+                        if error_audio:
+                            await websocket.send_bytes(error_audio)
+                        await websocket.send_json({"type": "tts_end"})
+                    except:
+                        pass
+
+            except WebSocketDisconnect:
+                logger.info("🔌 WebSocket disconnected.")
+                break
+            except Exception as e:
+                logger.exception(f"❌ Error during conversation: {e}")
+                try:
+                    await websocket.send_json({"error": str(e)})
+                except:
+                    pass
+                break
+
+    finally:
+        # Session summary generation (like friend's bot)
+        if flag and len(conversation_history) > 2:
+            try:
+                logger.info("💾 Generating session summary...")
+                
+                # Generate session summary
+                summary = await session_service.generate_session_summary(messages, thread_id)
+                
+                # Store the session summary
+                await session_service.store_session_summary(
+                    thread_id,
+                    summary,
+                    conversation_history
+                )
+                
+                logger.info(f"✅ Session summary stored for user {thread_id}")
+
+            except Exception as e:
+                logger.exception(f"❌ Error storing session summary: {e}")
+        else:
+            logger.info("🔄 Session ended - no summary needed")
+
+        logger.info(f"🔄 Conversational session {thread_id} ended")

enhanced_websocket_handler.py

@@ -20,6 +20,7 @@ from hybrid_llm_service import HybridLLMService
 from voice_service import voice_service
 from rag_service import search_government_docs
 from policy_chart_generator import PolicyChartGenerator
+from conversational_service import conversational_service
 
 # Initialize hybrid LLM service
 hybrid_llm_service = HybridLLMService()
@@ -633,7 +634,7 @@ async def handle_text_message(websocket: WebSocket, data: dict, session_data: di
             response_chunks = []
             provider_used = None
             async for chunk in get_hybrid_response(
-                user_message, session_data["context"], config, knowledge_base
+                user_message, session_data["context"], config, knowledge_base, session_data.get("session_id")
             ):
                 response_chunks.append(chunk)
                 # Send each chunk as structured data
@@ -829,7 +830,7 @@ async def handle_voice_message(websocket: WebSocket, data: dict, session_data: d
         if use_hybrid:
             response_chunks = []
             async for chunk in get_hybrid_response(
-                enhanced_message, session_data["context"], config, knowledge_base
+                enhanced_message, session_data["context"], config, knowledge_base, session_data.get("session_id")
             ):
                 response_chunks.append(chunk)
                 # Send each chunk as structured data
@@ -895,18 +896,53 @@ async def handle_voice_message(websocket: WebSocket, data: dict, session_data: d
             "message": f"Error processing voice message: {str(e)}. Please try again or switch to text mode."
         })
 
-async def get_hybrid_response(user_message: str, context: str, config: dict, knowledge_base: str):
-    """Get response using hybrid LLM with intelligent document search and fallback (streaming)"""
+async def get_hybrid_response(user_message: str, context: str, config: dict, knowledge_base: str, session_id: str = None):
+    """Get response using hybrid LLM with conversational clarity checks and intelligent document search"""
     try:
         # First, determine if this is a government document query or general query
         query_context = analyze_query_context(user_message)
         logger.info(f"🔍 Query analysis: {query_context}")
         
-        logger.info(f"🔍 Searching documents for: '{user_message}' in knowledge base: {knowledge_base}")
+        # Check for follow-up context from previous clarification requests
+        follow_up_context = conversational_service.handle_follow_up(user_message, session_id) if session_id else {'is_follow_up': False}
+        
+        if follow_up_context['is_follow_up']:
+            # Use enhanced query from follow-up context
+            search_query = follow_up_context['enhanced_query']
+            logger.info(f"� Using follow-up enhanced query: '{search_query}'")
+        else:
+            search_query = user_message
+        
+        logger.info(f"�🔍 Searching documents for: '{search_query}' in knowledge base: {knowledge_base}")
         from rag_service import search_documents_async
-        docs = await search_documents_async(user_message, limit=3)
+        docs = await search_documents_async(search_query, limit=5)  # Increased limit for better results
         logger.info(f"📊 Document search returned {len(docs) if docs else 0} results")
         
+        # Conversational clarity analysis - check if we need clarification
+        if not follow_up_context['is_follow_up']:  # Don't ask for clarification on follow-ups
+            conversational_analysis = conversational_service.generate_conversational_response(
+                user_message, docs, session_id
+            )
+            
+            if conversational_analysis['needs_clarification']:
+                logger.info("❓ Query needs clarification - asking user for more context")
+                # Return clarification request instead of search results
+                yield {
+                    "clause_text": conversational_analysis['response'],
+                    "summary": "Clarification request to better understand your question",
+                    "role_checklist": ["Please provide more specific information"],
+                    "source_title": "Conversational Assistant",
+                    "clause_id": "CLARIFICATION_REQUEST",
+                    "date": "2024",
+                    "url": "",
+                    "score": 1.0,
+                    "scenario_analysis": None,
+                    "charts": [],
+                    "needs_clarification": True,
+                    "query_type": conversational_analysis.get('query_type', 'unclear')
+                }
+                return
+        
         # Check if we have relevant documents
         has_relevant_docs = docs and any(doc.get("score", 0) > 0.5 for doc in docs)
         

session_service.py

@@ -0,0 +1,212 @@
+"""
+Session management service for storing and retrieving conversation context
+to make the voice bot more conversational and personalized.
+"""
+import json
+import os
+from datetime import datetime
+from typing import Dict, Optional, List
+import logging
+
+logger = logging.getLogger(__name__)
+
+class SessionService:
+    def __init__(self, storage_dir: str = "./session_data"):
+        self.storage_dir = storage_dir
+        os.makedirs(storage_dir, exist_ok=True)
+        
+    def get_session_file(self, user_id: str) -> str:
+        """Get the file path for a user's session data"""
+        return os.path.join(self.storage_dir, f"session_{user_id}.json")
+    
+    async def get_session_summary(self, user_id: str) -> Dict:
+        """Retrieve session summary for a user"""
+        try:
+            session_file = self.get_session_file(user_id)
+            if os.path.exists(session_file):
+                with open(session_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    return data.get('session_summary', {})
+            return {}
+        except Exception as e:
+            logger.error(f"Error retrieving session summary for {user_id}: {e}")
+            return {}
+    
+    async def get_user_preferences(self, user_id: str) -> Dict:
+        """Get user preferences and settings"""
+        try:
+            session_file = self.get_session_file(user_id)
+            if os.path.exists(session_file):
+                with open(session_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    return data.get('preferences', {
+                        'language': 'english',
+                        'voice_id': 'en-IN-isha',
+                        'conversation_style': 'friendly'
+                    })
+            return {
+                'language': 'english',
+                'voice_id': 'en-IN-isha', 
+                'conversation_style': 'friendly'
+            }
+        except Exception as e:
+            logger.error(f"Error retrieving user preferences for {user_id}: {e}")
+            return {
+                'language': 'english',
+                'voice_id': 'en-IN-isha',
+                'conversation_style': 'friendly'
+            }
+    
+    async def store_session_summary(self, user_id: str, summary: str, conversation_history: List[Dict] = None) -> bool:
+        """Store session summary and conversation context"""
+        try:
+            session_file = self.get_session_file(user_id)
+            
+            # Load existing data
+            existing_data = {}
+            if os.path.exists(session_file):
+                with open(session_file, 'r', encoding='utf-8') as f:
+                    existing_data = json.load(f)
+            
+            # Update session data
+            session_data = {
+                'user_id': user_id,
+                'last_updated': datetime.now().isoformat(),
+                'session_summary': summary,
+                'preferences': existing_data.get('preferences', {
+                    'language': 'english',
+                    'voice_id': 'en-IN-isha',
+                    'conversation_style': 'friendly'
+                }),
+                'conversation_count': existing_data.get('conversation_count', 0) + 1,
+                'recent_topics': existing_data.get('recent_topics', [])
+            }
+            
+            # Add conversation history if provided
+            if conversation_history:
+                session_data['last_conversation'] = conversation_history[-10:]  # Keep last 10 messages
+                
+                # Extract recent topics
+                topics = []
+                for msg in conversation_history:
+                    if msg.get('type') == 'user':
+                        content = msg.get('content', '').lower()
+                        if 'pension' in content:
+                            topics.append('pension policies')
+                        if 'medical' in content or 'allowance' in content:
+                            topics.append('medical allowances')
+                        if 'retirement' in content:
+                            topics.append('retirement planning')
+                        if 'dearness' in content or 'dr' in content:
+                            topics.append('dearness relief')
+                
+                # Keep unique recent topics
+                session_data['recent_topics'] = list(set(topics + session_data['recent_topics']))[:5]
+            
+            # Save to file
+            with open(session_file, 'w', encoding='utf-8') as f:
+                json.dump(session_data, f, indent=2, ensure_ascii=False)
+            
+            logger.info(f"✅ Session summary stored for user {user_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Error storing session summary for {user_id}: {e}")
+            return False
+    
+    async def get_conversation_context(self, user_id: str) -> str:
+        """Get conversation context string for system prompt"""
+        try:
+            session_data = await self.get_session_summary(user_id)
+            if not session_data:
+                return ""
+            
+            context_parts = []
+            
+            # Add conversation count
+            conv_count = session_data.get('conversation_count', 0)
+            if conv_count > 1:
+                context_parts.append(f"This is conversation #{conv_count} with this user.")
+            
+            # Add recent topics
+            recent_topics = session_data.get('recent_topics', [])
+            if recent_topics:
+                topics_str = ", ".join(recent_topics)
+                context_parts.append(f"User has previously discussed: {topics_str}.")
+            
+            # Add session summary if available
+            if isinstance(session_data, str):
+                context_parts.append(f"Previous conversation context: {session_data}")
+            elif isinstance(session_data, dict) and 'summary' in session_data:
+                context_parts.append(f"Previous conversation context: {session_data['summary']}")
+            
+            return " ".join(context_parts)
+            
+        except Exception as e:
+            logger.error(f"Error getting conversation context for {user_id}: {e}")
+            return ""
+    
+    async def generate_personalized_greeting(self, user_id: str, messages_context: List = None) -> str:
+        """Generate a personalized greeting based on user history"""
+        try:
+            session_data = await self.get_session_summary(user_id)
+            preferences = await self.get_user_preferences(user_id)
+            
+            conv_count = session_data.get('conversation_count', 0) if isinstance(session_data, dict) else 0
+            recent_topics = session_data.get('recent_topics', []) if isinstance(session_data, dict) else []
+            
+            if conv_count == 0:
+                # First time user
+                return "Hello! I'm your PWC Pension Assistant. I'm here to help you navigate pension policies, calculations, and retirement planning from our comprehensive knowledge base. What pension question can I help you with today?"
+            elif conv_count == 1:
+                # Second conversation
+                return "Welcome back! I'm glad to see you again. How can I assist you with your pension and policy questions today?"
+            else:
+                # Returning user with history
+                if recent_topics:
+                    topics_mention = f"I remember we discussed {recent_topics[0]} before. "
+                else:
+                    topics_mention = ""
+                
+                return f"Hello again! {topics_mention}I'm here to help with any pension or policy questions you have. What's on your mind today?"
+                
+        except Exception as e:
+            logger.error(f"Error generating personalized greeting for {user_id}: {e}")
+            return "Hello! I'm your PWC Pension Assistant. How can I help you with your pension questions today?"
+
+    async def generate_session_summary(self, messages: List, user_id: str) -> str:
+        """Generate a session summary from conversation messages"""
+        try:
+            # Extract key topics and user preferences from conversation
+            user_messages = [msg for msg in messages if hasattr(msg, 'content') and 'user' in str(type(msg)).lower()]
+            
+            if len(user_messages) < 2:
+                return "Brief conversation about pension policies."
+            
+            # Simple topic extraction
+            topics = []
+            for msg in user_messages:
+                content = msg.content.lower()
+                if 'pension' in content:
+                    topics.append('pension queries')
+                if 'medical' in content or 'allowance' in content:
+                    topics.append('medical allowances')
+                if 'retirement' in content:
+                    topics.append('retirement planning')
+                if 'dearness' in content or 'dr' in content:
+                    topics.append('dearness relief')
+                if 'calculation' in content or 'calculate' in content:
+                    topics.append('pension calculations')
+            
+            unique_topics = list(set(topics))
+            if unique_topics:
+                return f"User discussed: {', '.join(unique_topics)}. Showed interest in pension policies and government benefits."
+            else:
+                return "General conversation about pension and policy matters."
+                
+        except Exception as e:
+            logger.error(f"Error generating session summary for {user_id}: {e}")
+            return "Conversation session completed."
+
+# Global session service instance
+session_service = SessionService()

test_conversational.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+Test Conversational Voice Bot Features
+Demonstrates how the bot now asks for clarification like your friend's bot
+"""
+
+import asyncio
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
+logger = logging.getLogger(__name__)
+
+async def test_conversational_features():
+    """Test the conversational clarity detection"""
+    
+    print("🎯 Testing Conversational Voice Bot Features")
+    print("=" * 60)
+    print("This demonstrates how your bot now asks for clarification")
+    print("just like your friend's superior voice bot!")
+    print()
+    
+    try:
+        from conversational_service import conversational_service
+        
+        # Test queries that should trigger clarification
+        test_cases = [
+            {
+                "query": "pension",
+                "description": "Vague pension query",
+                "expected": "Should ask for specific pension topic"
+            },
+            {
+                "query": "what",
+                "description": "Too generic query", 
+                "expected": "Should ask what topic user wants help with"
+            },
+            {
+                "query": "help",
+                "description": "General help request",
+                "expected": "Should provide topic options"
+            },
+            {
+                "query": "tender",
+                "description": "Vague procurement query",
+                "expected": "Should ask about specific procurement aspect"
+            },
+            {
+                "query": "What are the pension rules?",
+                "description": "Clear specific query",
+                "expected": "Should proceed with search (no clarification needed)"
+            }
+        ]
+        
+        for i, test_case in enumerate(test_cases, 1):
+            print(f"🔍 Test {i}: {test_case['description']}")
+            print(f"Query: \"{test_case['query']}\"")
+            print(f"Expected: {test_case['expected']}")
+            print("-" * 50)
+            
+            # Analyze query clarity
+            clarity_analysis = conversational_service.analyze_query_clarity(
+                test_case['query'], 
+                []  # Empty search results for testing
+            )
+            
+            if clarity_analysis['clarification_needed']:
+                print("✅ RESULT: Bot will ask for clarification")
+                print("🤖 Bot response:")
+                print()
+                for question in clarity_analysis['clarification_questions']:
+                    print(f"   {question}")
+                print()
+                
+                if 'suggested_responses' in clarity_analysis:
+                    for suggestion in clarity_analysis['suggested_responses']:
+                        print(f"   {suggestion}")
+                        
+            else:
+                print("✅ RESULT: Query is clear, will proceed with search")
+                print(f"🎯 Confidence: {clarity_analysis['confidence']:.2f}")
+            
+            print()
+            print("=" * 60)
+            print()
+    
+    except ImportError as e:
+        print(f"❌ Import error: {e}")
+        print("💡 Make sure you're running from the PensionBot directory")
+    except Exception as e:
+        print(f"❌ Test error: {e}")
+
+def demonstrate_conversation_flow():
+    """Demonstrate a full conversation flow"""
+    
+    print("💬 Conversation Flow Demonstration")
+    print("=" * 40)
+    print("Here's how a conversation now works:")
+    print()
+    
+    conversation = [
+        {"speaker": "👤 User", "message": "pension"},
+        {"speaker": "🤖 Bot", "message": """I can help with pension-related questions! To give you the most accurate information, could you specify:
+
+📋 What specifically about pension?
+• How to calculate pension amount?
+• Pension eligibility criteria?
+• How to apply for pension?
+• Family pension benefits?
+• Commutation of pension?
+
+Please let me know which aspect interests you most!"""},
+        {"speaker": "👤 User", "message": "calculation"},
+        {"speaker": "🤖 Bot", "message": """Here's the pension calculation formula:
+
+**Formula**: (Last drawn basic pay + DA) × service years ÷ 70
+**Minimum pension**: ₹9,000 per month
+**Maximum pension**: No upper limit
+
+**Example calculation**:
+- Last basic pay: ₹50,000
+- DA: ₹25,000 (50% of basic)
+- Service years: 30
+- Pension = (50,000 + 25,000) × 30 ÷ 70 = ₹32,143 per month
+
+Would you like me to help with a specific pension calculation for your situation?"""}
+    ]
+    
+    for exchange in conversation:
+        print(f"{exchange['speaker']}: {exchange['message']}")
+        print()
+    
+    print("🎯 Key Improvements:")
+    print("✅ Bot asks for clarification instead of guessing")
+    print("✅ Provides structured options for user to choose")  
+    print("✅ Follows up with specific, detailed information")
+    print("✅ Encourages further conversation")
+    print()
+    print("This is exactly how your friend's bot works! 🎉")
+
+if __name__ == "__main__":
+    print("🎯 Conversational Voice Bot Test")
+    print("Testing enhanced conversational features")
+    print()
+    
+    # Run the tests
+    asyncio.run(test_conversational_features())
+    
+    print("\n" + "="*60)
+    demonstrate_conversation_flow()