How do I use remarkable-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@remarkable-mcp List my notebooks" 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

by lukaisailovic

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

remarkable-mcp

Give an AI assistant direct control of your reMarkable tablet — list notes, upload PDFs, export handwriting, write on pages — over SSH or rmfakecloud.

The assistant gets one MCP tool, remarkable_execute, and writes a short JavaScript snippet that calls rme.* (list, mkdir, write, export, …) in one shot.

You have	This project is
A reMarkable with developer mode	An MCP server
SSH (USB `10.11.99.1` / Wi‑Fi) or rmfakecloud	stdio or Streamable HTTP (Docker)
Claude / Cursor / VS Code / any MCP client	Same `rme.*` on either storage backend

How it works

MCP client                    this process                         storage
───────────                   ────────────                         ───────
remarkable_execute({          node:vm sandbox                      SSH → xochitl
  code: `async () => {   →    rme.list / rme.mkdir / …      →      or rmfakecloud sync v3
    await rme.mkdir(…)
    return await rme.list({})
  }`
})

Default is SSH into the tablet. rmfakecloud is opt-in (RMFAKECLOUD_URL + device token).

Enable Settings → General → Developer mode on the tablet (SSH).
SSH over USB (root@10.11.99.1) or Wi‑Fi — or pair with your rmfakecloud.
Run this server. Point your MCP client at it.

Related MCP server: remark-mcp

Install

Node 22+. No clone required.

Claude Desktop, Cursor, VS Code, …

{
  "mcpServers": {
    "remarkable": {
      "command": "npx",
      "args": ["-y", "@lukaisailovic/remarkable-mcp"],
      "env": {
        "REMARKABLE_HOST": "10.11.99.1",
        "REMARKABLE_USER": "root",
        "REMARKABLE_PASSWORD": "your-tablet-password"
      }
    }
  }
}

Prefer a key? Set REMARKABLE_KEY to a private-key path (or the PEM). If unset, ~/.ssh/id_ed25519 then id_rsa are tried.

rmfakecloud

Same rme.*, sync-v3 instead of SFTP. Pair once, save the device token:

{
  "mcpServers": {
    "remarkable": {
      "command": "npx",
      "args": ["-y", "@lukaisailovic/remarkable-mcp"],
      "env": {
        "RMFAKECLOUD_URL": "https://cloud.example",
        "RMFAKECLOUD_TOKEN": "device-jwt-from-pair"
      }
    }
  }
}

First pair: npx -y @lukaisailovic/remarkable-mcp --cloud https://cloud.example --pair ABCDEFGH (code from the rmfakecloud UI). It prints a device token to stderr. Writes commit the hash tree; the tablet picks them up on next Check Sync. Not official reMarkable Cloud.

HTTP

Same server, Streamable HTTP on /mcp:

npx -y @lukaisailovic/remarkable-mcp --http
# → http://127.0.0.1:8080/mcp    health: /health

Or pull the image from GHCR:

docker run --rm -p 8080:8080 \
  -e REMARKABLE_HOST=10.11.99.1 \
  -e REMARKABLE_PASSWORD=your-tablet-password \
  ghcr.io/lukaisailovic/remarkable-mcp:latest

From a clone: docker compose up --build (bind 0.0.0.0:8080, pass REMARKABLE_*).

A local checkout’s .mcp.json watches src/ and restarts the stdio child on save (no client restart). pnpm dev:http does the same for Streamable HTTP. In Grok, /mcps disable+enable respawns the process; r only refreshes the list.

What the model can do

The client only lists remarkable_execute. Inside the snippet, methods live on rme.

async () => {
  const folder = await rme.mkdir({ name: "Projects" });
  await rme.createNotebook({ name: "Ideas", parent: folder.id });
  await rme.writeText({
    notebook: "Ideas",
    newPage: true,
    blocks: [
      { text: "Ship it", style: "title" },
      { text: "Talk to design", style: "checkbox" },
    ],
  });
  await rme.writeText({ notebook: "Ideas", text: "Write the RFC", style: "checkbox" });
  return await rme.read({ notebook: "Ideas", page: 2 });
};

A notebook is the file (name, path /Work/Notes, or UUID). A page is 1-based inside that notebook. writeText always writes native Type Folio text and appends — call it again to stack more paragraphs. Ink points are [x, y] in 0–1 from the top-left. remove moves to trash. Writes apply once after the tool returns: SSH restarts xochitl; rmfakecloud commits the sync tree.

`rme.*`	What it does
`list({ includeTrash?, folder? })`	Library listing (trash hidden by default)
`browse({ path? })`	One folder, or a single notebook
`search({ query, tag? })`	Name / path search, optional tag
`info({ notebook })`	Id, path, type, tags, page count, `pages[].title`
`read({ notebook, page? })`	Native paragraphs (and checkbox state), or all pages if `page` is omitted. PDF/EPUB text.
`download({ notebook })`	Raw PDF/EPUB as base64
`exportPage({ notebook, page?, format? })`	Ink on a page → `png` or `svg` (typed text is not drawn)
`upload({ name, dataBase64, parent?, fileType? })`	Put a PDF or EPUB on the tablet
`mkdir` / `move` / `rename` / `remove`	Folders and trash
`createNotebook` / `addPage` / `removePage`	Notebooks and pages
`writeInk({ notebook, strokes, page? })`	Pen / highlighter strokes
`writeMermaid({ notebook, mermaid, page? })`	Mermaid → ink (flowchart, sequence, state, class, ER, xychart)
`writeText({ notebook, text?, style?, checked?, blocks?, page?, newPage?, replace? })`	Native Type Folio: `title` `heading` `body` `bullet` `checkbox`. Stacks unless `replace`.
`tag({ notebook, tag, remove?, page? })` / `tags()`	Notebook or page tags
`refresh()`	Apply now (SSH: restart xochitl; cloud: pull if remote moved, then commit)

Configuration

Flags and env vars are interchangeable (--host ≡ REMARKABLE_HOST).

Tablet	Default
`REMARKABLE_HOST` / `--host`	`10.11.99.1`	SSH host (USB default)
`REMARKABLE_USER` / `--user`	`root`	SSH user
`REMARKABLE_PORT` / `--port`	`22`	SSH port
`REMARKABLE_PASSWORD` / `--password`		Password
`REMARKABLE_KEY` / `--key`	`~/.ssh/id_ed25519`, then `id_rsa`	Key path or PEM

rmfakecloud	Default
`RMFAKECLOUD_URL` / `--cloud`		Base URL of your rmfakecloud
`RMFAKECLOUD_TOKEN` / `--token`		Device JWT from a prior `--pair`
`RMFAKECLOUD_PAIR` / `--pair`		One-shot 8-letter pairing code

Server	Default
`--http` / `MCP_HTTP=1`	off	Streamable HTTP instead of stdio
`MCP_HTTP_HOST` / `--http-host`	`127.0.0.1`	Bind address (`0.0.0.0` in Docker)
`MCP_HTTP_PORT` / `PORT` / `--http-port`	`8080`	HTTP port
`--fake` / `REMARKABLE_FAKE=1`	off	In-memory tablet (tests, no device)
`--fake-dir` / `REMARKABLE_FAKE_DIR`		Local directory treated as a xochitl tree

Agent skill

Installable with skills.sh:

npx skills add lukaisailovic/remarkable-mcp

The skill lives at skills/remarkable-mcp/SKILL.md.

Develop

pnpm test
pnpm test:e2e
pnpm lint
pnpm fmt
pnpm build
pnpm exec tsx src/index.ts --fake
pnpm exec tsx src/index.ts --fake --http --http-port 8080

pnpm test uses an in-memory tablet and a mock sync-v3 server. A live device is never required.

pnpm test:e2e starts rmfakecloud via docker-compose-test.yml, seeds it with test/fixtures/mcp-test (a tablet-verified dump of /mcp-test), pairs, reads that tree, then writes a notebook and reads it back from a second client. Needs Docker. Override the URL with RMFAKECLOUD_E2E_URL to point at an already-running server (skips seed).

Inspired by sammorrowdrums/remarkable-mcp and itsfabioroma/remarkable-cli.

MIT. See LICENSE.

Available Tools

1 tool

remarkable_executeA

Run JavaScript against the reMarkable API (SSH tablet or rmfakecloud).

declare const rme: { list(args): Promise; // List notebooks, PDFs, EPUBs, and folders. Trash is hidden unless includeTrash is true. browse(args): Promise; // Browse one folder path (default /). Opening a notebook returns that item. search(args): Promise; // Search by notebook name or path, optionally filtered by tag. info(args): Promise; // Notebook/folder/PDF info. Notebooks include pages[].title from the first typed line. read(args): Promise; // Read a notebook page (native paragraphs + checkbox state). Omit page to read every page. PDFs/EPUBs return extracted text. download(args): Promise; // Download the raw PDF or EPUB as base64. exportPage(args): Promise; // Render ink on a notebook page to PNG or SVG (base64). Does not render typed text. upload(args): Promise; // Upload a PDF or EPUB (base64) into a folder. mkdir(args): Promise; // Create a folder. move(args): Promise; // Move a notebook or folder into another folder (folder: "/" for root). rename(args): Promise; // Rename a notebook or folder. remove(args): Promise; // Move a notebook or folder to trash. createNotebook(args): Promise; // Create a blank notebook with one page. addPage(args): Promise; // Append (or insert after N) a blank notebook page. Returns the new 1-based page number. removePage(args): Promise; // Delete a 1-based notebook page. writeInk(args): Promise; // Append pen/highlighter strokes to a page. Points are [x,y] in 0–1 from the top-left. writeMermaid(args): Promise; // Draw a Mermaid diagram as ink (flowchart, sequence, state, class, ER, xychart). Renders to SVG then strokes. pie/gantt/etc. error. writeText(args): Promise; // Append native Type Folio text to a notebook page (default: last page). style: title (big), heading, body (small), bullet, checkbox. checked:true ticks a checkbox. blocks: mixed styles in one call. replace:true overwrites typed text (ink stays). newPage:true adds a blank page first. Repeated calls stack as new paragraphs. tag(args): Promise; // Add or remove a notebook tag (or a page tag when page is set). tags(args): Promise; // List every tag used on the tablet. refresh(args): Promise; // Restart xochitl so the tablet UI reloads the library. };

Write an async arrow function. No TypeScript syntax. Example: async () => { const docs = await rme.list({}); return docs; }

ParametersJSON Schema

Name	Required	Description	Default
`code`	Yes	JavaScript async arrow function to execute

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does so thoroughly: e.g., 'Trash is hidden unless includeTrash is true', 'exportPage ... Does not render typed text', 'writeMermaid ... pie/gantt/etc. error', and 'Repeated calls stack as new paragraphs' for writeText. It also notes refresh restarts xochitl, a side effect. This is rich, honest transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long, but it is well-structured like a TypeScript declaration with one-line comments per method. The primary purpose is front-loaded, and the method list is logically grouped. Every line adds necessary information for a complex execution environment; the length is justified and not redundant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's high complexity (arbitrary code execution over a rich API) and the lack of an output schema, the description is remarkably complete. It covers all available operations, their parameters, return types (as Promise<unknown>), notable behaviors, and limitations. The example anchors the usage, making the context fully self-contained.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

While the input schema only describes the 'code' parameter minimally, the description adds immense semantic value by defining the entire rme API that the code can call, including parameter notes (e.g., 'folder: "/" for root', 'style: title (big), heading...'). It also provides a full example, effectively turning the description into a mini-API reference that exceeds the schema's brief description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a clear, specific purpose: 'Run JavaScript against the reMarkable API'. It then enumerates a comprehensive set of methods (list, browse, search, etc.) each with a brief semantic, making the tool's function unmistakable and distinct from any sibling concept, though no siblings exist.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides explicit instructions on how to invoke the tool: 'Write an async arrow function. No TypeScript syntax.' and includes a concrete example. While it doesn't compare to alternative tools (none exist), it clearly outlines the expected format and gives a starting point for the code, which is sufficient guidance for use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.9/5.0

Disambiguation1/5

All functionality is bundled into a single tool with a polymorphic 'rme' object offering many methods, making it impossible for an agent to select a specific operation without inspecting the runtime API. The tool description describes numerous distinct actions, but as a single tool it obscures boundaries and forces arbitrary disambiguation at runtime.

Naming Consistency1/5

The tool itself is named 'remarkable_execute' while its methods use a mix of verb forms (list, read, download, exportPage, writeInk, etc.) and inconsistent naming styles (e.g., exportPage camelCase vs. others snake-like? Actually all methods are camelCase but the tool name is snake_case, and verb-noun pattern is inconsistent: 'list', 'browse', 'info', 'read' are verbs without nouns, while 'createNotebook', 'addPage', 'writeMermaid' have nouns. The mixture of generic verbs and specific compound names lacks a coherent pattern.

Tool Count2/5

With only one entry point for a rich API covering file operations, reading, writing ink, exports, and tags, the tool count is far too low for the scope. A single mega-tool burdens the agent with parsing and routing, and the server would benefit from splitting into separate tools per operation.

Completeness4/5

The bundled operations cover a broad lifecycle: listing, browsing, search, info, read, download, export, upload, mkdir, move, rename, remove, notebook creation, page manipulation, writing ink/text/Mermaid, tagging, and refresh. Missing operations like bulk exports or custom storage sync are minor; the surface is quite comprehensive for typical reMarkable workflows.

Maintenance

ActivityMaintained

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Jade Note
app.jadenote
MCP-native notes and memory for ChatGPT, Claude, and other AI tools.
Note Taking Knowledge & Memory
2
NoteMCP
io.github.jithinlalk25
Shared Markdown notes for MCP-compatible AI tools.
Note Taking Knowledge & Memory
2
Penlog
app.penlog
Handwritten iPad journal your AI can read and write tasks back to, over MCP.
Note Taking Project Management
2
hjarni AOAuth
com.hjarni
Markdown-based note-taking with a hosted MCP server. Your notes serve you and your AI.
Note Taking Workplace & Productivity
3

Related MCP Servers

mcp-remote-agent
File Systems Shell Access Command Line
knownothing20
A
license
Not graded
quality
B
maintenance
Enables AI agents to remotely read/write files and execute commands on Linux servers via MCP protocol.
Updated a month ago (2026-08-02 01:39 UTC)
4
MIT
remark-mcp
File Systems Note Taking
robbogd76
A
license
Not graded
quality
D
maintenance
Enables AI assistants to browse and read documents from a reMarkable tablet connected via USB, rendering PDF pages as images for the AI to see.
Updated 4 months ago (2026-05-13 01:43 UTC)
Apache 2.0
io.github.praveensehgal/remark
Note Taking File Systems Search
praveensehgal
A
license
A
quality
C
maintenance
MCP server that connects AI assistants to your reMarkable tablet, enabling reading, searching, and traversing handwritten and typed notes via OCR.
Updated 2 months ago (2026-07-01 01:54 UTC)
10
2
MIT
remarkable-mcp
Note Taking File Systems
sambt94
A
license
A
quality
C
maintenance
An MCP server that gives Claude direct access to your reMarkable tablet's notebooks, enabling document search, PDF rendering, handwriting transcription, and diagram conversion, all locally without API keys.
Updated 25 days ago (2026-08-09 10:03 UTC)
6
3
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/lukaisailovic/remarkable-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

remarkable-mcp

How it works

Install

Claude Desktop, Cursor, VS Code, …

rmfakecloud

HTTP

What the model can do

Configuration

Agent skill

Develop

Available Tools

TDQS

TDQS

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

mcp-remote-agent

remark-mcp

io.github.praveensehgal/remark

remarkable-mcp

Latest Blog Posts

MCP directory API