Przejdź do treści
Biblioteka skilli
Produktywność osobista · Konwersja i formaty

remarkable-memory

/remarkable-memory

Zamienia odręczne notatki z reMarkable w przeszukiwalną pamięć semantyczną: czyta pismo przez Claude vision, wydobywa notatki z oceną pewności i zapisuje je w Filesystem, Google Drive lub Notion.

Repozytorium
claude-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
23.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 23.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Zamienia odręczne notatki z reMarkable w przeszukiwalną pamięć semantyczną: czyta pismo przez Claude vision, wydobywa notatki z oceną pewności i zapisuje je w Filesystem, Google Drive lub Notion.

Wyzwalacze z opisu

extract my notes about the Amsterdam music festival
Oryginalny opis (EN)

Turns handwritten reMarkable notes into a queryable semantic memory, on Claude Desktop. Pulls pages from a reMarkable tablet through a connected reMarkable MCP server (or remarkdown), reads the handwriting with Claude vision — no OCR key — and extracts each page into confidence-scored, provenance-tagged notes stored in a connected memory (Filesystem, Google Drive, or Notion). Clusters notes by topic and project, renders a clean HTML artifact per cluster, and answers plain-language questions over them ("extract my notes about the Amsterdam music festival", "show layouts inspired by my living-ro

Jak działa

  1. What you need connected
  2. Memory layout (in the connected store)
  3. Process
  4. Guidelines
Sekcje z nagłówków SKILL.md, w oryginale · 150 linii, 1 095 słów
Podgląd SKILL.md
---
name: remarkable-memory
description: >-
  Turns handwritten reMarkable notes into a queryable semantic memory, on Claude
  Desktop. Pulls pages from a reMarkable tablet through a connected reMarkable MCP
  server (or remarkdown), reads the handwriting with Claude vision — no OCR key —
  and extracts each page into confidence-scored, provenance-tagged notes stored in
  a connected memory (Filesystem, Google Drive, or Notion). Clusters notes by topic
  and project, renders a clean HTML artifact per cluster, and answers plain-language
  questions over them ("extract my notes about the Amsterdam music festival", "show
  layouts inspired by my living-room design from the past 20 days"). Flags
  low-confidence reads for review and learns your handwriting and shorthand from
  every correction. Use when the user wants to sync, extract, organize, search, or
  reason over their reMarkable notes and build a second brain from handwritten pages.
metadata:
  side_effects: true
  trigger: "Syncing, extracting, organizing, searching, or reasoning over reMarkable notes on Claude Desktop; building a second brain from handwritten pages."
  tags: "remarkable, memory, notes, handwriting, knowledge-base, second-brain, desktop"
---

# reMarkable Memory (Desktop)

Turn handwritten reMarkable pages into a queryable, confidence-scored memory —
clustered, cited, and rendered as clean HTML artifacts — right inside Claude
Desktop. This is the connector-based companion to the `/remarkable-memory` Claude
Code skill; both share one philosophy: **provenance always, low confidence
visible, corrections are the product, memory is human-editable.**

## What you need connected

Detect these at the start of every run and report what's present:

- **A source** — a reMarkable MCP server (e.g. `SamMorrowDrums/remarkable-mcp`) or
  `remarkdown` (hosted). This is how pages reach the conversation. Look for
  `mcp__*remarkable*` tools.
- **A memory store** — one persistence connector so the memory survives across
  conversations: **Filesystem**, **Google Drive**, or **Notion** (in that
  preference order). Without one, you can still extract and render for this
  session, but say clearly that nothing will persist.

```
Connected:
  ✅ Source:  reMarkable MCP (USB mode)
  ✅ Memory:  Google Drive  → folder "reMarkable Memory"
  ❌ Notion:  not connected
```

If no source is connected, stop and walk the user through connecting one:

```
Connect a reMarkable source (pick one):
  • reMarkable MCP server (free) — enable "USB web interface" on the tablet
    (Settings → Storage), plug in, confirm http://10.11.99.1 loads, then add the
    server in Settings → Connectors.
  • remarkdown (hosted, paid) — pair once with a code, add its connector. It hands
    pages to me as images I read directly (works well on Desktop).

Then add a memory connector (Filesystem / Google Drive / Notion) so the memory
persists across conversations.

⚠ After adding any connector, RESTART Claude Desktop — connectors load at startup,
so I won't see a just-added source until you relaunch.
```

Reality checks: USB/SSH are free; cloud sync needs reMarkable Connect (~$3.99/mo);
SSH needs developer mode, which factory-resets the tablet. The community cloud API
can change — if a sync breaks, that's usually why, not the notes.

**Extraction:** read each page as an **image** and transcribe it yourself. Claude
Desktop supports MCP sampling, but the image path is simplest and avoids any
server-side OCR key — use it.

## Memory layout (in the connected store)

Mirror the Code skill so a user can move between the two:

```
reMarkable Memory/
├── memory.json          ← index: notes, clusters, confidence, provenance, last_sync
├── notes/               ← one Markdown note per page (frontmatter + transcription)
├── clusters/<slug>/     ← cluster.md + a rendered HTML artifact
├── assets/              ← page renders + sketches/images
├── corrections.md       ← every human correction (the learning signal)
└── extraction-guide.md  ← learned handwriting/shorthand guide, read on every sync
```

Note frontmatter carries: `id`, `source` (notebook, page, doc id, modified, synced),
`confidence` (0-1), `type`, `tags`, `entities`, `cluster`, `assets`, `reviewed`.
Uncertain words stay inline as `⟨uncertain: word?⟩` — never silently guessed.

## Process

### 1. Sync

- Ask (or infer) the scope: a specific notebook ("Human Memory"), a project, or a
  time window ("last 20 days"). Echo a one-line plan and get a go-ahead.
- Pull each in-scope page through the source connector. Typed pages come as text;
  handwritten pages render to images. Pull embedded **sketches and images** too —
  "sync all assets from my Human Memory notebook" means the visuals, not just words.
- **Idempotency:** key each page by doc id + page + a content hash held in
  `memory.json`. Skip unchanged pages; never duplicate.

### 2. Extract (Claude vision + learned guide)

- Read `extraction-guide.md` from the memory store first; treat it as ground truth
  about this user's hand and shorthand.
- Read each page image directly. Produce clean Markdown, a `type`, an honest
  `confidence`, `tags`, `entities`, and a one-line summary. Mark uncertain words
  inline; flag anything below the user's threshold (default 0.75) for review.
- Write one note file per page into `notes/` and update `memory.json`.

### 3. Cluster

- Group notes by topic (default), project, or hybrid. Reuse an existing cluster
  when the subject matches; create a new one only when nothing fits. Write
  `clusters/<slug>/cluster.md`.

### 4. Render — HTML artifact per cluster

_A rendered sample of the cluster look lives in the Code skill at
`code/remarkable-memory/examples/human-memory-posts.html`._


Produce a **single self-contained HTML artifact** (no external scripts/fonts) with
light + dark support via `prefers-color-scheme`, using the site's vocabulary (dark
`#121212`, primary `#ff5722`, secondary `#03a9f4`, hairline borders, faint
surfaces). Each note is a card showing: the transcription, a **confidence badge**
(green ≥ threshold, amber below), the **provenance line** (📓 notebook · p.N ·
synced date), tag chips, and any asset thumbnail. Below-threshold cards get an amber
left border and a non-interactive "run review" hint.

**Thumbnails in the artifact must be inline.** A claude.ai artifact is sandboxed
(strict CSP, no local filesystem), so `assets/*.png` or `file://` paths won't load —
embed each thumbnail as a base64 `data:` URI directly in the `<img src>` (keep them
small; mind the artifact size budget). Alternatively omit images from the artifact
and keep them only in the persisted store. Also render a top-level index artifact: a
card grid of all clusters. Save the HTML back into the memory store so it persists.

### 5. Query

For a plain-language question, answer **from the memory, with citations** — never
invent a note. Honor filters in the ask (dates, cluster, entity). When the ask is
generative ("show layouts inspired by my living-room design"), retrieve the relevant
notes/sketches first, then synthesize new ideas clearly labeled as generated, naming
the source notes they build on. If an answer leans on a low-confidence note, say so.

### 6. Review & learning

- Surface low-confidence, unreviewed notes one at a time with their page image.
  Let the user confirm, fix the text, or re-cluster.
- On every correction, append to `corrections.md` (what you read → the fix → the
  one-line lesson). When a lesson recurs, promote it to `extraction-guide.md` so the
  next sync applies it. Tell the user what you learned. Both files are
  human-editable — respect direct edits.

## Guidelines

- **Detect, don't assume** — only use connectors that are actually present; never
  fabricate a note or claim a source is connected when it isn't.
- **Cite everything** — every card and every answer names the page it came from.
- **Confidence is honest** — flag what you half-read; mark uncertain words; don't
  guess to look confident.
- **Confirm before anything irreversible** — deleting or overwriting notes needs an
  explicit OK. `reset`-style actions never touch the user's memory store.
- **Graceful degradation** — if the source or a page fails, note it and continue
  with what you got; be honest about gaps in the render.
- **Privacy-aware** — handwritten notes are personal; keep summaries to what the
  task needs and don't over-quote on a shared screen.
Pliki w paczce (2)
  • SKILL.md 8 KB
  • icon.svg 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · mostafa-drz/claude-skills100MIT
mostafa-drz/claude-skills95MIT

Migawka bazy z 13.11.2026 · wersja paczki 59b51ec39fc7 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100remarkable-setup
    Konfiguruje krok po kroku tablet reMarkable i Maca do logowania kluczem SSH przez USB i Wi-Fi, oraz sprawdza lub naprawia połączenie.
  • 100screenshots-memory
    Synchronizuje zrzuty ekranu z wybranych folderów i zamienia je w przeszukiwalne notatki Markdown z kategorią i metadanymi.
  • 100send-to-remarkable
    Tworzy PDF w rozmiarze reMarkable z artykułu lub tekstu i wysyła go przez SSH teraz albo w kolejce.
  • 100convert
    Zamienia odręczne notatki w PDF, eksporty z tabletu i skany pisma odręcznego na edytowalny Markdown, w tym rysunki i schematy.
  • 100daily-planner
    Buduje modułowy jednostronicowy planer dnia na tablet e-ink i dostarcza go przez Folio: wywiad, dane z kalendarza, zadań, GitHuba i pogody oraz PDF dopasowany do urządzenia, takiego jak reMarkable czy Kindle Scribe.
  • 100remarkable
    Renderuje dokument Markdown lub Org do PDF do czytania na reMarkable Paper Pure w klasycznym stylu prac informatycznych, przez pandoc i tectonic.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.