Turn Any Meeting Into Action Items, Summaries, and Follow-Up Emails — Automatically

After every meeting you need to: remember what was decided, figure out who owns what, and send a recap to everyone. Most people do this manually. It takes 20–40 minutes. And if you skip it, half the action items evaporate. This guide sets up an AI pipeline that does all three — in about 90 seconds.

What You'll Have When You're Done

What You Need Before You Start

• An OpenAI API key — get one at platform.openai.com. You'll spend about $0.01–0.05 per meeting.
• Python 3.9+ installed. Type python3 --version in your terminal to check. If you're on a Mac, you almost certainly have it.
• A way to get your meeting transcript. More on that in a moment.

Step 1: Install the One Dependency

Open your terminal and run:

pip install openai

That's it. One package. Takes about 10 seconds.

Step 2: Create the Script

Create a file called meeting_processor.py anywhere on your computer. Paste in this script:

import openai
import sys
import os
from pathlib import Path

# Put your OpenAI API key here, or set it as an environment variable
# export OPENAI_API_KEY="sk-..."
client = openai.OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

SYSTEM_PROMPT = """You are an expert at processing meeting notes.
Given a meeting transcript or notes, you produce three things:

1. SUMMARY — 3 to 5 bullet points covering the key decisions and context.
   Be concise. A busy person should understand what happened in 30 seconds.

2. ACTION ITEMS — A numbered list of every task that came up.
   Format each one as: [PERSON RESPONSIBLE] — [TASK] — [DEADLINE if mentioned, else "No deadline set"]
   If the person responsible isn't clear, write "Owner: TBD"

3. FOLLOW-UP EMAIL — A ready-to-send email with:
   - Subject line
   - Opening line (e.g. "Hi team, here's a recap of today's meeting:")
   - The summary as bullet points
   - The action items
   - A friendly closing line

Use plain, professional English. No jargon. No filler phrases like
"Great meeting everyone!" — just useful information.

Format your response EXACTLY like this:

## SUMMARY
[bullet points here]

## ACTION ITEMS
[numbered list here]

## FOLLOW-UP EMAIL
Subject: [subject line]

[email body here]
"""

def process_meeting(transcript: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": f"Here are the meeting notes:\n\n{transcript}"}
        ],
        temperature=0.3,  # Low temp = consistent, reliable output
        max_tokens=1500
    )
    return response.choices[0].message.content

def main():
    # Usage: python meeting_processor.py meeting_notes.txt
    # Or:    python meeting_processor.py  (then paste notes, press Ctrl+D when done)
    
    if len(sys.argv) > 1:
        # Read from file
        file_path = Path(sys.argv[1])
        if not file_path.exists():
            print(f"Error: File '{file_path}' not found.")
            sys.exit(1)
        transcript = file_path.read_text(encoding="utf-8")
        print(f"Processing: {file_path.name}\n")
    else:
        # Read from stdin (paste your notes)
        print("Paste your meeting notes below. Press Ctrl+D (Mac/Linux) or Ctrl+Z (Windows) when done:\n")
        transcript = sys.stdin.read()
    
    if not transcript.strip():
        print("Error: No meeting notes provided.")
        sys.exit(1)
    
    print("Processing...\n")
    result = process_meeting(transcript)
    print(result)
    
    # Optionally save to a file
    output_path = Path("meeting_output.md")
    output_path.write_text(result, encoding="utf-8")
    print(f"\n---\nSaved to: {output_path.resolve()}")

if __name__ == "__main__":
    main()

Step 3: Set Your API Key

In your terminal, run:

export OPENAI_API_KEY="sk-your-key-here"

To make this permanent so you don't have to run it every time, add that line to your ~/.zshrc (on Mac) or ~/.bashrc (on Linux). Then run source ~/.zshrc.

Step 4: Run It on Your First Meeting

If you have a transcript saved as a file:

python3 meeting_processor.py my_meeting.txt

Or paste notes directly:

python3 meeting_processor.py

Then paste your notes and press Ctrl+D.

The output appears in your terminal and is also saved to meeting_output.md in the same folder.

What the Output Looks Like

Here's a real example. Input was a rough 45-minute client call transcript (Zoom auto-transcript, no editing).

Total processing time: 8 seconds. API cost: $0.02.

Upgrading to gpt-4o for Complex Meetings

The script uses gpt-4o-mini by default, which handles 95% of meetings perfectly. For very long meetings (2+ hours) or complex technical discussions where accuracy really matters, change one line:

# Change this:
model="gpt-4o-mini",

# To this:
model="gpt-4o",

Cost goes from ~$0.02 to ~$0.15 per meeting. Still pennies. For a weekly all-hands or important client call, worth it.

Making It Even Faster: The One-Command Alias

If you run this daily, add an alias to your terminal config so you can type meeting instead of the full command.

Add this to your ~/.zshrc or ~/.bashrc:

alias meeting='python3 /path/to/your/meeting_processor.py'

Replace /path/to/your/ with the actual folder where you saved the script. Then source ~/.zshrc.

Now your workflow is: get transcript, run meeting transcript.txt, copy the email, paste, send.

Connecting It to Zoom Automatically

If you record every Zoom meeting to your local computer, you can set up a folder-watcher that processes new transcript files the moment Zoom saves them. Here's the setup:

pip install watchdog

# watch_meetings.py
import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import subprocess
import os

ZOOM_TRANSCRIPT_FOLDER = os.path.expanduser("~/Documents/Zoom")

class TranscriptHandler(FileSystemEventHandler):
    def on_created(self, event):
        if event.src_path.endswith(".vtt") or event.src_path.endswith(".txt"):
            if "transcript" in event.src_path.lower():
                print(f"New transcript detected: {event.src_path}")
                subprocess.run([
                    "python3",
                    "/path/to/your/meeting_processor.py",
                    event.src_path
                ])

if __name__ == "__main__":
    observer = Observer()
    observer.schedule(TranscriptHandler(), ZOOM_TRANSCRIPT_FOLDER, recursive=True)
    observer.start()
    print(f"Watching {ZOOM_TRANSCRIPT_FOLDER} for new transcripts...")
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

Run python3 watch_meetings.py in the background before your day starts. Every time Zoom saves a transcript, it's automatically processed. The output lands in meeting_output.md — or modify the script to save each one with a timestamp.

Four Things That Trip People Up

The Cost Breakdown

Here's what this actually costs per month at different meeting volumes:

• 5 meetings/week: ~$0.50/month with gpt-4o-mini, ~$3.75/month with gpt-4o
• 15 meetings/week: ~$1.50/month with gpt-4o-mini, ~$11/month with gpt-4o
• 30 meetings/week: ~$3/month with gpt-4o-mini, ~$22/month with gpt-4o

If you bill by the hour or your time is worth anything north of $20/hour, the math is obviously in your favor. The manual version — writing notes, extracting action items, drafting the email — takes most people 20–40 minutes per meeting.

What to Do Next

Run it on your next meeting and send the AI-generated follow-up email (after a quick 30-second review). Most people who do this once make it a permanent habit within a week. The output is better than what they'd write manually, it's consistent, and it's done before they've even closed their laptop.

After a week, look at your action items list. Are items actually getting done now that they're written down clearly? Are people more accountable because the "who owns what" is explicit? Most teams see a noticeable shift in meeting follow-through within the first month.