Mem0 平台记忆用例实战：七大场景的 Python 与 TypeScript 实现详解

本篇技术指南以仓库中的 use-cases.md 为主体，系统讲解 Mem0 平台在七大典型业务场景下的落地实现——从个性化陪伴、分类客服、医疗教练，到多智能体多租户隔离、个性化搜索与邮件智能。每个场景都给出可直接复制运行的 Python 与 TypeScript 双语言代码，并结合 Python 客户端 与 类型定义 的源码细节，说明 filters、threshold、top_k、custom_categories 等关键参数的真实约束与底层调用链路。

一、前置准备：MemoryClient 与项目定位

所有用例都基于平台客户端 MemoryClient 展开。Python 端从 mem0 包导入，TypeScript 端从 mem0ai 包导入，并依赖环境变量 MEM0_API_KEY：

from mem0 import MemoryClient
mem0 = MemoryClient()          # 读取 MEM0_API_KEY 环境变量

import MemoryClient from 'mem0ai';
const mem0 = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! });

从源码看，MemoryClient 的初始化流程会完成三件事：其一，读取 MEM0_API_KEY（未提供时抛出 ValueError）；其二，以 API Key 的 MD5 作为内部 user_id 标识并注入请求头 Authorization: Token <key> 与 Mem0-User-ID；其三，通过 /v1/ping/ 校验 Key 并自动解析出 org_id 与 project_id，随后挂载 Project 管理器供后续项目级配置使用。

适用前提与限制：project.update(...) 等项目管理操作要求 API Key 能解析出 org_id 与 project_id，否则 BaseProject._validate_org_project 会抛出 ValueError。也就是说，个人试用 Key 未必能调用项目级接口，生产项目需绑定组织。

核心记忆的写入走 /v3/memories/add/，检索走 /v3/memories/search/，全量列举走 /v3/memories/，这一 v3 接口约定直接决定了后文所有用例的调用形态。

二、用例 1：个性化 AI 陪伴（Fitness Coach）

场景：一个能跨会话记住目标、偏好与进展的健身教练。Mem0 负责在应用重启后依然保持上下文——无需自行维护会话状态。

Python 实现

from mem0 import MemoryClient
from openai import OpenAI

mem0 = MemoryClient()
openai_client = OpenAI()

def chat(user_input: str, user_id: str) -> str:
    # 1. 检索相关记忆
    memories = mem0.search(user_input, user_id=user_id)
    context = "\n".join([f"- {m['memory']}" for m in memories.get("results", [])])

    # 2. 结合记忆上下文生成回复
    system_prompt = f"""You are Ray, a personal fitness coach.
Use these known facts about the user to personalize your response:
{context if context else 'No prior context yet.'}"""

    response = openai_client.chat.completions.create(
        model="gpt-5-mini",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_input},
        ]
    )
    reply = response.choices[0].message.content

    # 3. 存储本轮交互供后续使用
    mem0.add(
        [{"role": "user", "content": user_input}, {"role": "assistant", "content": reply}],
        user_id=user_id
    )
    return reply

# 用法
chat("I want to run a marathon in under 4 hours", user_id="max")
# 次日、应用重启后：
chat("What should I focus on today?", user_id="max")
# Ray 会记得"4 小时完赛"这个目标

TypeScript 实现

import MemoryClient from 'mem0ai';
import OpenAI from 'openai';

const mem0 = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! });
const openai = new OpenAI();

async function chat(userInput: string, userId: string): Promise<string> {
    // 1. 检索相关记忆
    const memories = await mem0.search(userInput, { filters: { user_id: userId } });
    const context = memories.results
        ?.map((m: any) => `- ${m.memory}`)
        .join('\n') || 'No prior context yet.';

    // 2. 结合记忆上下文生成回复
    const response = await openai.chat.completions.create({
        model: 'gpt-5-mini',
        messages: [
            { role: 'system', content: `You are Ray, a personal fitness coach.\nUser context:\n${context}` },
            { role: 'user', content: userInput },
        ],
    });
    const reply = response.choices[0].message.content!;

    // 3. 存储交互
    await mem0.add(
        [{ role: 'user', content: userInput }, { role: 'assistant', content: reply }],
        { userId: userId }
    );
    return reply;
}

关键收益：上下文跨应用重启持久化，无需会话管理；记忆自动去重并更新；与任意 LLM 提供商解耦（OpenAI、Anthropic 等）。 适用对象：健身教练、导师、心理咨询师——任何需要跨会话记住用户目标的助手。

源码级注意点：TypeScript 实现中检索用的是 filters: { user_id: userId }，这与 SearchMemoryOptions 的设计一致——v3 检索接口不接收顶层实体参数。当前 Python 客户端的 search() 会对 user_id/agent_id/app_id/run_id 这类顶层实体参数显式抛出 ValueError，并提示改用 filters={'user_id': ...}。因此若按上文文档简写 mem0.search(q, user_id=...)，在现行 Python SDK 下会得到报错；稳妥写法是把实体 ID 放进 filters。写入侧（add）则允许把 user_id 等作为顶层字段随 /v3/memories/add/ 一并提交，因为 add() 不做该拒绝。

三、用例 2：带分类的客服支持（Customer Support with Categories）

场景：自动对支持数据分类，让团队快速取回正确的事实。核心是项目级 custom_categories，实现结构化检索。

Python 实现

from mem0 import MemoryClient

client = MemoryClient()

# 1. 在项目级一次性定义分类
custom_categories = [
    {"support_tickets": "Customer issues and resolutions"},
    {"account_info": "Account details and preferences"},
    {"billing": "Payment history and billing questions"},
    {"product_feedback": "Feature requests and feedback"},
]
client.project.update(custom_categories=custom_categories)

# 2. 存储交互——自动归入分类
def log_support_interaction(user_id: str, message: str, priority: str = "normal"):
    client.add(
        [{"role": "user", "content": message}],
        user_id=user_id,
        metadata={"priority": priority, "source": "support_chat"}
    )

# 3. 按分类检索
def get_billing_issues(user_id: str):
    return client.get_all(
        filters={
            "AND": [
                {"user_id": user_id},
                {"categories": {"in": ["billing"]}}
            ]
        }
    )

def search_support_history(user_id: str, query: str):
    return client.search(
        query,
        filters={
            "AND": [
                {"user_id": user_id},
                {"categories": {"contains": "support_tickets"}}
            ]
        },
        top_k=5
    )

# 用法
log_support_interaction("maria", "I was charged twice for last month's subscription", priority="high")
log_support_interaction("maria", "The dashboard is loading slowly on mobile")
billing = get_billing_issues("maria")   # 只返回账单相关记忆

TypeScript 实现

import MemoryClient from 'mem0ai';

const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! });

// 一次性设置分类
await client.updateProject({
    custom_categories: [
        { support_tickets: 'Customer issues and resolutions' },
        { billing: 'Payment history and billing questions' },
        { product_feedback: 'Feature requests and feedback' },
    ],
});

async function logInteraction(userId: string, message: string, priority = 'normal') {
    await client.add(
        [{ role: 'user', content: message }],
        { userId: userId, metadata: { priority, source: 'support_chat' } }
    );
}

async function getBillingIssues(userId: string) {
    return client.getAll({
        filters: { AND: [{ user_id: userId }, { categories: { in: ['billing'] } }] },
    });
}

关键收益：自动分类，无需手动打标签；可按分类过滤实现结构化检索；priority、source 等元数据支持多维查询。 适用对象：帮助台、SaaS 支持、电商——按分类的结构化检索省去人工翻找。

源码级说明：client.project.update(custom_categories=...) 对应 Project.update，它对 custom_instructions、custom_categories、multilingual、decay、agent_custom_instructions 至少要求一项非空，随后 PATCH 到 /api/v1/orgs/organizations/{org}/projects/{project}/。这与本文用例 6 的 custom_instructions 走同一入口。检索侧 {"AND": [...]} 复合过滤由 SearchMemoryOptions.filters 承载，top_k 控制返回条数。

四、用例 3：医疗健康教练（Healthcare Coach）

场景：用助手记住病史来指导患者。关键是在安全敏感场景使用较高的 threshold 保证检索置信度。

Python 实现

from mem0 import MemoryClient
from openai import OpenAI

mem0 = MemoryClient()
openai_client = OpenAI()

def save_patient_info(user_id: str, information: str):
    mem0.add(
        [{"role": "user", "content": information}],
        user_id=user_id,
        run_id="healthcare_session",
        metadata={"type": "patient_information"}
    )

def consult(user_id: str, question: str) -> str:
    # 医疗准确性要求高阈值
    memories = mem0.search(question, user_id=user_id, top_k=5, threshold=0.7)
    context = "\n".join([f"- {m['memory']}" for m in memories.get("results", [])])

    response = openai_client.chat.completions.create(
        model="gpt-5-mini",
        messages=[
            {"role": "system", "content": f"You are a health coach. Patient context:\n{context}"},
            {"role": "user", "content": question},
        ]
    )
    reply = response.choices[0].message.content

    # 存储本轮交互
    mem0.add(
        [{"role": "user", "content": question}, {"role": "assistant", "content": reply}],
        user_id=user_id,
        run_id="healthcare_session",
    )
    return reply

# 用法
save_patient_info("alex", "I'm allergic to penicillin and take metformin for type 2 diabetes")
consult("alex", "Can I take amoxicillin for my sore throat?")
# 记得青霉素过敏——阿莫西林属青霉素类抗生素

TypeScript 实现

import MemoryClient from 'mem0ai';
import OpenAI from 'openai';

const mem0 = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! });
const openai = new OpenAI();

async function savePatientInfo(userId: string, info: string) {
    await mem0.add(
        [{ role: 'user', content: info }],
        { userId: userId, runId: 'healthcare_session', metadata: { type: 'patient_information' } }
    );
}

async function consult(userId: string, question: string): Promise<string> {
    const memories = await mem0.search(question, {
        filters: { user_id: userId },
        topK: 5,
        threshold: 0.7,
    });
    const context = memories.results?.map((m: any) => `- ${m.memory}`).join('\n') || '';

    const response = await openai.chat.completions.create({
        model: 'gpt-5-mini',
        messages: [
            { role: 'system', content: `You are a health coach. Patient context:\n${context}` },
            { role: 'user', content: question },
        ],
    });
    const reply = response.choices[0].message.content!;

    await mem0.add(
        [{ role: 'user', content: question }, { role: 'assistant', content: reply }],
        { userId: userId, runId: 'healthcare_session' }
    );
    return reply;
}

关键收益：高阈值（0.7）确保安全敏感场景只返回高置信匹配；run_id 会话作用域将相关健康交互分组；元数据标签区分患者信息与对话历史。 适用对象：远程医疗、健康应用、患者管理——跨就诊的持久健康上下文。

源码级说明：threshold 与 top_k 均为 SearchMemoryOptions 的合法字段——top_k 指返回条数，threshold 指最小相似度阈值。run_id 用于会话分组，配合写入侧的 AddMemoryOptions（其 filters 与 metadata 见 types.py）。

五、用例 4：内容创作工作流（Content Creation Workflow）

场景：一次性存储风格指南，并应用到每一篇草稿。用 run_id 与 metadata 按会话隔离写作偏好。

Python 实现

from mem0 import MemoryClient
from openai import OpenAI

mem0 = MemoryClient()
openai_client = OpenAI()

def store_writing_preferences(user_id: str, preferences: str):
    mem0.add(
        [{"role": "user", "content": preferences}],
        user_id=user_id,
        run_id="editing_session",
        metadata={"type": "preferences", "category": "writing_style"}
    )

def draft_content(user_id: str, topic: str) -> str:
    # 检索写作偏好
    prefs = mem0.search(
        "writing style preferences",
        filters={"AND": [{"user_id": user_id}, {"run_id": "editing_session"}]}
    )
    style_context = "\n".join([f"- {m['memory']}" for m in prefs.get("results", [])])

    response = openai_client.chat.completions.create(
        model="gpt-5-mini",
        messages=[
            {"role": "system", "content": f"Write content matching these style preferences:\n{style_context}"},
            {"role": "user", "content": f"Write a blog post about: {topic}"},
        ]
    )
    return response.choices[0].message.content

# 用法
store_writing_preferences("writer_01", "I prefer short sentences. Active voice. No jargon. Use analogies.")
draft_content("writer_01", "Why AI memory matters for chatbots")
# 生成的草稿匹配已存储的风格指南

TypeScript 实现

import MemoryClient from 'mem0ai';
import OpenAI from 'openai';

const mem0 = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! });
const openai = new OpenAI();

async function storePreferences(userId: string, preferences: string) {
    await mem0.add(
        [{ role: 'user', content: preferences }],
        { userId: userId, runId: 'editing_session', metadata: { type: 'preferences' } }
    );
}

async function draftContent(userId: string, topic: string): Promise<string> {
    const prefs = await mem0.search('writing style preferences', {
        filters: { AND: [{ user_id: userId }, { run_id: 'editing_session' }] },
    });
    const styleContext = prefs.results?.map((m: any) => `- ${m.memory}`).join('\n') || '';

    const response = await openai.chat.completions.create({
        model: 'gpt-5-mini',
        messages: [
            { role: 'system', content: `Write content matching these preferences:\n${styleContext}` },
            { role: 'user', content: `Write a blog post about: ${topic}` },
        ],
    });
    return response.choices[0].message.content!;
}

关键收益：风格指南一次存储、全内容复用；会话作用域支持维护多套风格画像；偏好随迭代自动更新。 适用对象：市场团队、技术写作者、代理机构——全内容统一口吻。

六、用例 5：多智能体 / 多租户（Multi-Agent / Multi-Tenant）

场景：用 user_id、agent_id、app_id、run_id 四个维度隔离记忆，是多智能体工作流与多租户应用的核心。

Python 实现

from mem0 import MemoryClient

client = MemoryClient()

# 存储记忆：用户 + 智能体 + 会话 + 应用 四级作用域
def store_scoped_memory(messages: list, user_id: str, agent_id: str, run_id: str, app_id: str):
    client.add(
        messages,
        user_id=user_id,
        agent_id=agent_id,
        run_id=run_id,
        app_id=app_id
    )

# 在特定作用域内查询
def search_user_session(query: str, user_id: str, app_id: str, run_id: str):
    """检索某用户在某会话内的记忆。"""
    return client.search(
        query,
        filters={
            "AND": [
                {"user_id": user_id},
                {"app_id": app_id},
                {"run_id": run_id}
            ]
        }
    )

def search_agent_knowledge(query: str, agent_id: str, app_id: str):
    """检索某智能体跨所有用户的记忆。"""
    return client.search(
        query,
        filters={
            "AND": [
                {"agent_id": agent_id},
                {"app_id": app_id}
            ]
        }
    )

# 用法：多智能体的旅行 concierge 应用
store_scoped_memory(
    [{"role": "user", "content": "I'm vegetarian and prefer window seats"}],
    user_id="traveler_cam",
    agent_id="travel_planner",
    run_id="tokyo-2025",
    app_id="concierge_app"
)

# 用户作用域查询："Cam 偏好什么？"
user_mems = search_user_session("dietary restrictions?", "traveler_cam", "concierge_app", "tokyo-2025")

# 智能体作用域查询："所有旅行者的共性偏好？"（跨用户）
agent_mems = search_agent_knowledge("common dietary restrictions?", "travel_planner", "concierge_app")

TypeScript 实现

import MemoryClient from 'mem0ai';

const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! });

async function storeScopedMemory(
    messages: Array<{ role: string; content: string }>,
    userId: string, agentId: string, runId: string, appId: string
) {
    await client.add(messages, {
        userId: userId,
        agentId: agentId,
        runId: runId,
        appId: appId,
    });
}

async function searchUserSession(query: string, userId: string, appId: string, runId: string) {
    return client.search(query, {
        filters: { AND: [{ user_id: userId }, { app_id: appId }, { run_id: runId }] },
    });
}

async function searchAgentKnowledge(query: string, agentId: string, appId: string) {
    return client.search(query, {
        filters: { AND: [{ agent_id: agentId }, { app_id: appId }] },
    });
}

关键收益：用户、智能体、会话、应用间完全隔离；可按用户/智能体/会话/应用任意层级查询；租户之间无记忆泄漏。 适用对象：多智能体工作流、多租户 SaaS——每层级的正确隔离。

源码级说明：这四个实体参数正是 main.py 中定义的 ENTITY_PARAMS = frozenset({"user_id", "agent_id", "app_id", "run_id"})。写入侧 add() 允许其作为顶层字段；检索/列举侧则必须装入 filters。TypeScript 端在 mem0.ts 对 user_id/userId 等做了同样的拒绝处理，提示改用 filters。

七、用例 6：个性化搜索（Personalized Search）

场景：把实时搜索结果与个人上下文融合。用 custom_instructions 从查询中推断偏好。

Python 实现

from mem0 import MemoryClient
from openai import OpenAI

mem0 = MemoryClient()
openai_client = OpenAI()

# 一次性配置：让 Mem0 从查询中推断偏好
mem0.project.update(
    custom_instructions="""Infer user preferences and facts from their search queries.
Extract dietary preferences, location, interests, and purchase history."""
)

def personalized_search(user_id: str, query: str, search_results: list) -> str:
    # 从记忆获取用户上下文
    memories = mem0.search(query, user_id=user_id, top_k=5)
    user_context = "\n".join([f"- {m['memory']}" for m in memories.get("results", [])])

    response = openai_client.chat.completions.create(
        model="gpt-5-mini",
        messages=[
            {"role": "system", "content": f"Personalize search results using user context:\n{user_context}"},
            {"role": "user", "content": f"Query: {query}\n\nSearch results:\n{search_results}"},
        ]
    )
    reply = response.choices[0].message.content

    # 存储查询以持续学习偏好
    mem0.add(
        [{"role": "user", "content": query}],
        user_id=user_id
    )
    return reply

# 用法
personalized_search("user_42", "best restaurants nearby", ["Restaurant A", "Restaurant B"])
# 随时间推移 Mem0 学会："用户偏好素食，住在 Austin"
# 之后的搜索自动个性化

TypeScript 实现

import MemoryClient from 'mem0ai';
import OpenAI from 'openai';

const mem0 = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! });
const openai = new OpenAI();

async function personalizedSearch(userId: string, query: string, searchResults: string[]): Promise<string> {
    const memories = await mem0.search(query, { filters: { user_id: userId }, topK: 5 });
    const context = memories.results?.map((m: any) => `- ${m.memory}`).join('\n') || '';

    const response = await openai.chat.completions.create({
        model: 'gpt-5-mini',
        messages: [
            { role: 'system', content: `Personalize results using user context:\n${context}` },
            { role: 'user', content: `Query: ${query}\nResults: ${searchResults.join(', ')}` },
        ],
    });
    const reply = response.choices[0].message.content!;

    await mem0.add([{ role: 'user', content: query }], { userId: userId });
    return reply;
}

关键收益：通过 custom_instructions 自动从查询学习偏好；可与任意搜索提供商配合（Tavily、Google、Bing）；零手动偏好配置，随使用不断优化。 适用对象：个性化搜索引擎、推荐系统——按用户定制搜索结果。

源码级说明：project.update(custom_instructions=...) 与用例 2 走同一 Project.update 入口；custom_instructions 属于 ProjectUpdateOptions 字段之一，用于控制事实抽取行为。

八、用例 7：邮件智能（Email Intelligence）

场景：用带丰富元数据的持久记忆来捕获、分类并回忆收件箱线程。

Python 实现

from mem0 import MemoryClient

client = MemoryClient()

def store_email(user_id: str, sender: str, subject: str, body: str, date: str):
    client.add(
        [{"role": "user", "content": f"Email from {sender}: {subject}\n\n{body}"}],
        user_id=user_id,
        metadata={"email_type": "incoming", "sender": sender, "subject": subject, "date": date}
    )

def search_emails(user_id: str, query: str):
    return client.search(
        query,
        filters={"AND": [{"user_id": user_id}, {"categories": {"contains": "email"}}]},
        top_k=10
    )

def get_emails_from_sender(user_id: str, sender: str):
    return client.get_all(
        filters={
            "AND": [
                {"user_id": user_id},
                {"metadata": {"contains": sender}}
            ]
        }
    )

# 用法
store_email("alice", "[e-mail]", "Q3 Budget Review", "Attached is the Q3 budget...", "2025-01-15")
store_email("alice", "[e-mail]", "Sprint Planning", "Here are the priorities...", "2025-01-16")

results = search_emails("alice", "budget discussions")
sender_emails = get_emails_from_sender("alice", "[e-mail]")

TypeScript 实现

import MemoryClient from 'mem0ai';

const client = new MemoryClient({ apiKey: process.env.MEM0_API_KEY! });

async function storeEmail(userId: string, sender: string, subject: string, body: string, date: string) {
    await client.add(
        [{ role: 'user', content: `Email from ${sender}: ${subject}\n\n${body}` }],
        { userId: userId, metadata: { email_type: 'incoming', sender, subject, date } }
    );
}

async function searchEmails(userId: string, query: string) {
    return client.search(query, {
        filters: { AND: [{ user_id: userId }, { categories: { contains: 'email' } }] },
        topK: 10,
    });
}

关键收益：丰富元数据支持多维查询（发件人、日期、主题）；分类过滤把邮件与其他记忆类型区分开；对全部邮件内容做语义搜索。 适用对象：收件箱管理、邮件自动化——带元数据过滤的可检索邮件记忆。

九、跨用例的四大通用模式

七大场景共享同一套底层骨架，掌握以下模式即可迁移到任意新场景。

模式 1：检索 → 生成 → 存储

每个用例都遵循同样的三步循环：

# 1. 检索相关上下文
memories = mem0.search(user_input, user_id=user_id)
context = "\n".join([m["memory"] for m in memories.get("results", [])])

# 2. 结合上下文生成
response = llm.generate(system_prompt=f"Context:\n{context}", user_input=user_input)

# 3. 存储本轮交互
mem0.add(
    [{"role": "user", "content": user_input}, {"role": "assistant", "content": response}],
    user_id=user_id
)

模式 2：用实体标识符划分作用域

用 user_id、agent_id、app_id、run_id 隔离记忆：

# 用户级：个人偏好
client.add(messages, user_id="alice")

# 会话级：单次会话内的对话
client.add(messages, user_id="alice", run_id="session_123")

# 智能体级：智能体专属知识
client.add(messages, agent_id="support_bot", app_id="helpdesk")

模式 3：丰富元数据用于过滤

挂接结构化元数据实现多维查询：

# 带元数据存储
client.add(messages, user_id="alice", metadata={"priority": "high", "source": "phone_call"})

# 按分类 + 元数据过滤
client.search("billing issues", filters={
    "AND": [{"user_id": "alice"}, {"categories": {"contains": "billing"}}]
})

模式 4：用自定义指令做领域化抽取

控制 Mem0 从对话中抽取什么：

client.project.update(
    custom_instructions="Extract medical conditions, medications, and allergies. Exclude billing info."
)

十、参数速查与源码对照

下表汇总了本文用例中反复出现的关键检索参数，取自 SearchMemoryOptions 的类型定义，可作为复制代码时的取值参考：

参数	类型	说明
filters	Dict	检索过滤条件，实体 ID（user_id 等）必须置于其中，支持 AND 复合
top_k	int	返回结果条数（如用例 3 的 5、用例 7 的 10）
threshold	float	最小相似度阈值，安全敏感场景调高（如用例 3 的 0.7）
rerank	bool	是否对结果重排序
fields	List[str]	响应中要包含的字段
categories	List[str]	按分类过滤
show_expired	bool	是否包含已过期记忆
reference_date	str / int	相对时间查询的参照日期（YYYY-MM-DD 或 Unix 时间戳）
latest_only	bool	是否只返回最新记忆版本
keyword_search	bool	是否启用关键词搜索

写入侧 add() 的可选字段则来自 AddMemoryOptions：filters、metadata、infer、custom_categories、custom_instructions、agent_custom_instructions、timestamp、expiration_date、structured_data_schema。

阅读源码的三条线索

1. 接口版本：add/search/get_all 均落在 /v3/ 路径（见 main.py），这与旧的顶层实体参数写法不兼容，是理解"为什么检索要放进 filters"的根因。
2. 参数校验：实体参数校验集中在 ENTITY_PARAMS（main.py），search() 与 get_all() 会在顶层出现这些参数时主动抛错，避免静默失败。
3. 项目配置：custom_categories、custom_instructions、decay、multilingual 统一走 Project.update 的 PATCH 请求，且要求 org_id/project_id 均可解析。

结语

从个性化陪伴到多租户隔离，Mem0 平台用例的本质是"用四个实体维度 + 丰富元数据 + 项目级抽取指令"这套组合，把跨会话上下文管理从应用代码中剥离出来。上述代码与参数均基于当前仓库的 Python 客户端、类型定义 与 项目管理器 源码核对，可直接作为落地这些场景的起点；运行前请确保 MEM0_API_KEY 已配置，且项目级接口所需组织权限就绪。