先看目录结构（真实 find 结果，lib/crewai/src/crewai/memory/）：

memory/
├── __init__.py            # 对外导出 + 懒加载 Memory / EncodingFlow
├── types.py               # MemoryRecord / MemoryConfig / 评分函数（数据层）
├── unified_memory.py      # Memory 类：对外总入口（1104 行）  ← D34
├── encoding_flow.py       # 存的流水线（5 步 Flow）           ← D35
├── recall_flow.py         # 取的流水线（自适应深度 Flow）     ← D35
├── analyze.py             # LLM 分析：分类/合并/查询蒸馏
├── memory_scope.py        # MemoryScope / MemorySlice 作用域视图 ← D37
├── utils.py               # scope 路径规整工具
└── storage/
    ├── backend.py         # StorageBackend 协议（接口）        ← D40
    ├── factory.py         # 存储后端工厂（可替换）
    ├── lancedb_storage.py # 默认后端：LanceDB（669 行）       ← D40
    └── qdrant_edge_storage.py # 备选后端：Qdrant

入口文件用了懒加载（__init__.py:23）——这是个值得注意的设计：

# memory/__init__.py:23
_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
    "Memory": ("crewai.memory.unified_memory", "Memory"),
    "EncodingFlow": ("crewai.memory.encoding_flow", "EncodingFlow"),
}

def __getattr__(name: str) -> Any:
    """Lazily import Memory / EncodingFlow to avoid pulling in lancedb at import time."""
    if name in _LAZY_IMPORTS:
        import importlib
        module_path, attr = _LAZY_IMPORTS[name]
        mod = importlib.import_module(module_path)
        val = getattr(mod, attr)
        globals()[name] = val
        return val
    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

最核心的数据结构是 MemoryRecord（types.py:20），一条记忆存的所有东西都在这：

# types.py:20
class MemoryRecord(BaseModel):
    id: str = Field(default_factory=lambda: str(uuid4()))     # 唯一 ID
    content: str = Field(...)                                 # 记忆正文（必填）
    scope: str = Field(default="/")                           # 层级路径 /company/team/user
    categories: list[str] = Field(default_factory=list)      # 标签
    metadata: dict[str, Any] = Field(default_factory=dict)   # 任意元数据
    importance: float = Field(default=0.5, ge=0.0, le=1.0)   # 重要性 0~1
    created_at: datetime = Field(default_factory=datetime.utcnow)
    last_accessed: datetime = Field(default_factory=datetime.utcnow)
    embedding: list[float] | None = Field(
        default=None, exclude=True, repr=False,               # ★不参与序列化
        description="Vector embedding ... Excluded from serialization to save tokens.")
    source: str | None = Field(default=None)                 # 来源（用户ID/会话ID）
    private: bool = Field(default=False)                      # 私有：只对同 source 可见

MemoryConfig（types.py:135）把所有可调参数收进一个对象，最关键的是三个权重：

# types.py:135（节选核心字段）
class MemoryConfig(BaseModel):
    # 复合分 = semantic_weight*相似度 + recency_weight*新鲜度 + importance_weight*重要性
    recency_weight: float = Field(default=0.3)      # 新鲜度权重
    semantic_weight: float = Field(default=0.5)     # 语义相似权重（占大头）
    importance_weight: float = Field(default=0.2)   # 重要性权重
    recency_half_life_days: int = Field(default=30) # 新鲜度"半衰期"：30 天减半

    consolidation_threshold: float = Field(default=0.85)  # 相似度超此值触发"合并"
    consolidation_limit: int = Field(default=5)           # 合并时最多比对几条
    batch_dedup_threshold: float = Field(default=0.98)    # 批量去重阈值（近乎重复才丢）

    confidence_threshold_high: float = Field(default=0.8) # 检索置信度≥此值直接返回
    confidence_threshold_low: float = Field(default=0.5)  # 低于此值触发深挖
    exploration_budget: int = Field(default=1)            # 深挖轮数预算
    query_analysis_threshold: int = Field(default=250)    # 查询短于此字符数跳过 LLM 分析

整套记忆的"灵魂公式"就是 compute_composite_score（types.py:345）：

# types.py:345
def compute_composite_score(
    record: MemoryRecord, semantic_score: float, config: MemoryConfig,
) -> tuple[float, list[str]]:
    age_seconds = (datetime.utcnow() - record.created_at).total_seconds()
    age_days = max(age_seconds / 86400.0, 0.0)
    decay = 0.5 ** (age_days / config.recency_half_life_days)   # ★指数衰减

    composite = (
        config.semantic_weight * semantic_score      # 语义：向量搜出来的相似度
        + config.recency_weight * decay               # 新鲜：越新 decay 越接近 1
        + config.importance_weight * record.importance  # 重要：存时标记的分
    )
    reasons: list[str] = ["semantic"]
    if decay > 0.5:
        reasons.append("recency")           # 新鲜度还高就记一笔"因为新"
    if record.importance > 0.5:
        reasons.append("importance")        # 重要就记一笔"因为重要"
    return composite, reasons

记忆到底存进 LanceDB 还是 Qdrant？Memory 不关心——它只依赖一个 Protocol（storage/backend.py:44）：

# storage/backend.py:44
@runtime_checkable
class StorageBackend(Protocol):
    """Protocol for pluggable memory storage backends."""

    def save(self, records: list[MemoryRecord]) -> None: ...
    def search(self, query_embedding: list[float],
               scope_prefix: str | None = None,
               categories: list[str] | None = None,
               metadata_filter: dict[str, Any] | None = None,
               limit: int = 10, min_score: float = 0.0,
               ) -> list[tuple[MemoryRecord, float]]: ...
    def delete(self, ...) -> int: ...
    def update(self, record: MemoryRecord) -> None: ...
    def get_record(self, record_id: str) -> MemoryRecord | None: ...
    def list_records(self, ...) -> list[MemoryRecord]: ...
    def get_scope_info(self, scope: str) -> ScopeInfo: ...
    def list_scopes(self, parent: str = "/") -> list[str]: ...
    def list_categories(self, ...) -> dict[str, int]: ...
    def count(self, ...) -> int: ...
    def reset(self, ...) -> None: ...
    # 还有 asave / asearch / adelete 三个 async 版本

把上面的零件拼起来，就是对外的 Memory 类（unified_memory.py:76）：

# unified_memory.py:76（节选）
class Memory(BaseModel):
    """Unified memory: standalone, LLM-analyzed, with intelligent recall flow.
    Works without agent/crew. Uses LLM to infer scope, categories, importance on save."""

    llm: ... = Field(default="gpt-5.4-mini")       # 分析用的 LLM
    storage: ... = Field(default="lancedb")        # ★默认存储：字符串 "lancedb"
    embedder: Any = Field(default=None)            # None = 默认 OpenAI 嵌入
    recency_weight: float = Field(default=0.3)
    semantic_weight: float = Field(default=0.5)
    importance_weight: float = Field(default=0.2)
    ...
    root_scope: str | None = Field(default=None,
        description="Structural root scope prefix. ... a crew with "
        "root_scope='/crew/research' will store memories at '/crew/research/<inferred_scope>'.")