ИИ и автоматизация 15 мин чтения 2026-11-08

Долговременная память для локальных ИИ-агентов: развертывание Mem0 и Qdrant на VDS в Docker Compose

Развертывание суверенного слоя долговременной памяти Mem0 с векторной базой Qdrant и Ollama на VDS в Docker Compose: архитектура Fact Extraction, REST API на FastAPI, интеграция с Telegram-ботом и защита персональных данных по 152-ФЗ.

Инженерная редакция SysKit Проверено инженерами SysKit.ru

Современные большие языковые модели (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 Гбит/с.

Конфигурация
2 vCPU 3.3 ГГц • 4 ГБ RAM • 40 ГБ NVMe • Трафик без лимита
Премиум Tier III
🔷

Selectel — Надежные облачные серверы

Аттестованные ЦОД уровня Tier III в Москве и Санкт-Петербурге с гарантированной изоляцией ресурсов для соответствия 152-ФЗ.

Конфигурация
4 vCPU • 8 ГБ RAM • 60 ГБ NVMe • ЦОД Tier III 152-ФЗ
Простота и надежность
🟠

Beget — Удобные VDS для DevOps

Понятная панель управления, автоматические ежедневные бэкапы хоста и мгновенное развертывание стека Docker за пару кликов.

Конфигурация
2 vCPU • 4 ГБ RAM • 35 ГБ NVMe • Безлимитный канал

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/.

Вопросы и ответы (FAQ)

Популярные вопросы вебмастеров и сисадминов по данной теме

Чем Mem0 отличается от классического RAG с поиском по корпоративным документам?
Классический RAG осуществляет семантический поиск по статичной корпоративной базе знаний (инструкции, регламенты, документация) и не адаптируется под конкретного человека. Mem0 — это динамический слой персонализированной памяти: он автоматически извлекает факты, привычки, предпочтения и роли из диалогов пользователя, объединяет их в цифровой профиль и обновляет при изменении предпочтений, предотвращая накопление устаревших и противоречивых сведений.
Можно ли использовать Mem0 без локальной Ollama, через внешние API?
Да. Если на VDS не хватает ресурсов для локального инференса (например, базовый тариф с 1–2 vCPU и 2 ГБ RAM), в конфигурации Mem0 достаточно указать провайдера OpenAI, DeepSeek, Anthropic или Groq. Векторная база Qdrant и сервис Mem0 продолжат работать на вашем VDS, а LLM-вызовы будут отправляться во внешние API.
Как соблюдается 152-ФЗ при использовании Mem0 для клиентов из РФ?
Векторная база данных Qdrant и сервис Mem0 развертываются на серверах российских хостинг-провайдеров (Timeweb Cloud, Selectel, Beget) в ЦОД Москвы или Санкт-Петербурга. Это напрямую закрывает первичное требование ч. 5 ст. 18 152-ФЗ по локализации баз данных граждан РФ на территории страны. При использовании локальной Ollama персональные данные не покидают сервер. Для комплексного соответствия 152-ФЗ оператору также требуется уведомить Роскомнадзор о начале обработки ПДн (ст. 22 152-ФЗ), получить информированное согласие пользователя (ст. 9 152-ФЗ) и утвердить локальную политику и модель угроз безопасности (ст. 19 152-ФЗ).
Как удалить персональные данные пользователя по запросу (право на забвение)?
В Mem0 предусмотрено гранулярное удаление по фильтру: через метод DELETE /memories/{memory_id} или через прямой API Qdrant удалением всех точек с фильтром payload.user_id == "target_user". Все связанные векторы и метаданные пользователя стираются без остатка.
Какой объем оперативной памяти занимает база Qdrant при росте числа пользователей?
Благодаря оптимизированному векторному индексу HNSW в Qdrant 100 000 текстовых воспоминаний (векторы размерности 768 float32) занимают в оперативной памяти около 300–400 МБ. При включении скалярного квантования (Scalar Quantization) в Qdrant потребление памяти снижается в 4 раза практически без потери точности поиска.

Читайте также в блоге SysKit

Смежные руководства и полезные технические статьи