🔍 Code Extractor

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

Purpose

This endpoint allows users to regenerate meeting minutes from an existing session with different AI model settings, custom instructions, rigor levels, and detail preferences. It loads the original transcript and PowerPoint data from a saved session, applies new generation parameters, validates the output for potential truncation issues, and saves the regenerated minutes as a new session while preserving the original data.

Source Code

def regenerate_minutes():
    """Regenerate meeting minutes with modified instructions"""
    try:
        session_id = request.form.get('session_id')
        new_instructions = request.form.get('new_instructions', '')
        new_model = request.form.get('new_model', 'gpt-4o')
        
        # Get new configuration options (use defaults if not provided)
        new_rigor_level = request.form.get('new_rigor_level', 'balanced')
        new_detail_level = request.form.get('new_detail_level', 'comprehensive')
        
        # Load session data
        session_file = REPORTS_FOLDER / f"session_{session_id}.json"
        if not session_file.exists():
            return jsonify({'error': 'Session not found'}), 404
        
        with open(session_file, 'r') as f:
            session_data = json.load(f)
        
        # Initialize generator with new model
        generator = EnhancedMeetingMinutesGenerator(model=new_model)
        
        # Load original data
        with open(session_data['transcript_path'], 'r', encoding='utf-8') as f:
            transcript = f.read()
        
        # Process PowerPoint if available
        ppt_content = None
        if session_data['powerpoint_path']:
            ppt_content = generator.process_powerpoint_content(session_data['powerpoint_path'])
        
        # Extract previous reports summary if available
        previous_reports_summary = ""
        if session_data['previous_reports']:
            previous_reports_summary = extract_previous_reports_summary(session_data['previous_reports'])
        
        # Generate with new instructions and configuration
        minutes = generator.generate_meeting_minutes_with_config(
            transcript=transcript,
            ppt_content=ppt_content,
            meeting_title=session_data['meeting_title'],
            previous_reports_summary=previous_reports_summary,
            user_instructions=new_instructions,
            rigor_level=new_rigor_level,
            detail_level=new_detail_level,
            action_focus=session_data.get('action_focus', 'standard'),
            output_style=session_data.get('output_style', 'professional')
        )
        
        # Check for potential truncation issues  
        validation_notes = []
        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):
                validation_notes.append(f"⚠️ WARNING: Agenda lists {len(agenda_items)} items but only {len(discussion_items)} discussion sections generated.")
                validation_notes.append("This may indicate output truncation due to token limits. Consider regenerating or breaking into smaller sections.")
        
        # Add validation warnings to the output if needed
        if validation_notes:
            minutes += "\n\n## Generation Validation Warnings\n"
            for note in validation_notes:
                minutes += f"- {note}\n"
        
        # Save new report
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        report_filename = f"meeting_minutes_{timestamp}_regenerated.md"
        report_path = REPORTS_FOLDER / report_filename
        
        with open(report_path, 'w', encoding='utf-8') as f:
            f.write(minutes)
        
        # Convert to HTML
        html_content = markdown.markdown(minutes, extensions=['tables', 'fenced_code'])
        
        # Update session data
        session_data['user_instructions'] = new_instructions
        session_data['model'] = new_model
        session_data['report_path'] = str(report_path)
        
        new_session_id = timestamp
        new_session_file = REPORTS_FOLDER / f"session_{new_session_id}.json"
        with open(new_session_file, 'w') as f:
            json.dump(session_data, f)
        
        return jsonify({
            'success': True,
            'html_content': html_content,
            'markdown_content': minutes,
            'report_path': str(report_path),
            'session_id': new_session_id
        })
    
    except Exception as e:
        logger.error(f"Error regenerating minutes: {str(e)}")
        return jsonify({'error': f'Error regenerating minutes: {str(e)}'}), 500

Return Value

Returns a Flask JSON response. On success (200): {'success': True, 'html_content': string (HTML-formatted minutes), 'markdown_content': string (raw markdown), 'report_path': string (file path to saved report), 'session_id': string (new session identifier)}. On error (404 if session not found, 500 for other errors): {'error': string (error message)}.

Dependencies

• flask
• markdown
• logging
• pathlib
• datetime
• json
• openai

Required Imports

from flask import request, jsonify
import markdown
import json
from datetime import datetime
from pathlib import Path
import logging

Conditional/Optional Imports

These imports are only needed under specific conditions:

from enhanced_meeting_minutes_generator import EnhancedMeetingMinutesGenerator

from document_extractor import DocumentExtractor

Usage Example

# Example POST request to regenerate minutes
import requests

# Assuming Flask app is running on localhost:5000
response = requests.post(
    'http://localhost:5000/regenerate',
    data={
        'session_id': '20240115_143022',
        'new_instructions': 'Focus on action items and decisions made',
        'new_model': 'gpt-4o',
        'new_rigor_level': 'thorough',
        'new_detail_level': 'comprehensive'
    }
)

if response.status_code == 200:
    result = response.json()
    print(f"Success! New session ID: {result['session_id']}")
    print(f"Report saved to: {result['report_path']}")
    # Access HTML content: result['html_content']
    # Access markdown: result['markdown_content']
else:
    print(f"Error: {response.json()['error']}")

Best Practices

• Ensure REPORTS_FOLDER directory exists and has write permissions before calling this endpoint
• Session files must be valid JSON with all required fields (transcript_path, powerpoint_path, meeting_title, etc.)
• The function validates output for truncation by comparing agenda items to discussion sections - monitor validation warnings in the output
• Each regeneration creates a new session file to preserve history - implement cleanup strategy for old sessions
• Handle 404 errors when session_id doesn't exist and 500 errors for generation failures
• The function uses UTF-8 encoding for file operations - ensure transcript files are UTF-8 encoded
• Consider implementing rate limiting as this endpoint makes OpenAI API calls which can be expensive
• The markdown to HTML conversion uses 'tables' and 'fenced_code' extensions - ensure markdown library supports these
• Validation warnings are appended to the generated minutes - parse these separately if needed for UI display

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• function generate_minutes 81.4% 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

• function handle_potential_truncation 65.4% similar

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

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

• class MeetingMinutesGenerator 64.2% 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

• class MeetingMinutesGenerator_v1 62.9% 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 test_web_ui 62.2% similar

  Integration test function that validates a Flask web UI for meeting minutes generation by testing file upload, generation, and regeneration endpoints with sample transcript and PowerPoint files.

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