reMarkable MCP Server
A reMarkable MCP server that lets AI clients browse, read, search, render, export, and (in write-capable transports) manage a reMarkable tablet library.
Browse folders, search document names, and filter by tags
Read extracted text, raw PDF/EPUB text, or annotations with pagination, regex grep, and optional handwriting OCR
Search content across multiple documents and list recently modified documents
Check connection status, active transport, and per-transport capability matrix
Render notebook/annotated PDF pages as PNG or SVG, with merged PDF+annotation compositing, custom/transparent backgrounds, and OCR
Export a document as a temporary PDF or sectioned Markdown ResourceLink
Upload PDF/EPUB files and render Markdown into a paginated PDF uploaded to the tablet
Create folders, move, rename, and delete items (cloud and SSH; delete defaults to Trash and requires confirmation when supported)
Author native ink strokes, blank pages, and new notebooks, with serialized SSH writes and deferred-refresh batching
Open an interactive canvas viewer in MCP Apps–capable clients, falling back to an embedded PNG elsewhere
Work over cloud, USB web, local desktop-app directory (read-only), or SSH, served via stdio or Streamable HTTP, with optional root-path scoping
Provides handwriting OCR through Google Vision, allowing text extraction from handwritten notes and annotations on the reMarkable tablet.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@reMarkable MCP Server find my notes from yesterday's meeting"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
reMarkable MCP Server
Access a reMarkable library from MCP clients such as Claude, VS Code Copilot, OpenWebUI, and other compatible tools.
Features
Browse folders and recent documents.
Search names, tags, and extracted text.
Read typed text, PDF and EPUB text, highlights, and annotations.
Render notebooks and annotated PDFs as PNG or SVG.
Export one document as a complete PDF or sectioned Markdown resource.
Run handwriting OCR through Google Vision or Tesseract.
Upload files and manage folders in supported transports.
Render Markdown as PDF and upload it to the tablet.
Open an interactive canvas in clients that support MCP Apps.
Serve MCP over stdio or local Streamable HTTP.
Serve MCP
2026-07-28and every earlier SDK-supported revision from one stable SDK 2.xMCPServer.
Related MCP server: reMarkable MCP Server
Quick Install
Prerequisite: install uv
The commands below use uvx, which is included with uv.
Python 3.11 or later is required. If needed, install it with uv python install 3.11.
Page images are rasterized with PyMuPDF; no system Cairo, browser, or graphics
runtime needs to be installed on macOS, Linux, or Windows.
macOS and Linux
Use the official standalone installer:
curl -LsSf https://astral.sh/uv/install.sh | shOr install with Homebrew:
brew install uvWindows
Use the official standalone installer from PowerShell:
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"Or install with WinGet:
winget install --id=astral-sh.uv -eChoose a connection
Start with the first mode that fits your setup.
Order | Mode | Setup | Writes | Use when |
1 | USB web | Connect the tablet and enable USB web | Upload; destination chosen by tablet | You want the shortest setup without a subscription or developer mode |
2 | Local directory | Install and sign in to the desktop app | No | You want offline, device-free reads from the desktop cache |
3 | Cloud | Register once; Connect subscription required | Full document and folder management | You need wireless or remote access |
4 | SSH | Enable developer mode and configure SSH | Full management and native authoring | You need direct filesystem access or native ink writes |
USB Web Interface
Connect via USB and enable the web interface in your tablet's Storage Settings.
Connect your reMarkable via USB
On your tablet, open Settings > Storage and enable USB web interface
Install via the button above
Add to .vscode/mcp.json:
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--usb"],
"env": {
"GOOGLE_VISION_API_KEY": "your-api-key"
}
}
}
}Make sure your reMarkable is connected via USB and unlocked
Verify USB web interface is enabled in Settings > Storage
The tablet should be accessible at
http://10.11.99.1
Local Directory Mode
Read the official reMarkable desktop app's sync folder from disk. This mode is offline and read-only. The desktop app controls synchronization.
Add to .vscode/mcp.json:
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--local-dir"]
}
}
}With no path, the desktop app's data folder is auto-detected:
macOS (current app):
~/Library/Containers/com.remarkable.desktop/Data/Library/Application Support/remarkable/desktopmacOS (legacy app):
~/Library/Application Support/remarkable/desktopWindows:
%APPDATA%\remarkable\desktopLinux:
~/.local/share/remarkable/desktop
Or point at any xochitl-style directory (e.g. a tablet backup):
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--local-dir", "/path/to/xochitl-data"]
}
}
}Content freshness depends on the desktop app. Keep it running and signed in.
This mode is read-only. Direct writes could bypass synchronization and corrupt the app cache.
If the directory can't be found and a cloud token is configured, the server falls back to cloud mode for read access (the server remains read-only because it was launched in local-directory mode)
Cloud Mode
Cloud mode works without a device connection and requires a reMarkable Connect subscription.
It fetches metadata in parallel and caches content-addressed blobs on disk. See Cloud performance and caching for configuration.
1. Get a One-Time Code
Go to my.remarkable.com/device/desktop/connect and generate a code.
2. Convert to Token
uvx remarkable-mcp --register YOUR_CODERegistration saves the token to ~/.rmapi. When your MCP client runs the server as the same user on the same machine, remarkable-mcp reads that file automatically, so you do not need to put a token in the client configuration. Set REMARKABLE_TOKEN only when ~/.rmapi is unavailable, such as when the server runs under another user or on another machine.
3. Configure your MCP client
Minimal client-neutral server definition
Add this server definition using the MCP configuration UI or wrapper required by your client:
{
"command": "uvx",
"args": ["remarkable-mcp"]
}No env entry is needed when the server can read the token from ~/.rmapi.
VS Code
VS Code's .vscode/mcp.json uses a top-level servers object. The saved
~/.rmapi credential means no token input is required:
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp"]
}
}
}Claude Desktop and other clients
Claude Desktop and many other MCP clients use a top-level mcpServers object and literal values in env; they do not use VS Code's inputs array. With the token available in ~/.rmapi, the minimal configuration is:
{
"mcpServers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp"]
}
}
}If the token file is unavailable, add "env": {"REMARKABLE_TOKEN": "your-token"} to the remarkable server entry. Consult your client's documentation if it uses a different outer key or secret-storage mechanism.
SSH Mode
SSH provides direct filesystem access and native notebook authoring. It requires developer mode, which factory-resets the tablet when enabled. Use this mode only when USB web, local directory, or cloud mode does not provide the operation you need.
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--ssh"]
}
}
}See the SSH setup guide for authentication and device setup.
Connection Modes
All modes support reading, rendering, and single-document export. Cloud and SSH support full library management. USB web supports upload but does not accept a destination folder. Local directory mode is read-only.
Mode | Setup | Subscription | Offline | Tablet required | Raw source | Upload | Folder operations¹ |
Local directory | Desktop app installed | No² | Yes | No | PDF and EPUB | No | No |
USB web | Enable in Settings | No | Yes | Yes | Root only | No | |
Cloud | One-time registration | Connect | No | No | PDF and EPUB | Yes | Yes |
SSH | Developer mode | No | Yes | Yes | PDF and EPUB | Yes | Yes |
¹ Folder ops = create folder / move / rename / delete. Upload and folder ops are enabled by default; pass --read-only to expose a read-only server. Deletes move items to the trash and prompt for confirmation when your client supports elicitation, and are refused without it unless REMARKABLE_SKIP_CONFIRM=1 is set.
² The desktop app itself signs in to the reMarkable cloud to sync; local directory mode just reads whatever the app has already synced to disk.
Automatic cloud fallback
If a selected device transport is unavailable and a cloud credential is configured,
the server falls back to cloud mode. A server launched with --local-dir remains
read-only after fallback. remarkable_status reports the effective transport and
sets fell_back_to_cloud.
Pass --no-cloud-fallback (or set REMARKABLE_DISABLE_CLOUD_FALLBACK=1) to disable this and fail instead when the device is unreachable.
The transport is resolved once per server process. Restart the MCP server after connecting a device or starting the desktop app if the process already fell back to cloud.
Detailed setup:
OpenWebUI (Streamable HTTP)
OpenWebUI's native MCP connection uses Streamable HTTP. Start remarkable-mcp on the same machine:
uvx remarkable-mcp --httpThen add http://127.0.0.1:8000/mcp as the MCP server URL in OpenWebUI. The
HTTP transport combines with --usb, --ssh, and --read-only; for example:
uvx remarkable-mcp --usb --httpThe bind address and port can also be set with --host / --port or
REMARKABLE_MCP_HOST / REMARKABLE_MCP_PORT.
The server uses MCP Python SDK 2.x's dual-era endpoint. Modern
2026-07-28 requests are sessionless; older clients continue to use the
initialize handshake and legacy MCP sessions on the same /mcp route. The
reMarkable token and selected tablet transport remain process-local CLI/env
configuration and are never inferred from MCP HTTP authorization headers.
Streamable HTTP has no built-in authentication. It binds to127.0.0.1 by
default. Keep that default unless you control the network boundary. Wildcard
binds such as 0.0.0.0 and :: are rejected because they cannot provide a
strict Host allowlist. A concrete non-loopback address is allowed but exposes
every enabled tool, including writes, to clients that can reach the port.
Remote access through an authenticated reverse proxy
Keep remarkable-mcp on its default loopback bind and put the proxy on the same
host. MCPServer's DNS-rebinding protection only permits loopback Host and
Origin values by default. A proxy that forwards its public hostname unchanged
will therefore receive 421 Misdirected Request; a public browser Origin
will receive 403 Forbidden.
The proxy must authenticate requests, rewrite Host to the loopback upstream,
and clear Origin. For example, with nginx and an existing htpasswd file:
location /mcp {
auth_basic "reMarkable MCP";
auth_basic_user_file /etc/nginx/remarkable-mcp.htpasswd;
proxy_pass http://127.0.0.1:8000;
proxy_http_version 1.1;
proxy_buffering off;
proxy_read_timeout 3600s;
# Required by MCPServer's default DNS-rebinding protection.
proxy_set_header Host 127.0.0.1:8000;
proxy_set_header Origin "";
}Do not expose the upstream port directly. Configure OpenWebUI with the
authenticated proxy URL, such as https://mcp.example.com/mcp.
For NixOS, remarkable-mcp-bridge.nix provides a systemd module with the same
loopback default:
{
imports = [ ./remarkable-mcp-bridge.nix ];
services.remarkable-mcp = {
enable = true;
command = "/opt/remarkable-mcp/.venv/bin/remarkable-mcp";
};
}The service user must have its reMarkable credentials under
/var/lib/remarkable-mcp (or the configured home). The module adds
Tesseract to the service's executable search path; install the configured
command separately.
OpenClaw Integration
remarkable-mcp works as an OpenClaw skill. Add to your openclaw.json:
{
"mcpServers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--usb"]
}
}
}Install from ClawHub:
clawhub install remarkable-mcpOr copy the SKILL.md from this repository into your ~/.openclaw/skills/remarkable-mcp/ directory.
Tools
Tool | Description |
| Read and extract text from documents (with pagination and search) |
| Navigate folders, search by document name, or filter by tags |
| Search content across multiple documents (with tag filtering) |
| Get recently modified documents |
| Check connection status and the per-transport capability matrix |
| Get PNG/SVG images of pages with optional OCR |
| Export one document as a temporary PDF or Markdown resource |
The read/search/render tools are read-only. remarkable_export never changes the
tablet, but it writes a bounded temporary file on the MCP server host and therefore
declares readOnlyHint=false. Export links expire after 15 minutes and the server
retains at most eight at a time.
Supported transports also register write tools by default; pass --read-only to
disable them. See Write Tools. Clients that support
MCP Apps can also open remarkable_canvas.
Tool behavior
Browsing a document path returns its content.
Empty notebook text can trigger OCR automatically.
Search can scan several matching documents.
Image tools return visual content that text extraction misses.
remarkable_read.total_pagesis the physical document count;content_pagescounts extracted-text chunks, andmore/next_pagecontinue those chunks. Raw PDF reads count pages from the already-downloaded PDF. If a raw EPUB's separate archive cannot be read, its text still returns withtotal_pages: nullandtotal_pages_known: false.PNG images of PDF-backed pages merge the source page and annotations automatically; pass
render_merged=Falsefor the annotation layer alone.PDF exports preserve physical page order and merge mapped source underlays with annotations by default. Markdown exports keep fixed source/typed/annotation/ highlight/OCR sections without guessing document structure.
OCR uses Google Vision when configured and otherwise runs locally with Tesseract.
Browse and search accept tag filters.
Example Usage
# Read a document
remarkable_read("Meeting Notes")
# Search for keywords
remarkable_read("Project Plan", grep="deadline")
# Enable OCR for handwritten notes
remarkable_read("Journal", include_ocr=True)
# Browse your library
remarkable_browse("/Work/Projects")
# Filter by tags
remarkable_browse("/", tags=["important"])
remarkable_browse("/Work", tags=["project", "active"])
# Search across documents
remarkable_search("meeting", grep="action items")
# Search with tag filter
remarkable_search("project", tags=["work"])
# Get recent documents
remarkable_recent(limit=10)
# Get a page image (for visual content like UI mockups or diagrams)
remarkable_image("UI Mockup", page=1)
# Get SVG for editing in design tools
remarkable_image("Wireframe", output_format="svg")
# Get image with OCR text extraction
remarkable_image("Handwritten Notes", include_ocr=True)
# Imported PDF pages include their reMarkable annotations automatically
remarkable_image("Research Paper", page=3)
# Request only the reMarkable annotation layer
remarkable_image("Research Paper", page=3, render_merged=False)
# Transparent background for compositing
remarkable_image("Logo Sketch", background="#00000000")
# Compatibility mode: return resource URI instead of embedded resource
remarkable_image("Diagram", compatibility=True)
# Export a complete PDF through a temporary MCP ResourceLink
remarkable_export("Meeting Notes")
# Export honest, sectioned Markdown with opt-in OCR
remarkable_export("Journal", output_format="markdown", include_ocr=True)
# Export only full-page annotation layers when archive data is available
remarkable_export("Research Paper", pdf_mode="annotations")Note: PNG rendering uses PyMuPDF for both notebook SVGs and PDF pages, so
remarkable_imagedoes not require Cairo, Inkscape, Chromium, or another system graphics runtime. If local stroke parsing cannot handle a page, USB and SSH modes fall back to the tablet's native PDF export and cloud mode falls back to an original source PDF when one exists.
Resources
Documents are automatically registered as MCP resources:
URI Scheme | Description |
| Extracted text content |
| Extracted text from the original PDF |
| Extracted text from the original EPUB |
| PNG image of page N (notebooks only) |
| SVG vector image of page N (notebooks only) |
| Temporary generated PDF or Markdown export |
Trashed documents, including descendants of trashed folders, are excluded from
read tools, canvas, resources, and live document counts. Write tools prefer live
namesakes and never use trashed destinations. With no configured root, an explicit
absolute /trash/... write target remains available for SSH permanent deletion;
it cannot bypass REMARKABLE_ROOT_PATH.
remarkable_export returns a ResourceLink instead of embedding potentially
large file content in the tool response. The server stores the file in a private
temporary directory for 15 minutes, retains at most eight exports, and removes
managed exports at shutdown. Fetch and save the linked resource for durable use.
OCR for Handwriting
For handwritten content, remarkable-mcp offers two OCR backends:
Backend | Setup | Offline | Notes |
Google Vision | API key | No | Good handwriting support |
Tesseract | System install | Yes | Better suited to printed text |
Quick Setup
Set REMARKABLE_OCR_BACKEND in your MCP config:
{
"env": {
"REMARKABLE_OCR_BACKEND": "auto"
}
}Options: auto, google, tesseract
Enable Cloud Vision API
Create an API key
Add to config:
"GOOGLE_VISION_API_KEY": "your-key"
Cost: 1,000 free requests/month, then ~$1.50 per 1,000.
Open-source OCR designed for printed text. Poor results with handwriting, but useful as an offline fallback.
# Install Tesseract
# macOS
brew install tesseract
# Ubuntu/Debian
sudo apt install tesseract-ocr
# Windows
choco install tesseractDefault Behavior (auto)
When REMARKABLE_OCR_BACKEND=auto (default):
Google Vision (if
GOOGLE_VISION_API_KEYis set)Tesseract (fallback)
Write Tools by Transport
Write tools let you upload, organize, and manage documents on your reMarkable. Enabled by default on write-capable transports. Cloud and SSH modes support the full set; USB web supports upload only (its firmware exposes no folder operations); local-directory mode is always read-only. Pass --read-only to expose a read-only server elsewhere.
Feature | Local Directory | Cloud Mode | SSH Mode | USB Web Mode |
Upload | ❌ | ✅ | ✅ | ✅ (tablet-selected folder) |
Mkdir | ❌ | ✅ | ✅ | ❌ |
Move | ❌ | ✅ | ✅ | ❌ |
Rename | ❌ | ✅ | ✅ | ❌ |
Delete | ❌ | ✅ (→ trash) | ✅ (→ trash; optional permanent) | ❌ |
Disabling Write Tools (read-only mode)
Write tools are on by default in each write-capable mode. Local-directory mode is always read-only. To make another transport read-only, add the --read-only flag:
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--read-only"]
}
}
}It combines with any transport flag (--ssh, --usb):
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--ssh", "--read-only"]
}
}
}Or set the environment variable:
{
"env": {
"REMARKABLE_READ_ONLY": "1"
}
}The legacy
--writeflag andREMARKABLE_ENABLE_WRITEvariable are still accepted for backward compatibility but are now no-ops (write is the default).--writeand--read-onlyare mutually exclusive.
Available Write Tools
Tool | Description |
| Upload a PDF or EPUB file (cloud, SSH, and USB web; USB web preserves the name but ignores |
| Render Markdown as a paginated PDF and upload it (cloud, SSH, and USB web) |
| Create a new folder (cloud and SSH) |
| Move a document or folder (cloud and SSH) |
| Rename a document or folder (cloud and SSH) |
| Move a document/folder to Trash; SSH can permanently remove it with |
| Safely restart |
| Author native ink and notebooks — |
Safety
Upload registers in cloud, SSH, and USB web mode — local-directory mode never exposes write tools.
mkdir, move, rename, delete register in cloud and SSH modes only — they are not exposed on USB web (the tablet's USB web firmware has no folder/move/rename/delete endpoints), keeping the tool list scoped to what the active transport actually supports.
Delete prompts for confirmation when possible — if the client supports MCP elicitation,
remarkable_deleteasks the user to confirm before deleting. MCP SDK 2.x carries that prompt as a multi-round input request for2026-07-28clients and as push elicitation for legacy clients. If the client can't show a prompt, the delete is refused (not performed) unlessREMARKABLE_SKIP_CONFIRM=1is set — so write-on-by-default can't silently delete from clients that lack elicitation. Cloud and SSH move items to Trash by default. SSH also supportspermanent=Truefor an explicitly requested permanent removal; cloud permanent deletion remains a Trash-management operation in the app/tablet. SetREMARKABLE_SKIP_CONFIRM=1to allow deletes without a prompt in automated setups. All write tools carryToolAnnotations(read_only_hint=False)(anddestructive_hint=Truefor delete) so an agent harness can gate writes at the MCP layer.SSH work is fair and serialized per server — one FIFO dispatcher owns every SSH subprocess, so startup scans, reads, uploads, mutations, and refresh probes cannot churn the tablet's USB CDC connection concurrently. Cached metadata reads bypass the queue.
Concurrent SSH writes share a refresh barrier — near-simultaneous writes are persisted in FIFO order, then every participating call waits for one shared
xochitlrestart before reporting success. A bounded debounce coalesces bursts without background or late success.SSH refreshes avoid the firmware emergency-reboot path — the serialized refresh clears only
xochitl's systemd start counter immediately before restart, then requires stable, non-multiplexed SSH sessions on the same boot. OpenSSH aliases are resolved withssh -G; if USB web was reachable at that effective host before restart, port 80 must recover too. A failed probe keepsrefresh_pending: trueand never replays the write.Retries are deliberately narrow — only connection failures that prove the remote command never started (for example connection refused, connect timeout, or banner timeout) receive bounded exponential backoff. Ambiguous/post-start write failures are never replayed; the error directs the caller to refresh and inspect the tablet instead.
For explicit bulk operations, pass
defer_restart=Trueto each write (includingremarkable_author) — or setREMARKABLE_DEFER_RESTART=1— and callremarkable_refresh()once at the end. Deferred writes return immediately withrefresh_pending: true; an extra refresh is a no-op only after the current server process has confirmed a clean state. A new process performs one conservative recovery refresh because it cannot know whether an earlier process left disk changes pending.A multi-step SSH write that fails after any confirmed mutation returns
write_partially_persisted, says do not repeat, and reports whether refresh recovery is still pending. A shared refresh failure is propagated only to participants whose own mutation was dirty; clean validation/pre-execution failures retain their original error.USB HTTP requests use the same bounded operation core with
REMARKABLE_USB_MAX_CONCURRENCY(default2). Cloud sync keeps its existing pooled, idempotency-aware request layer andREMARKABLE_SYNC_WORKERScontrol.
Examples
# Upload a PDF
remarkable_upload("paper.pdf", parent_folder="/Research")
# Render Markdown and upload the PDF without creating a local file
remarkable_markdown_to_pdf(
"# Meeting Notes\n\n- Follow up with Sam",
document_name="Meeting Notes",
parent_folder="/Research",
)
# Create a folder
remarkable_mkdir("2024 Archive", parent="/Archive")
# Move a document
remarkable_move("Meeting Notes", "/Archive/2024 Archive")
# Rename a document
remarkable_rename("Untitled", "Q4 Planning Notes")
# Delete (destructive; confirms via elicitation when supported)
remarkable_delete("Old Draft")
# Permanently delete in SSH mode only
remarkable_delete("Disposable Test", permanent=True)
# Bulk import (SSH): defer the restart on each write, then refresh once.
# One xochitl restart for the whole batch instead of one per upload.
remarkable_upload("a.pdf", parent_folder="/Research", defer_restart=True)
remarkable_upload("b.pdf", parent_folder="/Research", defer_restart=True)
remarkable_refresh()
# Author native ink and notebooks (SSH only)
# Append pen/highlighter strokes to a page (coordinates normalized [0,1] from
# the page's top-left). The interactive canvas Save button calls this too.
remarkable_author(
method="draw",
document="Ideas",
page=1,
strokes=[{"points": [[0.1, 0.2], [0.8, 0.2]], "tool": "highlighter", "color": "yellow"}],
)
# Append a blank, drawable page to the end of a notebook
remarkable_author(method="add_page", document="Ideas")
# Create a new blank notebook
remarkable_author(method="create_document", name="Sketches")
# Only seed typed text when the user explicitly requested it.
remarkable_author(method="create_document", name="Meeting notes", text="Agenda\nFollow-ups")Interactive Canvas App (MCP Apps)
An interactive page viewer built on the MCP Apps extension (SEP-1865). Clients that support MCP Apps (such as ChatGPT, Claude, VS Code, and the MCP Inspector) render a canvas in a side panel where you can view a document page and navigate through it.
There is no flag to enable it — the remarkable_canvas tool and its ui://remarkable/canvas resource are always registered, and the capability is negotiated automatically in client capabilities (modern discovery or a legacy initialize handshake). App-capable clients open the interactive canvas; every other client simply receives the rendered page as an image, so the tool is safe and useful everywhere.
This registers one tool:
Tool | Description |
| Open a page in the interactive canvas viewer |
How it behaves:
App-capable clients open the canvas (declared at
ui://remarkable/canvas, MIMEtext/html;profile=mcp-app) and can page through the document via the MCP Apps postMessage bridge — the server delivers each rendered page in the wire result'sstructuredContent(structured_contentin Python).Other clients still get the rendered page back as an embedded PNG image, so the tool is useful everywhere; it just won't open the interactive panel. The
_meta.ui/ui://metadata is inert to clients that don't advertise the MCP Apps UI extension.
Drawing and authoring from the canvas
When write mode is on (the default) and the active transport is SSH, the canvas becomes a write surface:
Draw: choose a pen or highlighter, draw, then save native
.rmink to the device.Add page: queue a blank native notebook page, draw on it, then save.
One source of truth: the canvas calls the same
remarkable_authortool a model would call (method="draw"on Save,method="add_page"for +Page), so the human path and the model path produce byte-identical results.
The Save / Draw / +Page controls are hidden when the page isn't writable (read-only mode, or a non-SSH transport), and the canvas falls back to a plain image viewer. The iframe bridge follows the MCP Apps spec but is best validated against your specific client.
Advanced Configuration
Root Path Filtering
Limit the MCP server to a specific folder on your reMarkable. All operations will be scoped to this folder:
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--ssh"],
"env": {
"REMARKABLE_ROOT_PATH": "/Work",
"GOOGLE_VISION_API_KEY": "your-api-key"
}
}
}
}With this configuration:
remarkable_browse("/")shows contents of/Workremarkable_browse("/Projects")shows/Work/ProjectsDocuments outside
/Workare not accessibleWrite tools stay inside
/Work:remarkable_upload(..., parent_folder="/")lands in/Work, and move, rename, and delete cannot reach anything outside it. The configured root must identify a single existing folder; otherwise writes return a not-found errorUSB web uploads are refused while a root is set, because that interface cannot choose a folder
Useful for:
Focusing on work documents during office hours
Separating personal and professional notes
Limiting scope for specific AI workflows
Custom Background Color
Set the default background color for image rendering:
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--ssh"],
"env": {
"REMARKABLE_BACKGROUND_COLOR": "#FFFFFF"
}
}
}
}Supported formats:
#RRGGBB: RGB hex, such as#FFFFFF#RRGGBBAA: RGBA hex, such as#00000000
Default is #FBFBFB (reMarkable paper color). This affects both the remarkable_image tool and image resources.
Retry Configuration
Cloud API requests automatically retry on transient failures (HTTP 429, 500, 502, 503, 504) and network errors with exponential backoff and jitter. You can tune this via environment variables:
Variable | Default | Description |
|
| Maximum number of request attempts (minimum 1) |
|
| Base delay in seconds for exponential backoff |
Rate-limit retries honor numeric and HTTP-date Retry-After values, capped at
20 seconds. Authentication failures trigger token renewal instead of retry.
Cloud Performance & Caching
Cloud mode is built to make a device-free workflow fast:
Parallel traversal: fetch document metadata concurrently.
Connection pooling: reuse HTTP connections.
Content-addressed blob cache: reuse immutable blobs by hash and fetch new hashes when documents change.
You normally don't need to configure any of this, but these environment variables let you tune it:
Variable | Default | Description |
|
| Parallel workers for cloud fetches (clamped to |
| unset | Set to |
|
| Where cached blobs are stored. |
|
| Blobs larger than this are streamed through but not cached. |
The cache is purely a local accelerator: deleting REMARKABLE_CACHE_DIR only forces the next read to re-download. The mutable cloud root hash is always fetched fresh, so you never see a stale library.
Common Workflows
Read recent notes and extract action items.
Search names, tags, typed text, and OCR output.
Review annotated PDFs with the source page and annotations together.
Move selected notes into another local workflow.
Upload reference PDFs or generated Markdown documents.
Documentation
Guide | Description |
Enable developer mode and configure SSH | |
Set up handwriting OCR | |
Detailed tool documentation | |
MCP resources documentation | |
MCP protocol capabilities | |
Contributing and development setup | |
Roadmap and planned features |
Development
git clone https://github.com/SamMorrowDrums/remarkable-mcp.git
cd remarkable-mcp
uv sync --all-extras
uv run pytest -vDependabot checks Python dependencies and uv.lock through the uv ecosystem,
and GitHub Actions, weekly. Dependency updates are audited with pip-audit;
see the development guide for the full update and validation commands.
Multi-transport smoke test
When something looks broken, run the deterministic, no-AI smoke test first. It drives the real server over MCP and exercises every available tool in every reachable transport in this order: local directory, cloud, USB web, then SSH.
uv run python smoke/run_smoke.py # all available modes
uv run python smoke/run_smoke.py --read-only # connectivity + reads onlySmoke test guide and per-mode expectations.
License
MIT
Built with rmscene, PyMuPDF, markdown-it-py, and inspiration from ddvk/rmapi.
Available Tools
14 toolsremarkable_browseARead-onlyIdempotent
Browse your reMarkable library or search for documents. Three modes:
Browse mode (default): List contents of a folder
Use path="/" for root folder
Use path="/FolderName" to navigate into folders
Search mode: Find documents by name
Set query="search term" to search across all documents
Filter by tags: Find documents with specific tags
Set tags=["tag1", "tag2"] to filter by tags
Works in both browse and search modes
Results include document names, types, modification dates, and tags.
Note: If REMARKABLE_ROOT_PATH is configured, only documents within that folder are accessible. Paths are relative to the root path.
path: Folder path to browse (default: "/" for root)
query: Search term to find documents by name (optional, triggers search mode)
tags: List of tags to filter documents (optional, case-insensitive)
remarkable_browse() # List root folder
remarkable_browse("/Work") # List Work folder
remarkable_browse(query="meeting") # Search for "meeting"
remarkable_browse(tags=["important"]) # Show documents with "important" tag
remarkable_browse(query="project", tags=["work"]) # Search with tag filter
Inputs: path, tags, query. Returns: result
remarkable_canvasARead-only
Open a reMarkable page in an interactive canvas viewer. Renders a notebook or document page and, in clients that support MCP Apps interactive UI, opens a canvas viewer that lets the user page through the document. This is the entry point for the interactive viewer.
The canvas is currently a read-only viewer (render + page navigation). For plain image extraction without the interactive surface, use remarkable_image instead.
Clients that do not support MCP Apps still get the rendered page back as an embedded PNG image, so this tool is useful everywhere; it just won't open the interactive panel.
document: Document name or path (use remarkable_browse to find documents)
page: Page number to open (default: 1, 1-indexed)
remarkable_canvas("Meeting Notes")
remarkable_canvas("/Work/Sketches/Wireframe", page=3)
Inputs: document (required), page.
remarkable_deleteADestructive
Delete a document or folder on the reMarkable tablet. DESTRUCTIVE operation. By default the item is moved to the tablet's Trash and remains recoverable. In SSH mode only, permanent=True removes the resolved UUID and all sidecar files instead; use that only when the user explicitly asked for permanent deletion.
Works in cloud and SSH modes (default; --read-only disables). Not available over the USB web interface.
If the client supports elicitation, this tool asks the user to confirm before deleting. If the client cannot show a confirmation prompt, the delete is refused unless REMARKABLE_SKIP_CONFIRM=1 is set (for headless automation).
document: Name or path of the document/folder to delete
defer_restart: SSH only. Skip the xochitl restart so a batch of deletes can refresh once via remarkable_refresh() instead of once per delete. Sets "refresh_pending": true. Ignored in cloud mode.
permanent: SSH only. Permanently remove the resolved document/folder files instead of moving the item to Trash (default: False).
remarkable_delete("Old Notes")
remarkable_delete("/Books/Archive/Old Draft")
Inputs: document (required), permanent, defer_restart. Returns: result
remarkable_exportA
Export one reMarkable document as a reusable PDF or Markdown file. Exports a single document without modifying the tablet or its library.
The generated file is written to a server-managed temporary directory and returned as an MCP ResourceLink. The tool response stays small: it never embeds the PDF/Markdown as base64 and never writes to an arbitrary host path. The resource expires after 15 minutes and may be evicted earlier when more than eight exports are retained. Fetch and save the linked resource for durable use.
PDF behavior:
pdf_mode="merged"(default) preserves complete physical pages, combining mapped PDF underlays and reMarkable annotations.pdf_mode="annotations"exports full-page annotation layers only when the transport provides a document archive.Pages remain in physical device order. A render failure produces a labeled placeholder at that ordinal and a partial-export warning; pages are not skipped.
Markdown behavior:
Preserves basic source metadata and fixed source text, typed text, annotation, highlight, and OCR sections.
OCR is opt-in and uses the same configured/cached OCR path as remarkable_read.
Extracted text is kept verbatim; the exporter does not invent headings, lists, links, or page attribution it cannot prove.
document: Document name or path (use remarkable_browse to find documents).
output_format: "pdf" (default) or "markdown".
pdf_mode: PDF-only mode, "merged" (default) or "annotations".
include_ocr: Enable existing handwriting OCR for Markdown (default: False).
remarkable_export("Meeting Notes")
remarkable_export("Research Paper", output_format="pdf", pdf_mode="annotations")
remarkable_export("Journal", output_format="markdown", include_ocr=True)
Inputs: document (required), pdf_mode, include_ocr, output_format.
remarkable_imageARead-onlyIdempotent
Get an image of a specific page from a reMarkable document. Renders a notebook or document page as an image (PNG or SVG). This is useful for:
Viewing hand-drawn diagrams, sketches, or UI mockups
Getting visual context that text extraction might miss
Implementing designs based on hand-drawn wireframes
SVG format for scalable vector graphics that can be edited
Merged PDF + Annotation Rendering
PNG pages backed by an imported PDF automatically composite the PDF page with its reMarkable annotations. Set render_merged=False for an annotation-only render, or True to explicitly request compositing. SVG remains annotation-only.
Response Formats
By default, images are returned as embedded resources (EmbeddedResource) which include the full image data inline:
PNG: Returned as BlobResourceContents with base64-encoded data
SVG: Returned as TextResourceContents with SVG markup
If your client doesn't support embedded resources in tool responses, set compatibility=True to receive a JSON response with just the resource URI. The client can then fetch the resource separately.
Optionally, enable include_ocr=True to extract text from the image using OCR. Google Vision is used when configured; otherwise OCR runs locally with Tesseract.
Note: Native notebooks retain their existing stroke rendering behavior. If older USB firmware returns only a native PDF export, PNG remains available; SVG and explicit annotation-only rendering require an rmdoc archive and return a clear error when it is unavailable.
document: Document name or path (use remarkable_browse to find documents)
page: Page number (default: 1, 1-indexed)
background: Background color as hex code. Supports RGB (#RRGGBB) or RGBA (#RRGGBBAA). Default is "#FBFBFB" (reMarkable paper color), or set REMARKABLE_BACKGROUND_COLOR env var to override. Use "#00000000" for transparent.
output_format: Output format - "png" (default) or "svg" for vector graphics
compatibility: If True, return resource URI in JSON instead of embedded resource. Use this if your client doesn't support embedded resources in tool responses.
include_ocr: Enable OCR text extraction from the image (default: False).
render_merged: PDF compositing mode for PNG: None (default) automatically merges PDF-backed pages, True explicitly requests merging, and False returns the annotation-only layer. SVG output remains annotation-only.
remarkable_image("UI Mockup") # Get first page as embedded PNG resource
remarkable_image("Meeting Notes", page=2) # Get second page
remarkable_image("/Work/Designs/Wireframe", background="#FFFFFF") # White background
remarkable_image("Sketch", background="#00000000") # Transparent background
remarkable_image("Diagram", output_format="svg") # Get as embedded SVG resource
remarkable_image("Notes", compatibility=True) # Return resource URI for retry
remarkable_image("Notes", include_ocr=True) # Get image with OCR text extraction
remarkable_image("Annotated PDF") # PDF + annotations composited automatically
remarkable_image("Annotated PDF", render_merged=False) # Annotation layer only
Inputs: document (required), page, background, include_ocr, +3 more.
remarkable_markdown_to_pdfA
Render Markdown text as a PDF and upload it to the reMarkable tablet. Use this when the user wants notes, reports, summaries, or other Markdown content written back to the tablet without first creating a local file. Headings, lists, tables, links, blockquotes, and code blocks are rendered into a paginated A4 PDF. Raw HTML is escaped and image assets are omitted so rendering never reads local files or fetches remote content.
Works in all three transports:
Cloud: sync upload with parent_folder and document_name
SSH: filesystem upload with parent_folder and document_name
USB web: upload whose multipart filename is document_name + ".pdf"; parent_folder is ignored and the tablet web service chooses the folder.
Requires write mode (the default; disabled with --read-only).
markdown: Markdown source text. Must not be empty.
document_name: Display name on the tablet (default: "Markdown").
parent_folder: Destination folder (default: root "/"). USB web ignores this parameter because its upload endpoint has no folder argument.
defer_restart: SSH only. When True, skip the xochitl restart and call remarkable_refresh() once after the batch. Forwarded exactly like remarkable_upload; ignored in cloud and USB web modes.
remarkable_markdown_to_pdf("# Meeting Notes\n\n- Follow up with Sam")
remarkable_markdown_to_pdf( "# Q4 Report\n\nRevenue increased 20%.", document_name="Q4 Report", parent_folder="/Reports", )
remarkable_markdown_to_pdf( "# Batch item", document_name="Item 1", defer_restart=True ) remarkable_refresh()
Inputs: markdown (required), defer_restart, document_name, parent_folder. Returns: result
remarkable_mkdirA
Create a new folder on the reMarkable tablet. Creates a folder in the tablet's document hierarchy. In SSH mode the folder appears after xochitl restarts; in cloud mode it syncs to all your devices.
Works in cloud and SSH modes (default; --read-only disables). Not available over the USB web interface (the firmware exposes no folder-create endpoint).
folder_name: Name of the new folder
parent: Parent folder path (default: root "/")
defer_restart: SSH only. Skip the xochitl restart so a batch of writes can refresh once via remarkable_refresh() instead of once per write. Sets "refresh_pending": true. Ignored in cloud mode.
remarkable_mkdir("Projects")
remarkable_mkdir("2024", parent="/Archive")
Inputs: folder_name (required), parent, defer_restart. Returns: result
remarkable_moveA
Move a document or folder to a different location. Moves a document or folder by updating its parent reference in the metadata. Find the document name with remarkable_browse() first.
Works in cloud and SSH modes (default; --read-only disables). Not available over the USB web interface.
document: Name or path of the document/folder to move
dest_folder: Destination folder path (use "/" for root)
defer_restart: SSH only. Skip the xochitl restart so a batch of writes can refresh once via remarkable_refresh() instead of once per write. Sets "refresh_pending": true. Ignored in cloud mode.
remarkable_move("Meeting Notes", "/Archive")
remarkable_move("Old Project", "/Archive/2023")
Inputs: document (required), dest_folder (required), defer_restart. Returns: result
remarkable_readARead-onlyIdempotent
Read and extract text content from a reMarkable document. Extracts content from a document with pagination to preserve context window.
Content types:
"text" (default): Full extracted text (PDF/EPUB content + annotations)
"raw": Original PDF/EPUB text only (no annotations). Works in every transport, as long as the source file is present (very large PDFs/EPUBs may not be synced to the cloud).
"annotations": Only annotations, highlights, and handwritten notes
Use pagination to read large documents without overwhelming context:
Start with page=1 (default)
Check "more" field - if true, there's more content
Use "next_page" value to get the next page
"total_pages" is the physical document count; "content_pages" is the extracted-text count used by page/more/next_page
"total_pages_known" reports whether the physical count was available. Raw PDF reads count the downloaded PDF directly. If a raw EPUB archive cannot be read, content still returns with total_pages=null.
If older USB firmware returns only a native PDF, "text" returns source text without annotations and "annotations" reports that the archive is unavailable instead of trying to parse the PDF as a zip.
Use grep to search for specific content on the current page.
OCR uses Google Vision when configured, otherwise Tesseract.
document: Document name or path (use remarkable_browse to find documents)
content_type: "text" (full), "raw" (PDF/EPUB only), "annotations" (notes only)
page: Extracted-content page number (default: 1). Physical document pages are reported separately as total_pages.
grep: Optional regex pattern to filter content (searches current page)
include_ocr: Enable handwriting OCR for annotations (default: False)
remarkable_read("Meeting Notes") # Get first page of text
remarkable_read("Book.pdf", content_type="raw") # Get raw PDF text
remarkable_read("Notes", content_type="annotations") # Only annotations
remarkable_read("Report", page=2) # Get second page
remarkable_read("Manual", grep="installation") # Search for keyword
Inputs: document (required), grep, page, include_ocr, +1 more. Returns: result
remarkable_recentARead-onlyIdempotent
Get your most recently modified documents. Returns documents sorted by modification date (newest first). Optionally includes a text preview of each document's content.
Use this to quickly find what you were working on recently.
Note: If REMARKABLE_ROOT_PATH is configured, only documents within that folder are included.
limit: Maximum documents to return (default: 10, max: 50 without preview, 10 with preview)
include_preview: Include first ~200 chars of text content (default: False)
remarkable_recent() # Last 10 documents
remarkable_recent(limit=5, include_preview=True) # With content preview
Inputs: limit, include_preview. Returns: result
remarkable_renameA
Rename a document or folder on the reMarkable tablet. Changes the display name of a document or folder by updating its metadata. Find the document name with remarkable_browse() first.
Works in cloud and SSH modes (default; --read-only disables). Not available over the USB web interface.
document: Current name or path of the document/folder
new_name: New display name
defer_restart: SSH only. Skip the xochitl restart so a batch of writes can refresh once via remarkable_refresh() instead of once per write. Sets "refresh_pending": true. Ignored in cloud mode.
remarkable_rename("Untitled", "Meeting Notes 2024-01-15")
remarkable_rename("/Work/Draft", "Final Report")
Inputs: document (required), new_name (required), defer_restart. Returns: result
remarkable_searchARead-onlyIdempotent
Search across multiple documents and return matching content. Searches document names for the query, then optionally searches content with grep. Can filter by tags to narrow results. Returns summaries from multiple documents in a single call.
This is efficient for finding information across your library without making many individual tool calls.
Limits:
Max 5 documents per search (to keep response size manageable)
Returns first page (~8000 chars) of each matching document
Use grep to filter to relevant sections
query: Search term for document names
grep: Optional pattern to search within document content
limit: Max documents to return (default: 5, max: 5)
include_ocr: Enable OCR for handwritten content (default: False)
tags: List of tags to filter documents (optional, case-insensitive)
remarkable_search("meeting") # Find docs with "meeting" in name
remarkable_search("journal", grep="project") # Find "project" in journals
remarkable_search("notes", include_ocr=True) # Search with OCR enabled
remarkable_search("project", tags=["work"]) # Find work-tagged projects
Inputs: query (required), grep, tags, limit, +1 more. Returns: result
remarkable_statusARead-onlyIdempotent
Check connection status, active transport, and write capabilities. Returns authentication status, the active transport (cloud, local-dir, ssh, or usb-web), the document count, and a capability matrix describing what each transport can do. Use this to verify your connection, choose a transport, or troubleshoot.
Capability notes:
Export is available in every transport and creates only a bounded temporary local resource; it never modifies the tablet.
Cloud (default): full read/render/export/upload/mkdir/move/rename/delete — no device needed, works from anywhere your token is valid.
SSH: full capabilities over a local/USB connection to the tablet.
USB web: read, render, export, and upload (to root) only — the tablet's USB web interface firmware exposes no folder/move/rename/delete endpoints. For full write parity over a USB cable, use SSH mode pointed at the USB IP.
Local directory: fully offline read/render/export access to the desktop app's sync cache. Strictly read-only to avoid corrupting app-managed state. Write tools (upload/mkdir/move/rename/delete) are enabled by default; run with --read-only (or REMARKABLE_READ_ONLY=1) to expose a read-only server.
remarkable_status()
Inputs: no named parameters. Returns: result
remarkable_uploadA
Upload a PDF or EPUB file to the reMarkable tablet. Uploads a local file to the tablet. Only PDF and EPUB formats are supported. Works in all three transports:
Cloud: uploaded via the sync protocol; supports parent_folder + document_name
SSH: transferred over SSH, metadata created; supports parent_folder + document_name
USB web: uploaded via POST /upload. The multipart filename carries document_name, parent_folder is ignored, and the tablet web service chooses the destination folder.
Requires write mode (the default; disabled with --read-only).
file_path: Absolute path to the local PDF or EPUB file
parent_folder: Destination folder path on tablet (default: root "/"). Honored in cloud and SSH modes; ignored by the USB web interface.
document_name: Display name on tablet (default: filename without extension). Honored in every mode; USB web uses it as the uploaded filename.
defer_restart: SSH only. When True, skip the xochitl restart that normally makes the upload visible. Use this for every upload in a batch, then call remarkable_refresh() ONCE at the end. Each restart forces a full document-store rescan that briefly destabilises the SSH link, so deferring turns N restarts (and N races) into one. The response sets "refresh_pending": true while a refresh is owed. Ignored in cloud/USB modes (no xochitl).
remarkable_upload("/tmp/paper.pdf")
remarkable_upload("/tmp/book.epub", parent_folder="/Books")
remarkable_upload("/tmp/report.pdf", document_name="Q4 Report")
batch import: defer every upload, refresh once at the end
remarkable_upload("/tmp/a.pdf", defer_restart=True) remarkable_upload("/tmp/b.pdf", defer_restart=True) remarkable_refresh()
Inputs: file_path (required), defer_restart, document_name, parent_folder. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
Each tool targets a distinct operation: browsing, searching, reading text, exporting documents, rendering images, opening an interactive viewer, uploading, creating folders, moving, renaming, deleting, and checking status. While read, export, image, and canvas all retrieve content, their output formats and use cases are clearly different. No two tools have overlapping purposes.
All 14 tools follow a consistent 'remarkable_verb' or 'remarkable_noun' pattern in snake_case. Verbs are imperative where applicable (upload, move, rename, delete, search, browse, read) and nouns (status, canvas) are clear. No mixing of camelCase or inconsistent prefixes. The pattern is predictable and intuitive.
14 tools is well-scoped for a reMarkable tablet management server. It covers document retrieval (read, export, image, canvas), library navigation (browse, search, recent), file management (upload, mkdir, move, rename, delete), content creation (markdown_to_pdf), and status checking. Neither too sparse nor overwhelming.
The tool set provides full CRUD-like coverage for documents and folders, including browse, search, read, export, render, upload, create folder, move, rename, and delete. Minor gaps exist: no tool to list all tags independently, and annotation editing is absent, but these are not core to typical MCP workflows. Overall, the surface is thorough for the domain.
Maintenance
Related MCP Connectors
Personal context for every AI: search, read, and write back to your private Markdown library.
Convert PDFs, Office docs, websites and audio into AI-ready Markdown, then search and ask your docs.
Search and reason over your Obsidian-style Markdown vault, right from ChatGPT.
Securely search, create, and organize your Mem notes and collections from AI assistants.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to browse and read documents from a reMarkable tablet connected via USB, rendering PDF pages as images for the AI to see.Apache 2.0
- AlicenseAqualityDmaintenanceEnables AI assistants to read, search, and traverse your reMarkable tablet's library, including handwritten notes via OCR.12MIT
- AlicenseNot gradedqualityDmaintenanceEnables searching and exploring handwritten reMarkable notebooks through a natural conversation with Claude Desktop, with full-text search, classification, and source citations.16MIT
- AlicenseAqualityBmaintenanceEnables AI assistants to read, search, and traverse your reMarkable tablet library, including handwritten notes via OCR, turning it into a second brain.1722MIT