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.
Potencialize seu agente
O comando do próprio publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
uvx remarkable-mcp==2.1.0O Claude Code não tem link de instalação para um comando local. Copie o comando abaixo e execute-o em um terminal.
REMARKABLE_TOKEN=<secret> claude mcp add sammorrowdrums-remarkable-mcp -- uvx remarkable-mcp==2.1.0Execute em um terminal.
{ "mcpServers": { "sammorrowdrums-remarkable-mcp": { "command": "uvx", "args": [ "remarkable-mcp==2.1.0" ], "env": { "REMARKABLE_TOKEN": "<secret>" } } }}claude_desktop_config.json
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDo publicador
Access a reMarkable library from MCP clients such as Claude, VS Code Copilot, OpenWebUI, and other compatible tools.
MCP server for accessing reMarkable tablet data - sync files, extract text from highlights, and browse your reMarkable cloud
2026-07-28 and every earlier SDK-supported revision from one
stable SDK 2.x MCPServer.uvThe commands below use uvx, which is included with uv.
Page images are rasterized with PyMuPDF; no system Cairo, browser, or graphics
runtime needs to be installed on macOS, Linux, or Windows.
Use the official standalone installer:
curl -LsSf https://astral.sh/uv/install.sh | sh
Or install with Homebrew:
brew install uv
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 -e
Start with the first mode that fits your setup.
Connect via USB and enable the web interface in your tablet's Storage Settings.
Add to .vscode/mcp.json:
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--usb"],
"env": {
"GOOGLE_VISION_API_KEY": "your-api-key"
}
}
}
}
http://10.11.99.1Read 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:
~/Library/Containers/com.remarkable.desktop/Data/Library/Application Support/remarkable/desktop~/Library/Application Support/remarkable/desktop%APPDATA%\remarkable\desktop~/.local/share/remarkable/desktopOr point at any xochitl-style directory (e.g. a tablet backup):
{
"servers": {
"remarkable": {
"command": "uvx",
"args": ["remarkable-mcp", "--local-dir", "/path/to/xochitl-data"]
}
}
}
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.
Go to my.remarkable.com/device/desktop/connect and generate a code.
uvx remarkable-mcp --register YOUR_CODE
Registration 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.
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'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 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 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.
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.
¹ 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.
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's native MCP connection uses Streamable HTTP. Start remarkable-mcp on the same machine:
uvx remarkable-mcp --http
Then 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 --http
The 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.
[!WARNING] Streamable HTTP has no built-in authentication. It binds to
127.0.0.1by default. Keep that default unless you control the network boundary. Wildcard binds such as0.0.0.0and::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.
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.
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-mcp
Or copy the SKILL.md from this repository into your ~/.openclaw/skills/remarkable-mcp/ directory.
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.
remarkable_read.total_pages is the physical document count; content_pages
counts extracted-text chunks, and more / next_page continue 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 with
total_pages: null and total_pages_known: false.render_merged=False for the annotation layer alone.# 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.
Documents are automatically registered as MCP resources:
Trashed documents are excluded from tool, canvas, and resource lookup, so a trashed item cannot shadow a live document with the same name.
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.
For handwritten content, remarkable-mcp offers two OCR backends:
Set REMARKABLE_OCR_BACKEND in your MCP config:
{
"env": {
"REMARKABLE_OCR_BACKEND": "auto"
}
}
Options: auto, google, tesseract
"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 tesseract
auto)When REMARKABLE_OCR_BACKEND=auto (default):
GOOGLE_VISION_API_KEY is set)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.
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.
remarkable_delete asks the user to confirm before deleting. MCP SDK 2.x carries that prompt as a multi-round input request for 2026-07-28 clients and as push elicitation for legacy clients. If the client can't show a prompt, the delete is refused (not performed) unless REMARKABLE_SKIP_CONFIRM=1 is 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 supports permanent=True for an explicitly requested permanent removal; cloud permanent deletion remains a Trash-management operation in the app/tablet. Set REMARKABLE_SKIP_CONFIRM=1 to allow deletes without a prompt in automated setups. All write tools carry ToolAnnotations(read_only_hint=False) (and destructive_hint=True for delete) so an agent harness can gate writes at the MCP layer.xochitl restart before reporting success. A bounded debounce coalesces bursts without background or late success.xochitl's systemd start counter immediately before restart, then requires stable, non-multiplexed SSH sessions on the same boot. OpenSSH aliases are resolved with ssh -G; if USB web was reachable at that effective host before restart, port 80 must recover too. A failed probe keeps refresh_pending: true and never replays the write.defer_restart=True to each write (including remarkable_author) — or set REMARKABLE_DEFER_RESTART=1 — and call remarkable_refresh() once at the end. Deferred writes return immediately with refresh_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.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.REMARKABLE_USB_MAX_CONCURRENCY (default 2). Cloud sync keeps its existing pooled, idempotency-aware request layer and REMARKABLE_SYNC_WORKERS control.# 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")
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:
How it behaves:
ui://remarkable/canvas, MIME text/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's structuredContent (structured_content in Python)._meta.ui / ui:// metadata is inert to clients that don't advertise the MCP Apps UI extension.When write mode is on (the default) and the active transport is SSH, the canvas becomes a write surface:
.rm ink to the device.remarkable_author tool 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.
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/Projects/Work are not accessibleUseful for:
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 #00000000Default is #FBFBFB (reMarkable paper color). This affects both the remarkable_image tool and image resources.
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:
Rate-limit retries honor numeric and HTTP-date Retry-After values, capped at
20 seconds. Authentication failures trigger token renewal instead of retry.
Cloud mode is built to make a device-free workflow fast:
You normally don't need to configure any of this, but these environment variables let you tune it:
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.
git clone https://github.com/SamMorrowDrums/remarkable-mcp.git
cd remarkable-mcp
uv sync --all-extras
uv run pytest -v
Dependabot 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.
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 only
Smoke test guide and per-mode expectations.
MIT
Built with rmscene, PyMuPDF, markdown-it-py, and inspiration from ddvk/rmapi.
MCP server for accessing reMarkable tablet data - sync files, extract text from highlights, and browse your reMarkable cloud
{ "mcpServers": { "sammorrowdrums-remarkable-mcp": { "command": "uvx", "args": [ "remarkable-mcp==2.1.0" ], "env": { "REMARKABLE_TOKEN": "<secret>" } } }}Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
O publicador lista estas variáveis de ambiente: REMARKABLE_TOKEN.
Remarkable roda localmente via stdio.
Última verificação: 2026-10-28. MCP server for accessing reMarkable tablet data - sync files, extract text from highlights, and browse your reMarkable cloud