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