Claude Code

The @memsy-io/claude-code plugin wraps @memsy-io/mcp with Claude Code-native UX. The MCP server provides the tools and resources; the plugin adds the surface (slash commands, skills, hooks, agents) so Memsy is discoverable from inside Claude Code without you having to memorize the MCP tool names.

Plugin is strictly additive on top of the MCP — uninstalling the plugin leaves the MCP server working unchanged.

Install

export MEMSY_API_KEY=msy_...

claude plugin marketplace add memsy-io/memsy
claude plugin install memsy@memsy

/memsy doctor

Slash commands

/memsy <anything> — universal entry point

This is the one slash to remember. The memsy skill reads what you typed after the slash, classifies intent, and runs the matching workflow.

/memsy what did we decide about billing storage?     → searches memories
/memsy remember we picked Postgres for billing       → stores a memory
/memsy switch to work                                → switches profile
/memsy list                                          → lists recent memories
/memsy doctor                                        → runs the health check
/memsy setup                                         → first-time walkthrough
/memsy proactive on | /memsy proactive off           → toggle auto-save (session)
/memsy confirm on   | /memsy confirm off             → toggle ask-before-save
/memsy modes                                         → show current mode state
/memsy                                               → shows the menu above

In-session mode toggling: /memsy proactive, /memsy confirm, and /memsy autocontext change behavior for the current session only. The change is acknowledged immediately and applies to subsequent turns. To make the change persistent across Claude Code restarts, set the corresponding env var (MEMSY_PROACTIVE, MEMSY_CONFIRM_STORE, MEMSY_SESSION_AUTOCONTEXT) in your shell. /memsy autocontext is a special case — it fires at SessionStart, so the in-session toggle takes effect at the next launch, not the current one.

Routing rules: leading verbs (remember, save, switch to, list, doctor, setup) pick the intent; bare topics default to search — the safest fallback, since mis-storing creates noise that's hard to undo. When ambiguous, the router asks rather than guessing.

/memsy:<name> — explicit namespaced fast paths

Skills (auto-fire on natural phrasing, no slash needed)

MCP-level prompts (work in Cursor / VS Code / Cline too)

These come from the MCP server itself, so they're available in any MCP host — not just Claude Code:

Hooks

SessionStart auto-context (opt-in)

When MEMSY_SESSION_AUTOCONTEXT=on is set in the shell that launches Claude Code, the plugin's SessionStart hook injects a "Memsy recall" context block before your first message — surfacing the most recent N memories from the active profile.

Turn it off by unsetting MEMSY_SESSION_AUTOCONTEXT and restarting Claude Code. The hook is silent unless explicitly opted in.

Proactive mode (opt-in)

When MEMSY_PROACTIVE=on is set in the launch shell, the SessionStart hook tells Claude to actively watch the conversation for save-worthy content — preferences, intents, plans, decisions, learnings — and store it without you having to say "remember that".

Example: with MEMSY_PROACTIVE=on, if you say:

I really like football and plan to go to the FIFA World Cup 2026. Find me ticket sites.

Claude answers the ticket question normally, then appends:

→ saved to Memsy: "I really like football and plan to go to the FIFA World Cup 2026" (event abcd1234)

The save piggybacks on the substantive answer — it doesn't interrupt.

What qualifies for proactive saves:

• Preferences: "I like X", "my favorite is Y", "I prefer Z"
• Intents / plans: "I want to do X", "I plan to Y", "I'm going to Z"
• Decisions: "we decided X", "going with Y", "switching to Z"
• Constraints discovered: "X doesn't work because Y"
• Learnings: "turns out X", "the trick is Y"

What it skips: ephemeral chatter ("let me try X"), questions ("how do I X?"), already-stored content (no double-save), too-short content, and anything that looks like a secret.

Combine with MEMSY_CONFIRM_STORE=on to get watch + ask before storing each one — Claude proactively notices save-worthy content but checks with you before persisting.

Confirm-before-store mode (opt-in)

When MEMSY_CONFIRM_STORE=on is set in the launch shell, the SessionStart hook emits a [memsy modes: confirm-before-store] line into Claude's context. Every single-item save surface (memsy-remember skill on auto-fire, /memsy:memsy-remember <text> command, and the /memsy remember <text> smart-router branch) reads that line and asks for confirmation before calling memsy_ingest:

Memsy will store:
  picked Postgres for billing because it's already deployed

Save? (y / n / edit "<new text>")

• y / "save it" → stores.
• n / "don't" → not stored.
• edit "..." → stores the edited text instead.

/memsy:memsy-checkpoint and /memsy:memsy-index are unaffected — they always confirm by design (they batch multiple memories and show the list before any save).

This is independent of MEMSY_SESSION_AUTOCONTEXT — you can enable confirmation without enabling auto-context (or vice versa). Both modes accept on/true/1/yes/enabled.

Why not auto-store on session end? Claude Code's SessionEnd and Stop hooks don't pipe their stdout back into Claude, so an auto-save hook can't actually call MCP tools to store anything. We ship /memsy-checkpoint as a user-initiated command instead — safer (no surprise noise) and actually functional.

Subagent: memsy-archivist

For deep multi-query retrieval ("what's our full thinking on X", "audit all our past decisions on Y"), Claude Code can delegate to the memsy-archivist subagent. It runs 3–5 query variants in parallel, dedupes, clusters by theme, and returns a structured summary instead of a flat list — plus an explicit list of gaps it noticed.

Subagents in Claude Code are invoked explicitly (they don't auto-fire from description matching). Trigger it by asking:

Do a deep memsy dive on rate limiting decisions across all our services.

Environment reference

Full env reference: see the MCP docs.

Local development

Iterating on the MCP server itself? Point the plugin at your local build:

# 1. Build the MCP
cd /path/to/memsy/mcp
npm install && npm run build

# 2. Rewrite the plugin's .mcp.json to use the local build
cd /path/to/memsy/plugins/claude-code
./install.sh --dev /path/to/memsy

# 3. Restart Claude Code

Switch back to the published npm version:

./install.sh --prod

Troubleshooting

Uninstall

claude plugin uninstall memsy

The MCP server (@memsy-io/mcp) is unaffected — uninstalling the plugin only removes the slash commands, skills, hooks, and agent. The MCP keeps working in any other host where you've configured it (Cursor, VS Code, Cline, Continue.dev, Zed).