Agent skill

memory-integration

Use to maintain context across sessions - integrates episodic-memory for conversation recall and mcp__memory knowledge graph for persistent facts

View SKILL.md on GitHub Repository
Stars 5
Forks 0

Install this agent skill to your Project

npx add-skill https://github.com/troykelly/codex-skills/tree/main/skills/memory-integration

SKILL.md

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)

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

Precise Search (Multiple Concepts)

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

Reading Full Conversations

After finding relevant results:

javascript
// 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:

javascript
// 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:

javascript
// 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

javascript
// 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

javascript
// 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

javascript
// 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

javascript
// 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

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

troykelly/codex-skills

hook-development

Use when the user wants to create Codex workflow hooks (pre/post run gates, tool-use validators, stop checks) or needs guidance on hook scripts and hooks.json configuration.

5 0
Explore
troykelly/codex-skills

sentry-setup-ai-monitoring

Setup Sentry AI Agent Monitoring in any project. Use this when asked to add AI monitoring, track LLM calls, monitor AI agents, or instrument OpenAI/Anthropic/Vercel AI/LangChain/Google GenAI. Automatically detects installed AI SDKs and configures the appropriate Sentry integration.

5 0
Explore
troykelly/codex-skills

agent-development

Use when the user wants to design Codex agent equivalents (specialized workers/profiles/prompt files), define triggering conditions, or build reusable agent prompts and validation tools.

5 0
Explore
troykelly/codex-skills

skill-development

Use when the user wants to create or refine Codex skills, improve skill descriptions, organize skill resources, or follow Codex skill best practices.

5 0
Explore
troykelly/codex-skills

sentry-setup-logging

Setup Sentry Logging in any project. Use this when asked to add Sentry logs, enable structured logging, setup console log capture, or integrate logging with Sentry. Supports JavaScript, TypeScript, Python, Ruby, React, Next.js, and other frameworks.

5 0
Explore
troykelly/codex-skills

frontend-design

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

5 0
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results