Build an AI meeting assistant with Claude, GPT-4, or Gemini. Automate transcription, generate summaries, extract action items, and integrate with Zoom, Teams, and Google Meet.
Meetings consume 23 hours per week for the average knowledge worker, yet 71% of meetings are considered unproductive. AI meeting assistants in 2026 have transformed from simple transcription tools to intelligent participants that capture decisions, track commitments, and generate actionable insights.
This guide shows you how to build a complete AI meeting assistant that saves 10+ hours per week.
Current Reality:
AI Solution Impact:
Core Capabilities:
```typescript
// AI Meeting Assistant Architecture
interface MeetingAssistant {
// Core pipeline
transcriber: SpeechToText; // Audio ā text
diarizer: SpeakerDiarization; // Identify speakers
summarizer: MeetingSummarizer; // Generate summaries
extractor: ActionItemExtractor; // Find commitments
analyzer: MeetingAnalyzer; // Insights & metrics
integrator: CalendarIntegration; // Schedule & follow-up
}
// Meeting output
interface MeetingOutput {
transcript: string;
speakers: Speaker[];
summary: string;
keyDecisions: string[];
actionItems: ActionItem[];
topics: Topic[];
sentiment: SentimentAnalysis;
duration: number;
participants: Participant[];
}
interface ActionItem {
task: string;
assignee: string;
deadline: Date | null;
priority: 'high' | 'medium' | 'low';
status: 'pending' | 'in-progress' | 'completed';
context: string;
}
```
| Use Case | Best Solution | Cost | Setup Time | Accuracy |
|----------|--------------|------|------------|----------|
| Zoom meetings | Otter.ai + Claude | $20/mo | 30 min | 95% |
| Google Meet | Fireflies.ai | $10/mo | 15 min | 93% |
| Microsoft Teams | Teams Premium | $10/user/mo | 5 min | 94% |
| Custom/Multi-platform | Whisper + Claude API | $50-150/mo | 6 hours | 96% |
| Privacy-focused | Local Whisper + Ollama(hardware) | 10 hours | 92% |
Setup Steps:
```bash
npm install @anthropic-ai/sdk otter-api-client
export ANTHROPIC_API_KEY="your-claude-key"
export OTTER_API_KEY="your-otter-key"
```
Post-Meeting Processor:
```typescript
import Anthropic from '@anthropic-ai/sdk';
import { OtterClient } from 'otter-api-client';
class MeetingProcessor {
private anthropic: Anthropic;
private otter: OtterClient;
constructor() {
this.anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
this.otter = new OtterClient(process.env.OTTER_API_KEY!);
}
async processMeeting(meetingId: string): Promise
// Get transcript from Otter.ai
const transcript = await this.otter.getTranscript(meetingId);
// Process with Claude
const analysis = await this.analyzeWithClaude(transcript);
// Extract action items
const actionItems = await this.extractActionItems(transcript);
// Generate summary
const summary = await this.generateSummary(transcript, analysis);
return {
transcript: transcript.text,
speakers: transcript.speakers,
summary,
keyDecisions: analysis.decisions,
actionItems,
topics: analysis.topics,
sentiment: analysis.sentiment,
duration: transcript.duration,
participants: transcript.participants
};
}
private async analyzeWithClaude(transcript: any) {
const message = await this.anthropic.messages.create({
model: 'claude-sonnet-4-20250514',
max_tokens: 4096,
messages: [{
role: 'user',
content: `Analyze this meeting transcript and extract structured information:
${transcript.text}
Provide analysis in JSON format:
{
"decisions": ["decision 1", "decision 2"],
"topics": [
{"name": "topic", "duration": "minutes", "sentiment": "positive|neutral|negative"}
],
"sentiment": {
"overall": "positive|neutral|negative",
"concerns": ["concern 1"],
"enthusiasm": ["positive point 1"]
},
"keyMoments": [
{"timestamp": "MM:SS", "description": "what happened", "importance": "high|medium|low"}
],
"nextSteps": ["step 1", "step 2"]
}`
}]
});
const response = message.content[0].type === 'text'
? message.content[0].text
: '';
return JSON.parse(response);
}
private async extractActionItems(transcript: any): Promise
const message = await this.anthropic.messages.create({
model: 'claude-sonnet-4-20250514',
max_tokens: 2048,
messages: [{
role: 'user',
content: `Extract all action items from this meeting transcript:
${transcript.text}
For each action item, identify:
Respond in JSON array format:
[
{
"task": "clear description of what needs to be done",
"assignee": "person name or 'unassigned'",
"deadline": "ISO date or null",
"priority": "high|medium|low",
"context": "brief context from meeting",
"confidence": 0.0-1.0
}
]
Only include clear commitments, not vague discussions.`
}]
});
const response = message.content[0].type === ''
? message.content[0].text
: '';
const items = JSON.parse(response);
return items.map((item: any) => ({
...item,
status: 'pending' as const,
deadline: item.deadline ? new Date(item.deadline) : null
}));
}
private async generateSummary(transcript: any, analysis: any): Promise
const message = await this.anthropic.messages.create({
model: 'claude-sonnet-4-20250514',
max_tokens: 1024,
messages: [{
role: 'user',
content: `Generate a concise meeting summary:
Transcript: ${transcript.text.substring(0, 3000)}
Key Decisions: ${analysis.decisions.join(', ')}
Topics Discussed: ${analysis.topics.map((t: any) => t.name).join(', ')}
Create a summary with:
Keep it under 200 words, executive-friendly.`
}]
});
return message.content[0].type === 'text'
? message.content[0].text
: '';
}
}
```
Real-time Meeting Assistant:
```typescript
import { OpenAI } from 'openai';
import Anthropic from '@anthropic-ai/sdk';
import { createWriteStream } from 'fs';
import { spawn } from 'child_process';
class RealtimeMeetingAssistant {
private openai: OpenAI;
private anthropic: Anthropic;
private audioBuffer: Buffer[] = [];
private transcriptBuffer: string = '';
constructor() {
this.openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY
});
this.anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
}
async startRecording(audioSource: string = 'default') {
// Record audio using ffmpeg
const ffmpeg = spawn('ffmpeg', [
'-f', 'avfoundation', // macOS (use 'alsa' for Linux, 'dshow' for Windows)
'-i', `:${audioSource}`,
'-acodec', 'pcm_s16le',
'-ar', '16000',
'-ac', '1',
'-f', 'wav',
'pipe:1'
]);
let audioChunk: Buffer[] = [];
let chunkDuration = 0;
const CHUNK_SECONDS = 30; // Process every 30 seconds
ffmpeg.stdout.on('data', async (data: Buffer) => {
audioChunk.push(data);
chunkDuration += data.length / (16000 * 2); // 16kHz, 16-bit
if (chunkDuration >= CHUNK_SECONDS) {
const audio = Buffer.concat(audioChunk);
await this.processAudioChunk(audio);
audioChunk = [];
chunkDuration = 0;
}
});
return ffmpeg;
}
private async processAudioChunk(audio: Buffer) {
// Save to temp file for Whisper
const tempFile = `/tmp/audio-${Date.now()}.wav`;
const writeStream = createWriteStream(tempFile);
writeStream.write(audio);
writeStream.end();
// Transcribe with Whisper
const transcription = await this.openai.audio.transcriptions.create({
file: createReadStream(tempFile),
model: 'whisper-1',
language: 'en',
response_format: 'verbose_json'
});
// Add to transcript buffer
this.transcriptBuffer += transcription.text + '\n';
// Real-time analysis every 5 minutes
if (this.transcriptBuffer.length > 5000) {
await this.realtimeAnalysis();
}
// Clean up temp file
unlinkSync(tempFile);
}
private async realtimeAnalysis() {
const message = await this.anthropic.messages.create({
model: 'claude-sonnet-4-20250514',
max_tokens: 1024,
messages: [{
role: 'user',
content: `Analyze this ongoing meeting transcript and provide real-time insights:
${this.transcriptBuffer}
Provide:
Keep it brief (under 150 words).`
}]
});
const analysis = message.content[0].type === 'text'
? message.content[0].text
: '';
console.log('\n=== Real-time Meeting Insights ===');
console.log(analysis);
console.log('==================================\n');
// Optionally send to Slack, email, etc.
await this.sendRealtimeUpdate(analysis);
}
private async sendRealtimeUpdate(analysis: string) {
// Send to Slack, Teams, email, etc.
// Implementation depends on your notification system
}
async endMeeting(): Promise
// Final comprehensive analysis
const finalAnalysis = await this.analyzeWithClaude({
text: this.transcriptBuffer
});
const actionItems = await this.extractActionItems({
text: this.transcriptBuffer
});
const summary = await this.generateSummary(
{ text: this.transcriptBuffer },
finalAnalysis
);
return {
transcript: this.transcriptBuffer,
speakers: [],
summary,
keyDecisions: finalAnalysis.decisions,
actionItems,
topics: finalAnalysis.topics,
sentiment: finalAnalysis.sentiment,
duration: 0,
participants: []
};
}
}
```
Chrome Extension Approach:
```typescript
// content-script.ts - Runs in Google Meet page
class GoogleMeetAssistant {
private captions: string[] = [];
private meetingId: string;
constructor() {
this.meetingId = this.extractMeetingId();
this.startCaptionCapture();
}
private extractMeetingId(): string {
const url = window.location.href;
const match = url.match(/meet\.google\.com\/([a-z-]+)/);
return match ? match[1] : '';
}
private startCaptionCapture() {
// Google Meet captions appear in specific DOM elements
const observer = new MutationObserver((mutations) => {
mutations.forEach((mutation) => {
mutation.addedNodes.forEach((node) => {
if (node.nodeType === Node.ELEMENT_NODE) {
const element = node as Element;
const caption = element.querySelector('[jsname="tgaKEf"]');
if (caption) {
const text = caption.textContent || '';
const speaker = this.extractSpeaker(element);
this.captions.push(`${speaker}: ${text}`);
// Send to background script for processing
chrome.runtime.sendMessage({
type: 'NEW_CAPTION',
data: { speaker, text, timestamp: Date.now() }
});
}
}
});
});
});
// Observe caption container
const captionContainer = document.querySelector('[jsname="dsyhDe"]');
if (captionContainer) {
observer.observe(captionContainer, {
childList: true,
subtree: true
});
}
}
privateeaker(element: Element): string {
const speakerElement = element.querySelector('[jsname="YSxPC"]');
return speakerElement?.textContent || 'Unknown';
}
async endMeeting() {
// Send full transcript to background for processing
chrome.runtime.sendMessage({
type: 'MEETING_ENDED',
data: {
meetingId: this.meetingId,
transcript: this.captions.join('\n'),
duration: Date.now() - this.startTime
}
});
}
}
// background.ts - Processes captions with Claude
chrome.runtime.onMessage.addListener(async (message, sender, sendRespo if (message.type === 'MEETING_ENDED') {
const processor = new MeetingProcessor();
const output = await processor.processMeeting(message.data);
// Save to storage
await chrome.storage.local.set({
[`meeting_${message.data.meetingId}`]: output
});
// Send summary email
await sendMeetingSummary(output);
}
});
```
```typescript
import { Client } from '@notionhq/client';
class NotionMeetingSync {
private notion: Client;
constructor() {
this.notion = new Client({
authnv.NOTION_API_KEY
});
}
async saveMeeting(meeting: MeetingOutput, databaseId: string) {
// Create meeting page
const page = await this.notion.pages.create({
parent: { database_id: databaseId },
properties: {
'Title': {
title: [{ text: { content: meeting.title } }]
},
'Date': {
date: { start: meeting.date.toISOString() }
},
'Duration': {
number: meeting.duration
},
'Participants': {
multi_select: meeting.participants.map(p => ({ name: p.name }))
}
},
children: [
{
object: 'block',
type: 'heading_2',
heading_2: {
rich_text: [{ text: { content: 'Summary' } }]
}
},
{
object: 'block',
type: 'paragraph',
paragraph: {
rich_text: [{ text: { content: meeting.summary } }]
}
},
{
object: 'block',
type: 'heading_2',
heading_2: {
rich_text: [{ text: { content: 'Action Items' } }]
}
},
...meeting.actionItems.map(item => ({
object: 'block' as const,
type: 'to_do' as const,
to_do: {
rich_text: [{
text: {
content: `${item.task} (@${item.assignee}${item.deadline ? ` - Due: ${item.deadline.toLocaleDateString()}` : ''})`
}
}],
checked: false
}
}))
]
});
return page.id;
}
}
```
```typescript
import { WebClient } from '@slack/web-api';
class SlackMeetingNotifier {
private slack: WebClient;
constructor() {
this.slack = new WebClient(process.env.SLACK_BOT_TOKEN);
}
async sendMeetingSummary(meeting: MeetingOutput, channelId: string) {
await this.slack.chat.postMessage({
channel: channelId,
blocks: [
{
type: 'header',
text: {
type: 'plain_text',
text: `š Meeting Summary: ${meeting.title}`
}
},
{
type: 'section',
text: {
type: 'mrkdwn',
text: meeting.summary
}
},
{
type: 'section',
text: {
type: 'mrkdwn',
text: '*Key Decisions:*\n' + meeting.keyDecisions.map(d => `ā¢ ${d}`).join('\n')
}
},
{
type: 'section',
text: {
type: 'mrkdwn',
text: '*Action Items:*\n' + meeting.actionItems.map(item =>
`ā¢ ${item.task} - @${item.assignee}${item.deadline ? ` (Due: ${item.deadline.toLocaleDateString()})` : ''}`
).join('\n')
}
}
]
});
// Send individual DMs to assignees
for (const item of meeting.actionItems) {
const user = await this.findSlackUser(item.assignee);
if (user) {
await this.slack.chat.postMessage({
channel: user.id,
text: `You have a new action item from the meeting:\n\n*${item.task}*\n${item.deadline ? `Due: ${item.deadline.toLocaleDateString()}` : 'No deadline set'}\n\nContext: ${item.context}`
});
}
}
}
private async findSlackUser(name: string) {
const users = await this.slack.users.list();
return users.members?.find(u =>
u.real_name?.toLowerCase().includes(name.toLowerCase())
);
}
}
```
| Solution | Transcription | AI Processing | Total | Meetings/Month | Cost per Meeting |
|----------|--------------|---------------|-------|----------------|------------------|
| Otter.ai + Claude | $20 | $30 | $50 | 40 | $1.25 |
| Fireflies.ai | $10 | Included | $10 | 40 | $0.25 |
| Teams Premium | $10 | Included | $10 | Unlimited | $0 |
| Whisper + Claude | $15 | $50-150 | $65-165 | 60 | $1.08-2.75 |
| Local (Whisper + Ollama) | $0 | $0 | $0 | Unlimited | $0 |
Time Savings:
Value:
- Auto-join meeting 2 minutes early
- Load previous meeting context
- Prepare agenda-based prompts
- Real-time transcription
- Live action item detection
- Sentiment monitoring
- Generate summary (30 seconds)
- Extract action items
- Send to participants
- Create calendar reminders
- Update project management tools
```typescript
// Implement consent management
class MeetingConsent {
async requestConsent(participants: string[]): Promise
// Send consent request before recording
const responses = await Promise.all(
participants.map(p => this.sendConsentRequest(p))
);
return responses.every(r => r.consented);
}
async handleOptOut(participant: string) {
// Redact participant's contributions
// Or stop recording entirely
}
}
```
ā Recording without consent - Always get explicit permission
ā Poor audio quality - Use good microphones, test beforehand
ā No speaker diarization - Action items need clear ownership
ā Ignoring context - Feed previous meeting notes for continuity
ā Over-reliance - AI misses nuance; review summaries before sharing
AI meeting assistants in 2026 are production-ready and deliver immediate ROI. Start with Otter.ai + Claude for quick wins, or build custom with Whisper + Claude for maximum control.
Next Steps:
Never take manual meeting notes again.
Comprehensive guide to implementing AI automation in this domain. Learn tools, strategies, and best practices for 2026.
Master AI-powered email management with Claude, GPT-4, and specialized tools. Learn smart filtering, auto-responses, priority detection, and workflow automation to achieve inbox zero in 2026.
Comprehensive guide to implementing AI automation in this domain. Learn tools, strategies, and best practices for 2026.
Get your free AI audit and discover optimization opportunities.
START FREE AUDIT