Local AI Journaling: Private Daily Prompts & Mood Analysis

Published on April 23, 2026 · Updated August 23, 2026 · 14 min read

A local AI journal is three things: a folder of plain Markdown files, a small model running under Ollama, and two shell scripts — one that generates tomorrow's prompts from what you wrote this week, and one that reads the last seven entries on Sunday and writes you a synthesis. It runs on an 8 GB laptop, costs nothing per month, and because the model reads from disk rather than an API, your reflections never leave the machine.

The synthesis is the part worth building. Cloud journaling apps give you a calendar, a streak counter and sentiment icons; none of them will read what you actually wrote and tell you that you mentioned the same unresolved thing on four days out of seven. A 3B model on your own laptop will, because you control the prompt and it has the whole corpus.

Everything below is the stack: models, scripts, prompts, and the failure modes that make people abandon this after two weeks.

Quick Start: The Minimum Viable Setup

If you only want the working setup, here it is:

1. Install Ollama: brew install ollama on Mac, or curl -fsSL https://ollama.com/install.sh | sh on Linux.
2. Pull the model: ollama pull llama3.2:3b (2.0 GB, fits on any 8 GB machine).
3. Create the folder: mkdir -p ~/journal/{daily,weekly,prompts}.
4. Drop the morning script (below) into ~/bin/journal and make it executable.
5. Run it: journal. Three prompts appear. Type your answers. Save closes the file.

That is the minimum viable journal, and it is genuinely useful on its own. The rest of this guide adds voice input, mood tracking, weekly synthesis and Obsidian integration.

Table of Contents

1. Why Local Beats a Hosted Journaling App
2. The Stack: Models, Tools, Files
3. Hardware Reality Check
4. Step 1 — Install Ollama and the Model
5. Step 2 — Build the Daily Prompt Script
6. Step 3 — Voice Journaling with Whisper
7. Step 4 — Obsidian as the Front End
8. Step 5 — Weekly Reviews and Mood Trends
9. Prompt Library That Actually Works
10. Five Ways This Setup Fails
11. How This Compares to a Subscription App
12. FAQ

---

Why Local Beats a Hosted Journaling App

Cloud journaling apps share three problems:

Your entries sit on someone else's server. Before you type a divorce, a panic attack or a financial mess into a hosted text box, open the app's privacy policy and search it for "aggregate", "anonymized" and "service improvement" — those are the clauses that decide what happens to your words. Whatever they say today, they are a policy, not a technical guarantee, and policies change with ownership. Therapists hit this wall before the rest of us did — a local AI stack for therapy session notes exists for exactly the same reason, just with a licensing board attached.

Export is only as good as the schema. Most journaling apps export something, but they export it in their own structure. The minute you stop paying, the shape your reflections lived inside — prompts, tags, links between entries — is usually what you lose, even when the raw text survives.

You do not control what the AI does with it. Where hosted apps do offer AI features, you get the vendor's prompt, the vendor's model and the vendor's idea of what a weekly review should say. The synthesis is the most valuable part of journaling, and it is the part you most want to be able to rewrite.

A local stack solves all three. Plain Markdown files are forever. The AI is a 2 GB file you can copy to a USB stick. And because the model has unlimited access to your full corpus, the synthesis it produces is dramatically better than what a sentiment-analysis SaaS can do without seeing the words.

---

The Stack: Models, Tools, Files

This stack runs entirely offline. After the initial ollama pull and whisper-cli model download, you can airplane-mode the laptop forever and the journal still works.

---

Hardware Reality Check

Journaling is the least demanding local-AI workload there is: short prompts, short outputs, once or twice a day. The only question is whether the models fit in memory, and that is arithmetic rather than opinion.

weights (GB) ≈ parameters in billions × 0.6 at Q4_K_M, the default quantization

Floor: 8 GB of RAM. The 3B model fits with the operating system and leaves headroom; the 7B model also fits on 8 GB but you will feel the machine working. Comfortable: 16 GB, which lets both stay resident so the Sunday script does not reload anything.

Speed is bounded by memory bandwidth: ceiling (tok/s) = bandwidth (GB/s) ÷ model size (GB). On a laptop with roughly 100 GB/s of memory bandwidth, a 2 GB model tops out under 50 tokens per second, and a 4.4 GB model under 23 — both faster than you can read, which is why this workload does not need a GPU. On a low-bandwidth mini PC (around 40 GB/s) the weekly review is where you will notice the difference, because that is the only script that generates several hundred tokens at once. Those are ceilings from published bandwidth specs, not measurements; time your own machine once and you will know exactly where you sit.

---

Step 1 — Install Ollama and the Model

# Mac
brew install ollama
brew services start ollama

# Linux (Ubuntu, Debian, Fedora)
curl -fsSL https://ollama.com/install.sh | sh
sudo systemctl enable --now ollama

# Pull the journaling models
ollama pull llama3.2:3b      # 2.0 GB, daily reflection
ollama pull qwen2.5:7b       # 4.4 GB, weekly synthesis
ollama pull nomic-embed-text # 274 MB, semantic search later

Verify it is running:

curl http://127.0.0.1:11434/api/tags

If you get a JSON response listing the models, you are done. If you get connection refused, run ollama serve in a second terminal and check again.

For a deeper installation walkthrough, see the Mac local AI setup guide or the Linux local AI setup.

---

Step 2 — Build the Daily Prompt Script

This is the script that runs at 6:45 AM. Put it at ~/bin/journal and chmod +x it.

#!/usr/bin/env bash
set -e

JOURNAL_DIR="$HOME/journal/daily"
mkdir -p "$JOURNAL_DIR"
TODAY="$(date +%Y-%m-%d)"
FILE="$JOURNAL_DIR/$TODAY.md"

# Avoid overwriting an existing entry
if [ -f "$FILE" ]; then
  echo "Today's entry exists. Opening it."
  ${EDITOR:-vim} "$FILE"
  exit 0
fi

# Ask Llama for three context-aware prompts based on the last 3 days
LAST_THREE=$(ls -t "$JOURNAL_DIR"/*.md 2>/dev/null | head -3 | xargs cat 2>/dev/null || echo "")

PROMPT="Read the user's last three journal entries below. Then write exactly three short, specific morning journal prompts (one sentence each, no numbering, no preamble). The prompts should reference patterns or unfinished threads from the entries. Avoid generic prompts like 'how are you feeling'. Keep the tone calm, not therapeutic.

Recent entries:
$LAST_THREE"

QUESTIONS=$(echo "$PROMPT" | ollama run llama3.2:3b --format text 2>/dev/null)

cat > "$FILE" <<EOF
# $TODAY

## Mood (1-10):

## Energy (1-10):

## Three things I noticed yesterday:
-
-
-

## Today's prompts:

$QUESTIONS

## Free writing:


EOF

${EDITOR:-vim} "$FILE"

What this gives you: every morning the file already contains three prompts that reference what you wrote about earlier in the week. After three days of "I'm worried about the deck for Thursday," it stops asking generic things and starts asking "What is one slide on the Thursday deck you can finish before lunch?"

Wire it to a launchd job on macOS or a systemd timer on Linux so the file is waiting for you rather than something you have to remember to run. Generating three short prompts from three short entries is a few hundred tokens of work — fast enough on any machine that meets the floor above that you will not sit watching it.

---

Step 3 — Voice Journaling with Whisper

Some mornings you will not want to type. Voice journaling also tends to be more honest: typed entries get edited as you write them, spoken ones do not.

# Install whisper.cpp (Mac, Linux)
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp
make
bash ./models/download-ggml-model.sh small.en

The small.en model is about 466 MB and is the usual sweet spot for a single speaker in a quiet room; base.en is smaller and faster if you are on very modest hardware. Build with WHISPER_METAL=1 on Apple Silicon or WHISPER_CUBLAS=1 on an NVIDIA machine — acceleration is a much bigger speed lever here than model choice. The audio never goes anywhere: whisper.cpp reads the file, writes a transcript, and the LLM only ever sees text.

Wire it to a Karabiner shortcut or a Stream Deck button: tap to record, tap again to stop and dump the transcript into today's journal file. Working examples live in the whisper.cpp repository's examples folder.

---

Step 4 — Obsidian as the Front End

You can absolutely live in a terminal forever, but Obsidian gives you four things that matter for journaling:

1. Calendar plugin — see months at a glance, jump to any past entry.
2. Backlinks — when you mention a recurring topic ("the move," "Mom's surgery," "Q3 launch") it threads them automatically.
3. Daily Notes plugin — stops you from naming files inconsistently.
4. Templater — runs the prompt-generator script when you open today's note.

Point Obsidian at ~/journal as the vault. Install the Calendar, Daily Notes, and Templater community plugins. In Daily Notes settings, set the new file location to daily/ and the template to your prompt template.

If you go further with this, the local AI + Obsidian integration guide covers how to chat with the entire vault using AnythingLLM and embeddings — useful once you have 100+ entries and want to ask "what was the mood pattern in February?"

---

Step 5 — Weekly Reviews and Mood Trends

This is the feature no SaaS app gives you. Sunday at 8 PM, a second script reads all seven entries from the past week and writes a synthesis to ~/journal/weekly/YYYY-WW.md.

#!/usr/bin/env bash
WEEK="$(date +%G-W%V)"
OUT="$HOME/journal/weekly/$WEEK.md"
mkdir -p "$(dirname "$OUT")"

# Concat the last 7 daily files
ENTRIES=$(ls -t "$HOME/journal/daily"/*.md | head -7 | sort | xargs cat)

PROMPT="You are reading the user's last seven daily journal entries. Produce a private weekly review with these sections:

1. Three recurring themes (one line each)
2. Mood trajectory (improving / flat / declining, plus a one-line reason)
3. Open loops — things mentioned but not resolved
4. One question worth carrying into next week

Tone: a thoughtful friend who has actually read the entries, not a self-help bot. No emojis. No 'remember to be kind to yourself.' Be concrete and reference specific things the user said.

Entries:
$ENTRIES"

echo "$PROMPT" | ollama run qwen2.5:7b > "$OUT"

The shape you are aiming for — an illustrative example, not output from anyone's real journal:

Recurring themes: the Thursday board deck (mentioned 4/7 days), sleep quality (5/7), and a quiet anxiety about the SF trip in May.

Mood trajectory: improving — Mon and Tue were 4/10, Wed jumped to 6/10 after the run, Sat was 8/10. The pattern matches running days.

Open loops: you said Tuesday you would call Mom, no follow-up since. The "draft the resignation but don't send" line from Wednesday has not reappeared.

For next week: what would have to be true for the SF trip to feel exciting instead of obligatory?

That kind of synthesis is the entire reason to build this rather than install an app. It only works because the model has the raw text of every entry, which is precisely what a hosted service cannot give you without also holding the text.

For the script automation pattern, see the local AI automated reports guide — same architecture, different content.

---

Prompt Library That Actually Works

Drop these in ~/journal/prompts/ and have the daily script rotate through them on days when context-aware generation comes back too generic. They are written to be answerable in one specific sentence — vague prompts produce vague writing, which is the single most common reason a journal dies.

Morning (pick 1-3):

• What is the smallest possible version of today that would still feel like a good day?
• What did I avoid yesterday that would take 12 minutes today?
• Who do I owe a reply to that I have been pretending I forgot about?
• What would a mildly-disappointed-in-me version of myself notice this morning?

Evening (pick 1-2):

• What is one thing from today I want to remember in five years, and one I want to forget by tomorrow?
• Where did I lie to myself today, even slightly?
• What was the most interesting thing somebody else said?

Weekly (Sunday only):

• What story am I telling myself about this week that the data would not support?
• Which person did I think about most? Did they know?
• If I had to cancel three things on next week's calendar, which three?

These are deliberately specific. Vague prompts produce vague writing.

---

Five Ways This Setup Fails

1. Letting the AI rewrite your entries. It is tempting to have the model "polish" a rough morning entry. Do not. The value of a journal is that it is in your voice, and a polished entry is the model's voice wearing yours. Hard rule: the AI generates prompts and the weekly synthesis, and never touches the entry text.

2. Reaching for a bigger model. A 70B model is not better at asking you a question about your Thursday. It is just slower, and a script slow enough to be annoying is a script you stop running. Optimise for a model that responds fast enough that you never think about it.

3. No backup. The journal lives on one laptop, which is the whole point and also the whole risk. A nightly rsync to an encrypted external SSD plus a weekly tar | gpg --symmetric archive on a USB stick kept somewhere else covers it. The model can be re-downloaded; the entries cannot.

4. Styling instead of writing. An afternoon spent theming Obsidian is an afternoon with zero entries. The journal is the thing; everything else is procrastination with a progress bar.

5. Making it shareable. The moment an entry might be read by someone else, it becomes performance rather than reflection — and the weekly synthesis gets worse, because it is now summarising a performance. If you want a shared journal, keep it as a separate file with different prompts.

---

How This Compares to a Subscription App

Subscription prices change, so check the current figure for whichever app you are weighing up rather than trusting a number in a blog post. The structural differences do not change:

The savings are not really the point. The point is that the synthesis — the thing that makes journaling pay off — requires something to read every word you have written, and the only version of that which does not involve handing over every word you have written is the local one.

---

FAQ

Is local AI journaling actually private?

Yes, and it is verifiable rather than promised. Ollama loads models from disk and serves them on localhost:11434; whisper.cpp transcribes from a local file; entries are Markdown in a folder you own. The test is simple: put the laptop in airplane mode and confirm the whole workflow still runs. Nothing is transmitted because there is nothing to transmit to.

What is the smallest machine that runs this?

8 GB of RAM. Llama 3.2 3B is about 2 GB at Q4_K_M, which leaves room for the operating system and your editor. Weekly synthesis with a 7B model also fits in 8 GB but runs slower; on 16 GB you can keep both resident.

Which model should generate the prompts?

Start with Llama 3.2 3B — fast, and good at picking up threads from a short context. For the weekly review, where the model reads all seven entries at once, step up to Qwen 2.5 7B or Llama 3.1 8B for better long-context handling. Going above 13B for this workload buys you nothing you will notice and costs you speed you will.

Can the AI read my old entries to write better prompts?

Yes — that is what the morning script does, by concatenating the last three entries into the prompt. For recall across hundreds of entries you need retrieval rather than concatenation: embed each file with nomic-embed-text and pull the most relevant past entries in before generating. The Obsidian integration guide covers that setup.

How do I back up a local journal safely?

Two layers. Nightly rsync to an encrypted external SSD (APFS encryption on macOS, LUKS on Linux), and a weekly tar | gpg --symmetric archive on a USB drive stored somewhere other than your laptop bag. Back up the journal directory only — models are re-downloadable, entries are not.

Can I sync it between devices?

Yes, without a cloud: Syncthing does end-to-end encrypted folder sync directly between your machines, and each device runs its own Ollama. Avoid iCloud or Google Drive, which upload plaintext. If you must use a cloud sync provider, encrypt the folder with Cryptomator first.

---

Where to Go Next

• Set up Whisper for offline meeting transcription — same engine, broader use.
• Build a private second brain in Obsidian — worth doing once you have enough entries for retrieval to beat concatenation.
• Pick the right small model for your machine — if 3B feels limited.

The journal that survives is the one you actually open. The job of everything above is to make opening it lower-friction than opening a feed: the file already exists, the prompts are already in it, and on Sunday something has already read the week back to you.