Современные большие языковые модели (LLM) по своей природе не обладают постоянной памятью (Stateless). В рамках одного диалога модель помнит контекст до тех пор, пока он помещается в активное контекстное окно (Context Window). Однако при очистке чата, создании новой сессии или длительном общении контекст неизбежно теряется либо его передача в каждом запросе начинает стоить неоправданно дорого в расходах на API-токены и замедляет отклик.
Классический подход RAG (Retrieval-Augmented Generation) решает задачу поиска по статичной внешней базе знаний (регламенты, статьи, каталоги товаров), но не предназначен для адаптивной персонализации. Если клиент два месяца назад сообщил, что использует сервер на Ubuntu 24.04, оплачивает счета с расчетного счета ООО и предпочитает краткие сводки без лишних вводных слов, стандартный RAG не сможет динамически обновлять и учитывать этот цифровой профиль при каждом новом диалоге.
Mem0 — ведущая open-source платформа долговременной адаптивной памяти для ИИ-агентов (более 68 000 звёзд на GitHub). В отличие от простого сохранения истории сообщений в базу данных, Mem0 использует многоуровневый интеллектуальный конвейер: при каждом сообщении модель автоматически извлекает ключевые факты (Fact Extraction), сравнивает их с уже сохраненными воспоминаниями в векторной базе, разрешает противоречия (Memory Update & Deduplication) и сохраняет компактные семантические векторы с привязкой к конкретному пользователю (user_id), агенту (agent_id) или сессии (run_id).
1. Архитектура стека Mem0, Qdrant и Ollama в Docker
Для создания полностью суверенного, локального и защищенного решения мы объединяем три ключевых компонента в единый стек Docker Compose:
| Компонент | Базовый образ / Стек | Сетевой порт | Роль в архитектуре памяти |
|---|---|---|---|
mem0-api |
Python 3.11 / FastAPI / mem0ai 2.2.1 |
127.0.0.1:8000 |
REST API сервис. Принимает запросы на добавление, поиск и удаление воспоминаний, управляет логикой скоринга и связывает LLM с векторной базой. |
qdrant |
qdrant/qdrant:v1.20.0 |
127.0.0.1:6333 |
Высокопроизводительная векторная СУБД на Rust. Хранит векторные представления фактов (эмбеддинги) с метаданными и мгновенно выполняет семантический HNSW-поиск по косинусному расстоянию. |
ollama |
ollama/ollama:0.40.15 |
127.0.0.1:11434 |
Локальный инференс-сервер. Обеспечивает генерацию эмбеддингов через nomic-embed-text (768 измерений) и извлечение фактов через квантованную модель qwen2.5:3b без передачи данных во внешние облака. |
nginx |
Nginx 1.24+ (системный на хосте) | 80, 443 |
Reverse Proxy с Let's Encrypt SSL. Терминирует HTTPS-трафик, проверяет Bearer-токены авторизации и защищает API от DDoS и брутфорса. |
Когда внешнее приложение (например, корпоративный Telegram-бот или CRM-система) отправляет диалоговую реплику в mem0-api, сервис обращается к ollama для генерации эмбеддинга текста, проверяет существующие векторы пользователя в qdrant, извлекает новые предпочтения и атомарно обновляет векторную коллекцию. При последующих вопросах агент за 20–50 миллисекунд получает из Qdrant только релевантный персонализированный контекст (top-k фактов) и передает его в системный промпт LLM.
2. Системные требования и выбор тарифа VDS
Требования к серверным ресурсам зависят от того, где выполняется инференс языковой модели и генерация эмбеддингов — локально на CPU вашего VDS или через внешние API (например, DeepSeek API или прокси):
| Режим работы | vCPU | RAM | NVMe-диск | Назначение и сценарий использования |
|---|---|---|---|---|
| Гибридный (Qdrant + Mem0 на VDS, внешнее LLM API) | 1–2 ядра | 2 ГБ – 4 ГБ | 20 ГБ | Вся память и векторные базы клиентов хранятся локально на сервере, а быстрые вызовы LLM идут через API. Минимальная стоимость аренды VDS (от 350 ₽/мес). |
| 100% Автономный On-Premise (Qdrant + Mem0 + Ollama CPU) | 4 ядра (3.3+ ГГц) | 8 ГБ – 16 ГБ | 40–60 ГБ | Полная независимость от внешних сервисов и интернета. Модель qwen2.5:3b и эмбеддер nomic-embed-text работают прямо на CPU сервера. |
🔒 Комплексные требования 152-ФЗ к долговременной памяти ИИ
Долговременная память ИИ-агентов неизбежно накапливает чувствительную информацию: ФИО клиентов, номера телефонов, истории заказов, финансовые лимиты и технические параметры инфраструктуры. Развертывание Mem0 и Qdrant на российских облачных VDS выполняет базовое территориальное требование ст. 18 ч. 5 Федерального закона № 152-ФЗ по первичной записи и хранению баз данных граждан РФ строго на территории страны.
Однако для полного юридического соответствия одного хостинга в РФ недостаточно. Оператору необходимо предусмотреть:
- Уведомление Роскомнадзора (ст. 22 152-ФЗ): Направить уведомление о начале обработки персональных данных через портал РКН или Госуслуги до запуска сервиса в production.
- Согласие субъекта (ст. 9 152-ФЗ): Получить явное информированное согласие пользователя (например, кнопка подтверждения оферты и политики конфиденциальности при первом запуске команды
/startв Telegram-боте). - Организационно-технические меры (ст. 19 152-ФЗ): Назначить ответственного за безопасность данных, утвердить локальную Политику обработки ПДн, модель угроз и разграничить доступ к API через токены.
3. Подготовка сервера и конфигурация стека Docker Compose
Создадим рабочую директорию проекта /opt/mem0-stack/ с изолированной структурой для сервиса API и данных:
sudo mkdir -p /opt/mem0-stack/{server,qdrant_storage,ollama_data}
cd /opt/mem0-stack
Создадим файл зависимостей и исходный код микросервиса API server/main.py. Сервис оборачивает библиотеку mem0ai в стандартизированный REST API на FastAPI с авторизацией по токену:
# /opt/mem0-stack/server/main.py
import os
import secrets
from typing import List, Optional, Dict, Any
from fastapi import FastAPI, HTTPException, Security, Depends
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel
from mem0 import Memory
API_BEARER_TOKEN = os.getenv("API_BEARER_TOKEN", "change_me_super_secret_token_2026")
QDRANT_HOST = os.getenv("QDRANT_HOST", "qdrant")
QDRANT_PORT = int(os.getenv("QDRANT_PORT", "6333"))
OLLAMA_BASE_URL = os.getenv("OLLAMA_BASE_URL", "http://ollama:11434")
LLM_MODEL = os.getenv("LLM_MODEL", "qwen2.5:3b")
EMBEDDER_MODEL = os.getenv("EMBEDDER_MODEL", "nomic-embed-text:latest")
config = {
"vector_store": {
"provider": "qdrant",
"config": {
"collection_name": "ai_agent_memories",
"host": QDRANT_HOST,
"port": QDRANT_PORT,
"embedding_model_dims": 768,
},
},
"llm": {
"provider": "ollama",
"config": {
"model": LLM_MODEL,
"temperature": 0.1,
"max_tokens": 1000,
"ollama_base_url": OLLAMA_BASE_URL,
},
},
"embedder": {
"provider": "ollama",
"config": {
"model": EMBEDDER_MODEL,
"ollama_base_url": OLLAMA_BASE_URL,
},
},
}
memory = Memory.from_config(config)
app = FastAPI(title="SysKit Mem0 Service", version="2.2.0")
security = HTTPBearer()
def verify_token(credentials: HTTPAuthorizationCredentials = Security(security)):
# Сравнение в константном времени для защиты от timing-атак
if not secrets.compare_digest(credentials.credentials, API_BEARER_TOKEN):
raise HTTPException(status_code=403, detail="Недействительный токен авторизации")
return credentials.credentials
class MessageItem(BaseModel):
role: str
content: str
class AddMemoryRequest(BaseModel):
messages: List[MessageItem]
user_id: Optional[str] = None
agent_id: Optional[str] = None
run_id: Optional[str] = None
metadata: Optional[Dict[str, Any]] = None
class SearchRequest(BaseModel):
query: str
user_id: Optional[str] = None
agent_id: Optional[str] = None
limit: Optional[int] = 5
@app.post("/memories", dependencies=[Depends(verify_token)])
def add_memory(req: AddMemoryRequest):
messages_payload = [{"role": m.role, "content": m.content} for m in req.messages]
res = memory.add(
messages=messages_payload,
user_id=req.user_id,
agent_id=req.agent_id,
run_id=req.run_id,
metadata=req.metadata,
)
return {"status": "success", "results": res}
@app.get("/memories", dependencies=[Depends(verify_token)])
def get_memories(user_id: Optional[str] = None, agent_id: Optional[str] = None):
filters = {}
if user_id:
filters["user_id"] = user_id
if agent_id:
filters["agent_id"] = agent_id
return {"memories": memory.get_all(filters=filters)}
@app.post("/search", dependencies=[Depends(verify_token)])
def search_memory(req: SearchRequest):
filters = {}
if req.user_id:
filters["user_id"] = req.user_id
if req.agent_id:
filters["agent_id"] = req.agent_id
results = memory.search(query=req.query, filters=filters, limit=req.limit)
return {"query": req.query, "results": results}
@app.delete("/memories/{memory_id}", dependencies=[Depends(verify_token)])
def delete_memory(memory_id: str):
memory.delete(memory_id=memory_id)
return {"status": "deleted", "memory_id": memory_id}
@app.get("/health")
def healthcheck():
return {"status": "ok", "service": "mem0-qdrant-ollama"}
Создадим легковесный server/Dockerfile:
# /opt/mem0-stack/server/Dockerfile
FROM python:3.11-slim
WORKDIR /app
ENV PYTHONUNBUFFERED=1
RUN pip install --no-cache-dir \
fastapi==0.115.6 \
uvicorn==0.34.0 \
pydantic==2.10.4 \
mem0ai==2.2.1 \
qdrant-client==1.13.2 \
ollama==0.4.7
COPY main.py /app/main.py
USER 1000:1000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
Сформируем файл переменных окружения /opt/mem0-stack/.env. Для генерации безопасного токена используйте генератор криптостойких паролей SysKit:
API_BEARER_TOKEN=sk_mem0_sec_2026_9b8df7a14e3c2805
QDRANT_HOST=qdrant
QDRANT_PORT=6333
OLLAMA_BASE_URL=http://ollama:11434
LLM_MODEL=qwen2.5:3b
EMBEDDER_MODEL=nomic-embed-text:latest
Теперь создадим основной манифест docker-compose.yml. Мы строго соблюдаем стандарты production: зафиксированные версии образов, лимиты памяти mem_limit, лимиты CPU, изолированная подсеть и привязка портов строго к 127.0.0.1 для исключения обхода фаервола UFW:
# /opt/mem0-stack/docker-compose.yml
services:
qdrant:
image: qdrant/qdrant:v1.20.0
container_name: mem0_qdrant
restart: unless-stopped
ports:
- "127.0.0.1:6333:6333"
volumes:
- ./qdrant_storage:/qdrant/storage
environment:
- QDRANT__SERVICE__TELEMETRY_DISABLED=true
mem_limit: 2048m
cpus: 2.0
healthcheck:
test: ["CMD-SHELL", "curl -f http://localhost:6333/readyz || exit 1"]
interval: 10s
timeout: 5s
retries: 5
networks:
- mem0-net
ollama:
image: ollama/ollama:0.40.15
container_name: mem0_ollama
restart: unless-stopped
ports:
- "127.0.0.1:11434:11434"
volumes:
- ./ollama_data:/root/.ollama
mem_limit: 4096m
cpus: 3.5
networks:
- mem0-net
mem0-api:
build:
context: ./server
dockerfile: Dockerfile
container_name: mem0_api
restart: unless-stopped
ports:
- "127.0.0.1:8000:8000"
env_file:
- .env
depends_on:
qdrant:
condition: service_healthy
mem_limit: 1024m
cpus: 1.5
networks:
- mem0-net
networks:
mem0-net:
driver: bridge
4. Запуск стека и загрузка легковесных моделей
Запустим контейнеры в фоновом режиме:
sudo docker compose up -d --build
sudo docker compose ps
После старта контейнера mem0_ollama загрузим необходимые компактные модели для эмбеддингов и извлечения фактов:
# Загрузка легковесной эмбеддинг-модели (размерность 768, вес всего ~274 МБ)
sudo docker exec -it mem0_ollama ollama pull nomic-embed-text
# Загрузка квантованной модели Qwen 2.5 (3B параметров, вес ~2.0 ГБ — отличный баланс качества на CPU)
sudo docker exec -it mem0_ollama ollama pull qwen2.5:3b
Проверим доступность API и статус здоровья:
curl -s http://127.0.0.1:8000/health
# Ожидаемый ответ: {"status":"ok","service":"mem0-qdrant-ollama"}
Рекомендуемые VDS-провайдеры
Отказоустойчивые сервера с быстрыми NVMe и каналом до 1 Гбит/с
Timeweb Cloud — Быстрые NVMe VDS
Высокочастотные процессоры 3.3+ ГГц для быстрого инференса эмбеддингов, быстрые NVMe-диски и стабильный сетевой канал 1 Гбит/с.
Selectel — Надежные облачные серверы
Аттестованные ЦОД уровня Tier III в Москве и Санкт-Петербурге с гарантированной изоляцией ресурсов для соответствия 152-ФЗ.
Beget — Удобные VDS для DevOps
Понятная панель управления, автоматические ежедневные бэкапы хоста и мгновенное развертывание стека Docker за пару кликов.
5. Настройка безопасного Nginx Reverse Proxy и SSL
Для защищенного подключения внешних сервисов (веб-приложений, Telegram-ботов, внешних CRM) к REST API настроим системный Nginx в качестве обратного прокси с бесплатным доверенным SSL-сертификатом Let's Encrypt и защитой от перегрузки запросами (Rate Limiting).
Установим Certbot и выпустим сертификат для вашего поддомена (например, mem0.yourdomain.ru):
sudo apt update && sudo apt install -y nginx certbot python3-certbot-nginx
# Выпуск сертификата Let's Encrypt
sudo certbot certonly --nginx -d mem0.yourdomain.ru --agree-tos --email admin@yourdomain.ru --no-eff-email
Создадим файл виртуального хоста /etc/nginx/sites-available/mem0.conf:
# Зона ограничения частоты запросов: до 15 запросов в секунду на IP
limit_req_zone $binary_remote_addr zone=mem0_rate:10m rate=15r/s;
# Редирект с HTTP на HTTPS
server {
listen 80;
listen [::]:80;
server_name mem0.yourdomain.ru;
location / {
return 301 https://$host$request_uri;
}
}
# Основной HTTPS-сервер
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name mem0.yourdomain.ru;
ssl_certificate /etc/letsencrypt/live/mem0.yourdomain.ru/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/mem0.yourdomain.ru/privkey.pem;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_prefer_server_ciphers off;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 1d;
client_max_body_size 16M;
location / {
limit_req zone=mem0_rate burst=10 nodelay;
proxy_pass http://127.0.0.1:8000;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
# Таймауты для ожидания ответа CPU-инференса
proxy_connect_timeout 60s;
proxy_send_timeout 120s;
proxy_read_timeout 120s;
}
}
Активируем конфигурацию, проверяем синтаксис и перезагружаем веб-сервер:
sudo ln -s /etc/nginx/sites-available/mem0.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
Для генерации индивидуальных конфигураций воспользуйтесь конфигуратором Nginx для FastAPI/Uvicorn, а проверить корректность цепочки сертификатов поможет SSL-чекер SysKit.
6. Практическая работа с REST API Mem0: извлечение и дедупликация
Протестируем ключевые возможности долговременной памяти через curl.
1. Добавление диалога и автоматическое извлечение фактов
Отправим фрагмент диалога, в котором пользователь делится контекстом своей работы:
curl -X POST https://mem0.yourdomain.ru/memories \
-H "Authorization: Bearer sk_mem0_sec_2026_9b8df7a14e3c2805" \
-H "Content-Type: application/json" \
-d '{
"user_id": "client_alex",
"messages": [
{"role": "user", "content": "Привет! Меня зовут Алексей, руковожу backend-отделом. Мы строим микросервисы на Go и PostgreSQL, серверы арендуем на Ubuntu 24.04 в Timeweb Cloud. Бюджет на инфраструктуру 70 000 руб/мес."}
]
}'
Модель qwen2.5:3b под капотом Mem0 автоматически разобьет этот текст на атомарные факты:
- «Имя пользователя: Алексей, руководитель backend-отдела»
- «Основной технологический стек: Go и PostgreSQL»
- «Использует операционную систему Ubuntu 24.04 на VDS Timeweb Cloud»
- «Ежемесячный бюджет на серверы составляет 70 000 рублей»
Для каждого факта генерируется 768-мерный эмбеддинг через nomic-embed-text и сохраняется в коллекцию Qdrant.
2. Семантический поиск по смыслу
В следующем диалоге агент может ничего не знать о том, что именно пользователь спрашивает, но выполнив поиск по смыслу, мгновенно достает нужный факт:
curl -X POST https://mem0.yourdomain.ru/search \
-H "Authorization: Bearer sk_mem0_sec_2026_9b8df7a14e3c2805" \
-H "Content-Type: application/json" \
-d '{
"user_id": "client_alex",
"query": "На каком дистрибутиве Linux работают серверы и какой стек баз данных?",
"limit": 3
}'
Сервис возвратит точные релевантные факты с коэффициентом схожести (score > 0.85) за доли секунды без необходимости прочесывать гигабайты сырых логов чатов.
3. Автоматическое разрешение противоречий и обновление памяти
Если через месяц Алексей сообщает: «Мы пересмотрели архитектуру: вместо Go перешли на Rust, а бюджет вырос до 120 000 руб», Mem0 находит старые векторы про Go и 70 000 руб, помечает их устаревшими и перезаписывает новыми данными, предотвращая галлюцинации и конфликты в ответах ассистента.
7. Интеграция с Telegram-ботом на Python (aiogram 3)
Рассмотрим практический шаблон Telegram-бота, который подключает долговременную память Mem0 к каждому пользователю по его уникальному user.id:
# bot_with_memory.py
import asyncio
import os
import aiohttp
from aiogram import Bot, Dispatcher, types
from aiogram.filters import CommandStart
BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "YOUR_BOT_TOKEN")
MEM0_API_URL = "https://mem0.yourdomain.ru"
MEM0_TOKEN = "sk_mem0_sec_2026_9b8df7a14e3c2805"
bot = Bot(token=BOT_TOKEN)
dp = Dispatcher()
async def get_user_context(user_id: str, query: str) -> str:
"""Извлечение персонализированных воспоминаний из Mem0"""
headers = {"Authorization": f"Bearer {MEM0_TOKEN}"}
payload = {"user_id": user_id, "query": query, "limit": 4}
try:
async with aiohttp.ClientSession() as session:
async with session.post(f"{MEM0_API_URL}/search", json=payload, headers=headers, timeout=5) as resp:
if resp.status == 200:
data = await resp.json()
memories = [item.get("memory") for item in data.get("results", []) if item.get("memory")]
if memories:
return "\n".join([f"- {m}" for m in memories])
except Exception as e:
print(f"Ошибка поиска в памяти: {e}")
return "Факты о пользователе пока не накоплены."
async def save_user_dialog(user_id: str, user_text: str, assistant_text: str):
"""Фоновое сохранение и извлечение новых фактов"""
headers = {"Authorization": f"Bearer {MEM0_TOKEN}"}
payload = {
"user_id": user_id,
"messages": [
{"role": "user", "content": user_text},
{"role": "assistant", "content": assistant_text}
]
}
try:
async with aiohttp.ClientSession() as session:
async with session.post(f"{MEM0_API_URL}/memories", json=payload, headers=headers, timeout=30) as resp:
await resp.json()
except Exception as e:
print(f"Ошибка сохранения памяти: {e}")
@dp.message(CommandStart())
async def cmd_start(message: types.Message):
await message.answer(
"Привет! Я ваш умный ассистент с адаптивной памятью Mem0.\n\n"
"🔒 Продолжая диалог, вы даете согласие на обработку персональных данных "
"в соответствии с ФЗ № 152-ФЗ. База знаний и история предпочтений хранятся "
"в защищенном контуре сервера на территории РФ.\n\n"
"Чем я могу помочь по вашему проекту?"
)
@dp.message()
async def handle_message(message: types.Message):
user_id = f"tg_{message.from_user.id}"
user_query = message.text
# 1. Извлекаем накопленный контекст пользователя
known_facts = await get_user_context(user_id, user_query)
# 2. Формируем системный промпт с памятью
system_prompt = (
"Ты — экспертный инженерный ИИ-ассистент SysKit. "
"Учитывай персональные факты о пользователе:\n"
f"{known_facts}\n"
"Отвечай кратко, профессионально и по делу."
)
# 3. Здесь выполняется вызов LLM (например, Ollama или внешнего API)
response_text = f"Я помню ваши предпочтения:\n{known_facts}\n\nЧем я могу помочь по вашему проекту?"
await message.answer(response_text)
# 4. В фоновой задаче асинхронно обновляем память Mem0
asyncio.create_task(save_user_dialog(user_id, user_query, response_text))
async def main():
await dp.start_polling(bot)
if __name__ == "__main__":
asyncio.run(main())
Теперь даже после перезапуска бота, перезагрузки сервера или создания новой диалоговой ветки ассистент мгновенно знает, кто с ним говорит, какой стек используется и какие требования у клиента.
8. Резервное копирование и обслуживание Qdrant
Векторная база данных Qdrant поддерживает горячее создание мгновенных слепков (Snapshots) без остановки контейнеров и без блокировки входящих поисковых запросов. Установим утилиту jq для надежного парсинга JSON-ответов API:
sudo apt update && sudo apt install -y jq
Создадим скрипт автоматического бэкапа /usr/local/bin/backup-mem0.sh:
sudo tee /usr/local/bin/backup-mem0.sh << 'EOF'
#!/usr/bin/env bash
set -Eeuo pipefail
BACKUP_DIR="/var/backups/mem0"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
RETENTION_DAYS=14
COLLECTION="ai_agent_memories"
mkdir -p "${BACKUP_DIR}"
echo "[$(date)] Инициализация создания снепшота Qdrant..."
# Запрос к API Qdrant на создание снепшота коллекции
SNAPSHOT_RESP=$(curl -s -X POST "http://127.0.0.1:6333/collections/${COLLECTION}/snapshots")
# Надежный парсинг имени снепшота через утилиту jq
SNAPSHOT_NAME=$(echo "${SNAPSHOT_RESP}" | jq -r '.result.name // empty')
if [ -n "${SNAPSHOT_NAME}" ]; then
echo "[$(date)] Снепшот ${SNAPSHOT_NAME} запрошен. Ожидание завершения формирования файла..."
# Qdrant выполняет создание снепшота в фоне: опрашиваем список через jq
for i in {1..30}; do
if curl -s "http://127.0.0.1:6333/collections/${COLLECTION}/snapshots" | jq -e --arg name "${SNAPSHOT_NAME}" '.result[]? | select(.name == $name)' >/dev/null 2>&1; then
break
fi
sleep 1
done
# Скачивание файла снепшота
curl -s "http://127.0.0.1:6333/collections/${COLLECTION}/snapshots/${SNAPSHOT_NAME}" -o "${BACKUP_DIR}/qdrant_${COLLECTION}_${TIMESTAMP}.snapshot"
gzip -9 "${BACKUP_DIR}/qdrant_${COLLECTION}_${TIMESTAMP}.snapshot"
echo "[$(date)] Снепшот ${SNAPSHOT_NAME} успешно выгружен и сжат."
fi
# Резервная копия конфигурационных файлов стека
tar -czf "${BACKUP_DIR}/mem0_configs_${TIMESTAMP}.tar.gz" -C /opt/mem0-stack docker-compose.yml .env server
# Защищаем архив с токенами строгими правами 0600 от чтения другими пользователями хоста
chmod 600 "${BACKUP_DIR}/mem0_configs_${TIMESTAMP}.tar.gz"
# Ротация: удаление дампов старше 14 дней
find "${BACKUP_DIR}" -type f -name "qdrant_*" -mtime +${RETENTION_DAYS} -delete
find "${BACKUP_DIR}" -type f -name "mem0_configs_*" -mtime +${RETENTION_DAYS} -delete
echo "[$(date)] Резервное копирование успешно завершено."
EOF
sudo chmod +x /usr/local/bin/backup-mem0.sh
Добавим задание в системный планировщик cron. По стандартам Debian/Ubuntu файлы в /etc/cron.d/ обязаны иметь права строго 0644 и завершаться символом новой строки (LF):
printf '0 4 * * * root /usr/local/bin/backup-mem0.sh >> /var/log/mem0-backup.log 2>&1\n' | sudo tee /etc/cron.d/mem0-backup
sudo chmod 644 /etc/cron.d/mem0-backup
Для надежной выгрузки бэкапов в удаленное S3-совместимое хранилище воспользуйтесь генератором bash-скриптов бэкапа томов Docker.
9. Чек-лист инженера SysKit перед релизом
📋 Чек-лист готовности слоя памяти Mem0 в production
- Сетевая безопасность: порты
6333(Qdrant),11434(Ollama) и8000(API) привязаны строго к127.0.0.1и недоступны из интернета без прокси. Проверьте хост через онлайн-сканер портов. - Защита эндпоинтов: эндпоинты
/memoriesи/searchтребуют обязательного заголовкаAuthorization: Bearerи защищены от несанкционированного доступа. - SSL и домен: веб-сервис открывается по HTTPS без ошибок валидации сертификата.
- Скорость поиска: выполнение семантического поиска
POST /searchзанимает не более 20–50 миллисекунд. - Резервное копирование: тестовый запуск
/usr/local/bin/backup-mem0.shсоздает валидный.snapshot.gzв директории/var/backups/mem0/.