# Connect Claude to your notes and files with MCP

To make Claude answer from your own notes, add a filesystem MCP server that points at the folder holding them, then ask your question in the Claude Code CLI. Claude reads the files in that folder on demand and answers from their contents instead of guessing.

This guide walks through the whole setup with the Claude Code CLI: install the server, scope it correctly, confirm the connection, and ask your first grounded question. If MCP is new to you, read [MCP fundamentals](/guides/mcp-fundamentals) first for the mental model.

## What you are building

You have a folder of notes or docs on disk. A folder of meeting notes, a project wiki exported to markdown, a directory of design specs. You want Claude to read those files and answer questions about them, summarise them, or cross-reference them.

The filesystem MCP server is the bridge. It is a small program that exposes one directory (or a few) to Claude as a set of read and write tools. Claude calls those tools to list files, read their contents, and search across them. Point it at a directory you choose, and Claude can reach inside that one and nothing outside it.

## Why use a server instead of just opening files?

Claude Code already reads files in your current working directory. The filesystem MCP server matters when your notes live somewhere else, for example a separate vault folder outside the project you are working in, and you want Claude to reach them from any session without moving them.

It also gives Claude a defined, bounded view. Claude sees the folders you grant and no others. That boundary is the point: you decide exactly which directory Claude can read, and the server enforces it.

## Step 1: pick the folder

Decide which folder holds the notes you want Claude to read. Use one folder with a clear path. For this guide the example folder is `~/notes`, but any directory works, such as `~/work/specs` or a markdown export at `~/wiki`.

Two rules make this safe and predictable:

- **Be specific.** Point the server at the notes folder itself, not your whole home directory. A narrow grant means Claude can only touch what you intend.
- **Know the contents.** The server reads whatever is in that folder. If it holds secrets you do not want a model to see, move them out first or point at a subfolder that excludes them.

## Step 2: add the filesystem server

The official filesystem server runs through `npx`, so you do not install anything permanently. Pass the allowed folder as an argument and the server grants access to that path and its subfolders.

Add it with the Claude Code CLI. The `--` separates Claude's own flags from the command that launches the server. Everything after `--` runs the server itself:

```bash
claude mcp add --transport stdio notes -- npx -y @modelcontextprotocol/server-filesystem ~/notes
```

Reading that command left to right:

- `claude mcp add` registers a new server.
- `--transport stdio` says the server runs as a local stdio process on your machine, launched by Claude Code. No network is involved.
- `notes` is the name you give this server. You choose it; pick something you will recognise.
- `npx -y @modelcontextprotocol/server-filesystem ~/notes` is the command that starts the server, with your notes folder as the allowed path.

To grant more than one folder, list each path as an extra argument at the end:

```bash
claude mcp add --transport stdio notes -- npx -y @modelcontextprotocol/server-filesystem ~/notes ~/work/specs
```

## Step 3: choose where the config lives (scope)

When you add a server, Claude Code stores the configuration somewhere. The `--scope` flag controls where, and the choice decides who shares it.

| Scope | Who gets it | Where it is stored |
| --- | --- | --- |
| `local` | Only you, only this project | Your private project settings |
| `project` | Everyone who checks out the repo | A `.mcp.json` file in the project root |
| `user` | You, across every project | Your user-level config |

For a personal notes folder you read from anywhere, `user` scope fits:

```bash
claude mcp add --scope user --transport stdio notes -- npx -y @modelcontextprotocol/server-filesystem ~/notes
```

For a folder of docs that belongs to a shared repo, `project` scope writes a `.mcp.json` file you commit so teammates get the same server. Claude Code asks each person to approve a project server before it runs, since the file comes from version control.

A `project`-scoped `.mcp.json` looks like this:

```json
{
  "mcpServers": {
    "notes": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "./docs"
      ]
    }
  }
}
```

The `command` and `args` are the same pieces the CLI command spells out. The CLI writes this file for you, or you can write it by hand and commit it. Point `args` at a path inside the repo, such as `./docs`, so it resolves for everyone who clones it.A `~` in the JSON args is not expanded the way your shell expands it, so `~/notes` becomes a literal folder named `~` and the server grants nothing. Write the full path like `/Users/you/notes`, or keep `~` only in the CLI command where your shell expands it first.

## Step 4: confirm the connection

List your servers to check the registration took:

```bash
claude mcp list
```

Each server shows with a status. A healthy server reports as connected. To see the full configuration for one server, including its command and scope:

```bash
claude mcp get notes
```

Inside an interactive Claude Code session, the `/mcp` slash command shows connected servers and the tools each one exposes. Run it to see the filesystem tools Claude now has, such as reading a file and listing a directory. A `project`-scoped server you have not approved yet shows as pending until you accept it.

### What can Claude do with the filesystem server?

Once connected, it hands Claude a set of file tools. These are the actions Claude can take inside the granted directory:

- **List a directory.** See the names and structure of files in the folder.
- **Read a file.** Pull the contents of a chosen file into context.
- **Search.** Find files by name or content across the granted paths.
- **Write and edit.** Create new files and change existing ones inside the folder.

Claude picks among these based on your question. A "what do my notes say about X" question uses list, search, and read. A "draft a summary file" question adds a write.

## Step 5: ask a grounded question

With the server connected, ask Claude something that requires reading the files. Be specific about what you want and let Claude reach into the folder:

Read my notes in the notes folder and list every open question or unanswered TODO you find, grouped by which file it came from.

Claude calls the filesystem tools to list the folder, open the relevant files, and read them, then answers from what it found. Because the answer comes from your files, it reflects your actual notes, not the model's training data.

You can push further once the server is wired up:

- **Summarise.** "Summarise the meeting notes from last week into five bullet points."
- **Cross-reference.** "Find every note that mentions the pricing change and tell me where they disagree."
- **Draft from source.** "Using the spec in onboarding-flow.md, write a checklist a new hire would follow."

## How does Claude decide to read a file?

You do not tell Claude which tool to call. The server advertises its tools when it connects, Claude Code merges them into the set the model can see, and the model chooses to call them when your question needs them.

This is the standard MCP tool loop. The handshake happens once when the server connects, then the read calls repeat for each file Claude needs. See [MCP fundamentals](/guides/mcp-fundamentals) for the full flow.

## Keeping it scoped and safe

The server only reaches the directories you pass on the command line. That is the main control, so use it deliberately:

- **Grant the narrowest folder that works.** If Claude only needs your notes, do not grant your home directory.
- **Watch the write tools.** The filesystem server can create and edit files in the granted folder, not only read them. If you want Claude to read your notes without changing them, keep a separate read-only copy, or review every edit Claude proposes before you accept it.People assume pointing Claude at a notes folder is read-only, but the official filesystem server ships write and edit tools too, so a "tidy up these notes" request can overwrite the originals in place. Point it at a copy you can afford to lose, or set the granted folder read-only at the OS level, before you let Claude loose on notes you cannot recreate.
- **Review what connects.** Run `claude mcp list` when you want to see which servers are active, and remove ones you no longer use.

To remove the server later:

```bash
claude mcp remove notes
```

## Why won't the server connect?

If `claude mcp list` shows the server failed instead of connected, work through these in order:

- **Check the path exists.** The folder you passed must be real and readable. A typo in `~/notes` leaves the server with nothing to grant. Confirm the folder is there and spelled correctly.
- **Check `npx` runs.** The server starts through `npx`, which needs Node.js installed. If `npx` is missing, install Node first, then re-add the server.
- **Read the status detail.** Run `claude mcp get notes` to see the exact command Claude Code runs. Compare it against what you typed; a missing `--` or a stray quote is the usual cause.
- **Approve a project server.** A `project`-scoped server stays pending until you approve it in an interactive session. If it never connects, open `claude` and accept it when prompted.

Fix the cause, then run `claude mcp list` again to confirm the server reports as connected.

## What file formats work best?

The filesystem server reads files as text. Plain formats give Claude the cleanest view:

| Format | How well it reads | Note |
| --- | --- | --- |
| Markdown (`.md`) | Reads directly | Headings give Claude structure to work with |
| Plain text (`.txt`) | Reads directly | Simple and reliable |
| Code and config | Reads directly | Source files, JSON, YAML all read as text |
| PDF and `.docx` | Reads poorly | Binary formats are not plain text; export to markdown first |

If your notes live in a tool that exports to markdown, export them into the folder you granted. A folder of `.md` files is the format Claude works with most cleanly.

## Where to go next

You now have Claude answering from a folder of your own files. The same pattern, add a server, scope it, confirm it, ask, extends to other sources: [your GitHub repos](/guides/connect-claude-to-github) for code history, [a database server](/guides/connect-claude-to-your-database) for queries, a remote connector for a hosted tool. For more servers worth connecting, see [useful MCP servers](/guides/useful-mcp-servers). Each one is another bounded view you grant on purpose.

Start with one notes folder, get comfortable with how Claude reaches into it, then add the next source when you have a clear reason to.