跳转至

LingFlow 记忆系统理论设计文档

版本：v1.0
日期：2026-04-08
作者：AI Assistant
状态：待审阅研究

目录

  1. 摘要
  2. 背景
  3. 核心理论：艾宾浩斯记忆曲线
  4. 理论维度一至六：五因素模型
  5. 理论维度七：元记忆
  6. 理论维度八：集体行为
  7. 理论维度九：自我进化
  8. 理论维度十：常识记忆
  9. 理论维度十一：记忆启发式
  10. 理论维度十二：遗忘机制
  11. 理论维度十三：记忆重构
  12. 总结与实施建议
  13. 附录：关键数据结构

摘要

本文档基于艾宾浩斯记忆曲线及现代认知科学研究，为 LingFlow 智能开发工作流引擎设计了完整的记忆系统理论框架。该系统包含13个理论维度，旨在解决AI上下文管理的核心问题：如何让AI系统"记住"重要信息、遗忘不重要信息、并在适当的时机主动回忆。

核心创新： - 将艾宾浩斯遗忘曲线工程化为AI记忆衰减机制 - 引入五因素模型（时间、意义、联想、情绪、呈现、连贯） - 设计常识记忆机制，处理高频、跨任务的基础知识 - 集成认知科学启发式（首因效应、间隔效应、测试效应等） - 实现主动遗忘和记忆重构，优化记忆生态系统

预期成果： - 提升AI系统的长期记忆保持率 - 优化上下文检索效率和准确性 - 实现自适应的记忆管理策略 - 为用户提供透明的记忆控制机制

背景

当前 LingFlow 上下文系统的局限性

  1. 永久存储问题：一旦存储，永不遗忘
  2. 无优先级：所有信息平等对待
  3. 被动检索：等待被查询才返回
  4. 无复习机制：压缩后不再回顾
  5. 压缩黑箱：用户不知道丢失了什么
  6. 无常识识别：不区分高频使用的常识知识

艾宾浩斯记忆曲线的启示

德国心理学家 Hermann Ebbinghaus (1885) 发现的遗忘规律： - 指数级下降：遗忘最快发生在学习后最初几小时 - 关键数据：1天内遗忘~50%，1周内遗忘~90% - 最佳复习时间点：20分钟 → 1小时 → 9小时 → 1天 → 2天 → 6天 → 31天 - 24小时跳跃：睡眠巩固导致记忆保存率提升

核心理论：艾宾浩斯记忆曲线

遗忘曲线数学模型

Ebbinghaus 原始公式（1885）

Q(t) = 1.84 / ((log t)¹·²⁵ + 1.84)
其中： - Q(t)：保留率（Savings） - t：时间（分钟） - log：以10为底的对数

现代简化公式

retention(t) = initial_strength × e^(-kt)
其中： - k：衰减率（取决于记忆优先级） - initial_strength：初始强度

LingFlow 工程化映射

艾宾浩斯概念 LingFlow 对应 实现方式
遗忘曲线（指数下降） 上下文重要性衰减 memory_strength *= (1 - decay_rate)
间隔重复（7个关键点） 主动记忆召回机制 在 1天/2天/6天/31天 提醒
记忆强度（访问=复习） 访忆重要性评分 strength += access_count * 0.5
24小时跳跃（睡眠巩固） 会话重启时 strength += 1.0
原始学习深度 信息编码质量 基于 token 数、引用次数

理论维度一至六：五因素模型

维度一：时间（Time）

艾宾浩斯原话："遗忘随时间发生，呈指数下降"

实现机制

# 每日衰减
daily_strength_decay = strength * (1 - decay_rate[priority])

# 优先级相关衰减率
decay_rate = {
    P0: 0.00,   # 关键信息不衰减
    P1: 0.02,   # 重要信息每天 -2%
    P2: 0.05,   # 普通信息每天 -5%
    P3: 0.10,   # 临时信息每天 -10%
}

情景示例

  • P0记忆：系统配置、用户偏好 → 不衰减，永久保持
  • P1记忆：项目结构、关键实现 → 每天-2%，50天后强度约36%
  • P2记忆：代码片段、调试记录 → 每天-5%，20天后强度约36%
  • P3记忆：临时输出、实验性代码 → 每天-10%，10天后强度约35%

维度二：意义（Meaning）

艾宾浩斯原话："强度与相关性是记忆持久的决定性因素"

语义重要性分析

def calculate_semantic_importance(memory_content, context):
    """计算记忆的语义重要性"""
    importance = base_priority  # P0-P3

    # 因素1：与核心概念的关联度
    core_concepts = extract_core_concepts(context)
    relevance = semantic_similarity(memory_content, core_concepts)
    importance *= (0.7 + 0.3 * relevance)  # 0.7-1.0 倍

    # 因素2：信息密度（token/概念比）
    concepts = extract_concepts(memory_content)
    density = len(concepts) / memory_content.tokens
    importance *= (0.8 + 0.2 * sigmoid(density - 1.0))

    # 因素3：用户明确标记的重要性
    if memory.user_marked_as_important:
        importance *= 1.5

    # 因素4：重复出现频率
    frequency = count_occurrences(memory_content, recent_contexts)
    importance *= (1.0 + 0.1 * frequency)

    return importance

意义衰减率动态调整

# 意义越强，衰减越慢
semantic_impact_factor = calculate_semantic_importance(content)
effective_decay_rate = base_decay_rate * (2.0 - semantic_impact_factor)

# 例如：
# 高意义记忆：decay_rate = 0.02 * (2.0 - 0.9) = 0.022
# 低意义记忆：decay_rate = 0.10 * (2.0 - 0.3) = 0.17

维度三：联想（Association）

艾宾浩斯原话："信息是更容易回忆当它建立在已知事物之上"

记忆关联网络（知识图谱）

@dataclass
class MemoryAssociation:
    memory_id: str              # 记忆 ID
    related_memory_id: str        # 关联记忆 ID
    association_type: AssociationType  # 关联类型
    strength: float                # 关联强度 0.0-1.0

class AssociationType(Enum):
    CAUSAL = "causal"        # 因果关系（因为A，所以B）
    SEQUENTIAL = "sequential"  # 序列关系（A之后是B）
    HIERARCHICAL = "hierarchical"  # 层级关系（B是A的子类）
    SEMANTIC = "semantic"      # 语义相似（A和B相关）
    REFERENCE = "reference"    # 引用关系（B引用了A）

关联激活传播

def activate_memory(memory_id, context):
    """激活记忆时，传播到相关记忆"""
    memory = get_memory(memory_id)
    memory.strength += access_impact

    # 传播到关联记忆
    associations = get_associations(memory_id)
    for assoc in associations:
        related = get_memory(assoc.related_memory_id)

        # 激活强度 = 关联强度 × 原记忆强度 × 传播系数
        boost = assoc.strength * memory.strength * 0.3
        related.strength = min(4.0, related.strength + boost)

        # 记录传播日志
        log_propagation(memory_id, assoc.related_memory_id, boost)

联想衰减减缓

# 有关联的记忆，衰减减慢
def calculate_association_decay_rate(memory):
    associations = get_associations(memory.id)

    if not associations:
        return base_decay_rate

    # 计算平均关联强度
    avg_assoc_strength = sum(a.strength for a in associations) / len(associations)

    # 关联越强，衰减越慢
    association_factor = 1.0 + 0.5 * avg_assoc_strength
    return base_decay_rate / association_factor

# 例如：
# 无关联：decay_rate = 0.05
# 强关联（0.8）：decay_rate = 0.05 / 1.4 = 0.036

维度四：情绪（Emotion）

艾宾浩斯原话："压力、睡眠等生理因素影响保留"

情绪强度计算

@dataclass
class EmotionalContext:
    user_satisfaction: float      # 用户满意度 0.0-1.0
    error_rate: float            # 错误率 0.0-1.0
    task_importance: float       # 任务紧迫度 0.0-1.0
    interaction_quality: float    # 交互质量 0.0-1.0
    system_confidence: float      # 系统自信度 0.0-1.0

def calculate_emotional_impact(emotional_context):
    """计算情绪强度因子"""
    # 正面因素：
    # - 用户满意度高 → 记忆增强
    # - 系统自信度高 → 记忆增强
    # - 交互质量高 → 记忆增强

    positive_impact = (
        emotional_context.user_satisfaction * 0.4 +
        emotional_context.system_confidence * 0.3 +
        emotional_context.interaction_quality * 0.3
    )

    # 负面因素：
    # - 错误率高 → 记忆减弱
    # - 任务紧迫度高 → 压力状态 → 记忆减弱

    negative_impact = (
        emotional_context.error_rate * 0.6 +
        emotional_context.task_importance * 0.4
    )

    # 情绪强度 = 正面 - 负面
    impact = positive_impact - negative_impact
    return max(-0.5, min(0.5, impact))  # 限制在 [-0.5, 0.5]

情绪衰减调整

def calculate_emotional_decay_rate(memory, emotional_context):
    """基于情绪调整衰减率"""
    emotional_impact = calculate_emotional_impact(emotional_context)

    # 正面情绪（+）→ 衰减缓慢
    # 负面情绪（-）→ 衰减加快

    emotional_factor = 1.0 - emotional_impact  # 0.5-1.5

    return base_decay_rate * emotional_factor

# 例如：
# 正面情绪（+0.3）：decay_rate = 0.05 * 0.7 = 0.035
# 负面情绪（-0.3）：decay_rate = 0.05 * 1.3 = 0.065

情绪记忆固化

def apply_emotional_consolidation(memories, emotional_context):
    """情绪固化：重要情绪事件中的记忆增强"""

    # 高重要性任务中的记忆固化
    if emotional_context.task_importance > 0.8:
        for mem in memories:
            if mem.priority in [P0, P1]:
                mem.strength += 0.5
                mem.consolidated = True

    # 高用户满意度时期的记忆增强
    if emotional_context.user_satisfaction > 0.8:
        for mem in memories:
            if mem.access_count > 0:  # 被访问过的
                mem.strength += 0.3

    # 低错误率时期的记忆增强（流畅状态）
    if emotional_context.error_rate < 0.1:
        for mem in memories:
            mem.strength *= 1.1  # +10%

维度五：呈现方式（Presentation）

艾宾浩斯原话："信息呈现方式影响记忆保留"

格式化指数

def calculate_formatting_index(content):
    """计算格式化程度"""
    index = 0.0

    # 1. 代码块（高度格式化）
    if contains_code_block(content):
        index += 0.5

    # 2. 结构化文本（列表、表格）
    if contains_list(content) or contains_table(content):
        index += 0.3

    # 3. 标题层级（#标题结构）
    if has_heading_hierarchy(content):
        index += 0.2

    return index

呈现方式与其他因素交互

呈现方式 × 意义： 

# 高格式化 → 语义重要性提升
formatting_impact = calculate_formatting_index(content)
semantic_boost = semantic_importance * (1.0 + formatting_impact * 0.3)

呈现方式 × 联想： 

# 结构化信息更易建立关联
if has_clear_structure(content):
    # 关联强度提升
    association_boost = 1.3
else:
    association_boost = 1.0

呈现方式 × 情绪： 

# 高格式化减少情绪负面影响
formatting_index = calculate_formatting_index(content)
emotional_resilience = formatting_index * 0.2

# 情绪影响 = 原始影响 + 格式化抵消
net_emotional_impact = emotional_impact + emotional_resilience

维度六：连贯性（Coherence）

扩展因素：上下文连贯性影响记忆

连贯性指数

def calculate_coherence_index(content, surrounding_context):
    """计算上下文连贯性"""

    # 1. 与上下文的语义连续性
    continuity = semantic_similarity(content, surrounding_context)

    # 2. 逻辑一致性（是否遵循上下文的逻辑）
    consistency = check_logical_consistency(content, surrounding_context)

    # 3. 因果链条完整性
    causal_completeness = check_causal_chain(content, surrounding_context)

    # 加权平均
    index = (
        continuity * 0.5 +
        consistency * 0.3 +
        causal_completeness * 0.2
    )

    return index

连贯性衰减减缓

# 高连贯性 → 减缓时间衰减
time_impact = 1.0 + coherence_index * 0.2

# 高连贯性 → 提升联想
association_impact = 1.0 + coherence_index * 0.3

# 高连贯性 → 减缓情绪负面影响
emotional_resilience = coherence_index * 0.15

五因素综合模型

综合记忆强度计算

def calculate_composite_strength(memory, context, emotional_context):
    """综合计算记忆强度"""

    # 基础强度
    base_strength = memory.strength

    # 因素1：时间衰减（已在每日任务中应用）
    time_factor = apply_time_decay(memory)

    # 因素2：意义影响
    semantic_factor = calculate_semantic_importance(memory.content, context)

    # 因素3：联想影响（激活传播）
    association_factor = calculate_association_boost(memory)

    # 因素4：情绪影响
    emotional_factor = calculate_emotional_impact(emotional_context)

    # 因素5：呈现方式影响
    presentation_factor = calculate_formatting_index(memory.content)

    # 因素6：连贯性影响
    coherence_factor = calculate_coherence_index(memory.content, context)

    # 综合强度 = 基础 × 时间 × (意义 + 联想 + 情绪 + 呈现 + 连贯)
    composite_strength = (
        base_strength *
        time_factor *
        (0.25 * semantic_factor +     # 意义权重 25%
         0.20 * association_factor +   # 联想权重 20%
         0.15 * emotional_factor +     # 情绪权重 15%
         0.15 * presentation_factor +  # 呈现权重 15%
         0.25 * coherence_factor)      # 连贯权重 25%
    )

    return max(0.0, min(4.0, composite_strength))

综合衰减率计算

def calculate_composite_decay_rate(memory, context, emotional_context):
    """综合计算衰减率"""

    # 基础衰减率（基于优先级）
    base_decay = base_decay_rate[memory.priority]

    # 因素2：意义减慢
    semantic_impact = calculate_semantic_importance(memory.content, context)
    semantic_factor = 2.0 - semantic_impact  # 1.0-2.0

    # 因素3：联想减慢
    association_factor = calculate_association_decay_rate(memory)

    # 因素4：情绪调整
    emotional_impact = calculate_emotional_impact(emotional_context)
    emotional_factor = 1.0 - emotional_impact  # 0.5-1.5

    # 因素5：呈现方式增强
    presentation_factor = 1.0 + calculate_formatting_index(memory.content) * 0.3

    # 因素6：连贯性增强
    coherence_factor = 1.0 + calculate_coherence_index(memory.content, context) * 0.2

    # 综合衰减率
    composite_decay = (
        base_decay *
        semantic_factor *
        (base_decay / association_factor) *
        emotional_factor /
        presentation_factor /
        coherence_factor
    )

    return composite_decay

理论维度七：元记忆

概念：关于记忆的记忆

定义：元记忆 = 记忆的可访问性、可靠性、时效性、相关性等元数据

元记忆组成要素

1. 可访问性（Accessibility）

@dataclass
class MemoryAccessibility:
    """记忆可访问性元数据"""

    retrieval_success_rate: float  # 检索成功率 0.0-1.0
    retrieval_latency_ms: float  # 平均检索延迟（毫秒）
    context_relevance: float  # 检索结果与查询上下文的相关性
    confidence: float  # 系统对检索结果的自信度

2. 可靠性（Reliability）

@dataclass
class MemoryReliability:
    """记忆可靠性元数据"""

    source_trust: float  # 来源的可信度（用户 vs. AI）
    verification_status: VerificationStatus  # VERIFIED/UNVERIFIED/CONFLICTED
    conflict_count: int  # 与其他记忆冲突的次数
    update_history: List[MemoryUpdate]  # 而更记录

3. 时效性（Freshness）

@dataclass
class MemoryFreshness:
    """记忆时效性元数据"""

    last_accessed: datetime  # 最后访问时间
    last_updated: datetime  # 最后更新时间
    access_trend: str  # INCREASING/STEADY/DECREASING
    expiry_warning: bool  # 是否接近遗忘阈值

4. 相关性（Relevance）

@dataclass
class MemoryRelevance:
    """记忆相关性元数据"""

    current_task_relevance: float  # 与当前任务的相关性
    topic_relevance: float  # 与当前主题的相关性
    user_intent_relevance: float  # 与用户意图的相关性
    predicted_future_relevance: float  # 预测未来相关性

元记忆应用场景

不确定性检索

def retrieve_with_uncertainty(query, context):
    """带不确定性的检索"""

    # 检索候选记忆
    candidates = semantic_search(query, context)

    # 为每个记忆计算元记忆
    for mem in candidates:
        mem.meta = {
            "accessibility": calculate_accessibility(mem),
            "reliability": calculate_reliability(mem),
            "freshness": calculate_freshness(mem),
            "relevance": calculate_relevance(mem, query)
        }

    # 排序：相关性 × 可访问性 × 可靠性
    candidates.sort(key=lambda m: (
        m.meta["relevance"].current_task_relevance *
        m.meta["accessibility"].retrieval_success_rate *
        m.meta["reliability"].source_trust
    ), reverse=True)

    # 返回前N个，带置信度
    results = []
    for mem in candidates[:N]:
        confidence = (
            mem.meta["accessibility"].retrieval_success_rate *
            mem.meta["reliability"].source_trust
        )
        results.append({
            "memory": mem,
            "confidence": confidence,
            "uncertainty": 1.0 - confidence
        })

    return results

理论维度八：集体行为

概念：记忆群组的动态行为

现象： - 记忆竞争：多个记忆争夺"工作记忆"空间 - 记忆协同：相关记忆互相激活 - 记忆抑制：相互冲突的记忆互相抑制 - 记忆涌现：群组整体产生新的"元记忆"

记忆竞争机制

class MemoryCompetitionModel:
    """记忆竞争模型"""

    def __init__(self, working_memory_capacity=10):
        self.capacity = working_memory_capacity
        self.competition_matrix = {}

    def get_competition_strength(self, mem1, mem2):
        """获取两个记忆间的竞争强度"""

        # 因素1：语义相似度（越相似，竞争越强）
        semantic_similarity = calculate_semantic_similarity(mem1, mem2)

        # 因素2：优先级竞争（高优先级记忆竞争激烈）
        priority_competition = abs(mem1.priority.value - mem2.priority.value) / 4.0

        # 因素3：时间接近性（最近访问的记忆竞争强）
        time_proximity = 1.0 / (1.0 + time_diff_hours(mem1, mem2))

        # 综合竞争强度
        competition = (
            0.4 * semantic_similarity +
            0.3 * priority_competition +
            0.3 * time_proximity
        )

        return competition

    def allocate_working_memory(self, memories):
        """分配工作记忆空间"""

        scores = {}
        for mem in memories:
            composite_score = calculate_composite_strength(mem)
            competition_score = self.calculate_competition_score(memories)[mem.id]
            scores[mem.id] = composite_score - competition_score * 0.5

        sorted_memories = sorted(memories, key=lambda m: scores[m.id], reverse=True)
        return sorted_memories[:self.capacity]

记忆协同激活

class MemorySynergyModel:
    """记忆协同模型"""

    def activate_memory_chain(self, trigger_memory_id, depth=3):
        """激活记忆链"""

        chain = []
        visited = set()

        def dfs(mem_id, current_depth):
            if current_depth > depth or mem_id in visited:
                return

            visited.add(mem_id)
            mem = get_memory(mem_id)
            chain.append(mem)

            # 激活当前记忆
            mem.strength = min(4.0, mem.strength + 0.5)

            # 递归激活相关记忆
            associations = get_associations(mem_id)
            for assoc in associations:
                dfs(assoc.related_memory_id, current_depth + 1)

        dfs(trigger_memory_id, 0)
        return chain

    def calculate_synergy_score(self, memory_chain):
        """计算协同得分"""

        if len(memory_chain) < 2:
            return 0.0

        length_score = min(1.0, len(memory_chain) / 10.0)
        avg_strength = sum(m.strength for m in memory_chain) / len(memory_chain)
        semantic_consistency = calculate_semantic_consistency(memory_chain)
        priority_consistency = calculate_priority_consistency(memory_chain)

        synergy = (
            0.3 * length_score +
            0.3 * avg_strength / 4.0 +
            0.2 * semantic_consistency +
            0.2 * priority_consistency
        )

        return synergy

理论维度九：自我进化

概念：系统学习如何更好地记忆

机制： - 参数自适应（衰减率、权重） - 策略发现（最佳记忆时机、最佳记忆组合）

参数自适应

衰减率自适应

class AdaptiveDecayRate:
    """自适应衰减率"""

    def observe_outcome(self, decay_rate, outcome):
        """观察衰减效果"""
        self.history.append({
            "decay_rate": decay_rate,
            "outcome": outcome,  # GOOD/BAD
            "timestamp": datetime.now()
        })

    def recommend_decay_rate(self, memory_priority):
        """推荐衰减率"""

        priority_history = [
            h for h in self.history
            if h["decay_rate"].priority == memory_priority
        ]

        if not priority_history:
            return DEFAULT_DECAY_RATE[memory_priority]

        success_rate = sum(
            1 for h in priority_history if h["outcome"] == "GOOD"
        ) / len(priority_history)

        if success_rate > 0.8:
            adjustment = 1.1  # +10%
        elif success_rate < 0.6:
            adjustment = 0.9  # -10%
        else:
            adjustment = 1.0

        recommended_rate = DEFAULT_DECAY_RATE[memory_priority] * adjustment
        return min(0.2, max(0.01, recommended_rate))

权重自适应

class AdaptiveWeights:
    """自适应权重"""

    def observe_outcome(self, context_type, weights, outcome):
        """观察权重效果"""
        if context_type not in self.context_weights_history:
            self.context_weights_history[context_type] = []

        self.context_weights_history[context_type].append({
            "weights": weights.copy(),
            "outcome": outcome,
            "timestamp": datetime.now()
        })

    def recommend_weights(self, context_type):
        """推荐权重"""

        if context_type not in self.context_weights_history:
            return DEFAULT_WEIGHTS[context_type]

        history = self.context_weights_history[context_type]

        # 基于成功的权重组合微调
        successful_weights = [
            h["weights"] for h in history if h["outcome"] == "GOOD"
        ]

        if successful_weights:
            recommended_weights = {}
            for factor in ["time", "semantic", "association", "emotional", "presentation", "coherence"]:
                values = [h["weights"][factor] for h in successful_weights[-5:]]
                recommended_weights[factor] = sum(values) / len(values)

            # 归一化
            total = sum(recommended_weights.values())
            for factor in recommended_weights:
                recommended_weights[factor] /= total
        else:
            # 无历史，使用默认
            recommended_weights = DEFAULT_WEIGHTS[context_type]

        return recommended_weights

策略发现

最佳记忆时机

class OptimalMemoryTiming:
    """最佳记忆时机"""

    def analyze_access_pattern(self, memory_id):
        """分析访问模式"""

        accesses = get_access_history(memory_id)

        # 提取访问时间间隔
        intervals = []
        for i in range(1, len(accesses)):
            interval = accesses[i] - accesses[i-1]
            intervals.append(interval.total_seconds() / 3600)  # 小时

        if len(intervals) < 2:
            return None

        avg_interval = sum(intervals) / len(intervals)
        std_interval = (sum((x - avg_interval) ** 2 for x in intervals) / len(intervals)) ** 0.5

        # 判断访问模式
        if std_interval / avg_interval < 0.2:
            pattern = "REGULAR"
            optimal_review_time = avg_interval * 0.8  # 提前20%复习
        else:
            pattern = "IRREGULAR"
            optimal_review_time = avg_interval * 0.5  # 提前50%提醒

        self.access_patterns[memory_id] = {
            "pattern": pattern,
            "avg_interval": avg_interval,
            "optimal_review_time": optimal_review_time
        }

        return self.access_patterns[memory_id]

理论维度十：常识记忆

概念：高频、跨任务的基础知识

特点： - ✗ 高频使用：几乎所有任务都会用到 - ✗ 跨任务共享：不被单个任务绑定 - ✗ 几乎不遗忘：衰减率为0或极低 - ✗ 优先级最高：高于P0关键信息 - ✗ 永久固化：直接进入长期记忆

示例： - 项目常识：灵字辈成员、各自功能、工具 - 领域常识：泰山是五岳之首 - 系统常识：中国首都是北京

常识类型分类

class ProjectCommonKnowledgeCategory(Enum):
    TEAM_MEMBERS = "team_members"
    MEMBER_ALIASES = "member_aliases"
    MEMBER_FUNCTIONS = "member_functions"
    MEMBER_TOOLS = "member_tools"
    PROJECT_STRUCTURE = "project_structure"
    WORKFLOW_PATTERNS = "workflow_patterns"

class DomainCommonKnowledgeCategory(Enum):
    GEOGRAPHY = "geography"
    HISTORY = "history"
    LITERATURE = "literature"
    SCIENCE = "science"
    CULTURE = "culture"

class SystemCommonKnowledgeCategory(Enum):
    GEOGRAPHIC_FACTS = "geographic_facts"
    POLITICAL_FACTS = "political_facts"
    TECHNICAL_FACTS = "technical_facts"
    ORGANIZATIONAL_FACTS = "organizational_facts"

常识识别标准

1. 使用频率

def is_common_knowledge_by_frequency(memory):
    """基于使用频率判断是否为常识"""

    usage_history = get_usage_history(memory.id, window_days=90)

    if not usage_history:
        return False, 0.0

    total_tasks = get_total_tasks(window_days=90)
    usage_rate = len(usage_history) / total_tasks

    if usage_rate > 0.3:
        return True, usage_rate

    return False, usage_rate

2. 跨任务分布

def is_common_knowledge_by_distribution(memory):
    """基于跨任务分布判断是否为常识"""

    usage_contexts = get_usage_contexts(memory.id, window_days=90)

    unique_contexts = set(ctx.task_type for ctx in usage_contexts)
    diversity = len(unique_contexts) / len(usage_contexts)

    if diversity > 0.7:
        return True, diversity

    return False, diversity

3. 语义基础性

def is_common_knowledge_by_foundational(memory):
    """基于语义基础性判断是否为常识"""

    concepts = extract_core_concepts(memory.content)

    foundational_concepts = [
        c for c in concepts
        if is_foundational_concept(c)
    ]

    if len(foundational_concepts) / len(concepts) > 0.6:
        return True, len(foundational_concepts) / len(concepts)

    return False, 0.0

4. 验证性

def is_common_knowledge_by_verification(memory):
    """基于验证性判断是否为常识"""

    verification_status = get_verification_status(memory.id)

    if verification_status == VERIFIED:
        return True, 1.0

    independent_sources = get_independent_confirmation_sources(memory.id)
    if len(independent_sources) >= 3:
        return True, len(independent_sources) / 10.0

    return False, 0.0

常识固化机制

def promote_to_common_knowledge(memory, ck_type):
    """提升为常识记忆"""

    # 1. 优先级提升
    memory.priority = P0_PLUS  # 高于P0
    memory.strength = CONSOLIDATED

    # 2. 衰减率置0
    memory.decay_rate = 0.0

    # 3. 标记类型
    memory.common_knowledge_type = ck_type

    # 4. 永久化存储位置
    memory.layer = LAYER_LONG_TERM

    # 5. 记录固化时间
    memory.consolidated_at = datetime.now()

    return memory

理论维度十一：记忆启发式

概念：认知科学的记忆启发式

启发式意义： - 人类不是完美的记忆机器 - 但进化了几百万年，有很多优化的启发式 - AI记忆系统可以学习这些启发式

启发式1：首因效应

认知科学发现：系列位置呈"U"形，首尾记忆最好，中间最差

def apply_primacy_effect(memory, sequence_position):
    """应用首因效应"""

    if sequence_position < 0.2:
        # 开头20%，首因效应
        primacy_boost = 0.5
    elif sequence_position > 0.8:
        # 结尾20%，近因效应
        recency_boost = 0.5
    else:
        primacy_boost = 0.0
        recency_boost = 0.0

    memory.strength = min(4.0, memory.strength + primacy_boost + recency_boost)
    return memory

启发式2：间隔效应

认知科学发现：间隔学习比集中学习效果好

def schedule_review_spaced(memory):
    """安排间隔复习"""

    # 艾宾浩斯间隔：1h, 9h, 1d, 2d, 6d, 31d
    ebbinghaus_intervals = [1, 9, 24, 48, 144, 744]  # 小时

    # 目标：保持 80% 保留率
    target_retention = 0.8

    # 计算最佳间隔
    for i, interval_hours in enumerate(ebbinghaus_intervals):
        expected_retention = calculate_expected_retention(
            memory.strength,
            interval_hours
        )

        if expected_retention >= target_retention:
            memory.next_review = datetime.now() + timedelta(hours=interval_hours)
            memory.review_interval_index = i
            return memory

    return memory

启发式3：测试效应

认知科学发现：测试本身比重复学习更能加强记忆

def apply_testing_effect(memory, test_type, test_success):
    """应用测试效应"""

    if test_type == "RECALL":
        # 提取式测试（最有效）
        test_boost = 0.5
    elif test_type == "RECOGNITION":
        # 识别式测试（次有效）
        test_boost = 0.3
    elif test_type == "RELEARNING":
        # 重新学习（最差）
        test_boost = 0.1
    else:
        test_boost = 0.0

    if test_success:
        test_boost *= 1.0
    else:
        test_boost *= -0.5

    memory.strength = max(0.0, min(4.0, memory.strength + test_boost))
    return memory

启发式4：加工深度效应

认知科学发现：深度认知加工的信息记忆更好

def calculate_depth_of_processing(content):
    """计算加工深度"""

    depth_score = 0.0

    # 1. 意音加工（最浅）
    phonetic_features = extract_phonetic_features(content)
    if phonetic_features:
        depth_score += 0.1

    # 2. 结构加工（中等）
    structural_features = extract_structural_features(content)
    if structural_features:
        depth_score += 0.3

    # 3. 语义加工（最深层）
    semantic_features = extract_semantic_features(content)
    if semantic_features:
        depth_score += 0.6

    return depth_score

def apply_depth_effect(memory):
    """应用加工深度效应"""

    depth = calculate_depth_of_processing(memory.content)
    depth_boost = depth * 0.5  # 最大+0.5

    memory.strength = min(4.0, memory.strength + depth_boost)
    return memory

其他启发式

启发式 描述 效应 实现方式
情绪增强效应 情绪强烈的信息记忆更好 +0.5 apply_emotional_enhancement()
图式优势效应 图像记忆比文字记忆好 +0.3 apply_visual_advantage()
情境依赖记忆 相似情境下更容易提取 +0.4 ContextualMemory
状态依赖记忆 与生理/心理状态相关 +0.3 StateDependentMemory
干扰效应 相似信息相互干扰 -0.2~ -0.3 calculate_interference()

理论维度十二：遗忘机制

概念：遗忘不仅是衰减，是主动优化

机制： - 自然衰减：不使用，自然遗忘 - 主动遗忘：主动删除不重要/冲突的记忆 - 干扰遗忘：相似记忆相互干扰 - 提取诱导遗忘：提取某些记忆时，相关记忆被抑制 - 创造性遗忘：清理记忆以创造新空间

遗忘机制1：主动遗忘

def apply_active_forgetting(memory):
    """应用主动遗忘"""

    should_forget = False
    reason = None

    # 1. 强干扰（与多个高优先级记忆冲突）
    conflicts = find_conflicting_memories(memory)
    high_priority_conflicts = [c for c in conflicts if c.priority in [P0, P1]]

    if len(high_priority_conflicts) > 3:
        should_forget = True
        reason = "HIGH_INTERFERENCE"

    # 2. 低重要性且长期未访问
    if memory.priority == P3:
        time_since_access = datetime.now() - memory.last_accessed
        if time_since_access > timedelta(days=30):
            should_forget = True
            reason = "LOW_IMPORTANCE_EXPIRED"

    # 3. 已被新记忆替代
    if is_replaced_by_newer_memory(memory):
        should_forget = True
        reason = "REPLACED"

    if should_forget:
        delete_memory(memory.id, reason)
        return True, reason

    return False, None

遗忘机制2：提取诱导遗忘

def induce_forgetting_by_retrieval(retrieved_memory_id):
    """通过提取诱导遗忘"""

    # 1. 找到相关记忆
    related_memories = find_related_memories(retrieved_memory_id)

    # 2. 抑制相关记忆
    for related in related_memories:
        retrieval_mem = get_memory(retrieved_memory_id)

        # 抑制强度 = 相关性 × 提取记忆强度
        inhibition_strength = (
            related.association_strength *
            retrieval_mem.strength *
            0.3
        )

        related.strength = max(0.0, related.strength - inhibition_strength)

        log_forgetting(
            related.id,
            "INDUCED_BY_RETRIEVAL",
            induced_by=retrieved_memory_id
        )

    return len(related_memories)

遗忘机制3：创造性遗忘

def creative_forgetting(memory_pool, target_capacity):
    """创造性遗忘：清理记忆以创造空间"""

    current_count = len(memory_pool)

    if current_count <= target_capacity:
        return []

    to_forget_count = current_count - target_capacity

    # 排序：综合得分最低的优先遗忘
    scores = {}
    for mem in memory_pool:
        score = (
            mem.strength *
            mem.priority.value *
            (mem.access_count + 1)
        )
        scores[mem.id] = score

    sorted_ids = sorted(scores, key=scores.get)
    to_forget_ids = sorted_ids[:to_forget_count]

    for mem_id in to_forget_ids:
        delete_memory(mem_id, reason="CREATIVE_FORGETTING")

    return to_forget_ids

理论维度十三：记忆重构

概念：记忆不是静态存储，是动态重构

认知科学发现： - 记忆不是"录制" - 而是每次访问时"重新构建" - 每次提取都会修改记忆

记忆重构实现

def reconstruct_memory(memory_id, context):
    """重构建记忆"""

    memory = get_memory(memory_id)
    original_content = memory.content

    # 1. 上下文感知
    context_relevance = calculate_context_relevance(memory, context)

    # 2. 关联激活
    related_memories = activate_related_memories(memory_id)

    # 3. 重构内容
    reconstructed = {
        "content": original_content,
        "contextual_modifications": [],
        "association_influences": []
    }

    # 上下文修改
    if context_relevance > 0.7:
        contextual_mod = merge_context_into_memory(
            memory.content,
            context
        )
        reconstructed["content"] = contextual_mod
        reconstructed["contextual_modifications"].append({
            "context_id": context.id,
            "modification": contextual_mod
        })

    # 联想影响
    for related in related_memories:
        if related.association_strength > 0.6:
            association_inf = merge_association_into_memory(
                reconstructed["content"],
                related
            )
            reconstructed["content"] = association_inf
            reconstructed["association_influences"].append({
                "related_id": related.id,
                "influence": association_inf
            })

    # 4. 更新记忆
    if reconstructed["content"] != original_content:
        memory.content = reconstructed["content"]
        memory.last_reconstructed = datetime.now()
        memory.reconstruction_count += 1

        memory.reconstruction_history.append({
            "timestamp": datetime.now(),
            "original": original_content,
            "reconstructed": reconstructed["content"],
            "contextual_modifications": reconstructed["contextual_modifications"],
            "association_influences": reconstructed["association_influences"]
        })

        # 降低可靠性（重构可能引入错误）
        if memory.meta["reliability"].verification_status == VERIFIED:
            memory.meta["reliability"].verification_status = RECONSTRUCTED

    return memory

总结与实施建议

十三维度全景图

维度 核心问题 解决方案 优先级
1-6 五因素模型 时间/意义/联想/情绪/呈现/连贯 高
7 元记忆 可访问性/可靠性/时效性/相关性 高
8 集体行为 竞争/协同/抑制/涌现 中
9 自我进化 参数自适应/策略发现 中
10 常识记忆 识别/固化/更新/优先检索 极高
11 记忆启发式 10+认知启发式 中
12 遗忘机制 5种遗忘机制 高
13 记忆重构 上下文融合/联想融合 中

实施路线图

Phase 1: 核心机制（7天）

  1. MemoryStrength 动态跟踪 - 基础数据结构
  2. MemoryPriority 分级系统 - P0-P3 优先级
  3. MemoryDecay 时间衰减 - 每日定时任务
  4. 常识记忆识别 - 四标准判断
  5. 常识记忆固化 - 优先级提升

Phase 2: 因素交互（5天）

  1. 语义重要性分析 - 意义计算
  2. 记忆关联网络 - 联想激活
  3. 情绪状态追踪 - 情绪影响
  4. 呈现方式分析 - 格式化指数
  5. 连贯性计算 - 上下文连贯

Phase 3: 高级特性（7天）

  1. 元记忆系统 - 可访问性/可靠性/时效性/相关性
  2. 记忆集体行为 - 竞争/协同/抑制/涌现
  3. 记忆启发式 - 10+启发式实现
  4. 遗忘机制 - 主动/干扰/诱导/创造性遗忘
  5. 记忆重构 - 动态重构系统

Phase 4: 系统集成（5天）

  1. 与 SmartContextCompressor 集成 - 压缩时考虑强度
  2. 与 ContextManager 集成 - 会话保存/恢复
  3. 压缩透明度报告 - 显示保留/丢弃
  4. 记忆健康监控 - 实时统计和建议
  5. 自适应优化 - 参数自动调优

技术挑战

  1. 性能优化：每日衰减任务需要高效执行
  2. 存储设计：记忆关联网络如何高效存储
  3. 参数调优：衰减率、权重如何自适应调优
  4. 用户控制：如何让用户透明地控制和查看记忆
  5. 向后兼容：如何与现有上下文系统兼容

成功指标

  1. 记忆保持率：重要记忆30天保持率 >70%
  2. 检索准确率：Top-10 检索准确率 >85%
  3. 检索延迟：平均检索延迟 <200ms
  4. 存储效率：记忆增长 <20%/月
  5. 用户满意度：记忆相关性评分 >4.0/5.0

附录：关键数据结构

Memory 核心结构

@dataclass
class Memory:
    """记忆核心数据结构"""

    # 基本信息
    id: str                    # UUID
    content: str                # 实际内容
    tokens: int                 # Token 数量
    priority: MemoryPriority     # P0-P3

    # 强度系统
    strength: float             # 0.0-4.0
    created_at: datetime          # 创建时间
    last_accessed: datetime      # 最后访问
    access_count: int            # 访问次数

    # 优先级
    common_knowledge_type: Optional[CommonKnowledgeType]
    is_common_knowledge: bool

    # 衰减
    decay_rate: float            # 0.0-0.2
    last_decay: datetime

    # 关联
    associations: List[MemoryAssociation]

    # 启发式
    heuristic_scores: Dict[str, float]

    # 重构
    reconstruction_count: int
    last_reconstructed: datetime
    reconstruction_history: List[dict]

    # 元记忆
    meta: MemoryMeta

    # 情绪上下文
    learned_in_context: Optional[ContextFeatures]
    learned_in_state: Optional[SystemState]

    # 生命周期
    layer: MemoryLayer
    status: MemoryStatus

    # 标签
    tags: List[str]

优先级枚举

class MemoryPriority(Enum):
    """记忆优先级"""
    P0 = 0    # 关键信息（系统配置、用户偏好）
    P1 = 1    # 重要信息（项目结构、关键实现）
    P2 = 2    # 普通信息（代码片段、调试记录）
    P3 = 3    # 临时信息（临时输出、实验性代码）

    # 特殊优先级
    P0_PLUS = -1  # 常识记忆（高于P0）

    @property
    def value(self):
        if self == MemoryPriority.P0_PLUS:
            return 5.0
        return float(self.value)

记忆层枚举

class MemoryLayer(Enum):
    """记忆层级"""
    WORKING = "working"       # 工作记忆（当前会话）
    ACTIVE = "active"         # 活跃记忆（跨会话）
    DORMANT = "dormant"       # 休眠记忆（归档）
    LONG_TERM = "long_term"   # 长期记忆（常识）

记忆状态枚举

class MemoryStatus(Enum):
    """记忆状态"""
    ACTIVE = "active"           # 活跃
    WEAK = "weak"             # 弱
    DORMANT = "dormant"       # 休眠
    FORGOTTEN = "forgotten"   # 遗忘
    CONFLICTED = "conflicted"   # 冲突
    RECONSTRUCTED = "reconstructed"  # 重构

文档结束

提交对象：灵妍团队
用途：理论研究与系统设计参考
反馈：请审阅并提出修改意见