Skip to content
Back to search

remarkable-mcp

MCP server for accessing reMarkable tablet data - sync files, extract text from highlights, and browse your reMarkable cloud

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/SamMorrowDrums/remarkable-mcp with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/SamMorrowDrums/remarkable-mcp'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/sammorrowdrums--remarkable-mcp/badge.svg)](/listings/sammorrowdrums--remarkable-mcp)

HTML

<a href="/listings/sammorrowdrums--remarkable-mcp"><img src="/api/listings/sammorrowdrums--remarkable-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Prerequisite: install `uv`

The commands below use `uvx`, which is included with [`uv`](https://docs.astral.sh/uv/getting-started/installation/). 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](https://docs.astral.sh/uv/getting-started/installation/#standalone-installer):

curl -LsSf https://astral.sh/uv/install.sh | sh

Or install with Homebrew:

brew install uv

Windows

Use the [official standalone installer](https://docs.astral.sh/uv/getting-started/installation/#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

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

[![Install USB Web Mode in VS Code](https://img.shields.io/badge/VS_Code-Install_USB_Web_Mode-0098FF?style=for-the-badge&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=remarkable&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22google_vision_api_key%22%2C%22description%22%3A%22Google%20Vision%20API%20Key%20(for%20handwriting%20OCR)%22%2C%22password%22%3Atrue%7D%5D&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22remarkable-mcp%22%2C%22--usb%22%5D%2C%22env%22%3A%7B%22GOOGLE_VISION_API_KEY%22%3A%22%24%7Binput%3Agoogle_vision_api_key%7D%22%7D%7D) [![Install USB Web Mode in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_USB_Web_Mode-24bfa5?style=for-the-badge&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=remarkable&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22google_vision_api_key%22%2C%22description%22%3A%22Google%20Vision%20API%20Key%20(for%20handwriting%20OCR)%22%2C%22password%22%3Atrue%7D%5D&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22remarkable-mcp%22%2C%22--usb%22%5D%2C%22env%22%3A%7B%22GOOGLE_VISION_API_KEY%22%3A%22%24%7Binput%3Agoogle_vision_api_key%7D%22%7D%7D&quality=insiders)

1. Connect your reMarkable via USB 2. On your tablet, open **Settings > Storage** and enable **USB web interface** 3. Install via the button above

<details> <summary>Manual USB web configuration</summary>

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`

</details>

---

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.

<details> <summary>Local directory configuration</summary>

Add to `.vscode/mcp.json`:

{
  "servers": {
    "remarkable": {
      "command": "uvx",
      "args": ["remarkable-mcp", "--local-dir"]
    }

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 97 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ---
  2. name: remarkable
  3. description: >
  4. Access reMarkable tablet documents, notebooks, PDFs, and EPUBs.
  5. Use when the user wants to read, search, browse, or extract text
  6. from their reMarkable tablet. Supports handwriting OCR, typed text,
  7. annotations, highlights, and page rendering to PNG/SVG.
  8. Triggers: "reMarkable", "tablet notes", "handwritten notes",
  9. "remarkable read", "remarkable search", "remarkable browse".
  10. ---
  11. # reMarkable Tablet
  12. Access your reMarkable tablet as a second brain. Browse, search, read,
  13. and extract content from all documents including handwritten notes via OCR.
  14. ## Setup
  15. Add to `openclaw.json`:
  16. ```json
  17. {
  18. "mcpServers": {
  19. "remarkable": {
  20. "command": "uvx",
  21. "args": ["remarkable-mcp", "--usb"]
  22. }
  23. }
  24. }
  25. ```
  26. USB mode is recommended — connect via USB and enable "USB web interface"
  27. in tablet Settings → Storage. No subscription or developer mode needed.
  28. ### Alternative Modes
  29. SSH (requires developer mode):
  30. ```json
  31. {
  32. "mcpServers": {
  33. "remarkable": {
  34. "command": "uvx",
  35. "args": ["remarkable-mcp", "--ssh"]
  36. }
  37. }
  38. }
  39. ```
  40. Cloud (requires Connect subscription):
  41. ```json
  42. {
  43. "mcpServers": {
  44. "remarkable": {
  45. "command": "uvx",
  46. "args": ["remarkable-mcp"],
  47. "env": {
  48. "REMARKABLE_TOKEN": "your-token"
  49. }
  50. }
  51. }
  52. }
  53. ```
  54. ### OCR Support
  55. For handwriting OCR, add a Google Vision API key:
  56. ```json
  57. {
  58. "mcpServers": {
  59. "remarkable": {
  60. "command": "uvx",
  61. "args": ["remarkable-mcp", "--usb"],
  62. "env": {
  63. "GOOGLE_VISION_API_KEY": "your-api-key"
  64. }
  65. }
  66. }
  67. }
  68. ```
  69. ## Tools
  70. | Tool | Purpose |
  71. |------|---------|
  72. | `remarkable_read` | Read document content with text extraction, pagination, grep |
  73. | `remarkable_browse` | Browse folders, search by name, filter by tags |
  74. | `remarkable_search` | Multi-document content search with OCR |
  75. | `remarkable_recent` | List recently modified documents |
  76. | `remarkable_image` | Render pages as PNG or SVG |
  77. | `remarkable_status` | Check connection and device info |
  78. ## Workflow
  79. 1. Use `remarkable_browse` or `remarkable_search` to find documents
  80. 2. Use `remarkable_read` to extract text content
  81. 3. Use `remarkable_image` to render visual pages
  82. 4. Use `page` parameter to paginate through multi-page documents
README.md · README · 938 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # reMarkable MCP Server
  2. Access a reMarkable library from MCP clients such as Claude, VS Code Copilot,
  3. OpenWebUI, and other compatible tools.
  4. <!-- mcp-name: io.github.SamMorrowDrums/remarkable -->
  5. ## Features
  6. - Browse folders and recent documents.
  7. - Search names, tags, and extracted text.
  8. - Read typed text, PDF and EPUB text, highlights, and annotations.
  9. - Render notebooks and annotated PDFs as PNG or SVG.
  10. - Export one document as a complete PDF or sectioned Markdown resource.
  11. - Run handwriting OCR through Google Vision or Tesseract.
  12. - Upload files and manage folders in supported transports.
  13. - Render Markdown as PDF and upload it to the tablet.
  14. - Open an interactive canvas in clients that support MCP Apps.
  15. - Serve MCP over stdio or local Streamable HTTP.
  16. - Serve MCP `2026-07-28` and every earlier SDK-supported revision from one
  17. stable SDK 2.x `MCPServer`.
  18. ---
  19. ## Quick Install
  20. ### Prerequisite: install `uv`
  21. The commands below use `uvx`, which is included with [`uv`](https://docs.astral.sh/uv/getting-started/installation/).
  22. Python 3.11 or later is required. If needed, install it with `uv python install 3.11`.
  23. Page images are rasterized with PyMuPDF; no system Cairo, browser, or graphics
  24. runtime needs to be installed on macOS, Linux, or Windows.
  25. #### macOS and Linux
  26. Use the [official standalone installer](https://docs.astral.sh/uv/getting-started/installation/#standalone-installer):
  27. ```bash
  28. curl -LsSf https://astral.sh/uv/install.sh | sh
  29. ```
  30. Or install with Homebrew:
  31. ```bash
  32. brew install uv
  33. ```
  34. #### Windows
  35. Use the [official standalone installer](https://docs.astral.sh/uv/getting-started/installation/#standalone-installer) from PowerShell:
  36. ```powershell
  37. powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
  38. ```
  39. Or install with WinGet:
  40. ```powershell
  41. winget install --id=astral-sh.uv -e
  42. ```
  43. ### Choose a connection
  44. Start with the first mode that fits your setup.
  45. | Order | Mode | Setup | Writes | Use when |
  46. |---:|---|---|---|---|
  47. | 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 |
  48. | 2 | Local directory | Install and sign in to the desktop app | No | You want offline, device-free reads from the desktop cache |
  49. | 3 | Cloud | Register once; Connect subscription required | Full document and folder management | You need wireless or remote access |
  50. | 4 | SSH | Enable developer mode and configure SSH | Full management and native authoring | You need direct filesystem access or native ink writes |
  51. ### USB Web Interface
  52. Connect via USB and enable the web interface in your tablet's Storage Settings.
  53. [![Install USB Web Mode in VS Code](https://img.shields.io/badge/VS_Code-Install_USB_Web_Mode-0098FF?style=for-the-badge&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=remarkable&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22google_vision_api_key%22%2C%22description%22%3A%22Google%20Vision%20API%20Key%20(for%20handwriting%20OCR)%22%2C%22password%22%3Atrue%7D%5D&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22remarkable-mcp%22%2C%22--usb%22%5D%2C%22env%22%3A%7B%22GOOGLE_VISION_API_KEY%22%3A%22%24%7Binput%3Agoogle_vision_api_key%7D%22%7D%7D)
  54. [![Install USB Web Mode in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_USB_Web_Mode-24bfa5?style=for-the-badge&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=remarkable&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22google_vision_api_key%22%2C%22description%22%3A%22Google%20Vision%20API%20Key%20(for%20handwriting%20OCR)%22%2C%22password%22%3Atrue%7D%5D&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22remarkable-mcp%22%2C%22--usb%22%5D%2C%22env%22%3A%7B%22GOOGLE_VISION_API_KEY%22%3A%22%24%7Binput%3Agoogle_vision_api_key%7D%22%7D%7D&quality=insiders)
  55. 1. Connect your reMarkable via USB
  56. 2. On your tablet, open **Settings > Storage** and enable **USB web interface**
  57. 3. Install via the button above
  58. <details>
  59. <summary>Manual USB web configuration</summary>
  60. Add to `.vscode/mcp.json`:
  61. ```json
  62. {
  63. "servers": {
  64. "remarkable": {
  65. "command": "uvx",
  66. "args": ["remarkable-mcp", "--usb"],
  67. "env": {
  68. "GOOGLE_VISION_API_KEY": "your-api-key"
  69. }
  70. }
  71. }
  72. }
  73. ```
  74. - Make sure your reMarkable is connected via USB and unlocked
  75. - Verify USB web interface is enabled in Settings > Storage
  76. - The tablet should be accessible at `http://10.11.99.1`
  77. </details>
  78. ---
  79. ### Local Directory Mode
  80. Read the official reMarkable desktop app's sync folder from disk. This mode is
  81. offline and read-only. The desktop app controls synchronization.
  82. <details>
  83. <summary>Local directory configuration</summary>
  84. Add to `.vscode/mcp.json`:
  85. ```json
  86. {
  87. "servers": {
  88. "remarkable": {
  89. "command": "uvx",
  90. "args": ["remarkable-mcp", "--local-dir"]
  91. }
  92. }
  93. }
  94. ```
  95. With no path, the desktop app's data folder is auto-detected:
  96. - **macOS (current app):** `~/Library/Containers/com.remarkable.desktop/Data/Library/Application Support/remarkable/desktop`
  97. - **macOS (legacy app):** `~/Library/Application Support/remarkable/desktop`
  98. - **Windows:** `%APPDATA%\remarkable\desktop`
  99. - **Linux:** `~/.local/share/remarkable/desktop`
  100. Or point at any xochitl-style directory (e.g. a tablet backup):
  101. ```json
  102. {
  103. "servers": {
  104. "remarkable": {
  105. "command": "uvx",
  106. "args": ["remarkable-mcp", "--local-dir", "/path/to/xochitl-data"]
  107. }
  108. }
  109. }
  110. ```
  111. - Content freshness depends on the desktop app. Keep it running and signed in.
  112. - This mode is read-only. Direct writes could bypass synchronization and corrupt the app cache.
  113. - 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)
  114. </details>
  115. ---
  116. ### Cloud Mode
  117. Cloud mode works without a device connection and requires a reMarkable Connect subscription.
  118. It fetches metadata in parallel and caches content-addressed blobs on disk. See
  119. [Cloud performance and caching](#cloud-performance--caching) for configuration.
  120. <details>
  121. <summary>Cloud mode setup</summary>
  122. #### 1. Get a One-Time Code
  123. Go to [my.remarkable.com/device/desktop/connect](https://my.remarkable.com/device/desktop/connect) and generate a code.
  124. #### 2. Convert to Token
  125. ```bash
  126. uvx remarkable-mcp --register YOUR_CODE
  127. ```
  128. 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.
  129. #### 3. Configure your MCP client
  130. ##### Minimal client-neutral server definition
  131. Add this server definition using the MCP configuration UI or wrapper required by your client:
  132. ```json
  133. {
  134. "command": "uvx",
  135. "args": ["remarkable-mcp"]
  136. }
  137. ```
  138. No `env` entry is needed when the server can read the token from `~/.rmapi`.
  139. ##### VS Code
  140. VS Code's `.vscode/mcp.json` uses a top-level `servers` object. The saved
  141. `~/.rmapi` credential means no token input is required:
  142. ```json
  143. {
  144. "servers": {
  145. "remarkable": {
  146. "command": "uvx",
  147. "args": ["remarkable-mcp"]
  148. }
  149. }
  150. }
  151. ```
  152. ##### Claude Desktop and other clients
  153. 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:
  154. ```json
  155. {
  156. "mcpServers": {
  157. "remarkable": {
  158. "command": "uvx",
  159. "args": ["remarkable-mcp"]
  160. }
  161. }
  162. }
  163. ```
  164. 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.
  165. </details>
  166. ---
  167. ### SSH Mode
  168. SSH provides direct filesystem access and native notebook authoring. It requires
  169. [developer mode](docs/ssh-setup.md), which factory-resets the tablet when enabled.
  170. Use this mode only when USB web, local directory, or cloud mode does not provide the
  171. operation you need.
  172. ```json
  173. {
  174. "servers": {
  175. "remarkable": {
  176. "command": "uvx",
  177. "args": ["remarkable-mcp", "--ssh"]
  178. }
  179. }
  180. }
  181. ```
  182. See the [SSH setup guide](docs/ssh-setup.md) for authentication and device setup.
  183. ---
  184. <!-- Screenshots section - uncomment when screenshots are added
  185. ## Screenshots
  186. ### MCP Resources
  187. Documents appear as resources that AI assistants can access directly:
  188. ![Resources in VS Code](docs/assets/resources-screenshot.png)
  189. ### Tool Calls in Action
  190. AI assistants use the tools to read documents, search content, and more:
  191. ![Tool calls in VS Code](docs/assets/tool-calls-screenshot.png)
  192. -->
  193. ---
  194. ## Connection Modes
  195. All modes support reading, rendering, and single-document export. Cloud and SSH support full library
  196. management. USB web supports upload but does not accept a destination folder.
  197. Local directory mode is
  198. read-only.
  199. | Mode | Setup | Subscription | Offline | Tablet required | Raw source | Upload | Folder operations¹ |
  200. |---|---|---|---|---|---|---|---|
  201. | Local directory | Desktop app installed | No² | Yes | No | PDF and EPUB | No | No |
  202. | USB web | Enable in Settings | No | Yes | Yes | PDF | Root only | No |
  203. | Cloud | One-time registration | Connect | No | No | PDF and EPUB | Yes | Yes |
  204. | SSH | Developer mode | No | Yes | Yes | PDF and EPUB | Yes | Yes |
  205. ¹ 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.
  206. ² 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.
  207. ### Automatic cloud fallback
  208. If a selected device transport is unavailable and a cloud credential is configured,
  209. the server falls back to cloud mode. A server launched with `--local-dir` remains
  210. read-only after fallback. `remarkable_status` reports the effective transport and
  211. sets `fell_back_to_cloud`.
  212. Pass `--no-cloud-fallback` (or set `REMARKABLE_DISABLE_CLOUD_FALLBACK=1`) to disable this and fail instead when the device is unreachable.
  213. The transport is resolved once per server process. Restart the MCP server after
  214. connecting a device or starting the desktop app if the process already fell back to
  215. cloud.
  216. Detailed setup:
  217. - [USB web setup](docs/usb-web-setup.md)
  218. - [SSH setup](docs/ssh-setup.md)
  219. - [Cloud performance and caching](#cloud-performance--caching)
  220. ---
  221. ## OpenWebUI (Streamable HTTP)
  222. OpenWebUI's native MCP connection uses Streamable HTTP. Start remarkable-mcp on
  223. the same machine:
  224. ```bash
  225. uvx remarkable-mcp --http
  226. ```
  227. Then add `http://127.0.0.1:8000/mcp` as the MCP server URL in OpenWebUI. The
  228. HTTP transport combines with `--usb`, `--ssh`, and `--read-only`; for example:
  229. ```bash
  230. uvx remarkable-mcp --usb --http
  231. ```
  232. The bind address and port can also be set with `--host` / `--port` or
  233. `REMARKABLE_MCP_HOST` / `REMARKABLE_MCP_PORT`.
  234. The server uses MCP Python SDK 2.x's dual-era endpoint. Modern
  235. `2026-07-28` requests are sessionless; older clients continue to use the
  236. initialize handshake and legacy MCP sessions on the same `/mcp` route. The
  237. reMarkable token and selected tablet transport remain process-local CLI/env
  238. configuration and are never inferred from MCP HTTP authorization headers.
  239. > [!WARNING]
  240. > Streamable HTTP has no built-in authentication. It binds to `127.0.0.1` by
  241. > default. Keep that default unless you control the network boundary. Wildcard
  242. > binds such as `0.0.0.0` and `::` are rejected because they cannot provide a
  243. > strict Host allowlist. A concrete non-loopback address is allowed but exposes
  244. > every enabled tool, including writes, to clients that can reach the port.
  245. ### Remote access through an authenticated reverse proxy
  246. Keep remarkable-mcp on its default loopback bind and put the proxy on the same
  247. host. MCPServer's DNS-rebinding protection only permits loopback `Host` and
  248. `Origin` values by default. A proxy that forwards its public hostname unchanged
  249. will therefore receive **421 Misdirected Request**; a public browser `Origin`
  250. will receive **403 Forbidden**.
  251. The proxy must authenticate requests, rewrite `Host` to the loopback upstream,
  252. and clear `Origin`. For example, with nginx and an existing htpasswd file:
  253. ```nginx
  254. location /mcp {
  255. auth_basic "reMarkable MCP";
  256. auth_basic_user_file /etc/nginx/remarkable-mcp.htpasswd;
  257. proxy_pass http://127.0.0.1:8000;
  258. proxy_http_version 1.1;
  259. proxy_buffering off;
  260. proxy_read_timeout 3600s;
  261. # Required by MCPServer's default DNS-rebinding protection.
  262. proxy_set_header Host 127.0.0.1:8000;
  263. proxy_set_header Origin "";
  264. }
  265. ```
  266. Do not expose the upstream port directly. Configure OpenWebUI with the
  267. authenticated proxy URL, such as `https://mcp.example.com/mcp`.
  268. For NixOS, `remarkable-mcp-bridge.nix` provides a systemd module with the same
  269. loopback default:
  270. ```nix
  271. {
  272. imports = [ ./remarkable-mcp-bridge.nix ];
  273. services.remarkable-mcp = {
  274. enable = true;
  275. command = "/opt/remarkable-mcp/.venv/bin/remarkable-mcp";
  276. };
  277. }
  278. ```
  279. The service user must have its reMarkable credentials under
  280. `/var/lib/remarkable-mcp` (or the configured `home`). The module adds
  281. Tesseract to the service's executable search path; install the configured
  282. `command` separately.
  283. ---
  284. ## OpenClaw Integration
  285. remarkable-mcp works as an [OpenClaw](https://github.com/openclaw/openclaw) skill. Add to your `openclaw.json`:
  286. ```json
  287. {
  288. "mcpServers": {
  289. "remarkable": {
  290. "command": "uvx",
  291. "args": ["remarkable-mcp", "--usb"]
  292. }
  293. }
  294. }
  295. ```
  296. Install from [ClawHub](https://clawhub.ai):
  297. ```bash
  298. clawhub install remarkable-mcp
  299. ```
  300. Or copy the `SKILL.md` from this repository into your `~/.openclaw/skills/remarkable-mcp/` directory.
  301. ---
  302. ## Tools
  303. | Tool | Description |
  304. |------|-------------|
  305. | `remarkable_read` | Read and extract text from documents (with pagination and search) |
  306. | `remarkable_browse` | Navigate folders, search by document name, or filter by tags |
  307. | `remarkable_search` | Search content across multiple documents (with tag filtering) |
  308. | `remarkable_recent` | Get recently modified documents |
  309. | `remarkable_status` | Check connection status and the per-transport capability matrix |
  310. | `remarkable_image` | Get PNG/SVG images of pages with optional OCR |
  311. | `remarkable_export` | Export one document as a temporary PDF or Markdown resource |
  312. The read/search/render tools are read-only. `remarkable_export` never changes the
  313. tablet, but it writes a bounded temporary file on the MCP server host and therefore
  314. declares `readOnlyHint=false`. Export links expire after 15 minutes and the server
  315. retains at most eight at a time.
  316. Supported transports also register write tools by default; pass `--read-only` to
  317. disable them. See [Write Tools](#write-tools-by-transport). Clients that support
  318. [MCP Apps](#interactive-canvas-app-mcp-apps) can also open `remarkable_canvas`.
  319. [Full tools reference](docs/tools.md)
  320. ### Tool behavior
  321. - Browsing a document path returns its content.
  322. - Empty notebook text can trigger OCR automatically.
  323. - Search can scan several matching documents.
  324. - Image tools return visual content that text extraction misses.
  325. - `remarkable_read.total_pages` is the physical document count; `content_pages`
  326. counts extracted-text chunks, and `more` / `next_page` continue those chunks.
  327. Raw PDF reads count pages from the already-downloaded PDF. If a raw EPUB's
  328. separate archive cannot be read, its text still returns with
  329. `total_pages: null` and `total_pages_known: false`.
  330. - PNG images of PDF-backed pages merge the source page and annotations
  331. automatically; pass `render_merged=False` for the annotation layer alone.
  332. - PDF exports preserve physical page order and merge mapped source underlays with
  333. annotations by default. Markdown exports keep fixed source/typed/annotation/
  334. highlight/OCR sections without guessing document structure.
  335. - OCR uses Google Vision when configured and otherwise runs locally with Tesseract.
  336. - Browse and search accept tag filters.
  337. ### Example Usage
  338. ```python
  339. # Read a document
  340. remarkable_read("Meeting Notes")
  341. # Search for keywords
  342. remarkable_read("Project Plan", grep="deadline")
  343. # Enable OCR for handwritten notes
  344. remarkable_read("Journal", include_ocr=True)
  345. # Browse your library
  346. remarkable_browse("/Work/Projects")
  347. # Filter by tags
  348. remarkable_browse("/", tags=["important"])
  349. remarkable_browse("/Work", tags=["project", "active"])
  350. # Search across documents
  351. remarkable_search("meeting", grep="action items")
  352. # Search with tag filter
  353. remarkable_search("project", tags=["work"])
  354. # Get recent documents
  355. remarkable_recent(limit=10)
  356. # Get a page image (for visual content like UI mockups or diagrams)
  357. remarkable_image("UI Mockup", page=1)
  358. # Get SVG for editing in design tools
  359. remarkable_image("Wireframe", output_format="svg")
  360. # Get image with OCR text extraction
  361. remarkable_image("Handwritten Notes", include_ocr=True)
  362. # Imported PDF pages include their reMarkable annotations automatically
  363. remarkable_image("Research Paper", page=3)
  364. # Request only the reMarkable annotation layer
  365. remarkable_image("Research Paper", page=3, render_merged=False)
  366. # Transparent background for compositing
  367. remarkable_image("Logo Sketch", background="#00000000")
  368. # Compatibility mode: return resource URI instead of embedded resource
  369. remarkable_image("Diagram", compatibility=True)
  370. # Export a complete PDF through a temporary MCP ResourceLink
  371. remarkable_export("Meeting Notes")
  372. # Export honest, sectioned Markdown with opt-in OCR
  373. remarkable_export("Journal", output_format="markdown", include_ocr=True)
  374. # Export only full-page annotation layers when archive data is available
  375. remarkable_export("Research Paper", pdf_mode="annotations")
  376. ```
  377. > **Note:** PNG rendering uses PyMuPDF for both notebook SVGs and PDF pages, so
  378. > `remarkable_image` does not require Cairo, Inkscape, Chromium, or another
  379. > system graphics runtime. If local stroke parsing cannot handle a page, USB
  380. > and SSH modes fall back to the tablet's native PDF export and cloud mode falls
  381. > back to an original source PDF when one exists.
  382. ---
  383. ## Resources
  384. Documents are automatically registered as MCP resources:
  385. | URI Scheme | Description |
  386. |------------|-------------|
  387. | `remarkable:///{path}.txt` | Extracted text content |
  388. | `remarkableraw:///{path}.pdf.txt` | Extracted text from the original PDF |
  389. | `remarkableraw:///{path}.epub.txt` | Extracted text from the original EPUB |
  390. | `remarkableimg:///{path}.page-{N}.png` | PNG image of page N (notebooks only) |
  391. | `remarkablesvg:///{path}.page-{N}.svg` | SVG vector image of page N (notebooks only) |
  392. | `remarkableexport:///{format}/{id}` | Temporary generated PDF or Markdown export |
  393. Trashed documents, including descendants of trashed folders, are excluded from
  394. read tools, canvas, resources, and live document counts. Write tools prefer live
  395. namesakes and never use trashed destinations. With no configured root, an explicit
  396. absolute `/trash/...` write target remains available for SSH permanent deletion;
  397. it cannot bypass `REMARKABLE_ROOT_PATH`.
  398. `remarkable_export` returns a `ResourceLink` instead of embedding potentially
  399. large file content in the tool response. The server stores the file in a private
  400. temporary directory for 15 minutes, retains at most eight exports, and removes
  401. managed exports at shutdown. Fetch and save the linked resource for durable use.
  402. [Full resources reference](docs/resources.md)
  403. ---
  404. ## OCR for Handwriting
  405. For handwritten content, remarkable-mcp offers two OCR backends:
  406. | Backend | Setup | Offline | Notes |
  407. |---|---|---|---|
  408. | Google Vision | API key | No | Good handwriting support |
  409. | Tesseract | System install | Yes | Better suited to printed text |
  410. ### Quick Setup
  411. Set `REMARKABLE_OCR_BACKEND` in your MCP config:
  412. ```json
  413. {
  414. "env": {
  415. "REMARKABLE_OCR_BACKEND": "auto"
  416. }
  417. }
  418. ```
  419. **Options:** `auto`, `google`, `tesseract`
  420. <details>
  421. <summary>Google Cloud Vision</summary>
  422. 1. Enable [Cloud Vision API](https://console.cloud.google.com/apis/library/vision.googleapis.com)
  423. 2. Create an [API key](https://console.cloud.google.com/apis/credentials)
  424. 3. Add to config: `"GOOGLE_VISION_API_KEY": "your-key"`
  425. **Cost:** 1,000 free requests/month, then ~$1.50 per 1,000.
  426. [Google Vision setup guide](docs/google-vision-setup.md)
  427. </details>
  428. <details>
  429. <summary>Tesseract</summary>
  430. Open-source OCR designed for printed text. Poor results with handwriting, but useful as an offline fallback.
  431. ```bash
  432. # Install Tesseract
  433. # macOS
  434. brew install tesseract
  435. # Ubuntu/Debian
  436. sudo apt install tesseract-ocr
  437. # Windows
  438. choco install tesseract
  439. ```
  440. </details>
  441. ### Default Behavior (`auto`)
  442. When `REMARKABLE_OCR_BACKEND=auto` (default):
  443. 1. Google Vision (if `GOOGLE_VISION_API_KEY` is set)
  444. 2. Tesseract (fallback)
  445. ---
  446. ## Write Tools by Transport
  447. 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.
  448. | Feature | Local Directory | Cloud Mode | SSH Mode | USB Web Mode |
  449. |---------|:---------------:|:----------:|:--------:|:------------:|
  450. | Upload | ❌ | ✅ | ✅ | ✅ (tablet-selected folder) |
  451. | Mkdir | ❌ | ✅ | ✅ | ❌ |
  452. | Move | ❌ | ✅ | ✅ | ❌ |
  453. | Rename | ❌ | ✅ | ✅ | ❌ |
  454. | Delete | ❌ | ✅ (→ trash) | ✅ (→ trash; optional permanent) | ❌ |
  455. ### Disabling Write Tools (read-only mode)
  456. 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:
  457. ```json
  458. {
  459. "servers": {
  460. "remarkable": {
  461. "command": "uvx",
  462. "args": ["remarkable-mcp", "--read-only"]
  463. }
  464. }
  465. }
  466. ```
  467. It combines with any transport flag (`--ssh`, `--usb`):
  468. ```json
  469. {
  470. "servers": {
  471. "remarkable": {
  472. "command": "uvx",
  473. "args": ["remarkable-mcp", "--ssh", "--read-only"]
  474. }
  475. }
  476. }
  477. ```
  478. Or set the environment variable:
  479. ```json
  480. {
  481. "env": {
  482. "REMARKABLE_READ_ONLY": "1"
  483. }
  484. }
  485. ```
  486. > The legacy `--write` flag and `REMARKABLE_ENABLE_WRITE` variable are still accepted for backward compatibility but are now no-ops (write is the default). `--write` and `--read-only` are mutually exclusive.
  487. ### Available Write Tools
  488. | Tool | Description |
  489. |------|-------------|
  490. | `remarkable_upload(file_path, parent_folder, document_name, defer_restart)` | Upload a PDF or EPUB file (cloud, SSH, and USB web; USB web preserves the name but ignores `parent_folder`) |
  491. | `remarkable_markdown_to_pdf(markdown, document_name, parent_folder, defer_restart)` | Render Markdown as a paginated PDF and upload it (cloud, SSH, and USB web) |
  492. | `remarkable_mkdir(folder_name, parent, defer_restart)` | Create a new folder (cloud and SSH) |
  493. | `remarkable_move(document, dest_folder, defer_restart)` | Move a document or folder (cloud and SSH) |
  494. | `remarkable_rename(document, new_name, defer_restart)` | Rename a document or folder (cloud and SSH) |
  495. | `remarkable_delete(document, defer_restart, permanent)` | Move a document/folder to Trash; SSH can permanently remove it with `permanent=True` |
  496. | `remarkable_refresh()` | Safely restart `xochitl` once to apply pending writes made with `defer_restart=True`; no-op after this process has confirmed a clean state — **SSH only** |
  497. | `remarkable_author(method, ..., defer_restart)` | Author native ink and notebooks — `draw` (append strokes), `add_page` (append a blank notebook page), `create_document` (new notebook) — **SSH only** |
  498. ### Safety
  499. - **Upload registers in cloud, SSH, and USB web mode** — local-directory mode never exposes write tools.
  500. - **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.
  501. - **Delete prompts for confirmation when possible** — if the client supports MCP elicitation, `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.
  502. - **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.
  503. - **Concurrent SSH writes share a refresh barrier** — near-simultaneous writes are persisted in FIFO order, then every participating call waits for one shared `xochitl` restart before reporting success. A bounded debounce coalesces bursts without background or late success.
  504. - **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 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.
  505. - **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.
  506. - For explicit bulk operations, pass `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.
  507. - 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.
  508. - USB HTTP requests use the same bounded operation core with `REMARKABLE_USB_MAX_CONCURRENCY` (default `2`). Cloud sync keeps its existing pooled, idempotency-aware request layer and `REMARKABLE_SYNC_WORKERS` control.
  509. ### Examples
  510. ```python
  511. # Upload a PDF
  512. remarkable_upload("paper.pdf", parent_folder="/Research")
  513. # Render Markdown and upload the PDF without creating a local file
  514. remarkable_markdown_to_pdf(
  515. "# Meeting Notes\n\n- Follow up with Sam",
  516. document_name="Meeting Notes",
  517. parent_folder="/Research",
  518. )
  519. # Create a folder
  520. remarkable_mkdir("2024 Archive", parent="/Archive")
  521. # Move a document
  522. remarkable_move("Meeting Notes", "/Archive/2024 Archive")
  523. # Rename a document
  524. remarkable_rename("Untitled", "Q4 Planning Notes")
  525. # Delete (destructive; confirms via elicitation when supported)
  526. remarkable_delete("Old Draft")
  527. # Permanently delete in SSH mode only
  528. remarkable_delete("Disposable Test", permanent=True)
  529. # Bulk import (SSH): defer the restart on each write, then refresh once.
  530. # One xochitl restart for the whole batch instead of one per upload.
  531. remarkable_upload("a.pdf", parent_folder="/Research", defer_restart=True)
  532. remarkable_upload("b.pdf", parent_folder="/Research", defer_restart=True)
  533. remarkable_refresh()
  534. # Author native ink and notebooks (SSH only)
  535. # Append pen/highlighter strokes to a page (coordinates normalized [0,1] from
  536. # the page's top-left). The interactive canvas Save button calls this too.
  537. remarkable_author(
  538. method="draw",
  539. document="Ideas",
  540. page=1,
  541. strokes=[{"points": [[0.1, 0.2], [0.8, 0.2]], "tool": "highlighter", "color": "yellow"}],
  542. )
  543. # Append a blank, drawable page to the end of a notebook
  544. remarkable_author(method="add_page", document="Ideas")
  545. # Create a new blank notebook
  546. remarkable_author(method="create_document", name="Sketches")
  547. # Only seed typed text when the user explicitly requested it.
  548. remarkable_author(method="create_document", name="Meeting notes", text="Agenda\nFollow-ups")
  549. ```
  550. ---
  551. ## Interactive Canvas App (MCP Apps)
  552. An interactive page viewer built on the [MCP Apps](https://github.com/modelcontextprotocol/ext-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.
  553. 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.
  554. This registers one tool:
  555. | Tool | Description |
  556. |------|-------------|
  557. | `remarkable_canvas(document, page)` | Open a page in the interactive canvas viewer |
  558. How it behaves:
  559. - **App-capable clients** open the canvas (declared at `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).
  560. - **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.
  561. ### Drawing and authoring from the canvas
  562. When write mode is on (the default) **and** the active transport is SSH, the canvas becomes a write surface:
  563. - **Draw**: choose a pen or highlighter, draw, then save native `.rm` ink to the device.
  564. - **Add page**: queue a blank native notebook page, draw on it, then save.
  565. - One source of truth: the canvas calls the **same** `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.
  566. 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.
  567. ---
  568. ## Advanced Configuration
  569. ### Root Path Filtering
  570. Limit the MCP server to a specific folder on your reMarkable. All operations will be scoped to this folder:
  571. ```json
  572. {
  573. "servers": {
  574. "remarkable": {
  575. "command": "uvx",
  576. "args": ["remarkable-mcp", "--ssh"],
  577. "env": {
  578. "REMARKABLE_ROOT_PATH": "/Work",
  579. "GOOGLE_VISION_API_KEY": "your-api-key"
  580. }
  581. }
  582. }
  583. }
  584. ```
  585. With this configuration:
  586. - `remarkable_browse("/")` shows contents of `/Work`
  587. - `remarkable_browse("/Projects")` shows `/Work/Projects`
  588. - Documents outside `/Work` are not accessible
  589. - Write 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 error
  590. - USB web uploads are refused while a root is set, because that interface cannot choose a folder
  591. Useful for:
  592. - Focusing on work documents during office hours
  593. - Separating personal and professional notes
  594. - Limiting scope for specific AI workflows
  595. ### Custom Background Color
  596. Set the default background color for image rendering:
  597. ```json
  598. {
  599. "servers": {
  600. "remarkable": {
  601. "command": "uvx",
  602. "args": ["remarkable-mcp", "--ssh"],
  603. "env": {
  604. "REMARKABLE_BACKGROUND_COLOR": "#FFFFFF"
  605. }
  606. }
  607. }
  608. }
  609. ```
  610. Supported formats:
  611. - `#RRGGBB`: RGB hex, such as `#FFFFFF`
  612. - `#RRGGBBAA`: RGBA hex, such as `#00000000`
  613. Default is `#FBFBFB` (reMarkable paper color). This affects both the `remarkable_image` tool and image resources.
  614. ---
  615. ### Retry Configuration
  616. 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:
  617. | Variable | Default | Description |
  618. |----------|---------|-------------|
  619. | `REMARKABLE_RETRY_ATTEMPTS` | `3` | Maximum number of request attempts (minimum 1) |
  620. | `REMARKABLE_RETRY_DELAY` | `2.0` | Base delay in seconds for exponential backoff |
  621. Rate-limit retries honor numeric and HTTP-date `Retry-After` values, capped at
  622. 20 seconds. Authentication failures trigger token renewal instead of retry.
  623. ---
  624. ### Cloud Performance & Caching
  625. Cloud mode is built to make a device-free workflow fast:
  626. - **Parallel traversal**: fetch document metadata concurrently.
  627. - **Connection pooling**: reuse HTTP connections.
  628. - **Content-addressed blob cache**: reuse immutable blobs by hash and fetch new hashes when documents change.
  629. You normally don't need to configure any of this, but these environment variables let you tune it:
  630. | Variable | Default | Description |
  631. |----------|---------|-------------|
  632. | `REMARKABLE_SYNC_WORKERS` | `16` | Parallel workers for cloud fetches (clamped to `64`). |
  633. | `REMARKABLE_DISABLE_CACHE` | unset | Set to `1` to disable the on-disk blob cache entirely. |
  634. | `REMARKABLE_CACHE_DIR` | `~/.remarkable/cache/blobs` | Where cached blobs are stored. |
  635. | `REMARKABLE_CACHE_MAX_BLOB` | `4194304` (4 MiB) | Blobs larger than this are streamed through but not cached. |
  636. 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.
  637. ---
  638. ## Common Workflows
  639. - Read recent notes and extract action items.
  640. - Search names, tags, typed text, and OCR output.
  641. - Review annotated PDFs with the source page and annotations together.
  642. - Move selected notes into another local workflow.
  643. - Upload reference PDFs or generated Markdown documents.
  644. ---
  645. ## Documentation
  646. | Guide | Description |
  647. |-------|-------------|
  648. | [SSH Setup](docs/ssh-setup.md) | Enable developer mode and configure SSH |
  649. | [Google Vision Setup](docs/google-vision-setup.md) | Set up handwriting OCR |
  650. | [Tools Reference](docs/tools.md) | Detailed tool documentation |
  651. | [Resources Reference](docs/resources.md) | MCP resources documentation |
  652. | [Capability Negotiation](docs/capabilities.md) | MCP protocol capabilities |
  653. | [Development](docs/development.md) | Contributing and development setup |
  654. | [Future Plans](docs/future-plans.md) | Roadmap and planned features |
  655. ---
  656. ## Development
  657. ```bash
  658. git clone https://github.com/SamMorrowDrums/remarkable-mcp.git
  659. cd remarkable-mcp
  660. uv sync --all-extras
  661. uv run pytest -v
  662. ```
  663. [Development guide](docs/development.md)
  664. Dependabot checks Python dependencies and `uv.lock` through the `uv` ecosystem,
  665. and GitHub Actions, weekly. Dependency updates are audited with `pip-audit`;
  666. see the development guide for the full update and validation commands.
  667. ### Multi-transport smoke test
  668. When something looks broken, run the deterministic, no-AI smoke test first. It
  669. drives the real server over MCP and exercises every available tool in every
  670. reachable transport in this order: local directory, cloud, USB web, then SSH.
  671. ```bash
  672. uv run python smoke/run_smoke.py # all available modes
  673. uv run python smoke/run_smoke.py --read-only # connectivity + reads only
  674. ```
  675. [Smoke test guide](smoke/README.md)
  676. and per-mode expectations.
  677. ---
  678. ## License
  679. MIT
  680. ---
  681. Built with [rmscene](https://github.com/ricklupton/rmscene),
  682. [PyMuPDF](https://pymupdf.readthedocs.io/),
  683. [markdown-it-py](https://github.com/executablebooks/markdown-it-py), and
  684. inspiration from [ddvk/rmapi](https://github.com/ddvk/rmapi).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.