Skip to main content
Glama

npm version License: MIT Quantum Safe

CogmemAi — Cognitive Memory for Any Ai System

Autonomous robots. Self-driving vehicles. Defense systems. Coding assistants. Any Ai system that needs to remember.

CogmemAi is a portable memory layer that gives any Ai system persistent recall across sessions, devices, users, and teams — and captures knowledge autonomously, even when your Ai forgets to save. 95.10% accuracy on LongMemEval — top published score on the field's hardest long-term memory benchmark. 91% on LoCoMo, above human performance (87.9%). Quantum-safe encryption. Works with Claude Code, Cursor, Windsurf, Cline, Continue, and any MCP-compatible tool. Switch editors, switch models, switch machines — your knowledge stays. Not just one score on a test — the most complete Ai memory system available.

What's New in v3

Autonomous Memory — Your Ai Doesn't Decide Whether to Save Anymore (v3.15)

Every memory system has the same hidden failure mode: the Ai has to choose to save, and under pressure it doesn't. You can bake instructions into system prompts. You can nudge. But when your Ai is head-down on a coding task, it forgets to save — and the decisions you made two hours ago vanish when the context compacts.

CogmemAi v3.15 moves the decision out of the Ai's hands entirely. Your coding sessions are captured at the infrastructure level — decisions, file changes, bug fixes, and deployments land in memory without a single prompt. At session end, an intelligence pass distills them into structured memories: the right types, the right importance scores, the right scopes. Your Ai never sees this happen.

The result: a day of heavy coding produces 15–20 quality memories instead of 3. Future sessions pick up seamlessly. Your Ai stops re-litigating architectural choices you already made. Stop reminding your Ai to remember. It just does.

Think Before You Speak — Proactive Memory Recall (v3.12)

CogmemAi now thinks before it speaks. Before your Ai assistant suggests any action, approach, or recommendation, CogmemAi checks its memory first — automatically, on every topic.

  • preflight tool — A fast, lightweight recall designed to be called before every suggestion. Your assistant checks what it already knows about a topic before opening its mouth. "Let's try approach X" → first checks if X was already tried, rejected, or completed. Sub-200ms, near-zero cost.

  • Prior context surfacing — Every time a memory is saved, CogmemAi automatically searches for related prior memories across all topics — people, companies, technical approaches, features, everything — and surfaces them in the response. Your assistant never suggests something redundant.

  • Smart recall hooks — In Claude Code, CogmemAi reads every user message and automatically injects relevant memories before the assistant responds. No manual recall needed — context arrives before the assistant starts thinking.

  • Upgraded recall engine — Higher-dimensional semantic understanding, balanced reranking, keyword-expanded search, dual-path memory storage for more reliable retrieval, and adaptive search that expands automatically when initial results are low confidence.

The result: your Ai assistant stops suggesting things you've already tried, people you've already contacted, and approaches you've already rejected. Your brain is no longer the safety net for what your tools should already know.

Wisdom Engine — Auto-Extracted Principles (v3.10)

CogmemAi now automatically detects patterns across your memories and extracts factual principles. While skills tell your Ai HOW to behave ("always use Zustand"), principles tell it what's TRUE about your project ("this codebase never validates inputs at service boundaries"). Principles are extracted from clusters of 5+ related memories, scored by confidence, and injected into every session. Use extract_principles to trigger manually or let it happen automatically.

Remote MCP — Zero Install (v3.9)

CogmemAi now supports Streamable HTTP transport — connect from any MCP client without installing anything. No npm, no config files, no Node.js required. Just point your client to https://hifriendbot.com/mcp/ with your API key and start using persistent memory immediately. Same 35 tools, same Intelligence Engine, same benchmark-topping accuracy — zero setup friction.

Quantum-Safe Encryption (v3.7)

CogmemAi is the first quantum-safe Ai memory system. All memories are encrypted at rest with quantum-resistant encryption — both in cloud mode and local mode. Your data is protected against today's threats and tomorrow's quantum computers. Encryption is automatic, zero-config, and enabled by default. No setup required.

Choose Your Storage Mode (v3.6)

CogmemAi now runs three ways — pick the one that fits your workflow:

Cloud (default)

Local

Hybrid

Best for

Full intelligence, team collaboration, cross-device portability

Zero-config start, offline-only environments

Local speed + cloud brains, travel/unreliable networks

Setup

npx cogmemai-mcp setup (choose Cloud)

npx cogmemai-mcp setup (choose Local)

npx cogmemai-mcp setup (choose Hybrid)

API key needed

Yes (free)

Yes (free) — like a license key, your data stays local

Yes (free)

Search

Semantic (by meaning)

Full-text search (FTS5)

Semantic with local fallback

Intelligence Engine

Full — auto-linking, contradiction detection, memory decay, auto-skills, query synthesis

FTS5 search + CRUD — data stays on your machine

Full — with offline resilience

Team collaboration

Yes

No

Yes

Cross-device sync

Automatic

No — data stays on your machine

Automatic with local cache

Offline support

Requires internet

Full offline

Falls back to local when offline

Encryption

Quantum-safe (server)

Quantum-safe (local)

Quantum-safe (both)

Cloud mode is the recommended experience. It gives you the full Intelligence Engine — semantic search that finds memories by meaning, auto-linking knowledge graph, contradiction detection, self-improving recall, auto-skills, query synthesis, and team collaboration. Everything that makes CogmemAi more than just a database.

Local mode keeps your data on your machine. A free API key is required for registration (like a software license key), but all your data stays local. Full-text search (FTS5) provides quality recall. Works offline after initial setup. When you're ready for semantic search and the full Intelligence Engine, upgrading to cloud takes one command.

Hybrid mode is for developers who travel or work on unreliable networks. Saves to both local and cloud simultaneously. Reads from cloud when available, falls back to local when offline. Unsynced memories automatically push to cloud when connectivity returns.

Intelligence Engine + Auto-Skills (v3.5)

CogmemAi now gets smarter every time you use it. The Intelligence Engine is a self-improving memory system that learns what matters, connects related knowledge automatically, and synthesizes answers from your entire memory. Auto-Skills takes it further — CogmemAi doesn't just remember, it learns how to behave.

Auto-Skills (Closed-Loop Learning)

  • Behavioral skills — CogmemAi automatically synthesizes your corrections, preferences, and patterns into behavioral directives that tell your Ai assistant HOW to work, not just what to know

  • Closed learning loop — correct your assistant once, and CogmemAi detects the pattern. After enough evidence accumulates, it generates a skill that prevents the mistake from ever happening again

  • Confidence tracking — each skill has a confidence score that rises when it works and drops when it doesn't. Low-confidence skills are automatically retired

  • Self-evaluation — skills periodically review themselves against new evidence and adapt, strengthen, or retire as your practices evolve

Intelligence Engine — 95.10% on LongMemEval, 91% on LoCoMo

CogmemAi scores 95.10% accuracy on LongMemEval — the top published score on the field's hardest long-term memory benchmark — and 91% accuracy on LoCoMo with a 100% retrieval hit rate, above human performance (87.9%). Two benchmarks, two #1-tier scores. CogmemAi finds the right memories when you need them.

  • Precision reranking — every recall runs a second-pass reranker that re-scores candidates for precision, balanced with the initial ranking signal to surface the most relevant memory first

  • Self-improving recall — memories that consistently help you rank higher over time; memories you never use fade naturally. Your recall quality improves automatically with every session

  • Auto-linking knowledge graph — related memories are automatically connected when you save them. Your knowledge builds into a web of relationships, not a flat list

  • Contradiction detection — when recalled memories conflict with each other, CogmemAi flags the contradiction so you catch stale or outdated information before it causes problems

  • Context-aware ranking — tell CogmemAi what you're doing (debugging, planning, reviewing) and it boosts the right types of memories. Debugging? Bug reports and patterns surface first. Planning? Architecture decisions lead

  • Query synthesis — ask a question and get one coherent answer synthesized from all your relevant memories, not just a list of matches. Like asking a teammate who's read everything

  • Cross-project intelligence — patterns that appear across 3+ projects are automatically promoted to global scope. Your best practices follow you everywhere without manual effort

  • Proactive insights — at session start, CogmemAi tells you what you should know before you ask. Stale critical memories, duplicate subjects that need merging, patterns ready for promotion

Also in v3

  • Memory health score — 0-100 score with actionable factors

  • Session replay — pick up exactly where you left off with automatic session summaries

  • Self-tuning memory — importance adjusts based on real usage; stale memories auto-archive

  • Auto-ingest README — learn from your README on new projects instantly

  • Smart recall — relevant memories surface automatically as you switch topics

  • Auto-learning — CogmemAi learns from your sessions automatically

  • Task tracking — persistent tasks with status and priority

  • Correction learning — teach your assistant to avoid repeated mistakes

  • Session reminders — nudges that surface at the start of your next session

  • Mandatory rules — define absolute requirements ("NEVER do X", "ALWAYS do Y") that surface in every session, bypassing all scoring and decay

  • Autonomous memory — captures work even when your Ai skips saves

  • 35+ tools — the most complete memory toolkit for any Ai system

Related MCP server: SharedMemory MCP Server

Quick Start

Option 1: Remote (Zero Install)

Connect directly — no npm, no setup, no config files. Just add the remote endpoint to your MCP client with your API key:

Endpoint: https://hifriendbot.com/mcp/ Auth: Bearer token (your cm_ API key)

Get your free API key at hifriendbot.com/developer.

Works with any MCP client that supports Streamable HTTP transport (Claude Desktop, Cursor, and more).

Option 2: Local Install

npx cogmemai-mcp setup

The setup wizard walks you through three choices: Cloud (recommended — full Ai intelligence), Local (data stays on your machine), or Hybrid (both). Pick your mode, enter your API key if needed, and you're ready in under 60 seconds.

Don't have an API key yet? Get one free at hifriendbot.com/developer. Or choose Local mode to start immediately with no account.

The Problem

Every time you start a new session, you lose context. You re-explain your tech stack, your architecture decisions, your coding preferences. Built-in memory in tools like Claude Code is a flat file with no search, no structure, and no intelligence.

CogmemAi gives your Ai assistant a real memory system:

  • Semantic search — finds relevant memories by meaning, not keywords

  • Ai-powered extraction — automatically identifies facts worth remembering from your conversations

  • Smart deduplication — detects duplicate and conflicting memories automatically

  • Privacy controls — auto-detects API keys, tokens, and secrets before storing

  • Document ingestion — feed in READMEs and docs to instantly build project context

  • Project scoping — memories tied to specific repos, plus global preferences that follow you everywhere

  • Smart context — intelligently ranked for maximum relevance to your current work

  • Autonomous memory capture — saves knowledge even when your Ai forgets to call save. Decisions, file changes, and fixes land in memory without prompting

  • Compaction recovery — survives Claude Code context compaction automatically

  • Token-efficient — compact context loading that won't bloat your conversation

  • Zero setup — no databases, no Docker, no Python, no vector stores

CogmemAi offers three storage modes, but cloud is where the magic happens. The Intelligence Engine — semantic search, auto-linking knowledge graph, contradiction detection, self-improving recall, auto-skills, and query synthesis — runs server-side. In cloud mode, your MCP server is a thin HTTP client with zero local databases, zero RAM issues, zero maintenance. All memories are encrypted at rest, so your data is just as secure as local storage — with cross-device portability and team features on top.

Your memory follows you everywhere. Memories created in Claude Code are instantly available in Cursor, Windsurf, Cline, and any MCP-compatible tool. Switch between Opus, Sonnet, Haiku, or any model your editor supports — your memories persist regardless. New laptop? New OS? Log in and your full project knowledge is waiting. A local SQLite file dies with your machine. Cloud memory is permanent.

The privacy argument is a myth. Some memory tools market "local-first" as a privacy advantage. But think about what happens next: every memory your Ai reads gets sent to the model provider (Anthropic, OpenAI, Google) as part of the prompt. Your data leaves your machine at inference time no matter where it's stored. A local SQLite file doesn't protect your memories — it just makes them harder to search, slower to access, and impossible to share. CogmemAi encrypts at rest, transmits over HTTPS, and adds intelligence that local storage simply can't match.

Teams and collaboration. Cloud memory is the only way to share project knowledge across teammates. When one developer saves an architecture decision or documents a bug fix, every team member's Ai assistant knows about it instantly. No syncing, no merge conflicts, no stale local databases. Whether it's two developers or twenty, everyone's assistant has the same up-to-date context. This is impossible with local-only memory solutions.

Compaction Recovery

When your Ai assistant compacts your context, conversation history gets compressed and context is lost. CogmemAi handles this automatically — your context is preserved before compaction and seamlessly restored afterward. No re-explaining, no manual prompting.

The npx cogmemai-mcp setup command configures everything automatically.

Skill

CogmemAi includes a Claude Skill that teaches Claude best practices for memory management — when to save, importance scoring, memory types, and session workflows.

Claude Code:

/skill install https://github.com/hifriendbot/cogmemai-mcp/tree/main/skill/cogmemai-memory

Claude.ai: Upload the skill/cogmemai-memory folder in Settings > Skills.

CLI Commands

npx cogmemai-mcp setup          # Interactive setup wizard
npx cogmemai-mcp setup <key>    # Setup with API key
npx cogmemai-mcp verify         # Test connection and show usage
npx cogmemai-mcp --version      # Show installed version
npx cogmemai-mcp help           # Show all commands

Manual Setup

If you prefer to configure manually instead of using npx cogmemai-mcp setup:

Option A — Per project (add .mcp.json to your project root):

{
  "mcpServers": {
    "cogmemai": {
      "command": "cogmemai-mcp",
      "env": {
        "COGMEMAI_API_KEY": "cm_your_api_key_here"
      }
    }
  }
}

For local mode (free API key required for registration, data stays local):

{
  "mcpServers": {
    "cogmemai": {
      "command": "cogmemai-mcp",
      "env": {
        "COGMEMAI_MODE": "local",
        "COGMEMAI_API_KEY": "cm_your_api_key_here"
      }
    }
  }
}

Option B — Global (available in every project):

# Cloud (default)
claude mcp add cogmemai cogmemai-mcp -e COGMEMAI_API_KEY=cm_your_api_key_here --scope user

# Local (free API key required, data stays local)
claude mcp add cogmemai cogmemai-mcp -e COGMEMAI_API_KEY=cm_your_api_key_here -e COGMEMAI_MODE=local --scope user

# Hybrid (both)
claude mcp add cogmemai cogmemai-mcp -e COGMEMAI_API_KEY=cm_your_api_key_here -e COGMEMAI_MODE=hybrid --scope user

Works With

Automatic setup:

npx cogmemai-mcp setup

Cursor

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "cogmemai": {
      "command": "npx",
      "args": ["-y", "cogmemai-mcp"],
      "env": { "COGMEMAI_API_KEY": "cm_your_api_key_here" }
    }
  }
}

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "cogmemai": {
      "command": "npx",
      "args": ["-y", "cogmemai-mcp"],
      "env": { "COGMEMAI_API_KEY": "cm_your_api_key_here" }
    }
  }
}

Cline (VS Code)

Open VS Code Settings > Cline > MCP Servers, add:

{
  "cogmemai": {
    "command": "npx",
    "args": ["-y", "cogmemai-mcp"],
    "env": { "COGMEMAI_API_KEY": "cm_your_api_key_here" }
  }
}

Continue

Add to ~/.continue/config.yaml:

mcpServers:
  - name: cogmemai
    command: npx
    args: ["-y", "cogmemai-mcp"]
    env:
      COGMEMAI_API_KEY: cm_your_api_key_here

CogmemUI

CogmemUI is a free multi-model Ai workspace with built-in CogmemAi memory. Add your CogmemAi API key in Settings > API Keys and your memory is instantly available. CogmemUI also supports connecting any MCP-compatible tool server via Settings > MCP Servers — add endpoints, auto-discover tools, and use them in chat.

Get your free API key at hifriendbot.com/developer.

Tools

CogmemAi provides 35 tools that your Ai assistant uses automatically:

Tool

Description

preflight

Think Before You Speak. Fast recall to check prior context before making any suggestion

save_memory

Store a fact explicitly (architecture decision, preference, etc.)

recall_memories

Search memories using natural language (semantic search)

extract_memories

Ai extracts facts from a conversation exchange automatically

get_project_context

Load top memories at session start (with smart ranking, health score, and session replay)

list_memories

Browse memories with filters (paginated, with untyped filter)

update_memory

Update content, importance, scope, type, category, subject, and tags

delete_memory

Permanently delete a memory

bulk_delete

Delete up to 100 memories at once

bulk_update

Update up to 50 memories at once (content, type, category, tags, etc.)

get_usage

Check your usage stats and tier info

export_memories

Export all memories as JSON for backup or transfer

import_memories

Bulk import memories from a JSON array

ingest_document

Feed in a document (README, API docs) to auto-extract memories

save_session_summary

Save a summary of what was accomplished in this session

list_tags

View all tags in use across your memories

link_memories

Connect related memories with named relationships

get_memory_links

Explore the knowledge graph around a memory

get_memory_versions

View edit history of a memory

get_analytics

Memory health dashboard with self-tuning insights (filterable by project)

promote_memory

Promote a project memory to global scope

consolidate_memories

Merge related memories into comprehensive summaries using Ai

save_task

Create a persistent task with status and priority tracking

get_tasks

Retrieve tasks for the current project — pick up where you left off

update_task

Change task status, priority, or description as you work

save_correction

Store a "wrong approach → right approach" pattern to avoid repeated mistakes

set_reminder

Set a reminder that surfaces at the start of your next session

get_stale_memories

Find memories that may be outdated for review or cleanup

get_file_changes

See what files changed since your last session

feedback_memory

Signal whether a recalled memory was useful or irrelevant to improve future recall

generate_skills

Trigger skill generation from your corrections and preferences — or preview candidates with dry run

save_rule

Save a mandatory rule that surfaces in every session — bypasses all scoring and decay

list_rules

List all mandatory rules for the current project and/or globally

delete_rule

Delete a mandatory rule by ID

extract_principles

Trigger Wisdom Engine to detect factual patterns across memory clusters

SDKs

Build your own integrations with the CogmemAi API:

  • JavaScript/TypeScript: npm install cogmemai-sdk — npm · GitHub

  • Python: pip install cogmemai — PyPI · GitHub

Memory Types

Memories are categorized for better organization and retrieval:

  • identity — Who you are, your role, team

  • preference — Coding style, tool choices, conventions

  • architecture — System design, tech stack, file structure

  • decision — Why you chose X over Y

  • bug — Known issues, fixes, workarounds

  • dependency — Version constraints, package notes

  • pattern — Reusable patterns, conventions

  • context — General project context

  • task — Persistent tasks with status and priority tracking

  • correction — Wrong approach → right approach patterns

  • reminder — Next-session nudges that auto-expire

  • rule — Mandatory directives that surface in every session, bypassing all scoring and decay

Scoping

  • Project memories — Architecture, decisions, bugs specific to one repo. Auto-detected from your repository.

  • Global memories — Your coding preferences, identity, tool choices. Available in every project.

Pricing

Free

Pro

Team

Enterprise

Price

$0

$14.99/mo

$39.99/mo

$99.99/mo

Memories

500

2,000

10,000

50,000

Extractions/mo

500

2,000

5,000

20,000

Projects

5

20

50

200

Start free. Upgrade when you need more. Or pay per operation with USDC on-chain — no credit card required.

Privacy & Security

  • 🛡️ Quantum-safe encryption at rest. All memories are encrypted with quantum-resistant cryptography — in cloud mode and local mode. Protected against both current threats and future quantum computers.

  • No source code leaves your machine. We store extracted facts (short sentences), never raw code.

  • API keys cryptographically hashed (irreversible) server-side.

  • All traffic over HTTPS.

  • No model training on your data. Ever.

  • Delete everything instantly via dashboard or MCP tool.

  • No cross-user data sharing.

Read our full privacy policy.

Environment Variables

Variable

Required

Description

COGMEMAI_API_KEY

Cloud/Hybrid

Your API key (starts with cm_). Not needed for local mode.

COGMEMAI_MODE

No

Storage mode: cloud (default), local (data stays on your machine), or hybrid

COGMEMAI_LOCAL_DB

No

Path to local database (default: ~/.cogmemai/local.db). Used in local and hybrid modes.

COGMEMAI_API_URL

No

Custom API URL (default: hifriendbot.com)

COGMEMAI_ENCRYPTION_KEY

No

Custom encryption passphrase for local mode. If not set, a key is auto-generated.

COGMEMAI_LOCAL_ENCRYPTION

No

Set to off to disable local encryption (not recommended).

Support

License

MIT — see LICENSE


Built by HiFriendbot — Better Friends, Better Memories, Better Ai. 🛡️ Quantum Safe.

Available Tools

35 tools
bulk_deleteA

Delete multiple memories at once by their IDs. Maximum 100 IDs per call. This is permanent.

Inputs: ids (required).

bulk_updateA

Update multiple memories at once. Each item needs a memory_id and fields to update. Maximum 50 items per call.

Inputs: updates (required).

consolidate_memoriesA

Consolidate related memories into fewer, richer memories. Finds clusters of memories sharing the same subject (3+ memories required), then uses AI to synthesize each cluster into 1-2 comprehensive facts. Originals are archived (not deleted) with full version history. Use dry_run=true to preview without making changes. Great for cleaning up memory clutter after many sessions.

Inputs: subject, memory_type, category, dry_run.

delete_memoryA

Delete a specific memory by its ID. This is permanent.

Inputs: memory_id (required).

delete_ruleA

Delete a mandatory rule by its memory ID. Use list_rules to find the ID first.

Inputs: memory_id (required).

export_memoriesA

Export all memories as JSON. Use this to back up memories or transfer them to another project.

Inputs: no named parameters.

extract_memoriesA

Extract memories from a conversation exchange using AI. Send the developer message and assistant response, and the server identifies facts worth remembering (architecture decisions, preferences, bug fixes, etc.).

Inputs: user_message (required), assistant_response, previous_context.

extract_principlesB

Analyze memory clusters and extract underlying factual principles or patterns. Principles are observations about your project — "this codebase tends to have X" — not behavioral instructions (those are skills). Use dry_run to preview candidates first.

Inputs: subject, project_id, dry_run.

feedback_memoryA

Signal whether a recalled memory was useful or irrelevant. Helps improve future recall quality over time. Use after recalling memories to indicate which were helpful vs noise.

Inputs: memory_id (required), signal (required).

generate_skillsA

Manually trigger skill generation from your corrections, preferences, and patterns. Skills are behavioral directives that auto-improve how the AI works with you. CogmemAi also generates skills automatically when enough evidence accumulates — this tool lets you trigger it manually or preview candidates.

Inputs: subject, project_id, dry_run.

get_analyticsA

Get a memory health dashboard with insights: most recalled memories, never-recalled memories, stale memories, growth trends, and breakdowns by type and category. Use this to identify cleanup opportunities and understand memory usage patterns.

Inputs: project_id.

get_file_changesA

Show what files changed since your last session. Compares the current git state to a snapshot saved when your previous session ended. Helps you understand what happened between sessions.

Inputs: no named parameters.

get_memory_versionsA

View the edit history of a memory. Shows all previous versions with timestamps and what changed. Useful for understanding how a decision or fact evolved over time.

Inputs: memory_id (required).

get_project_contextA

Load top memories for the current project plus relevant global memories. Use at the start of a session to get full context from previous sessions. Optionally pass context to get memories most relevant to your current task.

Inputs: project_id, include_global, context, context_type, +3 more.

get_stale_memoriesA

Find memories that may be outdated based on age and access patterns. Returns memories that haven't been recalled or updated recently, so you can review, update, or delete them.

Inputs: days_threshold, limit.

get_tasksA

Get tasks for the current project. Returns tasks filtered by status — defaults to showing pending and in_progress tasks. Use at session start to pick up where you left off.

Inputs: status, include_done.

get_usageA

Get current usage statistics — memory count, extractions this month, tier info, projects.

Inputs: no named parameters.

import_memoriesA

Bulk import memories from a JSON array. Each memory needs at minimum a content field. Deduplication is applied automatically.

Inputs: memories (required).

ingest_documentA

Extract memories from a document by splitting it into chunks and processing each one. Great for onboarding — feed in READMEs, architecture docs, or API specs to quickly build project context.

Inputs: text (required), document_type.

list_memoriesB

List stored memories with optional filters by type, category, scope, or project.

Inputs: memory_type, category, importance_min, scope, +5 more.

list_rulesA

List all mandatory rules for the current project and/or globally. Rules are always-on memories that surface in every session.

Inputs: scope.

list_tagsA

List all tags in use across your memories, with counts. Use this to see what threads/groups exist and find related memories by tag.

Inputs: no named parameters.

preflightA

Think Before You Speak. Call this BEFORE making any suggestion, recommendation, or action plan. Sends the topic to a fast keyword search and returns any relevant prior context — previous attempts, decisions, contacts, evaluations. This prevents suggesting things that were already tried, rejected, or completed. Fast and cheap — use liberally.

Inputs: message (required), project_id.

promote_memoryA

Promote a project-scoped memory to global scope so it applies across all projects. Use this when you discover a preference or pattern that should be universal — e.g., "user prefers tabs over spaces" or "always use Bun instead of npm".

Inputs: memory_id (required).

recall_memoriesA

Search stored memories using semantic search. Returns memories ranked by relevance, importance, and recency. Use this to find relevant context from past sessions.

Inputs: query (required), scope, limit, memory_type, +6 more.

save_correctionA

Save a correction pattern — what went wrong and what the right approach is. These are surfaced automatically when similar situations arise in future sessions, helping avoid repeated mistakes.

Inputs: wrong_approach (required), right_approach (required), context, scope, +1 more.

save_memoryB

Store a developer memory (fact, preference, decision, architecture detail). Memories persist across all Claude Code sessions and are available in future conversations.

Inputs: content (required), memory_type, category, subject, +6 more.

save_ruleA

Save a mandatory rule that will ALWAYS be followed in every session. Rules bypass scoring and decay — they are injected into every conversation, every time. Use for absolute requirements like "NEVER do X" or "ALWAYS do Y".

Inputs: content (required), subject, scope, category, +2 more.

save_session_summaryB

Save a summary of the current coding session. Captures what was accomplished, decisions made, and next steps. Stored as a session_summary memory for future reference.

Inputs: summary (required).

save_taskB

Create a task that persists across sessions. Tasks are tracked with status (pending, in_progress, done, blocked) and priority (high, medium, low). Use this to maintain continuity on multi-session work.

Inputs: title (required), description, priority, status, +1 more.

set_reminderA

Set a reminder that surfaces automatically at the start of your next session. Use for follow-ups, things to check, or deferred work. Reminders auto-archive after being shown.

Inputs: content (required), ttl.

update_memoryC

Update an existing memory's content, importance, or scope.

Inputs: memory_id (required), content, importance, scope, +4 more.

update_taskA

Update a task's status, title, description, or priority. Use this to mark tasks as in_progress, done, or blocked as you work.

Inputs: task_id (required), status, title, description, +1 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 35 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose, with descriptions that precisely define scope (e.g., bulk_delete vs delete_memory, extract_memories vs extract_principles). No overlapping or ambiguous tools exist.

    Naming Consistency5/5

    All tools follow a consistent verb_noun pattern using snake_case (e.g., save_memory, get_analytics, list_rules). No mixing of conventions or irregular naming.

    Tool Count5/5

    35 tools is appropriate for a comprehensive memory management system covering memories, rules, skills, tasks, reminders, analytics, and import/export. Each tool addresses a specific operation without redundancy.

    Completeness3/5

    Core CRUD for memories is complete, but several operations are missing: no delete_task, no update_rule or delete_rule, no unlink_memories, no list/delete for reminders or skills. These gaps could cause agent failures in managing the full lifecycle.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      Gives AI coding agents persistent, cross-session memory by storing task insights as interlinked markdown knowledge cards and recalling relevant ones before new work begins. Uses plain files and git sync instead of a vector database or embeddings, and exposes this through MCP tools for Claude Code, Cursor, VS Code Copilot, Codex, Windsurf, and other clients.
      9 npm
      ISC