purmemo

SSE

by purmemo-ai

9 downloads Not rated yet

GitHub Website

About

AI conversation memory that works everywhere — save and recall across Claude, ChatGPT, Gemini, Cursor, and all MCP-compatible platforms. 11 tools including shared community memories.

Details

Transport: SSE

Explore

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name purmemo

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

`save_conversation`

Save complete conversations as living documents. 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 maintains a single memory per conversation topic. LIVING DOCUMENT + INTELLIGENT PROJECT TRACKING: - Each conversation becomes a living document that grows over time - Automatically extracts …

`recall_memories`

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_observation…

`get_memory_details`

Get complete details of a specific memory, including all linked parts if chunked

`discover_related_conversations`

CROSS-PLATFORM DISCOVERY: Find related conversations across ALL AI platforms. Uses Purmemo's semantic clustering to automatically discover conversations about similar topics, regardless of which AI platform was used (ChatGPT, Claude Desktop, Gemini, etc). WHAT THIS DOES: - Searches for memories matching your query - Uses AI-organized semantic clusters to find related conversations - Groups results by topic cluster with platform indicators - Shows conversations yo…

`get_user_context`

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 - c…

`run_workflow`

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…

`list_workflows`

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.

`share_memory`

Set the visibility of a memory you own. VISIBILITY LEVELS: - private: Only you can see it (default) - unlisted: Anyone with the direct link can view it - public: Discoverable in the community tab by all users WHEN TO USE: - User says "share this memory" or "make this public" - User wants to share knowledge with the community - User wants to generate a shareable link QUOTA: - Free tier: 5 shares/month - Pro/Teams: Unlimited EXAMPLE: share_memory({ memory_id: "abc-123", visibility: "public"…

`recall_public`

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 …

`get_public_memory`

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-45…

`report_memory`

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" })

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "purmemo": {
            "server": {
                "command": "node",
                "args": [
                    "purmemo-mcp"
                ]
            }
        }
    }
}

McpServers

{
    "server": {
        "command": "node",
        "args": [
            "purmemo-mcp"
        ]
    }
}

Transport

"stdio"

Package

"purmemo-mcp"

Registry

"npm"

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 theChrome Extensioninstead.

curl -fsSL https://app.purmemo.ai/install | sh

irm https://app.purmemo.ai/install.ps1 | iex

That's it for installing. The script handles everything — it'll install Node if you don't have it, set up thepurmemocommand, and tell you when it's done.

Quit and reopen Claude Desktop (or Claude Code). pūrmemo is now connected.

You'll know it workedwhen your next Claude session opens with a header like:

pūrmemo v15.7.20 · [email protected] · Free · 0 memories

Try saying "save this" at the end of a conversation, or "what was I working on?" at the start of a new one.

purmemocommand 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 init

This 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 atgithub.com/purmemo-ai/purmemo-mcp/issues— we read every one.

- 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.
- Works everywhere— Claude Code, Claude Desktop, Cursor, Windsurf, Zed, anything that speaks MCP.

Three slash commands you'll use most:

npm install -g purmemo-mcp && purmemo

Or, run it once without installing globally:

Open Claude Desktop → Settings → Developer → Edit Config and add:

{ "mcpServers": { "purmemo": { "url": "https://mcp.purmemo.ai/mcp/messages", "transport": "streamable-http" } } }

Get your API key from app.purmemo.ai→ Settings → API Keys, then edit:

- macOS:~/Library/Application Support/Claude/claude_desktop_config.json
- Windows:%APPDATA%\Claude\claude_desktop_config.json

{ "mcpServers": { "purmemo": { "command": "npx", "args": ["-y", "purmemo-mcp"], "env": { "PURMEMO_API_KEY": "your-api-key-here" } } } }

{ "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 undercontext_servers:

{ "context_servers": { "purmemo": { "command": { "path": "npx", "args": ["-y", "purmemo-mcp"], "env": { "PURMEMO_API_KEY": "your-api-key" } } } } }

Looking for the technical stuff? It's all here:

- Tools, resources, prompts reference— every MCP tool the server exposes (save_conversation,recall_memories,commit,snapshot,run_workflow, etc.)
- 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.

- Dashboard— view and manage memories
- Chrome Extension— for ChatGPT, Claude.ai, Gemini in browser
- Privacy Policy— encrypted in transit and at rest, never shared
- Support / Issues

The MCP connector code in this repo is MIT licensed. The pūrmemo platform, API, and backend are proprietary.

Local-first cross-agent memory MCP. 6-layer structured brain (goal/context/emotion/impl/caveat/learning) with token-saving file diff cache (86% measured savings on re-reads)

An AI capability enhancement system providing professional roles, memory management, and knowledge systems for applications like Claude and Cursor.

Mnemex is a Python MCP server that provides AI assistants with human-like memory dynamics through temporal decay and natural spaced repetition, storing memories locally in human-readable JSONL and Markdown formats.

Give your AI the ability to remember key facts and everything you've ever discussed

Centralized note store across AI clients: Claude, ChatGPT, Cursor, Codex, Windsurf. Save in one client, access in another instantly. Across devices — phone, desktop, everywhere. Cross-session context: 'catch me up' surfaces plans and findings from any prior session. AES-256-GCM encryption at rest, per-user key isolation. Soft delete with 30-day recovery window. Pin notes to exempt from cleanup and prioritize. Tag notes for categorization and filtering ('tag: auth'). Your mctx account is your identity — instant access from any AI tool.

Your prompt library as an MCP server — search and pull your saved prompts & skills straight into Claude Code, Cursor, ChatGPT & Windsurf.

Persistent memory for AI assistants and coding agents across ChatGPT, Claude, Cursor, and other MCP-compatible tools.

One shared, versioned memory for your AI agents across Claude Code, Cursor, Kiro and Grok, with a source on every answer and full history.

Hebbian memory for AI agents — learns file access patterns, builds neural pathways, predicts next tools/files, saves tokens

Operational memory for AI agents that persists across sessions and tools.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Explore

Setting up with Highlight

save_conversation

recall_memories

get_memory_details

discover_related_conversations

get_user_context

run_workflow

list_workflows

share_memory

recall_public

get_public_memory

report_memory

Claude Desktop / Cursor

McpServers

Transport

Package

Registry

More like this

Aws Kb Retrieval Server

Time

Memory

Context 7

`save_conversation`

`recall_memories`

`get_memory_details`

`discover_related_conversations`

`get_user_context`

`run_workflow`

`list_workflows`

`share_memory`

`recall_public`

`get_public_memory`

`report_memory`