Run Local LLMs on a Mac mini M4 (2026): Ollama Setup, RAM Tiers and the Cloud Trap

Ollama can run models locally on an M4 Mac mini and expose a local HTTP API. Whether the setup is useful depends on the actual model tag, available unified memory and context length. A localhost API address alone does not make a workflow private when cloud models or external agent tools are involved.

The Mac mini M4 is a previous-generation option. This guide covers its 16–64GB configurations and the steps required to install Ollama, choose a model and verify local execution.

Model size, context length and the surrounding apps determine what feels usable on 16, 24, 32, 48 or 64 GB. The sections below also cover a safe Open WebUI setup and the boundary between local and cloud workflows.

Best way to run local LLMs on a Mac mini M4 in 2026

If you only have two minutes, here is the working path that covers almost every realistic Mac mini M4 setup.

1. Install Ollama and start the actual server. For the desktop app, use the official macOS download, install it and open Ollama.app. If you prefer the Homebrew CLI formula, run brew install ollama and then brew services start ollama (or start ollama serve in a terminal). The CLI formula does not install or open the macOS desktop app; these are two different installation paths. Confirm the running service with curl -fsS http://127.0.0.1:11434/api/tags. See Homebrew’s formula and Ollama’s macOS guide.

2. Pick a model that matches your unified memory.

Unified memory	Recommended first models	What to test, not guaranteed performance
16 GB	gemma4:e4b, qwen3.5:9b, qwen3.5:4b	chat, summaries, quick tests
24 GB	gemma4:12b, gpt-oss:20b	the better entry point; qwen3.8:27b only with short context
32 GB	gemma4:26b, qwen3.8:27b, muse-glimmer:30b	27B–30B packages may load; cap context and inspect memory pressure
48 / 64 GB (M4 Pro)	gemma4:31b, qwen3.6:35b	long context, vision and coding workloads

Model tags and sizes checked in the Ollama library on October 4, 2026: qwen3.5:9b 6.6 GB, gpt-oss:20b 14 GB, qwen3.8:27b 18 GB (released August 14, 2026), muse-glimmer:30b 18 GB (Meta, August 10, 2026).

3. Pull and run.

ollama pull qwen3.5:9b
ollama run qwen3.5:9b "Explain in five sentences what local AI on a Mac is useful for."

Newer 2026 model families are covered in Gemma 4 on Mac and the best open-weight LLMs for Mac. For an exact estimate with your model, quantization and context, use the Mac LLM RAM calculator.

4. Measure speed instead of assuming it. No M4 throughput or first-token-latency measurements were collected for this article. The same 4B or 27B model can behave very differently with a larger prompt, another quantization, a different Ollama release or memory pressure. Start with a short context, record model digest and ollama ps, then use the local benchmark below to report output tokens/s, prompt-processing time, total duration, load time and swap. A model that downloads or starts is not necessarily responsive enough for an agent.

5. Ollama vs. LM Studio. Both support many local GGUF models, but model availability, MLX support, multimodal behavior and tool calling differ by release and runtime. Ollama is a practical fit for CLI automation and a local API; LM Studio is often simpler for interactive GUI-based exploration. Running both can duplicate downloaded weights because their default model directories differ. Check the precise model format, runtime features and storage settings rather than assuming identical compatibility.

The sections below explain the memory math, context length, Open WebUI, the cloud trap and the most common mistakes. Use the table above as the short version.

When Ollama is a good fit

Ollama is a good fit if you:

• use a Mac mini M4 or M4 Pro,
• want to test local AI without a subscription,
• need to understand Ollama, LM Studio and MLX (see LM Studio vs. Ollama),
• do not want to paste private text into cloud models by default,
• want models for coding, summaries, research, study notes or small tools,
• want to know why 16 GB of unified memory can be useful but is not unlimited (background: Unified Memory on Mac).

The Apple Intelligence vs. local AI comparison covers the privacy and routing trade-off. The Best open LLMs 2026 article collects the current local model options.

The key decision: local, cloud or hybrid?

Ollama can now appear in several roles. That makes the wording important.

Mode	What happens?	Good for	Watch out
Local Ollama model	The model runs on your Mac	Privacy, offline work, learning, quick tests	RAM, model size, context and speed limit you
Ollama Cloud	Ollama workflow, but inference runs in the cloud	Very large models without local hardware	Not local; data is processed to provide the service
Open WebUI + local Ollama	Browser UI talks to localhost:11434	Comfortable chat, local collections, nicer UI	Secure WebUI and do not expose it publicly
Hybrid with cloud API	Local models plus Gemini, Claude or OpenRouter for special tasks	Large context, agents, hard coding tasks	Data leaves your device

My default workflow is simple: local models for private files and everyday tasks; cloud models only when model quality or context length matters more than fully offline processing.

Mac mini M4: realistic memory guidance

The Mac mini M4 is surprisingly strong for local AI, but unified memory is not magic. Model weights, KV cache, context window, macOS, browser tabs, Docker, Open WebUI and other apps all share the same memory pool.

If you are still choosing hardware, the Mac mini M4 local AI buying guide compares 16 GB, 24 GB and M4 Pro configurations, model sizes and ongoing costs.

Mac mini	Useful model class	Model examples to test (not verified fits)	Recommendation
M4, 16 GB	1B to 8B	Gemma 4 E4B; larger only after a RAM check	start small, keep context short and close unused apps
M4, 24 GB	4B to 12B/14B	Gemma 4 12B and selected 8B–14B variants	test your own context; 27B is not a safe default recommendation
M4, 32 GB	8B to 27B with caution	Gemma 4 26B, Qwen 3.8 27B as experiments	verify load, swap and speed before calling these usable
M4 Pro, 48 GB	12B to 35B more comfortably	Gemma 4 31B, Qwen 3.6 35B as test cases	context and runtime still need an explicit memory check
M4 Pro, 64 GB	27B and larger experiments	chosen 27B–35B models; 70B Q4 unproven	verify actual 70B file, context and app headroom before purchase

The model column is an estimate, not a measured compatibility test. The Mac LLM RAM calculator models weight quantization, an assumed KV-cache precision and space for macOS. Do not transfer its estimates between architectures or quantizations: actual attention/KV behavior, vision components, runtime allocations and concurrent apps can change RAM requirements substantially.

This is not a guarantee. Quantization, runtime, architecture and context length change real memory use a lot. Concrete configurations are listed in the Apple Mac mini tech specs.

If you are buying new: Apple currently sells the Mac mini with M6 or M5 Pro. According to Apple, the M6 offers 170GB/s versus 120GB/s on the M4; the memory classes above still apply.

U.S. purchase note: Apple currently lists the M6/M5 Pro Mac mini. Compare the 24GB configuration and U.S. pricing directly on Apple’s U.S. Mac mini page instead of relying on a German Amazon link. RAM and storage are different upgrade decisions.

Model recommendations by memory size

16 GB: start small, do not fight the machine

On a 16 GB Mac mini M4, the largest model is the wrong starting point. Start with small, fast models. You will learn the workflow faster and avoid swap-heavy frustration.

Good first tests:

ollama pull gemma4:e4b
ollama pull llama3.2:3b
ollama pull qwen3:4b

Example:

ollama run llama3.2:3b "Explain in five sentences what local AI on a Mac is useful for."

For 16 GB, a smaller model that runs smoothly is better than a larger model that constantly hits memory pressure. The official model library with current tags lives on ollama.com/library.

24 GB: the better entry point

24 GB is noticeably more comfortable for Ollama on Mac mini M4. You can test many 8B models and start trying 12B models, as long as you do not force maximum context immediately.

Good tests:

ollama pull qwen3:8b
ollama pull gemma4:12b

Example:

ollama run qwen3:8b "Create a short checklist for a safe local Ollama setup."

32 GB: larger models become more realistic

32 GB makes larger experiments more realistic. That does not mean every 27B model becomes comfortable in every situation. It does mean you have more room for model weights, context and normal macOS usage.

Good tests:

ollama pull gemma4:26b
ollama pull qwen3.8:27b
ollama pull muse-glimmer:30b

Example:

ollama run gemma4:26b "Compare Ollama, LM Studio and MLX for a Mac user."

gemma4:26b is a mixture-of-experts model: only about 4B parameters are active per token, so it answers quickly, but all 26B weights still have to fit in memory.

qwen3.8:27b and qwen3.6:27b are listed in Ollama’s model library at about 18GB and 18–19GB of download size, respectively. That does not establish identical KV-cache footprint, unified-memory use or tokens/s. For 27B–30B checkpoints, start with a short context and inspect actual memory pressure and ollama ps. Sources: Qwen3.8, Qwen3.6; muse-glimmer:30b is another local model option.

48/64 GB M4 Pro: more context, more comfort

With 48 or 64 GB of unified memory, Ollama becomes much more comfortable. Longer prompts, coding tasks and vision-capable models benefit. The rule still remains: context costs memory.

Availability (as of August 22, 2026): Apple has pulled the 64 GB M4 Pro configuration (and the M4 with 32 GB) from its store amid the global memory shortage; the tech specs still list both as configurable options. Check the current store selection before buying — existing devices are unaffected.

Good tests:

ollama pull gemma4:31b
ollama pull qwen3.6:35b

After starting a larger model, check:

ollama ps

Installing Ollama on macOS

The simplest installation path on Mac is the official macOS app. The full walkthrough lives in the Ollama macOS documentation, and the installer is linked at ollama.com/download/mac.

1. Download Ollama for macOS.
2. Open the .dmg.
3. Drag the app into Applications.
4. Start Ollama once.
5. Open Terminal.
6. Check the CLI:

ollama --version

Then pull your first model:

ollama pull llama3.2:3b
ollama run llama3.2:3b

To leave the chat:

/bye

First useful tests

Do not start with a massive prompt. First check whether the model, language, speed and memory behavior fit your machine.

ollama run llama3.2:3b "Rewrite this sentence in a casual tone and then in a technical tone: Local AI is useful, but not unlimited."

ollama run gemma3:4b "Explain the difference between RAM, unified memory and SSD storage to a beginner."

ollama run qwen3:8b "Write a short terminal checklist for a new Ollama setup on Mac."

Then check:

ollama ps

And list downloaded models:

ollama list

Context length: do not max it out blindly

The default context length is not a dependable hardware specification. Ollama’s context-length page currently gives hardware-dependent VRAM tiers (4K below 24 GiB, 32K at 24–48 GiB, 256K at 48 GiB or more), while the FAQ still mentions 4,096 tokens as a default. Mac unified memory, effective GPU allowance and your Ollama release can change the actual allocation. Rather than treating either page as a guarantee, inspect the CONTEXT column in ollama ps with the exact model loaded. If you are using the Mac app, its context-length setting also matters.

Concurrency caveat for agents: Ollama documents that parallel requests increase total context memory approximately with OLLAMA_NUM_PARALLEL × OLLAMA_CONTEXT_LENGTH. A setup that fits one 8K request may swap or queue when several agent workers submit prompts at once. Benchmark with one request first; raise concurrency only after checking memory pressure and actual context. Ollama FAQ.

Many model pages mention large context windows: 32K, 128K, 256K or more. That does not mean you should always use the maximum.

Context means how many tokens the model can keep in view. The larger the context, the more memory the KV cache needs. This can make the model slower or push macOS into memory pressure. Ollama explains the trade-offs in the Context Length documentation.

A practical starting point:

Task	Context guidance
short questions, study help, simple text	4K to 8K
longer articles, summaries	8K to 16K
coding with several files	16K to 64K
agents, large repositories, long documents	64K+, only when memory allows

Start ollama run qwen3:8b, then issue this command inside the interactive Ollama chat, not in the macOS shell:

/set parameter num_ctx 8192

This avoids abruptly terminating unrelated Ollama sessions. You can then increase context incrementally if memory remains available.

Open a second terminal for inspection while the chat remains open in the first:

ollama ps

If the Mac becomes slow, fans spin up, apps freeze or memory compression becomes aggressive, reduce the context. Larger is not automatically better.

Memory check: Model weights plus KV cache, runtime buffers, macOS and other open apps all compete for the same unified memory. Disk download size is not an in-memory requirement. Check the effective context in ollama ps and macOS memory pressure rather than choosing a model from its file size alone. Ollama FAQ.

The cloud trap: what to watch for

Ollama is known for local models. But there are also cloud models and cloud APIs now. That is not a problem, but it must be intentional. Ollama describes the split in its Cloud documentation.

Local

Typical local command:

ollama run llama3.2:3b

Local API:

curl http://localhost:11434/api/chat \
  -d '{
    "model": "llama3.2:3b",
    "messages": [
      {
        "role": "user",
        "content": "Explain local AI in two sentences."
      }
    ]
  }'

Cloud

Cloud models are usually signaled by cloud labels, cloud tags or by the endpoint you are calling.

Do not confuse:

http://localhost:11434/api

with:

https://ollama.com/api

The localhost endpoint connects to Ollama on your Mac, but the selected model may still route inference to the cloud (for example a :cloud tag). To verify local processing, choose a locally downloaded model, disable Ollama Cloud features and run the offline connectivity check. https://ollama.com/api is the separate hosted API.

Privacy: local does not automatically mean perfectly private

A local model is strong for privacy, but it is not magic.

What local use gives you:

• prompts do not have to go to a cloud provider,
• you can work offline once the model and tool are installed,
• you control models, versions and workflows,
• there is no per-token fee for local inference.

What can still go wrong:

• you accidentally use a cloud model,
• you expose port 11434 on the network,
• Open WebUI or another client stores chat history,
• your Mac is compromised through backups, sync tools or malware,
• you later paste sensitive data into a cloud model anyway,
• you download models from questionable sources.

My rule:

Local is a data flow, not a feeling. Check which model runs, which API you call and who can reach your Ollama server.

Port 11434: bind to loopback, not your network

According to the Ollama FAQ, Ollama binds to 127.0.0.1:11434 by default. Your Mac can reach the service; other machines normally cannot. Do not switch to 0.0.0.0:11434 just to make a WebUI container connect: that listens on all interfaces. Never put the raw API on a LAN or the internet without separately verified access controls.¹

After downloading a small model, inspect the endpoint and loaded models:

ollama list
curl --fail-with-body -sS http://127.0.0.1:11434/api/tags
ollama ps

ollama ps reports loaded, not all installed, models. A local API address alone does not guarantee local inference if the selected model tag explicitly uses Ollama Cloud.²¹

Turn off Ollama Cloud inference when local-only matters

The official FAQ documents disable_ollama_cloud in ~/.ollama/server.json. Preserve any existing file keys when adding the setting:

{
  "disable_ollama_cloud": true
}

Quit and restart the Ollama macOS app. The server log should contain Ollama cloud disabled: true. Alternatively, Ollama supports OLLAMA_NO_CLOUD=1; set app-server variables through launchctl setenv and restart the app. Exporting a variable in a random terminal will not reconfigure a macOS app already running. Local-only mode disables Ollama cloud models and web search, but not independent browser, MCP or agent tools.¹

Open WebUI: a browser UI without exposing Docker ports

A browser frontend is optional. For a single-user Mac, the official Open WebUI uv/Python quickstart is easier to keep bound to loopback than a container that must reach Ollama on the host.

With uv already installed, launch Open WebUI directly on macOS with persistent local data:

DATA_DIR="$HOME/.open-webui" uvx --python 3.11 open-webui@latest serve --host 127.0.0.1 --port 3000

Open http://127.0.0.1:3000. Both Open WebUI and Ollama now run on the host Mac, so the frontend can reach Ollama at http://127.0.0.1:11434. Create a strong administrator account; conversation history and settings may remain in DATA_DIR. Back up that directory before updating. The @latest package selector is moving; pin a specific tested Open WebUI release for reproducible setups. The Open WebUI quickstart also notes that the session signing secret must remain stable (WEBUI_SECRET_KEY or the same .webui_secret_key in the launch directory), otherwise users are signed out. Never publish the secret in a repository or screenshot. This is a local single-user example, not a public deployment.

Why the earlier Docker example was a poor private default: docker run -p 3000:8080 generally publishes the UI port on all host interfaces. A host-local-only port mapping would use -p 127.0.0.1:3000:8080. Separately, a container using host.docker.internal does not reach the host’s 127.0.0.1 loopback listener automatically. Open WebUI documents additional Docker networking instructions. Exposing an unauthenticated Ollama API to every network interface just to fix the connection is not a safe shortcut.¹³

Regardless of deployment method, audit tools, web search, backups, chat retention and API integrations. After the initial model download, test the local-only workflow with network connectivity disabled. For legitimate remote use, prefer a private VPN or an authenticated TLS reverse proxy.

Reproducible local benchmark: measure tokens per second, not shell startup

A stopwatch around ollama run is a poor inference benchmark. It mixes cold model loading, first-token delay, prompt processing and generated output; it also hides whether another process was competing for unified memory. Ollama’s official /api/generate response exposes these timings and token counts separately, all in nanoseconds.

Run the same local test three times

Prerequisites: Ollama running on the Mac, Python 3 installed, and a downloaded local model (start with ollama pull llama3.2:3b). This script uses only Python’s standard library. The first request warms up the model; three valid subsequent requests are required for the median. If the model was already loaded, the first request is not a cold start. Nothing is transmitted to a hosted model unless you deliberately change the endpoint or model choice. It refuses :cloud tags and model names absent from the local /api/tags list.

OLLAMA_BENCH_MODEL=llama3.2:3b python3 - <<'PY'
import json
import os
from statistics import median
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen

base = "http://127.0.0.1:11434"
model = os.getenv("OLLAMA_BENCH_MODEL", "llama3.2:3b")
if model.endswith(":cloud"):
    raise SystemExit("Cloud-tagged models are not a local benchmark")

def get(path):
    with urlopen(base + path, timeout=15) as res:
        return json.load(res)

try:
    installed = {x["name"]: x for x in get("/api/tags")["models"]}
except (URLError, KeyError) as error:
    raise SystemExit("Start local Ollama first: " + str(error))
if model not in installed:
    raise SystemExit(f"Pull this exact local model first: ollama pull {model}")

def generate():
    payload = {
        "model": model,
        "prompt": "List five practical checks before running an LLM offline.",
        "stream": False,
        "keep_alive": "10m",
        "options": {"num_ctx": 8192, "temperature": 0, "seed": 42},
    }
    req = Request(
        base + "/api/generate",
        data=json.dumps(payload).encode(),
        headers={"Content-Type": "application/json"},
    )
    with urlopen(req, timeout=180) as res:
        return json.load(res)

try:
    cold = generate()
    warm = [generate() for _ in range(3)]
except (HTTPError, URLError) as error:
    raise SystemExit("Request failed; check model name, RAM and server logs: " + str(error))
print("Model:", model, "context:", 8192)
print("Model digest:", installed[model].get("digest", "not reported"))
print("Quantization:", installed[model].get("details", {}).get("quantization_level", "not reported"))
print("First-request load (seconds):", round(cold["load_duration"] / 1e9, 3))
speeds = [
    r["eval_count"] / (r["eval_duration"] / 1e9)
    for r in warm if r.get("eval_count", 0) and r.get("eval_duration", 0)
]
if len(speeds) != 3:
    raise SystemExit(f"Only {len(speeds)} of 3 valid warmed-up speed samples; no median reported")
print("Warm output tok/s (median, n=3):", round(median(speeds), 2))
print("Warm total seconds:", [round(r["total_duration"] / 1e9, 2) for r in warm])
print("Prompt tokens:", [r.get("prompt_eval_count", 0) for r in warm])
print("Cached prompt tokens:", [r.get("prompt_eval_cached_count", 0) for r in warm])
print("Generation stop reasons:", [r.get("done_reason") for r in warm])
PY

Read the results this way:

• First-request load (s): load_duration / 1e9. If the model was already resident, this is not a cold model start. The first call is a warm-up, not a forced model unload/reload.
• Warm tokens/s: median of eval_count / (eval_duration / 1e9) for exactly three valid warmed-up requests. These are output tokens, not prompt tokens. A zero or missing duration invalidates that sample.
• Warm total seconds: includes time outside token generation and therefore differs from output-token duration.
• Prompt counts and cache: check prompt_eval_count and prompt_eval_cached_count; these can change the measured prompt-processing time.
• Model identity, processor and context: the script prints the digest and quantization from /api/tags. Run ollama ps while the model is loaded. Tags alone can point to updated files; preserve the digest and actual runtime for reproducibility.

Publication protocol: repeat with the same model digest, num_ctx=8192, temperature, prompt, Ollama/macOS versions, free memory and background load; report first-request load time and the median warm speed separately. Repeated identical prompts can benefit from prompt caching, so publish the cache counters as well. A score for llama3.2:3b does not describe qwen3:8b or gemma3:4b. Actual M4 test values are intentionally not invented.

Good tasks for Ollama on Mac mini M4

Ollama is especially useful for:

• summarizing your own notes,
• study help and flashcards,
• rewriting text,
• simple code explanations,
• local document analysis,
• privacy-sensitive drafts,
• offline brainstorming,
• small automations through the local API,
• comparing open-weight models.

Ollama is less ideal for:

• current web research without extra tools,
• very hard reasoning tasks,
• huge codebases with very long context,
• tasks where a top cloud model is much more reliable,
• workflows where speed matters more than privacy.

Recommended starter workflow

Step 1: Install a small model

ollama pull llama3.2:3b

Step 2: Run a first test

ollama run llama3.2:3b "Explain Ollama on Mac in three simple sentences."

Step 3: Check memory behavior

ollama ps

Step 4: Try a stronger model

ollama pull qwen3:8b
ollama run qwen3:8b "Create a checklist for local AI on Apple Silicon."

Step 5: Increase context only when needed

If the workload needs it, set /set parameter num_ctx 8192 inside the interactive ollama run qwen3:8b session. Then inspect ollama ps rather than killing and restarting the server.

Step 6: Add Open WebUI

Only if you want a browser interface.

Step 7: Define a private data rule

Before using the setup seriously:

• What may be processed locally?
• What may go to cloud models?
• Where are chats stored?
• Who has access to the Mac?
• Is port 11434 local only?

Common mistakes

Mistake 1: Starting with a huge model

Many users start with the largest model and then conclude that Ollama is slow. Start small and scale up.

Mistake 2: Maxing out context length

128K context sounds great, but it can hurt speed and memory. Use long context only for genuinely long tasks.

Mistake 3: Mixing up cloud and local

If privacy is the reason you use Ollama, do not casually treat cloud models as local.

Mistake 4: Exposing Open WebUI publicly

A nice web interface is not a security model. Keep it local or protect it properly.

Mistake 5: Confusing download size with memory use

An 8 GB model download does not mean the model only needs 8 GB of unified memory. Context, KV cache and runtime overhead matter.

A local-only verification checklist

Extra local-only checks for code agents:

# Does the local server respond?
curl --fail-with-body -sS http://127.0.0.1:11434/api/tags

# Check whether it listens beyond the loopback interface.
lsof -nP -iTCP:11434 -sTCP:LISTEN

# See which process is loaded and what context it actually uses.
ollama ps

An authenticated desktop chat UI does not make an exposed Ollama API safe by itself. Confirm the model is installed locally, Ollama Cloud is disabled in ~/.ollama/server.json, and every browser, MCP, web-search and remote tool is explicitly controlled. The best end-to-end check is to disconnect the Mac from the internet after the model download and repeat a real prompt. Ollama local-only FAQ.

Before routing sensitive files through an agent, check four things. Use ollama list to identify the exact downloaded tag; inspect ollama ps for the running model and actual context. Confirm that cloud features and external tools are disabled or explicitly authorized. Keep the API bound to 127.0.0.1; exposing the port to the LAN requires separate access controls.

Start with a small 3B–8B model and a bounded context. Increase size only after a reproducible prompt succeeds and you have checked actual memory pressure and output speed.

Primary docs reviewed October 10, 2026: Ollama FAQ, API timing fields and Open WebUI quickstart. Memory tiers are planning estimates; no actual Mac mini M4 benchmark was run. Memory tiers are planning estimates, not independently measured Mac mini M4 benchmarks.

Sources

Footnotes

1. https://docs.ollama.com/faq ↩ ↩² ↩³ ↩⁴

2. https://docs.ollama.com/cloud ↩

3. https://docs.openwebui.com/getting-started/quick-start/ ↩