October 28, 2025

How to summarize meetings with LLMs

Learn how to generate detailed, structured meeting summaries powered by LLMs like Claude 3.5 Sonnet

Conversation AI

Ryan O'Connor

Senior Developer Educator

Ryan O'Connor

Senior Developer Educator

Reviewed by

No items found.

Table of contents

[Visible on live site]

In today's remote-first world, organizations conduct millions of virtual meetings daily, but crucial information often slips through the cracks. Important decisions get forgotten, action items go untracked, and valuable insights remain buried in recordings that nobody has time to review. These problems create a massive efficiency gap, and industry analysis shows that most organizations struggle to extract meaningful intelligence from their meetings and calls as they collaborate.

In this tutorial, you'll learn how to use AssemblyAI's LLM Gateway to automatically capture and analyze your meetings, allowing you to turn hours of conversations into structured summaries, clear action items, and actionable insights - all powered by large language models.

Getting Started

Meeting summarization with LLMs requires two components: speech-to-text transcription and LLM analysis through our LLM Gateway. Get your AssemblyAI API key here. Using the LLM Gateway may incur additional costs, so ensure your account has billing enabled.

Install the Python SDK to get started:

pip install -U assemblyai

Step 1: Run Speech-to-Text

To generate a meeting summary, you first need to get a transcript of the meeting audio. Create a file named main.py and add the following code. This script will import the necessary libraries, configure your API key, and transcribe the meeting audio.

While we set the API key inline here for simplicity, you should store it securely as an environment variable in production code and never check it into source control.

import assemblyai as aai import requests import sys # Set your API key aai.settings.api_key = "YOUR_API_KEY" # URL of the meeting audio to be transcribed MEETING_URL = "https://storage.googleapis.com/aai-web-samples/meeting.mp3" # Configure the transcriber transcriber = aai.Transcriber() # Transcribe the audio file transcript = transcriber.transcribe(MEETING_URL) # Check for transcription errors if transcript.status == aai.TranscriptStatus.error: print(f"Transcription failed: {transcript.error}", file=sys.stderr) sys.exit(1)

Step 2: Generate a meeting summary

With the transcript ready, you can analyze it using AssemblyAI's LLM Gateway. Create a structured prompt that defines exactly what information to extract:

prompt = """ Analyze this meeting transcript and provide a structured summary with the following: 1. Meeting Overview - Meeting date and duration - List of participants (if mentioned) - Main objectives discussed 1. Key Decisions - Document all final decisions made - Include any deadlines or timelines established - Note any budgets or resources allocated 1. Action Items - List each action item with: * Assigned owner * Due date (if specified) * Dependencies or prerequisites * Current status (if mentioned) 1. Discussion Topics - Summarize main points for each topic - Highlight any challenges or risks identified - Note any unresolved questions requiring follow-up 1. Next Steps - Upcoming milestones - Scheduled follow-up meetings - Required preparations for next discussion ROLE: You are a professional meeting analyst focused on extracting actionable insights. FORMAT: Present the information in clear sections with bullet points for easy scanning. Keep descriptions concise but include specific details like names, dates, and numbers when mentioned. If any of these elements are not discussed in the meeting, note their absence rather than making assumptions. """.strip()

Now, send the transcript text and your prompt to the LLM Gateway. This requires a separate API call. Add the following code to the end of your main.py file to send the request and print the summary:

# Prepare the request for the LLM Gateway llm_gateway_payload = { "model": "claude-sonnet-4-5-20250929", # A powerful and current model "messages": [ { "role": "user", "content": f"{prompt}\n\nTranscript:\n{transcript.text}" } ], "max_tokens": 2048, "temperature": 0.0 } try: # Send the request to the LLM Gateway response = requests.post( "https://llm-gateway.assemblyai.com/v1/chat/completions", headers={"authorization": aai.settings.api_key}, json=llm_gateway_payload ) response.raise_for_status() # Raise an exception for bad status codes result = response.json() print(result['choices'][0]['message']['content']) except requests.exceptions.RequestException as e: print(f"Error calling LLM Gateway: {e}", file=sys.stderr) sys.exit(1)

Step 3: Run the code

Execute this script in your terminal by running python main.py. This will transcribe the meeting audio, analyze the transcript, and generate a structured meeting summary based on your prompt. The output will be printed to your console. For example, here is an example output for the example file used above:

Here's a structured summary of the meeting transcript: 1. Meeting Overview - Date: February 18, 2021 - Participants mentioned: Eric Johnson, Sid, Lily, Mac, Christopher, Steve, Craig, Christy, Rob - Main objectives: Engineering key review, discussing KPIs, metrics, and organizational changes 2. Key Decisions - Break up the engineering key review into four department key reviews - Implement a two-month rotation for department reviews - Change the R&D wider MR Rate KPI to track percentage of total MRs that come from the community - Measure S1/S2 SLO achievement based on open bugs rather than closed bugs 3. Action Items - Lily: Work with Mac to transition to new community contribution KPI - Mac: Provide an update on the Postgres replication issue in next week's infra key review - Mac/Data team: Develop new measurement for average open bugs age - Mac/Data team: Adjust metrics to measure percentage of open bugs within SLO - Christopher: Continue monitoring narrow MR Rate and expect rebound in March 4. Discussion Topics a) Department Key Reviews - Proposal to split engineering review into development, quality, security, and UX - Two-month rotation proposed to avoid adding too many meetings b) R&D MR Rate Metrics - Confusion about current R&D wider MR Rate calculation - Decision to simplify and track percentage of MRs from community c) Postgres Replication Issue - Lag in data updates affecting February metrics - Need for dedicated computational resources and potential database tuning d) Defect Tracking and SLOs - S1 defects at 80% SLO achievement, S2 at 60% - Spike in mean time to close for S2 bugs noted e) SUS (Satisfaction) Metric - Smallest decline in Q4 compared to previous quarters - Cautious optimism about trend, but continued monitoring needed f) Narrow MR Rate - Currently below target but higher than previous year - Expectation to rebound in March after short February and power outages in Texas 5. Next Steps - Implement new department key review structure - Monitor effects of changes to KPI measurements - Continue focus on improving security work prioritization - Expect potential temporary jump in SLO achievement as backlog is cleared Note: Specific due dates for action items were not mentioned in the transcript.

Available LLM models

The LLM Gateway supports various language models from leading providers. Here is a selection of currently available models, but you can always check our Docs for the most up-to-date information:

claude-sonnet-4-5-20250929: (Anthropic) Claude's best model for complex agents and coding.
gpt-5: (OpenAI) OpenAI's best model for coding and agentic tasks across domains.
gemini-2.5-pro: (Google) Gemini's state-of-the-art thinking model, capable of reasoning over complex problems.
claude-haiku-4-5-20251001: (Anthropic) Claude's fastest and most intelligent Haiku model, ideal for near-instant responsiveness.
gpt-oss-120b: (OpenAI) OpenAI's most powerful open-weight model.

Access LLM Gateway Models

Start calling leading LLMs through a single API with your AssemblyAI key. Pick the model that fits your latency and cost needs for meeting summaries.

Get API key

Customizing the summary

LLMs allow you to custom-tailor your summary formats, giving you the ability to tell you what information you want the LLM to focus on and extract, and how you want the result to be presented. Feel free to experiment with different prompts to generate summaries that suit your needs. Here are some examples to get you started:

Focus on Action Items

action_items_prompt = """ Review the transcript and extract all action items: - Who is responsible - What needs to be done - When it's due - Current status Format as a clear, bulleted list. """

Technical Discussion Summary

technical_prompt = """ Analyze this technical discussion and provide: - Technical decisions made - Architecture changes approved - Dependencies identified - Technical debt noted - System constraints discussed Include specific technical details mentioned. """

Project Status Report

status_prompt = """ Generate a project status report including: - Overall project health - Milestones completed - Upcoming deadlines - Blocking issues - Resource needs - Risk assessment """

Error handling and troubleshooting

When moving from a simple script to a production application, robust error handling is critical, especially since some estimates show that over 80 percent of AI projects fail—double the rate of typical IT projects. Network issues, invalid file formats, or API problems can occur, and your code needs to handle them gracefully.

The workflow involves two API calls: one to the Speech-to-Text API and one to the LLM Gateway. Both can fail independently. The AssemblyAI Python SDK raises an AssemblyAIError for transcription problems, while the LLM Gateway call (made via requests) can raise an HTTPError.

import assemblyai as aai import requests import sys aai.settings.api_key = "YOUR_API_KEY" prompt = "Your summarization prompt..." try: # Step 1: Transcribe the audio transcript = aai.Transcriber().transcribe("https://path/to/your/file.mp3") if transcript.status == aai.TranscriptStatus.error: print(f"Transcription failed: {transcript.error}", file=sys.stderr) sys.exit(1) # Step 2: Analyze with LLM Gateway llm_gateway_payload = { "model": "claude-sonnet-4-5-20250929", "messages": [{"role": "user", "content": f"{prompt}\n\nTranscript:\n{transcript.text}"}] } llm_response = requests.post( "https://llm-gateway.assemblyai.com/v1/chat/completions", headers={"authorization": aai.settings.api_key}, json=llm_gateway_payload ) # Check for LLM Gateway errors llm_response.raise_for_status() # ... proceed with processing the response print(llm_response.json()['choices'][0]['message']['content']) except aai.errors.AssemblyAIError as e: print(f"A transcription API error occurred: {e}", file=sys.stderr) sys.exit(1) except requests.exceptions.RequestException as e: print(f"An LLM Gateway API error occurred: {e}", file=sys.stderr) sys.exit(1)

This example demonstrates multiple layers of error checking. First, it wraps the API calls in a try...except block to catch immediate issues like authentication failures or network problems. Second, it checks the transcript.status to handle errors that occur during the asynchronous transcription process. Finally, it checks the HTTP status of the LLM Gateway response. This ensures your application handles failures at each stage of the process.

Best Practices and Tips

Prompt engineering

Prompt structure directly impacts analysis quality. Treat prompts as precise API specifications for the LLM. A key advantage of this approach is the ability to define exactly what you need in natural language, allowing the LLM to handle the complex implementation.

Essential prompt elements:

Clear formatting requirements (bullet points, sections, tables)
Specific categories of information to extract
Instructions for handling uncertainty or missing information
Guidelines for maintaining consistent terminology
Requirements for level of detail and technical depth

You can check out our crash course on prompt engineering if you're unfamiliar:

Audio quality

Transcription accuracy directly affects LLM analysis quality. As recent analysis highlights, even the most sophisticated LLM can't extract meaningful insights from audio without a reliable transcript, and poor audio creates cascading errors through the entire pipeline.

Audio optimization checklist:

Use high-quality microphones or headsets rated for voice clarity
Ensure all participants are in quiet environments with minimal echo
Test audio settings before important meetings
Record locally when possible to avoid internet connectivity issues
Request that participants mute when not speaking

Meeting structure

Structured meetings create recognizable patterns for LLM processing, and consistent protocols improve extraction accuracy. In fact, industry benchmarks show meeting intelligence platforms can reduce follow-up time by 65% and increase action item completion by 30%.

Meeting structure requirements:

Begin with a clear agenda shared in advance
Start with brief participant introductions
Use consistent terminology for decisions and action items
Designate specific times for questions and discussion
End with a verbal summary of key points

Remember to use our Speaker Diarization service in your transcripts to automatically separate out speakers and attribute sentences accordingly, too.

Remember that these practices work together - good audio quality with poor meeting structure, or well-structured meetings with unclear prompts, will still result in suboptimal outcomes. You will find the most success in implementing these best practices as a cohesive system.

Frequently asked questions about meeting summarization with LLMs

How do I debug transcription accuracy issues with poor audio quality?

Check source audio for noise, echo, or overlapping speakers first. Enable Speaker Diarization for multi-speaker recordings to improve LLM context accuracy.

What are the performance implications of different LLM models for meeting summarization?

Different models offer trade-offs between performance, latency, and cost. For example, a model like gemini-2.5-pro offers state-of-the-art reasoning but may have higher latency. A model like claude-haiku-4-5-20251001 provides near-instant responsiveness at a lower cost. A good starting point for balanced performance is claude-sonnet-4-5-20250929.

How do I handle very long meetings that exceed LLM token limits?

Use map-and-reduce: chunk long transcripts into 15-minute segments, summarize each chunk individually, then combine summaries with a final prompt.

What's the best approach for processing meetings in real-time vs batch?

Use batch processing for post-meeting summaries or streaming transcription API for real-time analysis. Stream transcript chunks to the LLM Gateway for live insights during meetings.

How do I optimize costs when processing hundreds of meetings daily?

Implement caching to avoid duplicate processing, optimize prompt length to reduce token costs, and batch requests where latency permits.

Next Steps

To learn more about how to use our API and the features it offers, check out our Docs, or check out our cookbooks repository to browse solutions for common use cases. Ready to start building? Try our API for free and see how AssemblyAI's Voice AI models can transform your meeting workflows. Alternatively, check out our blog for tutorials and deep-dives on AI theory, like this Introduction to LLMs, or our YouTube channel for project tutorials and more, like this one on building an AI voice agent in Python with DeepSeek R1: