memory-management

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Memory Management & Knowledge Persistence

内存管理与知识持久化

Build and maintain a knowledge graph of patterns, decisions, and learnings across sessions.

跨会话构建并维护包含模式、决策和经验总结的知识图谱。

Memory Entity Types

实体类型

Entity Type	Purpose	Examples
`Pattern`	Recurring code patterns	CQRS, Validation, Repository
`Decision`	Architectural/design decisions	Why we chose X over Y
`BugFix`	Bug solutions for future reference	Race condition fixes
`ServiceBoundary`	Service ownership and responsibilities	TextSnippet owns Snippets
`SessionSummary`	End-of-session progress snapshots	Task progress, next steps
`Dependency`	Cross-service dependencies	TextSnippet depends on Accounts
`AntiPattern`	Patterns to avoid	Don't call side effects in cmd

实体类型	用途	示例
`Pattern`	重复出现的代码模式	CQRS, Validation, Repository
`Decision`	架构/设计决策	为何选择X而非Y
`BugFix`	供未来参考的Bug解决方案	竞态条件修复
`ServiceBoundary`	服务归属与职责	TextSnippet 拥有 Snippets
`SessionSummary`	会话结束时的进度快照	任务进展、下一步计划
`Dependency`	跨服务依赖关系	TextSnippet 依赖 Accounts服务
`AntiPattern`	需要避免的模式	不要在命令中调用副作用

Memory Operations

内存操作

Create New Entity

创建新实体

javascript

mcp__memory__create_entities([
    {
        name: 'EmployeeValidationPattern',
        entityType: 'Pattern',
        observations: [
            'Use PlatformValidationResult fluent API',
            'Chain with .And() and .AndAsync()',
            "Return validation result, don't throw",
            'Location: Growth.Application/UseCaseCommands/'
        ]
    }
]);

javascript

mcp__memory__create_entities([
    {
        name: 'EmployeeValidationPattern',
        entityType: 'Pattern',
        observations: [
            'Use PlatformValidationResult fluent API',
            'Chain with .And() and .AndAsync()',
            "Return validation result, don't throw",
            'Location: Growth.Application/UseCaseCommands/'
        ]
    }
]);

Create Relationships

创建关系

javascript

mcp__memory__create_relations([
    {
        from: 'TextSnippetService',
        to: 'AccountsService',
        relationType: 'depends_on'
    },
    {
        from: 'EmployeeEntity',
        to: 'UserEntity',
        relationType: 'syncs_from'
    }
]);

javascript

mcp__memory__create_relations([
    {
        from: 'TextSnippetService',
        to: 'AccountsService',
        relationType: 'depends_on'
    },
    {
        from: 'EmployeeEntity',
        to: 'UserEntity',
        relationType: 'syncs_from'
    }
]);

Add Observations

添加观测记录

javascript

mcp__memory__add_observations([
    {
        entityName: 'EmployeeValidationPattern',
        contents: ['Also supports .AndNot() for negative validation', 'Use .Of<IPlatformCqrsRequest>() for type conversion']
    }
]);

javascript

mcp__memory__add_observations([
    {
        entityName: 'EmployeeValidationPattern',
        contents: ['Also supports .AndNot() for negative validation', 'Use .Of<IPlatformCqrsRequest>() for type conversion']
    }
]);

Search Knowledge

搜索知识

javascript

// Search by query
mcp__memory__search_nodes({ query: 'validation pattern' });

// Open specific entities
mcp__memory__open_nodes({ names: ['EmployeeValidationPattern', 'TextSnippetService'] });

// Read entire graph
mcp__memory__read_graph();

javascript

// 按查询词搜索
mcp__memory__search_nodes({ query: 'validation pattern' });

// 打开特定实体
mcp__memory__open_nodes({ names: ['EmployeeValidationPattern', 'TextSnippetService'] });

// 读取整个图谱
mcp__memory__read_graph();

Delete Outdated Knowledge

删除过时知识

javascript

// Delete entities
mcp__memory__delete_entities({ entityNames: ['OutdatedPattern'] });

// Delete specific observations
mcp__memory__delete_observations([
    {
        entityName: 'EmployeeValidationPattern',
        observations: ['Outdated observation text']
    }
]);

// Delete relations
mcp__memory__delete_relations([
    {
        from: 'OldService',
        to: 'NewService',
        relationType: 'depends_on'
    }
]);

javascript

// 删除实体
mcp__memory__delete_entities({ entityNames: ['OutdatedPattern'] });

// 删除特定观测记录
mcp__memory__delete_observations([
    {
        entityName: 'EmployeeValidationPattern',
        observations: ['Outdated observation text']
    }
]);

// 删除关系
mcp__memory__delete_relations([
    {
        from: 'OldService',
        to: 'NewService',
        relationType: 'depends_on'
    }
]);

When to Save to Memory

何时保存到内存

Always Save

始终保存

Discovered Patterns: New code patterns not in documentation
Bug Solutions: Complex bugs with non-obvious solutions
Service Boundaries: Which service owns what
Architectural Decisions: Why a particular approach was chosen
Anti-Patterns: Mistakes to avoid

已发现的模式：文档中未提及的新代码模式
Bug解决方案：具有非直观解决方案的复杂Bug
服务边界：哪个服务负责什么内容
架构决策：为何选择特定实现方案
反模式：需要避免的错误做法

Save at Session End

会话结束时保存

javascript

// Session summary template
mcp__memory__create_entities([
    {
        name: `Session_${taskName}_${date}`,
        entityType: 'SessionSummary',
        observations: [
            `Task: ${taskDescription}`,
            `Completed: ${completedItems.join(', ')}`,
            `Remaining: ${remainingItems.join(', ')}`,
            `Key Files: ${keyFiles.join(', ')}`,
            `Discoveries: ${discoveries.join(', ')}`,
            `Next Steps: ${nextSteps.join(', ')}`
        ]
    }
]);

javascript

// 会话总结模板
mcp__memory__create_entities([
    {
        name: `Session_${taskName}_${date}`,
        entityType: 'SessionSummary',
        observations: [
            `Task: ${taskDescription}`,
            `Completed: ${completedItems.join(', ')}`,
            `Remaining: ${remainingItems.join(', ')}`,
            `Key Files: ${keyFiles.join(', ')}`,
            `Discoveries: ${discoveries.join(', ')}`,
            `Next Steps: ${nextSteps.join(', ')}`
        ]
    }
]);

Memory Retrieval Patterns

内存检索模式

Session Start Protocol

会话启动流程

javascript

// 1. Search for related context
const results = mcp__memory__search_nodes({
    query: 'current feature or task keywords'
});

// 2. Load relevant entities
mcp__memory__open_nodes({
    names: results.entities.map(e => e.name)
});

// 3. Check for incomplete sessions
mcp__memory__search_nodes({ query: 'SessionSummary Remaining' });

javascript

// 1. 搜索相关上下文
const results = mcp__memory__search_nodes({
    query: 'current feature or task keywords'
});

// 2. 加载相关实体
mcp__memory__open_nodes({
    names: results.entities.map(e => e.name)
});

// 3. 检查未完成的会话
mcp__memory__search_nodes({ query: 'SessionSummary Remaining' });

Before Implementation

实现前

javascript

// Check for existing patterns
mcp__memory__search_nodes({ query: 'CQRS command pattern' });

// Check for anti-patterns
mcp__memory__search_nodes({ query: 'AntiPattern command' });

// Check for related decisions
mcp__memory__search_nodes({ query: 'Decision validation' });

javascript

// 检查现有模式
mcp__memory__search_nodes({ query: 'CQRS command pattern' });

// 检查反模式
mcp__memory__search_nodes({ query: 'AntiPattern command' });

// 检查相关决策
mcp__memory__search_nodes({ query: 'Decision validation' });

After Bug Fix

Bug修复后

javascript

// Save the fix
mcp__memory__create_entities([
    {
        name: `BugFix_${bugName}`,
        entityType: 'BugFix',
        observations: [
            `Symptom: ${symptomDescription}`,
            `Root Cause: ${rootCause}`,
            `Solution: ${solution}`,
            `Files: ${affectedFiles.join(', ')}`,
            `Prevention: ${preventionTip}`
        ]
    }
]);

javascript

// 保存修复方案
mcp__memory__create_entities([
    {
        name: `BugFix_${bugName}`,
        entityType: 'BugFix',
        observations: [
            `Symptom: ${symptomDescription}`,
            `Root Cause: ${rootCause}`,
            `Solution: ${solution}`,
            `Files: ${affectedFiles.join(', ')}`,
            `Prevention: ${preventionTip}`
        ]
    }
]);

Knowledge Graph Structure

知识图谱结构

┌─────────────────────────────────────────────────────────────┐
│                     EasyPlatform Knowledge                    │
├─────────────────────────────────────────────────────────────┤
│  Services                                                   │
│  ├── TextSnippetService ──depends_on──> AccountsService          │
│  ├── TalentsService ──depends_on──> AccountsService         │
│  └── SurveysService ──depends_on──> AccountsService         │
│                                                             │
│  Patterns                                                   │
│  ├── CQRSCommandPattern                                     │
│  ├── CQRSQueryPattern                                       │
│  ├── EntityEventPattern                                     │
│  └── ValidationPattern                                      │
│                                                             │
│  Entities                                                   │
│  ├── Employee ──syncs_from──> User                          │
│  ├── Company ──syncs_from──> Organization                   │
│  └── LeaveRequest ──owned_by──> TextSnippetService               │
│                                                             │
│  Sessions                                                   │
│  ├── Session_LeaveRequest_2025-01-15                        │
│  └── Session_EmployeeImport_2025-01-14                      │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                     EasyPlatform 知识图谱                    │
├─────────────────────────────────────────────────────────────┤
│  服务                                                       │
│  ├── TextSnippetService ──depends_on──> AccountsService          │
│  ├── TalentsService ──depends_on──> AccountsService         │
│  └── SurveysService ──depends_on──> AccountsService         │
│                                                             │
│  模式                                                       │
│  ├── CQRSCommandPattern                                     │
│  ├── CQRSQueryPattern                                       │
│  ├── EntityEventPattern                                     │
│  └── ValidationPattern                                      │
│                                                             │
│  实体                                                       │
│  ├── Employee ──syncs_from──> User                          │
│  ├── Company ──syncs_from──> Organization                   │
│  └── LeaveRequest ──owned_by──> TextSnippetService               │
│                                                             │
│  会话                                                       │
│  ├── Session_LeaveRequest_2025-01-15                        │
│  └── Session_EmployeeImport_2025-01-14                      │
└─────────────────────────────────────────────────────────────┘

Importance Scoring

重要性评分

When saving observations, prioritize:

Score	Criteria
10	Critical bug fixes, security issues
8-9	Architectural decisions, service boundaries
6-7	Code patterns, best practices
4-5	Session summaries, progress notes
1-3	Temporary notes, exploration results

保存观测记录时，按以下优先级排序：

评分	标准
10	关键Bug修复、安全问题
8-9	架构决策、服务边界
6-7	代码模式、最佳实践
4-5	会话总结、进度笔记
1-3	临时笔记、探索结果

Memory Maintenance

内存维护

Weekly Cleanup

每周清理

javascript

// Find old session summaries (> 30 days)
mcp__memory__search_nodes({ query: 'SessionSummary' });

// Delete outdated sessions
mcp__memory__delete_entities({
    entityNames: ['Session_OldTask_2024-12-01']
});

javascript

// 查找旧的会话总结（超过30天）
mcp__memory__search_nodes({ query: 'SessionSummary' });

// 删除过时的会话
mcp__memory__delete_entities({
    entityNames: ['Session_OldTask_2024-12-01']
});

Consolidation

合并整理

When multiple observations cover same topic:

javascript

// 1. Read existing entity
mcp__memory__open_nodes({ names: ['PatternName'] });

// 2. Delete fragmented observations
mcp__memory__delete_observations([
    {
        entityName: 'PatternName',
        observations: ['Fragment 1', 'Fragment 2']
    }
]);

// 3. Add consolidated observation
mcp__memory__add_observations([
    {
        entityName: 'PatternName',
        contents: ['Consolidated comprehensive observation']
    }
]);

当多个观测记录涉及同一主题时：

javascript

// 1. 读取现有实体
mcp__memory__open_nodes({ names: ['PatternName'] });

// 2. 删除碎片化的观测记录
mcp__memory__delete_observations([
    {
        entityName: 'PatternName',
        observations: ['Fragment 1', 'Fragment 2']
    }
]);

// 3. 添加合并后的完整观测记录
mcp__memory__add_observations([
    {
        entityName: 'PatternName',
        contents: ['Consolidated comprehensive observation']
    }
]);

Quick Reference

快速参考

Create:

mcp__memory__create_entities

mcp__memory__create_relations

Read:

mcp__memory__read_graph

mcp__memory__open_nodes

mcp__memory__search_nodes

Update:

mcp__memory__add_observations

Delete:

mcp__memory__delete_entities

mcp__memory__delete_observations

mcp__memory__delete_relations

创建：

mcp__memory__create_entities

mcp__memory__create_relations

读取：

mcp__memory__read_graph

mcp__memory__open_nodes

mcp__memory__search_nodes

更新：

mcp__memory__add_observations

删除：

mcp__memory__delete_entities

mcp__memory__delete_observations

mcp__memory__delete_relations