Run AI locally with Ollama

Ollama lets Kapinote use a Qwen model running directly on your Mac. You do not need a ChatGPT, Claude, or Codex subscription, and you do not need a cloud API key. After the model has been downloaded, meeting summaries and chat can be processed on your computer.

Transcription and AI are separate: Ollama turns an existing transcript into titles, summaries, action items, and answers. It does not convert audio into text. For an entirely local workflow, also select Apple Speech or Qwen3-ASR in Kapinote's speech settings.

Before you start

• The first setup requires internet access: The Ollama app and a Qwen model both have to be downloaded — Kapinote can fetch the model for you. Local inference works offline once that is done.
• No account or API key is required: Local models do not require an Ollama sign-in. Never paste another service's account password into Kapinote.
• Keep Ollama running: Do not quit Ollama from the macOS menu bar while Kapinote is creating summaries or answering questions.
• System requirements: This guide recommends a Mac with Apple Silicon (M1 or newer) running macOS Sonoma 14 or later. Intel Macs are limited to CPU inference, which is not a good fit for Kapinote's local meeting-summary workflow, so local Ollama is not recommended on them.
• Allow for disk and memory overhead: Model files range from a few GB to tens of GB. Runtime memory also holds the meeting context, so download size alone does not determine whether a model will fit.

For the shortest setup path:

• Under 24 GB unified memory: use qwen3.5:4b.
• 24 GB to 48 GB unified memory: use qwen3.5:9b.
• 48 GB or more unified memory: use qwen3.8:27b.

These are the same three tiers Kapinote picks from on its own, so the field is normally already filled in correctly by the time you see it.

Step 1: Check your Mac's chip, memory, and storage

1. Select the Apple menu  → About This Mac.
2. Note the displayed chip and memory, such as “Apple M3 Pro, 18 GB.”
3. Open System Settings → General → Storage and make sure there is enough free space for a model.

When choosing a model, unified memory capacity matters more than whether the chip is M1, M2, M3, M4, or M5. Memory determines whether the model and a long meeting context fit. With the same memory, newer Pro, Max, and Ultra chips will generally run the model faster.

Step 2: Choose a Qwen model for this Mac

These recommendations prioritize reliable meeting summaries and leave memory for macOS, Kapinote, and longer meeting context. Download sizes come from the Ollama model library; actual runtime memory use is higher.

Why the recommendation is smaller than what fits: Fitting is the easy half. Generation speed on Apple Silicon tracks memory bandwidth, and a 16 GB machine has roughly a third of what a 48 GB one has. A model one size too large does not fail — it answers slowly enough to read as a broken app.

Model names matter: Ollama currently provides 27B and 35B local Qwen3.6 variants; there is no qwen3.6:8b or qwen3.6:14b. Lower-memory Macs should use the Qwen3.5 4B or 9B variants. Ollama's newest local Qwen3.8 model is currently 27B and is best suited to Macs with at least 32 GB.

About MLX: Ollama chooses its Apple Silicon-optimized MLX backend automatically on Macs with 32 GB or more of unified memory, and falls back to Metal below that. There is no setting and no separate tag involved. The -mlx tags in the library exist to pin that format explicitly, which a first setup does not need — downloading the same model a second time for the name in the tag buys nothing.

If the Mac becomes unresponsive, relies heavily on swap, or takes an impractical amount of time to produce a short summary, move down one model size. A larger parameter count does not compensate for timeouts or truncated long context.

If you choose a model outside this table: Kapinote's meeting chat hands the model tools so it can look your meetings up itself, so the model has to support tool calling. Every Qwen model above does. Check for a Tools capability on the model's Ollama page before switching — without it, summaries still work but chat fails.

Step 3: Install and start Ollama

1. Open the official Ollama download page and download the macOS version.
2. Open the downloaded .dmg and drag Ollama into Applications.
3. Open Ollama from Applications. Confirm the macOS security prompt if it appears.
4. If Ollama asks to install its command-line tool or create a link in /usr/local/bin, allow it. The command-line tool is used to download and inspect models.
5. Confirm that the Ollama icon appears in the macOS menu bar. Keep it running while using Kapinote.

If Ollama cannot be installed, confirm that the Mac runs Sonoma 14 or newer. See the official Ollama macOS requirements.

Step 4: Connect Kapinote and download the model

Kapinote reads Ollama's state for itself, so there is nothing to type here and no Terminal to open.

During first-run setup: at step 4, Configure your AI model, choose Use a model on this Mac. There is no provider list to search — that answer leads straight to Ollama.

Afterwards: Settings → AI Model, the Local tab, then Settings on the Ollama card.

Either way you get the same panel:

• A status line reading Ollama is running. If it says Ollama not found, Ollama is either not installed or not open — the Download Ollama button covers the first case, opening the app covers the second, then use Check again.
• A Model field, already filled in. Kapinote chooses from the memory in this Mac, following the same table as Step 2, and lists everything already on disk as one-click buttons.
• A download button when the chosen model is not on this Mac yet, labelled with its size: Download qwen3.5:4b · 3.4 GB. It downloads through Ollama with a progress bar. Nothing starts until you click it.
• Base URL under Advanced, which a normal local setup never needs to open.

Then:

1. If you started a download, wait for it. It is several GB, and an interrupted transfer resumes where it stopped.
2. Click Verify. The first one is slow, because the model is read off disk before it answers anything. Kapinote allows five minutes for a local model rather than the one minute it gives a cloud API, so there is no need to warm the model up yourself.
3. Click Save. During first-run setup there is no separate Save — verifying already stores the configuration. Either way Ollama becomes the active provider, a check mark appears on its card, and there is no further step.
4. Generate a summary from a short meeting, or ask one simple question, to complete an end-to-end check.

Ollama's local API listens on localhost:11434. Change the Base URL only when you deliberately host Ollama on another computer. For a normal local setup, do not append /api and do not paste a proxy address found online.

If you prefer the Terminal

None of the above needs it. It is still the quickest way to see what is on disk, and downloading a model there works just as well.

1. Press Command + Space, type “Terminal”, and press Return.

2. Download a model:

   ollama pull qwen3.5:4b

   A changing percentage means it is progressing normally.

3. Check that it answers on its own, which separates an Ollama problem from a Kapinote one:

   ollama run qwen3.5:4b --think=false

   Ask it anything, then type /bye to leave. --think=false matters: without it Ollama has the model reason at length before every answer, which Kapinote does not do, and the model will seem far slower here than it is in the app. See About thinking mode.

4. List what is installed. A model name typed into Kapinote by hand has to match one of these exactly, colon and tag included:

   ollama list

About thinking mode

Every Qwen model in Step 2 is a thinking model: given the chance, it writes out a chain of reasoning before it answers. Ollama enables that by default for every model that supports it, and it is not cheap. Measured on an M5 Pro, qwen3.5:4b answers a bare "hi" in 11.1 seconds with thinking on and 0.64 seconds with it off — 528 generated tokens against 27, because 500 of them were the model thinking to itself.

On a Mac with less memory bandwidth the same reasoning takes proportionally longer, which is where a "local models are unusable" impression usually comes from. It is rarely the model size.

Kapinote disables thinking on every request, so there is nothing to configure. Two things follow:

• The same model will feel much faster in Kapinote than in ollama run, which leaves thinking on. Add --think=false in Terminal to compare like with like.
• Kapinote never shows or stores a model's reasoning — it is discarded rather than folded into a summary, which is exactly why leaving it on would only cost time.

Thinking cannot be turned off in a Modelfile, and Qwen ignores the low / medium / high levels that the same setting accepts for some other model families — it reasons at length regardless. Only the on/off form has any effect, and Kapinote already sends it.

About the context length

Ollama serves every model with a fixed context length, and its default comes from available memory rather than from what the model accepts: below 24 GB it is 4k tokens, roughly ten minutes of meeting. The Qwen models in Step 2 all accept 256k.

That default would quietly ruin summaries. A summary request sends an entire transcript, whatever does not fit is dropped before the model reads it, and nothing reports an error — the summary would describe only the end of the meeting and read as a weak model. Kapinote asks for a larger window on every request, so this is already handled and there is nothing to set up.

How much larger depends on the memory in this Mac, because the context is held in a KV cache allocated from the same memory as the model — a number picked for a desktop can stop a laptop from loading a model it used to run:

These bands are not the ones in Step 2, and they are not meant to be. The model table is about how fast a Mac can drive a model; this one is about how much memory the KV cache may take on top of it.

Two consequences worth knowing:

• If this Mac starts swapping during a summary, move down one model size in Step 2 rather than changing anything here.
• Setting OLLAMA_CONTEXT_LENGTH on Ollama's side does not change Kapinote's requests, which carry their own value. To override it — a very small Mac, or unusually long meetings — set KAPINOTE_OLLAMA_NUM_CTX and restart Kapinote.

Troubleshooting

If it still fails, first test the model with ollama run MODEL_NAME in Terminal. If Terminal also fails, troubleshoot Ollama first. If Terminal works but Kapinote verification fails, see Kapinote troubleshooting and generate a diagnostic report.

Privacy boundaries

• Downloading or updating Ollama and downloading model files requires internet access.
• When you use one of the local tags in the table and keep the Base URL at http://localhost:11434, Kapinote sends meeting text to the Ollama service on this Mac.
• Do not choose a model tag ending in :cloud; cloud models use Ollama's online service and are not fully local.
• If you change the Base URL to another computer or a company server, meeting text is sent to that address. Review that network's data policy yourself.

Model tags and download sizes can change as Ollama is updated. Before choosing another Qwen model, verify the exact tag in the Ollama Qwen model library.