name	using-forgetful-memory
description	Guidance for using Forgetful semantic memory effectively. Applies Zettelkasten atomic memory principles. Use when deciding whether to query or create memories, structuring memory content, or understanding memory importance scoring.
allowed-tools	mcp__forgetful__discover_forgetful_tools, mcp__forgetful__how_to_use_forgetful_tool, mcp__forgetful__execute_forgetful_tool

Using Forgetful Memory

Forgetful is a semantic memory system using Zettelkasten (atomic note) principles. This skill guides effective memory usage.

When to Query Memory

Query memory proactively when:

Starting work on a project (check for existing context)
User references past work, decisions, or discussions
Encountering a problem that may have been solved before
Implementing patterns that may already be documented
Needing context about preferences or approaches

Use execute_forgetful_tool("query_memory", {...}) with:

query: Natural language search terms
query_context: Why you're searching (improves ranking)
include_links: true (to see connected knowledge)

When to Create Memory

Create memories for knowledge worth preserving:

Important decisions with rationale (importance 8-9)
Technical patterns or approaches (importance 7-8)
Architectural choices (importance 9-10)
Preferences and workflows (importance 8-9)
Project milestones (importance 6-7)
Solutions to non-trivial problems (importance 7-8)

Do NOT create memories for:

Temporary context (current file paths, transient issues)
Common knowledge available elsewhere
Trivial or throwaway information
Content that changes frequently

Atomic Memory Principles

Each memory must pass the atomicity test:

Can you understand it at first glance?
Can you title it in 5-50 words?
Does it represent ONE concept/fact/decision?

Constraints

Field	Limit	Guidance
Title	200 chars	Short, searchable phrase
Content	2000 chars	Single concept (~300-400 words)
Context	500 chars	WHY this matters
Keywords	10 max	For semantic clustering
Tags	10 max	For categorization

Importance Scoring

Score	Use For
9-10	Personal facts, foundational patterns
8-9	Critical solutions, major decisions
7-8	Useful patterns, preferences
6-7	Milestones, specific solutions
5-6	Minor context (use sparingly)

Project Discovery

Before creating memories, find the correct project:

Get current repo - Check the git remote:
```
git remote get-url origin
```
Extract the repo identifier (e.g., ScottRBK/forgetful-plugin)

Search by repo - Filter projects directly:

execute_forgetful_tool("list_projects", {"repo_name": "owner/repo"})

Use the project_id - Never assume project 1 - always discover first

If no project exists for the current repo:

Ask user if they want to create one (with repo_name set)
Or scope the memory without a project_id (global memory)

Query Before Create

Always check for existing memories before creating:

execute_forgetful_tool("query_memory", {
  "query": "<topic of potential new memory>",
  "query_context": "Checking for existing memories before creating",
  "k": 5
})

If similar memory exists:

Update it instead of creating duplicate
Or mark it obsolete if superseded
Or link new memory to existing one

Announcing Memory Operations

When creating a memory (importance >= 7), announce:

💾 Saved to memory: "[title]"
   Tags: [tags]
   Related: [auto-linked memory titles]

When querying, summarize:

Found X memories about [topic]:
- [Memory 1]: [brief insight]
- [Memory 2]: [brief insight]

Content That's Too Long

If content exceeds 2000 chars:

Use create_document for full content
Extract 3-5 atomic memories as entry points
Link memories to document via document_ids

Example: Architecture overview (document) → separate memories for each layer/decision.

using-forgetful-memory

Install Skill

SKILL.md