Guides9 min read

How to Use Claude Desktop With Your Own Notes and Screenshots (MCP Setup)

A practical guide to connecting Claude Desktop to your own notes, screenshots, and PDFs using MCP servers — plus how the Nemos MCP server fits in.

June 6, 2026·By Taha Baalla

What Claude Desktop with your own data actually means

Out of the box, Claude Desktop only knows what you type or paste. To let it search your own notes, screenshots, and files, you connect an MCP server — a small program that exposes your data as tools Claude can call. Per Anthropic's docs, MCP (Model Context Protocol) is the open standard that makes this work.

Think of an MCP server as a bridge. On one side is your data — a notes app, a folder, a database. On the other side is Claude Desktop. When you ask a question, Claude decides which tool to call, the server returns the relevant content, and Claude answers using it. Your files stay where they live; Claude just queries them on demand.

The difference this makes is concrete. Without a server, you're copy-pasting context into every chat and hoping you grabbed the right paragraph. With one, you ask a question and Claude goes and finds the source itself — across hundreds of saved items you'd never paste by hand. That's the whole point of connecting Claude to your data: turning a static chat into something that can reach into your real material.

Does Claude Desktop support MCP servers?

Yes. Claude Desktop is the most common MCP client, and Anthropic supports two ways to add servers: a manual JSON config file, or one-click `.mcpb` desktop extensions. Both register servers that Claude Desktop launches on startup, then surfaces as callable tools inside any chat.

Anthropic introduced the Desktop Extensions format (`.mcpb` files) to make installation as simple as clicking a button — the company compares it to installing a Chrome or VS Code extension. A `.mcpb` is a zip archive bundling an MCP server, its dependencies, and a `manifest.json`. For servers without a bundle, you still edit the config file by hand, which is the original and most flexible method.

Where the config file lives

Claude Desktop reads MCP servers from a single JSON file called `claude_desktop_config.json`. On macOS it sits at `~/Library/Application Support/Claude/`; on Windows it's under `%APPDATA%\Claude\`. You add servers under an `mcpServers` key, save, and fully restart the app.

The quickest way to find it: open Claude Desktop, go to Settings → Developer, and use the option to edit the config. That opens (or creates) the file in the right place so you don't have to hunt for the folder. According to Anthropic's MCP documentation, the file uses a simple structure where each server gets a `command`, optional `args`, and optional `env` for keys.

A minimal config looks like this conceptually:

Key	What it does
`mcpServers`	Top-level object holding every server you've added
`command`	The executable Claude runs (e.g. `node`, `npx`, or a full path)
`args`	Arguments passed to that command, like the server's entry file
`env`	Environment variables — API keys, tokens, account IDs

One caution from Anthropic's own guidance: this file can contain API keys, so don't back it up to a public Git repo.

How to set it up

Here's the generic flow that works for any MCP server, written so it stays accurate against Anthropic's current docs. I'll keep the Nemos-specific steps separate below since that server is still rolling out.

Install Node.js if the server needs it. Most local MCP servers run on Node, and Claude Desktop needs to find `node`/`npx`. Use Node 18.17 or newer — older versions throw a `parseArgs` error.
Open the config. In Claude Desktop, go to Settings → Developer → Edit Config (this creates `claude_desktop_config.json` if it's missing).
Add the server under `mcpServers`. Give it a name, a `command`, the `args` it needs, and any `env` values like API keys or tokens.
Use absolute paths. Anthropic's docs are explicit: paths must be valid and absolute, not relative. If `node` or `npx` isn't found (the common `ENOENT` error), point `command` at the full path, e.g. `/usr/local/bin/node`.
Save and fully quit Claude Desktop, then reopen it. A reload isn't enough — the app starts MCP servers on launch.
Verify it loaded. Look for the tools indicator in the chat input. If it's missing, the server didn't start. Enable Developer Mode and check the logs at `~/Library/Logs/Claude/mcp-server-[name].log`.
Or skip the JSON entirely — if your server ships a `.mcpb` bundle, drag it onto the Claude Desktop window or use Install Extension…, and it configures itself.

The Nemos angle: search your captured library from Claude

Nemos is an iOS-first visual second brain — it captures screenshots, voice notes, PDFs, and reminders into one searchable library. The Nemos MCP server exposes that library to Claude Desktop, so Claude can answer questions using the things you actually saved, not just what you paste in.

The server provides a focused set of tools. Once connected, Claude can call them on its own when your question needs them:

Tool	What Claude can do with it
`search_nemos`	Search your whole library by keyword or topic
`get_recent_items`	Pull the latest things you captured
`analyze_image_or_screenshot`	Read and reason over a screenshot's contents
`extract_pdf_text`	Pull text out of a saved PDF
`build_context_pack`	Assemble a bundle of relevant items as context for a task

The practical win: instead of digging through your camera roll for that pricing screenshot or the PDF a client sent, you ask Claude in plain language and it retrieves the source. Because the server understands your captures specifically — including the text inside images — it answers from material a generic file connector would never see.

The Nemos MCP server is rolling out now via waitlist — there isn't a finished public installer yet, so the steps above describe the general MCP pattern it will follow once available. If you want private, on-device capture in the meantime, see private AI note-taking on device.

Example prompts to try

Once a notes/screenshots MCP server is connected, these are the kinds of prompts that put it to work. They're written for Nemos's tools, but the shape applies to any library server:

"Search my Nemos library for everything I saved about pricing and summarize the options."
"What did I capture this week? Group the recent items by topic."
"Read this screenshot I saved of an error message and tell me what's failing."
"Pull the text from the contract PDF in my library and list the key dates."
"Build a context pack from everything related to my app launch, then draft a checklist."
"Find the screenshot where someone recommended a podcast and give me the name."

The pattern: ask in plain language, name the source loosely, and let Claude pick the right tool. You don't call tools by name — Claude maps your intent to them.

Common pitfalls (and quick fixes)

Most setup failures come down to a handful of issues that show up across the community and Anthropic's troubleshooting docs. Here's what trips people up and how to clear it fast.

`ENOENT` / command not found — Claude can't locate `node` or `npx`. Replace `command` with an absolute path to the binary. This is the single most reported issue, especially with NVM-managed Node.
Nothing happens after editing — you didn't fully quit the app. A window close isn't a quit; restart it completely.
Malformed JSON — a stray comma breaks the whole file and silently disables every server. Validate it.
Old Node version — below 18.17 you'll see a `parseArgs` error. Upgrade Node.
Keys in the wrong place — API tokens go under that server's `env`, not at the top level.

If the tools indicator still doesn't appear, the logs at `~/Library/Logs/Claude/` will tell you which server failed and why.

FAQ

Does Claude Desktop support MCP?

Yes. Claude Desktop is the primary desktop MCP client. You add servers either by editing `claude_desktop_config.json` under the `mcpServers` key, or by installing a one-click `.mcpb` desktop extension — a format Anthropic created specifically to skip manual JSON. Both register servers the app launches at startup.

Is it safe to connect my own data?

Local MCP servers run on your machine and expose only the tools they define, so you control what Claude can reach. Still, your config file can hold API keys — keep it out of public Git, and only install servers you trust. Treat a server like any app you grant access to your files.

Does this work with ChatGPT too?

MCP is an open standard, and a growing number of clients support it — not just Claude Desktop. So the same Nemos server concept can connect to other MCP-capable clients. The exact setup steps differ per client, but the idea — a server exposing your data as tools — is identical. This guide focuses on Claude Desktop specifically.

Do I need to code?

No coding logic is required — you edit a small JSON file or drag in a `.mcpb` bundle. The hardest part is getting paths right and remembering to fully restart. One-click `.mcpb` extensions remove even that, configuring the server for you. If you can edit a text file, you can connect Claude to your data.