Open-source plugin for Claude Code & Cowork

Claude remembers where you left off.

Every project gets a memory vault in plain Markdown. When a session starts, the context is already there: what the project is, what was decided and what comes next. No re-explaining, no rereading your code. Works in Claude Code and in Claude Cowork.

Using Claude Cowork? There's a version for it
  • Open source · MIT
  • 100% local
  • Claude Code · Cowork
  • macOS · Linux · Windows

Why it exists

Every new session starts with no memory.

Without memory

  • You explain the project, where you stopped and what was already decided.
  • The agent rereads the README, the code and the history to get its bearings.
  • When the conversation is compacted, details and reasons get lost in the summary.
  • Ideas you already rejected get proposed again.

With Obsidian Memory

  • The project context is ready when the session starts.
  • "Where did we leave off?" is answered without opening a single file.
  • The whole conversation is archived before every compaction.
  • Decisions are recorded with the reasons behind them, and so is what not to do.

How it works

Hooks handle every session. You just work.

In Claude Code, hooks do this. In Cowork, a skill loads and saves the same memory: see how.

  1. SessionStart

    Context ready

    The vault's CLAUDE.md loads with the project, and the hook adds the last session summary.

  2. During the session

    Read on demand

    Specs, decisions and older sessions only enter the context when the task needs them.

  3. PreCompact

    Nothing gets lost

    Before compaction, the conversation is archived. Afterwards, the project context comes back.

  4. SessionEnd

    Archive and commit

    Saves the conversation to daily/ and commits only the vault, if you use git. Never pushes.

The vault is just a folder of Markdown

obsidian-vault/ lives next to your code. Claude reads and writes it; you can browse it in Obsidian, or never open it at all.

CLAUDE.md
What the project is, the stack, current state, decisions, a file map and what not to do.
daily/
A summary of each session and the archived conversation, by day.
decisions/
Numbered decisions, with context and the reason why.
obsidian-vault/
├── CLAUDE.md          # project context
├── _index.md          # generated index
├── 00-inbox.md        # quick captures
├── daily/23-09-2026/
│   ├── session-18h40.md
│   └── transcript-*.md # kept out of git
├── specs/  plans/  processes/
├── decisions/         # 0001-*.md …
└── bugs/  retro/

What you get

Continuity for the project, not just the chat.

Instant resume

"Where did we leave off?" is answered from what's already in context, in a single call to the model.

Fewer tokens

Only CLAUDE.md and the last session load at the start, a few KB. Everything else stays on disk until it's useful.

Automatic archive

Every session is saved with its commands and replies, at compaction and at the end.

Decisions that stick

Numbered decision records and a "do not" list stop settled questions from being reopened.

Optional, safe git

Local commits of the vault only. Before each commit, the plugin scans for keys and tokens and blocks the commit if it finds any.

Optional Obsidian

Registers and opens the vault in Obsidian, with daily notes and templates set up. Or just use the Markdown.

Benchmark

Fewer tokens to catch up. More to build.

Measured on real projects

0tools used to answer "where did we leave off?"
0tokens of file reading added to the context
~6sto the answer, in one call to the model

Source: Claude Code usage logs (the usage field) from new sessions opened with "where did we leave off?". The context size is the same before and after the answer.

Estimate · resuming a project

Without memory
~19,500 tokens
With the plugin
~3,500 tokens
  • −82% context window used to get oriented
  • −90% input tokens processed when resuming
  • ~8 file reads avoided

What you save per month

Input tokens avoided
~10.1 million
File reads avoided
~160
Waiting avoided
~30 min

Per resume: ~506k input tokens, ~8 file reads and ~1.5 min, measured on a project with 74 KB of code and docs. Bigger projects save more. Much of that input comes from the prompt cache, which costs less but still counts toward your plan's usage limits.

Install

Two commands inside Claude Code.

  1. Add the marketplace

    /plugin marketplace add marcuswmc/obsidian-memory-plugin
  2. Install the plugin

    /plugin install obsidian-memory@obsidian-memory
  3. Create the vault in your project

    /obsidian-memory:vault init

    Claude asks whether you want to version the vault with git and use Obsidian. Both are optional.

CoworkUsing Claude Cowork? Install Obsidian Memory for Cowork from the same marketplace.

Requirements

macOS · LinuxWindows
Claude CodeRequiredRequired
Python 3.8+RequiredRequired
gitOptionalGit for Windows
ObsidianOptionalOptional

On Windows, Git Bash (included with Git for Windows) runs the hooks. To check everything, run /obsidian-memory:vault doctor: it installs whatever is missing, always with your approval.

Also in Claude Cowork

Same memory, now in Cowork.

Cowork gets its own companion plugin, Obsidian Memory for Cowork. It reads and writes the same obsidian-vault/, so a project can move between Claude Code and Cowork without losing its place.

Add it to Cowork

  1. Add the marketplace in Cowork's plugin settings

    marcuswmc/obsidian-memory-plugin
  2. Install Obsidian Memory for Cowork

    Not the Claude Code one: that plugin relies on hooks, which Cowork doesn't run.

  3. Start a session on a project folder

    If the folder already has obsidian-vault/, Claude resumes from it. If it doesn't, ask Claude to "create the project memory".

Resumes on its own

When the folder has a vault, Claude loads the skill and reads CLAUDE.md and the last session before answering.

Saves as you go

Cowork has no end-of-session hook, so Claude writes the session note while it works, and wraps up when you say "save the session".

Your time zone

Cowork may run on a remote machine in UTC. Notes use the time zone stored in the vault; Claude Code records it for you, or Claude asks once.

Files only

No hooks, no Python and no git. If git is on for the vault, the next save in Claude Code commits what Cowork wrote.

Claude CodeClaude Cowork
Pluginobsidian-memoryobsidian-memory-cowork
Loads the memoryAutomatically, through a hookThrough the skill, when the folder has a vault
Archives the conversationYes, at compaction and at session endSession notes written as you go
Git and ObsidianOptional, set at initDoesn't run git or open Obsidian
Same vaultYes: obsidian-vault/, same format, same notes

If Claude doesn't pick up the memory on its own in Cowork, ask "where did we leave off?" or run /obsidian-memory-cowork:vault.

Everyday use

Ask in plain words, or use a command.

"save the session"vault save

Writes today's summary, updates the project's current state and commits the vault.

✓ daily/24-09-2026/session-17h05.md
✓ Current State updated
✓ commit a1f3c9e · vault only
"record this decision"decisions/

Creates a numbered decision record with the context and the reason, and adds it to the project's key decisions.

✓ decisions/0005-use-postgres.md
✓ Key Decisions: +1
↳ added to "Do not" as well
"how's the memory?"vault status

Shows the state of the vault, git, Obsidian, the last session and any alerts.

vault ok · git on · obsidian on
last session · 23-09-2026 18:40
alerts · none
"check the requirements"vault doctor

Checks Python, git, Obsidian and Git Bash, and offers to install what's missing after you approve.

python 3.12 ✓ · git 2.45 ✓
obsidian missing
↳ install with Homebrew? (y/n)

Also: vault open opens the vault in Obsidian, and "where did we leave off?" works in any new session.

Open source

Open code. Your memory.

MIT license: free to use, adapt and redistribute. Read every line before you install.

If Obsidian Memory saves you time and tokens, leave a star on GitHub. It helps other developers find the project.

  • 100% local

    No server, no account and no telemetry. The vault is Markdown on your disk.

  • Your code untouched

    Commits include only the vault. What you staged stays as it is, and nothing is ever pushed.

  • No dependencies

    Python's standard library, a bash launcher and the hooks. Easy to audit.

  • Nothing without asking

    No vault is created without init. Installing or restarting anything always asks first.

Questions

Before you install

Do I need Obsidian?

No. The vault is a folder of Markdown that Claude reads and writes. Obsidian is only for browsing the notes yourself, if you want to.

Do my conversations end up in git?

No. Archived conversations stay out of git. If you turn git on, only the vault notes are committed, locally and never pushed.

Does it work in Claude Cowork?

Yes, with the companion plugin Obsidian Memory for Cowork, from the same marketplace. It uses the same vault, so you can switch between Claude Code and Cowork on the same project. See how to add it.

Does it work on existing projects?

Yes. Run init in the project folder: Claude explores the code and fills in CLAUDE.md with the context.

What if I never run init?

Nothing happens. The hooks only act on projects that have a vault, and the plugin never creates one on its own.

What language are the notes in?

The language of your conversation. Dates use the dd-mm-yyyy format.

Is this an official Obsidian or Anthropic product?

No. It's an independent open-source project. It works with Claude Code and stores notes in a format Obsidian can open.