Universal Memory Protocol: единый формат памяти для ИИ-агентов и приложений — VogueTech

Что нового

Universal Memory Protocol (UMP) — это общий протокол работы с памятью для ИИ-агентов. Его задача — сделать память такой же стандартизованной, как вызов инструментов через MCP (Model Context Protocol) и взаимодействие агентов через A2A (Agent2Agent).

Ключевые новшества:

Единый формат памяти
- Один тип записи: типизированный, с областью действия, би-временной, подписанный JSON.
- Использует существующие стандарты W3C PROV и DID, без придумывания нового словаря.
Транспорт-независимый протокол
- UMP работает поверх уже существующих транспортов: MCP, HTTP и любых других, где можно передать JSON.
- Для MCP это отдельный профиль (ump.* инструменты), который сразу понимают Claude Code, Codex, Cursor и другие MCP-клиенты.
Шесть базовых операций над памятью
- recall — поиск и извлечение памяти.
- remember — запись новой памяти.
- revise — корректировка существующей записи.
- forget — логическое «забывание» с учётом истории.
- get — получение записи по идентификатору.
- Дополнительно: feedback и subscribe как необязательные возможности.
Четыре уровня совместимости (conformance levels)
- Уровень L0: можно уже сейчас просто выгружать память в *.ump.json.
- Уровень L3: полноценный рантайм с полным набором операций.
- Это позволяет внедрять UMP поэтапно.
Поддержка разных хранилищ «из коробки»
В пакете @universalmemoryprotocol/core есть реализации для:
- локальных файлов (JsonFileStore, MarkdownDirectoryStore);
- SQL (Postgres, SQLite) плюс Redis как кэш;
- векторных движков (через VectorStore и адаптеры для Qdrant, Pinecone, Weaviate);
- движка Recall через отдельный адаптер.
Импорт существующей памяти
- Чтение AGENTS.md (открытый стандарт) и CLAUDE.md как процедурной памяти.
- Импорт Markdown-директорий и Obsidian-подобных хранилищ.
- Импорт не меняет исходные файлы, а создаёт черновики UMP с корректной провенанс-информацией.
Фокус на безопасности и контроле пользователя
- Би-временная модель: валидное время + время транзакции, записи не перезаписываются, а замыкаются и связываются с наследником.
- Подписи на основе DID: оператор, а не вендор модели, владеет ключом.
- Контент-адресуемые записи, проверяемость и отсутствие привязки к одному поставщику.
- Обязательный конвейер верификации, фильтрации и безопасной реинтерпретации перед использованием в промпте.
- Параметры согласия (retention, экспорт, редактирование) хранятся в самой записи и соблюдаются на всех границах.

Как это работает

Третий слой совместимости для агентов

Сейчас экосистема вокруг ИИ-агентов выглядит так:

MCP (Model Context Protocol) — стандартизирует вызов функций и чтение ресурсов агентами.
A2A (Agent2Agent) — описывает, как агенты находят и вызывают друг друга.
UMP (Universal Memory Protocol) — добавляет третий слой: единый способ, как агенты хранят и используют память между сессиями, между разными агентами и у разных вендоров.

Проблема, которую решает UMP: каждый рантайм агентов до этого реализовывал память по-своему. В итоге:

память лежит в файлах агентов, в проектах Claude/Codex, в экспортированных данных Recall, в папках Obsidian, в Postgres, Redis, SQLite и векторных базах;
каждый новый агент или хранилище начинали с нуля, не используя уже накопленное знание.

UMP задаёт один общий формат записи и небольшой набор операций. Любой новый агент или стор могут использовать уже существующую память, а не собирать её заново.

Формат записи

UMP-запись — это JSON-объект со следующими свойствами:

kind — тип памяти, например procedural или semantic.
body — содержимое, например { "text": "Use pnpm for this repository." }.
scope — область действия: владелец (owner), проект, видимость (visibility: private/public и т.д.).
provenance — откуда взялась запись: кто актор (actor), его тип (actor_kind: user, agent и др.), метод (method: user_correction и т.п.).
временная информация — валидное время и время транзакции, что позволяет хранить историю изменений без перезаписи.

Записи подписаны ключом на основе DID. Это позволяет:

проверять, кто создал и изменял запись;
переносить память между хранилищами без потери доверия;
не зависеть от конкретного вендора ИИ-модели.

Шесть операций

UMP описывает минимальный набор операций над памятью:

remember — создать запись;
recall — найти релевантные записи по запросу и области;
revise — обновить запись, не стирая историю;
forget — пометить запись как неактуальную с сохранением связи;
get — получить запись по идентификатору;
опционально feedback и subscribe для продвинутых сценариев.

Клиент, который реализует эти операции, укладывается примерно в 100 строк кода.

Транспорты: MCP и HTTP

UMP не придумывает свой транспорт. Он «ездит» поверх уже существующих:

MCP-профиль: основной вариант. Любой MCP-хост (Claude Code, Codex, Cursor и другие клиенты MCP) может использовать UMP через ump.* инструменты без изменения транспорта.
HTTP: простой JSON API, который можно вызвать из Python, Go, Swift, браузера и любых других клиентов.

Хранилища: «любая база может обслуживать UMP»

UMP — это протоколный слой, а не ставка на конкретную базу данных. В @universalmemoryprotocol/core уже есть реализации:

Файлы:
- JsonFileStore пишет память в memory.ump.json.
- MarkdownDirectoryStore создаёт человекочитаемые *.ump.md файлы — удобно для репозиториев и хранилищ в стиле Obsidian.
SQL + кэш:
- PostgresStore и SqliteStore используют существующие клиенты Postgres/SQLite.
- RedisStore добавляет кэш.
- В сам пакет не включены драйверы баз данных — вы подключаете свои.
Векторные базы:
- VectorStore плюс обёртки QdrantStore, PineconeStore, WeaviateStore.
- Векторные движки сами отвечают за качество поиска по эмбеддингам, UMP описывает только интерфейс.
Recall:
- адаптер для движка Recall, который выступает как более богатый механизм памяти за тем же интерфейсом UMP, без привязки к нему.

Импорт существующей памяти

UMP помогает забрать уже накопленную память из разных мест:

Файлы агентов:
- ump-import читает AGENTS.md (открытый стандарт) и CLAUDE.md как кандидатов на процедурную память.
- Путь к файлу сохраняется в provenance, чтобы всегда можно было отследить источник.
Заметки и хранилища:
- Утилита умеет обходить директории с Markdown и Obsidian-подобные хранилища.
- Это позволяет быстро нарастить локальное UMP-хранилище, не меняя привычную структуру заметок.

Импорт — это мост для перехода. После преобразования UMP остаётся основным форматом и интерфейсом работы с памятью.

Безопасность, доверие и управление

UMP стандартизирует:

структуру — единый формат JSON-записей;
provenance — кто создал, как, когда;
доступ — через чётко определённые операции;
доверие — через подписи и би-временную модель.

Интеллектуальные части — извлечение фактов, ранжирование, «старение» записей, слияние — остаются внутри конкретного движка памяти. Разные реализации могут конкурировать по качеству, оставаясь совместимыми.

Отдельный акцент — защита от инъекций:

память рассматривается как потенциально управляемый атакующим ввод;
спецификация требует конвейер: верификация → фильтрация → безопасная реинтерпретация при «ре-гидрации» в контекст модели;
записи не подставляются в промпт как строка без обработки;
параметры согласия и политики удаления/экспорта прошиваются в саму запись и проверяются при каждом переходе через границу.

Что это значит для вас

Для кого полезен UMP

Разработчики ИИ-агентов и рантаймов
- Если вы строите собственный агентный стек или IDE с агентами (по типу Claude Code, Codex, Cursor), UMP даёт готовый протокол памяти.
- Вместо того чтобы придумывать свою схему хранения, вы можете реализовать UMP и сразу получать совместимость с другими инструментами.
Команды, которые уже используют разные ИИ-инструменты
- Если у вас накопились AGENTS.md, CLAUDE.md, заметки в Obsidian, экспорт Recall, отдельные базы Postgres/Redis/векторные движки, UMP помогает собрать это в одну логическую память.
- Новый агент не начинает «с чистого листа», а продолжает историю.
Разработчики приложений с памятью пользователя
- Если вы строите приложение, которое должно помнить предпочтения пользователя, историю проектов, настройки, UMP даёт стандартный способ описать и хранить эти данные.
- Память можно переносить между сервисами без потери структуры и доверия.

Когда использовать UMP

Когда нужно делиться памятью между несколькими агентами или сервисами.
Когда важно хранить историю изменений фактов, а не только последнее состояние.
Когда вы хотите избежать привязки к одному вендору ИИ или одной базе данных.
Когда требуется жёсткий контроль над безопасностью памяти и происхождением данных.

Когда UMP может быть избыточен

Если у вас один простой бот без долгосрочной памяти, который не делится данными ни с кем, проще обойтись локальной базой или файлом.
Если вы не планируете мигрировать память между системами и не нуждаетесь в подписях и би-временной модели, UMP может показаться сложнее, чем нужно.

Доступность

UMP распространяется как npm-пакет @universalmemoryprotocol/core и HTTP-сервер, который можно поднять локально.
Технически его можно развернуть в любой инфраструктуре, где доступен Node.js и HTTP.
Ограничения по доступу в России зависят не от UMP, а от сопутствующих сервисов (например, MCP-хостов вроде Claude Code или Codex), которые могут требовать VPN.

Место на рынке

UMP занимает нишу стандарта памяти для ИИ-агентов. Если MCP уже стал де-факто способом описывать инструменты, а A2A — коммуникацию между агентами, UMP закрывает вопрос памяти.

По нескольким ключевым параметрам:

Стандартизация:
- MCP описывает функции и ресурсы, A2A — взаимодействие агентов, UMP — память.
- Вместе они формируют стек совместимости для агентных систем.
Привязка к хранилищу:
- В отличие от подходов, где память жёстко завязана на конкретную векторную базу или облачный сервис, UMP остаётся чистым протоколом.
- Можно использовать локальные файлы, SQL, Redis, Qdrant, Pinecone, Weaviate или Recall — всё через один интерфейс.
Совместимость с существующими практиками:
- Поддержка AGENTS.md, CLAUDE.md, Markdown-директорий и Obsidian-подобных хранилищ делает переход менее болезненным для команд, которые уже выстроили свои рабочие процессы.

Прямых числовых сравнений с конкретными конкурентами в описании UMP нет. Акцент идёт на совместимость, безопасность и переносимость памяти между агентами и хранилищами.

Установка

UMP поставляется как npm-пакет и может работать как MCP-сервер или HTTP-сервис.

MCP-хост (Claude Code, Codex, Cursor или любой MCP-клиент)

Конфигурация MCP-хоста для UMP-сервера памяти:

// MCP host config: Claude Code, Codex, Cursor, or any MCP client.
{
  "mcpServers": {
    "ump": {
      "command": "npx",
      "args": ["-y", "@universalmemoryprotocol/core", "ump-memory"]
    }
  }
}

После этого MCP-клиент сможет вызывать UMP как набор инструментов ump.*.

Как запустить

TypeScript / Node.js: локальный UMP-сервер и работа с памятью

Пример кода на TypeScript, который:

генерирует пару ключей;
открывает локальное JSON-хранилище memory.ump.json;
поднимает UMP-сервер;
записывает процедурную память;
выполняет запрос к памяти.

import {
  JsonFileStore,
  UmpServer,
  generateKeyPair,
} from "@universalmemoryprotocol/core";

const key = generateKeyPair();
const store = await JsonFileStore.open(".ump/memory.ump.json");

const ump = new UmpServer({
  name: "my-agent",
  version: "1.0.0",
  conformance: "L2",
  store,
  key,
});

await ump.remember({
  kind: "procedural",
  body: { text: "Use pnpm for this repository." },
  scope: {
    owner: key.did,
    project: "github.com/acme/app",
    visibility: "private",
  },
  provenance: {
    actor: key.did,
    actor_kind: "user",
    method: "user_correction",
  },
});

const memories = await ump.recall({
  query: "package manager",
  scope: {
    owner: key.did,
    project: "github.com/acme/app",
  },
});

HTTP-сервер: любой язык через JSON

Запуск HTTP-сервера UMP в терминале:

# Any language: expose JSON over HTTP.
UMP_HTTP=4000 npx -y @universalmemoryprotocol/core ump-memory

После запуска сервер доступен по HTTP. Пример клиента на Python, который:

получает owner из /.well-known/ump.json;
записывает семантическую память о предпочтениях пользователя;
делает запрос по этим предпочтениям.

import requests

base = "http://localhost:4000"
owner = requests.get(f"{base}/.well-known/ump.json").json()["owner"]

requests.post(
    f"{base}/ump/remember",
    json={
        "kind": "semantic",
        "body": {"text": "User prefers concise release notes."},
        "scope": {
            "owner": owner,
            "project": "github.com/acme/app",
            "visibility": "private",
        },
        "provenance": {
            "actor": owner,
            "actor_kind": "user",
            "method": "user_correction",
        },
    },
).raise_for_status()

hits = requests.post(
    f"{base}/ump/recall",
    json={
        "query": "release note preference",
        "scope": {
            "owner": owner,
            "project": "github.com/acme/app",
        },
    },
).json()["results"]

Когда использовать MCP-сервер, SDK или HTTP

MCP-сервер — если вам нужна память для агента прямо сейчас в окружении вроде Claude Code, Codex, Cursor.
TypeScript SDK — если вы строите собственное приложение или рантайм агента с поддержкой памяти и хотите тесную интеграцию с Node.js.
HTTP — если клиент написан на Python, Go, Swift, работает в браузере или в любой другой среде, где удобно отправлять JSON по HTTP.