Evernote Local

Read your Evernote notes from Claude (Desktop or Code) without an API key — built for the period when Evernote API key issuance is suspended, and useful any time you'd rather not depend on the cloud API.

This is a local-only, read-only bridge that talks directly to the Evernote desktop app's on-disk data store on macOS. It exposes notes, notebooks, attachments, OCR'd text from images, extracted PDF text, and links — both as a CLI you can pipe into anything, and as an MCP server that plugs straight into Claude Desktop or Claude Code.

Why this exists

Evernote's official Developer API is currently not accepting new key requests:

"Evernote API Key requests are temporarily suspended while we complete some maintenance on the platform. Our team is actively working on this, but we don't have a specific timeline for when the service will be reinstated." — Evernote Support, May 2026

Existing community projects (e.g. verygoodplugins/mcp-evernote) all need that key. AppleScript was the obvious workaround, but Evernote v10/11 stripped almost the entire AppleScript surface — only version reliably works.

So this project takes a different path: it reads the local Conduit graph SQLite database that the Evernote desktop app keeps on disk, plus the Yjs CRDT blobs that hold note bodies, plus the resource cache that holds attachments. No API, no scraping, no AppleScript, no auth. When the official API reopens, the same tool surface (list_notebooks / list_notes / get_note / weekly_review) maps cleanly onto it.

What it can do

• List notebooks and notes — filter by notebook, date window, etc.
• Fetch a note's body — best-effort plain-text extraction from the Yjs CRDT blob.
• Surface attachments — filename, mime type, size, local path, downloaded flag.
• OCR'd image text — Evernote pre-computes OCR on screenshots/photos and stores it in AttachmentSearchText. We pull it directly. No cloud OCR call needed.
• PDF text extraction — first 20K characters of any PDF attachment, via pypdf.
• Inline small text files — text/plain, markdown, csv, json, etc. under 200 KB are inlined as text.
• View images — the view_image MCP tool returns image bytes inline so Claude can actually see screenshots and diagrams.
• URL extraction — every https?:// URL across the note body, snippet, OCR text, and PDF text gets surfaced as a clean urls[] array, which Claude can then choose to fetch with its web tools.
• Weekly review bundle — a single weekly_review call dumps everything updated in the last N days as one JSON payload, designed to drop into a Claude conversation alongside calendar / task-manager data.

Requirements

• macOS (the path layout is macOS-specific; the underlying SQLite + Yjs format is the same on other platforms but the lookup paths would need to be adapted)
• The Evernote desktop app installed and signed in (tested against v11.13.2)
• Python 3.10 or later

Install

git clone https://github.com/nord342/evernote-local-mcp.git
cd evernote-local-mcp
python3 -m venv .venv
.venv/bin/pip install -r requirements.txt

That's it — no config, no token, no environment variables. The CLI auto-detects which Evernote account is active by picking the most recently modified RemoteGraph.sql under ~/Library/Containers/com.evernote.Evernote/....

CLI usage

# every notebook in your active account
.venv/bin/python evernote_local.py list-notebooks

# 50 most recently updated notes
.venv/bin/python evernote_local.py list-notes --limit 50

# notes touched in the last 7 days, in a specific notebook
.venv/bin/python evernote_local.py list-notes --since-days 7 --notebook "Daily Notes"

# full content + attachments + URLs for one note
.venv/bin/python evernote_local.py get-note <note-id>

# attachment metadata + on-disk path
.venv/bin/python evernote_local.py get-attachment <attachment-id>

# weekly review bundle (default 7 days)
.venv/bin/python evernote_local.py weekly-review --days 7

All commands print JSON to stdout. Pipe into jq, redirect to a file, feed to anything.

Wire into Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json and add an entry under mcpServers:

{
  "mcpServers": {
    "evernote-local": {
      "command": "/absolute/path/to/evernote-local-mcp/.venv/bin/python",
      "args": ["/absolute/path/to/evernote-local-mcp/mcp_server.py"]
    }
  }
}

Quit and relaunch Claude Desktop. You'll see six new tools available.

Wire into Claude Code

claude mcp add evernote-local \
  /absolute/path/to/evernote-local-mcp/.venv/bin/python \
  /absolute/path/to/evernote-local-mcp/mcp_server.py

MCP tools

Tool	What it does
list_notebooks	Every notebook in the active account.
list_notes(since_days?, notebook?, limit?)	Notes by recency, optionally filtered. Metadata + snippet only.
get_note(note_id)	One note: body text, attachments (with OCR/PDF text), URLs.
get_attachment(attachment_id)	Attachment metadata + local file path.
view_image(attachment_id)	Returns image bytes inline so Claude can analyze screenshots/diagrams visually.
weekly_review(days=7)	Bundle of every note updated in the last N days, full content + attachments + URLs.

Example: a real weekly review

Once wired up, you can just ask:

"Do my weekly review — pull this week's Evernote notes, my Google Calendar, and my Asana tasks and tell me what to focus on next week."

Claude calls weekly_review, gets a JSON payload of everything you've written in the last 7 days, cross-references it with whatever calendar/task MCP servers you have configured, and gives you a synthesis. For attachments, it sees the OCR/PDF text by default and can call view_image on screenshots that look interesting.

How it works

~/Library/Containers/com.evernote.Evernote/Data/Library/Application Support/Evernote/
├── conduit-storage/...                    # SQLite "graph" DB (notes, notebooks, attachments table)
│   └── UDB-User<id>+RemoteGraph.sql
├── conduit-fs/...                          # Yjs CRDT note bodies
│   └── <profile>/rte/Note/internal_rteDoc/<3>/<3>/<note-id>.dat
└── resource-cache/User<id>/<note-id>/<data-hash>   # actual attachment bytes

• The SQLite DB is copied to /tmp before reading, so it won't fight the live Evernote app for the lock.
• The Yjs binary isn't decoded — text is pulled with a printable-ASCII regex and then de-noised against a token list. Imperfect (some customNoteStyle / heading-style names leak through) but readable enough for summarization.
• Image OCR text comes free from Evernote's own AttachmentSearchText table.
• Attachment file paths are resolved by joining the user id (parsed from the DB filename) with the note id and the dataHash column.
• The Attachment table schema differs across Evernote versions — code handles both Attachment (newer, filename/dataHash) and Nodes_Attachment (older, label/data_hash) transparently.

Limitations / known issues

• macOS only. Linux/Windows have similar storage layouts but the paths and sandbox locations differ — pull requests welcome.
• Read-only. No create/edit/delete. By design — that's the kind of thing the official API is right for once it reopens.
• Local-only. If a note exists in your account but you've never opened it on this Mac, only its metadata + snippet are guaranteed to be present. Mark notebooks "available offline" in Evernote to force-sync the bodies and attachments.
• Yjs text extraction is heuristic. Don't expect pristine prose. Expect some style/heading tokens. Good enough for an LLM summarizer, not good enough to display verbatim to a human.
• PDF text only — no PDF images. Mostly-image PDFs (scans without OCR) won't yield useful text.
• No encrypted-note support. Same as the API.

Roadmap

If the official Evernote API reopens, the cleanest evolution is:

1. Add an EVERNOTE_API_TOKEN env var.
2. Implement the same six tools against the Evernote SDK.
3. Auto-prefer API when a token is set, fall back to local DB otherwise.

The tool surface is intentionally small and stable so this swap doesn't break any consumers.

License

MIT — see LICENSE.