Summarize meeting transcripts locally on a Mac with Ollama
Summarize a transcript locally on your Mac with Ollama: install, pull a model, a working prompt, chunking long transcripts, and a one-tap alternative.
You can turn a long transcript into a summary, action items or meeting minutes on your own Mac, with no cloud API and no credits, by running a language model locally with Ollama. This guide takes you from a blank Terminal to a working summarizer that handles transcripts longer than the model's context window, and then shows the one-step version built into a transcription app.
The DIY route works well. It costs you about half an hour of setup, some disk space for the model, and a bit of scripting for long files. Nothing you type into it leaves the machine.
What you need
- An Apple Silicon Mac. Models run on the GPU through Metal, and 16 GB of memory is a comfortable minimum for the 7B to 8B class of models that do a good job on summaries. 8 GB works with smaller models, with weaker results.
- A transcript as a plain text file. If you still have only audio, transcribe it to text on the Mac first.
- Homebrew, or the installer from ollama.com.
Step 1: Install Ollama
Ollama is an open-source runtime that downloads models, runs them locally and exposes a simple command line and a local HTTP API. Install it with Homebrew:
brew install ollama
Then start the server. Homebrew can run it as a background service:
brew services start ollama
Or run it in a Terminal window you leave open:
ollama serve
If you used the installer from ollama.com instead, the menu bar app starts the server for you.
Check that it answers:
ollama --version
Step 2: Pull a model
Models are pulled by name from the Ollama library. For summarization on a 16 GB Mac, a general-purpose instruction-tuned model in the 7B to 8B range is the sweet spot. Two reasonable choices as of writing are:
ollama pull llama3.1
ollama pull qwen2.5
Pulling downloads several gigabytes, once. Check the Ollama model library for current names and sizes, since they change. On an 8 GB Mac pick a 3B model instead, for example llama3.2 or qwen2.5:3b.
Try it interactively:
ollama run llama3.1
Type a question, get an answer, then type /bye to leave.
Step 3: A prompt that produces useful summaries
Models summarize badly when asked to "summarize this". They do well when told the audience, the shape of the output and what to leave out. Save this as summary-prompt.txt:
You are summarizing a meeting transcript for someone who was not there.
Write in plain English. Do not invent anything that is not in the transcript.
If the transcript does not contain something, say so rather than guessing.
Produce:
1. A two-sentence overview of what the meeting was about.
2. Key decisions, as a bulleted list. Include who decided if it is clear.
3. Action items, as a bulleted list in the form "Owner: task (deadline if stated)".
4. Open questions that were raised but not resolved.
Transcript follows.
Now run it. Ollama accepts the prompt as an argument and reads additional input from standard input, so you can feed the prompt file and the transcript together:
cat summary-prompt.txt transcript.txt | ollama run llama3.1 > summary.md
Open summary.md. For a transcript of up to roughly twenty minutes of speech this usually works on the first try. For anything longer, read on.
Change the audience line and the numbered list, and the same prompt handles other kinds of recording. For turning a lecture into study notes, ask for definitions, the results that matter and a set of questions to answer from memory, rather than decisions and action items.
Step 4: The context window problem
Every model has a maximum number of tokens it can look at in one go, and Ollama runs models with a fairly short default window unless told otherwise. When the transcript is longer than that window, the beginning is silently dropped and the summary quietly describes only the end of the meeting. Nothing warns you.
Two fixes, used together:
Raise the context length
Set a larger window when running the model. In an interactive session:
/set parameter num_ctx 16384
Or set it for every run through the environment variable that Ollama honours as of writing:
OLLAMA_CONTEXT_LENGTH=16384 ollama serve
Larger windows use more memory and slow the first token down. On a 16 GB Mac, 16k tokens with an 8B model is usually fine. Check the model's card in the library for the maximum it supports.
A rough conversion: one minute of conversational speech is around 150 words, and 150 words is around 200 tokens. So a one-hour meeting is about 12,000 tokens before the prompt. A two-hour workshop will not fit even in a generous window, which brings us to chunking.
Chunk long transcripts
The reliable method is map-reduce: split the transcript into pieces that fit comfortably, summarize each piece, then summarize the pieces' summaries. Save this as summarize.sh:
#!/bin/bash
# Usage: ./summarize.sh transcript.txt
set -e
MODEL=llama3.1
IN="$1"
WORK=$(mktemp -d)
# 1. Split into chunks of about 6,000 words.
split -l 400 "$IN" "$WORK/chunk_"
# 2. Summarize every chunk.
for f in "$WORK"/chunk_*; do
{
echo "Summarize this part of a meeting transcript. Keep every decision,"
echo "action item, name, number and date. Use bullet points. Transcript:"
cat "$f"
} | ollama run "$MODEL" > "$f.summary"
done
# 3. Combine the partial summaries into the final one.
{
cat summary-prompt.txt
cat "$WORK"/chunk_*.summary
} | ollama run "$MODEL"
rm -rf "$WORK"
Make it executable and run it:
chmod +x summarize.sh
./summarize.sh transcript.txt > summary.md
Two notes on the script. split -l 400 splits by lines, so the chunk size depends on how your transcript wraps; adjust the number until each chunk is well under your context window. And the final pass receives partial summaries rather than the transcript, so details that a chunk summary dropped are gone for good. That is why step 2 tells the model to keep names, numbers and dates.
Step 5: Ask questions instead of summarizing
The same setup answers questions about a transcript. Replace the prompt with the question:
{ echo "Answer using only the transcript below. Quote the relevant lines. Question: What did we agree about the launch date?"; cat transcript.txt; } | ollama run llama3.1
This is often more useful than a summary when you already know what you are looking for. The limits are the same: the whole transcript must fit in the window, and the model has no way to point you to where in the audio a quoted line was said.
Using the local HTTP API
For anything you want to automate, Ollama listens on localhost:11434. A minimal call:
curl http://localhost:11434/api/generate -d '{
"model": "llama3.1",
"prompt": "Summarize: ...",
"stream": false,
"options": { "num_ctx": 16384 }
}'
The API reference lives in the Ollama GitHub repository. Shortcuts, Automator or a small Python script can call it to summarize every new file in a folder.
What the DIY route costs you
Be realistic about the upkeep. You need to keep Ollama and the model updated, remember the context-length setting, keep your chunking script in step with the transcripts you produce, and copy the results into wherever your notes live. It is a good weekend project and a fine permanent setup for someone who enjoys the Terminal. It is a poor fit for someone who just wants minutes after every call.
The one-step alternative
If the recordings are lectures rather than meetings, turning a lecture recording into study notes walks through the same pipeline from the recording to the revision material. Summaries can be sent straight to Apple Notes, and transcripts export as TXT, Markdown, PDF or DOCX. It requires macOS 26 or later on an Apple Silicon Mac with 16 GB of memory, roughly the same machine the DIY route wants.
Frequently asked questions
Can I summarize a transcript with Ollama without internet?
Yes. Once the model has been pulled, Ollama runs entirely on the Mac. You can unplug from the network, and the summary is produced the same way. The only time it needs a connection is to download or update a model.
Which Ollama model is best for summarizing meeting transcripts?
As of writing, instruction-tuned general models in the 7B to 8B range, such as the current Llama or Qwen releases, give the best balance of quality and speed on a 16 GB Mac. Larger models are more accurate but slow and memory-hungry; 3B models are fast but tend to miss details in long transcripts. Try two and compare on the same meeting.
How long a transcript can a local LLM summarize?
As long as you want, if you chunk it. In a single pass the limit is the model's context window: at around 200 tokens per minute of speech, a 16k window holds roughly an hour of conversation plus the prompt. Beyond that, split the transcript and summarize in stages.
Is a local LLM summary as good as a cloud one?
For meeting summaries and action items, a good 8B model is close enough that most people will not notice the difference. Cloud models still win on very long documents, subtle reasoning and rare languages. For the private, routine job of turning an hour-long call into notes, local is more than adequate and costs nothing per use.
