A local meeting-notes setup is two models, not one: a speech-to-text model that turns audio into a transcript, and a chat model that turns the transcript into notes. The question that decides the setup is whether both fit on one card, and whether the summariser’s context window holds the whole meeting.
| Card | Speech-to-text | Summariser (Ollama tag) | Memory: weights + 32K-token cache | What it handles |
|---|---|---|---|---|
| No GPU | Whisper large-v3-turbo via whisper.cpp, q5_0 (0.57 GB) | qwen3.5:4b-q4_K_M (3.32 GB) | 4.97 GB (4.6 GiB) of system RAM | Recorded meetings processed after the fact, slowly |
| 8 GB | Parakeet TDT 0.6B v3 (2.51 GB file) | qwen3.5:4b-q4_K_M (3.32 GB) | 4.40 GB (4.1 GiB) one at a time; 6.91 GB (6.4 GiB) together | About two hours of transcript per summary, run in sequence |
| 12 GB | Whisper large-v3-turbo (1.62 GB) | qwen3.5:9b-q4_K_M (6.55 GB) | 9.24 GB (8.6 GiB) together | Both loaded at once, multilingual audio |
| 16 GB | Parakeet or Whisper turbo | gpt-oss:20b (13.79 GB) | 14.60 GB (13.6 GiB) for the LLM alone | Stronger summariser, strictly one model at a time |
| 24 GB | Whisper large-v3-turbo (1.62 GB) | qwen3.8:27b-q4_K_M (17.74 GB) | 21.51 GB (20.0 GiB) together | Both loaded at once, or 64K tokens of context in sequence |
Sizes are the published file sizes in decimal GB: Hugging Face file listings for the speech models, and the Ollama registry manifests (all layers, including the vision projector the Qwen3.5 tags ship) for the summarisers. The cache figures are arithmetic, shown further down. A “16 GB” card holds 16 GiB, which is 17.18 GB. None of these combinations has been run by this site; they are fits on paper, before the runtime’s own buffers.
How the two models share memory
There are two ways to run the pair. In sequence: transcribe the recording, unload the speech model, then load the summariser. Peak memory is whichever stage is larger. Together: both stay resident, which matters only when transcribing live and summarising while the meeting runs.
For notes from a recorded meeting, sequence is enough, and it is how the 8 GB and 16 GB rows work. Ollama keeps a model loaded for five minutes after its last request by default, per the Ollama FAQ, and ollama stop unloads it at once. The FAQ also notes that on a GPU, “new models must be able to completely fit in VRAM to allow concurrent model loads”; otherwise one model is unloaded to make room. The speech model usually runs in a separate process (whisper.cpp, faster-whisper, NeMo), so its memory is not managed by Ollama at all, and the two can collide if both are left running.
Picks by tier
No GPU. whisper.cpp runs Whisper on the CPU, and its quantised ggml-large-v3-turbo-q5_0.bin is 574,041,195 bytes on the model repository. The alternative is Parakeet’s 0.71 GB q8_0 GGUF through NeMo-Speech.cpp, whose README says speech recognition stays “faster than real time even on a CPU”; its CPU figure (6x real time) is vendor-reported and measured on a different streaming model, Nemotron Speech Streaming 0.6B. For the summary, qwen3.5:4b-q4_K_M is the same family the site’s chat models by VRAM guide picks for small hardware. The catch: CPU generation is slow, so this is an overnight-batch setup, not live notes.
8 GB. Parakeet TDT 0.6B v3 is 600 million parameters, CC-BY-4.0, covers 25 European languages and states “At least 2GB RAM for model to load.” Its card supports audio “up to 24 minutes long with full attention (on A100 80GB) or up to 3 hours with local attention”, so long recordings need the local-attention setting or chunking. Pair it with qwen3.5:4b-q4_K_M and run them in sequence. The catch: 6.9 GB for both at once leaves under 1.6 GiB of an 8 GiB card for everything else.
12 GB. Whisper large-v3-turbo (MIT, 809M parameters) is “the exact same model” as large-v3 “except that the number of decoding layers have reduced from 32 to 4”, which its card says makes it “way faster, at the expense of a minor quality degradation.” It is the multilingual choice when meetings are outside Parakeet’s 25 languages. qwen3.5:9b-q4_K_M is 6.55 GB; together the pair needs 9.24 GB (8.6 GiB) of a 12 GiB card at a 32K context. The catch: Qwen3.5 runs “in thinking mode by default” per its card, and that reasoning text is generated before the notes.
16 GB. gpt-oss:20b is 13.79 GB, Apache-2.0, with a 128K context on the Ollama tag page; its model card says it runs “within 16GB of memory.” That leaves no room for a speech model alongside it: Parakeet plus gpt-oss totals 17.11 GB, which is 15.9 GiB of a 16 GiB card. Sequence only. The catch: if live notes matter more than summary quality, drop to qwen3.5:9b-q4_K_M and keep both loaded.
24 GB. qwen3.8:27b-q4_K_M (17.74 GB including its vision projector, Apache-2.0, 262,144-token native context per the Qwen3.8-27B card) is the same model the site’s chat models by VRAM guide picks at this tier. Plus Whisper turbo it comes to 21.51 GB (20.0 GiB) at 32K, or 23.65 GB (22.0 GiB) at 64K, which leaves about 2 GiB of a 24 GiB card. The catch: thinking mode is on by default (the card says it “can be disabled per request”), and those tokens count against the same window.
The speech models by VRAM tier page covers the wider set of STT options, including Canary-Qwen-2.5B and the licence detail for each.
How much meeting fits in context
Two assumptions, labelled as such because this page did not find a primary source to pin either one: conversational speech at 150 words per minute, and 1.3 tokens per English word. Both vary by speaker, language and tokenizer. On those assumptions one minute of meeting is about 195 tokens, so an hour is about 11,700 tokens and two hours about 23,400. Timestamps and speaker labels in the transcript add more.
Reserve about 4,096 tokens for the instructions and the notes themselves (another assumption), then:
- 4,096 tokens: about 21 minutes of speech with nothing reserved, so an hour-long meeting is cut off. This matters because Ollama’s context length docs say it defaults to ”< 24 GiB VRAM: 4k context”. On every card below 24 GiB, raise
num_ctxorOLLAMA_CONTEXT_LENGTHfirst. - 32,768 tokens: about 147 minutes, roughly two and a half hours.
- 65,536 tokens: about 315 minutes.
The cache cost of that context comes from each model’s config.json. At Ollama’s default f16 cache (2 bytes per value, per the FAQ), each token costs full-attention layers x 2 (key and value) x KV heads x head size x 2 bytes:
- Qwen3.5-4B and 9B: 8 full-attention layers (the other 24 are linear attention), 4 KV heads, head size 256 = 32,768 bytes per token, so 1.0 GiB at 32K.
- gpt-oss-20b: 12 full-attention layers (the other 12 use a 128-token sliding window), 8 KV heads, head size 64 = 24,576 bytes per token, so 0.75 GiB at 32K.
- Qwen3.8-27B: 16 full-attention layers (the other 48 are linear attention), 4 KV heads, head size 256 = 65,536 bytes per token, so 2.0 GiB at 32K and 4.0 GiB at 64K.
These are lower bounds: the linear-attention layers keep a fixed-size state, and the runtime adds compute buffers. The FAQ’s q8_0 cache option “uses approximately 1/2 the memory of f16.” For meetings longer than the window, summarise in chunks and then summarise the summaries; the long-document Q&A guide covers the trade-offs of chunking versus a longer context.
Speaker labels
Neither Whisper nor Parakeet labels speakers by itself. Whisper’s own card says the models “may exhibit additional capabilities” for speaker diarization but “have not been robustly evaluated in these areas.” Diarisation is a separate model, and the main options differ on licence and access:
- pyannote speaker-diarization-community-1: CC-BY-4.0 and gated. Its page asks users to accept the conditions and create a Hugging Face access token before downloading; once fetched it supports offline use. WhisperX uses it, with the
--hf_tokenargument. - NVIDIA Streaming Sortformer 4spk v2: CC-BY-4.0, not gated, with a q8_0 GGUF for NeMo-Speech.cpp. Its card says it “can detect a maximum of 4 speakers; performance degrades on recordings with 5 and more speakers” and that it was trained “primarily in English.”
- whisper.cpp tinydiarize: listed in the README as “(experimental)”.
Ready-made apps
- Meetily (MIT, release v0.5.0 published 2026-11-14): a desktop app that transcribes with Whisper or Parakeet and summarises with Ollama by default, with optional Claude, Groq, OpenRouter or OpenAI-compatible endpoints. The repository description mentions speaker diarisation, but the README lists “Speaker Identification” among the paid PRO features.
- Scriberr (MIT, release v1.2.0 published 2025-12-17): a self-hosted server with Whisper, Parakeet and Canary, speaker detection, and summaries through “Ollama or OpenAI API compatible providers.” The site’s Scriberr setup guide walks through installation.
- WhisperX (BSD-2-Clause, release v3.8.6 published 2026-05-25): a command-line transcriber with word timestamps and pyannote diarisation, no summariser. Pipe its output into Ollama.
For a plain transcription setup without the notes step, see the whisper.cpp and faster-whisper guide.
Limits
- Transcripts can contain words nobody said. The Whisper card warns that “the predictions may include texts that are not actually spoken in the audio input (i.e. hallucination).” A summary built on that inherits it. Check names, numbers and decisions against the audio.
- Recording is the hard part. None of the models above captures a call; the app or the operating system has to record both sides. Consent rules for recording meetings depend on where the participants are.
- A cloud summary option undoes the privacy. Meetily’s README says that with a cloud provider, “only the transcript text is sent to it”, which is still the full content of the meeting.
Bottom line
On 8 to 16 GB, transcribe first, unload, then summarise, and set the context to at least 32K so an hour-long meeting is not cut off. On 12 GB and 24 GB, both models fit at once with room for a two-hour transcript. Parakeet is the efficient choice within its 25 European languages; Whisper large-v3-turbo is the multilingual alternative outside them. For speaker labels, budget for a separate diarisation model and read its licence and gating first. Cloud meeting assistants are compared in the Otter, Fireflies, Fathom and tl;dv review.