Skip to main content
Glama
remarkable-mcp

remarkable-mcp

by sambt94

remarkable-mcp

An MCP server that gives Claude direct access to your reMarkable tablet's notebooks. Search documents, render handwritten pages to PDF, and let Claude transcribe your handwriting or convert hand-drawn diagrams into editable formats — all from your local machine, no API keys required.

How it works

The reMarkable desktop app syncs your notebooks to a local cache. This MCP server reads that cache and exposes it as tools that Claude can use directly.

reMarkable tablet
    → reMarkable desktop app (cloud sync)
    → Local cache (~/.../remarkable/desktop)
    → remarkable-mcp (rmc → SVG → cairosvg → PDF)
    → Claude reads the PDF
    → Clean Markdown, Excalidraw diagrams, or whatever you need

No API keys. No cloud access. Everything runs locally. The desktop app handles syncing; this server just reads the files it produces.

Related MCP server: io.github.praveensehgal/remarkable

Prerequisites

  • reMarkable desktop app — installed and synced (download)

  • macOS — the server reads from the standard macOS cache path (Linux support is possible but untested)

  • Python 3.12+

  • uv — Python package manager (install)

  • cairo — system graphics library for SVG→PDF rendering:

    brew install cairo

Installation

git clone https://github.com/sambt94/remarkable-mcp.git
cd remarkable-mcp
uv sync

MCP Registration

Add the server to your Claude Code MCP configuration. See mcp.example.json for the full template, or add this to your .mcp.json:

{
  "mcpServers": {
    "remarkable": {
      "type": "stdio",
      "command": "/bin/bash",
      "args": [
        "-c",
        "export DYLD_LIBRARY_PATH=/opt/homebrew/lib; exec uv --directory '/path/to/remarkable-mcp' run server.py"
      ]
    }
  }
}

Replace /path/to/remarkable-mcp with the actual path to your cloned repo.

The DYLD_LIBRARY_PATH is needed so Python can find the Homebrew-installed cairo library on macOS.

Tools

The server exposes 6 tools:

Tool

Description

remarkable_check_status

Diagnostics — cache exists? rmc available? cairo available?

remarkable_list_documents

Search/list documents in the cache (optional substring filter)

remarkable_get_document_info

Detailed metadata for a document (page count, page IDs, format)

remarkable_render_pages

Render selected pages to a single PDF

remarkable_render_document

Render all pages of a document to PDF

remarkable_cleanup_renders

Remove temporary rendered PDFs

Page selection

remarkable_render_pages supports flexible page selection:

# Last 5 pages of a document
remarkable_render_pages(doc_id="<uuid>", last_n=5)

# First 3 pages
remarkable_render_pages(doc_id="<uuid>", first_n=3)

# Specific pages (0-indexed)
remarkable_render_pages(doc_id="<uuid>", page_indices=[0, 2, 4])

# All pages (no selection args)
remarkable_render_pages(doc_id="<uuid>")

Priority: page_indices > last_n > first_n > all pages.

Usage with Claude

Once registered, Claude can access your reMarkable notebooks directly:

"Transcribe the last 3 pages of my journal"

"Find my notebook called 'Architecture Notes' and render page 5"

"What documents do I have on my reMarkable?"

The rendered PDFs are saved to /tmp/remarkable-renders/ and can be cleaned up with remarkable_cleanup_renders.

Companion Skills

The skills/ directory contains Claude Code skill definitions that wrap the MCP tools into complete workflows:

  • remarkable-transcribe.md — Transcribe handwritten notes to clean Markdown

  • remarkable-diagram.md — Convert hand-drawn diagrams to interactive Excalidraw files

To use these, copy the skill files into your ~/.claude/skills/ directory (or symlink them).

Architecture

remarkable-mcp/
├── server.py                 # MCP server entry point (FastMCP, stdio transport)
├── remarkable_client.py      # Client library (cache reading, rendering pipeline)
├── skills/
│   ├── remarkable-transcribe.md   # Handwriting → Markdown skill
│   └── remarkable-diagram.md      # Diagram → Excalidraw skill
└── tests/
    ├── conftest.py           # Synthetic cache fixtures
    ├── test_remarkable_client.py  # Unit tests
    ├── test_server.py        # Integration tests
    └── test_e2e.py           # End-to-end stdio tests

The rendering pipeline:

  1. rmc parses reMarkable's proprietary .rm binary format (v6) into SVG

  2. cairosvg converts SVG to PDF

  3. pypdf merges per-page PDFs into a single document

  4. Claude reads the PDF and does whatever you need — transcription, diagram interpretation, summarization

Tests

# All tests
uv run pytest tests/ -v

# By category
uv run pytest tests/ -m unit          # unit tests (synthetic cache)
uv run pytest tests/ -m integration   # tool registration and response shapes
uv run pytest tests/ -m e2e           # full stdio transport

Tests use synthetic fixtures — no real reMarkable device or cache required.

License

MIT — see LICENSE.

Available Tools

6 tools
remarkable_check_statusA

Check reMarkable system status and tool availability. Returns whether the cache exists, document count, and rmc/cairo availability. Use this to diagnose issues before rendering.

Inputs: no named parameters. Returns: object

remarkable_cleanup_rendersA

Remove temporary rendered PDFs from the render directory. Returns the number of files removed and bytes freed. Call this after you're done reading rendered PDFs.

Inputs: no named parameters. Returns: object

remarkable_get_document_infoA

Get detailed metadata for a single reMarkable document. Returns document ID, name, page count, page IDs, and content format (v1/v2). Lightweight — reads JSON only, no rendering.

Inputs: doc_id (required). Returns: object

remarkable_list_documentsA

List documents in the reMarkable local cache. Optional case-insensitive substring filter on document names. Returns document IDs, names, page counts, and last modified timestamps.

Inputs: search. Returns: object

remarkable_render_documentA

Render all pages of a reMarkable document to a single PDF. Convenience wrapper — equivalent to render_pages with no selection args. Returns the PDF path, document name, pages rendered/failed, and indices.

Inputs: doc_id (required). Returns: object

remarkable_render_pagesA

Render selected pages of a reMarkable document to a single PDF. Priority: page_indices > last_n > first_n > all pages. For a 200-page doc with last_n=5, only the last 5 pages are rendered. Returns the PDF path, document name, pages rendered/failed, and indices.

Inputs: doc_id (required), last_n, first_n, page_indices. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 6 tools

    Disambiguation4/5

    Most tools have clearly distinct purposes, but remarkable_render_document is explicitly a wrapper for remarkable_render_pages with no selection arguments, creating a slight overlap. The descriptions mitigate this by clarifying the relationship, so it's mostly unambiguous.

    Naming Consistency5/5

    All tools follow a consistent verb_noun pattern with the remarkable_ prefix, such as list_documents, render_pages, and check_status. This makes the tool names predictable and easy to navigate.

    Tool Count5/5

    With 6 tools, the server is well-scoped for its purpose of managing and rendering reMarkable documents. Each tool serves a distinct function (listing, metadata, rendering, status, cleanup) without unnecessary bloat.

    Completeness4/5

    The tool set covers the core lifecycle for reading and rendering documents: listing, retrieving metadata, rendering all or select pages, checking status, and cleaning up. It lacks write operations like upload or delete, but those fall outside the apparent scope of a rendering-focused server.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that gives Claude AI direct access to your Obsidian vault, enabling natural language search, note creation, file management, and automated workflows.
      10
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A local MCP server that turns an Obsidian vault into a searchable second brain for Claude with meaning-based search, note read/write, and insight reports like contradictions and stale TODOs.
      MIT