🔍 Code Extractor

Detects and handles truncated meeting minutes by comparing agenda items to discussion sections, then attempts regeneration with enhanced instructions to ensure completeness.

Purpose

This function addresses a common issue in AI-generated meeting minutes where the output may be truncated before all agenda items are fully discussed. It analyzes the structure of generated minutes, detects when discussion sections are missing for agenda items, and automatically triggers a regeneration with explicit instructions to complete all sections. This ensures comprehensive meeting documentation without manual intervention.

Source Code

def handle_potential_truncation(generator, minutes, **generation_kwargs):
    """Handle potential truncation by attempting regeneration with completion enforcement"""
    
    # Check if truncation occurred
    if "## Meeting Agenda" in minutes and "## Meeting Discussion by Agenda Item" in minutes:
        agenda_section = minutes.split("## Meeting Agenda")[1].split("##")[0]
        agenda_items = [line.strip() for line in agenda_section.split('\n') if line.strip() and any(line.strip().startswith(f'{i}.') for i in range(1, 10))]
        
        discussion_section = minutes.split("## Meeting Discussion by Agenda Item")[1].split("## Action Items")[0] if "## Action Items" in minutes else minutes.split("## Meeting Discussion by Agenda Item")[1]
        discussion_items = [line.strip() for line in discussion_section.split('\n') if line.strip().startswith('###')]
        
        if len(agenda_items) > len(discussion_items) and len(agenda_items) >= 3:
            logger.warning(f"Detected truncation: {len(agenda_items)} agenda items vs {len(discussion_items)} discussion sections")
            
            # Try regeneration with explicit completion instruction
            completion_instruction = f"CRITICAL: You identified {len(agenda_items)} agenda items. You MUST provide detailed discussion sections for ALL {len(agenda_items)} agenda items. Do not stop until every agenda item has a complete discussion section with Summary, Key Points, and Decisions Made."
            
            # Append to existing user instructions
            original_instructions = generation_kwargs.get('user_instructions', '')
            enhanced_instructions = f"{original_instructions}\n\n{completion_instruction}" if original_instructions else completion_instruction
            
            try:
                logger.info("Attempting regeneration with completion enforcement...")
                regenerated_minutes = generator.generate_meeting_minutes_with_config(
                    **{**generation_kwargs, 'user_instructions': enhanced_instructions}
                )
                
                # Check if regeneration was successful
                if "## Meeting Discussion by Agenda Item" in regenerated_minutes:
                    regen_discussion_section = regenerated_minutes.split("## Meeting Discussion by Agenda Item")[1].split("## Action Items")[0] if "## Action Items" in regenerated_minutes else regenerated_minutes.split("## Meeting Discussion by Agenda Item")[1]
                    regen_discussion_items = [line.strip() for line in regen_discussion_section.split('\n') if line.strip().startswith('###')]
                    
                    if len(regen_discussion_items) > len(discussion_items):
                        logger.info(f"Regeneration successful: {len(regen_discussion_items)} discussion sections")
                        regenerated_minutes += f"\n\n## Regeneration Note\nThis output was automatically regenerated to ensure completeness. Original generation covered {len(discussion_items)}/{len(agenda_items)} agenda items. Regenerated version covers {len(regen_discussion_items)}/{len(agenda_items)} agenda items."
                        return regenerated_minutes
                    
            except Exception as regen_error:
                logger.error(f"Regeneration failed: {str(regen_error)}")
    
    return minutes

Parameters

Parameter Details

generator: An instance of EnhancedMeetingMinutesGenerator (or compatible class) that has a generate_meeting_minutes_with_config method. This object is used to regenerate the minutes if truncation is detected.

minutes: A string containing the generated meeting minutes in markdown format. Expected to have sections like '## Meeting Agenda' and '## Meeting Discussion by Agenda Item'. This is the content to be analyzed for potential truncation.

**generation_kwargs: Keyword arguments dictionary that will be passed to the generator's generate_meeting_minutes_with_config method during regeneration. Should include parameters like 'user_instructions' and any other configuration needed for generation (e.g., transcript, model settings, temperature).

Return Value

Returns a string containing the meeting minutes. If truncation is detected and regeneration is successful, returns the regenerated minutes with an appended '## Regeneration Note' section explaining the improvement. If no truncation is detected or regeneration fails, returns the original 'minutes' parameter unchanged.

Dependencies

• logging

Required Imports

import logging

Usage Example

import logging
from enhanced_meeting_minutes_generator import EnhancedMeetingMinutesGenerator

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

generator = EnhancedMeetingMinutesGenerator(api_key='your-api-key')

initial_minutes = '''## Meeting Agenda
1. Budget Review
2. Project Timeline
3. Resource Allocation

## Meeting Discussion by Agenda Item
### 1. Budget Review
Summary: Discussed Q4 budget...
'''

generation_kwargs = {
    'transcript': 'meeting transcript text...',
    'user_instructions': 'Generate detailed minutes',
    'model': 'gpt-4'
}

final_minutes = handle_potential_truncation(generator, initial_minutes, **generation_kwargs)
print(final_minutes)

Best Practices

• Ensure the logger is properly configured before calling this function to capture warning and error messages
• The generator object must be fully initialized and ready to generate minutes before passing to this function
• The generation_kwargs should include all necessary parameters for a complete regeneration attempt
• This function assumes a specific markdown structure; ensure your minutes follow the expected format with '## Meeting Agenda' and '## Meeting Discussion by Agenda Item' headers
• The function only attempts regeneration once; for critical applications, consider wrapping this in additional retry logic
• Monitor the regeneration note in the output to track when automatic corrections occur
• The truncation detection threshold is set at 3 agenda items minimum; adjust the logic if working with smaller meetings
• Handle exceptions from the generator gracefully as regeneration failures return the original minutes

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• function regenerate_minutes 65.4% similar

  Flask route handler that regenerates meeting minutes from a previous session using modified instructions, model selection, and configuration parameters.

  From: /tf/active/vicechatdev/leexi/app.py

• class MeetingMinutesGenerator 61.6% similar

  A class that generates professional meeting minutes from meeting transcripts using OpenAI's GPT-4o model, with capabilities to parse metadata, extract action items, and format output.

  From: /tf/active/vicechatdev/meeting_minutes_generator.py

• function generate_minutes 61.0% similar

  Flask route handler that processes uploaded meeting transcripts and optional supporting documents to generate structured meeting minutes using AI, with configurable output styles and validation.

  From: /tf/active/vicechatdev/leexi/app.py

• class MeetingMinutesGenerator_v1 60.6% similar

  A class that generates professional meeting minutes from meeting transcripts using either OpenAI's GPT-4o or Google's Gemini AI models.

  From: /tf/active/vicechatdev/advanced_meeting_minutes_generator.py

• function main_v15 59.1% similar

  Entry point function that orchestrates the process of loading a meeting transcript, generating structured meeting minutes using OpenAI's GPT-4o API, and saving the output to a file.

  From: /tf/active/vicechatdev/meeting_minutes_generator.py