Mac mini + Claude + Obsidian: an honest second brain build

By Daniel S. · June 24, 2026

A small always-on Mac mini, your existing Obsidian vault, and Claude as the reader and writer. That's the whole stack. A working version costs well under $5 a month in API calls if you wire two specific levers most guides skip. This article walks the real build — hardware choice, MCP wiring, three loops, and the order that keeps them from quietly running up an unattended API bill.

The build pattern comes from Andrej Karpathy's "LLM Wiki" gist (github.com/karpathy, April 2026), with one important correction to the cost math and one shortcut for the wiring that newer Obsidian plugin builds make possible.

TL;DR

• Hardware: base Mac mini M4 — 16 GB RAM, 512 GB SSD, $799 as of June 2026 (apple.com/mac-mini/specs). 24 GB only matters if you also want to run a local LLM in parallel.
• Software: Obsidian + the Local REST API plugin (now ships its own MCP server) + Claude Code + ~200 lines of Python.
• Cost target: under $5/month for three always-on loops, if you use the Batch API (50% off) and prompt caching (cache reads at 0.1× base price). Without those, it's roughly 5–10× more.
• Build order: prove each loop manually in a Claude chat first; only script it after it's earned the second use. The mistake most guides bake in is shipping three half-working loops at once.

What this is actually for

A second brain isn't a smarter chatbot. It's a folder of plain markdown files that an always-on machine writes into on a schedule, so the work of capturing what you read — articles, lectures, podcasts — happens without you sitting at a keyboard. Three things change when you have one:

• You stop being the trigger. Today, if you want a summary, you open a tab, paste a URL, type a question. Close the tab and the work stops. The Mac mini doesn't need a hand.
• Your vault stays yours. Notes are plain text on disk you can open with any editor, point any future model at, and back up like normal files.
• Connections compound. The 50th note you add is more useful than the first because there are 49 existing ones for it to link to.

What it won't do: make you smarter, more disciplined, or richer. The brain helps you remember and connect material you actually consumed. Decisions still belong to you.

What you're building

Three layers, no fewer, no more.

The box. A Mac mini sitting somewhere quiet, plugged into power and Wi-Fi. macOS's launchd runs Python scripts on a schedule. The "always on" is the only part that matters — any small computer can do this; the mini is the cleanest fit because it's silent, low-power, and macOS's native scheduler is more reliable than cron for a machine that sometimes sleeps (Apple Developer — Scheduled Jobs).

The store. Obsidian. Every note lives on disk as plain markdown inside a folder you control — no proprietary database, no cloud account between you and your text. That ownership is the only reason the rest of the stack works: Python scripts open the files like any other text, agents write into the same paths, and a future model can read the vault without changing anything. Nothing is gated behind an API you don't own.

The brain. Claude via the API. Sonnet for reading and synthesizing, Haiku for tagging and grading, both billed per token. Local Whisper (via whisper.cpp) handles audio transcription so you're not paying per minute of lecture.

Glue between them: ~200 lines of Python total. If it grows past that, the loops are doing too much.

How much RAM do you actually need? 16 GB or 24 GB?

If Claude is doing the thinking (this build), 16 GB is enough. The mini's workload is light: Obsidian, a couple of Python scripts that mostly wait on the API, and Whisper transcription. The heaviest single process is Whisper on the medium.en model, which uses ~1.5 GB resident. Real RAM ceiling for the whole stack during a lecture transcribe is 6–8 GB. 16 GB leaves comfortable headroom.

24 GB is worth the upgrade only if you want to run a local LLM alongside — for example, an Ollama 7B model handling cheap tagging while Claude handles reasoning. A 4-bit quantized 7B model takes ~5 GB resident; with Whisper running too, the math gets tight on 16 GB.

For the Claude-only path, the saving from 16 GB pays for several months of API calls.

A pricing note that may date this article fast. Apple killed the $599 / 256 GB tier in May 2026; the base is now $799 / 16 GB / 512 GB (9to5mac). The driver is the AI memory-chip shortage; Apple has signalled further increases are possible. Re-check Apple's store the day you buy.

MCP wiring — two paths that work

You need an MCP server sitting between Claude and Obsidian. As of 2026 there are two working setups; the second is the one most existing guides describe, but the first is one step simpler.

Path A (recommended): the Local REST API plugin's built-in MCP server

The plugin now exposes MCP directly at https://127.0.0.1:27124/mcp/ with bearer-token auth (coddingtonbear/obsidian-local-rest-api). One step less than the older path.

1. In Obsidian: Settings → Community plugins → Browse → Local REST API → Install → Enable.
2. Open the plugin's settings and copy the API Key (the bare string, not the Bearer prefix).
3. From a terminal — Claude Code's works:

claude mcp add-json obsidian-vault '{
  "type": "http",
  "url": "https://127.0.0.1:27124/mcp/",
  "headers": { "Authorization": "Bearer PASTE-KEY" }
}'

Documented at code.claude.com/docs/en/mcp. Test with: "list every file in my Obsidian vault." If files come back, the wiring works. If it errors on the certificate, the plugin settings have a one-click cert install for your keychain.

Path B (fallback): the uvx mcp-obsidian indirection

This is the path most existing guides describe. Slightly more moving parts but works if Path A's self-signed cert is causing problems:

claude mcp add-json obsidian-vault '{
  "type": "stdio",
  "command": "uvx",
  "args": ["mcp-obsidian"],
  "env": {
    "OBSIDIAN_API_KEY": "PASTE-KEY",
    "OBSIDIAN_HOST": "127.0.0.1",
    "OBSIDIAN_PORT": "27124"
  }
}'

Uses MarkusPfundstein/mcp-obsidian as a stdio MCP server wrapping the same REST API.

Either way, you're wiring Claude to the plugin, and the plugin to the vault. Obsidian has to be running for the connection to work — that's the constraint people forget.

The loop pattern that keeps this from running up your bill

The thing that separates a chat tab from a working agent is the loop contract. Every workflow on the mini has the same five-part shape:

TRIGGER  — schedule or a new file (never "you opened a tab")
DO       — the work, single-purpose
VERIFY   — a hard, programmatic check (not the model grading itself)
ITERATE  — fix the weakest verify failure, retry
STOP     — pass, OR retry-cap, OR cost-cap. All three. Always.

The verify rule is where most homebuilt setups fail. "Did the model produce something useful?" is not a rule. "Output has all five H2 sections AND at least one [[wikilink]] to an existing note title AND all tags drawn from a fixed taxonomy file" is a rule. The model can't talk its way past a regex.

The stop conditions are the safety net. Retry cap (3 attempts) protects you from infinite loops on a hard input. Cost cap aborts the call if estimated spend exceeds a per-run threshold. Day cap reads a CSV of today's spend and refuses to start new calls past a daily limit. Without all three, a single bad input — a paywall, a broken transcript, a hallucinating model — bills you all night.

What it costs (with the levers most guides skip)

Claude API pricing as of June 2026 (Anthropic pricing):

The two levers existing second-brain guides rarely mention:

• Batch API: 50% discount. The article and lecture loops don't need real-time response — they can queue and process every few hours. Wrap the calls in the Batch API and the bill halves. Same model, same output, half the price.
• Prompt caching. Cache reads cost 0.1× base. Every loop here re-reads the same taxonomy.md plus a list of existing note titles on every call. Cache them, and input cost on the cached portion drops by ~90%. After the cache warms, a per-run input bill of $0.005 becomes $0.0005.

Worked example for 10 articles a day on Sonnet, with both levers on:

• 10 articles × ~5K input + 1K output tokens, taxonomy + titles (3K tokens) cached
• Per call: cached input ~$0.0009 + fresh input ~$0.006 + output ~$0.008 = ~$0.015
• Batched (50% off): ~$0.0075 per call
• Daily: $0.075. Monthly: ~$2.25.

Add lectures (one a day, two-pass: Haiku for chapters then Sonnet on the structured JSON): under $1/month at this volume.

Morning review loop (Haiku-only, picks 3 notes, generates spaced-repetition questions): cents per month.

Total target for the three loops: under $5/month. The classic "few dollars a month" figure floating around in second-brain content is achievable but only with these levers; without them you're at $20–50/month for the same loops.

Log every call's usage to a costs.csv at the vault root. Don't estimate from token math; the API tells you.

The build order that doesn't blow up

The same four steps work whether you ship one loop or all three:

1. Prove the loop in the chat first. Use Claude Code. Paste your prompt; include a hard verify rule (e.g., "must contain at least one [[wikilink]] to one of these titles: [...]"); ask Claude to iterate up to 3 times and stop with the result either way. If the output is useful enough that you'd run it again tomorrow, continue. If not, the schedule won't save it.
2. Turn the working prompt into a Python script. Read inputs from disk, call the API, write outputs to disk. No looping yet.
3. Wrap the script in the loop. Add the verify check (programmatic, not a model self-grade) and all three stop conditions (pass, retry-cap, cost-cap).
4. Then, and only then, put it on launchd.

A launchd plist with StartCalendarInterval will fire on every scheduled time and catch up the next time the machine wakes from sleep — which cron doesn't (Apple Developer docs). That matters for a Mac mini that occasionally goes to sleep.

Build the article-ingest loop first. Articles are short, fast to verify, and cheap. Lecture transcripts and the morning-review loop both have failure modes (bad audio, sparse vaults) that articles don't — solve those after the easy loop is boring.

Three workflows worth running

Loop 1 — article → note. URL drops into a file; the script fetches the article text, sends it to Sonnet with a structured prompt, gets back a five-section markdown note, verifies the structure, files it under Sources/Articles/. Cost: pennies per article.

Loop 2 — lecture → note. YouTube URL → yt-dlp pulls audio → whisper-cli transcribes locally → Haiku extracts chapters and candidate quotes from the long transcript → Sonnet builds the final note from the small structured JSON (not the full transcript). The two-pass split is what keeps lecture costs sane: full transcripts on Sonnet directly would be 4–6× more expensive.

For Whisper on Apple Silicon, brew is now the fast path:

brew install whisper-cpp ffmpeg yt-dlp
sh "$(brew --prefix whisper-cpp)/share/whisper-cpp/download-ggml-model.sh" small.en

Verified June 2026 against ggml-org/whisper.cpp. The brew build uses Metal + Neural Engine acceleration and runs ~2–4× faster than the Python openai-whisper package.

Loop 3 — morning brief. Scans the vault for notes touched 7 / 30 / 90 days ago. Haiku generates one spaced-repetition question per note plus a 3-bullet "what changed this week" digest. Runs at 6:30am, drops the result into the daily note, optionally pushes to your phone. Costs pennies per month.

Loop 3 only earns its keep once Loops 1 and 2 have been feeding the vault for a month or two. Shipping it early is the equivalent of asking yourself questions about three things you already know.

Skills, not from-scratch

For Obsidian-specific tasks (writing Bases, JSON Canvas, well-formed front-matter), don't reinvent. kepano/obsidian-skills is five official Agent Skills published by the Obsidian CEO (Steph Ango), at ~36K GitHub stars as of June 2026. They teach Claude Code how to write Obsidian's native formats correctly. Install when you reach a project folder that would benefit — typically month 2, not month 1, because you want to feel what Claude can and can't do unaided first.

When this won't help

A few honest limits:

• If you don't read much, it has nothing to ingest. The brain compounds on input. If you're not putting articles, lectures, and notes in front of it, an empty vault doesn't become a smart one.
• If your "second brain" idea is "Claude as a memory upgrade for chats," the MCP setup costs more than it saves. Use Projects instead.
• Sensitive material. The Claude API path sends your captured content to Anthropic. For legal, medical, or NDA-bound material, run the loops against a local model via Ollama instead. The architecture stays the same; only the brain layer swaps.
• "It'll make better decisions for me." It won't. It can surface what you already wrote down when you ask. Decision quality is on you.

FAQ

Do I need a Mac mini specifically? No. Any small computer that stays on works — a Linux mini PC, a Raspberry Pi 5 with enough RAM, an old laptop with the lid closed and lid-close-sleep disabled. The mini wins on silence, power draw, and the macOS-native scheduler. If you already have a working always-on Linux box, use that.

Will this work with Claude Pro instead of API tokens? The MCP wiring uses Claude Code, which is available on paid Claude plans. Scheduled loops that run when you're not at the keyboard need the API, because Claude Code expects you to be in a session. Pro covers the manual phase (steps 1–2 of the build order); the API takes over once you script the loops.

Can I do this with a local LLM instead of Claude? Yes. Swap the API client for an Ollama call against qwen2.5:7b or llama3.2. You'll want 24 GB RAM minimum if you also want Whisper running, and quality will drop on synthesis tasks — local 7B models follow the verify rules less reliably than Sonnet, so expect more retries. The cost trade is real: $3–8/month electricity vs $0 in API tokens, against worse output quality.

What's the smallest version that's worth building? Loop 1 only. Article → note, running every two hours. Three hundred lines of Python total, $2/month at the cost levers above. If that feels useful for a month, the rest of the build pays off; if not, you've learned cheaply.

How do I keep this from quietly running up a bill? Three hard caps inside the script: per-run cost (abort if a single call estimates over the cap), per-day cost (reads a CSV of today's spend; refuses to start new calls past it), and retry cap (3 attempts then skip the input and log the reason). The day cap is the one most guides skip and the one that catches the runaway cases.

Last updated 2026-06-24. Time-sensitive: Mac mini base price, Claude API pricing, and the MCP CLI syntax all drift — re-check the linked sources the day you build.