Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Obsidian Hippocampus MCP — Persistent Agent Memory

    1

    Local persistent agent memory engine with Obsidian vault sync and Ebbinghaus forgetting logic.

    $60

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Obsidian Hippocampus MCP — Persistent Agent Memory

    Obsidian Hippocampus MCP — Persistent Agent Memory

    Example session with this skill installed

    Store a permanent memory that I prefer using Tailwind CSS for all frontend components and recall it to confirm it worked.

    • Read your context and instructions
    • Compiled the obsidian hippocampus mcp

    I have stored your preference for Tailwind CSS as a permanent memory and verified it via semantic recall.

    Memory Operation Results

    ActionKeyResultScore / Path
    Storepref-frontend-cssSuccess (Permanent)~/.hippocampus-mcp/memories/pref-frontend-css.md
    Recallpref-frontend-cssFound0.85

    Recall Data

    {
      "key": "pref-frontend-css",
      "score": 0.85,
      "content": "User prefers using Tailwind CSS for all frontend components",
      "tags": ["preference", "frontend", "css"]
    }
    

    Next steps

    • Open your Obsidian vault to see the new Markdown file with YAML frontmatter.
    • Add the permanent tag to other critical architectural decisions to exempt them from the forgetting sweep.
    • Use node motor/dist/cli.js status to monitor your total memory count.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    LLMs suffer from goldfish memory, losing track of user preferences and project decisions as soon as the context window rolls over. This skill provides a persistent memory engine for your agent, backed by a local Obsidian vault or a standalone JSON state file.

    What it does

    • Persistent storage — Saves facts, preferences, and architectural decisions as Markdown notes with YAML frontmatter.
    • Semantic recall — Retrieves relevant memories using a hybrid ranking of TF-IDF word similarity, access frequency, and tag matches.
    • Ebbinghaus forgetting — Automatically prunes stale memories based on a decay algorithm, moving forgotten items to a .trash folder rather than deleting them.
    • Obsidian synchronization — Performs bidirectional sync between the agent's memory state and an Obsidian vault, allowing you to edit memories manually.
    • Native MCP support — Operates either as a CLI tool for scripts or as a full Model Context Protocol (MCP) server for Claude Desktop and Cursor.

    How it works

    1. Initialize — Point the engine to an existing Obsidian vault or let it create a local state directory.
    2. Remember — Use the remember command to store strings, tags, and keys representing project-specific knowledge.
    3. Recall — Query the memory bank to retrieve the most relevant historical context for the current task.
    4. Sync — Run sync to import manual notes from Obsidian or export agent-generated memories to the vault.

    Frameworks & tools

    Built with Node.js 20+. Uses a local CLI engine located in the motor/ directory. Requires no external APIs, databases, or cloud accounts.

    Why this beats prompting it yourself

    Prompting an agent to "remember" only works within the current session. This skill creates a durable knowledge base that persists across reboots and different IDE instances, ensuring the agent never forgets your preferred tech stack or past debugging solutions.

    Use cases

    • Developer preferences — Store specific linting rules, naming conventions, and UI themes across all projects.
    • Project architecture — Maintain a record of why specific libraries or database schemas were chosen to prevent repetitive questioning.
    • Debugging history — Log complex fixes so the agent can instantly recall the solution if a similar error occurs months later.

    Known limitations

    Requires Node.js 20 or newer. Semantic recall relies on TF-IDF keyword matching, not vector embeddings, so queries must share vocabulary with the stored content.

    Requires Node.js 20+. No vector embeddings; search uses TF-IDF keyword matching. Requires manual initial dependency installation. Vault root must contain a .obsidian directory.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 19 days ago

    Requires

    Node.js
    Obsidian Hippocampus MCP
    Hippocampus MCP
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables
    Listed19 days ago

    What's inside

    Frequently Asked Questions

    Traditional prompting only lasts for a single session, whereas this skill creates a permanent knowledge base in your local filesystem. It allows agents to retain preferences, project history, and architectural decisions across different days and IDE instances.

    The skill functions as a native MCP server, making it compatible with Claude Desktop, Cursor, and any other IDE or agent framework that supports the Model Context Protocol. It requires Node.js 20 or newer to run locally.

    You get the full MCP server package, a CLI tool for manual memory management, and the 'motor' engine. No external database or API subscriptions are required, as all data stays in your local Markdown or JSON files.

    The Ebbinghaus logic uses a decay algorithm that tracks how often a memory is accessed; seldom-used facts are eventually moved to a `.trash` folder. This keeps the agent's active context focused on high-value information while preventing memory bloat.

    Yes, you can point the skill to any existing Obsidian vault. It performs bidirectional syncing, meaning the agent can read your handwritten notes and you can manually edit or refine the memories the agent has stored.

    Currently, the skill uses a hybrid ranking of TF-IDF and keyword matching rather than vector embeddings. This ensures it remains fast and fully local without needing an external embedding model or GPU acceleration.

    New in LLM Ops