Claude Code & MCP

DevNotes+ ships an MCP server, so Claude Code can read and write your project notes directly. No copy-pasting context into the conversation, and no notes that go stale because updating them was someone else's job.

What this gets you

Once connected, Claude Code can search your notes, read one in full, create new ones, append findings to an existing note, tick off todo items, and pull the open-task list for the whole project. Every change it makes is written to the same Markdown files you edit in the sidebar, and shows up in the activity feed attributed to Claude rather than to you.

The practical effect is that the notes stop being a thing you maintain for the assistant's benefit and start being shared memory. You write down why a constant is 60 seconds; a week later Claude reads that before touching the retry logic.

Requirements

The Claude Code CLI, installed and available on your PATH. DevNotes+ shells out to the claude command to register itself.
Node.js, which the Claude Code CLI already requires.
A workspace with a .devnotes/ folder — that is, one where you have created at least one note.

Connect

There are three routes to the same thing. Whichever you use, restart Claude Code afterwards so it picks up the new server.

The setup banner

On a fresh install the sidebar shows a Set up integrations panel with two rows — Connect GitHub and Register MCP server. Clicking the second one registers DevNotes+ with Claude Code. Each row ticks over to a done state once it is wired up, and the banner hides itself automatically when both are.

You can also dismiss it: Hide for now brings it back next session, Never show again retires it for good.

The Integrations menu

Once the banner is gone, reopen it from the ⋯ overflow button beside the search box and choose Integrations. This works even if you chose "Never show again" — it deliberately overrides both the dismissal and the auto-hide, so you can always check what is connected.

The Command Palette

Open the Command Palette with Ctrl+Shift+P (Cmd+Shift+P on macOS).
Run DevNotes: Connect to Claude Code (Register MCP Server).

Under the hood this runs the Claude Code CLI for you:

# removes any previous entry first, so the path is always current
claude mcp add --scope user devnotes node "<path-to-extension>/mcp-server/dist/index.js"

You can confirm it worked with claude mcp list — you are looking for a devnotes entry. Running the command again is safe; it removes and re-adds the entry, which is how you repoint it after the extension updates.

Why user scope

The server is registered once for your user account, not per project. It figures out which project's notes to serve at runtime — see below.

How the server finds your notes

This is the one thing worth understanding properly, because it explains almost every "Claude cannot see my notes" report.

The server resolves a workspace in this order:

The DEVNOTES_WORKSPACE environment variable, if set.
A --workspace <path> argument, if passed.
Otherwise it walks up from the current working directory looking for a .devnotes/ folder, and uses the first one it finds.

In normal use that third rule is the one doing the work — which means you need to start Claude Code from inside the project. Launch claude from your home directory and it will not find the notes for a project three folders away.

Tip

cd into the repo, then run claude. Anywhere inside the repo works, not just the root — the search walks upwards.

What Claude can do

Fourteen tools are exposed. You do not need to call them by name; ask in plain language and Claude picks the right one.

Tool	What it does
`create_note`	Creates a note, optionally with tags, a `file:line` code link, a branch scope and a reminder date.
`get_note`	Reads one note in full by ID or fuzzy title match, including its metadata.
`list_notes`	Lists notes, filtered by tag, text, branch, starred or archived state.
`search_notes`	Full-text search with ranked results and match snippets. Title matches rank above content matches.
`append_to_note`	Adds a timestamped section to an existing note without replacing what is there.
`update_note`	Changes a note's title, tags, starred or shared status. Does not touch the body.
`get_todos`	Pulls every unchecked `- [ ]` item from every note into one list, grouped by note.
`complete_todo`	Ticks off todo items by substring match.
`get_stale_notes`	Finds notes untouched for N days that still have open todos or a bug tag. Defaults to 14 days.
`note_history`	Shows the git commit history for a note file — who changed it and when. Shared notes only, and needs a git repo.
`log_session`	Appends a timestamped entry to a running session log note.
`delete_note`	Permanently deletes a note. Guarded by an explicit confirm flag.
`link_github`	Links a note to a GitHub issue or PR, fetching its title and status.
`get_github_context`	Pulls the full picture for a linked issue or PR: description, labels, assignees and the last 20 comments.

Deletion is permanent

delete_note removes the file. There is no undo inside DevNotes+ — if the note was shared and committed, git is your recovery path; if it was private, it is gone. Ask Claude to archive rather than delete when you are not certain.

Resources

The server also exposes three read-only resources that Claude can pull in as context without being asked to run a tool:

Resource	Contents
`devnotes://todos`	Every unchecked todo across all notes.
`devnotes://recent`	Notes created or updated in the last 72 hours.
`devnotes://session-log`	The last five session log entries — what previous sessions worked on.

Prompts

Two slash-style prompts come with the server:

solve — takes a note, reads it together with the code it is linked to, works out a fix, and saves the result back to the note as a Solution section. This is the one that makes code-linked notes pay off.
standup — builds a Done / Doing / Blocked summary from everything updated in the last 24 hours.

Things to ask for

A few phrasings that map cleanly onto the tools:

“What are my open todos in this project?”
“Read the note about the rate limit floor before you change the retry logic.”
“Write up what we just figured out as a note on src/github/client.js line 60.”
“Which notes have gone stale?”
“Append the fix to the rate-limit note and tick off the todo about retryAfterMs.”

Troubleshooting

The command says the Claude CLI was not found

DevNotes+ checks for claude on your PATH. If claude --version does not work in a fresh terminal, it will not work from the extension either. Install the CLI, then restart VS Code so it inherits the updated environment — a shell you opened before installing will not have it.

Claude connects but reports no notes

Almost always the working directory. Check that you started claude from inside the project, and that the project actually has a .devnotes/ folder — create one note in the sidebar if not. To rule it out entirely, set DEVNOTES_WORKSPACE to the absolute path of the project.

Changes do not appear in the sidebar

They should appear on their own — DevNotes+ watches .devnotes/ and reloads when files change underneath it. If the panel looks stale, run DevNotes: Refresh.

The server points at an old install

Re-register from any of the three routes above — the Command Palette command is the quickest. It removes the existing entry before adding the current path, so it doubles as a repair command.

Private GitHub repositories

link_github and get_github_context reach the GitHub API from the MCP server process, which does not share VS Code's authentication. For private repos, set a DEVNOTES_GITHUB_TOKEN environment variable. Linking issues from the sidebar is unaffected — that path uses VS Code's built-in GitHub sign-in.