Upload 3 files

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Ollama
+RUN curl -fsSL https://ollama.com/install.sh | sh
+
+# Set working directory
+WORKDIR /code
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Create directory for Ollama
+RUN mkdir -p /root/.ollama
+
+# Expose port
+EXPOSE 7860
+
+# Start Ollama service and then the app
+CMD ollama serve & sleep 10 && ollama pull llm_hub/child_trauma_gemma && python app.py 

README.md

@@ -1,11 +1,12 @@
 ---
-title: Another Test
+title: Testing Gradio Ollama
 emoji: 📊
-colorFrom: yellow
-colorTo: yellow
+colorFrom: gray
+colorTo: gray
 sdk: docker
+app_port: 7860
 pinned: false
-short_description: another test
+short_description: testing gradio with ollama using docker
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,1020 @@
+import os
+import threading
+import time
+import subprocess
+import gradio as gr
+import json
+import random
+from datetime import datetime
+import uuid
+import requests
+from requests.exceptions import ConnectionError, RequestException
+from dotenv import load_dotenv
+from supabase import create_client, Client
+from ollama import chat
+from pydantic import BaseModel
+
+# Ollama setup for Docker spaces
+print("Ollama should be running via Docker startup...")
+time.sleep(5)  # Give Ollama time to start
+
+# Test Ollama connection
+try:
+    # Simple test to see if Ollama is available
+    result = subprocess.run("ollama list", shell=True, capture_output=True, text=True)
+    print("Ollama status:", result.stdout)
+    print("Model should be available via Docker startup...")
+except Exception as e:
+    print(f"Ollama check failed: {e}")
+
+model_name = "llm_hub/child_trauma_gemma"
+
+# Load environment variables
+load_dotenv()
+
+# Pydantic model for structured report generation
+class RiskAssessment(BaseModel):
+    parent_observations: str
+    ai_analysis: str 
+    severity_score: int
+    risk_indicators: list[str]
+    cultural_context: str
+
+class EnhancedTraumaAssessmentApp:
+    def __init__(self):
+        self.report_data = {
+            "child_info": {
+                "name": "",
+                "age": 0,
+                "gender": "",
+                "location": ""
+            },
+            "assessment_data": {
+                "parent_observations": "",
+                "ai_analysis": "",
+                "severity_score": 0,
+                "risk_indicators": [],
+                "cultural_context": ""
+            },
+            "media_attachments": {
+                "drawings": [],
+                "audio_recordings": [],
+                "photos": []
+            },
+            "mobile_app_id": str(uuid.uuid4()),
+            "session_start": datetime.now().isoformat(),
+            "conversation_history": []
+        }
+        self.is_onboarded = False
+        self.submitted_report_id = None
+        self.polling_active = False
+        self.ollama_conversation = []  # Track conversation for the model
+        
+        # Initialize Supabase client
+        self.supabase_url = os.getenv("NEXT_PUBLIC_SUPABASE_URL")
+        self.supabase_key = os.getenv("NEXT_PUBLIC_SUPABASE_ANON_KEY")
+        
+        if self.supabase_url and self.supabase_key:
+            self.supabase: Client = create_client(self.supabase_url, self.supabase_key)
+        else:
+            self.supabase = None
+            print("⚠️ Supabase credentials not found in .env file")
+        
+    def complete_onboarding(self, child_name, child_age, child_gender, child_location):
+        """Complete the onboarding process and store child info"""
+        if not all([child_name, child_age, child_gender, child_location]):
+            return False, "Please fill in all required information about your child."
+        
+        self.report_data["child_info"] = {
+            "name": child_name,
+            "age": int(child_age),
+            "gender": child_gender,
+            "location": child_location
+        }
+        self.is_onboarded = True
+        
+        # Generate cultural context based on location
+        self.report_data["assessment_data"]["cultural_context"] = self.generate_cultural_context(child_location)
+        
+        return True, f"Welcome! I'm ready to help you with {child_name}'s assessment."
+    
+    def generate_cultural_context(self, location):
+        """Generate appropriate cultural context based on location"""
+        location_lower = location.lower()
+        if any(keyword in location_lower for keyword in ['gaza', 'palestine', 'west bank']):
+            return "Assessment conducted considering ongoing conflict exposure and displacement trauma"
+        elif any(keyword in location_lower for keyword in ['ukraine', 'kyiv', 'kharkiv', 'mariupol']):
+            return "Assessment considering war-related trauma and displacement from conflict zones"
+        elif any(keyword in location_lower for keyword in ['syria', 'lebanon', 'jordan']):
+            return "Assessment considering refugee experience and cultural adaptation challenges"
+        else:
+            return f"Assessment conducted with consideration for local cultural context in {location}"
+    
+    def add_message(self, history, message):
+        """Add user message with multimodal support"""
+        if not self.is_onboarded:
+            return history, gr.MultimodalTextbox(value=None, interactive=False)
+        
+        # Handle file uploads
+        if message.get("files"):
+            for file in message["files"]:
+                file_type = self.classify_file_type(file)
+                history.append({
+                    "role": "user", 
+                    "content": {"path": file}
+                })
+                
+                # Store in report data
+                if file_type == "image":
+                    # Determine if it's a drawing or photo based on content analysis
+                    attachment_type = "drawings" if "draw" in file.lower() else "photos"
+                    self.report_data["media_attachments"][attachment_type].append({
+                        "path": file,
+                        "timestamp": datetime.now().isoformat()
+                    })
+                    print(f"Image file detected: {file}")
+        
+        # Handle text message
+        if message.get("text"):
+            history.append({
+                "role": "user", 
+                "content": message["text"]
+            })
+            # Add to conversation history for model
+            self.ollama_conversation.append({
+                "role": "user", 
+                "content": message["text"]
+            })
+            # Add to parent observations
+            current_obs = self.report_data["assessment_data"]["parent_observations"]
+            self.report_data["assessment_data"]["parent_observations"] = (
+                current_obs + " " + message["text"] if current_obs else message["text"]
+            )
+        
+        # Store conversation history
+        self.report_data["conversation_history"] = history
+        return history, gr.MultimodalTextbox(value=None, interactive=False)
+    
+    def classify_file_type(self, file_path):
+        """Classify uploaded file type"""
+        if file_path.lower().endswith(('.jpg', '.jpeg', '.png', '.gif', '.bmp')):
+            return "image"
+        else:
+            return "other"
+    
+    def bot_response(self, history):
+        """Generate bot response using Ollama model"""
+        if not history or not self.is_onboarded:
+            return
+            
+        # Get the last user message
+        last_message = ""
+        has_image = False
+        image_path = None
+        
+        for msg in reversed(history):
+            if msg["role"] == "user":
+                if isinstance(msg["content"], str):
+                    last_message = msg["content"]
+                    break
+                elif isinstance(msg["content"], dict) and "path" in msg["content"]:
+                    has_image = True
+                    image_path = msg["content"]["path"]
+                    break
+        
+        # Prepare message for Ollama
+        if has_image and image_path:
+            # Handle image input
+            try:
+                response = chat(
+                    model=model_name,
+                    messages=[{
+                        'role': 'user',
+                        'content': f'I am sharing an image related to my child {self.report_data["child_info"]["name"]}\'s situation. Please analyze this image in the context of trauma assessment and respond empathetically.',
+                        'images': [image_path],
+                    }]
+                )
+                response_text = response.message.content
+            except Exception as e:
+                response_text = f"I can see you've shared an image. Thank you for providing this visual information about {self.report_data['child_info']['name']}. Visual expressions can tell us a lot about how children process their experiences. Could you tell me more about when this was created or what you'd like me to know about it?"
+                print(f"Ollama image error: {e}")
+        else:
+            # Handle text conversation
+            try:
+                response = chat(
+                    model=model_name,
+                    messages=self.ollama_conversation
+                )
+                response_text = response.message.content
+            except Exception as e:
+                response_text = f"Thank you for sharing that with me. I understand this is a difficult time for you and {self.report_data['child_info']['name']}. Could you tell me more about what you're observing?"
+                print(f"Ollama text error: {e}")
+        
+        # Add assistant response to conversation history
+        self.ollama_conversation.append({
+            "role": "assistant", 
+            "content": response_text
+        })
+        
+        # Start bot response
+        history.append({"role": "assistant", "content": ""})
+        
+        # Stream the response
+        for character in response_text:
+            history[-1]["content"] += character
+            time.sleep(0.02)
+            yield history
+    
+    def generate_comprehensive_report(self, progress_callback=None):
+        """Generate comprehensive assessment report using Ollama structured output"""
+        if not self.is_onboarded:
+            return "Please complete the initial assessment form first."
+        
+        if not self.ollama_conversation:
+            return "Please have a conversation first before generating a report."
+        
+        if progress_callback:
+            progress_callback("🤖 Analyzing conversation with AI...")
+        
+        try:
+            # Generate structured assessment using Ollama
+            assessment_prompt = f"""Based on our conversation about {self.report_data['child_info']['name']}, a {self.report_data['child_info']['age']}-year-old {self.report_data['child_info']['gender']} from {self.report_data['child_info']['location']}, generate a comprehensive trauma risk assessment report. 
+
+Include:
+- Parent observations summary from our conversation
+- AI analysis of trauma indicators
+- Severity score (1-10 scale)
+- List of risk indicators identified
+- Cultural context considering the child's location and circumstances
+
+Consider the conversation history and any cultural factors relevant to {self.report_data['child_info']['location']}."""
+
+            if progress_callback:
+                progress_callback("🧠 AI is generating structured assessment...")
+
+            response = chat(
+                model=model_name,
+                messages=[{'role': 'user', 'content': assessment_prompt}],
+                format=RiskAssessment.model_json_schema(),
+                options={'temperature': 0}
+            )
+            
+            if progress_callback:
+                progress_callback("📊 Processing assessment data...")
+            
+            # Parse structured response
+            assessment = RiskAssessment.model_validate_json(response.message.content)
+            
+            # Update report data with AI-generated assessment
+            self.report_data["assessment_data"]["parent_observations"] = assessment.parent_observations
+            self.report_data["assessment_data"]["ai_analysis"] = assessment.ai_analysis
+            self.report_data["assessment_data"]["severity_score"] = assessment.severity_score
+            self.report_data["assessment_data"]["risk_indicators"] = assessment.risk_indicators
+            self.report_data["assessment_data"]["cultural_context"] = assessment.cultural_context
+            
+            if progress_callback:
+                progress_callback("📋 Formatting final report...")
+            
+        except Exception as e:
+            print(f"Ollama structured output error: {e}")
+            if progress_callback:
+                progress_callback("⚠️ Using fallback assessment...")
+            # Fallback to basic assessment
+            self.report_data["assessment_data"]["severity_score"] = 6
+            self.report_data["assessment_data"]["risk_indicators"] = ["sleep disturbances", "behavioral changes", "anxiety"]
+        
+        # Generate formatted report
+        child_info = self.report_data["child_info"]
+        assessment_data = self.report_data["assessment_data"]
+        media_attachments = self.report_data["media_attachments"]
+        severity = assessment_data["severity_score"]
+        risk_indicators = assessment_data["risk_indicators"]
+        
+        return f"""# 🔍 COMPREHENSIVE TRAUMA ASSESSMENT REPORT
+
+**Generated:** {datetime.now().strftime("%B %d, %Y at %H:%M")}  
+**Assessment ID:** {self.report_data["mobile_app_id"][:8]}  
+**Confidentiality Level:** Protected Health Information
+**Platform:** Child Trauma Assessment AI
+
+---
+
+## 👤 CHILD INFORMATION
+
+**Name:** {child_info["name"]}  
+**Age:** {child_info["age"]} years old  
+**Gender:** {child_info["gender"].title()}  
+**Location:** {child_info["location"]}  
+**Assessment Date:** {datetime.now().strftime("%B %d, %Y")}
+
+---
+
+## 👥 PARENT OBSERVATIONS
+
+{assessment_data["parent_observations"]}
+
+**Session Details:**
+- **Duration:** {len(self.report_data["conversation_history"])} message exchanges
+- **Media Provided:** {len(media_attachments["drawings"])} drawings, {len(media_attachments["photos"])} photographs
+
+---
+
+## 🧠 AI ANALYSIS
+
+{assessment_data["ai_analysis"]}
+
+**Behavioral Patterns Identified:**
+{chr(10).join([f"• {indicator}" for indicator in risk_indicators])}
+
+---
+
+## ⚠️ SEVERITY ASSESSMENT
+
+**Severity Score:** {severity}/10  
+**Risk Level:** {"🟡 Moderate Risk" if severity < 7 else "🔴 High Risk - Urgent Intervention Recommended"}  
+**Clinical Priority:** {"Standard referral appropriate" if severity < 7 else "Expedited professional evaluation needed"}
+
+---
+
+## 🌍 CULTURAL CONTEXT
+
+{assessment_data["cultural_context"]}
+
+This assessment considers the cultural and environmental factors specific to {child_info["location"]}, including region-specific trauma expressions, family dynamics, and community support systems.
+
+---
+
+## 📋 CLINICAL RECOMMENDATIONS
+
+**Immediate Actions:**
+1. Schedule comprehensive evaluation with licensed child trauma specialist
+2. Ensure stable, predictable environment for {child_info["name"]}
+3. Implement safety planning and crisis contact protocols
+
+**Therapeutic Interventions:**
+1. Begin trauma-focused cognitive behavioral therapy (TF-CBT)
+2. Consider family therapy to strengthen support systems
+3. Monitor sleep, appetite, and behavioral patterns daily
+
+**Cultural Considerations:**
+1. Engage culturally competent mental health services
+2. Incorporate traditional coping mechanisms where appropriate
+3. Consider community-based support resources
+
+**Follow-up:**
+- Initial professional evaluation within 1-2 weeks
+- Regular monitoring and assessment as recommended by treating clinician
+
+---
+
+## ⚖️ IMPORTANT DISCLAIMERS
+
+- **Preliminary Screening Tool:** This AI-generated assessment is for screening purposes only and does NOT constitute a clinical diagnosis
+- **Professional Validation Required:** All findings must be validated by licensed mental health professionals
+- **Emergency Protocol:** For immediate safety concerns, contact emergency services immediately
+- **Clinical Judgment:** AI analysis should supplement, not replace, professional clinical assessment
+
+**Report Generated:** {datetime.now().isoformat()}  
+**Next Review Recommended:** {(datetime.now()).strftime("%B %d, %Y")} (2 weeks)
+"""
+    
+    def push_report_to_care_bridge(self, base_url="https://care-bridge-platform-7vs1.vercel.app"):
+        """Push the generated report to the Care Bridge platform."""
+        if not self.is_onboarded:
+            return False, "Please complete the initial assessment form first."
+        
+        if not self.report_data["conversation_history"]:
+            return False, "Please have a conversation first before pushing a report."
+        
+        # Prepare data in the format expected by Care Bridge API
+        api_data = {
+            "child_info": {
+                "age": self.report_data["child_info"]["age"],
+                "gender": self.report_data["child_info"]["gender"].lower(),
+                "location": self.report_data["child_info"]["location"]
+            },
+            "assessment_data": {
+                "parent_observations": self.report_data["assessment_data"]["parent_observations"],
+                "ai_analysis": self.report_data["assessment_data"]["ai_analysis"],
+                "severity_score": self.report_data["assessment_data"]["severity_score"],
+                "risk_indicators": self.report_data["assessment_data"]["risk_indicators"],
+                "cultural_context": self.report_data["assessment_data"]["cultural_context"]
+            },
+            "media_attachments": self.report_data["media_attachments"],
+            "mobile_app_id": self.report_data["mobile_app_id"]
+        }
+        
+        try:
+            url = f"{base_url}/api/reports"
+            headers = {"Content-Type": "application/json"}
+            
+            response = requests.post(url, json=api_data, headers=headers, timeout=10)
+            
+            if response.status_code == 201:
+                result = response.json()
+                report_id = result.get('id', 'Unknown')
+                # Store the report ID for polling
+                self.submitted_report_id = report_id
+                # Start polling for responses
+                self.start_response_polling()
+                return True, f"✅ Report successfully pushed to Care Bridge Platform!\n📋 Report ID: {report_id}\n🔄 Now monitoring for specialist response..."
+            else:
+                return False, f"❌ API Error: {response.status_code} - {response.text}"
+                
+        except ConnectionError:
+            return False, "❌ Could not connect to Care Bridge Platform. Please check if the platform is running."
+        except requests.exceptions.Timeout:
+            return False, "❌ Request timed out. Please try again."
+        except RequestException as e:
+            return False, f"❌ Network error: {str(e)}"
+        except Exception as e:
+            return False, f"❌ Unexpected error: {str(e)}"
+    
+    def start_response_polling(self):
+        """Start polling for specialist responses in a background thread."""
+        if not self.supabase or not self.submitted_report_id:
+            print("⚠️ Cannot start polling: Missing Supabase connection or report ID")
+            return
+        
+        if self.polling_active:
+            print("ℹ️ Polling already active")
+            return  # Already polling
+        
+        self.polling_active = True
+        print(f"🔄 Starting background polling for report ID: {self.submitted_report_id}")
+        polling_thread = threading.Thread(target=self._poll_for_response, daemon=True)
+        polling_thread.start()
+    
+    def _poll_for_response(self):
+        """Poll Supabase for specialist responses."""
+        max_polls = 120  # Poll for 10 minutes (120 * 5 seconds)
+        poll_count = 0
+        print("Starting polling for response...")
+        while self.polling_active and poll_count < max_polls:
+            try:
+                # Check for response in Supabase
+                print("Polling for response...")
+                response = self.supabase.table("responses").select("*").eq("report_id", self.submitted_report_id).execute()
+                
+                if response.data and len(response.data) > 0:
+                    # Response found!
+                    specialist_response = response.data[0]
+                    self.specialist_response = specialist_response
+                    self.get_specialist_response()
+                    self.polling_active = False
+                    break
+                
+                # Wait 5 seconds before next poll
+                time.sleep(5)
+                poll_count += 1
+                
+            except Exception as e:
+                print(f"Error polling for response: {e}")
+                time.sleep(5)
+                poll_count += 1
+        
+        # Stop polling after max attempts
+        if poll_count >= max_polls:
+            self.polling_active = False
+    
+    def get_specialist_response(self):
+        """Get the specialist response if available."""
+        if hasattr(self, 'specialist_response'):
+            response = self.specialist_response
+            
+            urgency_color = {
+                'low': '🟢',
+                'medium': '🟡', 
+                'high': '🟠',
+                'critical': '🔴'
+            }
+            
+            urgency_emoji = urgency_color.get(response['urgency_level'], '⚪')
+            
+            formatted_response = f"""
+# 👨‍⚕️ SPECIALIST RESPONSE RECEIVED
+
+**Response Date:** {response['response_date'][:19].replace('T', ' ')}  
+**Specialist ID:** {response['psychologist_id']}  
+**Urgency Level:** {urgency_emoji} {response['urgency_level'].upper()}
+
+---
+
+## 📝 PSYCHOLOGIST NOTES
+
+{response['psychologist_notes']}
+
+---
+
+## 💡 RECOMMENDATIONS
+
+"""
+            
+            if isinstance(response['recommendations'], dict):
+                for key, value in response['recommendations'].items():
+                    formatted_response += f"**{key.replace('_', ' ').title()}:** {value}\n\n"
+            else:
+                formatted_response += str(response['recommendations'])
+            
+            return True, formatted_response
+        
+        return False, "No specialist response available yet. Still monitoring..."
+
+# Initialize enhanced app
+app = EnhancedTraumaAssessmentApp()
+
+# Enhanced CSS with onboarding styles
+css = """
+/* Main container styling */
+.gradio-container {
+    max-width: 900px !important;
+    margin: 0 auto !important;
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+}
+
+/* Onboarding specific styles */
+.onboarding-container {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 40px 30px;
+    border-radius: 20px;
+    margin: 20px 0;
+    text-align: center;
+    box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+}
+
+.welcome-form {
+    background: white;
+    color: #333;
+    padding: 30px;
+    border-radius: 15px;
+    margin: 20px 0;
+    box-shadow: 0 5px 20px rgba(0,0,0,0.1);
+}
+
+.form-section {
+    margin: 20px 0;
+    text-align: left;
+}
+
+.form-section label {
+    font-weight: 600;
+    color: #2d3436;
+    margin-bottom: 8px;
+    display: block;
+}
+
+/* Header styling */
+.header-container {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 30px 20px;
+    border-radius: 15px;
+    margin-bottom: 25px;
+    text-align: center;
+    box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+}
+
+/* Status indicators */
+.status-success {
+    background: linear-gradient(135deg, #84fab0 0%, #8fd3f4 100%);
+    border-left: 4px solid #00b894;
+    padding: 15px 20px;
+    border-radius: 8px;
+    margin: 15px 0;
+    color: #00b894;
+    font-weight: 500;
+}
+
+.status-warning {
+    background: linear-gradient(135deg, #fff3cd 0%, #ffeaa7 100%);
+    border-left: 4px solid #f39c12;
+    padding: 15px 20px;
+    border-radius: 8px;
+    margin: 15px 0;
+    color: #e67e22;
+}
+
+.status-info {
+    background: linear-gradient(135deg, #a8edea 0%, #fed6e3 100%);
+    border-left: 4px solid #74b9ff;
+    padding: 15px 20px;
+    border-radius: 8px;
+    margin: 15px 0;
+    color: #0984e3;
+}
+
+/* Button styling */
+.primary-button {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    border: none !important;
+    color: white !important;
+    padding: 15px 30px !important;
+    border-radius: 25px !important;
+    font-weight: 600 !important;
+    font-size: 16px !important;
+    transition: all 0.3s ease !important;
+    width: 100% !important;
+}
+
+.primary-button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 8px 25px rgba(102, 126, 234, 0.4) !important;
+}
+
+/* Chat interface styling */
+.chat-container {
+    background: white;
+    border-radius: 15px;
+    padding: 20px;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+    margin-bottom: 20px;
+}
+
+.child-info-display {
+    background: linear-gradient(135deg, #ddd6fe 0%, #e0e7ff 100%);
+    border: 1px solid #c4b5fd;
+    padding: 15px 20px;
+    border-radius: 10px;
+    margin: 15px 0;
+    color: #5b21b6;
+}
+
+/* Mobile responsiveness */
+@media (max-width: 768px) {
+    .gradio-container {
+        max-width: 100% !important;
+        margin: 0 10px !important;
+    }
+    
+    .onboarding-container {
+        padding: 25px 20px;
+        margin: 10px 0;
+    }
+    
+    .welcome-form {
+        padding: 20px;
+        margin: 15px 0;
+    }
+}
+"""
+
+# Build enhanced Gradio interface with onboarding
+with gr.Blocks(css=css, title="Child Trauma Assessment - Professional Support", theme=gr.themes.Soft()) as demo:
+    
+    # Session state for controlling interface
+    onboarding_complete = gr.State(False)
+    
+    # Welcome/Onboarding Interface
+    with gr.Column(visible=True) as onboarding_section:
+        gr.HTML("""
+        <div class="onboarding-container">
+            <h1>🤗 Welcome to Child Trauma Assessment AI</h1>
+            <p>Professional-grade support for families and children in crisis</p>
+            <br>
+            <h3>Let's start by learning about your child</h3>
+        </div>
+        """)
+        
+        with gr.Column(elem_classes=["welcome-form"]):
+            gr.HTML("<h2 style='text-align: center; color: #667eea; margin-bottom: 25px;'>📝 Child Information Form</h2>")
+            
+            with gr.Row():
+                child_name = gr.Textbox(
+                    label="Child's Name (First name only for privacy)",
+                    placeholder="e.g., Sarah, Ahmed, Oleksandr",
+                    elem_classes=["form-section"]
+                )
+                child_age = gr.Number(
+                    label="Child's Age",
+                    minimum=2,
+                    maximum=18,
+                    value=8,
+                    elem_classes=["form-section"]
+                )
+            
+            with gr.Row():
+                child_gender = gr.Dropdown(
+                    label="Gender",
+                    choices=["Female", "Male", "Prefer not to say"],
+                    value="Female",
+                    elem_classes=["form-section"]
+                )
+                child_location = gr.Textbox(
+                    label="Current Location (City/Region)",
+                    placeholder="e.g., Gaza, Kyiv, Aleppo, London",
+                    elem_classes=["form-section"]
+                )
+            
+            gr.HTML("""
+            <div class="status-info" style="margin: 20px 0;">
+                <strong>🔒 Privacy Notice:</strong> This information is used only to personalize the assessment 
+                and provide culturally appropriate support. No personal data is stored permanently.
+            </div>
+            """)
+            
+            start_assessment_btn = gr.Button(
+                "🚀 Begin Assessment",
+                elem_classes=["primary-button"],
+                variant="primary",
+                size="lg"
+            )
+            
+            onboarding_status = gr.HTML()
+    
+    # Main Assessment Interface (hidden initially)  
+    with gr.Column(visible=False) as main_interface:
+        # Child info display
+        child_info_display = gr.HTML()
+        
+        with gr.Tab("💬 Confidential Consultation"):
+            gr.HTML("""
+            <div class="status-info">
+                <strong>🤖 REAL AI MODEL:</strong> This platform uses our fine-tuned Gemma 3N model for authentic trauma assessment conversations.
+                <br><br>
+                <strong>💡 Try These Features:</strong>
+                <br>
+                • Start a conversation: "Hello, I'm worried about my child's recent behavior changes"
+                <br>
+                • Upload images (child photos, drawings) for AI visual analysis
+                <br>
+                • Use different languages - the model supports Arabic, Ukrainian, and English
+                <br>
+                • Generate structured reports with AI-powered assessment insights
+                <br><br>
+                <strong>🔒 Privacy:</strong> All conversations are processed securely. Audio support coming soon.
+            </div>
+            """)
+            
+            chatbot = gr.Chatbot(
+                label="AI Trauma Assessment Specialist",
+                height=500,
+                bubble_full_width=False,
+                type="messages",
+                show_label=False,
+                elem_classes=["chat-container"]
+            )
+            
+            chat_input = gr.MultimodalTextbox(
+                interactive=True,
+                file_count="multiple",
+                placeholder="Share your concerns here... يمكنك الكتابة بالعربية • Можете писати українською",
+                show_label=False,
+                sources=["upload"]  # Removed microphone - audio not yet supported
+            )
+            
+            with gr.Row():
+                clear_btn = gr.Button("🗑️ New Conversation", variant="secondary", size="sm")
+                gr.HTML('<div style="flex-grow: 1;"></div>')
+        
+        with gr.Tab("📋 Professional Assessment Report"):
+            gr.HTML("""
+            <div class="status-warning">
+                <strong>⚠️ Professional Use Only:</strong> This AI-generated report is a preliminary screening tool. 
+                It must be reviewed by licensed mental health professionals.
+            </div>
+            """)
+            
+            generate_report_btn = gr.Button(
+                "📊 Generate Comprehensive Assessment", 
+                variant="primary", 
+                size="lg",
+                elem_classes=["primary-button"]
+            )
+            
+            # Add progress indicator
+            progress_status = gr.HTML()
+            
+            report_output = gr.Markdown()
+            
+            with gr.Row():
+                save_report_btn = gr.Button("💾 Save Report", variant="secondary")
+                push_care_bridge_btn = gr.Button("🌉 Push to Care Bridge", variant="primary")
+                gr.Button("📧 Email to Professional", variant="secondary", interactive=False)
+            
+            save_status = gr.HTML()
+            care_bridge_status = gr.HTML()
+        
+        with gr.Tab("👨‍⚕️ Specialist Response"):
+            gr.HTML("""
+            <div class="status-info">
+                <strong>🔄 Background Monitoring:</strong> Once you submit a report, we automatically monitor for specialist responses in the background.
+                Click the button below to check for new responses.
+            </div>
+            """)
+            
+            check_response_btn = gr.Button(
+                "🔍 Check for Specialist Response", 
+                variant="secondary", 
+                size="lg"
+            )
+            
+            specialist_response_output = gr.Markdown()
+            response_status = gr.HTML()
+        
+        with gr.Tab("📖 Resources & Information"):
+            gr.Markdown("""
+            ## 🎯 How This Assessment Works
+            
+            Our AI specialist uses evidence-based approaches tailored to your child's specific situation:
+            
+            ### 📝 **Personalized Assessment**
+            - Responses are customized based on your child's age, gender, and location
+            - Cultural context is considered throughout the evaluation
+            - All interactions are stored securely for comprehensive reporting
+            
+            ### 🔍 **What We Analyze**
+            - Behavioral pattern changes specific to your child's developmental stage
+            - Cultural expressions of trauma and stress
+            - Family dynamics and support systems
+            - Environmental factors affecting recovery
+            
+            ### 📊 **Structured Data Collection**
+            All information is organized into a comprehensive clinical format:
+            - Child demographics and context
+            - Detailed parent observations
+            - AI analysis and risk assessment  
+            - Multimedia evidence (drawings, voice recordings, photos)
+            - Cultural considerations and recommendations
+            
+            ## 🌉 **Care Bridge Platform Integration**
+            
+            This assessment tool integrates with the Care Bridge Platform to:
+            - **Share Reports**: Securely transmit assessment data to professional networks
+            - **Track Progress**: Maintain longitudinal care records
+            - **Coordinate Care**: Enable multi-disciplinary team collaboration
+            - **Emergency Response**: Alert crisis intervention teams when needed
+            """)
+    
+    # Event handlers
+    def handle_onboarding(name, age, gender, location):
+        success, message = app.complete_onboarding(name, age, gender, location)
+        
+        if success:
+            child_display = f"""
+            <div class="child-info-display">
+                <strong>👤 Assessment for:</strong> {name}, {int(age)} years old ({gender}) • 📍 {location}
+            </div>
+            """
+            return (
+                gr.Column(visible=False),  # Hide onboarding
+                gr.Column(visible=True),   # Show main interface
+                child_display,
+                f'<div class="status-success">{message}</div>'
+            )
+        else:
+            return (
+                gr.Column(visible=True),   # Keep onboarding visible
+                gr.Column(visible=False),  # Keep main interface hidden
+                "",
+                f'<div class="status-warning">❌ {message}</div>'
+            )
+    
+    # Onboarding completion
+    start_assessment_btn.click(
+        handle_onboarding,
+        inputs=[child_name, child_age, child_gender, child_location],
+        outputs=[onboarding_section, main_interface, child_info_display, onboarding_status]
+    )
+    
+    # Conversation handling
+    def handle_conversation():
+        chat_msg = chat_input.submit(
+            app.add_message, 
+            [chatbot, chat_input], 
+            [chatbot, chat_input]
+        )
+        bot_msg = chat_msg.then(
+            app.bot_response, 
+            chatbot, 
+            chatbot
+        )
+        bot_msg.then(
+            lambda: gr.MultimodalTextbox(interactive=True), 
+            None, 
+            [chat_input]
+        )
+    
+    handle_conversation()
+    
+    # Clear conversation
+    def clear_conversation():
+        app.report_data["conversation_history"] = []
+        app.report_data["assessment_data"]["parent_observations"] = ""
+        app.report_data["assessment_data"]["ai_analysis"] = ""
+        app.report_data["media_attachments"] = {"drawings": [], "audio_recordings": [], "photos": []}
+        return [], gr.MultimodalTextbox(value=None, interactive=True)
+    
+    clear_btn.click(
+        clear_conversation,
+        outputs=[chatbot, chat_input]
+    )
+    
+    # Generate report with progress updates
+    def generate_report_with_progress():
+        # Show initial progress
+        progress_updates = []
+        
+        def update_progress(message):
+            progress_updates.append(f'<div class="status-info">{message}</div>')
+            return progress_updates[-1]
+        
+        # Generate report with progress callback
+        try:
+            progress = update_progress("🚀 Starting assessment generation...")
+            yield "", progress  # Empty report, show progress
+            
+            report = app.generate_comprehensive_report(progress_callback=update_progress)
+            
+            final_progress = update_progress("✅ Assessment completed!")
+            yield report, final_progress
+            
+            # Clear progress after 3 seconds
+            time.sleep(3)
+            yield report, ""
+            
+        except Exception as e:
+            error_progress = f'<div class="status-warning">❌ Error: {str(e)}</div>'
+            yield "", error_progress
+
+    generate_report_btn.click(
+        generate_report_with_progress,
+        outputs=[report_output, progress_status]
+    )
+    
+    # Save report
+    def save_report_with_data(report_content):
+        if not report_content or "Please complete" in report_content:
+            return "❌ No report available to save."
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        # Save markdown report
+        report_filename = f"trauma_report_{app.report_data['child_info']['name']}_{timestamp}.md"
+        
+        # Save structured data
+        data_filename = f"assessment_data_{app.report_data['child_info']['name']}_{timestamp}.json"
+        
+        try:
+            with open(report_filename, 'w', encoding='utf-8') as f:
+                f.write(report_content)
+            
+            with open(data_filename, 'w', encoding='utf-8') as f:
+                json.dump(app.report_data, f, indent=2, ensure_ascii=False, default=str)
+            
+            return f"✅ Report saved as: **{report_filename}**<br>📊 Data saved as: **{data_filename}**"
+        except Exception as e:
+            return f"❌ Error saving files: {str(e)}"
+    
+    save_report_btn.click(
+        save_report_with_data,
+        inputs=[report_output],
+        outputs=[save_status]
+    )
+
+    # Push report to Care Bridge
+    def push_to_care_bridge():
+        success, message = app.push_report_to_care_bridge()
+        status_class = "status-success" if success else "status-warning"
+        return f'<div class="{status_class}">{message}</div>'
+
+    push_care_bridge_btn.click(
+        push_to_care_bridge,
+        outputs=[care_bridge_status]
+    )
+    
+    # Check for specialist response
+    def check_for_response():
+        has_response, response_content = app.get_specialist_response()
+        if has_response:
+            return response_content, '<div class="status-success">✅ Specialist response received!</div>'
+        elif app.polling_active:
+            return "", '<div class="status-info">🔄 Still monitoring for specialist response...</div>'
+        elif app.submitted_report_id:
+            return "", '<div class="status-warning">⏸️ Monitoring stopped. No response received within time limit.</div>'
+        else:
+            return "", '<div class="status-warning">ℹ️ Submit a report first to check for responses.</div>'
+    
+    check_response_btn.click(
+        check_for_response,
+        outputs=[specialist_response_output, response_status]
+    )
+    
+    # Note: Auto-refresh functionality can be added with newer Gradio versions
+    # For now, users can manually click the "Check for Specialist Response" button
+    
+    # Feedback handling
+    def handle_feedback(x: gr.LikeData):
+        feedback_type = "👍 Helpful" if x.liked else "👎 Needs Improvement"
+        print(f"User feedback: {feedback_type} on message {x.index}")
+        # Could store this in report_data for quality improvement
+    
+    chatbot.like(handle_feedback, None, None, like_user_message=True)
+
+# Launch configuration
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )