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)

Browse your reMarkable library or search for documents. Three modes:

1. Browse mode (default): List contents of a folder

   • Use path="/" for root folder

   • Use path="/FolderName" to navigate into folders

2. Search mode: Find documents by name

   • Set query="search term" to search across all documents

3. 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)

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)

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

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.

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.

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.

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).

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.

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.

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.

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.

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).

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)