Update annotated_casl_app.py

annotated_casl_app.py

@@ -18,8 +18,255 @@ if ANTHROPIC_API_KEY:
 else:
     logger.warning("Claude API key not found - using demo mode")
 
-def call_claude_api(prompt):
-    """Call Claude API for annotation or analysis"""
+def segment_response_by_sections(response_text):
+    """Segment response by section titles and return a dictionary of sections"""
+    required_sections = [
+        "1. SPEECH FACTORS",
+        "2. LANGUAGE SKILLS ASSESSMENT", 
+        "3. COMPLEX SENTENCE ANALYSIS",
+        "4. FIGURATIVE LANGUAGE ANALYSIS",
+        "5. PRAGMATIC LANGUAGE ASSESSMENT",
+        "6. VOCABULARY AND SEMANTIC ANALYSIS",
+        "7. MORPHOLOGICAL AND PHONOLOGICAL ANALYSIS",
+        "8. COGNITIVE-LINGUISTIC FACTORS",
+        "9. FLUENCY AND RHYTHM ANALYSIS",
+        "10. QUANTITATIVE METRICS",
+        "11. CLINICAL IMPLICATIONS",
+        "12. PROGNOSIS AND SUMMARY"
+    ]
+    
+    sections = {}
+    current_section = None
+    current_content = []
+    
+    lines = response_text.split('\n')
+    
+    for line in lines:
+        # Check if this line is a section header
+        is_section_header = False
+        for section in required_sections:
+            if section in line:
+                # Save previous section if exists
+                if current_section and current_content:
+                    sections[current_section] = '\n'.join(current_content).strip()
+                
+                # Start new section
+                current_section = section
+                current_content = []
+                is_section_header = True
+                break
+        
+        # If not a section header, add to current section content
+        if not is_section_header and current_section:
+            current_content.append(line)
+    
+    # Save the last section
+    if current_section and current_content:
+        sections[current_section] = '\n'.join(current_content).strip()
+    
+    return sections
+
+def combine_sections_smartly(sections_dict):
+    """Combine sections in the correct order without duplicates"""
+    required_sections = [
+        "1. SPEECH FACTORS",
+        "2. LANGUAGE SKILLS ASSESSMENT", 
+        "3. COMPLEX SENTENCE ANALYSIS",
+        "4. FIGURATIVE LANGUAGE ANALYSIS",
+        "5. PRAGMATIC LANGUAGE ASSESSMENT",
+        "6. VOCABULARY AND SEMANTIC ANALYSIS",
+        "7. MORPHOLOGICAL AND PHONOLOGICAL ANALYSIS",
+        "8. COGNITIVE-LINGUISTIC FACTORS",
+        "9. FLUENCY AND RHYTHM ANALYSIS",
+        "10. QUANTITATIVE METRICS",
+        "11. CLINICAL IMPLICATIONS",
+        "12. PROGNOSIS AND SUMMARY"
+    ]
+    
+    combined_parts = []
+    combined_parts.append("COMPREHENSIVE SPEECH SAMPLE ANALYSIS")
+    combined_parts.append("")
+    
+    for section in required_sections:
+        if section in sections_dict:
+            combined_parts.append(section)
+            combined_parts.append("")
+            combined_parts.append(sections_dict[section])
+            combined_parts.append("")
+    
+    return '\n'.join(combined_parts)
+
+def call_claude_api_with_continuation(prompt, max_continuations=0):
+    """Call Claude API with smart continuation system - unlimited continuations until complete"""
+    if not ANTHROPIC_API_KEY:
+        return "❌ Claude API key not configured. Please set ANTHROPIC_API_KEY environment variable."
+    
+    # Define all required sections
+    required_sections = [
+        "1. SPEECH FACTORS",
+        "2. LANGUAGE SKILLS ASSESSMENT", 
+        "3. COMPLEX SENTENCE ANALYSIS",
+        "4. FIGURATIVE LANGUAGE ANALYSIS",
+        "5. PRAGMATIC LANGUAGE ASSESSMENT",
+        "6. VOCABULARY AND SEMANTIC ANALYSIS",
+        "7. MORPHOLOGICAL AND PHONOLOGICAL ANALYSIS",
+        "8. COGNITIVE-LINGUISTIC FACTORS",
+        "9. FLUENCY AND RHYTHM ANALYSIS",
+        "10. QUANTITATIVE METRICS",
+        "11. CLINICAL IMPLICATIONS",
+        "12. PROGNOSIS AND SUMMARY"
+    ]
+    
+    # Safety limits to prevent infinite loops
+    MAX_CONTINUATIONS = 30  # Increased from 20 to 30 API calls
+    MAX_TIME_MINUTES = 15   # Increased from 10 to 15 minutes total
+    MIN_PROGRESS_PER_CALL = 0  # Changed from 1 to 0 to allow more flexibility
+    
+    try:
+        all_sections = {}  # Store all sections found across all parts
+        continuation_count = 0
+        start_time = time.time()
+        last_section_count = 0  # Track progress between calls
+        
+        # Add continuation instruction to original prompt
+        initial_prompt = prompt + "\n\nCRITICAL INSTRUCTIONS: You MUST complete ALL 12 sections of the analysis. If your response is cut off or incomplete, end with <CONTINUE> to indicate more content is needed. Do not skip any sections. Use the checklist to ensure all sections are completed."
+        
+        while True:  # Unlimited continuations until complete
+            if continuation_count == 0:
+                current_prompt = initial_prompt
+            else:
+                # For continuations, provide context about what was already covered
+                missing_sections = [s for s in required_sections if s not in all_sections]
+                missing_text = "\n".join([f"- {section}" for section in missing_sections])
+                
+                current_prompt = prompt + f"\n\nCONTINUATION {continuation_count + 1}: The following sections are STILL MISSING and MUST be completed:\n\n{missing_text}\n\nCRITICAL: Provide ONLY these missing sections. Do not repeat any sections that are already complete. Focus exclusively on the missing sections listed above. Complete ALL missing sections in this response."
+            
+            headers = {
+                "Content-Type": "application/json",
+                "x-api-key": ANTHROPIC_API_KEY,
+                "anthropic-version": "2023-06-01"
+            }
+            
+            data = {
+                "model": "claude-3-5-sonnet-20241022",
+                "max_tokens": 4096,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": current_prompt
+                    }
+                ]
+            }
+            
+            response = requests.post(
+                "https://api.anthropic.com/v1/messages",
+                headers=headers,
+                json=data,
+                timeout=90
+            )
+            
+            if response.status_code == 200:
+                response_json = response.json()
+                response_text = response_json['content'][0]['text']
+                
+                # Log response for debugging
+                print(f"\n=== PART {continuation_count + 1} RESPONSE ===")
+                print(f"Length: {len(response_text)} characters")
+                print(f"Contains CONTINUE: {'<CONTINUE>' in response_text}")
+                print(f"First 200 chars: {response_text[:200]}...")
+                print(f"Last 200 chars: {response_text[-200:]}...")
+                print("=" * 50)
+                
+                # Segment this part and add new sections to our collection
+                part_sections = segment_response_by_sections(response_text)
+                for section, content in part_sections.items():
+                    if section not in all_sections:  # Only add if not already present
+                        all_sections[section] = content
+                        print(f"Added section: {section}")
+                    else:
+                        print(f"Skipped duplicate section: {section}")
+                
+                # Check completion status
+                completed_sections = len(all_sections)
+                missing_sections = [s for s in required_sections if s not in all_sections]
+                
+                print(f"Completed sections: {completed_sections}/12")
+                print(f"Missing sections: {missing_sections}")
+                
+                # Check if response indicates continuation is needed
+                needs_continuation = "<CONTINUE>" in response_text
+                
+                print(f"Needs continuation: {needs_continuation}")
+                print(f"Continuation count: {continuation_count}")
+                
+                # Safety checks to prevent infinite loops
+                current_time = time.time()
+                elapsed_minutes = (current_time - start_time) / 60
+                current_section_count = len(all_sections)
+                progress_made = current_section_count - last_section_count
+                
+                # Check if we're making progress
+                if continuation_count > 0 and progress_made < MIN_PROGRESS_PER_CALL:
+                    # Only stop if we've made multiple calls with no progress
+                    if continuation_count > 3:  # Allow more attempts before giving up
+                        logger.warning(f"No progress made in last call (added {progress_made} sections). Stopping to prevent infinite loop.")
+                        break
+                    else:
+                        logger.info(f"No progress in call {continuation_count}, but continuing to allow more attempts...")
+                
+                # Check time limit
+                if elapsed_minutes > MAX_TIME_MINUTES:
+                    logger.warning(f"Time limit exceeded ({elapsed_minutes:.1f} minutes). Stopping to prevent excessive API usage.")
+                    break
+                
+                # Check continuation limit
+                if continuation_count >= MAX_CONTINUATIONS:
+                    logger.warning(f"Continuation limit reached ({MAX_CONTINUATIONS} calls). Stopping to prevent excessive API usage.")
+                    break
+                
+                # Continue if <CONTINUE> is present and safety checks pass
+                if needs_continuation:
+                    continuation_count += 1
+                    last_section_count = current_section_count
+                    logger.info(f"Continuing analysis (attempt {continuation_count}/{MAX_CONTINUATIONS}, {elapsed_minutes:.1f} minutes elapsed)")
+                    continue
+                else:
+                    break
+            else:
+                logger.error(f"Claude API error: {response.status_code} - {response.text}")
+                return f"❌ Claude API Error: {response.status_code}"
+                
+    except Exception as e:
+        logger.error(f"Error calling Claude API: {str(e)}")
+        return f"❌ Error: {str(e)}"
+    
+    # Combine all sections in the correct order
+    final_response = combine_sections_smartly(all_sections)
+    
+    # Log final results
+    print(f"\n=== FINAL SMART VALIDATION ===")
+    print(f"Total sections found: {len(all_sections)}")
+    print(f"All sections present: {len(all_sections) == 12}")
+    print(f"Missing sections: {[s for s in required_sections if s not in all_sections]}")
+    print(f"Total time: {(time.time() - start_time) / 60:.1f} minutes")
+    print(f"Total API calls: {continuation_count + 1}")
+    print("=" * 50)
+    
+    # Add completion indicator with safety info
+    if continuation_count > 0:
+        final_response += f"\n\n[Analysis completed in {continuation_count + 1} parts over {(time.time() - start_time) / 60:.1f} minutes]"
+    
+    # Add warning if incomplete due to safety limits
+    if len(all_sections) < 12:
+        missing_sections = [s for s in required_sections if s not in all_sections]
+        final_response += f"\n\n⚠️ WARNING: Analysis incomplete due to safety limits. Missing sections: {', '.join(missing_sections)}"
+        final_response += f"\n\n💡 TIP: Try running the analysis again, or use the 'Targeted Analysis' tab to focus on specific areas."
+        final_response += f"\nThe 'Quick Questions' tab may also provide faster results for specific areas of interest."
+    
+    return final_response
+
+def call_claude_api_quick_analysis(prompt):
+    """Call Claude API for quick focused analysis - single response only"""
     if not ANTHROPIC_API_KEY:
         return "❌ Claude API key not configured. Please set ANTHROPIC_API_KEY environment variable."
     
@@ -59,6 +306,259 @@ def call_claude_api(prompt):
         logger.error(f"Error calling Claude API: {str(e)}")
         return f"❌ Error: {str(e)}"
 
+def call_claude_api(prompt):
+    """Call Claude API directly (legacy function for backward compatibility)"""
+    return call_claude_api_quick_analysis(prompt)
+
+def answer_quick_question(transcript_content, question, age, gender, slp_notes):
+    """Answer a specific question about the transcript quickly"""
+    if not transcript_content or len(transcript_content.strip()) < 20:
+        return "Error: Please provide a transcript for analysis."
+    
+    if not question or len(question.strip()) < 5:
+        return "Error: Please provide a specific question."
+    
+    # Add SLP notes to the prompt if provided
+    notes_section = ""
+    if slp_notes and slp_notes.strip():
+        notes_section = f"""
+    
+    SLP CLINICAL NOTES:
+    {slp_notes.strip()}
+    """
+    
+    prompt = f"""
+    You are a speech-language pathologist answering a specific question about a speech sample.
+
+    Patient: {age}-year-old {gender}
+    
+    TRANSCRIPT:
+    {transcript_content}{notes_section}
+    
+    QUESTION: {question}
+    
+    INSTRUCTIONS:
+    - Provide a focused, detailed answer to the specific question asked
+    - Include specific examples from the transcript with exact quotes
+    - Provide quantitative data when relevant (counts, percentages, rates)
+    - Give clinical interpretation and significance
+    - Keep the response focused on the question but thorough in analysis
+    - If the question relates to multiple areas, address all relevant aspects
+    
+    Answer the question with specific evidence from the transcript:
+    """
+    
+    return call_claude_api_quick_analysis(prompt)
+
+def analyze_targeted_area(transcript_content, analysis_area, age, gender, slp_notes):
+    """Perform targeted analysis of a specific area"""
+    if not transcript_content or len(transcript_content.strip()) < 20:
+        return "Error: Please provide a transcript for analysis."
+    
+    # Add SLP notes to the prompt if provided
+    notes_section = ""
+    if slp_notes and slp_notes.strip():
+        notes_section = f"""
+    
+    SLP CLINICAL NOTES:
+    {slp_notes.strip()}
+    """
+    
+    # Define analysis prompts for different areas
+    analysis_prompts = {
+        "Fluency and Disfluencies": """
+        Conduct a comprehensive FLUENCY ANALYSIS focusing on:
+        
+        1. DISFLUENCY TYPES AND COUNTS:
+        - Count and quote ALL filler words ("um", "uh", "like", "you know", etc.)
+        - Count and quote ALL false starts and self-corrections
+        - Count and quote ALL word/phrase repetitions
+        - Count and quote ALL revisions and restarts
+        - Count and quote ALL prolongations or blocks (if noted)
+        
+        2. DISFLUENCY PATTERNS:
+        - Calculate disfluency rate per 100 words
+        - Identify most frequent disfluency types
+        - Analyze clustering patterns
+        - Assess impact on communication effectiveness
+        
+        3. FLUENCY FACILITATORS:
+        - Identify fluent segments and their characteristics
+        - Note any fluency-enhancing contexts
+        - Assess overall speech rhythm and flow
+        
+        4. CLINICAL SIGNIFICANCE:
+        - Compare to age-appropriate norms
+        - Assess severity level
+        - Recommend intervention priorities
+        """,
+        
+        "Grammar and Syntax": """
+        Conduct a comprehensive GRAMMATICAL ANALYSIS focusing on:
+        
+        1. MORPHOLOGICAL ANALYSIS:
+        - Count and categorize ALL grammatical morphemes (plurals, past tense, etc.)
+        - Identify missing obligatory morphemes with specific examples
+        - Analyze morphological error patterns
+        
+        2. SYNTACTIC STRUCTURES:
+        - Analyze sentence types (simple, compound, complex)
+        - Count and quote ALL grammatical errors
+        - Assess word order and sentence construction
+        - Evaluate use of conjunctions and subordination
+        
+        3. VERB USAGE:
+        - Analyze tense consistency and accuracy
+        - Count subject-verb agreement errors
+        - Assess auxiliary verb usage
+        
+        4. CLINICAL IMPLICATIONS:
+        - Identify primary grammatical targets for intervention
+        - Assess developmental appropriateness
+        - Recommend specific therapy goals
+        """,
+        
+        "Vocabulary and Semantics": """
+        Conduct a comprehensive VOCABULARY ANALYSIS focusing on:
+        
+        1. LEXICAL DIVERSITY:
+        - Calculate Type-Token Ratio (TTR)
+        - Identify vocabulary sophistication levels
+        - Count unique vs. repeated words
+        
+        2. SEMANTIC ACCURACY:
+        - Identify and quote ALL semantic errors or inappropriate word choices
+        - Analyze word-finding difficulties and circumlocutions
+        - Assess precision of vocabulary use
+        
+        3. VOCABULARY CATEGORIES:
+        - Categorize vocabulary by semantic fields
+        - Identify high-frequency vs. low-frequency words
+        - Assess academic vs. conversational vocabulary
+        
+        4. WORD RETRIEVAL:
+        - Count and analyze word-finding pauses
+        - Identify compensatory strategies
+        - Assess overall lexical access efficiency
+        
+        5. CLINICAL RECOMMENDATIONS:
+        - Identify vocabulary intervention targets
+        - Recommend strategies for word-finding support
+        """,
+        
+        "Pragmatics and Discourse": """
+        Conduct a comprehensive PRAGMATIC ANALYSIS focusing on:
+        
+        1. DISCOURSE ORGANIZATION:
+        - Analyze topic initiation, maintenance, and transitions
+        - Assess narrative structure and coherence
+        - Evaluate logical sequencing of ideas
+        
+        2. CONVERSATIONAL SKILLS:
+        - Assess turn-taking appropriateness
+        - Analyze response relevance and appropriateness
+        - Evaluate social communication effectiveness
+        
+        3. REFERENTIAL COMMUNICATION:
+        - Count and analyze unclear pronoun references
+        - Assess use of demonstratives ("this," "that")
+        - Evaluate overall referential clarity
+        
+        4. PRAGMATIC APPROPRIATENESS:
+        - Identify any inappropriate content or responses
+        - Assess contextual appropriateness
+        - Evaluate social awareness in communication
+        
+        5. CLINICAL IMPLICATIONS:
+        - Identify pragmatic intervention priorities
+        - Recommend social communication goals
+        """,
+        
+        "Sentence Complexity": """
+        Conduct a comprehensive SENTENCE COMPLEXITY ANALYSIS focusing on:
+        
+        1. SENTENCE TYPES:
+        - Count and categorize simple sentences with examples
+        - Count and categorize compound sentences with examples
+        - Count and categorize complex sentences with examples
+        
+        2. CLAUSE ANALYSIS:
+        - Calculate clauses per utterance
+        - Analyze subordinate clause usage
+        - Assess coordination patterns
+        
+        3. PHRASE STRUCTURES:
+        - Analyze noun phrase complexity
+        - Assess verb phrase elaboration
+        - Evaluate prepositional phrase usage
+        
+        4. SYNTACTIC MATURITY:
+        - Calculate Mean Length of Utterance (MLU)
+        - Assess developmental appropriateness
+        - Identify areas for syntactic growth
+        
+        5. CLINICAL RECOMMENDATIONS:
+        - Identify targets for increasing complexity
+        - Recommend scaffolding strategies
+        """,
+        
+        "Word Finding and Retrieval": """
+        Conduct a comprehensive WORD RETRIEVAL ANALYSIS focusing on:
+        
+        1. WORD-FINDING DIFFICULTIES:
+        - Count and quote ALL instances of word-finding pauses
+        - Identify and quote ALL circumlocutions
+        - Count and quote ALL use of generic terms ("thing," "stuff")
+        
+        2. RETRIEVAL STRATEGIES:
+        - Identify compensatory strategies used
+        - Analyze self-cueing attempts
+        - Assess success rate of retrieval attempts
+        
+        3. ERROR PATTERNS:
+        - Categorize word-finding errors by type
+        - Identify semantic vs. phonological retrieval issues
+        - Analyze error consistency patterns
+        
+        4. CONTEXTUAL FACTORS:
+        - Identify contexts that facilitate vs. hinder retrieval
+        - Assess impact of topic familiarity
+        - Evaluate effect of linguistic complexity on retrieval
+        
+        5. CLINICAL IMPLICATIONS:
+        - Recommend word-finding intervention strategies
+        - Identify cueing hierarchies to trial
+        - Suggest compensatory strategy training
+        """
+    }
+    
+    if analysis_area not in analysis_prompts:
+        return f"Error: Analysis area '{analysis_area}' not recognized. Available areas: {', '.join(analysis_prompts.keys())}"
+    
+    prompt = f"""
+    You are a speech-language pathologist conducting a targeted analysis of a specific area.
+
+    Patient: {age}-year-old {gender}
+    
+    TRANSCRIPT:
+    {transcript_content}{notes_section}
+    
+    ANALYSIS FOCUS: {analysis_area}
+    
+    {analysis_prompts[analysis_area]}
+    
+    INSTRUCTIONS:
+    - Provide specific examples with exact quotes from the transcript
+    - Include quantitative data (counts, percentages, rates per 100 words)
+    - Give detailed clinical interpretation
+    - Provide specific, measurable recommendations
+    - Be thorough but focused on the specified area
+    
+    Conduct the targeted analysis:
+    """
+    
+    return call_claude_api_quick_analysis(prompt)
+
 def check_annotation_completeness(original_transcript, annotated_transcript):
     """Check if annotation is complete by verifying last 3 words are present"""
     import re
@@ -1441,44 +1941,119 @@ with gr.Blocks(title="Speech Analysis", theme=gr.themes.Soft()) as demo:
                     show_copy_button=True
                 )
     
-    with gr.Tab("📊 Analysis Only"):
-        gr.Markdown("### Step 2: Analyze pre-annotated transcript")
+
+    with gr.Tab("❓ Quick Questions"):
+        gr.Markdown("### Ask specific questions about the transcript")
         
         with gr.Row():
             with gr.Column():
-                annotated_input = gr.Textbox(
-                    label="Annotated Transcript",
-                    placeholder="Paste annotated transcript with [MARKERS] here...",
-                    lines=10
+                transcript_input_4 = gr.Textbox(
+                    label="Speech Transcript",
+                    placeholder="Paste the speech transcript here...",
+                    lines=8
+                )
+                
+                question_input = gr.Textbox(
+                    label="Your Question",
+                    placeholder="e.g., How many filler words are used? What grammatical errors are present?",
+                    lines=2
                 )
                 
                 with gr.Row():
-                    age_input_3 = gr.Textbox(label="Age", value="45")
-                    gender_input_3 = gr.Dropdown(
+                    age_input_4 = gr.Textbox(label="Age", value="45")
+                    gender_input_4 = gr.Dropdown(
                         label="Gender",
                         choices=["Male", "Female", "Other"],
                         value="Male"
                     )
                 
-                slp_notes_input_3 = gr.Textbox(
+                slp_notes_input_4 = gr.Textbox(
                     label="SLP Clinical Notes (Optional)",
-                    lines=3
+                    lines=2
                 )
                 
-                example_annotated_btn = gr.Button("📄 Load Example Annotated Transcript", variant="secondary", size="sm")
-                analyze_only_btn = gr.Button("📊 Analyze Annotated Transcript", variant="secondary")
+                # Quick question examples
+                gr.Markdown("**Example Questions:**")
+                with gr.Row():
+                    q1_btn = gr.Button("Count filler words", size="sm", variant="secondary")
+                    q2_btn = gr.Button("Grammar errors?", size="sm", variant="secondary")
+                    q3_btn = gr.Button("Vocabulary level?", size="sm", variant="secondary")
+                
+                with gr.Row():
+                    q4_btn = gr.Button("Sentence complexity?", size="sm", variant="secondary")
+                    q5_btn = gr.Button("Word finding issues?", size="sm", variant="secondary")
+                    q6_btn = gr.Button("Fluency problems?", size="sm", variant="secondary")
+                
+                example_btn_4 = gr.Button("📄 Load Example Transcript", variant="secondary", size="sm")
+                ask_question_btn = gr.Button("❓ Ask Question", variant="primary")
             
             with gr.Column():
-                analysis_only_output = gr.Textbox(
-                    label="Comprehensive Analysis",
-                    lines=20,
+                question_output = gr.Textbox(
+                    label="Answer",
+                    lines=15,
+                    show_copy_button=True
+                )
+    
+    with gr.Tab("🎯 Targeted Analysis"):
+        gr.Markdown("### Focus on specific areas of speech and language")
+        
+        with gr.Row():
+            with gr.Column():
+                transcript_input_5 = gr.Textbox(
+                    label="Speech Transcript",
+                    placeholder="Paste the speech transcript here...",
+                    lines=8
+                )
+                
+                analysis_area = gr.Dropdown(
+                    label="Analysis Focus",
+                    choices=[
+                        "Fluency and Disfluencies",
+                        "Grammar and Syntax", 
+                        "Vocabulary and Semantics",
+                        "Pragmatics and Discourse",
+                        "Sentence Complexity",
+                        "Word Finding and Retrieval"
+                    ],
+                    value="Fluency and Disfluencies"
+                )
+                
+                with gr.Row():
+                    age_input_5 = gr.Textbox(label="Age", value="45")
+                    gender_input_5 = gr.Dropdown(
+                        label="Gender",
+                        choices=["Male", "Female", "Other"],
+                        value="Male"
+                    )
+                
+                slp_notes_input_5 = gr.Textbox(
+                    label="SLP Clinical Notes (Optional)",
+                    lines=2
+                )
+                
+                example_btn_5 = gr.Button("📄 Load Example Transcript", variant="secondary", size="sm")
+                targeted_analysis_btn = gr.Button("🎯 Run Targeted Analysis", variant="primary")
+            
+            with gr.Column():
+                targeted_output = gr.Textbox(
+                    label="Targeted Analysis Results",
+                    lines=15,
                     show_copy_button=True
                 )
     
     # Event handlers - now all components are defined
     example_btn.click(fn=lambda: example_transcript, outputs=[transcript_input])
     example_btn_2.click(fn=lambda: example_transcript, outputs=[transcript_input_2])
-    example_annotated_btn.click(fn=lambda: example_annotated, outputs=[annotated_input])
+    example_btn_4.click(fn=lambda: example_transcript, outputs=[transcript_input_4])
+    example_btn_5.click(fn=lambda: example_transcript, outputs=[transcript_input_5])
+    
+    # Quick question button handlers
+    q1_btn.click(fn=lambda: "How many filler words (um, uh, like, you know) are used in this transcript? Provide exact counts and examples.", outputs=[question_input])
+    q2_btn.click(fn=lambda: "What grammatical errors are present in this transcript? List all errors with specific examples and corrections.", outputs=[question_input])
+    q3_btn.click(fn=lambda: "What is the vocabulary level and sophistication in this transcript? Analyze word choice and complexity.", outputs=[question_input])
+    q4_btn.click(fn=lambda: "How complex are the sentences in this transcript? Analyze sentence types and structures used.", outputs=[question_input])
+    q5_btn.click(fn=lambda: "Are there any word-finding difficulties or retrieval issues? Identify specific examples and patterns.", outputs=[question_input])
+    q6_btn.click(fn=lambda: "What fluency problems or disfluencies are present? Count and categorize all instances.", outputs=[question_input])
     
     file_input.change(
         fn=process_file,
@@ -1702,52 +2277,213 @@ with gr.Blocks(title="Speech Analysis", theme=gr.themes.Soft()) as demo:
         4. Complete ALL 12 sections of the comprehensive analysis
         
         COMPREHENSIVE SPEECH SAMPLE ANALYSIS:
+        
+        CRITICAL: Provide EXTENSIVE detail with ALL possible examples for each category. Quote liberally from the transcript and provide comprehensive breakdowns.
+
+        1. SPEECH FACTORS (with EXHAUSTIVE detail and ALL examples):
+        
+        A. Fluency Issues:
+        - Filler words (total: [count]):
+          * "um" ([count]): "Um, it has two..."
+          * "like" ([count]): "is like looks silver", "like fits people" 
+          * "I don't know" ([count]): "I don't know how to say..."
+          * Other fillers: [list with counts]
+        - False starts/self-corrections ([count]):
+          * "My bike is like looks silver"
+          * [List other examples]
+        - Repetitions ([count]):
+          * Word repetitions: "golf cart(s)" (Xx), "back" (Xx)
+          * [List other patterns]
+
+        B. Word Retrieval Issues:
+        - Circumlocution ([count]):
+          * "this type of fish in it" (for "anchovies")
+          * "where you go golfing and the golf clubs are in back"
+        - Incomplete thoughts ([count]):
+          * "Like I've seen like a I don't know..."
+        - Word-finding pauses ([count]): [brief description]
+        - Generic language ([count]): "thing," "stuff," "something"
+
+        C. Grammatical Errors:
+        - Subject-verb agreement ([count]): "there is another type"
+        - Verb tense errors ([count]): [examples]
+        - Pronoun errors ([count]): [examples]
+        - Run-on sentences ([count]): [examples]
+
+        2. LANGUAGE SKILLS ASSESSMENT (with comprehensive evidence):
+        
+        A. Lexical/Semantic Skills:
+        - Type-Token Ratio: [number] unique words/[number] total words
+        - Vocabulary examples:
+          * Advanced vocabulary: "churrasco," "lo mein," "anchovies"
+          * Transportation terms: "bike," "golf cart," "wheels"
+          * Food terms: "caesar salad," "hummus," "pita bread"
+        - Semantic relationships:
+          * Categories: [examples of categorization]
+          * Part-whole: bike parts, food components
+          * Cause-effect: "pumped up → feels better"
+
+        B. Syntactic Skills:
+        - Sentence types:
+          * Simple sentences: [count]
+          * Compound sentences: [count] 
+          * Complex sentences: [count]
+        - MLU: [number] words, [number] morphemes
+        - Average sentence length: [number] words
+
+        C. Supralinguistic Skills:
+        - Cause-effect relationships ([count]):
+          * "If you do not have a golf cart driving license you can get busted"
+          * "It feels much better now that it's pumped"
+        - Inferences: [count with examples]
+        - Problem-solving language: [count with examples]
+
+        3. COMPLEX SENTENCE ANALYSIS (with ALL examples and counts):
+        
+        A. Coordinating Conjunctions:
+        - "and": [count]
+        - "but": [count] 
+        - "or": [count]
+        - "so": [count]
+        - "because": [count]
+
+        B. Subordinating Conjunctions:
+        - "because": [count]
+        - "when": [count]
+        - "if": [count] 
+        - "that": [count]
+        - "where": [count]
+
+        C. Sentence Structure Analysis:
+        - Average sentence length: [number] words
+        - Sentence complexity: [brief description of patterns]
+
+        4. FIGURATIVE LANGUAGE ANALYSIS (with ALL examples):
+        
+        A. Similes and Metaphors:
+        - Similes ([count]): [examples]
+        - Metaphors ([count]): [examples]
+        - "Like" as filler vs. comparison: [brief analysis]
+
+        B. Idioms and Non-literal Language:
+        - Idioms ([count]): "get busted"
+        - Colloquialisms ([count]): [examples]
+
+        5. PRAGMATIC LANGUAGE ASSESSMENT (with detailed examples):
+        
+        A. Discourse Management:
+        - Topic shifts: [count] - quote ALL transitions:
+          * Bike → Golf carts: Quote exact transition
+          * Golf carts → Food: Quote exact transition
+          * Food → Cookies: Quote exact transition
+        - Topic maintenance analysis:
+          * Golf cart topic: [X utterances] - quote entire sequence
+          * Food topic: [X utterances] - quote entire sequence
+        - Topic elaboration: Count details provided per topic
+
+        B. Referential Communication:
+        - Pronoun reference errors: [count] - quote ALL unclear references
+        - Demonstrative use: [count] - quote ALL "this," "that" uses
+        - Referential clarity: Analyze with specific examples
+
+        6. VOCABULARY AND SEMANTIC ANALYSIS (comprehensive breakdown):
+        
+        A. Vocabulary Diversity:
+        - ALL lexical diversity measures with interpretations:
+          * Simple TTR: [number] - age comparison
+          * MTLD: [number] - clinical interpretation
+          * HDD: [number] - vocabulary range assessment
+          * MATTR: [number] - moving average interpretation
+        - Most frequent words: List top 20 with frequencies
+        - Vocabulary sophistication by domain with examples
+
+        B. Semantic Relationships:
+        - Word associations: Analyze patterns with examples
+        - Semantic categories: List ALL categories used
+        - Synonym/antonym use: Quote ALL instances
+        - Semantic precision: Analyze accuracy with examples
+
+        7. MORPHOLOGICAL AND PHONOLOGICAL ANALYSIS (detailed breakdown):
+        
+        A. Morphological Markers:
+        - Plurals: [count] - list ALL regular and irregular examples
+        - Verb tenses: Break down by type with ALL examples:
+          * Present tense: List 20+ examples
+          * Past tense regular: List ALL examples
+          * Past tense irregular: List ALL examples
+        - Progressive forms: [count] - list ALL "-ing" examples
+        - Possessives: [count] - list ALL examples
+        - Compound words: [count] - list ALL examples
+        - Derivational morphemes: [count] - list ALL prefixes/suffixes
+
+        B. Phonological Patterns:
+        - Articulation accuracy: Note any sound errors
+        - Syllable structure: Analyze complexity with examples
+        - Prosodic patterns: Describe rhythm and stress
+
+        8. COGNITIVE-LINGUISTIC FACTORS (with specific evidence):
+        
+        A. Working Memory:
+        - Longest successful utterance: [word count] - quote entire utterance
+        - Complex information management: Quote examples of multi-part descriptions
+        - Information retention across narrative: Analyze with examples
+
+        B. Processing Speed:
+        - Word-finding efficiency: [count delays] - quote ALL instances
+        - Response fluency: Analyze patterns with examples
+        - Processing load indicators: Identify with examples
+
+        C. Executive Function:
+        - Self-monitoring: [count] - quote ALL self-correction instances
+        - Planning evidence: Analyze organization with examples
+        - Cognitive flexibility: Analyze topic management with examples
+
+        9. FLUENCY AND RHYTHM ANALYSIS (comprehensive measurement):
+        
+        A. Disfluency Patterns:
+        - Total disfluency count: [number] with rate per 100 words
+        - Disfluency types breakdown with ALL examples
+        - Severity assessment compared to age norms
+        - Impact on communication effectiveness
 
-        1. SPEECH FACTORS (with EXACT verified counts and specific citations):
-        A. Fluency Issues: Use the verified counts above, cite specific examples from transcript
-        B. Word Retrieval Issues: Use verified counts, analyze patterns with examples
-        C. Grammatical Errors: Use verified error counts, categorize with examples
-
-        2. LANGUAGE SKILLS ASSESSMENT (with verified evidence):
-        A. Lexical/Semantic Skills: Use verified lexical diversity measures and vocabulary data
-        B. Syntactic Skills: Use verified sentence complexity counts and MLU data
-        C. Supralinguistic Skills: Clinical interpretation with transcript examples
-
-        3. COMPLEX SENTENCE ANALYSIS (with verified counts):
-        A. Coordinating Conjunctions: Count from transcript, use verified sentence data
-        B. Subordinating Conjunctions: Count from transcript, analyze complexity
-        C. Sentence Structure Analysis: Use verified MLU and sentence type data
-
-        4. FIGURATIVE LANGUAGE ANALYSIS (with verified counts):
-        A. Similes and Metaphors: Use verified figurative markers, cite examples
-        B. Idioms and Non-literal Language: Analysis with specific examples
-
-        5. PRAGMATIC LANGUAGE ASSESSMENT (with verified examples):
-        A. Discourse Management: Use verified pragmatic marker counts
-        B. Referential Communication: Use verified pronoun reference data
-
-        6. VOCABULARY AND SEMANTIC ANALYSIS (with verified quantification):
-        A. Vocabulary Diversity: Use ALL verified lexical diversity measures (MTLD, HDD, etc.)
-        B. Semantic Relationships: Use verified word frequency and sophistication data
-
-        7. MORPHOLOGICAL AND PHONOLOGICAL ANALYSIS (with verified counts):
-        A. Morphological Markers: Use verified morphological data and MLU morphemes
-        B. Phonological Patterns: Analysis from transcript evidence
-
-        8. COGNITIVE-LINGUISTIC FACTORS (with verified evidence):
-        A. Working Memory: Use verified sentence length and complexity data
-        B. Processing Efficiency: Use verified fluency and error pattern data
-        C. Executive Function: Use verified self-correction patterns
-
-        9. FLUENCY AND RHYTHM ANALYSIS (with verified quantification):
-        A. Disfluency Patterns: Use verified fluency counts and rates
-        B. Language Flow: Use verified sentence variability data
-
-        10. QUANTITATIVE METRICS (report ALL verified data):
-        Report all the verified statistical values provided above
-
-        11. CLINICAL IMPLICATIONS:
-        Based on verified data, provide clinical interpretation and recommendations
+        B. Language Flow:
+        - Natural pause patterns: [count] - identify ALL appropriate pauses
+        - Disrupted flow instances: [count] - quote ALL with analysis
+        - Rhythm variation: Describe patterns with examples
+
+        10. QUANTITATIVE METRICS (report ALL data with calculations shown):
+        - Total words: [count] (method of counting explained)
+        - Total sentences: [count] (criteria for sentence boundaries)
+        - Unique words: [count] (how uniqueness determined)
+        - MLU words: [calculation] ([total words]/[utterances])
+        - MLU morphemes: [calculation] ([total morphemes]/[utterances])
+        - ALL lexical diversity measures: [list with values and interpretations]
+        - Error rates: [calculations] for each error type
+        - Age-appropriate comparisons for ALL measures
+
+        11. CLINICAL IMPLICATIONS (evidence-based with priorities):
+        
+        A. Strengths (ranked with evidence):
+        1. [Primary strength] - specific evidence with quotes and data
+        2. [Secondary strength] - specific evidence with quotes and data
+        3. [Continue ranking ALL strengths with supporting evidence]
+
+        B. Areas of Need (prioritized by severity):
+        1. [Highest priority] - severity data, impact analysis, examples
+        2. [Second priority] - severity data, impact analysis, examples
+        3. [Continue with ALL areas needing intervention]
+
+        C. Treatment Recommendations (specific and measurable):
+        1. [Primary goal] - specific techniques, frequency, duration, success criteria
+        2. [Secondary goal] - specific techniques, frequency, duration, success criteria
+        3. [Continue with ALL treatment recommendations]
+
+        12. PROGNOSIS AND SUMMARY (comprehensive profile):
+        - Overall severity rating: [level] with detailed justification
+        - Developmental appropriateness: Compare ALL skills to age expectations
+        - Functional communication impact: Real-world implications
+        - Prognosis: Specific predictions with timelines and success indicators
+        - Monitoring plan: Specific measures and reassessment schedule
 
         12. PROGNOSIS AND SUMMARY:
         Overall profile based on comprehensive verified data
@@ -1810,25 +2546,20 @@ with gr.Blocks(title="Speech Analysis", theme=gr.themes.Soft()) as demo:
         outputs=[annotation_output]
     )
     
-    def analyze_standalone(annotated_transcript, age, gender, slp_notes):
-        """Analyze standalone annotated transcript"""
-        # Extract original transcript by removing markers
-        original_transcript = annotated_transcript
-        for marker in ['[FILLER]', '[FALSE_START]', '[REPETITION]', '[REVISION]', '[PAUSE]', 
-                      '[CIRCUMLOCUTION]', '[INCOMPLETE]', '[GENERIC]', '[WORD_SEARCH]', 
-                      '[GRAM_ERROR]', '[SYNTAX_ERROR]', '[MORPH_ERROR]', '[RUN_ON]', 
-                      '[SIMPLE_VOCAB]', '[COMPLEX_VOCAB]', '[SEMANTIC_ERROR]', 
-                      '[TOPIC_SHIFT]', '[TANGENT]', '[INAPPROPRIATE]', '[COHERENCE_BREAK]', 
-                      '[SIMPLE_SENT]', '[COMPLEX_SENT]', '[COMPOUND_SENT]', '[FIGURATIVE]', 
-                      '[PRONOUN_REF]', '[MAZING]', '[PERSEVERATION]']:
-            original_transcript = original_transcript.replace(marker, '')
-        
-        return analyze_with_backup(annotated_transcript, original_transcript, age, gender, slp_notes)
-    
-    analyze_only_btn.click(
-        fn=analyze_standalone,
-        inputs=[annotated_input, age_input_3, gender_input_3, slp_notes_input_3],
-        outputs=[analysis_only_output]
+
+    
+    # Quick Questions event handler
+    ask_question_btn.click(
+        fn=answer_quick_question,
+        inputs=[transcript_input_4, question_input, age_input_4, gender_input_4, slp_notes_input_4],
+        outputs=[question_output]
+    )
+    
+    # Targeted Analysis event handler
+    targeted_analysis_btn.click(
+        fn=analyze_targeted_area,
+        inputs=[transcript_input_5, analysis_area, age_input_5, gender_input_5, slp_notes_input_5],
+        outputs=[targeted_output]
     )
 
 if __name__ == "__main__":