Plume
How to Analyze Your Journal
With a Local LLM
To analyze your journal with a local LLM: install a runner like Ollama (or LM Studio, or llama.cpp), download a 7–9B open model such as Llama 3.1 8B, then either export your journal as plain text and pipe a month of entries in with an analysis prompt, or — if you journal in Plume on a Mac — point the app straight at http://localhost:11434/v1 and skip the export. Everything runs on your own Mac either way, so nothing is ever uploaded. Here is the full walkthrough, with the exact commands and eight prompts that actually surface useful patterns.
Why run the AI locally instead of pasting into ChatGPT?
Your journal is probably the most sensitive text you own. It is more revealing than your email, your messages, or your browser history, because it is the one place you write things you would not say to anyone. That makes "paste it into a chatbot" a bigger decision than it looks.
Nothing leaves your Mac
Local inference processes your entries in your machine's memory. No server ever sees them, no retention policy applies, no vendor can train on them. Turn off Wi-Fi and it still works, which is the proof.
Works offline
Once the model is downloaded, you can run a yearly review on a plane or in a cabin with no signal. There is no service to be down and no rate limit.
Free after setup
Open-weight models and the tools that run them cost nothing. Analyze your journal every night for a year and the bill is still zero, versus a $20/month cloud subscription.
The trade-off is capability: a model that fits on a laptop is weaker than a frontier cloud model. We cover exactly where that matters below, and when using cloud AI carefully is a reasonable choice. For journal analysis specifically, though, small models punch above their weight, because summarizing and pattern-spotting are things they do well.
Two paths, same privacy
Both paths start identically: a local runner and a model that fits your Mac, which is Steps 1 and 2 below. What differs is how your words reach the model.
Path A — export and pipe
Export a date range as plain text, then paste or pipe it into the model. Works with any journaling app that can produce plain text: Plume, Obsidian, Logseq, jrnl, Day One. Steps 1 through 4.
The portable skill. Learn it once, keep it whatever app you use next year.
Path B — no export needed
If you journal in Plume on a Mac, point its AI settings at http://localhost:11434/v1 and the analysis runs from inside the entry you already have open. No export file, no copy-paste, nothing leaving the machine.
Mac app only, opt-in, off until you turn it on.
Path A is how you run a twelve-month review and the only option in most apps, so it is written out in full first. Path B is the one you actually reach for on a Tuesday night, because the export step is friction and friction is how good habits die. Nothing stops you using both.
Both paths
Step 1: Pick a runner (Ollama is the easy answer)
A "runner" is the app that downloads a model and executes it on your hardware. As of September 2026, three options cover almost everyone:
| Tool | Interface | Price | Best for |
|---|---|---|---|
| Ollama (ollama.com) | Command line (plus a simple app) | Free, open source | Most people. One command to install, one command to run a model. This guide uses it. |
| LM Studio (lmstudio.ai) | Full GUI with chat window | Free for personal use | Anyone allergic to the Terminal. Browse models, click download, paste your journal into a chat box. |
| llama.cpp (GitHub) | Command line, maximum control | Free, open source | Tinkerers who want to tune quantization, context length, and sampling by hand. Ollama uses it under the hood. |
Installing Ollama on a Mac:
That second command drops you into an interactive chat with the model, running entirely on your Mac. Type /bye to exit. If this worked, the hard part is already over.
Both paths
Step 2: Which model fits your Mac?
The rule of thumb on Apple Silicon: the model (in its default 4-bit quantized form) should use no more than about half your unified memory, so the rest of your system stays usable. As of September 2026, these are sensible picks:
| Your Mac | Model size | Good choices | What to expect |
|---|---|---|---|
| 8 GB (base M1/M2/M3) | 2–4B | Llama 3.2 3B, small Gemma or Qwen variants | Fine for summaries and simple theme-spotting. Keep prompts short; close other apps. |
| 16 GB (the sweet spot) | 7–9B | Llama 3.1 8B, Gemma 9B-class, Qwen 7–8B | Genuinely useful analysis at comfortable speed. This is what this guide assumes. |
| 32 GB | 12–14B | Gemma 12B-class, Qwen 14B, Mistral mid-size | Noticeably better nuance and instruction-following, still fast. |
| 64 GB+ (Pro/Max/Ultra) | 27–70B (quantized) | Gemma 27B-class, Llama 70B-class, larger Qwen | Approaching last-generation cloud quality. Slower, but excellent for a deep yearly review. |
Model names and sizes shift every few months; treat the table as a snapshot as of September 2026 and check the Ollama or LM Studio model library for whatever the current 8B-class favorite is. For journal analysis, any recent instruction-tuned 7–9B model is more than adequate.
Path A · any journaling app
Step 3: Get your journal into plain text
LLMs eat plain text. Whether this step takes ten seconds or an evening depends entirely on which journaling app you use. (On a Mac, Plume can skip this step entirely — but the export path is worth knowing anyway, and it is the only path in most apps.)
-
Plume: open export, pick any date range (say, June 1 to June 30), choose which sections to include (gratitudes, memories, accomplishments, journal text), and copy it out as plain text. Save it as
journal-june.txt. No export fee, no lock-in; this workflow is exactly why Plume ships plain-text export. -
Obsidian, Logseq, jrnl: you are already done. Your entries are Markdown or plain-text files on disk. Concatenate a month with something like
cat "Daily Notes"/2026-06-*.md > journal-june.txt. This is why these tools show up in every local-AI journaling roundup. - Day One: export to plain text or JSON from settings, then trim the range you want by hand.
- Apple Journal: the weak link. As of September 2026 there is no practical plain-text export path, so your options are manual copy-paste per entry. If AI analysis matters to you, this is a real reason to journal somewhere with an exit door; see our guide to local-first journaling apps.
A note on where the file lives
The export file is your journal in the clear. Keep it out of cloud-synced folders (Desktop and Documents often sync to iCloud), and delete it when you are done. The model never phones home, but a text file in Dropbox defeats the point.
Path A · any journaling app
Step 4: Run the analysis
The whole workflow, numbered:
Export one month
In Plume: export June as plain text, save as journal-june.txt in a local folder.
Start the model
Run ollama run llama3.1, then paste your prompt followed by the month of entries. For small exports, paste-into-chat is all you need.
Or pipe the file in directly
One-shot analysis from the shell, no pasting:
Mind the context window
A month of daily journaling is typically 5,000–15,000 words, which fits comfortably. Ollama defaults to a modest context length, so for long months raise it inside the session with /set parameter num_ctx 16384 (or the equivalent slider in LM Studio). If the model starts "forgetting" the beginning of your entries, your context is too small or your excerpt too big.
Go bigger with map-reduce
For a year: analyze each month separately, save the twelve summaries to a file, then feed the summaries back to the model for the yearly review. Small models handle this two-pass approach far better than one giant paste.
LM Studio users: the equivalent is dragging journal-june.txt into the chat, or pasting it after your prompt. Same models, same privacy, just with a GUI.
Path B · if you journal in Plume on a Mac
The shortcut: point your journal straight at the local model
Ollama and LM Studio do not just run models — they also expose an OpenAI-compatible HTTP API on localhost. Any app that lets you type your own base URL can therefore use them. Plume's Mac app has exactly that option, so the export file, the folder, and the paste all disappear: the model reads the entry you already have open, and the answer lands in the same window. Setup is a one-time, four-minute job.
Leave the local server running
Ollama serves an OpenAI-compatible API at http://localhost:11434/v1 whenever it is running — the menu-bar app, or ollama serve. LM Studio does the same at http://localhost:1234/v1 once you start its local server from the developer tab. llama.cpp's llama-server also works; use whichever port you launched it on.
Settings → AI → Advanced
Turn AI on, open the Advanced toggle, paste that base URL, and type the model name exactly as your runner reports it — llama3.1 for Ollama, or whatever identifier LM Studio shows in its server panel. Save. A model on your own machine needs no API key, so leave that field alone.
Run it from the keyboard
In Zen Mode an AI toolbar appears with three prompt buttons on Cmd/Ctrl+Shift+1 through Cmd/Ctrl+Shift+3, and Cmd/Ctrl+Shift+4 drafts your Gratitude, Memory, and Accomplishments fields from what you have already written in the journal body. The same runtime is available in the Today view and the calendar entry editor. Each prompt's output can either append to the entry or replace it, so the analysis can live next to the writing that produced it.
Turn the prompts below into buttons
The three prompt presets are editable templates with a reset-to-default, which is the part that makes this worth setting up: the analysis prompts in the next section are not one-off pastes. Rewrite a preset as "list the recurring themes with a short supporting quote for each", save it, and from then on it is one keystroke on tonight's entry.
What this is, precisely
- Mac only. The AI settings and the Zen toolbar live in the Mac app. The iPhone and iPad apps have no AI UI at all, so treat this as a desktop workflow and use Path A if you want analysis on mobile.
- Off by default. The whole feature is opt-in. Until you enable it and enter an endpoint, Plume makes no network calls for AI whatsoever.
- No Plume model, no Plume server. Plume runs no AI service of its own and ships no model, and there is no Plume API key in the middle. Requests go from your Mac to the endpoint you named — on this path, your own localhost, which is why the analysis is as offline as the Terminal version.
- The same box accepts a cloud provider. OpenAI, Claude, Gemini, Grok, and Mistral all work in those settings, with the key held in the macOS Keychain rather than in plain text. That is a genuinely different privacy trade, and one to make on purpose — we walk through it in using cloud AI with a private journal.
- Same model, same limits. An 8B model inside a journaling app is still an 8B model: everything in what local models get wrong applies here too.
Eight analysis prompts that actually work
Prepend any of these to your exported text on Path A, or save them as editable prompt presets on Path B. The bracketed parts are yours to tweak.
1. Recurring themes
"List the 5 themes that appear most often in these entries. For each, give a one-line summary and quote two short passages that show it."
2. Mood trajectory
"Track my mood across this month week by week. Describe the trajectory, flag the best and worst stretches, and note what events coincided with each shift."
3. Gratitude patterns
"Look only at the gratitude entries. What categories do they cluster into (people, work, health, small pleasures)? What or who shows up most, and what never shows up that you'd expect to?"
4. Unfinished loops
"Find things I said I would do, decide, or resolve that never appear again. List each open loop with the date I first mentioned it."
5. Energy audit
"Which people and activities consistently precede entries where I sound energized? Which precede entries where I sound drained? Cite the evidence."
6. Stated values vs. actual time
"Compare what I say matters most to me in these entries with what I actually spend my days on. Where is the biggest gap?"
7. Yearly review (on monthly summaries)
"These are 12 monthly summaries of my journal. Write my year in review: the arc of the year, 3 turning points, what I struggled with all year, and what quietly got better."
8. Questions to sit with
"Based on these entries, what are the 5 most useful questions I should journal about next month? Don't answer them, just ask them well."
Want more raw material to write about first? See our journaling prompts library.
What local models get wrong (be honest with yourself)
Three real limits
- They are weaker than frontier models. An 8B model will miss subtle connections a top cloud model would catch, occasionally misattribute a quote, and sometimes confidently invent a "pattern" that is not in the text. Verify surprising claims against your actual entries before believing them; ask "quote the exact passages" as a habit.
- This is not therapy. A language model finding themes in your writing is a mirror, not a clinician. If your journal keeps surfacing anxiety, low mood, or anything heavier, the right next step is a professional, not a bigger model.
- Long context is the weak spot. Even models that advertise huge context windows degrade on long inputs, and small models degrade sooner. The month-at-a-time, map-reduce approach exists because of this, not as a style preference.
When is cloud AI acceptable? If you want frontier-quality analysis and are willing to share selected excerpts, the risk can be managed: use temporary chats, turn off model-training toggles, and only paste ranges you have consciously chosen. We wrote a full guide on doing this carefully in How to use ChatGPT with a private journal. The honest framing: local is the default for a whole journal; cloud is a deliberate exception for chosen excerpts.
Where your journaling app fits into this
Path A needs an app whose data you can get out. Path B needs an app that will talk to an endpoint you choose. Plume does both. Entries live in a local SQLite database on your device (no account, no cloud requirement, no data collection), and plain-text export lets you pick any date range and choose exactly which sections to include. Plume also runs no AI service of its own and ships no model: you point it at a provider or at your own machine, and when you do use a provider the API key is stored in the macOS Keychain rather than in plain text. The distinction matters, because it means you decide which words go to which model rather than an app quietly shipping your whole journal to a vendor's servers to power an "insights" feature.
If you are still choosing an app for this workflow, Obsidian and jrnl remain excellent — plain files, zero export step, and Obsidian's local-LLM community plugins are a genuinely good setup if you want a plain-file vault. We compare the field honestly in journaling apps that work with local AI and the best local-first journaling apps. The honest ordering for local AI specifically: an app that will speak to an arbitrary OpenAI-compatible endpoint is better than one that can only hand you files, which is better than cloud-only AI with no local option (Day One), which is better than no AI and no real export either (Apple Journal). Plume's other edge is that it is a structured daily journal (gratitudes, a memory, accomplishments, free writing) rather than a general notes tool, which makes both the exports and the in-app prompts unusually analyzable: prompt 3 above works precisely because gratitudes are a labeled section.
Frequently asked questions
Is analyzing my journal with a local LLM really private?
Yes. Ollama, LM Studio, and llama.cpp run the model entirely on your own hardware; your text is processed in RAM and never sent to a server. The simplest verification: turn off Wi-Fi and run the analysis again. It works, which proves nothing is being uploaded.
Can I use a local LLM inside my journaling app instead of exporting?
On a Mac, yes, if your app lets you set a custom endpoint. Plume's Mac app has an Advanced option under Settings → AI for any OpenAI-compatible base URL, so http://localhost:11434/v1 (Ollama) or http://localhost:1234/v1 (LM Studio) points it at a model on your own machine. The Zen Mode AI toolbar (Cmd/Ctrl+Shift+1–3) and field autofill (Cmd/Ctrl+Shift+4) then run against it with no export step and nothing leaving the Mac, and the three prompt presets are editable, so your own analysis prompts become buttons. It is opt-in, off by default, and Mac-only — the iPhone and iPad apps have no AI UI. Plume runs no AI service and ships no model, so the endpoint is always your choice; point it at a cloud provider instead and the key is held in the macOS Keychain.
Which model should I use on a 16GB MacBook?
As of September 2026, a 7–9B instruction-tuned model: Llama 3.1 8B, a Gemma 9B-class model, or Qwen 7–8B. In default 4-bit quantization they use roughly 5 GB, run at comfortable reading speed on Apple Silicon, and are plenty for summarizing and pattern-finding.
Is this free?
Yes. Ollama and llama.cpp are open source, LM Studio is free for personal use, and open-weight models cost nothing to download. Your only costs are 2–9 GB of disk per model and electricity. No tokens, no subscription.
Can a local model analyze a whole year at once?
Usually not reliably. A year of daily entries can pass 100,000 words, which overwhelms small models even when their context window technically allows it. Use map-reduce: summarize each month, then analyze the twelve summaries together for the yearly review.
Are local models as good as ChatGPT or Claude for this?
No, frontier cloud models are stronger at nuance and long inputs. But journal analysis leans on summarization and theme-spotting, which small models do well, and the privacy difference is absolute. Many people use local for the full journal and reserve careful cloud AI use for hand-picked excerpts.
How do I get my journal out of my app as plain text?
Plume exports any date range as plain text for free, and on the Mac you can skip the export altogether by pointing it at a local endpoint. Obsidian, Logseq, and jrnl already store plain files. Day One exports plain text or JSON from settings. Apple Journal has no practical export path as of September 2026, which is worth knowing before you commit years of entries to it.
A journal built for
this exact workflow
Plume keeps every entry in a local database on your Mac, iPhone, and iPad, and exports any date range as clean plain text. On the Mac it will also talk straight to a model running on your own machine, so the analysis never leaves the room. Your journal, your endpoint, your choice of AI.
Free for 21 writing days, then $19.99/year or $59.99 once. No account needed.