Как научить ИИ помнить: Memory Store в Microsoft Foundry на реальном примере — VogueTech

Что нового

Microsoft добавила в Foundry Agent Service новую подсистему долговременной памяти — Memory Store (preview). Это управляемое хранилище, которое позволяет агентам на базе GPT‑4.1:

помнить информацию между сессиями, устройствами и разговорами;
хранить не просто историю чата, а структурированные типы памяти:
- профиль пользователя (предпочтения, устойчивые привычки);
- сжатые сводки диалогов (chat summary);
изолировать память по пользователю через scope (например, user_123 или {{$userId}} из авторизации);
автоматически использовать память через отдельный инструмент MemorySearchPreviewTool.

Memory Store уже можно попробовать в режиме превью в рамках Microsoft Foundry при наличии:

подписки Azure;
проекта Microsoft Foundry;
развёрнутых моделей:
- чат‑модель уровня gpt-4.1;
- модель эмбеддингов text-embedding-3-small.

На базе этих компонентов Microsoft показывает рабочий пример: агент‑бариста, который запоминает, что пользователь любит dark roast и в следующей сессии сам предлагает «обычный» заказ.

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

Базовые сущности

Memory Store
Контейнер, где живут все «воспоминания» агента. Для каждого агента Microsoft рекомендует поднимать отдельный Memory Store — так проще контролировать, что и кому доступно, и быстрее выполнять поиск.

Scope
Идентификатор, который определяет, кому принадлежит память:

кастомный ID, например user_123;
или автоматическое сопоставление через {{$userId}} из заголовков аутентификации.

Это даёт жёсткое разделение: память одного пользователя не утекает к другому.

Типы памяти

User profile memory
Долгоживущая информация о человеке:
- вкусы (например, «люблю тёмную обжарку»);
- устойчивые привычки;
- повторяющиеся выборы.
Эти данные подмешиваются в контекст в начале разговора как статическая часть промпта.
Chat summary memory
Сжатые сводки прошлых диалогов. Агент не хранит весь лог, а опирается на краткие выводы, которые легче искать и дешевле подавать в модель.

Технический пайплайн

Вы создаёте Memory Store с указанием:
- чат‑модели: gpt-4.1;
- модели эмбеддингов: text-embedding-3-small;
- опций:
  - chat_summary_enabled=True;
  - user_profile_enabled=True;
  - user_profile_details="Avoid sensitive data like age, finance, or credentials" — рекомендация не писать в профиль возраст, финансы и доступы.
Создаёте агента с типом PromptAgentDefinition и подключаете к нему MemorySearchPreviewTool с параметрами:
- memory_store_name="coffee_memory_store";
- scope="user_123";
- update_delay=1 — минимальная задержка перед обновлением памяти.
Агент работает через OpenAI‑совместимый клиент Foundry (project_client.get_openai_client()):
- вы создаёте разговор openai_client.conversations.create();
- отправляете запрос через openai_client.responses.create(...) с agent_reference.
После того как пользователь сообщает предпочтение («I prefer dark roast coffee»), агент:
- обрабатывает запрос моделью gpt‑4.1;
- через MemorySearchPreviewTool отправляет релевантные факты в Memory Store;
- сохраняет их как профильную память.
Между сессиями нужно подождать, пока память «проглотится». В демо автор делает time.sleep(65) — это даёт время на debounce и запись в хранилище.
В новой сессии вы создаёте другой conversation и спрашиваете: «Order my usual coffee». Агент:
- подтягивает профильную память по scope user_123;
- видит, что пользователь любит dark roast;
- отвечает с учётом этого знания.

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

Когда Memory Store полезен

Если вы делаете продуктовое ИИ‑решение на базе Microsoft Foundry, Memory Store закрывает сразу несколько типичных задач:

Персонализированные ассистенты
- Внутренний помощник для сотрудников, который помнит любимые инструменты, проекты, формат отчётов.
- Клиентский ассистент, который знает, что пользователь пьёт латте без сиропа и заказывает его каждое утро.
Долгие сценарии с продолжением
- Обучающие треки: ассистент запоминает, на чём пользователь остановился, какие темы уже проходил.
- Онбординг: бот помнит, какие шаги сотрудник уже выполнил.
Поддержка и сервис
- Саппорт‑бот, который видит историю обращений и не задаёт каждый раз одни и те же вопросы.
- Внутренний IT‑ассистент, который помнит, какие проблемы у этого пользователя возникают чаще всего.
Рекомендательные сценарии
- Подбор курсов, инструментов, контента с учётом прошлых выборов.
- Персональные подборки товаров или услуг.

Где Memory Store не нужен или избыточен

Разовые чаты без возврата. Если пользователь заходит на страницу один раз и не возвращается, долговременная память не даёт выгоды.
Жёстко регламентированные процессы. Там, где важнее точное следование инструкции, чем персонализация, достаточно обычного контекста сессии.
Сценарии с чувствительными данными, если у вас нет чёткого плана по комплаенсу и управлению доступом. Память легко превратить в «чёрный ящик» с лишними персональными данными.

Ограничения и нюансы

Требуется Azure и Microsoft Foundry. Если у вас нет доступа к этим сервисам или они заблокированы по региональным/корпоративным правилам, использовать Memory Store не получится.
Нужна развёрнутая инфраструктура. Минимальный набор: Azure subscription, Foundry‑проект, деплой gpt‑4.1 и text‑embedding‑3-small.
Задержка записи. В демо используется пауза в 65 секунд перед проверкой памяти. В боевом продукте нужно учитывать, что запись не мгновенная и подстраивать UX.
Ответственность за содержимое памяти лежит на вас. Microsoft прямо советует не хранить возраст, финансы и учётные данные в профиле.

Если вы уже сидите на Azure и смотрите в сторону агентных систем, Memory Store — логичное продолжение: меньше кода вокруг БД и векторных хранилищ, больше логики на уровне агента.

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

Memory Store решает ту же задачу, что и внешние векторные БД и кастомные «memory layers» вокруг GPT‑моделей: хранить знания о пользователях и прошлых диалогах. Но есть важные отличия:

Память встроена прямо в Microsoft Foundry Agent Service. Не нужно отдельно поднимать векторную базу, писать коннекторы и клеить всё в промптах.
Memory Store завязан на конкретные модели (gpt-4.1 и text-embedding-3-small) и агенты Foundry. Это плюс, если вы уже в экосистеме Azure, и минус, если хотите полностью мульти‑облачное решение.
Управление памятью идёт через отдельный MemorySearchPreviewTool. Это отличается от подхода, где вы вручную пишете логику: сформировать эмбеддинг, положить в БД, вытащить по косинусному расстоянию, подмешать в промпт.

Прямых цифр по скорости, стоимости запросов или сравнению с аналогами в других платформах в материале нет. Но архитектурно это предложение для тех, кто уже выбрал Microsoft Foundry как основную среду для агентных решений.

Установка

Для запуска демо‑агента с памятью понадобится:

Python 3.8+;
подписка Azure;
проект Microsoft Foundry;
деплой моделей gpt-4.1 и text-embedding-3-small.

Установка зависимостей:

pip install azure-ai-projects azure-identity openai python-dotenv
``

Далее создайте файл `.env` с подключением к Foundry:

```bash
FOUNDRY_PROJECT_ENDPOINT=your_connection_string_here

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

Ниже — полный рабочий пример из Microsoft, который создаёт Memory Store, агента и проверяет, что он запоминает предпочтение по кофе.

import os
import time
from dotenv import load_dotenv

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    MemoryStoreDefaultDefinition,
    MemoryStoreDefaultOptions,
    MemorySearchPreviewTool,
    PromptAgentDefinition,
)
from azure.identity import DefaultAzureCredential

# ---------------------------------------------------
# Load environment variables
# ---------------------------------------------------
load_dotenv()

FOUNDRY_PROJECT_ENDPOINT = os.getenv("FOUNDRY_PROJECT_ENDPOINT")
if not FOUNDRY_PROJECT_ENDPOINT:
    raise ValueError("FOUNDRY_PROJECT_ENDPOINT not set in .env file")

# ---------------------------------------------------
# Create Foundry Project Client
# ---------------------------------------------------
project_client = AIProjectClient(
    endpoint=FOUNDRY_PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)

openai_client = project_client.get_openai_client()

# ---------------------------------------------------
# STEP 1: Create Memory Store
# ---------------------------------------------------
print("Creating memory store...")

options = MemoryStoreDefaultOptions(
    chat_summary_enabled=True,
    user_profile_enabled=True,
    user_profile_details="Avoid sensitive data like age, finance, or credentials",
)

definition = MemoryStoreDefaultDefinition(
    chat_model="gpt-4.1",
    embedding_model="text-embedding-3-small",
    options=options,
)

# Try to create memory store, or get existing one if it already exists
try:
    memory_store = project_client.beta.memory_stores.create(
        name="coffee_memory_store",
        definition=definition,
        description="Memory store for coffee preferences",
    )
    print(f"✅ Memory store created: {memory_store.name}")
except Exception as e:
    if "already exists" in str(e):
        print("Memory store already exists, using existing one...")
        # Get the existing memory store
        memory_stores = project_client.beta.memory_stores.list()
        memory_store = None
        for store in memory_stores:
            if store.name == "coffee_memory_store":
                memory_store = store
                break
        if memory_store:
            print(f"✅ Using existing memory store: {memory_store.name}")
        else:
            print("❌ Could not find existing memory store")
            raise e
    else:
        raise e

# ---------------------------------------------------
# STEP 2: Create Agent with Memory
# ---------------------------------------------------
print("Creating agent with memory...")

memory_tool = MemorySearchPreviewTool(
    memory_store_name="coffee_memory_store",
    scope="user_123",
    update_delay=1,
)

# Try to create agent, or get existing one if it already exists
try:
    agent = project_client.agents.create_version(
        agent_name="CoffeeAgent",
        definition=PromptAgentDefinition(
            model="gpt-4.1",
            instructions="You are a helpful coffee assistant with memory. You can remember customer preferences and order history across conversations. When a customer mentions their preferences, remember them for future orders.",
            tools=[memory_tool],
        ),
    )
    print(f"✅ Agent created: {agent.name}")
except Exception as e:
    if "already exists" in str(e) or "Agent with name" in str(e):
        print("Agent already exists, using existing one...")
        # Get the existing agent
        agents = project_client.agents.list_versions(agent_name="CoffeeAgent")
        if agents:
            agent = agents[0]  # Use the first/latest version
            print(f"✅ Using existing agent: {agent.name}")
        else:
            print("❌ Could not find existing agent")
            raise e
    else:
        raise e

# ---------------------------------------------------
# STEP 3: First Conversation (Learning)
# ---------------------------------------------------
print("Starting first conversation...")

conversation = openai_client.conversations.create()

response = openai_client.responses.create(
    input="I prefer dark roast coffee",
    conversation=conversation.id,
    extra_body={
        "agent_reference": {
            "name": agent.name,
            "type": "agent_reference",
        }
    },
)

print("🧠 Agent response:", response.output_text)

print("Waiting for memory to be stored...")
time.sleep(65)  # allow debounce + memory write

# ---------------------------------------------------
# STEP 4: New Conversation (Recall)
# ---------------------------------------------------
print("Starting new conversation...")

new_conversation = openai_client.conversations.create()

new_response = openai_client.responses.create(
    input="Order my usual coffee",
    conversation=new_conversation.id,
    extra_body={
        "agent_reference": {
            "name": agent.name,
            "type": "agent_reference",
        }
    },
)

print("☕ Agent response:", new_response.output_text)

print("🎉 Memory recall successful!")

Как проверить, что память работает

Через интерфейс Microsoft Foundry можно визуально убедиться, что агент действительно что‑то запомнил:

Откройте CoffeeAgent в портале Foundry.
Перейдите в раздел Memory и проверьте, что к агенту подключён coffee_memory_store.
Встроенным чатом спросите: «What coffee do I prefer?».
Агент должен ответить, что вы предпочитаете dark roast.

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

Несколько моментов, которые стоит заложить в архитектуру сразу:

Единый scope для пользователя. Не меняйте идентификатор пользователя от запроса к запросу. Иначе память распадётся на куски.
Обработка уже созданных ресурсов. Как и в примере, лучше закладывать логику «создать или взять существующий» для Memory Store и агента.
Учёт задержек. Память не обновляется мгновенно. Планируйте UX так, чтобы не полагаться на только что сохранённый факт в пределах одной секунды.
Правильные инструкции для агента. В промпте явно объясните, что агент умеет помнить и когда ему нужно записывать новые факты.
Ограничение типов данных. Явно решите, какие поля профиля вы храните, а какие принципиально не пишете в память.

Если вы строите ИИ‑агентов в Microsoft Foundry и хотите уйти от «амнезии» между сессиями, Memory Store даёт готовый, управляемый слой долговременной памяти без необходимости собирать его вручную из векторной БД и обвязки.