2 · 核心架构（Core Architecture）

长期记忆与上下文管理 · 本章是 Mem0 DeepWiki 中文译文的独立章节页，保留原始链接、源码锚点、模块标签和章节层级。

项目Mem0 章节2 状态全文译文模块系统架构、模型调用与提供方适配、检索、召回与索引、界面与交互

项目要点页2.5 参考项目项目章节目录Mem0 DeepWiki 原始章节Core Architecture 上一章1.3 下一章2.1

源码线索

Makefile
docs/components/vectordbs/config.mdx
docs/components/vectordbs/dbs/chroma.mdx
docs/components/vectordbs/dbs/qdrant.mdx
docs/components/vectordbs/overview.mdx
mem0/__init__.py
mem0/configs/prompts.py
mem0/memory/main.py
mem0/memory/storage.py
mem0/memory/utils.py

模块标签

系统架构
模型调用与提供方适配
检索、召回与索引
界面与交互
配置治理

中文译文

核心架构（中文译文）

原始 DeepWiki 页面：https://deepwiki.com/mem0ai/mem0/2-core-architecture

翻译时间：2026-05-27T08:45:07.423Z

翻译模型：deepseek-chat

原文字符数：15330

项目：Mem0 (mem0)

---

核心架构

架构总览

Mem0 的架构围绕模块化组件系统构建，该系统使用工厂模式在运行时选择提供方，涵盖五大核心组件类别：大语言模型（LLM）、向量存储、嵌入器、图谱存储和重排序器。Memory 类（位于 mem0/memory/main.py:172-234）负责编排这些组件，在初始化时通过对应的工厂实例化每个组件。

该架构通过四种关键机制实现可扩展性：

机制	实现方式	用途
工厂类	`LlmFactory`、`EmbedderFactory`、`VectorStoreFactory`、`GraphStoreFactory`、`RerankerFactory`（位于 `mem0/utils/factory.py:28-284`）	动态实例化特定提供方的实现
提供方注册表	`provider_to_class` 字典（例如 `mem0/utils/factory.py:35-53` 中的 LLM 映射）	将提供方名称映射到实现类
配置系统	Pydantic 模型（例如 `mem0/configs/base.py:15-102` 中的 `MemoryConfig`、`mem0/vector_stores/configs.py:6-67` 中的 `VectorStoreConfig`）	类型安全的配置，支持提供方特定的模式
动态加载	`load_class()` 函数（位于 `mem0/utils/factory.py:22-25`）	通过 `importlib.import_module()` 在运行时导入

记忆类初始化流程

Memory.__init__() 方法展示了所有工厂如何协同构建记忆引擎：

# 简化流程，来自 mem0/memory/main.py:173-234
class Memory(MemoryBase):
    def __init__(self, config: MemoryConfig = MemoryConfig()):
        self.config = config

        # 第 178 行：嵌入器工厂
        self.embedding_model = EmbedderFactory.create(
            self.config.embedder.provider,
            self.config.embedder.config,
            self.config.vector_store.config,
        )

        # 第 183 行：向量存储工厂
        self.vector_store = VectorStoreFactory.create(
            self.config.vector_store.provider,
            self.config.vector_store.config
        )

        # 第 186 行：LLM 工厂
        self.llm = LlmFactory.create(
            self.config.llm.provider,
            self.config.llm.config
        )

        # 第 187 行：SQLite 历史数据库
        self.db = SQLiteManager(self.config.history_db_path)

来源：mem0/utils/factory.py:28-284、mem0/vector_stores/configs.py:6-67、mem0/memory/main.py:172-234

组件类别与代码结构

下图将系统名称与负责提供方实例化和管理的具体代码实体关联起来。

记忆类初始化与工厂编排

graph TB
    subgraph MemoryClass["Memory 类 (mem0/memory/main.py:172-234)"]
        MemoryInit["Memory.__init__(config: MemoryConfig)"]
        EmbedderInit["第 178 行：self.embedding_model = EmbedderFactory.create()"]
        VectorInit["第 183 行：self.vector_store = VectorStoreFactory.create()"]
        LLMInit["第 186 行：self.llm = LlmFactory.create()"]
        DBInit["第 187 行：self.db = SQLiteManager()"]
        RerankerInit["第 192-197 行：self.reranker = RerankerFactory.create()"]
        GraphInit["第 199-206 行：self.graph = GraphStoreFactory.create()"]
    end

    subgraph FactoryClasses["工厂类 (mem0/utils/factory.py)"]
        LLMFactory["LlmFactory<br/>第 28-134 行<br/>create(provider, config)"]
        EmbedderFactory["EmbedderFactory<br/>第 136-162 行<br/>create(provider, config, vector_config)"]
        VectorFactory["VectorStoreFactory<br/>第 164-206 行<br/>create(provider, config)"]
        GraphFactory["GraphStoreFactory<br/>第 208-230 行<br/>create(provider, config)"]
        RerankerFactory["RerankerFactory<br/>第 232-284 行<br/>create(provider, config)"]
    end

    subgraph ProviderRegistries["提供方注册表"]
        LLMRegistry["provider_to_class 字典<br/>第 35-53 行<br/>18+ 个提供方：<br/>openai、anthropic、groq、<br/>ollama、gemini、litellm"]
        EmbedderRegistry["provider_to_class 字典<br/>第 137-149 行<br/>11 个提供方：<br/>openai、huggingface、<br/>vertexai、gemini、ollama"]
        VectorRegistry["provider_to_class 字典<br/>第 165-189 行<br/>24+ 个提供方：<br/>qdrant、chroma、pinecone、<br/>weaviate、pgvector、redis"]
        GraphRegistry["provider_to_class 字典<br/>第 214-220 行<br/>4+ 个提供方：<br/>default (neo4j)、memgraph、<br/>neptune、neptunedb、kuzu"]
        RerankerRegistry["provider_to_class 字典<br/>第 239-245 行<br/>5 个提供方：<br/>cohere、sentence_transformer、<br/>zero_entropy、llm_reranker"]
    end

    subgraph ProviderImpls["提供方实现"]
        LLMImpl["mem0/llms/<br/>openai.py: OpenAILLM<br/>anthropic.py: AnthropicLLM<br/>ollama.py: OllamaLLM"]
        EmbedderImpl["mem0/embeddings/<br/>openai.py: OpenAIEmbedding<br/>huggingface.py: HuggingFaceEmbedding<br/>gemini.py: GoogleGenAIEmbedding"]
        VectorImpl["mem0/vector_stores/<br/>qdrant.py: Qdrant<br/>chroma.py: ChromaDB<br/>valkey.py: ValkeyDB"]
        GraphImpl["mem0/memory/graph_memory.py: MemoryGraph<br/>mem0/memory/kuzu_memory.py: MemoryGraph<br/>mem0/graphs/neptune/"]
        RerankerImpl["mem0/reranker/<br/>cohere_reranker.py: CohereReranker<br/>llm_reranker.py: LLMReranker<br/>sentence_transformer_reranker.py"]
    end

    MemoryInit --> EmbedderInit
    MemoryInit --> VectorInit
    MemoryInit --> LLMInit
    MemoryInit --> DBInit
    MemoryInit --> RerankerInit
    MemoryInit --> GraphInit

    EmbedderInit --> EmbedderFactory
    VectorInit --> VectorFactory
    LLMInit --> LLMFactory
    RerankerInit --> RerankerFactory
    GraphInit --> GraphFactory

    LLMFactory --> LLMRegistry
    EmbedderFactory --> EmbedderRegistry
    VectorFactory --> VectorRegistry
    GraphFactory --> GraphRegistry
    RerankerFactory --> RerankerRegistry

    LLMRegistry -->|"load_class()<br/>第 22-25 行"| LLMImpl
    EmbedderRegistry -->|"load_class()"| EmbedderImpl
    VectorRegistry -->|"load_class()"| VectorImpl
    GraphRegistry -->|"load_class()"| GraphImpl
    RerankerRegistry -->|"load_class()"| RerankerImpl

来源：mem0/memory/main.py:172-234、mem0/utils/factory.py:28-284、pyproject.toml:26-83

工厂模式实现

每个工厂类都遵循一致的模式，包含三个核心方法：create()、register_provider() 和 get_supported_providers()。create() 方法是实例化组件的主要入口点。

LlmFactory 架构

LlmFactory 类（位于 mem0/utils/factory.py:28-134）展示了所有工厂使用的模式。它定义了用于提供方实例化和注册的类方法。该工厂在 Memory.__init__() 的第 186 行被调用。

LlmFactory 类结构与数据流

graph TB
    subgraph LlmFactoryClass["LlmFactory (mem0/utils/factory.py:28-134)"]
        Registry["provider_to_class 字典<br/>第 35-53 行<br/>15+ 个 LLM 提供方"]
        CreateMethod["@classmethod create()<br/>第 56-109 行"]
        RegisterMethod["@classmethod register_provider()<br/>第 112-123 行"]
        GetProvidersMethod["@classmethod get_supported_providers()<br/>第 126-133 行"]
    end

    subgraph RegistryEntry["注册表条目：'openai' 提供方"]
        EntryKey["键：'openai'"]
        EntryClassPath["类路径：<br/>'mem0.llms.openai.OpenAILLM'"]
        EntryConfigClass["配置类：<br/>OpenAIConfig<br/>(mem0/configs/llms/openai.py)"]
        EntryTuple["元组：<br/>(class_path, config_class)"]

        EntryKey --> EntryTuple
        EntryClassPath --> EntryTuple
        EntryConfigClass --> EntryTuple
    end

    subgraph InstantiationProcess["实例化过程"]
        LoadClass["load_class(class_path)<br/>第 22-25 行<br/>importlib.import_module()"]
        ConfigCreate["配置处理<br/>第 78-107 行<br/>支持：None、dict、<br/>BaseLlmConfig、ProviderConfig"]
        LLMInstance["OpenAILLM(config)<br/>第 109 行"]
    end

    subgraph CalledFrom["从 Memory 类调用"]
        MemoryInit["Memory.__init__()<br/>main.py:186<br/>self.llm = LlmFactory.create()"]
    end

    Registry --> CreateMethod
    EntryTuple --> Registry
    CreateMethod --> LoadClass
    CreateMethod --> ConfigCreate
    LoadClass --> LLMInstance
    ConfigCreate --> LLMInstance

    RegisterMethod --> Registry
    MemoryInit --> CreateMethod

provider_to_class 字典（位于 mem0/utils/factory.py:35-53）将提供方名称映射到 (class_path, config_class) 元组。此注册表支持延迟加载，因为实现类仅在 load_class() 在实例化期间被调用时才导入。

来源：mem0/utils/factory.py:28-134、mem0/memory/main.py:186

使用 load_class() 进行动态类加载

load_class() 函数（位于 mem0/utils/factory.py:22-25）使用 Python 的 importlib 模块在运行时导入提供方实现。所有工厂的 create() 方法都会调用此函数。

# mem0/utils/factory.py:22-25
def load_class(class_type):
    module_path, class_name = class_type.rsplit(".", 1)
    module = importlib.import_module(module_path)
    return getattr(module, class_name)

这种模式允许 Mem0 在所有组件类型中支持 60 多个提供方，而无需预先安装所有包。ImportError 仅在请求特定提供方时发生，从而通过 pyproject.toml 特性组（pyproject.toml:26-83）实现可选依赖。

来源：mem0/utils/factory.py:22-25、pyproject.toml:26-83

提供方注册表系统

每个工厂都维护一个 provider_to_class 字典，将提供方名称映射到实现细节。此注册表是 Mem0 可扩展性的核心。

向量存储工厂注册表

VectorStoreFactory（位于 mem0/utils/factory.py:164-206）展示了最广泛的提供方注册表，包含 24 个以上的向量存储实现。每个注册表条目将提供方名称映射到其实现类路径。

注册表示例（来自 mem0/utils/factory.py:165-189）：

provider_to_class = {
    "qdrant": "mem0.vector_stores.qdrant.Qdrant",
    "chroma": "mem0.vector_stores.chroma.ChromaDB",
    "pgvector": "mem0.vector_stores.pgvector.PGVector",
    "valkey": "mem0.vector_stores.valkey.ValkeyDB",
    # ... 其他提供方
}

例如，ValkeyDB 实现位于 mem0/vector_stores/valkey.py:44-825，其配置位于 mem0/configs/vector_stores/valkey.py:4-16。

来源：mem0/utils/factory.py:164-206、mem0/vector_stores/valkey.py:44-825、mem0/configs/vector_stores/valkey.py:4-16

配置校验系统

配置系统使用 Pydantic 模型，采用两层结构：顶层工厂配置类和提供方特定配置类。

VectorStoreConfig 校验模式

VectorStoreConfig 类（位于 mem0/vector_stores/configs.py:6-67）展示了 Pydantic 的 @model_validator 模式，用于运行时提供方校验和配置实例化。

VectorStoreConfig 校验流程

graph TD
    Input["VectorStoreConfig(provider='valkey', config={...})"]

    Input --> Validator["@model_validator(mode='after')<br/>validate_and_create_config()"]

    Validator --> GetProvider["提取 provider 和 config"]

    GetProvider --> CheckProvider{"provider 在<br/>_provider_configs 中？"}

    CheckProvider -->|"否"| Error["raise ValueError:<br/>不支持的向量存储提供方"]
    CheckProvider -->|"是"| DynamicImport["动态导入：<br/>mem0.configs.vector_stores.{provider}"]

    DynamicImport --> GetConfigClass["获取 config_class<br/>例如 ValkeyConfig"]

    GetConfigClass --> CheckConfigType{"config 为 None？"}

    CheckConfigType -->|"是"| SetEmptyDict["config = {}"]
    CheckConfigType -->|"否"| CheckIsDict{"isinstance(config, dict)？"}

    CheckIsDict -->|"否"| ValidateInstance["检查 config 是否<br/>已经是 config_class 实例"]
    ValidateInstance -->|"否"| Error2["raise ValueError:<br/>无效的 config 类型"]
    ValidateInstance -->|"是"| Return["return self"]

    CheckIsDict -->|"是"| AddDefaults["添加默认 'path'<br/>如果不存在"]
    SetEmptyDict --> AddDefaults

    AddDefaults --> Instantiate["self.config = config_class(**config)"]
    Instantiate --> Return

例如，当 provider='valkey' 时，校验器会从 mem0/configs/vector_stores/valkey.py:4-16 导入 ValkeyConfig，并根据其 Pydantic 模式校验配置字典。

来源：mem0/vector_stores/configs.py:6-67、mem0/configs/vector_stores/valkey.py:4-16

扩展机制

可以通过使用所有工厂类上可用的 register_provider() 类方法来添加新的提供方，而无需修改工厂代码。这允许自定义实现与 Memory 系统无缝集成。

可用的工厂方法

所有五个工厂都提供相同的运行时扩展接口：

方法	签名	用途	位置
`create()`	`create(provider_name, config, **kwargs)`	实例化提供方	各工厂行号不同
`register_provider()`	`register_provider(name, class_path, config_class=None)`	添加自定义提供方	`LlmFactory`：`112-123`
`get_supported_providers()`	`get_supported_providers() -> list`	列出已注册的提供方	`LlmFactory`：`126-133`

来源：mem0/utils/factory.py:112-133、mem0/memory/main.py:186