# 1. 建虚拟环境（Python 3.10–3.12）
python3 -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\activate

# 2. 安装
pip install -U mem0ai

# 3.（推荐）启用混合检索的 NLP 扩展：BM25 关键词 + 实体抽取
pip install -U "mem0ai[nlp]"
python -m spacy download en_core_web_sm

# 4. Qdrant 用户：额外安装 fastembed 以启用 BM25 稀疏向量
pip install fastembed

# 5. 设置默认提供商的 Key
export OPENAI_API_KEY="sk-..."

from mem0 import Memory

m = Memory()  # 默认：gpt-5-mini 提取 + text-embedding-3-small + 本地 Qdrant(/tmp/qdrant) + SQLite 历史(~/.mem0/history.db)

m.add([{"role": "user", "content": "我喜欢在早上喝咖啡并散步"}], user_id="alex")
results = m.search("alex 的习惯是什么？", filters={"user_id": "alex"})
print(results)

python check.py

npm install mem0ai

import { Memory } from "mem0ai/oss";  // 注意：OSS 入口是 /oss 子路径，不是 "mem0ai"

const memory = new Memory();
await memory.add("I love hiking on weekends", { userId: "alex" });
const res = await memory.search("What does Alex like?", { filters: { userId: "alex" } });
console.log(res);

# 0. 前置：安装 Docker Engine + Compose v2 与 make；克隆仓库
git clone https://github.com/mem0ai/mem0.git
cd mem0/server

# 1. 配置环境变量
cp .env.example .env
# 至少填写：OPENAI_API_KEY 与 POSTGRES_PASSWORD（不设置则 compose 拒绝启动）
openssl rand -base64 48   # 生成一个 JWT_SECRET，写入 .env 的 JWT_SECRET=
cat >> .env <<EOF
POSTGRES_PASSWORD=你的强密码
JWT_SECRET=$(openssl rand -base64 48)
EOF

# 2A. Agent-first：一条命令起栈 + 建管理员 + 发第一个 API Key
make bootstrap
# 可自定义管理员凭据：
# make bootstrap EMAIL=admin@company.com PASSWORD='strong-password' NAME='Admin'

# 2B. Browser-first：只起栈，然后浏览器里走一次性 setup 向导
make up
# 打开 http://localhost:3000 ，首次会重定向到 /setup 向导

git clone https://github.com/mem0ai/mem0.git
cd mem0\server
copy .env.example .env
# 编辑 .env：填 OPENAI_API_KEY、POSTGRES_PASSWORD、JWT_SECRET
docker compose up -d --build
# 打开 http://localhost:3000 走 setup 向导，或用 curl 调 /auth/register 建管理员

docker pull mem0/mem0-api-server
# 或本地构建
cd mem0/server && docker build -t mem0-api-server .

# 注意：此路径假设 Postgres(pgvector) 已在 POSTGRES_HOST:POSTGRES_PORT 可达
docker run -p 8000:8000 --env-file .env mem0-api-server
# API 在 http://localhost:8000 ，OpenAPI 文档在 /docs

cd mem0/server
pip install -r requirements.txt
export POSTGRES_HOST=... POSTGRES_PORT=5432 POSTGRES_DB=... POSTGRES_USER=... POSTGRES_PASSWORD=...
export OPENAI_API_KEY=... JWT_SECRET=$(openssl rand -base64 48)
alembic upgrade head          # 初始化/迁移数据库表
uvicorn main:app --host 0.0.0.0 --port 8000

from mem0 import Memory

config = {
    "llm": {
        "provider": "ollama",              # 换成 openai/anthropic/gemini 等即可切换
        "config": {
            "model": "llama3.1:8b",
            "temperature": 0.1,            # 提取保持低温，避免漏抓事实
            "ollama_base_url": "http://localhost:11434",
            "max_tokens": 2000,
        },
    },
    "embedder": {
        "provider": "ollama",
        "config": {
            "model": "nomic-embed-text",
            "ollama_base_url": "http://localhost:11434",
            "embedding_dims": 768,         # 必须与向量库集合维度一致
        },
    },
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333,
            "collection_name": "memories",  # 生产必填，隔离租户
            "embedding_model_dims": 768,
            "on_disk": True,
        },
    },
    "custom_instructions": "重点记录用户的长期偏好、项目决策与联系方式",
}

memory = Memory.from_config(config)

cd mem0/server
make up          # 起栈并等待健康检查
make health      # 检查 API/仪表盘/Postgres 状态
make logs        # 跟踪日志（等价 docker compose logs -f）
make down        # 停栈（保留数据卷）
make clean       # 停栈并删除数据卷（毁数据！）

# /etc/systemd/system/mem0-server.service
[Unit]
Description=Mem0 Self-hosted REST Server
After=network.target postgresql.service

[Service]
User=mem0
WorkingDirectory=/opt/mem0/server
EnvironmentFile=/opt/mem0/server/.env
ExecStart=/opt/mem0/.venv/bin/uvicorn main:app --host 0.0.0.0 --port 8000 --workers 2
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now mem0-server
systemctl status mem0-server

nssm install Mem0Server "C:\path\to\.venv\Scripts\uvicorn.exe" "main:app --host 0.0.0.0 --port 8000"
nssm set Mem0Server AppDirectory C:\opt\mem0\server
nssm set Mem0Server AppEnvironmentExtra JWT_SECRET=xxx OPENAI_API_KEY=xxx POSTGRES_HOST=xxx
nssm start Mem0Server

# 在 server/docker-compose.yaml 的 mem0 与 mem0-dashboard 服务下加：
restart: unless-stopped
# postgres 服务已有 restart: on-failure，可一并改为 unless-stopped

server {
    listen 443 ssl;
    server_name mem0.example.com;

    location / {
        proxy_pass http://127.0.0.1:8888;      # API
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

export OPENAI_API_KEY=sk-...
pip install mem0ai

from mem0 import Memory

m = Memory()
m.add([{"role": "user", "content": "Hi, I'm Alex. I love basketball and gaming."}], user_id="alex")
print(m.search("What do you know about me?", filters={"user_id": "alex"}))

{
  "results": [
    {
      "id": "mem_123abc",
      "memory": "Name is Alex. Enjoys basketball and gaming.",
      "user_id": "alex",
      "categories": ["personal_info"],
      "created_at": "2026-10-22T04:40:22.864647-07:00",
      "score": 0.89
    }
  ]
}

from openai import OpenAI
from mem0 import Memory

openai_client = OpenAI()
memory = Memory()

def chat_with_memories(message: str, user_id: str = "default_user") -> str:
    relevant_memories = memory.search(query=message, filters={"user_id": user_id}, top_k=3)
    memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories["results"])
    system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}"
    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
    response = openai_client.chat.completions.create(model="gpt-5-mini", messages=messages)
    assistant_response = response.choices[0].message.content
    messages.append({"role": "assistant", "content": assistant_response})
    memory.add(messages, user_id=user_id)   # 对话结束后异步写入新记忆
    return assistant_response

# 1. 首个管理员注册（仅在没有用户时可用，之后返回 403）
curl -X POST http://localhost:8888/auth/register \
  -H "Content-Type: application/json" \
  -d '{"name": "Admin", "email": "admin@example.com", "password": "strong-password"}'

# 2. 登录拿 JWT
curl -X POST http://localhost:8888/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email": "admin@example.com", "password": "strong-password"}'
# 返回 access_token / refresh_token；过期后 POST /auth/refresh 换新

# 3. 用 JWT 写入记忆
curl -X POST http://localhost:8888/memories \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -d '{"messages": [{"role": "user", "content": "I love pizza."}], "user_id": "alice"}'

# 4. 用按用户 API Key（m0sk_...）检索
curl -X POST http://localhost:8888/search \
  -H "Content-Type: application/json" \
  -H "X-API-Key: m0sk_your_key_here" \
  -d '{"query": "vegetable pizza", "user_id": "alice"}'

# 5. 打开打分解释模式，查看混合检索的评分信号
curl -X POST http://localhost:8888/search \
  -H "Content-Type: application/json" \
  -H "X-API-Key: m0sk_your_key_here" \
  -d '{"query": "vegetable pizza", "user_id": "alice", "explain": true}'

# 6. 列出 / 更新 / 删除
curl -X GET "http://localhost:8888/memories?user_id=alice" -H "X-API-Key: m0sk_your_key_here"
curl -X PUT http://localhost:8888/memories/<memory_id> -H "X-API-Key: m0sk_your_key_here" \
  -H "Content-Type: application/json" -d '{"text": "喜欢蔬菜披萨"}'
curl -X DELETE http://localhost:8888/memories/<memory_id> -H "X-API-Key: m0sk_your_key_here"

cd server
make prune-logs                              # 默认保留 30 天
make prune-logs REQUEST_LOG_RETENTION_DAYS=7 # 自定义保留窗口

# 写入时带 metadata
m.add(messages, user_id="alice", metadata={"category": "movie_recommendations"})
# 按元数据过滤检索（OSS 任意键可过滤，不受 Platform 白名单限制）
m.search("推荐电影", filters={"user_id": "alice", "category": "movie_recommendations"})
# 范围算子（实际可用性取决于所选向量库）
m.search("q", filters={"user_id": "alice", "created_at": {"gte": "2026-01-01"}})
# 原文直存（跳过 LLM 提取，注意会与 infer=True 混出重复）
m.add("原始记录文本", user_id="alice", infer=False)
# 过期时间
m.add(messages, user_id="alice", expiration_date="2030-01-31")
# 自定义提取指令
config = {"custom_instructions": "只记录用户明确表达的长期偏好，忽略寒暄"}

import asyncio
from mem0 import AsyncMemory

memory = AsyncMemory()

async def handler(message: str):
    hits = await memory.search(message, filters={"user_id": "u1"})
    await memory.add([{"role": "user", "content": message}], user_id="u1")
    return hits["results"]

asyncio.run(handler("我想订周五的会议室"))

pip install mem0-cli          # 或 npm install -g @mem0/cli
mem0 init                      # 初始化（默认走托管平台，Key 存 ~/.mem0/config.json，权限 0600）
mem0 add "Prefers dark mode and vim keybindings" --user-id alice
mem0 search "What does Alice prefer?" --user-id alice

pip show mem0ai                 # 库版本
npm list mem0ai
docker compose -f server/docker-compose.yaml images   # 容器镜像版本
curl http://localhost:8888/docs -o /dev/null -w '%{http_code}\n'   # 服务健康

# 库模式
pip install --upgrade mem0ai            # 大版本升级前先读迁移指南
pip install --upgrade "mem0ai[nlp]" && python -m spacy download en_core_web_sm
npm install mem0ai@latest

# 自托管服务端
cd mem0
git pull
cd server
make up        # 或 docker compose up -d --build；API 容器启动时自动跑 alembic 迁移

# 库模式回滚到指定版本
pip install mem0ai==2.1.0      # 以 PyPI 实际存在的版本号为准
npm install mem0ai@<version>

# 服务端回滚：checkout 旧 commit 后重建
cd mem0 && git checkout <旧 tag 或 commit>
cd server && docker compose up -d --build

# 自托管栈
cd mem0/server
make down                       # 停容器
docker compose down -v          # 删除容器+postgres_db 数据卷（毁数据）
docker rmi mem0/mem0-api-server 2>/dev/null
docker image prune -f
rm -rf ~/.mem0                  # 库模式本地数据：Qdrant 向量在 /tmp/qdrant，历史库在 ~/.mem0/history.db
pip uninstall mem0ai mem0-cli -y
npm uninstall -g mem0ai @mem0/cli
# systemd 方式另需：sudo systemctl disable --now mem0-server && sudo rm /etc/systemd/system/mem0-server.service

# ---- 安装 ----
pip install -U mem0ai                        # Python 库
pip install -U "mem0ai[nlp]" && python -m spacy download en_core_web_sm   # 混合检索 NLP 扩展
pip install fastembed                        # Qdrant BM25 需要
npm install mem0ai                           # Node SDK
pip install mem0-cli                         # CLI

# ---- 自托管 ----
git clone https://github.com/mem0ai/mem0.git && cd mem0/server
cp .env.example .env                         # 必填 OPENAI_API_KEY / POSTGRES_PASSWORD / JWT_SECRET
make bootstrap                               # 一键：起栈+管理员+首个 API Key
make up                                      # 起栈，浏览器走 setup 向导
make health | make logs | make down | make clean
make reset-admin-password EMAIL=... PASSWORD=...
make prune-logs [REQUEST_LOG_RETENTION_DAYS=7]
docker pull mem0/mem0-api-server             # 仅 API 镜像
docker run -p 6333:6333 qdrant/qdrant        # 本地 Qdrant

# ---- API 快捷调用（自托管，无 /v1 前缀）----
curl -X POST http://localhost:8888/auth/login -H "Content-Type: application/json" \
  -d '{"email":"admin@example.com","password":"..."}'
curl -X POST http://localhost:8888/memories -H "X-API-Key: m0sk_..." -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"..."}],"user_id":"alice"}'
curl -X POST http://localhost:8888/search -H "X-API-Key: m0sk_..." -H "Content-Type: application/json" \
  -d '{"query":"...","user_id":"alice"}'
curl http://localhost:8888/memories?user_id=alice -H "X-API-Key: m0sk_..."
# 浏览器：http://localhost:3000 仪表盘 / http://localhost:8888/docs OpenAPI

# ---- 升级/回滚/卸载 ----
pip install --upgrade mem0ai
pip install mem0ai==<version>
cd mem0 && git pull && cd server && make up
docker compose down -v                        # 危险：清空全部数据
pip uninstall mem0ai -y && rm -rf ~/.mem0 /tmp/qdrant