Memory Bear：给 AI Agent 装上人类般的记忆

class Memory(BaseModel):
    id: str                    # 内容哈希，用于去重
    type: MemoryType           # EPISODIC / SEMANTIC / PROCEDURAL / WORKING
    content: str               # 自然语言内容
    tags: list[str]            # 语义标签
    associations: list[str]    # 关联记忆 ID（激活扩散图边）
    emotion: Emotion           # 效价 × 唤醒度
    activation: Activation     # ACT-R 激活状态
    created_at: float          # 创建时间
    last_accessed: float       # 最后访问时间
    access_count: int          # 访问次数
    decay_rate: float = 0.3    # 艾宾浩斯衰减常数
    strength: float = 1.0      # 编码强度

class Encoder:
    def encode(self, content, memory_type, tags, emotion, ...):
        # 1. 自动标签提取（CJK + Latin 关键词）
        auto_tags = self._extract_tags(content)

        # 2. 情绪检测（关键词启发式）
        if emotion is None:
            emotion = self._detect_emotion(content)

        # 3. 生成内容哈希 ID
        mem_id = self._generate_id(content, memory_type)

        return Memory(id=mem_id, content=content, tags=all_tags, ...)

# 中文：连续 2+ 个汉字作为一个 token
# 英文：2+ 字母的单词
tokens = re.findall(r"[\u4e00-\u9fff]{2,}|[a-zA-Z]{2,}\d*", content.lower())

class ExplicitMemory:
    _nodes: dict[str, Memory]              # id → Memory
    _adj: dict[str, dict[str, float]]      # 邻接表（带权重）
    _tag_index: dict[str, set[str]]        # 标签倒排索引

# 共享标签权重：log1p 增长，避免边权爆炸
weight = 1.0 + math.log1p(count - 1) if count > 1 else 1.0

class ImplicitMemory:
    _patterns: dict[str, [response, confidence]]  # pattern → response

new_conf = old_conf + (1.0 - old_conf) * incoming_confidence

# "早安" 匹配已学模式 "早上好" → 相似度 0.67 → 触发响应
ratio = SequenceMatcher(None, query, stored_key).ratio()
effective_confidence = confidence * ratio

class SpreadingActivation:
    def activate(self, seed_ids, now):
        # BFS 遍历
        queue = deque([(sid, 0) for sid in seed_ids])

        while queue:
            current_id, depth = queue.popleft()
            if depth >= self.max_depth:
                continue

            for nid in neighbors:
                # 激活随深度衰减 × 节点自身记忆强度
                spread = current_activation * self.decay_factor
                received = spread * neighbor.current_strength(now)

                if received >= self.threshold:
                    activation_map[nid] = received
                    queue.append((nid, depth + 1))

class RetrievalEngine:
    KEYWORD_WEIGHT = 0.4    # 关键词匹配
    TAG_WEIGHT = 0.2        # 标签匹配
    ACTIVATION_WEIGHT = 0.4 # 扩散激活

    def retrieve(self, query, tags, now, limit):
        # 1. 关键词搜索（AND 语义）
        keyword_scores = ...

        # 2. 标签过滤（OR 语义）
        tag_scores = ...

        # 3. 从命中种子扩散激活
        seed_ids = set(keyword_scores) | set(tag_scores)
        activation_scores = self.spreading.activate(seed_ids, now)

        # 4. 分数融合
        for mid in all_ids:
            score = (0.4 * kw + 0.2 * tg + 0.4 * ac)

class MemoryConsolidation:
    def consolidate(self, now):
        for mid, mem in all_mems.items():
            strength = mem.current_strength(now)

            # 遗忘：强度低于阈值 → 删除
            if strength < 0.05:
                self.explicit.remove(mid)

            # 增强（LTP）：强度高 + 访问频繁 → 激活值提升
            if strength > 0.7 and mem.access_count > 3:
                mem.activation.base_level *= 1.2  # 饱和上限 2.0

        # 模式提取：3+ 条相似记忆 → 提炼为隐性模式
        self.extract_pattern(all_mems)

from memory_bear import MemoryBear, MemoryType

bear = MemoryBear()

# ── 存储记忆 ──
bear.remember("用户喜欢喝美式咖啡", tags=["偏好", "咖啡"])
bear.remember("用户是软件工程师", tags=["职业"])
bear.remember(
    "项目上线当天出了严重 bug，团队通宵修复",
    tags=["项目", "bug"],
    # 情绪会自动检测到"严重""通宵"等高唤醒词
)

# ── 检索记忆 ──
result = bear.recall("咖啡")
for mem, score in result.memories:
    print(f"  [{score:.2f}] {mem.content}")
# 不仅找到"咖啡"那条，还通过共享标签"偏好"激活了相关记忆

# ── 学习技能（隐性记忆）──
bear.learn_pattern("早上好", "提醒用户喝咖啡")
match = bear.match_pattern("早安")  # 模糊匹配！
# → ("提醒用户喝咖啡", 0.35)

# ── 记忆巩固（模拟睡眠）──
report = bear.consolidate()
print(f"遗忘 {report.forgotten} 条，增强 {report.reinforced} 条")

# ── 持久化 ──
bear.save("/tmp/memories.json")