Memory Integration Skill

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

Search episodic memory for:
- Current issue number
- Project/repository name
- Active feature being worked on
Search knowledge graph for:
- Project entity
- Related decisions
- Known patterns
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

Update knowledge graph with:
- New decisions made
- Problems solved
- Patterns discovered
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

Agent Skills: Memory Integration

Skill Files