How to Build an AI Meeting Notes Distributor

Meeting notes sitting in one person's notebook help nobody. I built an ai meeting notes distribution system that takes raw notes, extracts action items per person, and sends each attendee their specific tasks within minutes of the meeting ending.

Everyone gets what they need to know. Nobody gets buried in notes that are not relevant to them.

What You Need Before Starting

• Python 3.8+
• An AI API key (Claude)
• Meeting attendee list with email/Slack IDs
• A transcription source or raw notes input

Step 1: Process Raw Notes into Structured Data

import anthropic
import json

client = anthropic.Anthropic()

def extract_action_items(raw_notes, attendees):
    prompt = f"""Extract action items from these meeting notes.
Assign each action to a specific person from the attendee list.

Attendees: {', '.join(attendees)}

Meeting Notes:
{raw_notes}

Return JSON:
{{
    "summary": "2-3 sentence meeting summary",
    "decisions": ["list of decisions made"],
    "action_items": [
        {{"assignee": "name", "task": "specific action", "deadline": "if mentioned, else null"}}
    ],
    "follow_ups": ["topics to revisit next meeting"]
}}"""

    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}]
    )
    return json.loads(message.content[0].text)

Step 2: Build Per-Person Summaries

def create_personal_summaries(structured_notes, attendees_map):
    summaries = {}

    for attendee, contact in attendees_map.items():
        personal_actions = [a for a in structured_notes["action_items"] if a["assignee"].lower() == attendee.lower()]

        summary = f"## Meeting Summary\n{structured_notes['summary']}\n\n"

        if structured_notes["decisions"]:
            summary += "## Decisions Made\n"
            for d in structured_notes["decisions"]:
                summary += f"- {d}\n"
            summary += "\n"

        summary += "## Your Action Items\n"
        if personal_actions:
            for a in personal_actions:
                deadline = f" (by {a['deadline']})" if a.get("deadline") else ""
                summary += f"- {a['task']}{deadline}\n"
        else:
            summary += "- No action items assigned to you\n"

        summaries[attendee] = {"content": summary, "contact": contact, "action_count": len(personal_actions)}

    return summaries

Step 3: Distribute via Slack

import requests

def distribute_via_slack(summaries, slack_token):
    for person, data in summaries.items():
        if data["action_count"] > 0:
            header = f"You have {data['action_count']} action item(s) from today's meeting"
        else:
            header = "Meeting notes from today"

        requests.post(
            "https://slack.com/api/chat.postMessage",
            headers={"Authorization": f"Bearer {slack_token}"},
            json={
                "channel": data["contact"],
                "text": f"*{header}*\n\n{data['content']}"
            }
        )
        print(f"Sent to {person}: {data['action_count']} actions")

Step 4: Store for Reference

from pathlib import Path
from datetime import datetime

def store_meeting_record(structured_notes, meeting_title, raw_notes):
    date = datetime.now().strftime("%Y-%m-%d")
    slug = meeting_title.lower().replace(" ", "-")

    record_dir = Path("meeting-records") / date
    record_dir.mkdir(parents=True, exist_ok=True)

    (record_dir / f"{slug}-raw.md").write_text(raw_notes)
    (record_dir / f"{slug}-structured.json").write_text(json.dumps(structured_notes, indent=2))

    return str(record_dir)

Step 5: Wire It All Together

def process_and_distribute(raw_notes, meeting_title, attendees_map, slack_token):
    attendee_names = list(attendees_map.keys())

    structured = extract_action_items(raw_notes, attendee_names)
    summaries = create_personal_summaries(structured, attendees_map)
    distribute_via_slack(summaries, slack_token)
    store_meeting_record(structured, meeting_title, raw_notes)

    total_actions = sum(s["action_count"] for s in summaries.values())
    print(f"Distributed {total_actions} action items to {len(summaries)} attendees")

What to Build Next

Add a follow-up tracker that checks in on action items before the next meeting. Unfinished items automatically appear in the next meeting's agenda. The distribution is step one. Accountability is step two.

Related Reading

• AI-Powered Reporting That Actually Gets Read - making distributed reports useful
• Building Your First Automation: A Complete Guide - automation fundamentals
• The Feedback Loop That Powers Everything - meeting action follow-through