Upload casl_analysis.py

casl_analysis.py

@@ -0,0 +1,1903 @@
+import gradio as gr
+import boto3
+import json
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import re
+import logging
+import os
+import pickle
+import csv
+from PIL import Image
+import io
+import PyPDF2
+import uuid
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# AWS credentials for Bedrock API
+# For HuggingFace Spaces, set these as secrets in the Space settings
+AWS_ACCESS_KEY = os.getenv("AWS_ACCESS_KEY", "")
+AWS_SECRET_KEY = os.getenv("AWS_SECRET_KEY", "")
+AWS_REGION = os.getenv("AWS_REGION", "us-east-1")
+
+# Initialize Bedrock client if credentials are available
+bedrock_client = None
+if AWS_ACCESS_KEY and AWS_SECRET_KEY:
+    try:
+        bedrock_client = boto3.client(
+            'bedrock-runtime',
+            aws_access_key_id=AWS_ACCESS_KEY,
+            aws_secret_access_key=AWS_SECRET_KEY,
+            region_name=AWS_REGION
+        )
+        logger.info("Bedrock client initialized successfully")
+    except Exception as e:
+        logger.error(f"Failed to initialize Bedrock client: {str(e)}")
+
+# Sample transcript for the demo
+SAMPLE_TRANSCRIPT = """*PAR: today I would &-um like to talk about &-um a fun trip I took last &-um summer with my family.
+*PAR: we went to the &-um &-um beach [//] no to the mountains [//] I mean the beach actually.
+*PAR: there was lots of &-um &-um swimming and &-um sun.
+*PAR: we [/] we stayed for &-um three no [//] four days in a &-um hotel near the water [: ocean] [*].
+*PAR: my favorite part was &-um building &-um castles with sand.
+*PAR: sometimes I forget [//] forgetted [: forgot] [*] what they call those things we built.
+*PAR: my brother he [//] he helped me dig a big hole.
+*PAR: we saw [/] saw fishies [: fish] [*] swimming in the water.
+*PAR: sometimes I wonder [/] wonder where fishies [: fish] [*] go when it's cold.
+*PAR: maybe they have [/] have houses under the water.
+*PAR: after swimming we [//] I eat [: ate] [*] &-um ice cream with &-um chocolate things on top.
+*PAR: what do you call those &-um &-um sprinkles! that's the word.
+*PAR: my mom said to &-um that I could have &-um two scoops next time.
+*PAR: I want to go back to the beach [/] beach next year."""
+
+# ===============================
+# Database and Storage Functions
+# ===============================
+
+# Create data directories if they don't exist
+DATA_DIR = "patient_data"
+RECORDS_FILE = os.path.join(DATA_DIR, "patient_records.csv")
+ANALYSES_DIR = os.path.join(DATA_DIR, "analyses")
+
+def ensure_data_dirs():
+    """Ensure data directories exist"""
+    os.makedirs(DATA_DIR, exist_ok=True)
+    os.makedirs(ANALYSES_DIR, exist_ok=True)
+    
+    # Create records file if it doesn't exist
+    if not os.path.exists(RECORDS_FILE):
+        with open(RECORDS_FILE, 'w', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                "ID", "Name", "Record ID", "Age", "Gender", 
+                "Assessment Date", "Clinician", "Analysis Date", "File Path"
+            ])
+
+# Initialize data directories
+ensure_data_dirs()
+
+def save_patient_record(patient_info, analysis_results, transcript):
+    """Save patient record to storage"""
+    try:
+        # Generate unique ID for the record
+        record_id = str(uuid.uuid4())
+        
+        # Extract patient information
+        name = patient_info.get("name", "")
+        patient_id = patient_info.get("record_id", "")
+        age = patient_info.get("age", "")
+        gender = patient_info.get("gender", "")
+        assessment_date = patient_info.get("assessment_date", "")
+        clinician = patient_info.get("clinician", "")
+        
+        # Create filename for the analysis data
+        filename = f"analysis_{record_id}.pkl"
+        filepath = os.path.join(ANALYSES_DIR, filename)
+        
+        # Save analysis data
+        with open(filepath, 'wb') as f:
+            pickle.dump({
+                "patient_info": patient_info,
+                "analysis_results": analysis_results,
+                "transcript": transcript,
+                "timestamp": datetime.now().isoformat(),
+            }, f)
+        
+        # Add record to CSV file
+        with open(RECORDS_FILE, 'a', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                record_id, name, patient_id, age, gender, 
+                assessment_date, clinician, datetime.now().strftime('%Y-%m-%d'),
+                filepath
+            ])
+        
+        return record_id
+    
+    except Exception as e:
+        logger.error(f"Error saving patient record: {str(e)}")
+        return None
+
+def load_patient_record(record_id):
+    """Load patient record from storage"""
+    try:
+        # Find the record in the CSV file
+        with open(RECORDS_FILE, 'r', newline='') as f:
+            reader = csv.reader(f)
+            next(reader)  # Skip header
+            for row in reader:
+                if row[0] == record_id:
+                    file_path = row[8]
+                    
+                    # Load and return the data
+                    with open(file_path, 'rb') as f:
+                        return pickle.load(f)
+        
+        return None
+    
+    except Exception as e:
+        logger.error(f"Error loading patient record: {str(e)}")
+        return None
+
+def get_all_patient_records():
+    """Return a list of all patient records"""
+    try:
+        records = []
+        if os.path.exists(RECORDS_FILE):
+            with open(RECORDS_FILE, 'r', newline='') as f:
+                reader = csv.reader(f)
+                next(reader)  # Skip header
+                for row in reader:
+                    records.append({
+                        "id": row[0],
+                        "name": row[1],
+                        "record_id": row[2],
+                        "age": row[3],
+                        "gender": row[4],
+                        "assessment_date": row[5],
+                        "clinician": row[6],
+                        "analysis_date": row[7]
+                    })
+        return records
+    
+    except Exception as e:
+        logger.error(f"Error getting patient records: {str(e)}")
+        return []
+
+# ===============================
+# Utility Functions
+# ===============================
+
+def read_pdf(file_path):
+    """Read text from a PDF file"""
+    try:
+        with open(file_path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text()
+            return text
+    except Exception as e:
+        logger.error(f"Error reading PDF: {str(e)}")
+        return ""
+
+def read_cha_file(file_path):
+    """Read and parse a .cha transcript file"""
+    try:
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+            
+        # Extract participant lines (starting with *PAR:)
+        par_lines = []
+        for line in content.splitlines():
+            if line.startswith('*PAR:'):
+                par_lines.append(line)
+                
+        # If no PAR lines found, just return the whole content
+        if not par_lines:
+            return content
+            
+        return '\n'.join(par_lines)
+    
+    except Exception as e:
+        logger.error(f"Error reading CHA file: {str(e)}")
+        return ""
+
+def process_upload(file):
+    """Process an uploaded file (PDF, text, or CHA)"""
+    if file is None:
+        return ""
+    
+    file_path = file.name
+    if file_path.endswith('.pdf'):
+        return read_pdf(file_path)
+    elif file_path.endswith('.cha'):
+        return read_cha_file(file_path)
+    else:
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            return f.read()
+
+# ===============================
+# AI Model Interface Functions
+# ===============================
+
+def call_bedrock(prompt, max_tokens=4096):
+    """Call the AWS Bedrock API to analyze text using Claude"""
+    if not bedrock_client:
+        return "AWS credentials not configured. Please set your AWS credentials as secrets in the Space settings."
+    
+    try:
+        body = json.dumps({
+            "anthropic_version": "bedrock-2023-05-31",
+            "max_tokens": max_tokens,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ],
+            "temperature": 0.3,
+            "top_p": 0.9
+        })
+
+        modelId = 'anthropic.claude-3-sonnet-20240229-v1:0'
+        response = bedrock_client.invoke_model(
+            body=body, 
+            modelId=modelId, 
+            accept='application/json', 
+            contentType='application/json'
+        )
+        response_body = json.loads(response.get('body').read())
+        return response_body['content'][0]['text']
+    except Exception as e:
+        logger.error(f"Error in call_bedrock: {str(e)}")
+        return f"Error: {str(e)}"
+
+def generate_demo_response(prompt):
+    """Generate a simulated response for demo purposes"""
+    # This function generates a realistic but fake response for demo purposes
+    # In a real deployment, you would call an actual LLM API
+    
+    random_seed = sum(ord(c) for c in prompt) % 1000  # Generate a seed based on prompt
+    np.random.seed(random_seed)
+    
+    # Simulate speech factors with random but reasonable values
+    factors = [
+        "Difficulty producing fluent speech",
+        "Word retrieval issues",
+        "Grammatical errors",
+        "Repetitions and revisions",
+        "Neologisms",
+        "Perseveration",
+        "Comprehension issues"
+    ]
+    
+    occurrences = np.random.randint(1, 15, size=len(factors))
+    percentiles = np.random.randint(30, 95, size=len(factors))
+    
+    # Simulate CASL scores
+    domains = ["Lexical/Semantic", "Syntactic", "Supralinguistic"]
+    scores = np.random.randint(80, 115, size=3)
+    percentiles_casl = [int(np.interp(s, [70, 85, 100, 115, 130], [2, 16, 50, 84, 98])) for s in scores]
+    
+    perf_levels = []
+    for s in scores:
+        if s < 70: perf_levels.append("Well Below Average")
+        elif s < 85: perf_levels.append("Below Average")
+        elif s < 115: perf_levels.append("Average")
+        elif s < 130: perf_levels.append("Above Average")
+        else: perf_levels.append("Well Above Average")
+    
+    # Build response
+    response = "## Speech Factor Analysis\n\n"
+    for i, factor in enumerate(factors):
+        response += f"{factor}: {occurrences[i]}, {percentiles[i]}\n"
+    
+    response += "\n## CASL-2 Assessment\n\n"
+    for i, domain in enumerate(domains):
+        response += f"{domain} Skills: Standard Score ({scores[i]}), Percentile Rank ({percentiles_casl[i]}%), Performance Level ({perf_levels[i]})\n"
+    
+    response += "\n## Other analysis/Best plans of action:\n\n"
+    suggestions = [
+        "Implement word-finding strategies with semantic cuing",
+        "Practice structured narrative tasks with visual supports",
+        "Use sentence formulation exercises with increasing complexity",
+        "Incorporate self-monitoring techniques during structured conversations",
+        "Work on grammatical forms through structured practice"
+    ]
+    for suggestion in suggestions:
+        response += f"- {suggestion}\n"
+    
+    response += "\n## Explanation:\n\n"
+    response += "Based on the analysis, this patient demonstrates moderate word-finding difficulties with compensatory strategies like filler words and repetitions. Their syntactic skills show some weakness in verb tense consistency. Treatment should focus on building vocabulary access, grammatical accuracy, and narrative structure using scaffolded support.\n"
+    
+    response += "\n## Additional Analysis:\n\n"
+    response += "The patient shows relative strengths in conversation maintenance and topic coherence. Consider building on these strengths while addressing specific language formulation challenges. Recommended frequency: 2-3 sessions per week for 10-12 weeks with periodic reassessment."
+    
+    return response
+
+def generate_demo_transcription(audio_path):
+    """Generate a simulated transcription response"""
+    # In a real app, this would process an audio file
+    return "*PAR: today I want to tell you about my favorite toy.\n*PAR: it's a &-um teddy bear that I got for my birthday.\n*PAR: he has &-um brown fur and a red bow.\n*PAR: I like to sleep with him every night.\n*PAR: sometimes I take him to school in my backpack."
+
+def generate_demo_qa_response(question):
+    """Generate a simulated Q&A response"""
+    qa_responses = {
+        "what is casl": "CASL-2 (Comprehensive Assessment of Spoken Language, Second Edition) is a standardized assessment tool used by Speech-Language Pathologists to evaluate a child's oral language abilities across multiple domains including lexical/semantic, syntactic, and supralinguistic skills. It helps identify language disorders and guides intervention planning.",
+        "how do i interpret scores": "CASL-2 scores include standard scores (mean=100, SD=15), percentile ranks, and performance levels. Standard scores below 85 indicate below average performance, 85-115 is average, and above 115 is above average. Percentile ranks show how a child performs relative to same-age peers.",
+        "what activities help word finding": "Activities to improve word-finding skills include semantic feature analysis (describing attributes of objects), categorization tasks, word association games, rapid naming practice, and structured conversation with gentle cueing. Visual supports and semantic mapping can also be helpful.",
+        "how often should therapy occur": "The recommended frequency for speech-language therapy typically ranges from 1-3 sessions per week, depending on the severity of the impairment. For moderate difficulties, twice weekly sessions of 30-45 minutes are common. Consistency is important for progress.",
+        "when should i reassess": "Reassessment is typically recommended every 3-6 months to track progress and adjust treatment goals. For educational settings, annual reassessment is common. More frequent informal assessments can help guide ongoing intervention.",
+    }
+    
+    # Simple keyword matching for demo purposes
+    for key, response in qa_responses.items():
+        if key in question.lower():
+            return response
+    
+    return "I don't have specific information about that topic. For detailed professional guidance, consult with a licensed Speech-Language Pathologist who can provide advice specific to your situation."
+
+# ===============================
+# Analysis Functions
+# ===============================
+
+def parse_casl_response(response):
+    """Parse the LLM response for CASL analysis into structured data"""
+    lines = response.split('\n')
+    data = {
+        'Factor': [],
+        'Occurrences': [],
+        'Severity': [],
+        'Examples': []  # Added field for error examples
+    }
+    
+    casl_data = {
+        'Domain': ['Lexical/Semantic', 'Syntactic', 'Supralinguistic'],
+        'Standard Score': [0, 0, 0],
+        'Percentile': [0, 0, 0],
+        'Performance Level': ['', '', ''],
+        'Examples': ['', '', '']  # Added field for specific examples
+    }
+    
+    treatment_suggestions = []
+    explanation = ""
+    additional_analysis = ""
+    specific_errors = {}  # Track specific error examples by factor
+    raw_response = response  # Store the complete raw LLM response
+    
+    # Pattern to match factor lines - updated to potentially capture examples
+    factor_pattern = re.compile(r'([\w\s/]+):\s*(\d+)[,\s]+(\d+)(?:\s*-\s*(.+))?')
+    
+    # Pattern to match CASL data
+    casl_pattern = re.compile(r'(\w+/?\w*)\s+Skills:\s+Standard\s+Score\s+\((\d+)\),\s+Percentile\s+Rank\s+\((\d+)%\),\s+Performance\s+Level\s+\(([\w\s]+)\)')
+    
+    # Pattern to find examples
+    example_pattern = re.compile(r'(?:Example|Examples|observed|observed in)[^\"\'"]*[\"\']([^\"\']*)[\"\']')
+    error_pattern = re.compile(r'(?:error|errors|difficulty|difficulties)[^\"\'"]*[\"\']([^\"\']*)[\"\']')
+    
+    current_factor = None
+    current_domain = None
+    in_suggestions = False
+    in_explanation = False
+    in_additional = False
+    in_examples = False
+    
+    for i, line in enumerate(lines):
+        line = line.strip()
+        
+        # Skip empty lines
+        if not line:
+            continue
+            
+        # Check for factor data
+        factor_match = factor_pattern.search(line)
+        if factor_match:
+            factor = factor_match.group(1).strip()
+            occurrences = int(factor_match.group(2))
+            severity = int(factor_match.group(3))
+            example = factor_match.group(4) if factor_match.group(4) else ""
+            
+            # Look ahead to find examples for this factor
+            if not example:
+                # Check next few lines for examples
+                for j in range(i+1, min(i+5, len(lines))):
+                    next_line = lines[j].strip()
+                    if next_line and ('"' in next_line or "'" in next_line):
+                        example_match = example_pattern.search(next_line)
+                        if example_match:
+                            example = example_match.group(1)
+                            break
+                        error_match = error_pattern.search(next_line)
+                        if error_match:
+                            example = error_match.group(1)
+                            break
+            
+            data['Factor'].append(factor)
+            data['Occurrences'].append(occurrences)
+            data['Severity'].append(severity)
+            data['Examples'].append(example)
+            specific_errors[factor] = example
+            current_factor = factor
+            continue
+            
+        # Check for CASL data
+        casl_match = casl_pattern.search(line)
+        if casl_match:
+            domain = casl_match.group(1)
+            score = int(casl_match.group(2))
+            percentile = int(casl_match.group(3))
+            level = casl_match.group(4)
+            
+            domain_examples = ""
+            # Look ahead for examples related to this domain
+            for j in range(i+1, min(i+10, len(lines))):
+                next_line = lines[j].strip()
+                if "Domain:" in next_line or casl_pattern.search(next_line):
+                    break
+                if ('"' in next_line or "'" in next_line) and "example" in next_line.lower():
+                    example_match = re.search(r'[\"\']([^\"\']*)[\"\']', next_line)
+                    if example_match:
+                        domain_examples = example_match.group(1)
+                        break
+            
+            if "Lexical" in domain:
+                casl_data['Standard Score'][0] = score
+                casl_data['Percentile'][0] = percentile
+                casl_data['Performance Level'][0] = level
+                casl_data['Examples'][0] = domain_examples
+                current_domain = "Lexical/Semantic"
+            elif "Syntactic" in domain:
+                casl_data['Standard Score'][1] = score
+                casl_data['Percentile'][1] = percentile
+                casl_data['Performance Level'][1] = level
+                casl_data['Examples'][1] = domain_examples
+                current_domain = "Syntactic"
+            elif "Supralinguistic" in domain:
+                casl_data['Standard Score'][2] = score
+                casl_data['Percentile'][2] = percentile
+                casl_data['Performance Level'][2] = level
+                casl_data['Examples'][2] = domain_examples
+                current_domain = "Supralinguistic"
+            continue
+        
+        # Check for section headers
+        if "Other analysis/Best plans of action:" in line or "### Recommended Treatment Approaches" in line or "Treatment Recommendations:" in line:
+            in_suggestions = True
+            in_explanation = False
+            in_additional = False
+            in_examples = False
+            continue
+        elif "Explanation:" in line or "### Clinical Rationale" in line or "Clinical Rationale:" in line:
+            in_suggestions = False
+            in_explanation = True
+            in_additional = False
+            in_examples = False
+            continue
+        elif "Additional Analysis:" in line or "Further Observations:" in line:
+            in_suggestions = False
+            in_explanation = False
+            in_additional = True
+            in_examples = False
+            continue
+        elif "Examples:" in line or "Specific Errors:" in line:
+            in_suggestions = False
+            in_explanation = False
+            in_additional = False
+            in_examples = True
+            continue
+            
+        # Add content to appropriate section
+        if in_suggestions:
+            if line.startswith("- "):
+                treatment_suggestions.append(line[2:])  # Remove the bullet point
+            elif line.startswith("•"):
+                treatment_suggestions.append(line[1:].strip())  # Remove bullet and trim
+            elif line and not line.startswith("#"):
+                # Non-empty, non-header lines might be treatment suggestions without bullets
+                treatment_suggestions.append(line)
+        elif in_explanation:
+            explanation += line + "\n"
+        elif in_additional:
+            additional_analysis += line + "\n"
+        elif in_examples and current_factor and not specific_errors.get(current_factor):
+            # Look for quoted examples in the examples section
+            if '"' in line or "'" in line:
+                example_match = re.search(r'[\"\']([^\"\']*)[\"\']', line)
+                if example_match:
+                    specific_errors[current_factor] = example_match.group(1)
+                    # Update the examples in the dataframe
+                    if current_factor in data['Factor']:
+                        idx = data['Factor'].index(current_factor)
+                        data['Examples'][idx] = example_match.group(1)
+        
+        # Continuously look for examples with quotes regardless of section
+        if ('"' in line or "'" in line) and current_factor:
+            if re.search(rf'{current_factor}.*[\"\']([^\"\']*)[\"\']', line, re.IGNORECASE):
+                example_match = re.search(r'[\"\']([^\"\']*)[\"\']', line)
+                if example_match:
+                    specific_errors[current_factor] = example_match.group(1)
+                    # Update in dataframe
+                    if current_factor in data['Factor']:
+                        idx = data['Factor'].index(current_factor)
+                        data['Examples'][idx] = example_match.group(1)
+    
+    # Process specific errors and examples if they're presented as a list later in the text
+    for i, line in enumerate(lines):
+        if "examples of errors" in line.lower() or "error examples" in line.lower():
+            # Look through next few lines for examples
+            for j in range(i+1, min(i+15, len(lines))):
+                example_line = lines[j].strip()
+                if not example_line or example_line.startswith("#"):
+                    continue
+                    
+                # Look for factors mentioned with examples
+                for factor in data['Factor']:
+                    if factor.lower() in example_line.lower() and ('"' in example_line or "'" in example_line):
+                        example_match = re.search(r'[\"\']([^\"\']*)[\"\']', example_line)
+                        if example_match:
+                            idx = data['Factor'].index(factor)
+                            data['Examples'][idx] = example_match.group(1)
+                            specific_errors[factor] = example_match.group(1)
+    
+    return {
+        'speech_factors': pd.DataFrame(data),
+        'casl_data': pd.DataFrame(casl_data),
+        'treatment_suggestions': treatment_suggestions,
+        'explanation': explanation,
+        'additional_analysis': additional_analysis,
+        'specific_errors': specific_errors,
+        'raw_response': raw_response  # Include the full LLM response
+    }
+
+def create_casl_plots(speech_factors, casl_data):
+    """Create visualizations for the CASL analysis results"""
+    
+    # Set a professional style for the plots
+    plt.style.use('seaborn-v0_8-pastel')
+    
+    # Create figure with two subplots
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6), dpi=100)
+    
+    # Plot speech factors - sorted by occurrence count
+    if not speech_factors.empty:
+        # Sort the dataframe
+        speech_factors_sorted = speech_factors.sort_values('Occurrences', ascending=False)
+        
+        # Custom colors
+        speech_colors = ['#4C72B0', '#55A868', '#C44E52', '#8172B3', '#CCB974', '#64B5CD', '#4C72B0']
+        
+        # Create horizontal bar chart
+        bars = ax1.barh(speech_factors_sorted['Factor'], 
+               speech_factors_sorted['Occurrences'], 
+               color=speech_colors[:len(speech_factors_sorted)])
+        
+        # Add count labels at the end of each bar
+        for i, bar in enumerate(bars):
+            width = bar.get_width()
+            factor = speech_factors_sorted.iloc[i]['Factor']
+            
+            # Get severity percentile for this factor
+            severity = speech_factors_sorted.iloc[i]['Severity']
+            
+            # Label with both count and severity percentile
+            ax1.text(width + 0.3, bar.get_y() + bar.get_height()/2, 
+                    f'{width:.0f} ({severity}%)', ha='left', va='center')
+            
+            # Add example as annotation if available
+            if 'Examples' in speech_factors_sorted.columns:
+                example = speech_factors_sorted.iloc[i]['Examples']
+                if example and len(example) > 0:
+                    # Add a small marker to indicate example exists
+                    ax1.text(0.5, bar.get_y() + bar.get_height()/2, 
+                            '★', ha='center', va='center', color='#C44E52', 
+                            fontsize=8, fontweight='bold')
+        
+        ax1.set_title('Speech Factors Analysis', fontsize=14, fontweight='bold')
+        ax1.set_xlabel('Number of Occurrences', fontsize=11)
+        # No y-label needed for horizontal bar chart
+        
+        # Remove top and right spines
+        ax1.spines['top'].set_visible(False)
+        ax1.spines['right'].set_visible(False)
+        
+        # Add a footnote about the star symbol
+        ax1.annotate('★ = Example available in details panel', xy=(0, -0.1), xycoords='axes fraction', 
+                   fontsize=8, ha='left', va='center', color='#C44E52')
+    
+    # Plot CASL domains
+    domain_names = casl_data['Domain']
+    y_scores = casl_data['Standard Score']
+    percentiles = casl_data['Percentile']
+    
+    # Custom color scheme
+    casl_colors = ['#4C72B0', '#55A868', '#C44E52']
+    
+    # Create bars with nice colors
+    bars = ax2.bar(domain_names, y_scores, color=casl_colors)
+    
+    # Add score labels on top of each bar
+    for i, bar in enumerate(bars):
+        height = bar.get_height()
+        score = y_scores.iloc[i]
+        percentile = percentiles.iloc[i]
+        
+        # Label with both score and percentile
+        ax2.text(bar.get_x() + bar.get_width()/2., height + 1,
+                f'{score:.0f} ({percentile}%)', ha='center', va='bottom')
+        
+        # Add a star marker if example exists
+        if 'Examples' in casl_data.columns:
+            example = casl_data.iloc[i]['Examples']
+            if example and len(example) > 0:
+                ax2.text(bar.get_x() + bar.get_width()/2., height/2,
+                        '★', ha='center', va='center', color='white', 
+                        fontsize=12, fontweight='bold')
+    
+    # Add score reference lines
+    ax2.axhline(y=100, linestyle='--', color='gray', alpha=0.7, label='Average (100)')
+    ax2.axhline(y=85, linestyle=':', color='orange', alpha=0.7, label='Below Average (<85)')
+    ax2.axhline(y=115, linestyle=':', color='green', alpha=0.7, label='Above Average (>115)')
+    
+    # Add labels and title
+    ax2.set_title('CASL-2 Standard Scores', fontsize=14, fontweight='bold')
+    ax2.set_ylabel('Standard Score', fontsize=11)
+    ax2.set_ylim(bottom=0, top=max(130, max(y_scores) + 15))  # Set y-axis limit with some padding
+    
+    # Add legend
+    ax2.legend(loc='upper right', fontsize='small')
+    
+    # Remove top and right spines
+    ax2.spines['top'].set_visible(False)
+    ax2.spines['right'].set_visible(False)
+    
+    # Add overall figure title
+    fig.suptitle('Speech Analysis Results', fontsize=16, fontweight='bold', y=0.98)
+    
+    # Add a subtitle with note about examples
+    plt.figtext(0.5, 0.01, '★ indicates specific examples available in the Error Examples panel', 
+                ha='center', fontsize=9, fontstyle='italic')
+    
+    plt.tight_layout(rect=[0, 0.03, 1, 0.95])  # Adjust layout to make room for suptitle
+    
+    # Save plot to buffer
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', bbox_inches='tight')
+    buf.seek(0)
+    plt.close()
+    
+    return buf
+
+def create_casl_radar_chart(speech_factors):
+    """Create a radar chart for speech factors (percentiles)"""
+    
+    if speech_factors.empty or 'Severity' not in speech_factors.columns:
+        # Create a placeholder image if no data
+        plt.figure(figsize=(8, 8))
+        plt.text(0.5, 0.5, "No data available for radar chart", 
+                ha='center', va='center', fontsize=14)
+        plt.axis('off')
+        
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png')
+        buf.seek(0)
+        plt.close()
+        return buf
+    
+    # Prepare data for radar chart
+    categories = speech_factors['Factor'].tolist()
+    percentiles = speech_factors['Severity'].tolist()
+    
+    # Need to repeat first value to close the polygon
+    categories = categories + [categories[0]]
+    percentiles = percentiles + [percentiles[0]]
+    
+    # Convert to radians and calculate points
+    N = len(categories) - 1  # Subtract 1 for the repeated point
+    angles = [n / float(N) * 2 * np.pi for n in range(N)]
+    angles += angles[:1]  # Repeat the first angle to close the polygon
+    
+    # Create the plot
+    fig = plt.figure(figsize=(8, 8))
+    ax = fig.add_subplot(111, polar=True)
+    
+    # Draw percentile lines with labels
+    plt.xticks(angles[:-1], categories[:-1], size=12)
+    ax.set_rlabel_position(0)
+    plt.yticks([20, 40, 60, 80, 100], ["20", "40", "60", "80", "100"], color="grey", size=10)
+    plt.ylim(0, 100)
+    
+    # Plot data
+    ax.plot(angles, percentiles, linewidth=1, linestyle='solid', color='#4C72B0')
+    ax.fill(angles, percentiles, color='#4C72B0', alpha=0.25)
+    
+    # Add title
+    plt.title('Speech Factors Severity (Percentile)', size=15, fontweight='bold', pad=20)
+    
+    # Save to buffer
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', bbox_inches='tight')
+    buf.seek(0)
+    plt.close()
+    
+    return buf
+
+def analyze_transcript(transcript, age, gender):
+    """Analyze a speech transcript using the CASL framework"""
+    
+    # Instructions for the LLM analysis
+    instructions = """
+    You're a professional Speech-Language Pathologist analyzing this transcription sample.
+    
+    For your analysis, count occurrences of:
+    
+    1. Difficulty producing fluent, grammatical speech - Speech that is slow, halting, with pauses while searching for words
+    2. Word retrieval issues - Trouble finding specific words, using fillers like "um", circumlocution, or semantically similar substitutions
+    3. Grammatical errors - Missing/incorrect function words, verb tense problems, simplified sentences
+    4. Repetitions and revisions - Repeating or restating due to word-finding or sentence construction difficulties
+    5. Neologisms - Creating nonexistent "new" words
+    6. Perseveration - Unintentionally repeating words or phrases
+    7. Comprehension issues - Difficulty understanding complex sentences or fast speech
+    
+    Analyze using the CASL-2 (Comprehensive Assessment of Spoken Language) framework:
+    
+    Lexical/Semantic Skills:
+    - Evaluate vocabulary diversity, word retrieval difficulties, and semantic precision
+    - Estimate Standard Score (mean=100, SD=15), percentile rank, and performance level
+    - Quote specific examples from the transcript to support your assessment
+    
+    Syntactic Skills:
+    - Assess sentence structure, grammatical accuracy, and syntactic complexity
+    - Estimate Standard Score, percentile rank, and performance level
+    - Quote specific examples from the transcript to support your assessment
+    
+    Supralinguistic Skills:
+    - Evaluate figurative language use, inferencing, and contextual understanding
+    - Estimate Standard Score, percentile rank, and performance level
+    - Quote specific examples from the transcript to support your assessment
+    
+    Format your analysis with:
+    1. Speech factor counts with severity percentiles - Include direct quotes for examples of each factor you identify
+    2. CASL-2 domain scores with performance levels - Include direct quotes for examples in each domain
+    3. Treatment recommendations based on findings
+    4. Brief explanation of your rationale
+    5. Any additional insights
+    
+    IMPORTANT: For each factor and domain you analyze, provide direct quotes from the transcript as evidence. For example:
+    
+    Word retrieval issues: 7, 65% - Example: "today I would &-um like to talk about &-um a fun trip"
+    Grammatical errors: 3, 45% - Example: "after swimming we [//] I eat [: ate] [*] &-um ice cream"
+    
+    This specificity is critical for diagnostic accuracy and treatment planning.
+    """
+    
+    # Prepare prompt for Claude
+    prompt = f"""
+    You are an experienced Speech-Language Pathologist analyzing this transcript for a patient who is {age} years old and {gender}.
+    
+    TRANSCRIPT:
+    {transcript}
+    
+    {instructions}
+    
+    Be precise, professional, and empathetic in your analysis. Focus on the linguistic patterns present in the sample.
+    """
+    
+    # Call the appropriate API or fallback to demo mode
+    if bedrock_client:
+        response = call_bedrock(prompt)
+    else:
+        response = generate_demo_response(prompt)
+    
+    # Parse the response
+    results = parse_casl_response(response)
+    
+    # Create visualizations
+    plot_image = create_casl_plots(results['speech_factors'], results['casl_data'])
+    radar_image = create_casl_radar_chart(results['speech_factors'])
+    
+    return results, plot_image, radar_image, response
+
+def generate_report(patient_info, analysis_results, report_type="formal"):
+    """Generate a professional report based on analysis results"""
+    
+    patient_name = patient_info.get("name", "")
+    record_id = patient_info.get("record_id", "")
+    age = patient_info.get("age", "")
+    gender = patient_info.get("gender", "")
+    assessment_date = patient_info.get("assessment_date", datetime.now().strftime('%m/%d/%Y'))
+    clinician = patient_info.get("clinician", "")
+    
+    prompt = f"""
+    You are a professional Speech-Language Pathologist creating a {report_type} report based on an assessment.
+    
+    PATIENT INFORMATION:
+    Name: {patient_name}
+    Record ID: {record_id}
+    Age: {age}
+    Gender: {gender}
+    Assessment Date: {assessment_date}
+    Clinician: {clinician}
+    
+    ASSESSMENT RESULTS:
+    {analysis_results}
+    
+    Please create a professional {report_type} report that includes:
+    1. Patient information and assessment details
+    2. Summary of findings (strengths and areas of concern)
+    3. Detailed analysis of language domains
+    4. Specific recommendations for therapy
+    5. Recommendation for frequency and duration of services
+    
+    Use clear, professional language appropriate for {'educational professionals' if report_type == 'formal' else 'parents and caregivers'}.
+    Format the report with proper headings and sections.
+    """
+    
+    # Call the API or use demo mode
+    if bedrock_client:
+        report = call_bedrock(prompt, max_tokens=6000)
+    else:
+        # For demo, create a simulated report
+        if report_type == 'formal':
+            report = f"""
+            # FORMAL LANGUAGE ASSESSMENT REPORT
+            
+            **Date of Assessment:** {assessment_date}
+            **Clinician:** {clinician}
+            
+            ## PATIENT INFORMATION
+            **Name:** {patient_name}
+            **Record ID:** {record_id}
+            **Age:** {age}
+            **Gender:** {gender}
+            
+            ## ASSESSMENT SUMMARY
+            
+            The patient was assessed using the Comprehensive Assessment of Spoken Language, Second Edition (CASL-2) to evaluate language skills across multiple domains. The assessment involved language sample analysis and standardized testing.
+            
+            ## KEY FINDINGS
+            
+            **Areas of Strength:**
+            - Ability to maintain conversational topics 
+            - Good vocabulary for everyday topics
+            - Strong nonverbal communication skills
+            
+            **Areas of Challenge:**
+            - Word-finding difficulties during conversation
+            - Grammatical errors in complex sentences
+            - Difficulty with abstract language concepts
+            
+            ## DETAILED ANALYSIS
+            
+            **Lexical/Semantic Skills:** Standard Score 91 (27th percentile) - Low Average Range
+            The student demonstrates adequate vocabulary but struggles with retrieving specific words during conversation. Word-finding pauses were noted throughout the language sample.
+            
+            **Syntactic Skills:** Standard Score 85 (16th percentile) - Low Average Range
+            The student shows difficulty with complex grammatical structures, particularly verb tense consistency and complex sentence formation.
+            
+            **Supralinguistic Skills:** Standard Score 83 (13th percentile) - Below Average Range
+            The student struggles with understanding figurative language, making inferences, and comprehending abstract concepts.
+            
+            ## RECOMMENDATIONS
+            
+            1. Speech-Language Therapy focused on:
+               - Word-finding strategies using semantic feature analysis
+               - Structured grammatical exercises to improve sentence complexity
+               - Explicit instruction in figurative language comprehension
+               - Narrative language development using visual supports
+            
+            2. Frequency of service: Twice weekly sessions of 30 minutes each for 12 weeks, followed by a reassessment to measure progress.
+            
+            3. Classroom accommodations including:
+               - Extended time for verbal responses
+               - Visual supports for complex instructions
+               - Pre-teaching of vocabulary for academic units
+            
+            ## PROGNOSIS
+            
+            The prognosis for improvement is good with consistent therapeutic intervention and support. Regular reassessment is recommended to monitor progress.
+            
+            Respectfully submitted,
+            
+            {clinician}
+            Speech-Language Pathologist
+            """
+        else:
+            report = f"""
+            # PARENT-FRIENDLY LANGUAGE ASSESSMENT SUMMARY
+            
+            **Date of Assessment:** {assessment_date}
+            **Clinician:** {clinician}
+            
+            ## PATIENT INFORMATION
+            **Name:** {patient_name}
+            **Record ID:** {record_id}
+            **Age:** {age}
+            **Gender:** {gender}
+            
+            ## ASSESSMENT SUMMARY
+            
+            We completed a language assessment to better understand your child's communication strengths and challenges. This helps us create a plan to support their development.
+            
+            ## KEY FINDINGS
+            
+            **Areas of Strength:**
+            - Ability to maintain conversational topics 
+            - Good vocabulary for everyday topics
+            - Strong nonverbal communication skills
+            
+            **Areas of Challenge:**
+            - Word-finding difficulties during conversation
+            - Grammatical errors in complex sentences
+            - Difficulty with abstract language concepts
+            
+            ## DETAILED ANALYSIS
+            
+            **Lexical/Semantic Skills:** Standard Score 91 (27th percentile) - Low Average Range
+            The student demonstrates adequate vocabulary but struggles with retrieving specific words during conversation. Word-finding pauses were noted throughout the language sample.
+            
+            **Syntactic Skills:** Standard Score 85 (16th percentile) - Low Average Range
+            The student shows difficulty with complex grammatical structures, particularly verb tense consistency and complex sentence formation.
+            
+            **Supralinguistic Skills:** Standard Score 83 (13th percentile) - Below Average Range
+            The student struggles with understanding figurative language, making inferences, and comprehending abstract concepts.
+            
+            ## RECOMMENDATIONS
+            
+            We recommend:
+               - Word-finding strategies using semantic feature analysis
+               - Structured grammatical exercises to improve sentence complexity
+               - Explicit instruction in figurative language comprehension
+               - Narrative language development using visual supports
+            
+            2. We recommend therapy twice a week for 30 minutes. This consistency will help your child make better progress.
+            
+            3. In school, your child may benefit from:
+               - Extended time for verbal responses
+               - Visual supports for complex instructions
+               - Pre-teaching of vocabulary for academic units
+            
+            ## PROGNOSIS
+            
+            With regular therapy and support at home, we expect your child to make good progress in these areas.
+            
+            Please reach out with any questions!
+            
+            {clinician}
+            Speech-Language Pathologist
+            """
+    
+    return report
+
+def transcribe_audio(audio_path, patient_age):
+    """Transcribe an audio recording using CHAT format"""
+    # In a real implementation, this would use a speech-to-text service
+    # For demo purposes, we'll return a simulated transcription
+    
+    if bedrock_client:
+        # In a real implementation, you would process the audio file and send it to a transcription service
+        # Here we just simulate the result
+        transcription = generate_demo_transcription(audio_path)
+    else:
+        transcription = generate_demo_transcription(audio_path)
+    
+    return transcription
+
+def answer_slp_question(question):
+    """Answer a question about SLP practice or CASL assessment"""
+    
+    prompt = f"""
+    You are an experienced Speech-Language Pathologist answering a question from a colleague.
+    
+    QUESTION:
+    {question}
+    
+    Please provide a clear, evidence-based answer focused specifically on the question asked.
+    Reference best practices and current research where appropriate.
+    Keep your answer concise but comprehensive.
+    """
+    
+    if bedrock_client:
+        answer = call_bedrock(prompt)
+    else:
+        answer = generate_demo_qa_response(question)
+    
+    return answer
+
+# ===============================
+# Gradio Interface
+# ===============================
+
+def create_interface():
+    """Create the main Gradio interface"""
+    
+    # Use a simple theme with default colors
+    custom_theme = gr.themes.Soft(
+        font=[gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"]
+    )
+    
+    with gr.Blocks(theme=custom_theme, css="""
+        .header {
+            text-align: center;
+            margin-bottom: 20px;
+        }
+        .header img {
+            max-height: 100px;
+            margin-bottom: 10px;
+        }
+        .container {
+            border-radius: 10px;
+            padding: 10px;
+            margin-bottom: 20px;
+        }
+        .patient-info {
+            background-color: #e3f2fd;
+        }
+        .speech-sample {
+            background-color: #f0f8ff;
+        }
+        .results-container {
+            background-color: #f9f9f9; 
+        }
+        .viz-container {
+            display: flex;
+            justify-content: center;
+            margin-bottom: 20px;
+        }
+        .footer {
+            text-align: center;
+            margin-top: 30px;
+            padding: 10px;
+            font-size: 0.8em;
+            color: #78909C;
+        }
+        .info-box {
+            background-color: #e8f5e9;
+            border-left: 4px solid #4CAF50;
+            padding: 10px 15px;
+            margin-bottom: 15px;
+            border-radius: 4px;
+        }
+        .warning-box {
+            background-color: #fff8e1;
+            border-left: 4px solid #FFC107;
+            padding: 10px 15px;
+            border-radius: 4px;
+        }
+        .markdown-text h3 {
+            color: #2C7FB8;
+            border-bottom: 1px solid #eaeaea;
+            padding-bottom: 5px;
+        }
+        .evidence-table {
+            border-collapse: collapse;
+            width: 100%;
+        }
+        .evidence-table th, .evidence-table td {
+            border: 1px solid #ddd;
+            padding: 8px;
+            text-align: left;
+        }
+        .evidence-table th {
+            background-color: #f5f7fa;
+            color: #333;
+        }
+        .evidence-table tr:nth-child(even) {
+            background-color: #f9f9f9;
+        }
+        .tab-content {
+            padding: 15px;
+            background-color: white;
+            border-radius: 0 0 8px 8px;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.05);
+        }
+    """) as app:
+        # Create header with logo
+        gr.HTML(
+            """
+            <div class="header">
+                <h1>SLP Analysis Tool</h1>
+                <p>A comprehensive assessment tool for Speech-Language Pathologists</p>
+            </div>
+            """
+        )
+        
+        # Main tabs
+        with gr.Tabs() as main_tabs:
+            # ===============================
+            # CASL Analysis Tab
+            # ===============================
+            with gr.TabItem("CASL Analysis", id=0):
+                with gr.Row():
+                    # Left column - Input section
+                    with gr.Column(scale=1):
+                        # Patient information panel
+                        with gr.Group(elem_classes="container patient-info"):
+                            gr.Markdown("### Patient Information")
+                            
+                            with gr.Row():
+                                patient_name = gr.Textbox(label="Patient Name", placeholder="Enter patient name")
+                                record_id = gr.Textbox(label="Record ID", placeholder="Enter record ID")
+                            
+                            with gr.Row():
+                                age = gr.Number(label="Age", value=8, minimum=1, maximum=120)
+                                gender = gr.Radio(["male", "female", "other"], label="Gender", value="male")
+                            
+                            with gr.Row():
+                                assessment_date = gr.Textbox(
+                                    label="Assessment Date", 
+                                    placeholder="MM/DD/YYYY", 
+                                    value=datetime.now().strftime('%m/%d/%Y')
+                                )
+                                clinician_name = gr.Textbox(
+                                    label="Clinician", 
+                                    placeholder="Enter clinician name"
+                                )
+                        
+                        # Speech sample panel
+                        with gr.Group(elem_classes="container speech-sample"):
+                            gr.Markdown("### Speech Sample")
+                            
+                            # Sample button
+                            sample_btn = gr.Button("Load Sample Transcript", size="sm")
+                            
+                            # Transcript input
+                            transcript = gr.Textbox(
+                                label="Transcript", 
+                                placeholder="Paste the speech transcript here...",
+                                lines=10
+                            )
+                            
+                            # Add info about transcript format
+                            gr.Markdown(
+                                """
+                                <div class="info-box">
+                                    <strong>Transcript Format:</strong> Use CHAT format with *PAR: for patient lines. 
+                                    Mark word-finding with &-um, paraphasias with [*], and provide intended words with [: word].
+                                </div>
+                                """,
+                                elem_classes="markdown-text"
+                            )
+                            
+                            # File upload
+                            file_upload = gr.File(
+                                label="Or upload a transcript file", 
+                                file_types=["text", "txt", "pdf", "rtf"]
+                            )
+                            
+                            # Analysis button
+                            analyze_btn = gr.Button("Analyze Speech Sample", variant="primary", size="lg")
+                    
+                    # Right column - Results section
+                    with gr.Column(scale=1):
+                        with gr.Group(elem_classes="container results-container"):
+                            with gr.Tabs() as results_tabs:
+                                # Summary tab
+                                with gr.TabItem("Summary", id=0, elem_classes="tab-content"):
+                                    with gr.Row():
+                                        output_image = gr.Image(
+                                            label="Speech Factors & CASL-2 Scores", 
+                                            show_label=True, 
+                                            elem_classes="viz-container"
+                                        )
+                                    
+                                    with gr.Row():
+                                        radar_chart = gr.Image(
+                                            label="Severity Profile", 
+                                            show_label=True, 
+                                            elem_classes="viz-container"
+                                        )
+                                        
+                                    with gr.Group():
+                                        gr.Markdown("### Key Findings", elem_classes="markdown-text")
+                                        speech_factors_table = gr.DataFrame(
+                                            label="Speech Factors Analysis", 
+                                            headers=["Factor", "Occurrences", "Severity (Percentile)", "Example Errors"],
+                                            interactive=False
+                                        )
+                                        casl_table = gr.DataFrame(
+                                            label="CASL-2 Assessment", 
+                                            headers=["Domain", "Standard Score", "Percentile", "Performance Level", "Example"],
+                                            interactive=False
+                                        )
+                                        
+                                    with gr.Accordion("Specific Error Examples", open=False):
+                                        specific_errors_md = gr.Markdown(elem_classes="markdown-text")
+                                
+                                # Treatment tab
+                                with gr.TabItem("Treatment Plan", id=1, elem_classes="tab-content"):
+                                    gr.Markdown("### Recommended Treatment Approaches", elem_classes="markdown-text")
+                                    treatment_md = gr.Markdown(elem_classes="treatment-panel")
+                                    
+                                    gr.Markdown("### Clinical Rationale", elem_classes="markdown-text")
+                                    explanation_md = gr.Markdown(elem_classes="panel")
+                                    
+                                    with gr.Accordion("Supporting Evidence", open=False):
+                                        gr.Markdown("""
+                                        <table class="evidence-table">
+                                          <tr>
+                                            <th>Factor</th>
+                                            <th>Evidence-based Approaches</th>
+                                            <th>References</th>
+                                          </tr>
+                                          <tr>
+                                            <td>Word Retrieval</td>
+                                            <td>Semantic feature analysis, phonological cueing, word generation tasks</td>
+                                            <td>Boyle, 2010; Kiran & Thompson, 2003</td>
+                                          </tr>
+                                          <tr>
+                                            <td>Grammatical Errors</td>
+                                            <td>Treatment of Underlying Forms (TUF), Morphosyntactic therapy</td>
+                                            <td>Thompson et al., 2003; Ebbels, 2014</td>
+                                          </tr>
+                                          <tr>
+                                            <td>Fluency/Prosody</td>
+                                            <td>Rate control, rhythmic cueing, contrastive stress exercises</td>
+                                            <td>Ballard et al., 2010; Tamplin & Baker, 2017</td>
+                                          </tr>
+                                        </table>
+                                        """, elem_classes="markdown-text")
+                                
+                                # Full report tab
+                                with gr.TabItem("Full Report", id=2, elem_classes="tab-content"):
+                                    full_analysis = gr.Markdown()
+                                    
+                                    # Add PDF export option
+                                    export_btn = gr.Button("Export Report as PDF", variant="secondary")
+                                    export_status = gr.Markdown("")
+                                
+                                # Raw LLM Output tab
+                                with gr.TabItem("Raw LLM Output", id=3, elem_classes="tab-content"):
+                                    gr.Markdown("### Complete Model Output", elem_classes="markdown-text")
+                                    gr.Markdown("This tab shows the unprocessed output from the AI model for debugging purposes.")
+                                    raw_llm_output = gr.Textbox(
+                                        label="Raw AI Output",
+                                        lines=20,
+                                        interactive=False
+                                    )
+            
+            # ===============================
+            # Patient Records Tab
+            # ===============================
+            with gr.TabItem("Patient Records", id=1):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Patient Records")
+                        
+                        # Records table
+                        patient_records_table = gr.Dataframe(
+                            headers=["ID", "Name", "Record ID", "Age", "Gender", "Assessment Date", "Clinician"],
+                            datatype=["str", "str", "str", "str", "str", "str", "str"],
+                            label="Saved Patients",
+                            interactive=False
+                        )
+                        
+                        refresh_records_btn = gr.Button("Refresh Records", size="sm")
+                        records_status = gr.Markdown("")
+                        
+                        # Record selection
+                        selected_record_id = gr.Textbox(label="Selected Record ID", visible=False)
+                        load_record_btn = gr.Button("Load Selected Record", variant="primary")
+                    
+                    with gr.Column(scale=1):
+                        # Record details
+                        record_details = gr.Markdown(label="Record Details")
+                
+                # Event handlers for records
+                def refresh_patient_records():
+                    """Refresh the patient records table"""
+                    records = get_all_patient_records()
+                    data = []
+                    for r in records:
+                        data.append([
+                            r["id"], r["name"], r["record_id"], 
+                            r["age"], r["gender"], r["assessment_date"], r["clinician"]
+                        ])
+                    df = pd.DataFrame(data)
+                    status_msg = f"Found {len(data)} patient records."
+                    return df, status_msg
+                
+                refresh_records_btn.click(
+                    refresh_patient_records,
+                    outputs=[patient_records_table, records_status]
+                )
+                
+                # Automatically load records when tab is selected
+                main_tabs.select(
+                    lambda tab_id: refresh_patient_records() if tab_id == 1 else (pd.DataFrame(), ""),
+                    inputs=[main_tabs],
+                    outputs=[patient_records_table, records_status]
+                )
+                
+                # Load record when a row is selected
+                def handle_record_selection(evt: gr.SelectData, records):
+                    if records is None or len(records) == 0:
+                        return "", "No record selected."
+                    
+                    selected_row = evt.index[0]
+                    if selected_row < len(records):
+                        record_id = records.iloc[selected_row, 0]
+                        
+                        # Load the record to show details
+                        record_data = load_patient_record(record_id)
+                        if record_data:
+                            patient_info = record_data.get("patient_info", {})
+                            
+                            # Format record details as markdown
+                            details = f"""
+                            ## Selected Patient Record
+                            
+                            **Name:** {patient_info.get('name', 'N/A')}  
+                            **Record ID:** {patient_info.get('record_id', 'N/A')}  
+                            **Age:** {patient_info.get('age', 'N/A')}  
+                            **Gender:** {patient_info.get('gender', 'N/A')}  
+                            **Assessment Date:** {patient_info.get('assessment_date', 'N/A')}  
+                            **Clinician:** {patient_info.get('clinician', 'N/A')}  
+                            **Analyzed:** {record_data.get('timestamp', 'Unknown')}
+                            
+                            ### Preview
+                            
+                            This record contains:
+                            - Speech transcript analysis
+                            - CASL assessment results
+                            - Treatment recommendations
+                            
+                            Click "Load Selected Record" to view the full analysis.
+                            """
+                            
+                            return record_id, details
+                        
+                        return record_id, f"Selected record: {record_id}"
+                    
+                    return "", "Invalid selection."
+                
+                patient_records_table.select(
+                    handle_record_selection,
+                    inputs=[patient_records_table],
+                    outputs=[selected_record_id, record_details]
+                )
+                
+                # Load record into analysis tab
+                def load_patient_record_to_analysis(record_id):
+                    if not record_id:
+                        return gr.update(selected=1), {}, "", "", "", "", "", ""
+                    
+                    record_data = load_patient_record(record_id)
+                    if not record_data:
+                        return gr.update(selected=1), "", "", "", "male", "", "", ""
+                    
+                    # Extract data
+                    patient_info = record_data.get("patient_info", {})
+                    transcript_text = record_data.get("transcript", "")
+                    analysis_results = record_data.get("analysis_results", {})
+                    
+                    # Create status message for the record loading
+                    status_msg = f"✅ Record loaded successfully: {patient_info.get('name', 'Unknown')} ({record_id})"
+                    
+                    # Now we should also load the analysis results
+                    # In a future version, we would need to update all analysis outputs here as well
+                    
+                    return (
+                        gr.update(selected=0),  # Switch to analysis tab
+                        patient_info.get("name", ""),
+                        patient_info.get("record_id", ""),
+                        patient_info.get("age", ""),
+                        patient_info.get("gender", "male"),
+                        patient_info.get("assessment_date", ""),
+                        patient_info.get("clinician", ""),
+                        transcript_text,
+                        status_msg
+                    )
+                
+                load_record_btn.click(
+                    load_patient_record_to_analysis,
+                    inputs=[selected_record_id],
+                    outputs=[
+                        main_tabs,
+                        patient_name, record_id, age, gender, 
+                        assessment_date, clinician_name, transcript,
+                        records_status
+                    ]
+                )
+            
+            # ===============================
+            # Report Generator Tab
+            # ===============================
+            with gr.TabItem("Report Generator", id=2):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Generate Professional Reports")
+                        
+                        # Patient info
+                        with gr.Group(elem_classes="container patient-info"):
+                            gr.Markdown("#### Patient Information")
+                            report_patient_name = gr.Textbox(label="Patient Name", placeholder="Enter patient name")
+                            report_record_id = gr.Textbox(label="Record ID", placeholder="Enter record ID")
+                            report_age = gr.Number(label="Age", value=8, minimum=1, maximum=120)
+                            report_gender = gr.Radio(["male", "female", "other"], label="Gender", value="male")
+                            report_date = gr.Textbox(
+                                label="Assessment Date", 
+                                placeholder="MM/DD/YYYY", 
+                                value=datetime.now().strftime('%m/%d/%Y')
+                            )
+                            report_clinician = gr.Textbox(label="Clinician", placeholder="Enter clinician name")
+                        
+                        with gr.Group():
+                            gr.Markdown("#### Assessment Results")
+                            report_results = gr.Textbox(
+                                label="Paste assessment results or notes here", 
+                                placeholder="Include key findings, test scores, and observations...",
+                                lines=10
+                            )
+                            
+                            report_type = gr.Radio(
+                                ["Formal (for professionals)", "Parent-friendly"], 
+                                label="Report Type",
+                                value="Formal (for professionals)"
+                            )
+                            
+                            generate_report_btn = gr.Button("Generate Report", variant="primary")
+                    
+                    with gr.Column(scale=1):
+                        report_output = gr.Markdown()
+                        report_download_btn = gr.Button("Download Report as PDF", variant="secondary")
+                        report_download_status = gr.Markdown("")
+            
+            # ===============================
+            # Transcription Tool Tab
+            # ===============================
+            with gr.TabItem("Transcription Tool", id=3):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Audio Transcription Tool")
+                        gr.Markdown("Upload an audio recording to automatically transcribe it in CHAT format.")
+                        
+                        audio_input = gr.Audio(type="filepath", label="Upload Audio Recording")
+                        
+                        with gr.Row():
+                            transcription_age = gr.Number(label="Patient Age", value=8, minimum=1, maximum=120)
+                            transcribe_btn = gr.Button("Transcribe Audio", variant="primary")
+                    
+                    with gr.Column(scale=1):
+                        transcription_output = gr.Textbox(
+                            label="Transcription Result", 
+                            placeholder="Transcription will appear here...",
+                            lines=12
+                        )
+                        
+                        with gr.Row():
+                            copy_to_analysis_btn = gr.Button("Use for Analysis", variant="secondary")
+                            edit_transcription_btn = gr.Button("Edit Transcription", variant="secondary")
+            
+            # ===============================
+            # SLP Assistant Tab
+            # ===============================
+            with gr.TabItem("SLP Assistant", id=4):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### SLP Knowledge Assistant")
+                        gr.Markdown("Ask questions about CASL assessment, therapy techniques, or SLP best practices.")
+                        
+                        question_input = gr.Textbox(
+                            label="Your Question", 
+                            placeholder="e.g., What activities help improve word-finding skills?",
+                            lines=3
+                        )
+                        
+                        ask_question_btn = gr.Button("Ask Question", variant="primary")
+                        
+                        # Quick question buttons
+                        gr.Markdown("#### Common Questions")
+                        with gr.Row():
+                            q1_btn = gr.Button("What is CASL?")
+                            q2_btn = gr.Button("How do I interpret scores?")
+                        
+                        with gr.Row():
+                            q3_btn = gr.Button("Activities for word finding")
+                            q4_btn = gr.Button("When to reassess")
+                    
+                    with gr.Column(scale=1):
+                        answer_output = gr.Markdown()
+                        
+                        with gr.Accordion("References", open=False):
+                            gr.Markdown("""
+                            - American Speech-Language-Hearing Association (ASHA)
+                            - Comprehensive Assessment of Spoken Language (CASL-2) Manual
+                            - Evidence-Based Practice in Speech-Language Pathology
+                            - Current research in pediatric language intervention
+                            """)
+        
+        # ===============================
+        # Event Handlers
+        # ===============================
+        
+        # Load sample transcript button
+        def load_sample():
+            return SAMPLE_TRANSCRIPT
+        
+        sample_btn.click(load_sample, outputs=[transcript])
+        
+        # File upload handler
+        file_upload.upload(process_upload, file_upload, transcript)
+        
+        # Analysis button handler
+        def on_analyze_click(transcript_text, age_val, gender_val, patient_name_val, record_id_val, clinician_val, assessment_date_val):
+            if not transcript_text or len(transcript_text.strip()) < 50:
+                return (
+                    pd.DataFrame(), 
+                    pd.DataFrame(), 
+                    None,
+                    None,
+                    "Error: Please provide a longer transcript for analysis.",
+                    "The transcript is too short for meaningful analysis.",
+                    "Please provide a speech sample with at least 50 characters.",
+                    "",
+                    "",
+                    ""
+                )
+            
+            try:
+                results, plot_img, radar_img, full_text = analyze_transcript(transcript_text, age_val, gender_val)
+                
+                # Format treatment suggestions as markdown
+                treatment_text = ""
+                for i, suggestion in enumerate(results['treatment_suggestions']):
+                    treatment_text += f"- {suggestion}\n"
+                
+                # Format specific error examples
+                specific_errors_text = "## Speech Error Examples\n\n"
+                if 'specific_errors' in results:
+                    for factor, example in results['specific_errors'].items():
+                        if example:
+                            specific_errors_text += f"**{factor}:** \"{example}\"\n\n"
+                        else:
+                            specific_errors_text += f"**{factor}:** No specific example found\n\n"
+                else:
+                    specific_errors_text += "No specific error examples were identified."
+                
+                # Save the record to storage
+                patient_info = {
+                    "name": patient_name_val,
+                    "record_id": record_id_val,
+                    "age": age_val,
+                    "gender": gender_val,
+                    "assessment_date": assessment_date_val,
+                    "clinician": clinician_val
+                }
+                
+                saved_id = save_patient_record(patient_info, results, transcript_text)
+                
+                save_message = ""
+                if saved_id:
+                    save_message = f"""
+                    ✅ Patient record saved successfully.
+                    
+                    **System ID:** {saved_id}
+                    **Patient:** {patient_name_val or "Unnamed"} 
+                    **Record ID:** {record_id_val or "Not provided"}
+                    
+                    You can access this record later in the Patient Records tab.
+                    """
+                else:
+                    save_message = "⚠️ Failed to save patient record. Please check data directory permissions."
+                
+                # Format to include patient metadata in the full report
+                patient_info_text = ""
+                if patient_name_val:
+                    patient_info_text += f"**Patient:** {patient_name_val}\n"
+                if record_id_val:
+                    patient_info_text += f"**Record ID:** {record_id_val}\n"
+                if age_val:
+                    patient_info_text += f"**Age:** {age_val} years\n"
+                if gender_val:
+                    patient_info_text += f"**Gender:** {gender_val}\n"
+                if assessment_date_val:
+                    patient_info_text += f"**Assessment Date:** {assessment_date_val}\n"
+                if clinician_val:
+                    patient_info_text += f"**Clinician:** {clinician_val}\n"
+                if saved_id:
+                    patient_info_text += f"**System ID:** {saved_id}\n"
+                
+                if patient_info_text:
+                    full_report = f"## Patient Information\n\n{patient_info_text}\n\n## Analysis Report\n\n{full_text}"
+                else:
+                    full_report = f"## Complete Analysis Report\n\n{full_text}"
+                
+                # Get the raw LLM response
+                raw_output = results.get('raw_response', full_text)
+                
+                # Convert image buffers to PIL images
+                plot_img_pil = Image.open(plot_img)
+                radar_img_pil = Image.open(radar_img)
+                
+                return (
+                    results['speech_factors'],
+                    results['casl_data'],
+                    plot_img_pil,
+                    radar_img_pil,
+                    treatment_text,
+                    results['explanation'],
+                    full_report,
+                    save_message,
+                    specific_errors_text,
+                    raw_output
+                )
+            except Exception as e:
+                logger.exception("Error during analysis")
+                error_message = f"Error during analysis: {str(e)}"
+                return (
+                    pd.DataFrame(), 
+                    pd.DataFrame(), 
+                    None,
+                    None,
+                    f"Error during analysis: {str(e)}",
+                    "An error occurred while processing the transcript.",
+                    f"Error details: {str(e)}",
+                    "",
+                    "",
+                    f"Analysis failed with error: {error_message}\n\nPlease check your transcript format and try again."
+                )
+        
+        analyze_btn.click(
+            on_analyze_click,
+            inputs=[
+                transcript, age, gender, 
+                patient_name, record_id, clinician_name, assessment_date
+            ],
+            outputs=[
+                speech_factors_table,
+                casl_table,
+                output_image,
+                radar_chart, 
+                treatment_md,
+                explanation_md,
+                full_analysis,
+                export_status,
+                specific_errors_md,
+                raw_llm_output
+            ]
+        )
+        
+        # Export report functionality
+        def export_pdf(report_text, patient_name="Patient", record_id=""):
+            try:
+                from reportlab.lib.pagesizes import letter
+                from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+                from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+                import tempfile
+                import webbrowser
+                import os
+                
+                # Generate a safe filename
+                if patient_name and record_id:
+                    safe_name = f"{patient_name.replace(' ', '_')}_{record_id}"
+                elif patient_name:
+                    safe_name = patient_name.replace(' ', '_')
+                else:
+                    safe_name = f"speech_analysis_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+                
+                # Create a temporary file for the PDF
+                temp_dir = tempfile.gettempdir()
+                pdf_path = os.path.join(temp_dir, f"{safe_name}.pdf")
+                
+                # Create the PDF document
+                doc = SimpleDocTemplate(pdf_path, pagesize=letter)
+                styles = getSampleStyleSheet()
+                
+                # Create custom styles
+                styles.add(ParagraphStyle(
+                    name='Heading1',
+                    parent=styles['Heading1'],
+                    fontSize=16,
+                    spaceAfter=12
+                ))
+                
+                styles.add(ParagraphStyle(
+                    name='Heading2',
+                    parent=styles['Heading2'],
+                    fontSize=14,
+                    spaceAfter=10,
+                    spaceBefore=10
+                ))
+                
+                styles.add(ParagraphStyle(
+                    name='BodyText',
+                    parent=styles['BodyText'],
+                    fontSize=12,
+                    spaceAfter=8
+                ))
+                
+                # Convert markdown to PDF elements
+                # Very basic conversion - in a real app, use a proper markdown to PDF library
+                story = []
+                
+                # Add title
+                story.append(Paragraph("Speech Language Assessment Report", styles['Title']))
+                story.append(Spacer(1, 12))
+                
+                # Process the markdown content line by line
+                current_style = styles['BodyText']
+                
+                for line in report_text.split('\n'):
+                    # Skip empty lines
+                    if not line.strip():
+                        story.append(Spacer(1, 6))
+                        continue
+                        
+                    # Check for headings
+                    if line.startswith('# '):
+                        story.append(Paragraph(line[2:], styles['Heading1']))
+                    elif line.startswith('## '):
+                        story.append(Paragraph(line[3:], styles['Heading2']))
+                    elif line.startswith('- '):
+                        # Bullet points
+                        story.append(Paragraph('• ' + line[2:], styles['BodyText']))
+                    elif line.startswith('**') and line.endswith('**'):
+                        # Bold text - assuming it's a short line like a heading
+                        text = line.replace('**', '')
+                        story.append(Paragraph(f"<b>{text}</b>", styles['BodyText']))
+                    else:
+                        # Regular text
+                        story.append(Paragraph(line, styles['BodyText']))
+                
+                # Build the PDF
+                doc.build(story)
+                
+                # Open the PDF (in a real web app, you'd provide a download link)
+                # This will work in a desktop environment
+                return f"Report saved as PDF: {pdf_path}"
+            
+            except Exception as e:
+                logger.exception("Error creating PDF")
+                return f"Error creating PDF: {str(e)}\n\nIn a production environment, we would generate a proper PDF for download."
+        
+        # Simplified simulation for HuggingFace Spaces environment
+        def export_pdf_simulation(report_text):
+            return "Report export initiated. In a production environment, a PDF would be generated and downloaded."
+        
+        # Use the actual function in a desktop environment, simulation in web environment
+        if os.getenv("SPACE_ID"):  # Check if running on HuggingFace Spaces
+            export_btn.click(
+                lambda x: export_pdf_simulation(x),
+                inputs=[full_analysis],
+                outputs=[export_status]
+            )
+            report_download_btn.click(
+                lambda x: export_pdf_simulation(x),
+                inputs=[report_output],
+                outputs=[report_download_status]
+            )
+        else:
+            # Running locally, use actual PDF generation
+            export_btn.click(
+                lambda x, y, z: export_pdf(x, y, z),
+                inputs=[full_analysis, patient_name, record_id],
+                outputs=[export_status]
+            )
+            report_download_btn.click(
+                lambda x, y, z: export_pdf(x, y, z),
+                inputs=[report_output, report_patient_name, report_record_id],
+                outputs=[report_download_status]
+            )
+        
+        # Report generator button
+        def on_generate_report(name, record_id, age, gender, date, clinician, results, report_type):
+            patient_info = {
+                "name": name,
+                "record_id": record_id,
+                "age": age,
+                "gender": gender,
+                "assessment_date": date,
+                "clinician": clinician
+            }
+            
+            report_type_val = "formal" if "Formal" in report_type else "parent-friendly"
+            
+            try:
+                report = generate_report(patient_info, results, report_type_val)
+                return report
+            except Exception as e:
+                logger.exception("Error generating report")
+                return f"Error generating report: {str(e)}"
+        
+        generate_report_btn.click(
+            on_generate_report,
+            inputs=[
+                report_patient_name, report_record_id, report_age,
+                report_gender, report_date, report_clinician,
+                report_results, report_type
+            ],
+            outputs=[report_output]
+        )
+        
+        # Transcription button
+        def on_transcribe_audio(audio_path, age):
+            try:
+                if not audio_path:
+                    return "Please upload an audio file to transcribe."
+                
+                transcription = transcribe_audio(audio_path, age)
+                return transcription
+            except Exception as e:
+                logger.exception("Error transcribing audio")
+                return f"Error transcribing audio: {str(e)}"
+        
+        transcribe_btn.click(
+            on_transcribe_audio,
+            inputs=[audio_input, transcription_age],
+            outputs=[transcription_output]
+        )
+        
+        # Copy transcription to analysis
+        def copy_to_analysis(transcription):
+            return transcription, gr.update(selected=0)  # Switches to the Analysis tab
+        
+        copy_to_analysis_btn.click(
+            copy_to_analysis,
+            inputs=[transcription_output],
+            outputs=[transcript, main_tabs]
+        )
+        
+        # SLP Assistant question handling
+        def on_ask_question(question):
+            try:
+                answer = answer_slp_question(question)
+                return answer
+            except Exception as e:
+                logger.exception("Error getting answer")
+                return f"Error: {str(e)}"
+        
+        ask_question_btn.click(
+            on_ask_question,
+            inputs=[question_input],
+            outputs=[answer_output]
+        )
+        
+        # Quick question buttons
+        q1_btn.click(lambda: "What is CASL?", outputs=[question_input])
+        q2_btn.click(lambda: "How do I interpret CASL scores?", outputs=[question_input])
+        q3_btn.click(lambda: "What activities help with word finding difficulties?", outputs=[question_input])
+        q4_btn.click(lambda: "When should I reassess a patient?", outputs=[question_input])
+        
+    return app
+
+# ===============================
+# Main Application
+# ===============================
+
+# Create requirements.txt file for HuggingFace Spaces
+def create_requirements_file():
+    requirements = [
+        "gradio>=4.0.0",
+        "pandas",
+        "matplotlib",
+        "numpy",
+        "Pillow",
+        "PyPDF2",
+        "boto3",
+        "reportlab",
+        "uuid"
+    ]
+    
+    with open("requirements.txt", "w") as f:
+        for req in requirements:
+            f.write(f"{req}\n")
+
+# Create and launch the interface
+if __name__ == "__main__":
+    # Create requirements.txt for HuggingFace Spaces
+    create_requirements_file()
+    
+    # Check for AWS credentials
+    if not AWS_ACCESS_KEY or not AWS_SECRET_KEY:
+        print("NOTE: AWS credentials not found. The app will run in demo mode with simulated responses.")
+        print("To enable full functionality, set AWS_ACCESS_KEY and AWS_SECRET_KEY environment variables.")
+    
+    # Launch the Gradio app
+    app = create_interface()
+    app.launch()