Get comprehensive onboarding protocol for Memento including tool usage guidance, retrieval flow optimization, and best practices.

MEMENTO ONBOARDING PROTOCOL:

1. INITIALIZATION: Run memento_onboarding() at session start

2. RETRIEVAL FLOW:

   • Fact Check: Use search_mementos(tags=[...]) for simple identity/known facts

   • Complex Tasks: Use recall_mementos(query="...") for dev/architecture context

   • Fallback: If search fails, fallback to recall

3. AUTOMATIC STORAGE: Store via store_memento on git commits, bug fixes, version releases

4. ON-DEMAND TRIGGERS: Store instantly when user says "memento...", "remember...", etc.

5. MEMORY SCHEMA: Required tags (project, tech, category). Importance: 0.8+ (critical), 0.5 (standard)

OPTIMIZED RETRIEVAL (Avoid 6+ tool calls):

• Target: 1-3 tool calls for simple info

• Maximum: 5 tool calls for complex tasks

• Follow decision tree: Known tags → search_mementos, Conceptual → recall_mementos

CRITICAL DISTINCTION: Memento vs Session memory

• Memento: Long-term, cross-session, global scope

• Session Memory: Temporary, project-specific, session-only

USE memento_onboarding(topic="...") for specific guidance:

• "protocol": Full onboarding protocol

• "retrieval_flow": Optimized retrieval guide

• "distinction": Memento vs Session memory

• "examples": Practical examples

• "best_practices": Usage guidelines

Primary tool for finding mementos using natural language queries.

Optimized for fuzzy matching - handles plurals, tenses, and case variations automatically.

BEST FOR:

• Conceptual queries ("how does X work")

• General exploration ("what do we know about authentication")

• Fuzzy/approximate matching

USE FOR: Long-term knowledge that survives across sessions. DO NOT USE FOR: Temporary session context or project-specific state.

LESS EFFECTIVE FOR:

• Acronyms (DCAD, JWT, API) - use search_mementos with tags instead

• Proper nouns (company names, services)

• Exact technical terms

EXAMPLES:

• recall_mementos(query="timeout fix") - find timeout-related solutions

• recall_mementos(query="how does auth work") - conceptual query

• recall_mementos(project_path="/app") - memories from specific project

FALLBACK: If recall returns no relevant results, try search_mementos with tags filter.

Store a new memento with context and metadata.

Required: type, title, content. Optional: id, tags, importance (0-1), context.

USE FOR: Long-term knowledge that should survive across ALL sessions. DO NOT USE FOR: Temporary session state or project-specific context.

LIMITS:

• title: max 500 characters

• content: max 50KB (50,000 characters)

• tags: max 50 tags, 100 chars each

• id: if provided, must be unique string identifier

TAGGING BEST PRACTICE:

• Always include acronyms AS TAGS (e.g., tags=["jwt", "auth"])

• Fuzzy search struggles with acronyms in content

• Tags provide exact match fallback for reliable retrieval

Types: solution, problem, error, fix, task, code_pattern, technology, command, file_context, workflow, project, general, conversation

Note: decision is not a standalone type — use type="general" with tags=["decision", "architecture"]. Note: pattern is not a standalone type — use type="code_pattern".

EXAMPLES:

• store_memento(type="solution", title="Fixed Redis timeout", content="Increased timeout to 30s...", tags=["redis"], importance=0.8)

• store_memento(type="error", title="OAuth2 auth failure", content="Error details...", tags=["auth", "oauth2"], id="custom-error-123")

Returns memory_id. Use create_memento_relationship to link related memories.

Retrieve a specific memento by ID.

Use when you have a memory_id from search results or store_memento. Set include_relationships=true (default) to see connected memories.

EXAMPLE: get_memento(memory_id="abc-123")

Update an existing memento

Delete a memento and all its relationships

Advanced search with fine-grained filters for precise retrieval of mementos.

USE THIS TOOL FIRST (not recall) when searching for:

• Acronyms: DCAD, JWT, MCR2, API, etc.

• Proper nouns: Company names, service names, project names

• Known tags: When you know the tag from previous memories

• Technical terms: Exact matches needed

PARAMETERS:

• tags: Filter by exact tag match (most reliable for acronyms)

• memory_types: Filter by type (solution, problem, etc.)

• min_importance: Filter by importance threshold

• search_tolerance: strict/normal/fuzzy

• match_mode: any/all for multiple terms

NOTE: Tags are automatically normalized to lowercase for case-insensitive matching.

EXAMPLES:

• search_mementos(tags=["jwt", "auth"]) - find JWT-related memories

• search_mementos(tags=["dcad"]) - find DCAD memories by tag

• search_mementos(query="timeout", memory_types=["solution"]) - timeout solutions

• search_mementos(tags=["redis"], min_importance=0.7) - important Redis memories

For conceptual/natural language queries, use recall_mementos instead.

Search only within the context of a given memento (scoped search).

Two-phase process: (1) Find related memories, (2) Search only within that set. Provides semantic scoping without embeddings.

WHEN TO USE:

• Searching within a specific problem context

• Finding solutions in related knowledge

• Scoped discovery

HOW TO USE:

• Specify memory_id (context root)

• Provide query (search term)

• Optional: max_depth (default: 2)

RETURNS:

• Matches found only within related memories

• Context information

• No leakage outside context

Link two mementos with a typed relationship.

Common types: SOLVES (solution→problem), CAUSES (cause→effect), ADDRESSES (fix→error), REQUIRES (dependent→dependency), RELATED_TO (general)

EXAMPLES:

• create_memento_relationship(from_memory_id="sol-1", to_memory_id="prob-1", relationship_type="SOLVES")

• create_memento_relationship(from_memory_id="err-1", to_memory_id="fix-1", relationship_type="CAUSES", context="Config error caused timeout")

Optional: strength (0-1), confidence (0-1), context (description)

Find mementos connected to a specific memory via relationships.

Filter by relationship_types (e.g., ["SOLVES"], ["CAUSES"]) and max_depth (default 1).

EXAMPLES:

• get_related_mementos(memory_id="prob-1", relationship_types=["SOLVES"]) - find solutions

• get_related_mementos(memory_id="err-1", relationship_types=["CAUSES"], max_depth=2) - find root causes

Get statistics about the memento database

Get summary of recent memento activity for session context.

Returns: memory counts by type, recent memories (up to 20), unresolved problems.

EXAMPLES:

• get_recent_memento_activity(days=7) - last week's activity

• get_recent_memento_activity(days=30, project="/app") - last month for specific project

Search memento relationships by their structured context fields (scope, conditions, evidence, components)

Manually adjust confidence of a relationship.

Use for:

• Correcting confidence scores when you know a memory is valid/invalid

• Setting custom confidence based on verification

• Overriding automatic decay for specific cases

Examples:

• adjust_memento_confidence(relationship_id="rel-123", new_confidence=0.9, reason="Verified in production")

• adjust_memento_confidence(relationship_id="rel-456", new_confidence=0.1, reason="Obsolete after library update")

Confidence ranges:

• 0.9-1.0: High confidence (recently validated)

• 0.7-0.89: Good confidence (regularly used)

• 0.5-0.69: Moderate confidence (somewhat outdated)

• 0.3-0.49: Low confidence (likely outdated)

• 0.0-0.29: Very low confidence (probably obsolete)

Find memories with low confidence scores.

Use for:

• Identifying potentially obsolete knowledge

• Periodic cleanup and verification

• Quality assurance of the knowledge base

• Finding memories that need review

Features:

• Filter by confidence threshold (default: < 0.3)

• Shows relationships causing low confidence

• Includes memory details and last access time

• Sorted by confidence (lowest first)

Returns:

• List of low confidence relationships with associated memories

• Memory details for both ends of each relationship

• Confidence scores and last access times

Apply automatic confidence decay based on last access time.

Use for:

• System maintenance to keep knowledge base fresh

• Applying intelligent decay rules

• Monthly confidence adjustment routine

Intelligent decay rules:

• Critical memories (security, auth, api_key, password, critical, no_decay tags): NO DECAY

• High importance memories: Reduced decay based on importance score

• General knowledge: Standard 5% monthly decay (decay_factor=0.95)

• Temporary context: Higher decay rate

Decay formula: monthly_decay = confidence × decay_factor^(months_since_last_access)

Minimum confidence: 0.1 (won't decay below this)

Returns:

• Number of relationships updated

• Summary of decay applied

• Breakdown by memory type

Boost confidence when a memory is successfully used.

Use for:

• Reinforcing valid knowledge

• Manual confidence increase for verified information

• After successfully applying a solution

• When verifying old information is still valid

Usage patterns:

• After successfully applying a solution → boost its confidence

• When verifying old information is still valid → boost confidence

• When multiple team members confirm a pattern → boost confidence

Boost mechanics:

• Base boost: +0.10 per access (capped at 1.0)

• Additional boost for validation: +0.10 to +0.20

• Maximum confidence: 1.0 (cannot exceed)