AI Meeting Assistant

Overview

This workflow automates the entire meeting lifecycle: transcription, summarization, action item extraction, and follow-up. It transforms raw meeting audio into actionable insights and organized records.

Difficulty

Easy - Can be set up with existing tools and APIs.

Tools Required

• OpenAI Whisper: High-accuracy speech-to-text transcription
• Claude / GPT-4: Meeting summarization and action item extraction
• Zoom API: Meeting recording access
• Google Calendar: Meeting scheduling and follow-up events
• Notion: Meeting notes storage and sharing

Workflow Steps

Step 1: Transcriber Agent

Converts meeting audio to text with speaker identification.

import whisper
from datetime import datetime

def transcribe_meeting(audio_path: str) -> dict:
    """
    Transcribe meeting audio with speaker diarization.
    
    Args:
        audio_path: Path to meeting recording
        
    Returns:
        Transcription with timestamps and speaker labels
    """
    model = whisper.load_model("large-v3")
    result = model.transcribe(audio_path, word_timestamps=True)
    
    # Speaker diarization (separate step)
    segments = add_speaker_labels(result["segments"])
    
    return {
        "text": result["text"],
        "segments": segments,
        "duration": result.get("duration", 0),
        "transcribed_at": datetime.utcnow().isoformat()
    }

# Example output
"""
[00:00 - 00:15] Speaker 1: Good morning everyone, let's start with the project update.
[00:15 - 00:45] Speaker 2: We've completed the authentication module and are now working on the dashboard.
[00:45 - 01:20] Speaker 1: Great progress. What about the timeline for the API integration?
"""

Step 2: Summarizer Agent

Creates a structured meeting summary.

def summarize_meeting(transcription: dict) -> dict:
    """
    Generate meeting summary from transcription.
    
    Returns:
        Structured summary with key points
    """
    prompt = f"""
    Summarize the following meeting transcript:
    
    {transcription['text']}
    
    Provide:
    1. Meeting title and date
    2. Attendees
    3. Key discussion points (bullet list)
    4. Decisions made
    5. Topics deferred to future meetings
    6. Overall sentiment (positive/neutral/concerned)
    """
    
    # Call Claude API
    summary = call_claude(prompt)
    
    return parse_summary(summary)

Step 3: Action Agent

Extracts action items with owners and deadlines.

def extract_action_items(transcription: dict) -> list:
    """
    Extract action items from meeting transcript.
    
    Returns:
        List of action items with owner, description, deadline
    """
    prompt = f"""
    Extract all action items from this meeting transcript:
    
    {transcription['text']}
    
    For each action item, identify:
    - Description (what needs to be done)
    - Owner (who is responsible)
    - Deadline (if mentioned)
    - Priority (high/medium/low)
    
    Format as JSON array.
    """
    
    action_items = call_claude(prompt)
    
    return [
        {
            "description": item["description"],
            "owner": item["owner"],
            "deadline": item.get("deadline"),
            "priority": item.get("priority", "medium"),
            "status": "open"
        }
        for item in action_items
    ]

# Example output
"""
[
  {
    "description": "Complete API integration for user dashboard",
    "owner": "Sarah Chen",
    "deadline": "2025-06-15",
    "priority": "high",
    "status": "open"
  },
  {
    "description": "Schedule follow-up meeting with design team",
    "owner": "Mike Johnson",
    "deadline": "2025-06-10",
    "priority": "medium",
    "status": "open"
  }
]
"""

Step 4: Scheduler Agent

Creates follow-up calendar events.

from googleapiclient.discovery import build
from datetime import datetime, timedelta

def create_followup_events(action_items: list, meeting_time: datetime) -> list:
    """
    Create calendar events for action item deadlines.
    
    Args:
        action_items: List of extracted action items
        meeting_time: Original meeting time
        
    Returns:
        Created calendar events
    """
    service = build('calendar', 'v3', credentials=credentials)
    
    events = []
    for item in action_items:
        if item.get("deadline"):
            deadline = datetime.strptime(item["deadline"], "%Y-%m-%d")
            
            event = {
                'summary': f"Follow-up: {item['description']}",
                'description': f"Action item from meeting on {meeting_time.date()}\nOwner: {item['owner']}",
                'start': {'date': item['deadline']},
                'end': {'date': item['deadline']},
                'reminders': {'useDefault': False, 'overrides': [{'method': 'email', 'minutes': 1440}]}
            }
            
            created = service.events().insert(calendarId='primary', body=event).execute()
            events.append(created)
    
    return events

Step 5: Notifier Agent

Sends meeting summary to participants.

def send_meeting_summary(meeting: dict, summary: dict, action_items: list):
    """
    Send meeting summary to all participants via email or Slack.
    """
    email_body = f"""
    Meeting Summary: {meeting['title']}
    Date: {meeting['date']}
    
    ## Key Points
    {format_bullet_list(summary['key_points'])}
    
    ## Decisions Made
    {format_bullet_list(summary['decisions'])}
    
    ## Action Items
    {format_action_items(action_items)}
    
    ---
    Full transcript and recording: {meeting['recording_url']}
    """
    
    # Send via email or Slack
    send_email(
        to=meeting['attendees'],
        subject=f"Meeting Summary: {meeting['title']}",
        body=email_body
    )

Example Usage

# 1. Upload meeting recording
Meeting recording uploaded to workflow

# 2. Automatic processing
Transcription: 5 minutes (Whisper)
Summary generation: 30 seconds (Claude)
Action extraction: 20 seconds (Claude)

# 3. Output delivered
- Meeting notes saved to Notion
- Action items added to task tracker
- Calendar events created for deadlines
- Summary email sent to 8 participants

Pros

• ✅ Saves hours of manual note-taking
• ✅ Captures action items automatically
• ✅ Creates follow-up reminders
• ✅ Searchable meeting archive
• ✅ Works with any meeting platform

Cons

• ❌ Transcription accuracy varies with audio quality
• ❌ Speaker identification may be imperfect
• ❌ Requires API credits for transcription and summarization
• ❌ Privacy considerations for sensitive meetings

When to Use

Use this workflow when:

• You have regular team meetings with many participants
• You need to track action items across meetings
• You want searchable meeting archives
• You're managing remote teams across time zones

Consider alternatives when:

• Meetings are very short (< 10 minutes)
• Audio quality is poor (phone calls, background noise)
• Meeting content is highly confidential

Resources

• OpenAI Whisper
• Zoom API
• Google Calendar API
• Notion API