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

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

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:

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:

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