Documentation

A periodical, composed from your own notes.

AgainPage reads your personal note vault and periodically composes an original edition — connecting ideas, resurfacing forgotten notes, and reflecting them back as something worth reading. It runs entirely on your machine.

Notes apps are great at capture and search, but poor at return. Knowledge goes in and rarely comes back out. AgainPage is a quiet periodical built from your own notes: on a cadence you choose, it composes an edition — a lead essay, thematic connections, standalone summaries, questions, and things to apply — generated from your material rather than a list of links.

It is deliberately local-first: a desktop app that runs its own database and talks only to the AI provider you choose, including a fully local one. Your notes never leave your machine unless you pick a remote model.

What makes an edition

• ·Composed, not collected. Original writing generated from your notes, not a feed of links.
• ·Reads across your whole vault. It embeds each note and clusters them into themes, so an edition can connect ideas written months apart.
• ·Click any note, read in depth. Every referenced note is clickable — a slide-in drawer shows a rich standalone summary, generated on demand.
• ·On your schedule. Choose a delivery time and cadence; a live helper tells you when the next edition lands.

Quick start.

You're setting up two things: the engine — the "newsroom" that reads your notes and writes your editions, running on one computer that stays on — and the reader app you actually read in. To let your phone reach the engine safely we use Tailscale: a private, invite-only tunnel between your own devices.

Part A · Start the engine

Do this once, on the always-on computer (a laptop, a spare Mac/PC, or a home server).

1. 1Install Docker Desktop — this is what runs the engine. Grab it from docker.com, install, and open it once so it's running (you'll see a whale icon).
2. 2Get the AgainPage code. Open the Terminal app and run these one line at a time.
3. 3Tell it where your notes are — create a file named .env in the Againpage folder (see below).
4. 4Turn it on and wait about a minute. The engine is now running. 🎉

git clone https://github.com/Kushalrock/Againpage.git
cd Againpage

Create .env with two lines (use your real notes path):

VAULT_PATH=/Users/you/Documents
POSTGRES_PASSWORD=make-up-a-password-here

docker compose up --build -d

To update later: git pull && docker compose up --build -d. If it ever gets stuck: ./scripts/clear-jobs.sh.

Part B · Set up the private tunnel (Tailscale)

1. 1Install Tailscale on the engine computer and sign in (Google / GitHub / email — free for personal use). Downloads at tailscale.com/download.
2. 2Install Tailscale on your phone and other devices too, signed in with the same account — that's what puts them all on one private tunnel.
3. 3On the engine computer, run the two commands below. It prints a web address like https://yourcomputer.tailXXXX.ts.net — copy it; that's how your other devices reach the engine.

tailscale up
tailscale serve --bg 8000

Part C · Install the reader app

Download the app for each device from the releases page:

macOS only — one extra step. Because the app isn't from the App Store, macOS may say it's "damaged". That's expected. Drag AgainPage into Applications, then run this once to clear the block:

xattr -dr com.apple.quarantine /Applications/Againpage.app

Android only. When installing the .apk, your phone asks to "allow installing unknown apps" — say yes (you can turn it back off afterwards).

Open the app and connect it. On first launch it asks for the Engine URL:

• ·Same computer as the engine → http://localhost:8000
• ·Phone or another device → paste your Tailscale address from Part B (https://yourcomputer.tailXXXX.ts.net)

Finish setup in the app. Add your notes folders by name under /vault/. If Documents holds Vault1, Work Notes, and Journal, add each one:

/vault/Vault1
/vault/Work Notes
/vault/Journal

Add as many as you like — the engine reads across all of them. Then go to Settings → AI source, paste your OpenRouter key (get one at openrouter.ai/keys), pick your models, hit Test connection, and save. Editions start composing on your schedule.

You only set up once

The engine remembers everything — notes folders, API key, models, schedule — because all of that lives on the engine, not the app.

• ·First device you install the reader on: go through the full onboarding (Engine URL → notes folders → AI key). This configures the engine.
• ·Every device after that: just install the app and paste the same Tailscale address. It sees setup is done and drops you straight into reading — no folders, no keys, no re-onboarding.

The only per-device setting is the Android "notify me when an edition is ready" toggle — that one's local to each phone.

Staying safe

If Android "can't reach the engine"

Choosing your AI.

AgainPage uses models you control. Embedding, summarisation, and the writer model are each selectable — all configured in-app, no config files.

OpenRouter — hosted

Paste one API key and reach the best frontier models. Your notes are sent only to the model you choose, only when an edition is composed. Covers both writing and embeddings.

Ollama — fully local

Run models on your own machine, fully offline. With a local model an edition can be composed with the network disconnected — nothing leaves your device. Pull an embedding model (nomic-embed-text) and a chat model to get started.

Mix & match

Set the embedding, summarising, and writing models independently — a local model for one step, a frontier model for another. Any combination you like.

Using the reader.

The reader is the front end — desktop and Android — that talks to your self-hosted engine. Here's what you'll find once it's connected.

Reading

• ·Today's edition — a composed issue built from your notes: a theme, an anchor piece, fresh notes, and "connections" drawn between ideas, tuned to your chosen reading length.
• ·Archive — browse every past edition, with an Active / Inactive / All filter and per-edition active/inactive and favourite toggles.
• ·Favourites — a dedicated view of your starred editions, independent of active/inactive.

Settings

• ·Notes folders — point at your vault folder(s), exclude sub-paths, and watch a live sync-status line (e.g. 56 scanned · 54 synced · 2 failed · 12m ago) with a Retry.
• ·Preferences — cadence (every N days), delivery time + timezone, default reading length, notes woven per edition, and an Android "notify me when ready" toggle.
• ·AI source — provider (OpenRouter / Ollama / Custom), endpoint, models (embed / summary / writer), and write-only API keys; Test connection before saving.
• ·Advanced — re-index notes & embeddings, generate an issue now, cancel running jobs, set the auto-sync interval, and customise the editorial voice (writer + note-expand prompts) and note-expand word count.

Resilience

An onboarding wizard runs a live connection check against your engine. When the engine is slow or unreachable you get editorial Connecting / "newsroom isn't answering" screens rather than silent failures. And a version-compatibility gate catches a too-old engine or reader with a clear, full-screen page telling you exactly how to update.

Releases & changelog.

AgainPage is published as GitHub releases. The current build is the latest public alpha.

v0.1.4-alpha — alpha

The AgainPage reader app (alpha). Run the engine separately (Postgres + API + worker) with docker compose up --build -d, then open the reader and point it at the engine (defaults to http://localhost:8000). Reader builds for macOS, Windows, Linux, and now Android are attached to the release.

License.

AgainPage is source-available under the Functional Source License 1.1, converting to Apache 2.0 on 1 January 2029.

You may read the source, run it, modify it, self-host it for your own use, use it for non-commercial research or education, and build on it — for any purpose except competing with AgainPage.

You may not, before the Change Date, offer AgainPage (or a substantially similar substitute built from it) to third parties as a commercial product or service that competes with it.

The 2029 conversion

On the Change Date — 1 January 2029 — this software automatically becomes available under the Apache License, Version 2.0, with no further restriction. That grant is irrevocable and applies to every version released under this license, including versions released before that date.

Frequently asked.

Do my notes leave my computer?

No. Indexing and storage are local. Notes only reach a model provider if you choose a remote one; with Ollama, nothing leaves your machine.

What note formats are supported?

Markdown files (e.g. an Obsidian vault). Point it at one or more folders.

How often do editions arrive?

You choose: a delivery time and a "every N days" cadence. A countdown shows the next one.

Which AI models can I use?

Local models through Ollama, or hosted models through OpenRouter — set in-app. Embedding, summarisation, and writer models are individually configurable.

Is it open source?

Source-available today under the Functional Source License 1.1, converting to Apache 2.0 on 1 January 2029. See License.

Architecture.

A local-first desktop app: a Tauri shell wrapping a React reader, backed by a Python engine and a local Postgres with pgvector.

The pipeline

vault (.md files)
   │  scan + parse frontmatter/title
   ▼
ingest ─► summarise + embed each note ─► Postgres (pgvector)
   │
   ▼
cluster notes into themes (UMAP + HDBSCAN)
   │
   ▼
compose an edition (writer model) ─► reader renders it

Components

• ·engine — a FastAPI HTTP API (againpage-api) the reader talks to, and a background worker (againpage-worker) that runs ingest, embedding, clustering, and generation off a Postgres-backed job queue.
• ·reader — a React + TypeScript single-page app: editions, archive, onboarding, settings. Standalone in dev; bundled as the Tauri frontend in the desktop build.
• ·desktop — Tauri v2 shell packaging the reader + engine + a bundled Postgres into one installable app.
• ·infra — the local Postgres (image pgvector/pgvector:pg17).

Local dev setup.

A pnpm workspace (JS/TS) plus a uv-managed Python engine and a Cargo/Tauri desktop shell.

Prerequisites

• ·Node.js v24.x (see .nvmrc) and pnpm 10.30.3.
• ·uv + Python ≥ 3.14 for the engine.
• ·Docker for local Postgres + pgvector.
• ·Rust (stable) — only to build the desktop app.

First-time setup

pnpm install                 # JS deps, workspace-wide
cd engine && uv sync && cd ..  # Python deps → engine/.venv
pnpm db:up                     # start Postgres (pgvector) in Docker

Schema migrations apply automatically when the API or worker boots — there is no separate migrate command.

Run it (three terminals)

cd engine && uv run againpage-api      # http://127.0.0.1:8000
cd engine && uv run againpage-worker   # ingest / embed / cluster / compose
pnpm --filter reader dev               # http://localhost:5173

Open the reader, complete onboarding (pick a notes folder, choose a provider, paste a key), then trigger a re-index from Settings → Advanced. Provider keys are entered through the UI and stored write-only in the DB.

Contributing.

Contributions are welcome. The project practices TDD — write a failing test, make it pass, refactor — and keeps both the engine (pytest) and reader (Vitest) suites green.

Branch off main, make the change with tests, and run the full gate before opening a PR: engine pytest, reader test + lint + build. Match the surrounding code — naming, comment density, and idiom. Database access goes through raw parameterised SQL; schema changes are new numbered, forward-only migration files.

Security.

AgainPage is local-first and single-user by design. A couple of things are worth knowing before you deploy it beyond your own machine.

Your notes and derived data live only in the app's local data directory. Notes reach a model provider only if you choose a remote one. To report a vulnerability, follow the disclosure process in the repository's security policy.