pūrmemo
Officialpūrmemo is an MCP memory server that lets an AI save, recall, and organize your conversations and identity context — with most advanced tools gated by account plan or operator flags.
Save conversations as memories with complete transcripts, auto-chunking, smart titles/tags, project extraction, and
replacevsappendmodes (save_conversation).Recall memories via semantic search with filters (entity, intent, initiative, stakeholder, deadline, cluster, observation quality) and fetch full/paginated details (
recall_memories,get_memory_details).Load your identity and context at session start — role, expertise, current project, recent themes (
get_user_context).See what changed about a project/person/thing over time, with dated superseded facts and contradictions (
what_changed, account-gated).Browse the memory map — project/theme hierarchy and cluster membership (
list_clusters, paused).Preserve artifacts separately (research, code, tables, specs, diagrams) and list them (
save_artifact,get_artifacts, paused).Create commitments like PRDs, ADRs, specs, and OKRs, queryable by type (
commit, paused).Manage state snapshots — draft, synthesize, save, read, and promote canonical topic snapshots (
snapshot,snapshot_sources,save_snapshot,get_snapshot,accept_snapshot, paused).Discover related conversations across AI platforms and run structured workflows (PRD, debug, sprint, incident, etc.) (
discover_related_conversations,run_workflow,list_workflows, paused).Share and explore community memories — set visibility, search public memories, read full content, report abuse (
share_memory,recall_public,get_public_memory,report_memory, paused).Admin/ops extras — error investigation tools, project task queue (
get_next_task,complete_task), test result tracking, handoff briefs, and multi-account transfer (flag- or account-gated).
Provides persistent memory for Windsurf (by Codeium) AI coding assistant via MCP, allowing recall of previous work and context.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@pūrmemo remember that I am working on the login system"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
pūrmemo
Memory for your AI tools. Claude remembers who you are, what you're working on, and what you said last time — across every session, on every platform.
Just want it in ChatGPT or Claude.ai in your browser? Get the Chrome Extension instead.
Install in 30 seconds
1. Paste this into your terminal
Mac or Linux:
curl -fsSL https://app.purmemo.ai/install | shWindows (PowerShell):
irm https://app.purmemo.ai/install.ps1 | iexThat's it for installing. The script handles everything — it'll install Node if you don't have it, set up the purmemo command, and tell you when it's done.
2. Type purmemo
purmemoYour browser opens. Sign in (or create a free account). Close the tab when it says you're done.
3. Restart Claude
Quit and reopen Claude Desktop (or Claude Code). pūrmemo is now connected.
You'll know it worked when your next Claude session opens with a header like:
pūrmemo v15.7.20 · you@example.com · Free · 0 memoriesTry saying "save this" at the end of a conversation, or "what was I working on?" at the start of a new one.
Related MCP server: agent-mem0
If something goes wrong
purmemo command not found? Close and reopen your terminal, then try again. New commands sometimes need a fresh shell.
You see "Failed to read token" or "bad decrypt"? Run:
purmemo --update && purmemo initThis clears any stale credentials and signs you back in. (Fixed in v15.7.20+ — if you're on an older version, this is a one-time thing.)
Anything else? Open an issue at github.com/purmemo-ai/purmemo-mcp/issues — we read every one.
What it does
Remembers everything — save any conversation, recall it later by typing what you remember about it.
Knows who you are — your role, your projects, your stack — loaded automatically into every new session.
Tells you what changed — ask
what_changedabout a person, project, or thing and get its dated history: what used to be true, what replaced it, and when.Works everywhere — Claude Code, Claude Desktop, Cursor, Windsurf, Zed, anything that speaks MCP.
Three slash commands you'll use most:
You type | What happens |
| Saves this conversation. Use the same title later → updates the same memory. |
| Search your memories in plain English. |
| At the start of a session — loads who you are and what you were last working on. |
Other ways to install
npm install -g purmemo-mcp && purmemoOr, run it once without installing globally:
npx purmemo-mcp@latest initOpen Claude Desktop → Settings → Developer → Edit Config and add:
{
"mcpServers": {
"purmemo": {
"url": "https://mcp.purmemo.ai/mcp/messages",
"transport": "streamable-http"
}
}
}Restart Claude Desktop. You'll be prompted to sign in via OAuth on first use.
Get your API key from app.purmemo.ai → Settings → API Keys, then edit:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"purmemo": {
"command": "npx",
"args": ["-y", "purmemo-mcp"],
"env": { "PURMEMO_API_KEY": "your-api-key-here" }
}
}
}Restart Claude Desktop after saving.
Cursor — edit ~/.cursor/mcp.json:
{ "mcpServers": { "purmemo": { "command": "npx", "args": ["-y", "purmemo-mcp"], "env": { "PURMEMO_API_KEY": "your-api-key" } } } }Windsurf — edit ~/.codeium/windsurf/mcp_config.json (same shape as above).
Zed — edit ~/.config/zed/settings.json, add under context_servers:
{ "context_servers": { "purmemo": { "command": { "path": "npx", "args": ["-y", "purmemo-mcp"], "env": { "PURMEMO_API_KEY": "your-api-key" } } } } }Pricing
Plan | Price | Recalls | Saves |
Free | $0 | 50/month | Unlimited |
Pro | $19/month | Unlimited | Unlimited |
For developers
Looking for the technical stuff? It's all here:
Tools listed by default — four, for every account:
save_conversation,recall_memories,get_memory_details,get_user_context. A short list helps the assistant pick the right tool.Tools that follow your account — listed only when your account includes them (your plan, or an invite), never because of a setting on the machine. purmemo-next decides this per account and the connector asks it (
GET /api/v1/features); if it cannot be confirmed, these tools stay hidden and the four above carry on as usual. Called without access, they answer "not part of your plan".what_changed— the dated history of a person, project or thing.search_past_sessions— searches the raw transcripts of your past AI sessions. It also needsPURMEMO_SESSIONS_BETA=1on the machine: that setting is an off-switch (unset hides the tool for everyone on that connector); it does not grant access. Served by purmemo-next atPURMEMO_READ_BASE_URL, elsePURMEMO_SESSIONS_URL, elsehttps://next.purmemo.ai.
Operator flags bring back paused groups for the whole process:
PURMEMO_ADMIN=1— adds the admin tools (get_acknowledged_errors,save_investigation_result,get_investigations).PURMEMO_LEGACY_TOOLS=1— brings back the paused tools (save_artifact,commit, the snapshot tools,list_clusters,discover_related_conversations,run_workflow,list_workflows, sharing, tasks, test results and the rest). Called while paused, they answer with what to use instead.
Several accounts on one machine (e.g. personal and work, each connected with
purmemo-mcp-setup add). The server still starts on your active account, and that stays the default for every call, hook and auto-capture. When two or more accounts are signed in locally, the core tools gain an optionalaccountargument (a choice among those signed-in accounts only; anything else is refused before any network call) andtransfer_memoryis listed, which moves one memory between your accounts. Calls on a non-default account are labelled with the account and logged, without content or keys, to~/.purmemo/account-audit.jsonl. Programs use the same boundary throughpurmemo-ops(accounts,whoami,save,recall,transfer), which always requires an explicit account. Hosted (remote) mode never offers it;PURMEMO_MULTI_ACCOUNT=0turns it off. See ADR-040.Tools, resources, prompts reference — every MCP tool the server can expose, including the paused ones.
Living document semantics —
mode='append'vsmode='replace', chunking behavior, ADR-036/038 details.Identity layer — the cognitive fingerprint that loads into every session.
Architecture decisions (ADRs) — every design decision, with context and trade-offs.
Source for the install scripts — read before running, if you want.
Links
Dashboard — view and manage memories
Chrome Extension — for ChatGPT, Claude.ai, Gemini in browser
Privacy Policy — encrypted in transit and at rest, never shared
License
The MCP connector code in this repo is MIT licensed. The pūrmemo platform, API, and backend are proprietary.
Available Tools
29 toolsaccept_snapshotA
Promote a draft snapshot to canonical. Supersedes the prior canonical for this topic.
If gate blockers exist (conflicts detected, tier downgrade, or first canonical), returns them for review. Pass force: true to approve and promote anyway.
Inputs: snapshot_id (required), force.
commitA
Persist a commitment-shaped artifact (PRD, ADR, spec, OKR) as a memory with intent='commitment'.
WHEN TO USE: This is the write primitive for /prd, /decide, /spec, /commit slash commands. Call after the artifact is fully drafted in the conversation. Send the COMPLETE artifact verbatim — do NOT summarize.
INSERT-only. Each call creates a new memory; supersede prior versions by recency, never overwrite. No conversationId parameter (intentional — see ADR-034).
QUERYABLE: GET /api/v1/commitments/?type= returns all commitments of a given type, filterable by target_date and sorted by recency.
EXAMPLES:
commit(title="ADR-035 - Foo - Bar - 2026-04-28", type="ADR", content="", key_result="single-sentence chosen-option statement")
commit(title="PRD - Email verification flow", type="PRD", content="", target_date="2026-05-15")
Inputs: title (required), content (required), commitment_type (required), tags, +2 more.
complete_taskA
Mark a project task as done and close the Jered Loop for this session.
Sets status='done', records completion_summary, clears active_session_id. Returns the next pending task so you know what comes next before closing.
Call this BEFORE ending a session — Jered's rule: consciously close each task.
RETURNS:
completed — the task that was just finished
next_task — { id, sequence, title } of next pending task, or null if all done
message — "Task complete. N tasks remaining." or "Task complete. All tasks done!"
Inputs: task_id (required), project_name (required), verification_summary (required).
generate_handoff_briefARead-onlyIdempotent
Generate a surgical context brief for a new AI session. Instead of re-explaining your context, the AI already knows where you left off.
Uses a 5-layer compaction hierarchy to maximize signal in ~2,000 tokens:
Intent — What you were trying to accomplish (never cut)
Decisions — What was decided and completed
Open Loops — Blockers, unresolved items, active todos
Context — Technologies, entities, project details
Content — Brief excerpts (trimmed to fit budget)
Call this at the start of a new session or when switching projects to give the AI instant context. No new data is generated — composes from your existing V2 intelligence extraction data.
Inputs: project_name, token_budget.
get_acknowledged_errorsARead-onlyIdempotent
Fetch open and acknowledged errors waiting for AI investigation.
Returns errors with status 'open' or 'acknowledged' — all errors needing
attention. Each error includes recent_occurrences[] with per-request context
(user_id, path, method) for investigation.
USAGE:
- Call this when user says "investigate errors" or "/investigate-errors"
- Errors are sorted by occurrence count (most frequent first)
- Each result includes recent_occurrences[] for per-request investigation context
QUERY PARAMETERS:
- limit: Max errors to return (default: 10)
- level_filter: Filter by level - 'all', 'critical', 'error', 'warning' (default: 'all')
- min_occurrences: Only errors with occurrence_count >= this (default: 1)
EXAMPLE:
get_acknowledged_errors(limit=5, level_filter="error", min_occurrences=3)
→ Returns top 5 error-level issues that occurred 3+ times
RETURNS:
- acknowledged_errors: Array of error objects (open + acknowledged)
- total_count: Number of errors returned
- filters_applied: Summary of filters usedInputs: limit, level_filter, min_occurrences.
get_artifactsARead-onlyIdempotent
List artifacts linked to a parent conversation. Pairs with save_artifact.
Inputs: parent_conversation_id (required), limit, artifact_type.
get_investigationsARead-onlyIdempotent
List error investigation results (admin). Pairs with save_investigation_result.
Inputs: limit, status, incident_id.
get_memory_detailsARead-onlyIdempotent
Get complete details of a specific memory, including all linked parts if chunked
Inputs: memoryId (required), offset, maxChars, includeLinkedParts.
get_next_taskA
Get the next pending task for a project and mark it active.
Fetches the lowest-sequence pending task from the project_tasks queue, sets its status to 'active', and returns the task details plus a brief from the linked PRD memory.
NOTE: project_tasks is a structured work queue — separate from recall_memories todos. Tasks are created explicitly via the task management workflow, not auto-populated from saved conversations. If this returns "no pending tasks", the project queue is empty — use recall_memories to find work items in saved conversations instead.
Call this at the start of a work session to pick up where you left off. When done, call complete_task({ task_id, verification_summary }) to close the loop.
RETURNS:
task.id — use this in complete_task
task.sequence — task order number
task.title — what to do
task.description — how to do it
task.acceptance_criteria — how to know it's done
task.context_brief — first 500 chars of the PRD for context
task.total_remaining — pending tasks left (including this one)
Inputs: project_name (required).
get_public_memoryARead-onlyIdempotent
Retrieve the FULL content of a public or unlisted memory by ID.
WHEN TO USE:
After recall_public returns a preview and you need the complete content
When a user wants to read or implement from a shared community memory
When you have a public memory ID and need the full text
This is the tool that closes the loop: recall_public finds memories, this tool retrieves them in full. No authentication required — public knowledge is free.
EXAMPLE: get_public_memory({ memory_id: "abc-123-def-456" })
RETURNS: Full memory content, observations, entities, tags, author attribution, and metadata.
Inputs: memory_id (required).
get_snapshotARead-onlyIdempotent
Read an existing canonical snapshot into context. Fast — no LLM calls.
WHEN TO USE: When you need the current canonical state document for a topic (e.g. architecture, auth, glossary) without generating a new one.
Inputs: topic, snapshot_id.
get_test_resultsARead-onlyIdempotent
List recent test results for a project, newest first.
Pairs with save_test_result — use this to recall past test outcomes without having to query the conversational memory layer.
USAGE:
Latest 50 results: get_test_results({ project_name: "polymathematics" })
Only failures: get_test_results({ project_name, passed: false })
Custom limit: get_test_results({ project_name, limit: 10 })
RETURNS:
results[] — each with id, test_suite, passed, failure_details, updated_at
Inputs: project_name (required), limit, passed.
get_user_contextARead-onlyIdempotent
Get the current user's cognitive identity and active session context.
Call this at the START of a conversation to understand who you're talking to — their role, expertise, current project, and recent memory themes.
This is the core of Purmemo's identity layer: once set in the dashboard, your identity travels silently to every AI session so you're never explaining yourself from scratch again.
WHAT IT RETURNS:
identity: role, expertise areas, primary domain, work style, preferred tools
current_session: what the user is working on right now (project, focus)
memory_summary: 2-3 sentence synthesis of the user's most recent memory themes
WHEN TO CALL:
At the start of every new session (add to Claude system prompt)
When user says "load my context" or "what do you know about me?"
Before making recommendations that depend on knowing the user's background
EXAMPLE USAGE: → User starts new Claude session → Claude calls get_user_context automatically → Response: { role: "founder", expertise: ["product", "fullstack"], project: "purmemo", focus: "identity layer", memory_summary: "Chris has been building Purmemo's..." } → Claude responds with full context already loaded — no re-explaining needed
Inputs: no named parameters.
list_clustersARead-onlyIdempotent
Browse the memory map. With NO arguments, returns the user's PROJECT -> THEME hierarchy with member counts (the "galaxy" as text) — use this to show "what projects/topics do I have?". With cluster="", OPENS that cluster and lists its member memories (a project title pulls every memory across all its themes; a theme title pulls that theme). Pair with recall_memories(cluster=...) to then semantically search inside a cluster. Read-only.
Inputs: cluster.
list_workflowsARead-onlyIdempotent
List all available Purmemo workflows — structured, memory-powered processes you can run.
WHEN TO USE THIS TOOL:
User asks "what can you help me with?" or "what workflows do you have?"
User wants to see available capabilities before choosing one
User says "show me what's available" or "list workflows"
Returns the full catalog of workflows organized by category with descriptions.
Inputs: category.
recall_memoriesARead-onlyIdempotent
Search and retrieve saved memories with intelligent semantic ranking.
🎯 BASIC SEARCH: recall_memories(query="authentication") → Returns all memories about authentication, ranked by semantic relevance
🔍 FILTERED SEARCH (Phase 2 Knowledge Graph Intelligence): Use filters when you need PRECISION over semantic similarity:
✓ entity="name" - Find memories mentioning specific people/projects/technologies Example: entity="purmemo" → Only memories discussing purmemo
✓ has_observations=true - Find substantial, fact-dense conversations Example: has_observations=true → Only high-quality technical discussions
✓ initiative="project" - Scope to specific initiatives/goals Example: initiative="Q1 OKRs" → Only Q1-related memories
✓ intent="type" - Filter by conversation purpose Options: decision, learning, question, blocker Example: intent="blocker" → Only conversations about blockers
💡 WHEN TO FILTER:
Use entity when user asks about specific person/project by name
Use has_observations for "detailed" or "substantial" requests
Use initiative/stakeholder for project-specific searches
Use intent when user asks for decisions, learnings, or blockers
📝 COMBINED EXAMPLES: recall_memories(query="auth", entity="purmemo", has_observations=true) → Find detailed technical discussions about purmemo authentication
recall_memories(query="blockers", intent="blocker", stakeholder="Engineering") → Find engineering team blockers
Inputs: query (required), limit, entity, intent, +6 more.
recall_publicARead-onlyIdempotent
Search public memories shared by all Purmemo users. This is the community knowledge base.
WHEN TO USE:
User asks "what have other people saved about X?"
User wants to explore community knowledge
User asks to search public/shared memories
Looking for solutions others have found
DOES NOT COUNT AGAINST RECALL QUOTA — public knowledge is free.
FILTERS:
query: Semantic search query (uses vector similarity)
tag: Filter by tag
platform: Filter by source platform
sort: "recent" or "popular" (by recall count)
EXAMPLE: recall_public({ query: "MCP server testing best practices" })
RETURNS: List of public memories with author attribution, relevance scores, and recall counts.
Inputs: tag, page, sort, query, +1 more.
report_memoryAIdempotent
Report a public memory for inappropriate content.
WHEN TO USE:
User encounters spam, misleading, or inappropriate public content
User wants to flag content that contains personal information
REASONS: spam, inappropriate, misleading, personal_info, other
After 3 reports, a memory is automatically hidden from public view pending admin review.
EXAMPLE: report_memory({ memory_id: "abc-123", reason: "spam", description: "Promotional content" })
Inputs: reason (required), memory_id (required), description.
run_workflowARead-onlyIdempotent
Run a Purmemo workflow — structured, memory-powered processes for product, engineering, business, and operations tasks. Your relevant memories and identity are automatically loaded to personalize every workflow.
WHEN TO USE THIS TOOL:
User wants to write a PRD, debug an issue, plan a sprint, review code, or any structured task
User describes a goal but doesn't know the exact process ("I want to ship a feature")
User asks for strategic advice, design guidance, or operational help
User says "help me", "guide me", "walk me through", or describes a business/product/engineering need
AVAILABLE WORKFLOWS (pass the workflow name, or describe what you need): Product: prd, roadmap, story, design, feedback Strategy: ceo, growth, metrics, intel Engineering: debug, review, deploy, incident Operations: sprint Content: copy
EXAMPLES: run_workflow(workflow="prd", input="notification system for mobile app") run_workflow(workflow="debug", input="TypeError: Cannot read property 'map' of undefined in Timeline") run_workflow(input="production is down, users can't save memories") → auto-routes to incident run_workflow(input="what should I focus on this week?") → auto-routes to sprint run_workflow(input="how's the business doing?") → auto-routes to metrics
DO NOT use this tool for: simple memory recall (use recall_memories), saving conversations (use save_conversation), or finding related discussions (use discover_related_conversations).
If no specific workflow is named, the system auto-routes based on the user's intent.
Inputs: input (required), workflow.
save_artifactA
Save a single artifact (research report, table, framework, spec, code) linked to a conversation memory.
WHEN TO USE: After calling save_conversation for a session that produced artifacts. Call this ONCE PER ARTIFACT with the full verbatim content — do NOT summarize or truncate.
WHY: Artifacts are the highest-value output of research sessions. Saving them separately ensures complete preservation. Each artifact becomes a first-class searchable object linked to its parent conversation.
FLOW:
save_conversation(title="Research Session", conversationId="my-research") → saves the conversation transcript
save_artifact(conversationId="my-research", title="Competitive Analysis", type="research", content="")
save_artifact(conversationId="my-research", title="Ranking Table", type="table", content="")
IMPORTANT: Send the COMPLETE artifact content in the content field. The entire point of this tool is to preserve artifacts that would otherwise be lost or summarized. Minimum 100 characters.
Inputs: type (required), title (required), content (required), conversationId (required), +1 more.
save_conversationA
Save complete conversations as memory. REQUIRED: Send COMPLETE conversation in 'conversationContent' parameter (minimum 100 chars, should be thousands). Include EVERY message verbatim - NO summaries or partial content.
Intelligently tracks context, extracts project details, and routes to a single memory per conversation topic.
HOW SAVES TARGET MEMORIES:
- conversationId is auto-generated from title slug (e.g., "MCP Tools" → "mcp-tools")
- Same title (or explicit conversationId) → targets the existing memory
- The 'mode' parameter controls what happens to that existing memory:
• mode='replace' (default): overwrites the existing content with what you send
• mode='append': concatenates new content below existing with a timestamped separator
(\n\n--- UPDATE <ISO8601> ---\n\n) — preserves all prior history in the live row
- The /save skill sets mode='append' automatically for living-document use
- For one-shot snapshots, ad-hoc captures, or explicit overwrite: pass mode='replace'
PRIOR CONTENT IS NEVER LOST:
- Even with mode='replace', prior content is snapshotted to memory_events audit log on every update
- Recovery from overwrites requires a one-off script (out-of-band)
- Use mode='append' if you want history to remain visible inline in the live memory
INTELLIGENT EXTRACTION (independent of mode):
- Auto-extracts project context (name, component, feature being discussed)
- Detects work iteration and status (planning/in_progress/completed/blocked)
- Generates smart titles like "Purmemo - Timeline View - Implementation"
- Tracks technologies, tools used, identifies relationships/dependencies
SERVER AUTO-CHUNKING:
- Large conversations (>15K chars) automatically split into linked chunks
- Small conversations (<15K chars) saved directly as single memory
- You always send complete content — server handles chunking
- APPEND + CHUNKING: append mode works only for content <15K chars. Saves >15K
with mode='append' are rejected with a clear error — appending to chunked
storage would double each chunk's content on re-save. For long-running living
docs, send only the new delta since the last save (keep it <15K) or use
mode='replace' for full re-saves.
- KNOWN CAVEAT: a doc that is saved small (single memory) and later grows past 15K
transitions to chunked storage at a new conversation_id space — the original
single memory becomes orphaned. Tracked under ADR-038 (uniform namespace).
EXAMPLES:
User: "Save progress" via /save skill
→ /save sets mode='append'; new content is appended below prior content
User: "Save this snapshot" (one-shot capture)
→ mode='replace' default; current content overwrites any existing memory at this title
User: "Save as conversation react-hooks-guide" with explicit append
→ save_conversation(conversationId="react-hooks-guide", mode="append")
→ Appends to existing memory at that ID (or creates if new)
WHAT TO INCLUDE (COMPLETE CONVERSATION REQUIRED):
- EVERY user message (verbatim, not paraphrased)
- EVERY assistant response (complete, not summarized)
- ALL code blocks with full syntax
- ALL artifacts with complete content (not just titles/descriptions)
- ALL file paths, URLs, and references mentioned
- ALL system messages and tool outputs
- EXACT conversation flow and context
- Minimum 500 characters expected - should be THOUSANDS of characters
FORMAT REQUIRED:
=== CONVERSATION START ===
[timestamp] USER: [complete user message 1]
[timestamp] ASSISTANT: [complete assistant response 1]
[timestamp] USER: [complete user message 2]
[timestamp] ASSISTANT: [complete assistant response 2]
... [continue for ALL exchanges]
=== ARTIFACTS ===
[Include ALL artifacts with full content]
=== CODE BLOCKS ===
[Include ALL code with syntax highlighting]
=== END ===
IMPORTANT: Do NOT send just "save this conversation" or summaries. If you send less than 500 chars, you're doing it wrong. Include the COMPLETE conversation with all details.
ARTIFACT PRESERVATION (ADR-025):
If this conversation produced artifacts (research reports, tables, frameworks, specs, design documents),
save them SEPARATELY using save_artifact after this call.
Flow: save_conversation first, then save_artifact for each artifact.
This ensures artifacts are preserved in full — do not try to embed large artifacts in conversationContent.Inputs: conversationContent (required), mode, tags, title, +2 more.
save_investigation_resultA
Save AI investigation results for an error incident.
Used to store investigation results for audit trail and learning from past fixes.
Call this after investigating an error and proposing/deploying a fix.
USAGE:
- Call after completing investigation and deploying fix
- Stores root cause analysis, research sources, proposed changes
- Creates audit trail for learning from past investigations
REQUEST FIELDS:
- incident_id: UUID of the error incident (from get_acknowledged_errors)
- root_cause_analysis: Your analysis of what caused the error
- similar_incidents_analyzed: Array of similar incident IDs found
- research_sources: Array of URLs used (search_web_ai, Context7 docs)
- fix_type: Type of fix - 'code_change', 'config_update', 'deployment', 'migration', 'documentation'
- proposed_changes: Object with file paths and changes made
- confidence_score: Your confidence in the fix (0.0-1.0)
- risk_level: Risk assessment - 'low', 'medium', 'high'
- test_plan: How you tested the fix
- rollback_plan: How to roll back if needed
- deployment_commit_hash: Git commit hash of the fix
- deployment_results: Object with deployment success/failure details
EXAMPLE:
save_investigation_result({
incident_id: "550e8400-e29b-41d4-a716-446655440000",
root_cause_analysis: "Timeout set to 5s, too short for slow networks",
fix_type: "code_change",
confidence_score: 0.85,
risk_level: "low",
deployment_commit_hash: "abc123def456"
})
RETURNS:
- investigation_id: UUID of saved investigation
- incident_id: UUID of the error incident
- investigation_status: 'in_progress' or 'completed'
- deployment_status: 'not_started', 'in_progress', 'completed'
- success: true if saved successfullyInputs: incident_id (required), fix_type, test_plan, risk_level, +8 more.
save_snapshotA
Persist your synthesized snapshot content as a draft. Step 3 of the MCP snapshot path (ADR-032 Amendment A).
Call this after synthesizing from snapshot_sources(). Backend derives evidence_tier from cited_ids — not caller-controlled. Runs claim verification on your content.
Inputs: topic (required), content (required), cited_ids (required), force.
save_test_resultAIdempotent
Save a test result memory for a project, linked to the current active task.
Call this after running tests — pass or fail — to record the outcome. Saves a memory with category='test_result' and links it to the most recent active task. Re-running with the same test_suite name updates the existing memory (living document).
USAGE:
After a passing test run: save_test_result({ project_name, passed: true, test_suite })
After a failing run: save_test_result({ ..., passed: false, failure_details: "..." })
RETURNS:
memory_id — UUID of the saved test result memory
status — "PASSED" or "FAILED"
linked_task — the active task this result is associated with (if any)
Inputs: passed (required), test_suite (required), project_name (required), failure_details.
snapshotA
Generate a state-shaped artifact for a topic from your saved memories.
WHEN TO USE: When you want a current-state document derived from saved conversations — architecture map, glossary, runbook, manifesto, project state. The slash command /snapshot calls this.
HOW IT WORKS:
Queries memories matching the topic (fuzzy match against tags + title), recency-weighted.
Builds a draft snapshot via the deterministic baseline generator (concatenates source memories — Phase 1 baseline; Gemini integration ships later).
Computes evidence_tier (A/B/C, deterministic) and grounded_ratio (claim verification).
Persists as status='draft'. Promotion to canonical requires explicit POST /api/v1/snapshots/{id}/accept per ADR-032.
INSERT-only — each call creates a new draft (versioned). Two snapshots of the same topic both exist; supersede via /accept.
EXAMPLES:
snapshot(topic: "architecture") — gathers all memories tagged or titled with "architecture"
snapshot(topic: "auth") — pulls everything auth-related, recency-weighted
Inputs: topic (required).
snapshot_sourcesARead-onlyIdempotent
Fetch citation bundle + conflict detection for a topic so YOU can synthesize the snapshot in-context. Step 1 of the MCP snapshot path (ADR-032 Amendment A).
WHEN TO USE: When you want to generate a snapshot from inside Claude. Returns source memories + conflicts so you synthesize, then call save_snapshot() to persist.
FLOW:
snapshot_sources(topic) → sources returned to you
You synthesize a current-state document from the sources
save_snapshot(topic, content, cited_ids) → persists your synthesis as a draft
accept_snapshot(snapshot_id) → promotes to canonical
Inputs: topic (required).
what_changedARead-onlyIdempotent
TIMELINE OF A THING: what facts about an entity (a project, machine, person, product) were TRUE and then REPLACED by newer facts, with dates — plus any open contradictions. Served by the purmemo-next ledger, which knows when a fact became true and when it stopped; plain search cannot answer this.
WHEN TO USE: "what changed about X", "what used to be true about X", "when did X move/switch/get renamed", "is this fact still current", or before relying on an older memory about X.
EXAMPLES: what_changed({ entity: "purmemo-next" }) → e.g. "2026-08-10 [hosting]: database stayed on Supabase → now: migrated to the Mac mini" what_changed({ entity: "clo-mini", limit: 20 })
Returns: current-fact count, superseded facts newest-first with what replaced each, open contradictions, and the entity id. Read-only.
Inputs: entity (required), limit.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 29 tools
Descriptions are detailed and give WHEN TO USE guidance, but the set contains several overlapping clusters: a five-tool snapshot family (get_snapshot, snapshot, snapshot_sources, save_snapshot, accept_snapshot) and a save family (save_conversation, save_artifact, save_snapshot, save_test_result, commit). An agent must read carefully to pick the right one, and 'snapshot' vs 'get_snapshot' are easy to confuse.
Mostly snake_case, but the verb conventions are mixed: most tools use verb_noun (get_snapshot, save_conversation, list_workflows), while several are bare nouns/verbs (snapshot, commit, what_changed). The inconsistency within the snapshot family itself weakens predictability.
29 tools is well above the 3-15 well-scoped range and on the high end even for the broad memory domain. Several families could be consolidated (e.g. the five snapshot-related tools), suggesting bloat rather than each tool clearly earning its place.
The surface covers a lot: conversation/artifact capture, snapshots, commitments, recall with filters, timeline, clusters, user context, workflows, public sharing, and test/task tracking. Minor gaps remain (no explicit update/delete for individual memories) but core workflows are covered.
Maintenance
Related MCP Connectors
Persistent memory for AI assistants. Save once; recall from Claude, ChatGPT, or any MCP client.
Long-term memory for AI assistants. Isolated per-user storage, recall across conversations.
Persistent memory layer for AI tools. Save and recall notes across Claude and other MCP clients.
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Related MCP Servers
- -licenseNot gradedqualityDmaintenanceProvides persistent memory for AI assistants like Claude, storing and retrieving information across conversations using a local SQLite database.-
- AlicenseNot gradedqualityDmaintenanceProvides persistent cross-session memory for Claude Code, enabling it to remember user preferences, decisions, and project context across new sessions.Apache 2.0

SAE4U Memoryofficial
AlicenseAqualityCmaintenanceProvides persistent memory for Claude with hierarchical categorization, cross-corpus recall, session journals, and customizable persona, enabling memory continuity across sessions.7MIT- FlicenseNot gradedqualityDmaintenanceEnables AI tools like Claude and Cursor to share persistent memory across sessions.5-