解决方案设计

方案概览

根据能力验证结果，memU支持两种部署方式：云服务和自托管。本节将详细分析两种方案。

方案对比矩阵

方案A：云服务集成（原生方案）

架构图

┌─────────────────────────────────────────────────────────────────┐
│                        Your AI Agent                             │
└─────────────────────────────────────────────────────────────────┘
                              │
                              │ HTTPS API
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    memU Cloud (api.memu.so)                      │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
│  │  memorize   │  │  retrieve   │  │  categories │              │
│  │  endpoint   │  │  endpoint   │  │  endpoint   │              │
│  └─────────────┘  └─────────────┘  └─────────────┘              │
│                              │                                   │
│                              ▼                                   │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │           Managed PostgreSQL + pgvector                      ││
│  └─────────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────────┘

API端点

代码示例

import httpx

class MemUCloudClient:
    def __init__(self, api_key: str):
        self.base_url = "https://api.memu.so"
        self.headers = {"Authorization": f"Bearer {api_key}"}
        self.client = httpx.AsyncClient(base_url=self.base_url, headers=self.headers)
    
    async def memorize(self, resource_url: str, modality: str, user_id: str = None):
        """存储记忆"""
        payload = {
            "resource_url": resource_url,
            "modality": modality,
        }
        if user_id:
            payload["user"] = {"user_id": user_id}
        
        response = await self.client.post("/api/v3/memory/memorize", json=payload)
        return response.json()
    
    async def retrieve(self, query: str, user_id: str = None, method: str = "rag"):
        """检索记忆"""
        payload = {
            "queries": [{"role": "user", "content": {"text": query}}],
            "method": method
        }
        if user_id:
            payload["where"] = {"user_id": user_id}
        
        response = await self.client.post("/api/v3/memory/retrieve", json=payload)
        return response.json()

适用场景

• 快速原型验证
• 中小规模应用
• 不需要数据本地化要求的场景
• 希望减少运维负担的团队

方案B：自托管部署（完整控制）

架构图

┌─────────────────────────────────────────────────────────────────┐
│                        Your AI Agent                             │
│  ┌───────────────────────────────────────────────────────────┐  │
│  │                    memU SDK (Python)                       │  │
│  │    pip install memu-py                                     │  │
│  └───────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
                              │
                              │ PostgreSQL Protocol
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│              PostgreSQL + pgvector (Docker)                      │
│  ┌─────────────────────┐  ┌─────────────────────┐               │
│  │  Memory Items Table │  │  Categories Table   │               │
│  │  (向量 + 元数据)      │  │  (类别结构)          │               │
│  └─────────────────────┘  └─────────────────────┘               │
└─────────────────────────────────────────────────────────────────┘
                              │
                              │ LLM API Calls
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    LLM Provider (Your Choice)                    │
│     OpenAI / OpenRouter / Azure / 阿里云 / 自部署模型             │
└─────────────────────────────────────────────────────────────────┘

部署步骤

1. 数据库准备

# 启动PostgreSQL + pgvector
docker run -d \
  --name memu-postgres \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=postgres \
  -e POSTGRES_DB=memu \
  -p 5432:5432 \
  pgvector/pgvector:pg16

2. 安装memU

pip install memu-py

3. 初始化服务

from memu import MemUService

service = MemUService(
    llm_profiles={
        "default": {
            "base_url": "https://api.openai.com/v1",
            "api_key": "your_openai_key",
            "chat_model": "gpt-4o",
            "embed_model": "text-embedding-3-small"
        }
    },
    database_config={
        "metadata_store": {
            "provider": "postgres",
            "url": "postgresql://postgres:postgres@localhost:5432/memu"
        }
    }
)

自定义配置

使用阿里云通义

service = MemUService(
    llm_profiles={
        "default": {
            "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
            "api_key": "your_dashscope_key",
            "chat_model": "qwen-max",
            "embed_model": "text-embedding-v3"
        }
    },
    database_config={
        "metadata_store": {"provider": "postgres", "url": "..."}
    }
)

使用OpenRouter多模型

service = MemUService(
    llm_profiles={
        "default": {
            "provider": "openrouter",
            "client_backend": "httpx",
            "api_key": "your_openrouter_key",
            "chat_model": "anthropic/claude-3.5-sonnet",
            "embed_model": "openai/text-embedding-3-small"
        }
    }
)

适用场景

• 企业级部署
• 数据敏感场景（医疗、金融等）
• 需要完全控制数据位置
• 需要深度定制记忆处理逻辑
• 大规模应用（成本可控）

方案C：主动式记忆代理（高级场景）

工作原理

┌─────────────────────────────────────────────────────────────────┐
│                         用户交互                                 │
└─────────────────────────────────────────────────────────────────┘
          │                                    │
          ▼                                    ▼
┌──────────────────────┐          ┌──────────────────────────────┐
│     Main Agent       │◄────────►│       memU Bot               │
│   (响应用户请求)       │  注入记忆  │   (持续监控、记忆、预测)      │
└──────────────────────┘          └──────────────────────────────┘
          │                                    │
          │                                    ▼
          │                      ┌──────────────────────────────┐
          │                      │     Memory Operations        │
          │                      │  - 监控输入输出               │
          │                      │  - 提取偏好/事实              │
          │                      │  - 预测下一步意图             │
          │                      │  - 主动建议                  │
          │                      └──────────────────────────────┘
          │                                    │
          └────────────────────────────────────┘
                         持续同步循环

典型用例

信息推荐

# memU持续跟踪用户阅读习惯
用户行为：阅读AI相关文章，保存了3篇RAG论文

# 主动推荐
memU Bot: "我发现3篇新的RAG优化论文符合你最近的研究方向。
          其中一位作者（陈博士）你之前引用过，昨天刚发表了新作。"

邮件管理

# memU学习邮件处理模式
学习内容：
- 常见场景的回复模板
- 重要联系人和紧急关键词
- 日程偏好和可用时间

# 主动辅助
memU Bot: "你有12封新邮件。我已经为3封常规请求草拟了回复，
          并标记了2封来自重要联系人的紧急事项。"

实现代码

# examples/proactive/proactive.py
import asyncio
from memu import MemUService

class ProactiveMemoryAgent:
    def __init__(self, service: MemUService, user_id: str):
        self.service = service
        self.user_id = user_id
    
    async def observe_and_memorize(self, conversation: list):
        """观察对话并记忆"""
        result = await self.service.memorize(
            resource_url=conversation,  # 对话历史
            modality="conversation",
            user={"user_id": self.user_id}
        )
        return result
    
    async def predict_intent(self, recent_context: str):
        """预测用户意图"""
        result = await self.service.retrieve(
            queries=[{"role": "user", "content": {"text": recent_context}}],
            where={"user_id": self.user_id},
            method="llm"  # 使用LLM进行深度推理
        )
        return result.get("next_step_query")

选型建议

场景匹配

成本估算

云服务成本

自托管成本

参考资料

• memU Quick Start - 官方快速开始指南
• memU Cloud - 云服务入口
• memUBot - 主动式代理示例