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)

Getting Recent Memories for a Project

To see what's been recorded recently for a specific project:

execute_forgetful_tool("get_recent_memories", {
  "limit": 10,
  "project_ids": [PROJECT_ID]
})

This is useful when:

• •Starting a session on a project you haven't worked on recently
• •Reviewing what was captured in previous conversations
• •Getting a quick overview of project 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:

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

Constraints

Importance Scoring

Project Discovery

Before creating memories, find the correct project:

1. •

   Get current repo - Check the git remote:

   bash

   git remote get-url origin
   

   Extract the repo identifier (e.g., ScottRBK/forgetful-plugin)

2. •

   Search by repo - Filter projects directly:

   python

   # MCP tool invocation - not standalone Python
   execute_forgetful_tool("list_projects", {"repo_name": "owner/repo"})
   

3. •

   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:

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

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

Tool Quick Reference

Common tools you can call directly via execute_forgetful_tool(tool_name, args):

Memory Tools

Project Tools

Entity Tools

Document & Code Artifact Tools

Full schemas: See TOOL_REFERENCE.md for complete parameter details and examples.

Memory Curation

When to Update a Memory

Use update_memory when:

• •Information needs correction or clarification
• •Importance level changes (more/less relevant than thought)
• •Content needs refinement
• •Links to projects/artifacts/documents change

Only specified fields are changed (PATCH semantics).

When to Mark Obsolete

Use mark_memory_obsolete when:

• •Memory is outdated or contradicted by newer information
• •Decision has been reversed or superseded
• •Referenced code/feature no longer exists
• •Memory was created in error

Obsolete memories are soft-deleted (preserved for audit, hidden from queries).

Auto-Linking

Forgetful auto-links semantically similar memories (similarity >= 0.7) during creation. Manual linking is for:

• •Explicit relationships auto-linking missed
• •Cross-project connections
• •Non-obvious conceptual links

Check similar_memories in create response to see what was auto-linked.

Signs of Poor Curation

Watch for these indicators:

• •Multiple similar memories on same topic (deduplicate)
• •Memories referencing deleted code (mark obsolete)
• •Contradictory memories (resolve conflict)
• •Low-importance memories (importance < 6) accumulating
• •Orphaned memories with no links (consider linking or removing)

Deep Graph Exploration

For comprehensive context beyond simple queries, explore the knowledge graph in phases.

Exploration Phases

Track visited IDs to prevent cycles. Execute phases sequentially.

Phase 1: Semantic Entry Point

execute_forgetful_tool("query_memory", {
  "query": "<topic>",
  "query_context": "Exploring knowledge graph for comprehensive context",
  "k": 5,
  "include_links": True,
  "max_links_per_primary": 5
})

Collect: primary_memories + linked_memories (1-hop connections).

Phase 2: Expand Memory Details

For key memories, get full details:

execute_forgetful_tool("get_memory", {"memory_id": <id>})

Extract: document_ids, code_artifact_ids, project_ids, additional linked_memory_ids.

Phase 3: Entity Discovery

Find entities in discovered projects:

execute_forgetful_tool("list_entities", {
  "project_ids": [<discovered project ids>]
})

Phase 4: Entity Relationships

For relevant entities, map relationship graph:

execute_forgetful_tool("get_entity_relationships", {
  "entity_id": <id>,
  "direction": "both"
})

Phase 5: Entity-Linked Memories

For each entity, find all linked memories:

execute_forgetful_tool("get_entity_memories", {"entity_id": <id>})

Depth Control

Match depth to task complexity. Start shallow, go deeper if context insufficient.