Upload one Markdown file and Claude can search, read, and write your Indenta notes — in your own browser, with nothing uploaded. Here is the complete skill.
· Productivity · 8 min read
Indenta keeps every note in your own browser. There is no account, no server, and no copy of your archive anywhere but your devices. That is the entire point of the app — and it's also the reason "connect my notes to an AI" normally isn't on the table. There's nothing for a model to connect to.
So Indenta does it the other way around. While the app is open in a tab, the page itself publishes a set of tools — search, read, create, append, rename, delete, open — and an AI agent running in your browser calls them. The notes never leave. What crosses the wire is the answer to one specific question at a time.
This article ships the piece that makes that pleasant to use: a Claude skill for Indenta. One Markdown file, uploaded once, after which you can say "find the note about the API migration in Indenta" or "append these action items to my standup note" and it just happens. Copy the block below and you're done.
Once the skill is installed, these all work as plain requests, with no setup per conversation:
[[wiki-link]] pointing at the old name is rewritten for you.The two things it deliberately makes awkward are deleting notes and replacing a note's whole body. Both are covered below, because that design choice is most of what separates a skill you keep from one you uninstall after it eats something.
An export before you start is cheap insurance. Indenta exports to plain Markdown files, and the backup rules apply here exactly as they do everywhere else — an assistant misfiring is just one more way to lose a note.
Save the file below as SKILL.md, then open Customize → Skills, click +, choose Upload a skill, and pick that file. Toggle it on afterwards — uploaded is not the same as enabled.
That's the whole installation. Nothing is compiled, and Claude loads the file on its own when a request matches the description in the frontmatter.
---
name: indenta
description: >
Read and write notes in the note app Indenta (indenta.app) from Claude.
Supports searching, viewing, creating, appending, rewriting, renaming, and
deleting notes. Use when the user names Indenta explicitly, e.g. "write this
to Indenta", "find it in Indenta", "show me the XX note in my note app",
"append to the meeting notes in Indenta". Do NOT trigger on a bare "take a
note" / "remember this" (the destination is undecided). Not for editing
Indenta's source code.
---
# Operating Indenta from Claude
Indenta is an offline app with no server; notes live in the browser's
IndexedDB. That means **the only way to touch the user's real data is to open
`https://indenta.app` in the user's own Chrome and call the tools the page
exposes.** While the app is open, `window.__webmcp` exists with the note
tools hanging off it.
## Workflow
1. Establish the connection (below)
2. If the task isn't decided yet, get oriented with `list_notes` / `search_notes` first
3. For writes, confirm the target note and content with the user before executing
4. Show the result on screen with `open_note`
## 1. Establish the connection
Use Claude in Chrome — `navigate`, `javascript_tool`, and
`tabs_close_mcp` are all this task needs.
- **If the extension isn't connected, stop there and ask the user to connect
it.** Do not open an in-app browser pane or localhost instead. Those are a
different browser profile where the IndexedDB is empty, so **every operation
"succeeds"** against nothing. Reporting zero visible notes as "there are no
notes" is the worst failure mode.
- Open `https://indenta.app` with `navigate`. Claude in Chrome can only see
its own tab group, so you cannot reuse a tab the user already has open. A
dedicated tab is fine (same profile = same IndexedDB, so the visible notes
are identical).
- Once open, check `typeof window.__webmcp`. If it's `undefined`, you're
still on the landing screen or pre-hydration. The bridge only appears once
the app itself has mounted, so wait a moment and re-check; if it still
doesn't appear, look at the screen and click through Get Started.
## 2. Calling the tools
`javascript_tool` evaluates REPL-style in the page context and **supports
top-level `await`**. One execution can call multiple tools, so batch reads to
cut round-trips.
```javascript
const r = await window.__webmcp.callTool('search_notes', { query: 'meeting notes' });
JSON.stringify({ err: r.isError, text: r.content[0].text })
```
The return value is `{ content: [{ type: 'text', text }], isError?: true }`.
On success `isError` is absent. `text` is often a JSON string, so
`JSON.parse` it when needed rather than eyeballing it raw.
**Don't memorize argument schemas.** When unsure, `window.__webmcp.listTools()`
returns name / description / inputSchema. That is the single source of truth
that's always correct; any spec copied here goes stale when the app changes.
Tools: `list_notes`, `search_notes`, `read_note`, `create_note`,
`update_note` (`mode: "replace" | "append" | "prepend"`), `rename_note`,
`delete_note`, `open_note`.
**Only adding lines? Use `append` or `prepend` — never `replace`.** A replace
rebuilds every block in the note, which resets the user's collapsed (folded)
rows across the whole note, including parts you never touched. Reserve
`replace` for genuinely rewriting the body.
## 3. Format for written content
Indenta is an outliner. Content that breaks this shape is not rejected — the
write boundary auto-structures it, but **lossily** (`#` headings are folded
into indent levels with their markers stripped, blank lines are dropped), so
what lands may not match what you sent. Follow these rules so the write is
predictable:
1. **Every line starts with `- `**
2. **Indentation is in units of 2 spaces** to express hierarchy
3. **No `#` headings.** Express structure with indentation
4. Links are `[text](url)`, note-to-note links are `[[Note name]]`, tags are `#tag`
```
- Meeting
- Decisions
- Release is next week
- Homework #todo
```
## 4. Choosing where to write
When told "write this down" with no note specified:
1. `search_notes` with keywords from the content to find a likely existing note
2. If found, **confirm first** ("append to XX?") and then write
3. If nothing matches, append to the Quick Note
Don't jump straight to creating a new note. Every extra note is later sorting
work for a human; appending to an existing note is almost always the right call.
## 5. Destructive operations
Notes sync to other devices via P2P / Google Drive. **What you delete on this
device disappears from the other devices too.** There is no undo, so follow
these rules.
- `delete_note`: confirm every time, naming the target
- `update_note` (`mode: "replace"`): first fetch the current content with
`read_note`, **show the lines that will be lost**, and get confirmation.
Never do a full replace without confirmation
- `rename_note`: get confirmation — it changes how the note appears everywhere.
(`[[Note name]]` links in other notes are rewritten automatically, so they
do NOT break)
- `create_note` / `update_note` (`append` / `prepend`): no confirmation
needed — they don't destroy existing content
**For operations spanning multiple notes, don't take blanket approval.
Confirm one note at a time.** A vague request like "clean up my old notes"
combined with blanket approval deletes 10× what was intended.
## 6. On failure
If `isError: true` comes back, **do not auto-retry.** Report the message
verbatim and stop. Blindly re-running a write double-writes when the original
actually succeeded. Error messages are human-readable and include remediation,
so read them before proposing the next step to the user.
Four of those rules exist because of specific ways this goes wrong with Indenta in particular. Worth reading before you trust it with anything.
The empty-profile trap. Indenta's notes live in one browser profile's IndexedDB. Point the same code at a different profile — an embedded preview pane, a localhost dev build, a fresh browser — and every tool call returns a clean, successful, completely empty result. Nothing errors. "You don't have any notes about that" is a plausible sentence and a catastrophic one if you have four hundred notes sitting in the other profile. The skill's first instruction is therefore to refuse to proceed on any browser but yours.
Append is safe; replace is not. Adding lines to a note is visible and reversible by eye. Replacing a note's body deletes whatever was there with no trace. The skill splits writes along exactly that line: appends, prepends and creates go through without ceremony, while replace and delete require you to see what's about to be lost first. Rename sits in between — nothing is destroyed and the links keep working, but it changes how the note appears everywhere, so it still asks. Notes in Indenta are meant to be cheap to rearrange — that only holds if rearranging can't silently drop things.
Sync makes deletion global. Indenta syncs device to device over WebRTC and optionally through Drive. A delete isn't local; it propagates to your laptop and your phone. There's no trash. Hence: confirm every delete by name, and never accept one blanket "yes" for a batch — that's the failure that turns "tidy up my old meeting notes" into forty gone notes.
The outline format is load-bearing. Indenta is an outliner, not a Markdown text box. Prose Markdown isn't rejected — the write boundary reshapes it into outline rows — but it does so lossily: # headings become plain rows at a matching indent level with the # markers stripped, and blank lines and horizontal rules are dropped entirely. Structure survives, the exact text you sent may not. The four formatting rules in section 3 exist so that what lands in the note is what the assistant meant to write, rather than a best-effort reconstruction of it.
Ask before you write, at least for the first few days. What did I decide about X? Where did I put the notes from that call? What have I written about this topic since spring? Retrieval is where most of the value is, it costs nothing when it's wrong, and it's the fastest way to learn whether the keyword search underneath finds what you'd find yourself. Then start writing with appends to notes you name explicitly, which is the harmless end of the write tools anyway.
There's no read-only mode to flip, and you don't really need one — section 5 is doing that job. Confirm-before-destroying plus an export sitting on disk covers the realistic failure, which isn't a rogue assistant, it's an ordinary misunderstanding about which note you meant.
And it's a text file. If a rule in it is wrong for how you work, edit the line.
Try it in practice: Indenta is a free, offline-first outliner — nested notes, backlinks, tags, and peer-to-peer sync, with no account required. Start writing in your browser, or read the User Guide first.