troykelly/memory-integration

Memory Integration

Overview

Use both memory systems to maintain context across sessions.

Core principle: You have no memory between sessions. Use these tools to remember.

Systems:

• Episodic Memory - Conversation history search
• Knowledge Graph (mcp__memory) - Structured facts and relationships

When to Use Memory

| Moment | Memory Action | |--------|---------------| | Session start | Search for relevant context | | Before starting issue | Search for previous work | | Making decision | Check for past decisions | | Completing work | Store important learnings | | Session end | Store key outcomes |

Episodic Memory

What It Stores

• Full conversation history
• Decisions made
• Problems solved
• Approaches tried
• Lessons learned

Searching Episodic Memory

Use the episodic-memory skill or MCP tools:

Search for:
- Issue number: "issue 123", "#123"
- Feature name: "authentication", "user login"
- Problem type: "TypeScript error", "build failure"
- Project name: repository name

Semantic Search (Single Query)

// Search with natural language
mcp__plugin_episodic-memory_episodic-memory__search({
  query: "user authentication implementation decisions"
})

Precise Search (Multiple Concepts)

// Search for intersection of concepts
mcp__plugin_episodic-memory_episodic-memory__search({
  query: ["authentication", "session", "JWT"]
})

Reading Full Conversations

After finding relevant results:

// Read the full conversation
mcp__plugin_episodic-memory_episodic-memory__read({
  path: "/path/to/conversation.jsonl"
})

What to Search For

| Situation | Search Terms | |-----------|-------------| | Starting issue #123 | "issue 123", "#123" | | Working on auth | "authentication", "login", "session" | | TypeScript problem | "TypeScript", "type error", specific error message | | Similar feature | Feature name, related concepts |

Knowledge Graph (mcp__memory)

What It Stores

• Entities (Projects, Issues, Decisions, Patterns)
• Relationships between entities
• Observations about entities

Creating Entities

Store important facts:

// Create an entity for a project decision
mcp__memory__create_entities({
  entities: [{
    name: "Decision: Use JWT for Auth",
    entityType: "Decision",
    observations: [
      "Decided on 2024-12-01",
      "JWT chosen over sessions for API statelessness",
      "Related to issue #123",
      "Implementation in src/auth/jwt.ts"
    ]
  }]
})

Creating Relationships

Link entities together:

// Create relationships
mcp__memory__create_relations({
  relations: [
    {
      from: "Project: MyApp",
      to: "Decision: Use JWT for Auth",
      relationType: "has_decision"
    },
    {
      from: "Issue #123",
      to: "Decision: Use JWT for Auth",
      relationType: "resulted_in"
    }
  ]
})

Searching the Graph

// Search for relevant nodes
mcp__memory__search_nodes({
  query: "authentication"
})

// Open specific nodes
mcp__memory__open_nodes({
  names: ["Decision: Use JWT for Auth"]
})

// Read entire graph (for small graphs)
mcp__memory__read_graph({})

Memory Protocol

At Session Start

1. Search episodic memory for:

   • Current issue number
   • Project/repository name
   • Active feature being worked on

2. Search knowledge graph for:

   • Project entity
   • Related decisions
   • Known patterns

3. Synthesize context before proceeding

During Work

Store as you go:

| Event | Store In | |-------|----------| | Major decision | Knowledge graph entity | | Problem solved | Add observation to issue entity | | Pattern discovered | Knowledge graph entity | | Lesson learned | Add observation |

At Session End

1. Update knowledge graph with:

   • New decisions made
   • Problems solved
   • Patterns discovered

2. Add observations to existing entities:

   • Progress on issues
   • Learnings
   • Next steps

Entity Types

Suggested entity types for the knowledge graph:

| Type | Use For | Example | |------|---------|---------| | Project | Repository/codebase | "Project: MyApp" | | Issue | GitHub issues | "Issue #123: Auth" | | Decision | Architectural decisions | "Decision: Use JWT" | | Pattern | Code patterns | "Pattern: Repository Layer" | | Problem | Known issues | "Problem: Race Condition in X" | | Person | Collaborators | "Person: Alice (maintainer)" |

Example: Issue Memory Flow

Session 1: Starting Issue

// Search for any previous context
const episodic = await search("issue 456 user profile");
const graph = await search_nodes("user profile");

// If nothing found, create fresh entity
await create_entities({
  entities: [{
    name: "Issue #456: User Profile Page",
    entityType: "Issue",
    observations: [
      "Started: 2024-12-01",
      "Scope: Profile display, edit, avatar upload"
    ]
  }]
});

Session 1: Mid-Work Decision

// Store a decision made
await add_observations({
  observations: [{
    entityName: "Issue #456: User Profile Page",
    contents: [
      "Decision: Using react-image-crop for avatar cropping",
      "Reason: Best mobile support, active maintenance"
    ]
  }]
});

Session 2: Resuming

// Search for context
const results = await search("issue 456");
// Read: "Using react-image-crop for avatar cropping"

// Continue with context maintained

What to Store

Always Store

• Architectural decisions with rationale
• Non-obvious problem solutions
• Important constraints discovered
• Dependencies between components

Don't Store

• Trivial implementation details
• Things obvious from code
• Temporary debugging notes
• Speculation without conclusion

Checklist

At session start:

• [ ] Search episodic memory for issue/project
• [ ] Search knowledge graph for context
• [ ] Note relevant findings

During work:

• [ ] Store major decisions
• [ ] Record problem solutions
• [ ] Note discovered patterns

At session end:

• [ ] Update entities with progress
• [ ] Add new learnings
• [ ] Record next steps

Integration

This skill is called by:

• session-start - Initial context gathering
• issue-driven-development - Step 4

This skill supports:

• Cross-session continuity
• Decision documentation
• Pattern discovery