Capture

Capture anything the moment it occurs to you.

Capture is a fast, local-first web app for catching thoughts, ideas and tasks the instant they happen. One keystroke drops you into a focused capture overlay; an LLM auto-tags what you captured; a calm, responsive UI keeps everything organised by tag. An MCP endpoint lets agents add, search, edit, archive and delete captures without ever touching the UI.

Everything is stored in a local SQLite database — no third-party services, no account, no network beyond your LLM endpoint.

Features

• One-keystroke capture — press N (or click New) and a blurred overlay takes over. Enter adds a new line; Ctrl/⌘+Enter (or the Save button) captures. Works on desktop and mobile.

• LLM auto-tagging — new captures are tagged by any OpenAI-compatible chat-completions endpoint. The LLM has free rein: it prefers the default tags and any tag already in use, but may coin a new general tag (one or two words, never a sentence) when nothing fits. Tagging can be disabled; the capture is never blocked by the LLM (failures fall back to inbox).

• Three views — a board grouped by tag (for the visual), a chronological list with a tag filter (for the data-driven), and a force-directed graph that links each capture to the tag hubs it carries — click a tag to isolate its cluster and see where captures interconnect. Live search across content and tags in all three.

• Edit, archive, delete — editing reuses the capture overlay with an "Editing capture" context; archiving is instant with an Undo toast; deleting asks for confirmation first.

• MCP server — the six core functions are exposed over streamable HTTP at /mcp, so any MCP-capable agent can work with your captures.

• Runs as a service — capture install installs it as a background service on Linux (systemd), macOS (launchd) and Windows (Task Scheduler), with auto-restart on Linux and macOS.

• Single-file configuration — everything lives in settings.yaml, including the tag list, which is read from disk as needed: add a tag in the file and it appears in the UI, the LLM prompt and the MCP tools immediately.

Related MCP server: mcp-notes-server

Quick start

Requirements: Python 3.10+.

git clone <your-fork-of-this-repo> capture
cd capture
python -m venv .venv
source .venv/bin/activate
pip install -e .
cp example.settings.yaml settings.yaml   # copy the example config

capture                 # or: python -m capture

Then open http://localhost:8000.

• In the background: capture install sets up a service that starts at boot/login and keeps the app running — Running as a background service.

• From your phone: the app binds to 0.0.0.0 by default, so on the same Wi-Fi open http://<your-machine's-ip>:8000. Set server.host: 127.0.0.1 in settings.yaml to keep it local-only.

• CLI overrides: capture --host 127.0.0.1 --port 9000 --settings /path/to/settings.yaml.

The first run creates the SQLite database (data/captures.db by default).

Running as a background service

capture install installs the app as a service that starts at boot/login and keeps running in the background. capture uninstall stops and removes it again.

capture install                # per-user service (default; host/port from settings.yaml)
capture install --port 9000    # override the port (--host / --settings work too)
capture install --system       # Linux only: system-wide service (needs root)
capture uninstall              # stop and remove the service

How it works:

• The unit is generated with absolute paths (the interpreter you ran from, the project root, settings.yaml), so the service behaves exactly like the CLI. Keep the repo and its venv where they are — the unit points at them.

• Linux units restart the app automatically on crash (Restart=on-failure); the macOS LaunchAgent does the same via KeepAlive. The Windows scheduled task re-runs the app at each logon but does not restart crashes — a true Windows service needs a wrapper such as NSSM, which this tool deliberately avoids as a dependency.

• capture install refuses to start if the port is already in use, so you can't end up with two instances fighting over it.

Logs and status:

Notes:

• Linux: the user service runs inside your login session. To keep it running after you log out, enable lingering with sudo loginctl enable-linger <your-user> — the installer prints this hint when it applies.

• macOS: the agent lives at ~/Library/LaunchAgents/com.capture.app.plist; log files in ~/Library/Logs/capture/ are kept after uninstall.

• Windows: the task is created for the current user; no password is stored.

Using the web UI

Tags are multi-valued: a capture can carry several, and in the board view it appears under each. In the capture overlay you can pick tags manually — the picker lists the configured tags plus any the LLM has already coined. If you leave tags blank (on a new capture only) the LLM assigns one.

Configuration

All settings live in a single settings.yaml at the project root. The file is gitignored — your personal settings (host/port, LLM endpoint, tag list) stay out of the repo. On a fresh clone, create it from the bundled example (cp example.settings.yaml settings.yaml), then edit to taste:

server:
  host: 0.0.0.0        # bind address (127.0.0.1 = local-only)
  port: 8000

database:
  path: data/captures.db   # relative to the project root

llm:
  enabled: yes                     # no = skip the LLM, tag everything inbox
  url: http://localhost:8080/v1    # any OpenAI-compatible base URL
  model: qwen3.8-27b               # model name served at that URL

tags:
  - inbox
  - todo
  - idea
  - urgent

LLM auto-tagging

When a capture is added without explicit tags, Capture calls POST {llm.url}/chat/completions with a classifier prompt. The model sees the capture text, the default tag list, and the tags already in use across your captures — and must answer with a JSON object {"tag": "<tag>"}.

The LLM has free rein over the vocabulary:

• It prefers existing tags (the defaults, then anything already in use) so related captures share tags and stay consistent over time.

• It may coin a new tag when nothing fits, but is told to keep it general — one or two words, never a sentence or specific detail. The parser enforces this: a new tag that isn't one or two short words is rejected and the capture falls back to inbox.

• inbox is for text that genuinely resists any tag.

Guarantees:

• The capture is saved no matter what. If the LLM is down, times out (30 s), returns an unusable tag, or returns nothing parseable, the capture is tagged inbox (or the first configured tag if inbox isn't in the list). A failed LLM call is logged, never fatal.

• Reasoning models are supported. The completion budget is generous (512 tokens) so models that "think" before answering still fit their answer; the parser takes the JSON object (with a bare-word fallback).

• Manual tags always win. If you (or an agent) supply tags, the LLM is not consulted.

• The context is always current — the prompt is built from a fresh read of settings.yaml and a fresh query of the tags in use, on every capture.

MCP

The app serves a streamable-HTTP MCP endpoint at:

http://<host>:<port>/mcp

(point at the machine:port from settings.yaml — e.g. http://localhost:8000/mcp, or your LAN IP for agents on other devices).

Add it to any MCP-capable client. Generic config:

{
  "mcpServers": {
    "capture": {
      "url": "http://localhost:8000/mcp"
    }
  }
}

Tools

Example session:

> list_captures()
[{"id": 3, "content": "Idea: ...", "tags": ["idea"], "archived": false, ...}, ...]

> add_capture(content="Call the dentist tomorrow")
{"id": 4, "content": "Call the dentist tomorrow", "tags": ["todo"], ...}

> archive_capture(id=4)
{"id": 4, ..., "archived": true, ...}

REST API

The web UI is a thin client of this API — useful for scripting too.

curl -s localhost:8000/api/captures -H 'Content-Type: application/json' \
  -d '{"content": "Idea: ..."}'

curl -s -X PATCH localhost:8000/api/captures/1 -d '{"archived": true}'

Interactive OpenAPI docs: http://localhost:8000/docs.

Data & storage

A single SQLite file (database.path, default data/captures.db), WAL mode:

captures(
    id          INTEGER PRIMARY KEY,
    content     TEXT    NOT NULL,
    archived    INTEGER NOT NULL DEFAULT 0,   -- 0 = active, 1 = archived
    created_at  TEXT    NOT NULL,             -- ISO-8601 UTC
    updated_at  TEXT    NOT NULL
);

capture_tags(
    capture_id  INTEGER NOT NULL REFERENCES captures(id) ON DELETE CASCADE,
    tag         TEXT    NOT NULL
);

A capture keeps its full history: editing updates content/updated_at, archiving flips archived, only DELETE removes the row. Delete the file (and its -wal/-shm siblings) to wipe the store.

Project layout

capture/
├── settings.yaml           # all configuration (tags live here)
├── pyproject.toml
├── LICENSE                 # MIT
├── src/capture/
│   ├── cli.py              # `capture` CLI: run / install / uninstall
│   ├── app.py              # FastAPI app: REST API, static UI, MCP mount
│   ├── mcp_server.py       # the six MCP tools (streamable HTTP)
│   ├── llm.py              # auto-tagging (JSON contract, inbox fallback)
│   ├── db.py               # SQLite layer (WAL, capture_tags join table)
│   ├── service.py          # background-service install (systemd/launchd/schtasks)
│   ├── config.py           # settings.yaml loader (fresh reads for tags)
│   └── static/             # web UI: index.html, style.css, app.js (no build step)
└── data/captures.db        # created on first run (gitignored)

Development

Run with capture (or python -m capture) and reload the page after editing src/capture/static/*. Background-service commands work the same way: capture install / capture uninstall (or python -m capture install).

License

MIT — do whatever you want with it, no warranty.