Test Memory

Memory MCP Live Testing Skill

Run /test-memory to start a guided testing session. Walk through each phase, execute tests, and track results.

Prerequisites

Install memory-mcp from the marketplace:

# Add the marketplace
/plugin marketplace add michael-denyer/memory-mcp

# Install the plugin
/plugin install memory-mcp@michael-denyer/memory-mcp

Or install directly:

/plugin install github:michael-denyer/memory-mcp

Phases

Phase 1: Core Memory Operations

1.1 Remember - Store test memories:

remember("Test: FastAPI with async endpoints", memory_type="project", tags=["test", "tech-stack"])
remember("Test: Always use uv run pytest -v", memory_type="pattern", tags=["test", "commands"])
remember("Test: API rate limit 100 req/min", memory_type="reference", tags=["test", "api"])

Record the returned IDs for later tests.

1.2 Recall - Semantic search (use different phrasings):

• "what framework for backend" → should find FastAPI
• "how to run tests" → should find pytest
• "request throttling" → should find rate limit

Verify confidence levels returned.

1.3 Recall Modes - Compare precision vs exploratory:

• recall("testing", mode="precision") → fewer, higher-confidence
• recall("testing", mode="exploratory") → more results

1.4 Recall by Tag:

• recall_by_tag("test") → should return all test memories

1.5 Forget - Delete one test memory and verify it's gone.

Phase 2: Hot Cache Mechanics

2.1 Manual Promotion:

• promote(memory_id) one of the test memories
• hot_cache_status() → verify it appears

2.2 Manual Demotion:

• demote(memory_id)
• Verify removed from hot cache but still recallable

2.3 Pin/Unpin:

• pin(memory_id) → pinned_count increases
• unpin(memory_id) → pinned_count decreases

2.4 Auto-Promotion (optional - requires multiple recalls):

• Create a memory and recall it 3+ times
• Check if auto-promoted

Phase 3: Knowledge Graph

3.1 Create Linked Memories:

remember("Test: Database uses PostgreSQL") → ID: A
remember("Test: pgvector for embeddings") → ID: B
remember("Test: Vector search needs pgvector") → ID: C
link_memories(A, B, "relates_to")
link_memories(B, C, "depends_on")

3.2 Traverse Graph:

• get_related_memories(B) → should show A and C
• get_related_memories(A, direction="outgoing") → should show B

3.3 Multi-Hop Recall:

• recall("PostgreSQL", expand_relations=true) → should include related memories

3.4 Unlink:

• unlink_memories(A, B)
• Verify relationship removed

Phase 4: Trust Management

4.1 Validate:

• validate_memory(id, reason="used_correctly")
• Check trust_score increased

4.2 Invalidate:

• invalidate_memory(id, reason="outdated", note="Testing invalidation")
• Check trust_score decreased

4.3 Trust History:

• get_trust_history(memory_id) → shows all changes

Phase 5: Contradiction Detection

5.1 Create Conflicting Memories:

remember("Test: Timeout is 30 seconds") → ID: X
remember("Test: Timeout is 60 seconds") → ID: Y

5.2 Find & Mark:

• find_contradictions(X) → should suggest Y
• mark_contradiction(X, Y)
• get_contradictions() → pair listed

5.3 Resolve:

• resolve_contradiction(X, Y, keep_id=X, resolution="supersedes")
• Verify X supersedes Y, Y's trust reduced

Phase 6: Sessions & Episodic Memory

6.1 Check Sessions:

• get_sessions(limit=5)

6.2 Episodic Memories:

remember("Test: Debugging auth today", memory_type="episodic")
remember("Test: Found token bug", memory_type="episodic")

6.3 Session Topic:

• set_session_topic(session_id, "Testing session")

6.4 Summarize Session:

• summarize_session(session_id) → structured summary with:
  • Decisions (choices made and rationale)
  • Insights (lessons, antipatterns, landmines, constraints)
  • Action Items (todos, bugs, tasks)
  • Context (background, conventions, preferences, architecture)
• Use before end_session() to review what will be promoted

6.5 End Session (optional - ends current session):

• end_session(session_id, promote_top=true)

Phase 7: Pattern Mining

7.1 Log Output:

log_output("import pandas as pd")
log_output("import numpy as np")
log_output("uv run pytest -v")

7.2 Run Mining:

• run_mining(hours=1)
• mining_status()

7.3 Review Candidates:

• review_candidates()

7.4 Approve/Reject (if candidates exist):

• approve_candidate(id) or reject_candidate(id)

Phase 8: Seeding & Bootstrap

8.1 Seed from Text:

seed_from_text("- Item one\n- Item two\n- Item three", memory_type="project")

Verify 3 memories created.

8.2 Seed from File (creates temp file):

• seed_from_file(file_path, memory_type="reference")

8.3 Bootstrap Project:

• bootstrap_project(root_path=".", promote_to_hot=false)
• Verify it finds CLAUDE.md, README.md, etc.

Phase 9: Predictive Cache

9.1 Check Status:

• predictive_cache_status() → shows if enabled

9.2 Access Patterns:

• access_patterns(limit=5) → learned patterns

9.3 Predict Next (needs existing access history):

• predict_next(memory_id) → predicted memories

9.4 Warm Cache:

• warm_cache(memory_id) → pre-promote predicted

Phase 10: Retrieval Quality

10.1 Mark Memory Used:

• mark_memory_used(memory_id, feedback="helpful")

10.2 Retrieval Stats:

• retrieval_quality_stats() → global stats
• retrieval_quality_stats(memory_id=X) → per-memory

Phase 11: Maintenance & DB Info

11.1 Stats & Observability:

• memory_stats()
• hot_cache_status()
• metrics_status()

11.2 Database Info:

• db_info() → schema version, size
• embedding_info() → provider, cache info

11.3 Maintenance Operations:

• db_maintenance()
• validate_embeddings()
• run_cleanup() → comprehensive cleanup

11.4 Consolidation:

• preview_consolidation() → dry run
• run_consolidation(dry_run=true) → preview
• run_consolidation(dry_run=false) → actual merge (careful!)

11.5 Audit History:

• audit_history(limit=10)

11.6 Vector Rebuild (use with caution - rebuilds all embeddings):

• db_rebuild_vectors(batch_size=100) → re-embed all memories
• Use when: switching embedding models, fixing dimension mismatches, recovering from corruption

Phase 12: MCP Resources

12.1 Hot Cache Resource: Read memory://hot-cache directly (auto-injected to Claude):

• Session-aware active context (~10 items max)
• Combines: recently recalled, predicted next, top salience
• Verify contents match hot_cache_status() items

12.2 Promoted Memories Resource: Read memory://promoted-memories directly:

• Backing store of promoted memories (~20 items, disabled by default)
• Verify larger/broader than hot-cache

12.3 Project Context Resource: Read memory://project-context directly:

• Project-scoped memories for current working directory
• Should filter to current project only

Phase 13: Additional Tools

13.1 List Memories:

• list_memories(limit=5) → paginated browse
• list_memories(memory_type="pattern") → filtered
• list_memories(offset=5, limit=5) → pagination

13.2 Recall with Fallback:

• recall_with_fallback("query") → tries patterns → project → all

13.3 Relationship Stats:

• relationship_stats() → knowledge graph overview

13.4 Session Details:

• get_session(session_id) → specific session
• get_session_memories(session_id) → memories from session
• cross_session_patterns() → patterns across sessions

Phase 14: Error Handling & Edge Cases

14.1 Invalid IDs:

• forget(memory_id=999999) → should return error/not found
• promote(memory_id=-1) → should handle gracefully
• get_related_memories(memory_id=0) → should not crash

14.2 Recall Edge Cases:

• recall("", mode="precision") → empty query handling
• recall("xyz", threshold=0.99) → very high threshold, likely no results
• recall("test", limit=0) → zero limit edge case
• recall("test", limit=1000) → large limit handling

14.3 Pagination Boundaries:

• list_memories(offset=99999, limit=10) → beyond data range
• list_memories(offset=-1) → negative offset
• audit_history(limit=0) → zero limit

14.4 Link/Unlink Errors:

• link_memories(id, id, "relates_to") → self-link
• link_memories(999, 888, "relates_to") → non-existent IDs
• unlink_memories(id_a, id_b) → when no link exists

14.5 Trust Boundaries:

• validate_memory(id, boost=10.0) → extreme boost (should cap at 1.0)
• invalidate_memory(id, penalty=10.0) → extreme penalty (should floor at 0.0)

14.6 Session Errors:

• get_session("nonexistent-session-id") → invalid session
• end_session("bad-id") → non-existent session

14.7 Mining Edge Cases:

• run_mining(hours=0) → zero hours
• approve_candidate(pattern_id=999) → non-existent candidate

Phase 15: Cleanup

After testing, clean up test data:

• forget() all memories tagged with "test"
• Or use recall_by_tag("test") to find them first

Phase 16: Compact Conversation

16.1 Run Compact: After completing all tests, prompt the user to run /compact to:

• Reduce conversation context size
• Test that the session can be resumed after compaction
• Verify memories persist across conversation summarization

Note: /compact is a user-initiated command and cannot be run programmatically by the assistant.

Test Tracking

Track results as you go:

Quick Smoke Test

For a 2-minute sanity check:

1. remember("Smoke test", tags=["smoke"])
2. recall("smoke")
3. promote(id) → hot_cache_status()
4. demote(id) → forget(id)
5. memory_stats()

Execution Mode

When running this skill:

1. Ask user which phase to start with (or start from Phase 1)
2. Execute each test, showing tool calls and results
3. Update the tracking table after each test
4. Pause between phases to let user review
5. Note any failures or unexpected behavior
6. Offer to skip phases or run specific tests