Update app.py

app.py

@@ -12,20 +12,19 @@ import pickle
 from dataclasses import dataclass, asdict
 import hashlib
 from collections import defaultdict
-import re
 
 # Set page configuration
 st.set_page_config(
-    page_title="MedChat - AI Doctor Consultation",
+    page_title="MedAssist - AI Medical Preconsultation",
     layout="wide",
     initial_sidebar_state="expanded",
-    page_icon="👩‍⚕️"
+    page_icon="🏥"
 )
 
-# Enhanced CSS for conversational medical theme
+# Enhanced CSS for medical theme
 st.markdown("""
 <style>
-    /* Medical conversation theme */
+    /* Medical theme styling */
     html, body, .stApp, .main {
         background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
         color: #ffffff !important;
@@ -44,716 +43,554 @@ st.markdown("""
     .chat-container {
         background: rgba(255, 255, 255, 0.1) !important;
         border-radius: 15px !important;
-        padding: 1.5rem !important;
+        padding: 1rem !important;
         backdrop-filter: blur(10px) !important;
         border: 1px solid rgba(255, 255, 255, 0.2) !important;
         margin-bottom: 1rem !important;
-        max-height: 600px !important;
+        max-height: 500px !important;
         overflow-y: auto !important;
-        min-height: 400px !important;
     }
     
-    .patient-message {
+    .user-message {
         background: linear-gradient(45deg, #4CAF50, #66BB6A) !important;
         color: white !important;
-        padding: 1.2rem !important;
-        border-radius: 18px 18px 5px 18px !important;
-        margin: 0.8rem 0 !important;
-        margin-left: 3rem !important;
+        padding: 1rem !important;
+        border-radius: 15px 15px 5px 15px !important;
+        margin: 0.5rem 0 !important;
+        margin-left: 2rem !important;
         box-shadow: 0 4px 15px rgba(76, 175, 80, 0.4) !important;
-        position: relative !important;
-    }
-    
-    .patient-message::before {
-        content: "👤 Patient";
-        position: absolute;
-        top: -10px;
-        right: 15px;
-        background: #2E7D32;
-        color: white;
-        padding: 2px 8px;
-        border-radius: 10px;
-        font-size: 12px;
-        font-weight: bold;
     }
     
-    .doctor-message {
+    .assistant-message {
         background: rgba(255, 255, 255, 0.15) !important;
         color: white !important;
-        padding: 1.2rem !important;
-        border-radius: 18px 18px 18px 5px !important;
-        margin: 0.8rem 0 !important;
-        margin-right: 3rem !important;
+        padding: 1rem !important;
+        border-radius: 15px 15px 15px 5px !important;
+        margin: 0.5rem 0 !important;
+        margin-right: 2rem !important;
         border-left: 4px solid #2196F3 !important;
         backdrop-filter: blur(5px) !important;
-        position: relative !important;
     }
     
-    .doctor-message::before {
-        content: "👩‍⚕️ Dr. AI";
-        position: absolute;
-        top: -10px;
-        left: 15px;
-        background: #1976D2;
-        color: white;
-        padding: 2px 8px;
-        border-radius: 10px;
-        font-size: 12px;
-        font-weight: bold;
-    }
-    
-    .follow-up-questions {
-        background: rgba(33, 150, 243, 0.2) !important;
-        border: 1px solid rgba(33, 150, 243, 0.4) !important;
-        border-radius: 10px !important;
+    .agent-status-card {
+        background: rgba(255, 255, 255, 0.15) !important;
+        border: 1px solid rgba(255, 255, 255, 0.3) !important;
+        border-radius: 12px !important;
         padding: 1rem !important;
         margin: 0.5rem 0 !important;
+        backdrop-filter: blur(5px) !important;
     }
     
-    .conversation-phase {
-        background: linear-gradient(45deg, #9C27B0, #BA68C8) !important;
+    .evolution-metrics {
+        background: linear-gradient(45deg, #FF6B6B, #FF8E8E) !important;
         color: white !important;
-        padding: 0.5rem 1rem !important;
-        border-radius: 15px !important;
-        text-align: center !important;
-        margin: 1rem 0 !important;
-        font-weight: bold !important;
-    }
-    
-    .typing-indicator {
-        background: rgba(255, 255, 255, 0.1) !important;
         padding: 1rem !important;
-        border-radius: 18px 18px 18px 5px !important;
+        border-radius: 10px !important;
         margin: 0.5rem 0 !important;
-        margin-right: 3rem !important;
-        animation: pulse 1.5s infinite !important;
     }
     
-    @keyframes pulse {
-        0%, 100% { opacity: 0.6; }
-        50% { opacity: 1; }
-    }
-    
-    .agent-insights {
-        background: rgba(255, 193, 7, 0.15) !important;
-        border-left: 4px solid #FFC107 !important;
-        padding: 1rem !important;
-        border-radius: 8px !important;
-        margin: 0.5rem 0 !important;
-        font-size: 0.9em !important;
+    .warning-box {
+        background: rgba(255, 152, 0, 0.2) !important;
+        border: 2px solid #FF9800 !important;
+        border-radius: 10px !important;
+        padding: 1.5rem !important;
+        margin: 1rem 0 !important;
+        color: white !important;
     }
     
-    .quick-response {
-        background: rgba(76, 175, 80, 0.8) !important;
+    .stButton > button {
+        background: linear-gradient(45deg, #2196F3, #64B5F6) !important;
         color: white !important;
         border: none !important;
-        border-radius: 20px !important;
-        padding: 0.5rem 1rem !important;
-        margin: 0.2rem !important;
-        cursor: pointer !important;
+        border-radius: 25px !important;
+        font-weight: bold !important;
+        padding: 0.75rem 2rem !important;
         transition: all 0.3s ease !important;
     }
     
-    .quick-response:hover {
-        background: #4CAF50 !important;
+    .stButton > button:hover {
         transform: translateY(-2px) !important;
+        box-shadow: 0 8px 25px rgba(33, 150, 243, 0.6) !important;
     }
     
-    .conversation-summary {
-        background: rgba(103, 58, 183, 0.2) !important;
-        border: 1px solid rgba(103, 58, 183, 0.4) !important;
-        border-radius: 10px !important;
+    .chat-input {
+        position: sticky !important;
+        bottom: 0 !important;
+        background: rgba(255, 255, 255, 0.1) !important;
         padding: 1rem !important;
-        margin: 1rem 0 !important;
+        border-radius: 15px !important;
+        backdrop-filter: blur(10px) !important;
+    }
+    
+    .spinner {
+        border: 2px solid rgba(255, 255, 255, 0.3);
+        border-radius: 50%;
+        border-top: 2px solid #ffffff;
+        width: 20px;
+        height: 20px;
+        animation: spin 1s linear infinite;
+        display: inline-block;
+    }
+    
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
     }
 </style>
 """, unsafe_allow_html=True)
 
-@dataclass
-class ConversationState:
-    """Track the current state of the medical conversation"""
-    phase: str = "greeting"  # greeting, history_taking, symptom_exploration, assessment, recommendations, follow_up
-    patient_concerns: List[str] = None
-    symptoms_discussed: Dict[str, dict] = None
-    medical_history: Dict[str, any] = None
-    current_focus: str = ""
-    questions_asked: List[str] = None
-    patient_responses: Dict[str, str] = None
-    conversation_depth: int = 0
-    urgency_level: str = "routine"  # routine, urgent, emergency
-    
-    def __post_init__(self):
-        if self.patient_concerns is None:
-            self.patient_concerns = []
-        if self.symptoms_discussed is None:
-            self.symptoms_discussed = {}
-        if self.medical_history is None:
-            self.medical_history = {}
-        if self.questions_asked is None:
-            self.questions_asked = []
-        if self.patient_responses is None:
-            self.patient_responses = {}
-
 @dataclass
 class ConversationEntry:
-    """Enhanced conversation entry with conversational context"""
+    """Data structure for storing conversation entries"""
     timestamp: str
     user_input: str
     assistant_response: str
-    conversation_phase: str
     symptoms: List[str]
     severity_score: float
     confidence_score: float
     search_queries_used: List[str]
-    follow_up_questions: List[str]
-    agent_insights: Dict[str, str]
-    user_feedback: Optional[int] = None
+    user_feedback: Optional[int] = None  # 1-5 rating
     was_helpful: Optional[bool] = None
 
-class ConversationalMedicalAgent:
-    """Enhanced medical agent with conversational capabilities"""
+@dataclass
+class AgentPerformance:
+    """Track agent performance metrics"""
+    agent_name: str
+    total_queries: int = 0
+    successful_responses: int = 0
+    average_confidence: float = 0.0
+    user_satisfaction: float = 0.0
+    learning_rate: float = 0.01
+    expertise_areas: Dict[str, float] = None
     
-    def __init__(self, agent_id: str, specialization: str, personality: str = "professional"):
-        self.agent_id = agent_id
-        self.specialization = specialization
-        self.personality = personality
-        self.conversation_patterns = self._load_conversation_patterns()
-        self.question_bank = self._initialize_question_bank()
-        self.response_templates = self._load_response_templates()
-        
-    def _load_conversation_patterns(self) -> Dict[str, List[str]]:
-        """Load conversational patterns for natural dialogue"""
-        return {
-            "greeting": [
-                "Hello! I'm here to help with your health concerns. What brings you in today?",
-                "Good to see you today. How are you feeling, and what can I help you with?",
-                "Welcome! I'd like to understand what's been concerning you about your health lately."
-            ],
-            "follow_up": [
-                "Can you tell me more about that?",
-                "When did you first notice this?",
-                "How has this been affecting your daily activities?",
-                "Have you noticed any patterns with this symptom?"
-            ],
-            "empathy": [
-                "I can understand how concerning that must be for you.",
-                "That does sound uncomfortable. Let's explore this further.",
-                "Thank you for sharing that with me. It helps me understand better."
-            ],
-            "clarification": [
-                "Just to make sure I understand correctly...",
-                "Let me clarify what you're experiencing...",
-                "I want to make sure I have the full picture..."
-            ]
-        }
+    def __post_init__(self):
+        if self.expertise_areas is None:
+            self.expertise_areas = defaultdict(float)
+
+class MedicalSearchTool:
+    """Enhanced medical search tool with domain-specific optimization"""
     
-    def _initialize_question_bank(self) -> Dict[str, List[str]]:
-        """Initialize comprehensive question bank for different scenarios"""
-        return {
-            "symptom_exploration": [
-                "On a scale of 1-10, how would you rate the intensity?",
-                "Does anything make it better or worse?",
-                "How long have you been experiencing this?",
-                "Does it happen at specific times of day?",
-                "Have you tried anything to relieve it?"
-            ],
-            "medical_history": [
-                "Do you have any chronic medical conditions?",
-                "Are you currently taking any medications?",
-                "Any family history of similar issues?",
-                "Have you had any surgeries or hospitalizations?",
-                "Any known allergies to medications?"
-            ],
-            "lifestyle": [
-                "How would you describe your stress levels lately?",
-                "How is your sleep quality?",
-                "Any recent changes in diet or exercise?",
-                "Do you smoke or drink alcohol?",
-                "Any recent travel or exposure to illness?"
-            ],
-            "associated_symptoms": [
-                "Are you experiencing any other symptoms alongside this?",
-                "Any fever, nausea, or dizziness?",
-                "How is your appetite?",
-                "Any changes in bowel movements or urination?",
-                "Any skin changes or rashes?"
-            ]
-        }
+    def __init__(self):
+        self.ddgs = DDGS()
+        self.medical_sources = [
+            "mayoclinic.org", "webmd.com", "healthline.com", "medlineplus.gov",
+            "nih.gov", "who.int", "cdc.gov", "ncbi.nlm.nih.gov"
+        ]
     
-    def _load_response_templates(self) -> Dict[str, str]:
-        """Load response templates for different conversation phases"""
-        return {
-            "symptom_acknowledgment": "I see that you're experiencing {symptom}. That can certainly be {emotion_word}. Let me ask you a few questions to better understand what might be going on.",
-            "information_gathering": "Based on what you've told me about {symptom}, I'd like to gather some more information. {question}",
-            "assessment": "From what you've described - {symptom_summary} - there are a few possibilities we should consider. {assessment_details}",
-            "reassurance": "I want to reassure you that {concern} is {reassurance_level}. However, it's important that we {recommended_action}.",
-            "urgent_referral": "Based on your symptoms, especially {urgent_symptoms}, I recommend that you {urgent_action} as this may require immediate attention."
-        }
+    def search_medical_info(self, query: str, search_type: str = "symptoms") -> str:
+        """Search for medical information with safety considerations"""
+        try:
+            # Add medical context to search
+            medical_queries = {
+                "symptoms": f"medical symptoms {query} causes diagnosis",
+                "treatment": f"medical treatment {query} therapy options",
+                "prevention": f"disease prevention {query} health tips",
+                "general": f"medical information {query} health facts"
+            }
+            
+            enhanced_query = medical_queries.get(search_type, medical_queries["general"])
+            
+            # Perform search with medical focus
+            search_results = list(self.ddgs.text(
+                enhanced_query,
+                max_results=5,
+                region='wt-wt',
+                safesearch='on'
+            ))
+            
+            if not search_results:
+                return "No relevant medical information found. Please consult with a healthcare professional."
+            
+            # Filter and format results with medical authority preference
+            formatted_results = []
+            for idx, result in enumerate(search_results, 1):
+                title = result.get('title', 'No title')
+                snippet = result.get('body', 'No description')
+                url = result.get('href', 'No URL')
+                
+                # Prioritize trusted medical sources
+                source_trust = "⭐" if any(source in url for source in self.medical_sources) else ""
+                
+                formatted_results.append(
+                    f"{idx}. {source_trust} {title}\n"
+                    f"   Information: {snippet}\n"
+                    f"   Source: {url}\n"
+                )
+            
+            return "\n".join(formatted_results)
+            
+        except Exception as e:
+            return f"Search temporarily unavailable: {str(e)}"
+
+class GroqLLM:
+    """Medical-optimized LLM client"""
+    
+    def __init__(self, model_name="openai/gpt-oss-20b"):
+        self.client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+        self.model_name = model_name
+        self.medical_context = """
+        You are a medical AI assistant for preconsultation guidance. 
+        IMPORTANT: Always remind users that this is not a substitute for professional medical advice.
+        Provide helpful information while emphasizing the need for proper medical consultation.
+        """
+    
+    def generate_response(self, prompt: str, conversation_history: List[str] = None) -> Tuple[str, float]:
+        """Generate response with confidence scoring"""
+        try:
+            # Build context with conversation history
+            context = self.medical_context
+            if conversation_history:
+                context += f"\n\nConversation History:\n{chr(10).join(conversation_history[-5:])}"
+            
+            full_prompt = f"{context}\n\nUser Query: {prompt}\n\nPlease provide helpful medical guidance while emphasizing the importance of professional medical consultation."
+            
+            completion = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[{"role": "user", "content": full_prompt}],
+                temperature=0.3,  # Lower temperature for medical accuracy
+                max_tokens=1500,
+                stream=False
+            )
+            
+            response = completion.choices[0].message.content if completion.choices else "Unable to generate response"
+            
+            # Calculate confidence score based on response characteristics
+            confidence = self._calculate_confidence(response, prompt)
+            
+            return response, confidence
+            
+        except Exception as e:
+            return f"LLM temporarily unavailable: {str(e)}", 0.0
     
-    def generate_conversational_response(self, query: str, conversation_state: ConversationState, 
-                                       search_results: str = "") -> Tuple[str, List[str], Dict[str, any]]:
-        """Generate contextual, conversational response"""
+    def _calculate_confidence(self, response: str, query: str) -> float:
+        """Calculate confidence score based on response quality"""
+        confidence_factors = 0.0
         
-        # Determine conversation phase and adjust response
-        phase_response = self._determine_response_strategy(query, conversation_state)
+        # Check for medical disclaimers (increases confidence in safety)
+        if any(phrase in response.lower() for phrase in ["consult", "doctor", "medical professional", "healthcare provider"]):
+            confidence_factors += 0.3
         
-        # Generate main response based on specialization and conversation context
-        main_response = self._craft_specialized_response(query, conversation_state, search_results)
+        # Check response length (adequate detail)
+        if 200 <= len(response) <= 1000:
+            confidence_factors += 0.2
         
-        # Generate follow-up questions
-        follow_up_questions = self._generate_follow_up_questions(query, conversation_state)
+        # Check for structured information
+        if any(marker in response for marker in ["1.", "•", "-", "**"]):
+            confidence_factors += 0.2
         
-        # Provide agent insights
-        insights = {
-            "specialization_note": f"From a {self.specialization} perspective, {self._get_specialist_insight(query)}",
-            "conversation_guidance": self._suggest_conversation_direction(conversation_state),
-            "urgency_assessment": self._assess_urgency(query, conversation_state)
-        }
+        # Check for balanced information (not overly certain)
+        if any(phrase in response.lower() for phrase in ["may", "might", "could", "possible", "typically"]):
+            confidence_factors += 0.3
         
-        return main_response, follow_up_questions, insights
+        return min(confidence_factors, 1.0)
+
+class EvolutionaryMedicalAgent:
+    """Evolutionary agent with reinforcement learning capabilities"""
     
-    def _determine_response_strategy(self, query: str, state: ConversationState) -> str:
-        """Determine the appropriate response strategy based on conversation state"""
-        query_lower = query.lower()
+    def __init__(self, agent_id: str, specialization: str):
+        self.agent_id = agent_id
+        self.specialization = specialization
+        self.performance = AgentPerformance(agent_name=agent_id)
+        self.knowledge_base = defaultdict(float)
+        self.response_patterns = {}
+        self.learning_memory = []
         
-        # Check for emergency indicators
-        emergency_keywords = ["chest pain", "can't breathe", "severe", "emergency", "blood", "unconscious"]
-        if any(keyword in query_lower for keyword in emergency_keywords):
-            state.urgency_level = "emergency"
-            return "emergency_response"
-        
-        # Check for urgent indicators
-        urgent_keywords = ["intense", "sudden", "worsening", "spreading", "difficulty"]
-        if any(keyword in query_lower for keyword in urgent_keywords):
-            state.urgency_level = "urgent"
-            return "urgent_response"
-        
-        # Determine conversation phase
-        if state.phase == "greeting":
-            return "initial_response"
-        elif state.phase == "history_taking":
-            return "information_gathering"
-        elif state.phase == "symptom_exploration":
-            return "detailed_exploration"
-        else:
-            return "general_response"
-    
-    def _craft_specialized_response(self, query: str, state: ConversationState, search_results: str) -> str:
-        """Craft a specialized response based on agent expertise"""
+    def process_query(self, query: str, context: str, search_results: str) -> Tuple[str, float]:
+        """Process query and adapt based on specialization"""
         
-        # Base response structure
-        response_parts = []
+        # Update query count
+        self.performance.total_queries += 1
         
-        # Acknowledgment and empathy
-        if state.conversation_depth == 0:  # First interaction
-            response_parts.append(self._get_greeting_response(query))
-        else:
-            response_parts.append(self._get_acknowledgment(query, state))
+        # Extract key terms for learning
+        key_terms = self._extract_medical_terms(query)
+        
+        # Build specialized response based on agent's expertise
+        specialized_prompt = f"""
+        As a {self.specialization} specialist, analyze this medical query:
+        Query: {query}
+        Context: {context}
+        Search Results: {search_results}
         
-        # Specialized analysis
-        specialist_analysis = self._provide_specialist_analysis(query, search_results)
-        if specialist_analysis:
-            response_parts.append(specialist_analysis)
+        Provide specialized insights based on your expertise in {self.specialization}.
+        Always emphasize the need for professional medical consultation.
+        """
         
-        # Guidance and recommendations
-        guidance = self._provide_guidance(query, state)
-        if guidance:
-            response_parts.append(guidance)
+        # Simulate processing (in real implementation, this would use the LLM)
+        response = f"Based on my specialization in {self.specialization}, {query.lower()} suggests several considerations. However, please consult with a healthcare professional for proper diagnosis and treatment."
         
-        # Medical disclaimer
-        response_parts.append("Please remember that this guidance is for informational purposes. For a proper diagnosis and treatment plan, it's important to consult with a healthcare provider.")
+        confidence = 0.7 + (self.performance.average_confidence * 0.3)
         
-        return "\n\n".join(response_parts)
+        # Update expertise in relevant areas
+        for term in key_terms:
+            self.knowledge_base[term] += 0.1
+        
+        return response, confidence
     
-    def _generate_follow_up_questions(self, query: str, state: ConversationState) -> List[str]:
-        """Generate contextually relevant follow-up questions"""
-        questions = []
-        query_lower = query.lower()
+    def update_from_feedback(self, query: str, response: str, feedback_score: int, was_helpful: bool):
+        """Update agent based on user feedback (reinforcement learning)"""
+        
+        # Calculate reward signal
+        reward = (feedback_score - 3) / 2  # Convert 1-5 scale to -1 to 1
+        if was_helpful:
+            reward += 0.2
+        
+        # Update performance metrics
+        if feedback_score >= 3:
+            self.performance.successful_responses += 1
+        
+        # Update satisfaction and confidence
+        self.performance.user_satisfaction = (
+            (self.performance.user_satisfaction * (self.performance.total_queries - 1) + feedback_score) /
+            self.performance.total_queries
+        )
         
-        # Symptom-specific questions
-        if "pain" in query_lower:
-            questions.extend([
-                "Where exactly is the pain located?",
-                "How would you describe the pain - sharp, dull, throbbing?",
-                "What were you doing when the pain started?"
-            ])
-        
-        if "headache" in query_lower:
-            questions.extend([
-                "Where on your head do you feel the pain?",
-                "How often do you get headaches like this?",
-                "Any visual changes or sensitivity to light?"
-            ])
-        
-        # General health questions based on conversation phase
-        if state.phase == "greeting":
-            questions.extend([
-                "How long have you been experiencing this?",
-                "Have you noticed any other symptoms?",
-                "Is this your first time having this issue?"
-            ])
-        
-        # Limit to most relevant questions
-        return questions[:3]
+        # Store learning memory
+        self.learning_memory.append({
+            'query': query,
+            'response': response,
+            'reward': reward,
+            'timestamp': datetime.now().isoformat()
+        })
+        
+        # Adapt learning rate based on performance
+        if self.performance.user_satisfaction > 4.0:
+            self.performance.learning_rate *= 0.95  # Slow down learning when performing well
+        elif self.performance.user_satisfaction < 3.0:
+            self.performance.learning_rate *= 1.1   # Speed up learning when performing poorly
+        
+        # Update expertise areas based on feedback
+        terms = self._extract_medical_terms(query)
+        for term in terms:
+            self.knowledge_base[term] += reward * self.performance.learning_rate
     
-    def _get_specialist_insight(self, query: str) -> str:
-        """Provide specialist insight based on agent's expertise"""
-        insights = {
-            "General Practice Medicine": "this requires a comprehensive evaluation of your overall health and symptoms",
-            "Symptom Analysis and Triage": "we need to prioritize your symptoms and determine the appropriate level of care",
-            "Preventive Care and Wellness": "there may be lifestyle factors we can address to prevent this from recurring",
-            "Mental Health and Psychology": "stress and mental health can significantly impact physical symptoms",
-            "Emergency Assessment and Urgent Care": "we need to quickly assess if this requires immediate medical attention"
+    def _extract_medical_terms(self, text: str) -> List[str]:
+        """Extract medical terms from text for learning"""
+        medical_keywords = [
+            'pain', 'fever', 'headache', 'nausea', 'fatigue', 'cough', 'cold', 'flu',
+            'diabetes', 'hypertension', 'infection', 'allergy', 'asthma', 'arthritis',
+            'anxiety', 'depression', 'insomnia', 'migraine', 'rash', 'swelling'
+        ]
+        
+        found_terms = []
+        text_lower = text.lower()
+        for term in medical_keywords:
+            if term in text_lower:
+                found_terms.append(term)
+        return found_terms
+    
+    def get_expertise_summary(self) -> Dict:
+        """Get summary of agent's learned expertise"""
+        return {
+            'specialization': self.specialization,
+            'total_queries': self.performance.total_queries,
+            'success_rate': (self.performance.successful_responses / max(1, self.performance.total_queries)) * 100,
+            'user_satisfaction': self.performance.user_satisfaction,
+            'learning_rate': self.performance.learning_rate,
+            'top_expertise_areas': dict(sorted(self.knowledge_base.items(), key=lambda x: x[1], reverse=True)[:5])
         }
-        return insights.get(self.specialization, "this warrants careful evaluation")
 
-class ConversationalMedicalSystem:
-    """Enhanced medical system with natural conversation flow"""
+class MedicalConsultationSystem:
+    """Main medical consultation system with evolutionary agents"""
     
     def __init__(self):
         self.llm = GroqLLM()
         self.search_tool = MedicalSearchTool()
-        self.agents = self._initialize_conversational_agents()
-        self.conversation_state = ConversationState()
+        self.agents = self._initialize_agents()
         self.conversation_history = []
         self.conversation_data = []
         
-    def _initialize_conversational_agents(self) -> Dict[str, ConversationalMedicalAgent]:
-        """Initialize conversational medical agents"""
+    def _initialize_agents(self) -> Dict[str, EvolutionaryMedicalAgent]:
+        """Initialize specialized medical agents"""
         return {
-            "primary_physician": ConversationalMedicalAgent("primary", "General Practice Medicine", "warm"),
-            "symptom_specialist": ConversationalMedicalAgent("symptom", "Symptom Analysis and Triage", "analytical"),
-            "wellness_coach": ConversationalMedicalAgent("wellness", "Preventive Care and Wellness", "encouraging"),
-            "mental_health_counselor": ConversationalMedicalAgent("mental", "Mental Health and Psychology", "empathetic"),
-            "emergency_consultant": ConversationalMedicalAgent("emergency", "Emergency Assessment and Urgent Care", "direct")
+            "general_practitioner": EvolutionaryMedicalAgent("gp", "General Practice Medicine"),
+            "symptom_analyzer": EvolutionaryMedicalAgent("symptom", "Symptom Analysis and Triage"),
+            "wellness_advisor": EvolutionaryMedicalAgent("wellness", "Preventive Care and Wellness"),
+            "mental_health": EvolutionaryMedicalAgent("mental", "Mental Health and Psychology"),
+            "emergency_assessor": EvolutionaryMedicalAgent("emergency", "Emergency Assessment and Urgent Care")
         }
     
-    def process_conversational_query(self, user_input: str) -> Dict:
-        """Process query with full conversational context"""
+    def process_medical_query(self, user_query: str) -> Dict:
+        """Process medical query through evolutionary agent system"""
         
         timestamp = datetime.now().isoformat()
-        self.conversation_state.conversation_depth += 1
-        
-        # Update conversation phase based on input and history
-        self._update_conversation_phase(user_input)
         
-        # Extract and update patient information
-        self._extract_patient_information(user_input)
+        # Determine which agents should handle this query
+        relevant_agents = self._select_relevant_agents(user_query)
         
-        # Select primary agent for this interaction
-        primary_agent = self._select_primary_agent(user_input)
+        # Search for medical information
+        search_results = self.search_tool.search_medical_info(user_query, "symptoms")
         
-        # Get supporting agents
-        supporting_agents = self._select_supporting_agents(user_input)
+        # Build conversation context
+        context = "\n".join(self.conversation_history[-3:]) if self.conversation_history else ""
         
-        # Perform medical search if needed
-        search_results = ""
-        if self._should_search(user_input):
-            search_results = self.search_tool.search_medical_info(user_input, self._determine_search_type())
+        # Get responses from relevant agents
+        agent_responses = {}
+        for agent_name in relevant_agents:
+            agent = self.agents[agent_name]
+            response, confidence = agent.process_query(user_query, context, search_results)
+            agent_responses[agent_name] = {
+                'response': response,
+                'confidence': confidence,
+                'specialization': agent.specialization
+            }
         
-        # Generate conversational response from primary agent
-        main_response, follow_up_questions, primary_insights = primary_agent.generate_conversational_response(
-            user_input, self.conversation_state, search_results
+        # Generate main LLM response
+        main_response, main_confidence = self.llm.generate_response(
+            f"{user_query}\n\nRelevant Information: {search_results}",
+            self.conversation_history
         )
         
-        # Get insights from supporting agents
-        supporting_insights = {}
-        for agent_name in supporting_agents:
-            agent = self.agents[agent_name]
-            _, _, insights = agent.generate_conversational_response(user_input, self.conversation_state, search_results)
-            supporting_insights[agent_name] = insights
+        # Combine responses intelligently
+        final_response = self._combine_responses(main_response, agent_responses)
         
-        # Generate LLM-enhanced response for natural conversation
-        enhanced_response = self._enhance_with_llm(user_input, main_response, self.conversation_state)
+        # Update conversation history
+        self.conversation_history.extend([
+            f"User: {user_query}",
+            f"Assistant: {final_response}"
+        ])
         
-        # Update conversation tracking
-        self._update_conversation_tracking(user_input, enhanced_response)
+        # Extract symptoms for analysis
+        symptoms = self._extract_symptoms(user_query)
+        severity_score = self._assess_severity(user_query, symptoms)
         
-        # Create conversation entry
-        entry = ConversationEntry(
+        # Store conversation data
+        conversation_entry = ConversationEntry(
             timestamp=timestamp,
-            user_input=user_input,
-            assistant_response=enhanced_response,
-            conversation_phase=self.conversation_state.phase,
-            symptoms=list(self.conversation_state.symptoms_discussed.keys()),
-            severity_score=self._calculate_severity(),
-            confidence_score=0.8,  # Placeholder
-            search_queries_used=[user_input] if search_results else [],
-            follow_up_questions=follow_up_questions,
-            agent_insights={primary_agent.agent_id: primary_insights, **supporting_insights}
+            user_input=user_query,
+            assistant_response=final_response,
+            symptoms=symptoms,
+            severity_score=severity_score,
+            confidence_score=main_confidence,
+            search_queries_used=[user_query]
         )
         
-        self.conversation_data.append(entry)
+        self.conversation_data.append(conversation_entry)
         
         return {
-            'response': enhanced_response,
-            'follow_up_questions': follow_up_questions,
-            'conversation_phase': self.conversation_state.phase,
-            'urgency_level': self.conversation_state.urgency_level,
-            'primary_agent': primary_agent.agent_id,
-            'supporting_agents': supporting_agents,
-            'agent_insights': {primary_agent.agent_id: primary_insights, **supporting_insights},
-            'patient_summary': self._get_patient_summary(),
-            'search_performed': bool(search_results)
+            'response': final_response,
+            'confidence': main_confidence,
+            'severity_score': severity_score,
+            'symptoms_detected': symptoms,
+            'agents_consulted': relevant_agents,
+            'agent_responses': agent_responses,
+            'search_performed': True
         }
     
-    def _update_conversation_phase(self, user_input: str):
-        """Update conversation phase based on user input and history"""
-        input_lower = user_input.lower()
-        
-        if self.conversation_state.conversation_depth == 1:
-            self.conversation_state.phase = "greeting"
-        elif any(word in input_lower for word in ["history", "medical", "medication", "allergy"]):
-            self.conversation_state.phase = "history_taking"
-        elif any(word in input_lower for word in ["pain", "symptom", "feel", "hurt"]):
-            self.conversation_state.phase = "symptom_exploration"
-        elif any(word in input_lower for word in ["what should", "recommend", "treatment", "help"]):
-            self.conversation_state.phase = "recommendations"
-        elif self.conversation_state.conversation_depth > 3:
-            self.conversation_state.phase = "follow_up"
-    
-    def _extract_patient_information(self, user_input: str):
-        """Extract and store patient information from conversation"""
-        input_lower = user_input.lower()
-        
-        # Extract symptoms
-        symptom_patterns = {
-            'headache': ['headache', 'head pain', 'migraine'],
-            'fever': ['fever', 'temperature', 'hot', 'chills'],
-            'nausea': ['nausea', 'sick', 'throw up', 'vomit'],
-            'fatigue': ['tired', 'exhausted', 'fatigue', 'weak'],
-            'cough': ['cough', 'coughing'],
-            'pain': ['pain', 'hurt', 'ache', 'sore']
-        }
+    def _select_relevant_agents(self, query: str) -> List[str]:
+        """Select most relevant agents for the query"""
+        query_lower = query.lower()
+        relevant_agents = ["general_practitioner"]  # Always include GP
         
-        for symptom, patterns in symptom_patterns.items():
-            if any(pattern in input_lower for pattern in patterns):
-                if symptom not in self.conversation_state.symptoms_discussed:
-                    self.conversation_state.symptoms_discussed[symptom] = {
-                        'first_mentioned': datetime.now().isoformat(),
-                        'details': []
-                    }
-                self.conversation_state.symptoms_discussed[symptom]['details'].append(user_input)
-        
-        # Extract duration information
-        duration_patterns = [
-            r'(\d+)\s+(day|days|week|weeks|month|months)',
-            r'(yesterday|today|last night)',
-            r'(few days|several days|about a week)'
-        ]
+        # Mental health keywords
+        mental_health_keywords = ["stress", "anxiety", "depression", "sleep", "mood", "worry", "panic", "sad"]
+        if any(keyword in query_lower for keyword in mental_health_keywords):
+            relevant_agents.append("mental_health")
         
-        for pattern in duration_patterns:
-            matches = re.search(pattern, input_lower)
-            if matches:
-                self.conversation_state.medical_history['duration'] = matches.group(0)
-                break
-    
-    def _select_primary_agent(self, user_input: str) -> ConversationalMedicalAgent:
-        """Select the primary agent to handle this conversation turn"""
-        input_lower = user_input.lower()
-        
-        # Emergency situations
-        emergency_keywords = ["chest pain", "can't breathe", "emergency", "severe", "blood"]
-        if any(keyword in input_lower for keyword in emergency_keywords):
-            return self.agents["emergency_consultant"]
-        
-        # Mental health focus
-        mental_keywords = ["stress", "anxiety", "depression", "worried", "scared", "panic"]
-        if any(keyword in input_lower for keyword in mental_keywords):
-            return self.agents["mental_health_counselor"]
-        
-        # Wellness and prevention
-        wellness_keywords = ["prevent", "healthy", "lifestyle", "diet", "exercise"]
-        if any(keyword in input_lower for keyword in wellness_keywords):
-            return self.agents["wellness_coach"]
-        
-        # Symptom analysis
-        symptom_keywords = ["symptom", "pain", "hurt", "feel", "experience"]
-        if any(keyword in input_lower for keyword in symptom_keywords):
-            return self.agents["symptom_specialist"]
-        
-        # Default to primary physician
-        return self.agents["primary_physician"]
-    
-    def _enhance_with_llm(self, user_input: str, agent_response: str, state: ConversationState) -> str:
-        """Enhance response with LLM for natural conversation"""
+        # Emergency keywords
+        emergency_keywords = ["severe", "intense", "emergency", "urgent", "chest pain", "difficulty breathing", "blood"]
+        if any(keyword in query_lower for keyword in emergency_keywords):
+            relevant_agents.append("emergency_assessor")
         
-        conversation_context = "\n".join(self.conversation_history[-6:])  # Last 3 exchanges
+        # Wellness keywords
+        wellness_keywords = ["prevention", "healthy", "nutrition", "exercise", "lifestyle", "diet"]
+        if any(keyword in query_lower for keyword in wellness_keywords):
+            relevant_agents.append("wellness_advisor")
         
-        prompt = f"""
-        You are having a natural, empathetic medical conversation with a patient. 
+        # Always include symptom analyzer for health queries
+        if any(keyword in query_lower for keyword in ["pain", "ache", "hurt", "symptom", "feel"]):
+            relevant_agents.append("symptom_analyzer")
         
-        Conversation context: {conversation_context}
+        return list(set(relevant_agents))
+    
+    def _combine_responses(self, main_response: str, agent_responses: Dict) -> str:
+        """Intelligently combine responses from multiple agents"""
+        if not agent_responses:
+            return main_response
         
-        Patient just said: "{user_input}"
+        combined = main_response + "\n\n**Specialist Insights:**\n"
+        for agent_name, data in agent_responses.items():
+            if data['confidence'] > 0.6:  # Only include confident responses
+                combined += f"\n• **{data['specialization']}**: {data['response'][:200]}...\n"
         
-        Current conversation phase: {state.phase}
-        Patient's concerns so far: {', '.join(state.patient_concerns)}
-        Symptoms discussed: {', '.join(state.symptoms_discussed.keys())}
+        return combined
+    
+    def _extract_symptoms(self, query: str) -> List[str]:
+        """Extract symptoms from user query"""
+        common_symptoms = [
+            'fever', 'headache', 'nausea', 'pain', 'cough', 'fatigue', 'dizziness',
+            'rash', 'swelling', 'shortness of breath', 'chest pain', 'abdominal pain'
+        ]
         
-        Agent suggested response: {agent_response}
+        query_lower = query.lower()
+        detected_symptoms = [symptom for symptom in common_symptoms if symptom in query_lower]
+        return detected_symptoms
+    
+    def _assess_severity(self, query: str, symptoms: List[str]) -> float:
+        """Assess severity of reported symptoms (0-10 scale)"""
+        severity_score = 0.0
+        query_lower = query.lower()
         
-        Please provide a natural, conversational response that:
-        1. Shows empathy and understanding
-        2. Builds on the conversation naturally
-        3. Asks relevant follow-up questions
-        4. Maintains a professional but warm tone
-        5. Always emphasizes the need for professional medical care
+        # High severity indicators
+        high_severity = ["severe", "intense", "unbearable", "emergency", "chest pain", "difficulty breathing"]
+        medium_severity = ["moderate", "persistent", "recurring", "worse", "concerning"]
         
-        Keep the response conversational and avoid being too clinical or robotic.
-        """
+        if any(indicator in query_lower for indicator in high_severity):
+            severity_score += 7.0
+        elif any(indicator in query_lower for indicator in medium_severity):
+            severity_score += 4.0
+        else:
+            severity_score += 2.0
         
-        try:
-            enhanced_response, _ = self.llm.generate_response(prompt, self.conversation_history)
-            return enhanced_response
-        except Exception as e:
-            return agent_response  # Fallback to agent response
-    
-    def _get_patient_summary(self) -> Dict:
-        """Generate a summary of the patient's current situation"""
-        return {
-            'chief_concerns': self.conversation_state.patient_concerns,
-            'symptoms_discussed': list(self.conversation_state.symptoms_discussed.keys()),
-            'conversation_depth': self.conversation_state.conversation_depth,
-            'current_phase': self.conversation_state.phase,
-            'urgency_level': self.conversation_state.urgency_level,
-            'questions_asked': len(self.conversation_state.questions_asked)
-        }
-
-# Continue with the rest of the implementation...
-# [The rest of the classes like GroqLLM, MedicalSearchTool would remain the same but with enhanced conversational capabilities]
-
-class GroqLLM:
-    """Medical-optimized LLM client with conversational enhancement"""
-    
-    def __init__(self, model_name="openai/gpt-oss-20b"):
-        self.client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
-        self.model_name = model_name
-        self.medical_context = """
-        You are an empathetic AI medical assistant having a natural conversation with a patient. 
-        Your responses should be:
-        - Conversational and warm, not clinical or robotic
-        - Empathetic to the patient's concerns
-        - Informative but accessible
-        - Always emphasizing the importance of professional medical care
-        
-        Remember: This is a conversation, not a medical exam. Show genuine care and understanding.
-        """
+        # Add points for multiple symptoms
+        severity_score += min(len(symptoms) * 0.5, 2.0)
+        
+        return min(severity_score, 10.0)
     
-    def generate_response(self, prompt: str, conversation_history: List[str] = None) -> Tuple[str, float]:
-        """Generate conversational response"""
-        try:
-            context = self.medical_context
-            if conversation_history:
-                recent_history = conversation_history[-6:]  # Last 3 exchanges
-                context += f"\n\nRecent conversation:\n{chr(10).join(recent_history)}"
-            
-            full_prompt = f"{context}\n\n{prompt}"
+    def update_agent_performance(self, query_index: int, feedback_score: int, was_helpful: bool):
+        """Update agent performance based on user feedback"""
+        if query_index < len(self.conversation_data):
+            entry = self.conversation_data[query_index]
+            entry.user_feedback = feedback_score
+            entry.was_helpful = was_helpful
             
-            completion = self.client.chat.completions.create(
-                model=self.model_name,
-                messages=[{"role": "user", "content": full_prompt}],
-                temperature=0.7,  # Higher temperature for more natural conversation
-                max_tokens=1000,
-                stream=False
-            )
-            
-            response = completion.choices[0].message.content if completion.choices else "I'm here to help. Could you tell me more about what's concerning you?"
-            confidence = self._calculate_conversational_confidence(response, prompt)
-            
-            return response, confidence
-            
-        except Exception as e:
-            return "I'm here to listen and help. Could you share more about what's been concerning you?", 0.5
+            # Update all agents that were involved in this query
+            for agent in self.agents.values():
+                agent.update_from_feedback(entry.user_input, entry.assistant_response, feedback_score, was_helpful)
     
-    def _calculate_conversational_confidence(self, response: str, query: str) -> float:
-        """Calculate confidence for conversational responses"""
-        confidence = 0.5  # Base confidence
+    def get_system_metrics(self) -> Dict:
+        """Get comprehensive system performance metrics"""
+        total_conversations = len(self.conversation_data)
         
-        # Check for empathetic language
-        empathy_words = ["understand", "concerning", "help", "support", "care", "here for you"]
-        if any(word in response.lower() for word in empathy_words):
-            confidence += 0.2
+        if total_conversations == 0:
+            return {"status": "No conversations yet"}
         
-        # Check for medical disclaimers
-        if any(phrase in response.lower() for phrase in ["healthcare provider", "medical professional", "doctor", "consult"]):
-            confidence += 0.2
+        avg_confidence = np.mean([entry.confidence_score for entry in self.conversation_data])
+        avg_severity = np.mean([entry.severity_score for entry in self.conversation_data])
         
-        # Check for conversational elements
-        if any(phrase in response for phrase in ["?", "tell me", "share", "describe"]):
-            confidence += 0.1
+        feedback_entries = [entry for entry in self.conversation_data if entry.user_feedback is not None]
+        avg_feedback = np.mean([entry.user_feedback for entry in feedback_entries]) if feedback_entries else 0
         
-        return min(confidence, 1.0)
-
-class MedicalSearchTool:
-    """Medical search with conversational context"""
-    
-    def __init__(self):
-        self.ddgs = DDGS()
-        self.medical_sources = [
-            "mayoclinic.org", "webmd.com", "healthline.com", "medlineplus.gov",
-            "nih.gov", "who.int", "cdc.gov", "ncbi.nlm.nih.gov"
-        ]
-    
-    def search_medical_info(self, query: str, search_type: str = "symptoms") -> str:
-        """Search with conversational context awareness"""
-        try:
-            medical_queries = {
-                "symptoms": f"symptoms causes {query} patient concerns",
-                "treatment": f"treatment options {query} patient care",
-                "prevention": f"prevention {query} patient education",
-                "general": f"patient information {query} healthcare"
-            }
-            
-            enhanced_query = medical_queries.get(search_type, medical_queries["general"])
-            
-            search_results = list(self.ddgs.text(
-                enhanced_query,
-                max_results=5,
-                region='wt-wt',
-                safesearch='on'
-            ))
-            
-            if not search_results:
-                return "I'll help guide our conversation, though I'd recommend discussing this with your healthcare provider for specific medical advice."
-            
-            formatted_results = []
-            for idx, result in enumerate(search_results, 1):
-                title = result.get('title', 'No title')
-                snippet = result.get('body', 'No description')
-                url = result.get('href', 'No URL')
-                
-                # Prioritize trusted medical sources
-                source_trust = "⭐" if any(source in url for source in self.medical_sources) else ""
-                
-                formatted_results.append(
-                    f"{idx}. {source_trust} {title}\n"
-                    f"   {snippet}\n"
-                    f"   Source: {url}\n"
-                )
-            
-            return "\n".join(formatted_results)
-            
-        except Exception as e:
-            return f"I'm having trouble accessing medical resources right now, but I can still help guide our conversation based on general medical knowledge."
+        return {
+            "total_conversations": total_conversations,
+            "average_confidence": avg_confidence,
+            "average_severity": avg_severity,
+            "average_user_feedback": avg_feedback,
+            "agent_performance": {name: agent.get_expertise_summary() for name, agent in self.agents.items()}
+        }
 
-# Initialize session state for conversational system
-if 'conversational_system' not in st.session_state:
-    st.session_state.conversational_system = ConversationalMedicalSystem()
+# Initialize session state
+if 'medical_system' not in st.session_state:
+    st.session_state.medical_system = MedicalConsultationSystem()
 if 'chat_messages' not in st.session_state:
     st.session_state.chat_messages = []
-if 'conversation_context' not in st.session_state:
-    st.session_state.conversation_context = {}
-if 'typing' not in st.session_state:
-    st.session_state.typing = False
 
-medical_system = st.session_state.conversational_system
+medical_system = st.session_state.medical_system
 
 # Main interface
 st.markdown("""
 <div class="medical-header">
-    <h1>👩‍⚕️ MedChat - Your AI Medical Companion</h1>
-    <p>Natural, empathetic conversations about your health concerns</p>
+    <h1>🏥 MedAssist - AI Medical Preconsultation</h1>
+    <p>Advanced AI-powered medical guidance with evolutionary learning agents</p>
 </div>
 """, unsafe_allow_html=True)
 
@@ -761,294 +598,433 @@ st.markdown("""
 st.markdown("""
 <div class="warning-box">
     <h3>⚠️ Important Medical Disclaimer</h3>
-    <p>I'm here to have a supportive conversation about your health concerns and provide general information. However, I cannot diagnose or treat medical conditions. For proper medical care, please consult with qualified healthcare professionals. In emergencies, contact emergency services immediately.</p>
+    <p>This AI system provides general health information and is NOT a substitute for professional medical advice, diagnosis, or treatment. Always consult with qualified healthcare professionals for medical concerns. In case of emergency, contact emergency services immediately.</p>
 </div>
 """, unsafe_allow_html=True)
 
-# Main chat layout
-col_main, col_sidebar = st.columns([4, 1])
+# Main layout
+col1, col2 = st.columns([3, 1])
 
-with col_main:
-    st.markdown("### 💬 Let's Talk About Your Health")
+with col1:
+    st.markdown("### 💬 Medical Consultation Chat")
     
-    # Display conversation phase
-    if medical_system.conversation_state.phase:
-        phase_display = {
-            "greeting": "👋 Getting to know you",
-            "history_taking": "📋 Understanding your background", 
-            "symptom_exploration": "🔍 Exploring your symptoms",
-            "assessment": "🧠 Assessing the situation",
-            "recommendations": "💡 Discussing next steps",
-            "follow_up": "🔄 Following up on your concerns"
-        }
-        current_phase = phase_display.get(medical_system.conversation_state.phase, "💬 In conversation")
-        st.markdown(f'<div class="conversation-phase">{current_phase}</div>', unsafe_allow_html=True)
-    
-    # Chat container
+    # Chat display area
     chat_container = st.container()
     with chat_container:
         st.markdown('<div class="chat-container">', unsafe_allow_html=True)
         
-        # Display conversation history
         for i, message in enumerate(st.session_state.chat_messages):
             if message["role"] == "user":
-                st.markdown(f'<div class="patient-message">{message["content"]}</div>', unsafe_allow_html=True)
+                st.markdown(f'<div class="user-message">👤 <strong>You:</strong> {message["content"]}</div>', unsafe_allow_html=True)
             else:
-                st.markdown(f'<div class="doctor-message">{message["content"]}</div>', unsafe_allow_html=True)
-                
-                # Show agent insights if available
-                if "insights" in message:
-                    for agent, insight in message["insights"].items():
-                        if insight.get("specialization_note"):
-                            st.markdown(f'<div class="agent-insights"><strong>Specialist Note:</strong> {insight["specialization_note"]}</div>', unsafe_allow_html=True)
+                st.markdown(f'<div class="assistant-message">🤖 <strong>MedAssist:</strong> {message["content"]}</div>', unsafe_allow_html=True)
                 
-                # Show follow-up questions
-                if "follow_up_questions" in message and message["follow_up_questions"]:
-                    st.markdown('<div class="follow-up-questions">', unsafe_allow_html=True)
-                    st.markdown("<strong>I'd like to know more about:</strong>")
-                    for question in message["follow_up_questions"][:3]:  # Show max 3
-                        if st.button(question, key=f"followup_{i}_{hash(question)}", help="Click to discuss this"):
-                            st.session_state.chat_messages.append({"role": "user", "content": question})
-                            st.rerun()
-                    st.markdown('</div>', unsafe_allow_html=True)
-        
-        # Typing indicator
-        if st.session_state.typing:
-            st.markdown('<div class="typing-indicator">Dr. AI is thinking... 💭</div>', unsafe_allow_html=True)
+                # Add feedback buttons for assistant messages
+                col_a, col_b, col_c = st.columns([1, 1, 8])
+                with col_a:
+                    if st.button("👍", key=f"helpful_{i}"):
+                        medical_system.update_agent_performance(i//2, 5, True)
+                        st.success("Feedback recorded!")
+                with col_b:
+                    if st.button("👎", key=f"not_helpful_{i}"):
+                        medical_system.update_agent_performance(i//2, 2, False)
+                        st.info("Feedback recorded. We'll improve!")
         
         st.markdown('</div>', unsafe_allow_html=True)
     
-    # Chat input area
-    st.markdown("---")
-    
-    # Conversation starters for new users
-    if len(st.session_state.chat_messages) == 0:
-        st.markdown("**How can I help you today?** You can start by:")
-        
-        starter_col1, starter_col2, starter_col3 = st.columns(3)
-        
-        with starter_col1:
-            if st.button("💬 Tell me about symptoms I'm having", key="starter_symptoms"):
-                starter_text = "I've been experiencing some symptoms and I'd like to talk about them."
-                st.session_state.chat_messages.append({"role": "user", "content": starter_text})
+    # Chat input
+    with st.container():
+        st.markdown('<div class="chat-input">', unsafe_allow_html=True)
+        user_input = st.text_input("Describe your symptoms or health concerns:", 
+                                 placeholder="e.g., I've been having headaches for 3 days...", 
+                                 key="medical_input")
+        
+        col_send, col_clear = st.columns([1, 4])
+        with col_send:
+            send_message = st.button("Send 📤", type="primary")
+        with col_clear:
+            if st.button("Clear Chat 🗑️"):
+                st.session_state.chat_messages = []
                 st.rerun()
-        
-        with starter_col2:
-            if st.button("🤔 Ask about a health concern", key="starter_concern"):
-                starter_text = "I have a health concern I'd like to discuss."
-                st.session_state.chat_messages.append({"role": "user", "content": starter_text})
-                st.rerun()
-        
-        with starter_col3:
-            if st.button("🩺 Get a health checkup conversation", key="starter_checkup"):
-                starter_text = "I'd like to have a general health discussion."
-                st.session_state.chat_messages.append({"role": "user", "content": starter_text})
-                st.rerun()
-    
-    # Main input area
-    user_input = st.text_area(
-        "What would you like to talk about?", 
-        placeholder="For example: 'I've been having headaches for the past few days...' or 'I'm worried about some symptoms I'm having...'",
-        height=100,
-        key="main_input"
-    )
-    
-    # Input controls
-    input_col1, input_col2, input_col3, input_col4 = st.columns([2, 1, 1, 2])
-    
-    with input_col1:
-        send_message = st.button("💬 Send Message", type="primary")
-    
-    with input_col2:
-        if st.button("🔄 New Topic"):
-            # Save current conversation but start new topic
-            medical_system.conversation_state.phase = "greeting"
-            medical_system.conversation_state.conversation_depth = 0
-            st.success("Ready to discuss a new topic!")
-    
-    with input_col3:
-        if st.button("🗑️ Clear Chat"):
-            st.session_state.chat_messages = []
-            st.session_state.conversational_system = ConversationalMedicalSystem()
-            st.rerun()
+        st.markdown('</div>', unsafe_allow_html=True)
 
-with col_sidebar:
-    st.markdown("### 🤖 Conversation Status")
+with col2:
+    st.markdown("### 🤖 AI Agent Status")
     
-    # Current conversation summary
-    if medical_system.conversation_state.conversation_depth > 0:
-        summary = medical_system._get_patient_summary()
+    # Agent status display
+    for agent_name, agent in medical_system.agents.items():
+        expertise = agent.get_expertise_summary()
         
         st.markdown(f"""
-        <div class="conversation-summary">
-            <h4>📊 Our Conversation</h4>
-            <p><strong>Phase:</strong> {summary['current_phase'].replace('_', ' ').title()}</p>
-            <p><strong>Messages:</strong> {summary['conversation_depth']}</p>
-            <p><strong>Topics Discussed:</strong> {len(summary['symptoms_discussed'])}</p>
-            <p><strong>Priority:</strong> {summary['urgency_level'].title()}</p>
+        <div class="agent-status-card">
+            <h4>{agent.specialization}</h4>
+            <p><strong>Queries:</strong> {expertise['total_queries']}</p>
+            <p><strong>Success Rate:</strong> {expertise['success_rate']:.1f}%</p>
+            <p><strong>Satisfaction:</strong> {expertise['user_satisfaction']:.1f}/5</p>
+            <p><strong>Learning Rate:</strong> {expertise['learning_rate']:.3f}</p>
         </div>
         """, unsafe_allow_html=True)
-        
-        if summary['symptoms_discussed']:
-            st.markdown("**Symptoms We've Discussed:**")
-            for symptom in summary['symptoms_discussed']:
-                st.markdown(f"• {symptom.title()}")
-    
-    # Quick response suggestions
-    st.markdown("### 💡 Quick Responses")
-    
-    quick_responses = [
-        "Yes, that's right",
-        "No, that's not quite right", 
-        "Can you explain more?",
-        "I'm not sure about that",
-        "That makes sense",
-        "What should I do next?",
-        "How serious is this?",
-        "When should I see a doctor?"
-    ]
-    
-    for response in quick_responses[:4]:  # Show only first 4
-        if st.button(response, key=f"quick_{response}", help="Quick response"):
-            st.session_state.chat_messages.append({"role": "user", "content": response})
-            st.rerun()
     
-    # Agent status
-    st.markdown("### 🏥 Medical Team Status")
+    st.markdown("### 📊 System Metrics")
+    metrics = medical_system.get_system_metrics()
     
-    active_agents = ["primary_physician", "symptom_specialist", "wellness_coach"]
-    
-    for agent_id in active_agents:
-        agent = medical_system.agents[agent_id]
-        status_color = "🟢" if agent_id == "primary_physician" else "🟡"
-        st.markdown(f"{status_color} **{agent.specialization}**")
-        st.markdown(f"*{agent.personality.title()} approach*")
-        st.markdown("---")
-    
-    # Emergency reminder
-    st.markdown("""
-    <div style="background: rgba(244, 67, 54, 0.1); border: 2px solid #F44336; border-radius: 8px; padding: 1rem; margin: 1rem 0;">
-        <h4 style="color: #F44336;">🚨 Emergency?</h4>
-        <p style="color: white;">If you're having a medical emergency, please call emergency services immediately rather than using this chat.</p>
-    </div>
-    """, unsafe_allow_html=True)
+    if "total_conversations" in metrics:
+        st.markdown(f"""
+        <div class="evolution-metrics">
+            <p><strong>Total Chats:</strong> {metrics['total_conversations']}</p>
+            <p><strong>Avg Confidence:</strong> {metrics['average_confidence']:.2f}</p>
+            <p><strong>Avg Severity:</strong> {metrics['average_severity']:.1f}/10</p>
+            <p><strong>User Rating:</strong> {metrics['average_user_feedback']:.1f}/5</p>
+        </div>
+        """, unsafe_allow_html=True)
 
 # Process user input
 if send_message and user_input:
     # Add user message
     st.session_state.chat_messages.append({"role": "user", "content": user_input})
     
-    # Show typing indicator
-    st.session_state.typing = True
-    st.rerun()
-    
-    # Process the conversational query
-    with st.spinner("Having a thoughtful conversation..."):
-        result = medical_system.process_conversational_query(user_input)
-        
-        # Create assistant message with all context
-        assistant_message = {
-            "role": "assistant", 
-            "content": result['response'],
-            "follow_up_questions": result.get('follow_up_questions', []),
-            "insights": result.get('agent_insights', {}),
-            "phase": result.get('conversation_phase', ''),
-            "urgency": result.get('urgency_level', 'routine')
-        }
+    # Show thinking indicator
+    with st.spinner("🧠 AI agents are analyzing your query..."):
+        # Process the query
+        result = medical_system.process_medical_query(user_input)
         
-        st.session_state.chat_messages.append(assistant_message)
+        # Add assistant response
+        response_content = result['response']
         
-        # Update conversation context
-        st.session_state.conversation_context = {
-            'phase': result['conversation_phase'],
-            'urgency': result['urgency_level'],
-            'primary_agent': result['primary_agent'],
-            'patient_summary': result['patient_summary']
-        }
+        # Add severity and confidence info
+        if result['severity_score'] > 7:
+            response_content += f"\n\n⚠️ **High severity detected ({result['severity_score']:.1f}/10). Please seek immediate medical attention if symptoms are severe.**"
+        elif result['severity_score'] > 4:
+            response_content += f"\n\n⚡ **Moderate severity detected ({result['severity_score']:.1f}/10). Consider scheduling a medical appointment.**"
+        
+        if result['symptoms_detected']:
+            response_content += f"\n\n🔍 **Detected symptoms:** {', '.join(result['symptoms_detected'])}"
+        
+        response_content += f"\n\n🤖 **Confidence Score:** {result['confidence']:.2f} | **Agents Consulted:** {', '.join(result['agents_consulted'])}"
+        
+        st.session_state.chat_messages.append({"role": "assistant", "content": response_content})
     
-    # Remove typing indicator
-    st.session_state.typing = False
     st.rerun()
 
-# Auto-follow-up system
-if len(st.session_state.chat_messages) > 0:
-    last_message = st.session_state.chat_messages[-1]
+# Sidebar with additional features
+with st.sidebar:
+    st.markdown("### 🛠️ System Controls")
     
-    if (last_message["role"] == "assistant" and 
-        medical_system.conversation_state.conversation_depth > 2 and
-        medical_system.conversation_state.phase not in ["recommendations", "follow_up"]):
-        
-        # Suggest natural follow-up after a few exchanges
-        if len(st.session_state.chat_messages) % 6 == 0:  # Every 3 exchanges
-            st.info("💭 Would you like me to summarize what we've discussed so far, or is there something specific you'd like to explore further?")
+    if st.button("🔄 Reset System"):
+        st.session_state.medical_system = MedicalConsultationSystem()
+        st.session_state.chat_messages = []
+        st.rerun()
+    
+    st.markdown("### 📈 Learning Analytics")
+    if st.button("📊 View Detailed Analytics"):
+        st.session_state.show_analytics = True
+    
+    if st.button("💾 Export Chat History"):
+        if st.session_state.chat_messages:
+            chat_data = {
+                'timestamp': datetime.now().isoformat(),
+                'messages': st.session_state.chat_messages,
+                'system_metrics': medical_system.get_system_metrics()
+            }
+            st.download_button(
+                label="Download Chat Data",
+                data=json.dumps(chat_data, indent=2),
+                file_name=f"medical_chat_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                mime="application/json"
+            )
+        else:
+            st.warning("No chat history to export")
+    
+    st.markdown("### 🎯 Quick Health Topics")
+    quick_topics = [
+        "Common cold symptoms",
+        "Headache causes",
+        "Stress management",
+        "Sleep problems",
+        "Healthy diet tips",
+        "Exercise recommendations"
+    ]
+    
+    for topic in quick_topics:
+        if st.button(f"💡 {topic}", key=f"topic_{topic.replace(' ', '_')}"):
+            st.session_state.chat_messages.append({"role": "user", "content": f"Tell me about {topic.lower()}"})
+            
+            with st.spinner("🧠 Processing..."):
+                result = medical_system.process_medical_query(f"Tell me about {topic.lower()}")
+                response_content = result['response']
+                
+                if result['symptoms_detected']:
+                    response_content += f"\n\n🔍 **Related symptoms:** {', '.join(result['symptoms_detected'])}"
+                
+                response_content += f"\n\n🤖 **Confidence:** {result['confidence']:.2f}"
+                st.session_state.chat_messages.append({"role": "assistant", "content": response_content})
+            
+            st.rerun()
 
-# Conversation analytics (simplified)
-if st.sidebar.button("📊 View Conversation Insights"):
-    st.sidebar.markdown("### 📈 Conversation Analytics")
+# Analytics Dashboard (if requested)
+if st.session_state.get('show_analytics', False):
+    st.markdown("---")
+    st.markdown("## 📊 Detailed System Analytics")
+    
+    metrics = medical_system.get_system_metrics()
+    
+    if "agent_performance" in metrics:
+        # Agent Performance Comparison
+        st.markdown("### 🤖 Agent Performance Analysis")
+        
+        agent_data = []
+        for agent_name, performance in metrics["agent_performance"].items():
+            agent_data.append({
+                'Agent': performance['specialization'],
+                'Success Rate (%)': performance['success_rate'],
+                'User Satisfaction': performance['user_satisfaction'],
+                'Learning Rate': performance['learning_rate'],
+                'Total Queries': performance['total_queries']
+            })
+        
+        if agent_data:
+            df_agents = pd.DataFrame(agent_data)
+            st.dataframe(df_agents, use_container_width=True)
+            
+            # Performance charts
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown("#### Success Rate by Agent")
+                if not df_agents.empty:
+                    st.bar_chart(df_agents.set_index('Agent')['Success Rate (%)'])
+            
+            with col2:
+                st.markdown("#### User Satisfaction by Agent")
+                if not df_agents.empty:
+                    st.bar_chart(df_agents.set_index('Agent')['User Satisfaction'])
+    
+    # Conversation Analysis
+    st.markdown("### 💬 Conversation Analysis")
     
     if medical_system.conversation_data:
-        # Simple metrics
-        total_exchanges = len(medical_system.conversation_data)
-        avg_response_length = np.mean([len(entry.assistant_response) for entry in medical_system.conversation_data])
-        phases_covered = set([entry.conversation_phase for entry in medical_system.conversation_data])
-        
-        st.sidebar.metric("Total Exchanges", total_exchanges)
-        st.sidebar.metric("Avg Response Length", f"{avg_response_length:.0f} chars")
-        st.sidebar.metric("Conversation Phases", len(phases_covered))
-        
-        # Conversation flow
-        st.sidebar.markdown("**Conversation Flow:**")
-        for entry in medical_system.conversation_data[-5:]:  # Last 5
-            st.sidebar.markdown(f"• {entry.conversation_phase.replace('_', ' ').title()}")
-
-# Export conversation
-if st.sidebar.button("💾 Save Our Conversation"):
-    if st.session_state.chat_messages:
-        conversation_export = {
-            'timestamp': datetime.now().isoformat(),
-            'conversation_summary': st.session_state.conversation_context,
-            'messages': st.session_state.chat_messages,
-            'patient_summary': medical_system._get_patient_summary(),
-            'total_exchanges': medical_system.conversation_state.conversation_depth
-        }
+        conversation_df = pd.DataFrame([asdict(entry) for entry in medical_system.conversation_data])
         
-        st.sidebar.download_button(
-            label="📄 Download Conversation",
-            data=json.dumps(conversation_export, indent=2),
-            file_name=f"medical_conversation_{datetime.now().strftime('%Y%m%d_%H%M')}.json",
-            mime="application/json"
-        )
-        st.sidebar.success("Conversation ready for download!")
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Total Conversations", len(conversation_df))
+            avg_confidence = conversation_df['confidence_score'].mean()
+            st.metric("Average Confidence", f"{avg_confidence:.2f}")
+        
+        with col2:
+            avg_severity = conversation_df['severity_score'].mean()
+            st.metric("Average Severity", f"{avg_severity:.1f}/10")
+            
+            feedback_data = conversation_df[conversation_df['user_feedback'].notna()]
+            if not feedback_data.empty:
+                avg_feedback = feedback_data['user_feedback'].mean()
+                st.metric("Average User Rating", f"{avg_feedback:.1f}/5")
+        
+        with col3:
+            symptoms_detected = sum(len(symptoms) for symptoms in conversation_df['symptoms'])
+            st.metric("Total Symptoms Detected", symptoms_detected)
+            
+            helpful_responses = conversation_df['was_helpful'].sum() if 'was_helpful' in conversation_df else 0
+            st.metric("Helpful Responses", helpful_responses)
+        
+        # Severity distribution
+        st.markdown("#### Severity Score Distribution")
+        severity_counts = conversation_df['severity_score'].value_counts().sort_index()
+        st.bar_chart(severity_counts)
+        
+        # Most common symptoms
+        st.markdown("#### Most Common Symptoms")
+        all_symptoms = []
+        for symptoms_list in conversation_df['symptoms']:
+            all_symptoms.extend(symptoms_list)
+        
+        if all_symptoms:
+            symptom_counts = pd.Series(all_symptoms).value_counts().head(10)
+            st.bar_chart(symptom_counts)
+        else:
+            st.info("No symptoms data available yet")
+        
+        # Timeline analysis
+        st.markdown("#### Usage Timeline")
+        conversation_df['timestamp'] = pd.to_datetime(conversation_df['timestamp'])
+        daily_usage = conversation_df.groupby(conversation_df['timestamp'].dt.date).size()
+        st.line_chart(daily_usage)
+    
+    else:
+        st.info("No conversation data available for analysis yet")
+    
+    # Learning Progress
+    st.markdown("### 🧠 AI Learning Progress")
+    
+    for agent_name, agent in medical_system.agents.items():
+        with st.expander(f"📖 {agent.specialization} Learning Details"):
+            expertise = agent.get_expertise_summary()
+            
+            st.write(f"**Total Experience:** {expertise['total_queries']} queries processed")
+            st.write(f"**Current Learning Rate:** {expertise['learning_rate']:.4f}")
+            st.write(f"**Performance Trend:** {'Improving' if expertise['user_satisfaction'] > 3.5 else 'Learning'}")
+            
+            if expertise['top_expertise_areas']:
+                st.write("**Top Expertise Areas:**")
+                for area, score in expertise['top_expertise_areas'].items():
+                    st.write(f"  • {area.title()}: {score:.2f}")
+            
+            # Learning memory (last few interactions)
+            if hasattr(agent, 'learning_memory') and agent.learning_memory:
+                st.write("**Recent Learning Events:**")
+                for memory in agent.learning_memory[-3:]:
+                    reward_emoji = "✅" if memory['reward'] > 0 else "❌" if memory['reward'] < 0 else "➡️"
+                    st.write(f"  {reward_emoji} Reward: {memory['reward']:.2f} | Query: {memory['query'][:50]}...")
+    
+    if st.button("🔄 Close Analytics"):
+        st.session_state.show_analytics = False
+        st.rerun()
 
-# Health reminders
+# Health Tips Section
 st.markdown("---")
-st.markdown("### 🌟 Gentle Health Reminders")
+st.markdown("### 🌟 Daily Health Tips")
+
+health_tips = [
+    "💧 Stay hydrated: Aim for 8-10 glasses of water daily",
+    "🚶 Take regular walks: Even 10 minutes can boost your mood",
+    "😴 Maintain sleep hygiene: 7-9 hours of quality sleep is essential",
+    "🥗 Eat colorful foods: Variety ensures you get different nutrients",
+    "🧘 Practice mindfulness: Just 5 minutes of meditation can reduce stress",
+    "📱 Take breaks from screens: Follow the 20-20-20 rule",
+    "🤝 Stay connected: Social connections are vital for mental health",
+    "☀️ Get sunlight: 15 minutes of sunlight helps with Vitamin D"
+]
+
+# Display a random tip
+import random
+daily_tip = random.choice(health_tips)
+st.info(f"**💡 Today's Health Tip:** {daily_tip}")
 
-reminders_col1, reminders_col2 = st.columns(2)
+# Emergency Resources Section
+st.markdown("### 🚨 Emergency Resources")
 
-with reminders_col1:
+emergency_col1, emergency_col2 = st.columns(2)
+
+with emergency_col1:
     st.markdown("""
-    **💧 Daily Wellness:**
-    • Stay hydrated throughout the day
-    • Take breaks from screens regularly
-    • Practice deep breathing
-    • Get some sunlight when possible
+    **🆘 When to Seek Immediate Help:**
+    - Chest pain or difficulty breathing
+    - Severe allergic reactions
+    - Loss of consciousness
+    - Severe bleeding
+    - Signs of stroke (FAST test)
+    - Severe burns
     """)
 
-with reminders_col2:
+with emergency_col2:
     st.markdown("""
-    **🤝 Remember:**
-    • This chat supplements, doesn't replace medical care
-    • Trust your instincts about your body
-    • Don't hesitate to seek professional help
-    • Your health concerns are always valid
+    **📞 Emergency Contacts:**
+    - Emergency Services: 911 (US), 112 (EU)
+    - Poison Control: 1-800-222-1222 (US)
+    - Mental Health Crisis: 988 (US)
+    - Text HOME to 741741 (Crisis Text Line)
+    
+    **🏥 Find Nearest Hospital:**
+    Use your maps app or call emergency services
     """)
 
-# Footer
+# Data Persistence and Learning Enhancement
+class DataPersistence:
+    """Handle data persistence for learning and analytics"""
+    
+    def __init__(self, data_dir: str = "medical_ai_data"):
+        self.data_dir = data_dir
+        os.makedirs(data_dir, exist_ok=True)
+    
+    def save_conversation_data(self, system: MedicalConsultationSystem):
+        """Save conversation data for future learning"""
+        try:
+            data_file = os.path.join(self.data_dir, f"conversations_{datetime.now().strftime('%Y%m%d')}.json")
+            
+            conversations = []
+            for entry in system.conversation_data:
+                conversations.append(asdict(entry))
+            
+            with open(data_file, 'w') as f:
+                json.dump(conversations, f, indent=2)
+                
+            return True
+        except Exception as e:
+            st.error(f"Failed to save data: {str(e)}")
+            return False
+    
+    def save_agent_knowledge(self, system: MedicalConsultationSystem):
+        """Save agent learning data"""
+        try:
+            for agent_name, agent in system.agents.items():
+                agent_file = os.path.join(self.data_dir, f"agent_{agent_name}_knowledge.pkl")
+                
+                agent_data = {
+                    'knowledge_base': dict(agent.knowledge_base),
+                    'performance': asdict(agent.performance),
+                    'learning_memory': agent.learning_memory[-100:]  # Keep last 100 entries
+                }
+                
+                with open(agent_file, 'wb') as f:
+                    pickle.dump(agent_data, f)
+            
+            return True
+        except Exception as e:
+            st.error(f"Failed to save agent knowledge: {str(e)}")
+            return False
+    
+    def load_agent_knowledge(self, system: MedicalConsultationSystem):
+        """Load previously saved agent knowledge"""
+        try:
+            for agent_name, agent in system.agents.items():
+                agent_file = os.path.join(self.data_dir, f"agent_{agent_name}_knowledge.pkl")
+                
+                if os.path.exists(agent_file):
+                    with open(agent_file, 'rb') as f:
+                        agent_data = pickle.load(f)
+                    
+                    # Restore knowledge base
+                    agent.knowledge_base = defaultdict(float, agent_data.get('knowledge_base', {}))
+                    
+                    # Restore learning memory
+                    agent.learning_memory = agent_data.get('learning_memory', [])
+                    
+                    # Restore performance metrics
+                    if 'performance' in agent_data:
+                        perf_data = agent_data['performance']
+                        agent.performance.total_queries = perf_data.get('total_queries', 0)
+                        agent.performance.successful_responses = perf_data.get('successful_responses', 0)
+                        agent.performance.average_confidence = perf_data.get('average_confidence', 0.0)
+                        agent.performance.user_satisfaction = perf_data.get('user_satisfaction', 0.0)
+                        agent.performance.learning_rate = perf_data.get('learning_rate', 0.01)
+            
+            return True
+        except Exception as e:
+            st.error(f"Failed to load agent knowledge: {str(e)}")
+            return False
+
+# Initialize data persistence
+if 'data_persistence' not in st.session_state:
+    st.session_state.data_persistence = DataPersistence()
+
+# Load previous learning data when system starts
+if 'knowledge_loaded' not in st.session_state:
+    st.session_state.data_persistence.load_agent_knowledge(medical_system)
+    st.session_state.knowledge_loaded = True
+
+# Auto-save functionality
+if len(st.session_state.chat_messages) > 0 and len(st.session_state.chat_messages) % 10 == 0:
+    # Save data every 10 messages
+    st.session_state.data_persistence.save_conversation_data(medical_system)
+    st.session_state.data_persistence.save_agent_knowledge(medical_system)
+
+# Footer with system information
+st.markdown("---")
 st.markdown("""
-<div style="text-align: center; padding: 2rem; opacity: 0.8; border-top: 1px solid rgba(255,255,255,0.2); margin-top: 2rem;">
-    <p><strong>MedChat - Conversational Medical AI</strong></p>
-    <p>Providing empathetic, intelligent health conversations • Always encouraging professional medical care</p>
-    <p><small>This AI system is designed to have supportive conversations about health topics and encourage appropriate medical care.</small></p>
+<div style="text-align: center; padding: 2rem; opacity: 0.8;">
+    <p><strong>MedAssist v1.0</strong> | AI-Powered Medical Preconsultation System</p>
+    <p>🤖 Evolutionary Learning Agents • 🔍 Real-time Medical Search • 💬 Intelligent Chat Interface</p>
+    <p><small>⚠️ This system is for informational purposes only and is not a substitute for professional medical advice</small></p>
 </div>
 """, unsafe_allow_html=True)