Thoth

Prov1.1.0

A private, offline AI index over your notes, PDFs and boards

Thoth is a Pro app

It needs a free KimtOS account and a Pro subscription. Everything still runs on your device — Pro unlocks the app, it does not send your data anywhere. Install it without Pro and the app opens to an upgrade wall. See what Pro includes

Overview

Thoth is a private, offline knowledge base over your own content. It builds an on-device search index of the notes, task lists, PDF highlights and boards you already keep in the suite, then lets you ask a question in plain language and get the matching passages from your material — verbatim, with a cited AI summary on top. It is part of the kimtos new-tab app suite, and it is a Pro app.

Under the hood it is a retrieval-augmented generation (RAG) system, but everything a RAG pipeline usually sends to a server happens in your browser instead: the embedding model, the vector index and the language model that writes the answer all run on-device. Nothing is uploaded, there is no account, and there are no third-party calls.

Highlights

• Ask across everything you've written — one question searches your Notes pages, Tasks, PDF highlights and NotaBoard boards at once.
• Your notes, verbatim — the retrieved passages are shown in full under From your notes the moment retrieval finds them, and a click on a passage's header opens that item in its own app.
• A checked AI summary — the model writes a cited summary of those passages ([1], [2]), and Thoth verifies it: a number, time or figure the summary asserts that your notes never mention is flagged as invented, and when your content doesn't cover the question at all Thoth says so instead of guessing.
• Incremental indexing — rebuilding the index only re-embeds documents that are new or changed and drops ones you deleted, so repeat builds are fast.
• Fully offline — the search model (~23 MB) and the chat model download once, are cached by the browser, and then run with no network at all.
• Declared for a future assistant — Thoth also declares a search_knowledge agent tool, which would retrieve cited passages from your private index. No shipped model can run it, so it does nothing today.

What it indexes

Thoth reads only text you authored in other suite apps:

Source app	What is indexed
Notes	Each page's title and Markdown content.
Tasks	Each task's title and description.
PDF	Your PDF highlights and their comments (labeled by page).
NotaBoard	The text of a board's elements and sticky notes.

Each indexed document keeps a link back to the exact record it came from, which is what makes a citation clickable.

Privacy model

Thoth adds no new place your data can go — it only reads from, and writes a derived index into, the same local browser storage the rest of the suite uses:

• The index (text passages and their embedding vectors) is stored in your browser's IndexedDB, alongside a small set of content hashes used to detect changes.
• The search model and the chat model are downloaded from a model host the first time you use them, then cached locally; after that, asking a question needs no network.
• Nothing you index, ask, or receive as an answer is ever uploaded, and there are no analytics.

Getting Started

Open Thoth from the dock. Using it is a two-step rhythm: build the index once (and again whenever your content changes), then ask as many questions as you like. As a Pro app, Thoth shows an upgrade wall for free users before the app itself opens.

Build the index

At the top of the app a status line shows what's indexed so far — No index yet on first run, or something like 128 passages · 34 documents indexed once you've built it.

1. Click Rebuild index.
2. The first build downloads the on-device search model (~23 MB) — you'll see a Downloading search model… progress message. This happens only once; the model is cached for next time.
3. Thoth then reads your Notes, Tasks, PDF highlights and boards, splitting each into passages and embedding them. Progress shows as Indexing 3/34: <title>.
4. When it finishes you'll see a summary, e.g. Indexed 128 passages from 34 documents.

If you have no content to index yet, Thoth tells you so — add some notes, tasks, PDF highlights or boards first, then rebuild.

Rebuilding is incremental. After the first full build, later rebuilds only re-embed documents that are new or have changed since last time, and remove ones you've deleted. So it's cheap to click Rebuild index again after you've edited a note or highlighted a new PDF passage, to bring your answers up to date.

Ask a question

Once the index has content, type a question into the ask box — for example "What did I decide about the pricing model?" — and click Ask (or press ⌘/Ctrl+Enter).

Behind the scenes Thoth:

1. Embeds your question and finds the most relevant passages in your index (the retrieval step), and shows them immediately under From your notes — verbatim text from your own content, before the AI has said anything.
2. Loads the on-device chat model the first time you ask (Downloading AI model…, then Thinking…).
3. Streams back an AI summary of those passages, token by token.

If nothing in your index is relevant, Thoth says so rather than inventing an answer — and if the index is empty, it reminds you to build it first.

The passages are the answer; the summary is checked

The retrieved passages are exact quotes from your notes, so they are always right. The summary above them comes from a small on-device model, which can occasionally misstate a detail even with the passage in front of it — that is why it is labelled AI summary — check it against the passages below. Thoth also verifies the summary for you: any number, time or figure it asserts that appears nowhere in the retrieved passages is flagged with a warning naming the invented detail, so a misquoted date or amount never passes silently.

Read the citations

The summary cites its sources inline as [1], [2], and so on. Below it, the From your notes list shows each citation with its passage text — click the passage to expand it, or click its header chip like [1] Notes · Roadmap to open that item in its own app (Notes, Tasks, PDF or NotaBoard), so you can jump straight to the original context.

Agent tool (not active yet)

Thoth declares a search_knowledge tool, which would pull cited passages from your private index while the assistant answers. It does not run today: no shipped on-device model is reliable enough to call tools, so searching your knowledge base means opening Thoth.

Architecture

Thoth is a retrieval-augmented generation (RAG) pipeline that runs entirely on-device. The code lives in extension/src/apps/thoth/, and it leans on two shared engines — one for embeddings, one for chat — plus the suite's shared IndexedDB. Every module that makes decisions (what to index, how to chunk, how to score) is kept pure and free of storage or model imports, so the plumbing and the logic can be tested and reasoned about separately.

Modules

File	Role
index.ts	The app descriptor and UI — the index-status header, Rebuild index button, the ask box, the retrieved From your notes passages, and the streamed, grounding-checked AI summary. Also declares the search_knowledge agent tool.
grounding.ts	Pure grounding check over the generated summary (#913) — any number, time or figure it asserts that the retrieved passages (and question) never mention is reported as invented, reusing the numeric-fact scanner from lib/rephraseCheck.ts.
sources.ts	Pure mappers turning a raw stored record from each source app into a KbDoc (app, docId, title, text). Defines SOURCES — the collections indexed: Notes pages, Tasks todos, PDF annotations, NotaBoard boards.
chunk.ts	Splits a document into overlapping word-windows (default 180 words, 30 overlap) small enough to embed well but large enough to carry context. Pure.
plan.ts	Pure indexing decisions — an FNV-1a content hashString, docKeyOf (${app}:${docId}), and planReindex, which compares current hashes against stored ones to decide what to (re)index and what to drop.
indexer.ts	Orchestration — indexStatus, reindex (gather → plan → chunk → embed → store), and search (embed the query, cosine-match stored chunks).
search.ts	Brute-force cosine similarity and topK over the stored chunk vectors — a linear scan, plenty fast for a personal-scale index. Pure.
store.ts	The on-device vector store over the shared IndexedDB (dataStore): StoredChunk records in the thoth-chunks collection, plus the content-hash map. Vectors persist as Float32Array via structured clone.
lib/engines/embed.ts	On-device embeddings via Transformers.js — kimtos-labs/all-MiniLM-L6-v2 (ONNX/WASM), producing 384-dim L2-normalized vectors so cosine equals a dot product.
lib/engines/kimtai.ts	The on-device chat engine — a small instruction-tuned model (SmolLM2 360M by default) run in a Web Worker that streams the answer token by token.

The RAG flow

Indexing

reindex gathers every source document, computes a content hash for each, and asks planReindex what changed. Documents that are new or changed lose any old chunks and are re-chunked and re-embedded; documents you deleted simply have their chunks removed. Unchanged documents are skipped entirely, so a rebuild after a small edit only touches what moved. Each resulting chunk is stored as a StoredChunk — { id, docKey, app, docId, title, text, vector } — where docKey (${app}:${docId}) groups all chunks of one document and docId is what a citation uses to reopen the original record. The hash map is then written back so the next build has a fresh baseline.

Retrieval and answering

Asking a question runs the right-hand stages of the diagram. The query is embedded with the same MiniLM model, and topK does a brute-force cosine scan over every stored vector, keeping the best matches above a minimum similarity (the app retrieves 6 passages by default, dropping ones below 0.2 so unrelated chunks don't pad the context). The matching passages are shown immediately and verbatim under From your notes — they are the reliable part of the pipeline, and they stay up even if the model then fails. The same passages, formatted with their [n] labels and app/title, are handed to the on-device chat model behind a system prompt that tells it to answer using only that context and cite sources inline, at a low temperature. The summary streams back token by token and is then checked by grounding.ts: a small model can misstate a detail even with the passage in front of it, so a number, time or figure the summary asserts that the passages never mention is flagged as invented, with a warning pointing the reader at the passages.

The search_knowledge agent tool

The descriptor declares one MCP-shaped tool, search_knowledge, for a future on-device assistant (dormant today — no shipped model can call it). It would retrieve from the private index: it takes a query and an optional limit (default 6, max 12), checks that the index is non-empty, embeds the query, runs the same search, and returns the matching passages formatted with [n] citations for the model to quote. It is read-only — it never modifies the index — and if the index is empty it returns a message asking the user to build it in Thoth first.

Changelog

1.1.0 — 2026-07-22

• Asking now shows the retrieved passages from your notes verbatim, the moment they are found — before the AI has written anything, and even if the model then fails.
• The generated text is labelled as an AI summary and checked against the retrieved passages: a number, time or figure it asserts that your notes never mention is flagged as invented.

1.0.0 — 2026-07-08

• Initial release.