🔍 Code Extractor

Command-line interface function that orchestrates the generation of meeting minutes from a transcript file using either GPT-4o or Gemini LLM models.

Purpose

This is the main entry point for a CLI application that processes meeting transcripts and generates structured meeting minutes. It handles argument parsing, API key validation, model initialization, transcript loading, minutes generation, and output saving. The function supports multiple LLM backends (OpenAI GPT-4o and Google Gemini) and provides automatic output path generation with timestamps.

Source Code

def main():
    """Main function to process transcript and generate meeting minutes."""
    
    parser = argparse.ArgumentParser(description='Generate meeting minutes from transcript using LLM')
    parser.add_argument('--model', choices=['gpt-4o', 'gemini'], default='gpt-4o',
                        help='LLM model to use (default: gpt-4o)')
    parser.add_argument('--input', type=str, 
                        default='/tf/active/leexi/leexi-20250618-transcript-development_team_meeting.md',
                        help='Path to transcript file')
    parser.add_argument('--output', type=str,
                        help='Output path for meeting minutes (auto-generated if not specified)')
    parser.add_argument('--title', type=str, 
                        default='Development Team Meeting',
                        help='Meeting title for the minutes')
    
    args = parser.parse_args()
    
    # Auto-generate output path if not specified
    if not args.output:
        timestamp = datetime.now().strftime('%Y-%m-%d')
        model_suffix = args.model.replace('-', '_')
        args.output = f"/tf/active/meeting_minutes_{timestamp}_{model_suffix}.md"
    
    # Check API keys
    if args.model == 'gpt-4o':
        api_key = os.getenv('OPENAI_API_KEY')
        if not api_key:
            print("Error: OPENAI_API_KEY environment variable not set")
            print("Please set your OpenAI API key:")
            print("export OPENAI_API_KEY='your-api-key-here'")
            return
    elif args.model == 'gemini':
        api_key = os.getenv('GEMINI_API_KEY')
        if not api_key:
            print("Error: GEMINI_API_KEY environment variable not set") 
            print("Please set your Gemini API key:")
            print("export GEMINI_API_KEY='your-api-key-here'")
            return
    
    try:
        # Initialize generator
        print(f"Initializing {args.model.upper()} generator...")
        generator = MeetingMinutesGenerator(model=args.model)
        
        # Load transcript
        print(f"Loading transcript from: {args.input}")
        transcript = generator.load_transcript(args.input)
        
        # Generate meeting minutes
        print(f"Generating meeting minutes using {args.model.upper()}...")
        minutes = generator.generate_meeting_minutes(transcript, args.title)
        
        # Save results
        generator.save_minutes(minutes, args.output)
        
        print("✅ Meeting minutes generation completed successfully!")
        print(f"📄 Output saved to: {args.output}")
        
        # Print a preview
        print("\n" + "="*50)
        print("PREVIEW OF GENERATED MINUTES:")
        print("="*50)
        print(minutes[:1000] + "..." if len(minutes) > 1000 else minutes)
        
    except Exception as e:
        print(f"❌ Error: {e}")

Return Value

Returns None. The function performs side effects including printing status messages to stdout, saving generated meeting minutes to a file, and potentially exiting early if API keys are missing.

Dependencies

• argparse
• os
• datetime
• openai
• google-generativeai

Required Imports

import argparse
import os
from datetime import datetime
import openai
import google.generativeai as genai

Conditional/Optional Imports

These imports are only needed under specific conditions:

import openai

import google.generativeai as genai

Usage Example

# Basic usage with default GPT-4o model
export OPENAI_API_KEY='sk-your-api-key-here'
python script.py

# Using Gemini model with custom input and output
export GEMINI_API_KEY='your-gemini-api-key'
python script.py --model gemini --input /path/to/transcript.md --output /path/to/output.md --title 'Weekly Standup'

# Using GPT-4o with custom title
export OPENAI_API_KEY='sk-your-api-key-here'
python script.py --model gpt-4o --title 'Q4 Planning Meeting' --input meeting_transcript.md

Best Practices

• Always set the appropriate API key environment variable before running (OPENAI_API_KEY or GEMINI_API_KEY)
• Ensure the MeetingMinutesGenerator class is properly defined with methods: __init__(model), load_transcript(path), generate_meeting_minutes(transcript, title), and save_minutes(minutes, path)
• Verify that input transcript files exist and are readable before execution
• The function expects specific directory paths (/tf/active/) - adjust default paths for different environments
• Handle exceptions appropriately as the function catches all exceptions and prints error messages
• The output path is auto-generated with timestamp if not specified, preventing accidental overwrites
• The function prints a preview of the first 1000 characters - consider this when dealing with sensitive information
• This function is designed to be called as the main entry point: if __name__ == '__main__': main()

Tags

Similar Components

AI-powered semantic similarity - components with related functionality:

• function main_v3 90.2% similar

  Command-line interface function that orchestrates the generation of enhanced meeting minutes from transcript files and PowerPoint presentations using various LLM models (GPT-4o, Azure GPT-4o, or Gemini).

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

• function main_v15 83.3% 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

• class MeetingMinutesGenerator_v1 80.2% 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

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