Sdílet prostřednictvím

Vytvoření a použití paměti ve službě Foundry Agent Service (Preview)

Důležité

Paměť (Preview) ve službě Foundry Agent Service a Memory Store API (Preview) jsou vám licencovány v rámci předplatného Azure a vztahují se na podmínky platné pro verze Preview v Podmínkách produktů Microsoft a v Dodatku k ochraně dat produktů a služeb společnosti Microsoft, stejně jako na verzi Preview služeb Microsoft Generative AI Services v doplňkových podmínkách použití pro verze Preview Microsoft Azure.

Paměť ve službě Foundry Agent Service je spravované dlouhodobé řešení paměti. Umožňuje kontinuitu agentů napříč relacemi, zařízeními a pracovními postupy. Vytvořením a správou úložišť paměti můžete vytvářet agenty, kteří si zachovávají uživatelské předvolby, udržují historii konverzací a poskytují přizpůsobené prostředí.

Úložiště paměti fungují jako trvalé úložiště a definují, které typy informací jsou pro každého agenta relevantní. Přístup řídíte pomocí parametru scope , který segmentuje paměť napříč uživateli, aby se zajistilo zabezpečené a izolované prostředí.

Tento článek vysvětluje, jak vytvářet, spravovat a používat úložiště paměti. Koncepční informace naleznete v tématu Paměť ve službě Foundry Agent Service.

Podpora využití

Schopnost Python SDK JavaScript SDK REST API
Vytvoření, aktualizace, výpis a odstranění úložišť paměti ✔️ ✔️ ✔️
Aktualizace a hledání vzpomínek ✔️ ✔️ ✔️
Připojit paměť k příkazovému agentovi ✔️ ✔️ ✔️

Předpoklady

Autorizace a oprávnění

Pro produkční nasazení doporučujeme řízení přístupu na základě role . Pokud role nejsou proveditelné, přeskočte tuto část a místo toho použijte ověřování založené na klíči.

Konfigurace přístupu na základě role:

  1. Přihlaste se do Azure Portalu.
  2. Na tvém projektu:
    1. V levém podokně vyberte správu prostředků>Identitu.
    2. Pomocí přepínače povolte spravovanou identitu přiřazenou systémem.
  3. Na zdroji, který obsahuje váš projekt:
    1. V levém podokně vyberte Řízení přístupu (IAM).
    2. Vyberte Přidat>Přiřadit roli.
    3. Přiřaďte uživatele Azure AI ke spravované identitě projektu.

Nastavení proměnných prostředí

Nastavte proměnné prostředí pro názvy koncových bodů projektu a nasazení modelu:

export FOUNDRY_PROJECT_ENDPOINT="https://{your-ai-services-account}.services.ai.azure.com/api/projects/{project-name}"
export MEMORY_STORE_CHAT_MODEL_DEPLOYMENT_NAME="<chat-model-deployment-name>"
export MEMORY_STORE_EMBEDDING_MODEL_DEPLOYMENT_NAME="<embedding-model-deployment-name>"

Nastavte proměnné prostředí pro koncový bod projektu, nasazení modelu, verzi rozhraní API a přístupový token:

FOUNDRY_PROJECT_ENDPOINT="https://{your-ai-services-account}.services.ai.azure.com/api/projects/{project-name}"
MEMORY_STORE_CHAT_MODEL_DEPLOYMENT_NAME="<chat-model-deployment-name>" # For example, gpt-5.2
MEMORY_STORE_EMBEDDING_MODEL_DEPLOYMENT_NAME="<embedding-model-deployment-name>" # For example, text-embedding-3-small
API_VERSION="2025-11-15-preview"

# Get a short-lived access token using Azure CLI
ACCESS_TOKEN="$(az account get-access-token --resource https://ai.azure.com/ --query accessToken -o tsv)"

Pochopit rozsah

Parametr scope řídí způsob dělení paměti. Každý obor v úložišti paměti uchovává izolovanou kolekci položek paměti. Pokud například vytvoříte agenta zákaznické podpory s pamětí, každý zákazník by měl mít svou vlastní individuální paměť.

Jako vývojář zvolíte klíč použitý k ukládání a načítání položek paměti. Můžete předat statickou hodnotu, jako je univerzální jedinečný identifikátor (UUID) nebo jiný stabilní identifikátor z vašeho systému.

Pokud jako obor zadáte {{$userId}}, systém automaticky extrahuje ID tenanta (TID) a ID objektu (OID) z hlavičky ověřování požadavku. Tento přístup dává každému ověřenému uživateli vlastní izolovaný oddíl paměti a eliminuje potřebu spravovat identifikátory ručně.

Vytvoření úložiště paměti

Vytvořte vyhrazené úložiště paměti pro každého agenta, abyste vytvořili jasné hranice pro přístup k paměti a optimalizaci. Při vytváření úložiště paměti určete nasazení modelu chatu a modelu vkládání, která zpracovávají obsah paměti.

import os
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import MemoryStoreDefaultDefinition, MemoryStoreDefaultOptions
from azure.identity import DefaultAzureCredential

project_client = AIProjectClient(
    endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)

memory_store_name = "my_memory_store"

# Specify memory store options
options = MemoryStoreDefaultOptions(
    chat_summary_enabled=True,
    user_profile_enabled=True,
    user_profile_details="Avoid irrelevant or sensitive data, such as age, financials, precise location, and credentials"
)

# Create memory store
chat_model = os.environ["MEMORY_STORE_CHAT_MODEL_DEPLOYMENT_NAME"]
embedding_model = os.environ["MEMORY_STORE_EMBEDDING_MODEL_DEPLOYMENT_NAME"]

definition = MemoryStoreDefaultDefinition(
    chat_model=chat_model,
    embedding_model=embedding_model,
    options=options
)

memory_store = project_client.beta.memory_stores.create(
    name=memory_store_name,
    definition=definition,
    description="Memory store for customer support agent",
)

print(f"Created memory store: {memory_store.name}")

import { DefaultAzureCredential } from "@azure/identity";
import type {
  MemoryStoreDefaultDefinition,
  MemoryStoreDefaultOptions,
} from "@azure/ai-projects";
import { AIProjectClient } from "@azure/ai-projects";

const projectEndpoint =
  process.env["FOUNDRY_PROJECT_ENDPOINT"] ||
  "<project endpoint>";
const chatModelDeployment =
  process.env["MEMORY_STORE_CHAT_MODEL_DEPLOYMENT_NAME"] ||
  "<chat model deployment name>";
const embeddingModelDeployment =
  process.env["MEMORY_STORE_EMBEDDING_MODEL_DEPLOYMENT_NAME"] ||
  "<embedding model deployment name>";

const memoryStoreName = "my_memory_store";

const project = new AIProjectClient(
  projectEndpoint,
  new DefaultAzureCredential(),
);

const memoryOptions: MemoryStoreDefaultOptions = {
  user_profile_enabled: true,
  chat_summary_enabled: true,
  user_profile_details:
    "Avoid irrelevant or sensitive data, such as age, " +
    "financials, precise location, and credentials",
};

const definition: MemoryStoreDefaultDefinition = {
  kind: "default",
  chat_model: chatModelDeployment,
  embedding_model: embeddingModelDeployment,
  options: memoryOptions,
};

const memoryStore = await project.beta.memoryStores.create(
  memoryStoreName,
  definition,
  {
    description: "Memory store for customer support agent",
  },
);

console.log(
  `Created memory store: ${memoryStore.name} (${memoryStore.id})`,
);

curl -X POST "${FOUNDRY_PROJECT_ENDPOINT}/memory_stores?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my_memory_store",
    "description": "Memory store for customer support agent",
    "definition": {
      "kind": "default",
      "chat_model": "'"${MEMORY_STORE_CHAT_MODEL_DEPLOYMENT_NAME}"'",
      "embedding_model": "'"${MEMORY_STORE_EMBEDDING_MODEL_DEPLOYMENT_NAME}"'",
      "options": {
        "chat_summary_enabled": true,
        "user_profile_enabled": true,
        "user_profile_details": "Avoid irrelevant or sensitive data, such as age, financials, precise location, and credentials"
      }
    }
  }'

Návod

Fragmenty kódu ve zbývajících částech tohoto článku vycházejí z klienta a proměnných definovaných v úložišti paměti. Pokud tyto fragmenty kódu spustíte nezávisle, zahrňte kód importu a inicializace klienta z této části.

Přizpůsobení paměti

Přizpůsobte si, jaké informace agent ukládá, aby byla paměť efektivní, relevantní a respektující soukromí. Pomocí parametru user_profile_details určete typy dat, které jsou pro funkci agenta důležité.

Například nastavte user_profile_details prioritu "preference letového dopravce a dietní omezení" pro cestovního agenta. Tento přístup zaměřený na paměť pomáhá systému paměti zjistit, které podrobnosti se mají extrahovat, shrnout a potvrdit do dlouhodobé paměti.

Tento parametr můžete také použít k vyloučení určitých typů dat, zachování štíhlé paměti a dodržování požadavků na ochranu osobních údajů. Nastavte user_profile_details například možnost "vyhnout se irelevantním nebo citlivým datům, jako jsou věk, finanční údaje, přesné umístění a přihlašovací údaje".

Aktualizace úložiště paměti

Aktualizujte vlastnosti úložiště paměti, například description nebo metadata, aby bylo lepší spravovat úložiště paměti.

# Update memory store properties
updated_store = project_client.beta.memory_stores.update(
    name=memory_store_name,
    description="Updated description"
)

print(f"Updated: {updated_store.description}")

const updatedStore = await project.beta.memoryStores.update(
  memoryStoreName,
  {
    description: "Updated description",
  },
);

console.log(`Updated: ${updatedStore.description}`);

MEMORY_STORE_NAME="my_memory_store"

curl -X POST "${FOUNDRY_PROJECT_ENDPOINT}/memory_stores/${MEMORY_STORE_NAME}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "description": "Updated description"
  }'

Výpis úložišť paměti

Načtěte seznam úložišť paměti v projektu pro správu a monitorování infrastruktury paměti.

# List all memory stores
stores_list = list(project_client.beta.memory_stores.list())

print(f"Found {len(stores_list)} memory stores")
for store in stores_list:
    print(f"- {store.name} ({store.description})")

const storeList = project.beta.memoryStores.list();

console.log("Listing all memory stores...");
for await (const store of storeList) {
  console.log(`  - Memory Store: ${store.name} (${store.id})`);
}

curl -X GET "${FOUNDRY_PROJECT_ENDPOINT}/memory_stores?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}"

Použití pamětí prostřednictvím agentového nástroje

Po vytvoření úložiště paměti můžete nástroj pro vyhledávání paměti připojit k agentu výzvy. Tento nástroj umožňuje agentu číst a zapisovat do úložiště paměti během konverzací. Nakonfigurujte nástroj s odpovídajícími scope a update_delay pro kontrolu, jak a kdy se aktualizují paměti.

from azure.ai.projects.models import MemorySearchPreviewTool, PromptAgentDefinition

# Set scope to associate the memories with
# You can also use "{{$userId}}" to take the TID and OID of the request authentication header
scope = "user_123"

openai_client = project_client.get_openai_client()

# Create memory search tool
tool = MemorySearchPreviewTool(
    memory_store_name=memory_store_name,
    scope=scope,
    update_delay=1, # Wait 1 second of inactivity before updating memories
    # In a real application, set this to a higher value like 300 (5 minutes, default)
)

# Create a prompt agent with memory search tool
agent = project_client.agents.create_version(
    agent_name="MyAgent",
    definition=PromptAgentDefinition(
        model=os.environ["MEMORY_STORE_CHAT_MODEL_DEPLOYMENT_NAME"],
        instructions="You are a helpful assistant that answers general questions",
        tools=[tool],
    )
)

print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

// Set scope to associate the memories with
// You can also use "{{$userId}}" to take the TID and OID of the request authentication header
const scope = "user_123";

const agent = await project.agents.createVersion(
  "memory-search-agent",
  {
    kind: "prompt",
    model: chatModelDeployment,
    instructions:
      "You are a helpful assistant that retrieves relevant " +
      "information from the user's memory store to answer their questions.",
    tools: [
      {
        type: "memory_search_preview",
        memory_store_name: memoryStoreName,
        scope: scope,
        update_delay: 1,
      },
    ],
  },
);

console.log(
  `Created agent with memory search tool, agent ID: ${agent.id}, ` +
    `name: ${agent.name}, version: ${agent.version}`,
);

# Note: The agents API uses api-version=v1, which differs from the memory store API version
curl -X POST "${FOUNDRY_PROJECT_ENDPOINT}/agents?api-version=v1" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "MyAgent",
    "definition": {
        "kind": "prompt",
        "model": "gpt-5.2",
        "instructions": "You are a helpful assistant that answers general questions",
        "tools": [
            {
              "type": "memory_search_preview",
              "memory_store_name": "my_memory_store",
              "scope": "user_123",
              "update_delay": 1
            }
        ]
    }
}'

Vytvoření konverzace

Teď můžete vytvářet konverzace a žádat o odpovědi agenta. Na začátku každé konverzace se vloží statické vzpomínky, takže agent má okamžitý trvalý kontext. Kontextové paměti se získávají v každém kroku podle nejnovějších zpráv, aby informovaly každou odpověď.

Po každé reakci agenta služba interně volá update_memories. Skutečné zápisy do dlouhodobé paměti jsou však debouncovány update_delay nastavením. Aktualizace je naplánovaná a dokončí se až po nakonfigurované době nečinnosti.

import time

# Create a conversation with the agent with memory tool enabled
conversation = openai_client.conversations.create()
print(f"Created conversation (id: {conversation.id})")

# Create an agent response to initial user message
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(f"Response output: {response.output_text}")

# After an inactivity in the conversation, memories will be extracted from the conversation and stored
print("Waiting for memories to be stored...")
time.sleep(65)

# Create a new conversation
new_conversation = openai_client.conversations.create()
print(f"Created new conversation (id: {new_conversation.id})")

# Create an agent response with stored memories
new_response = openai_client.responses.create(
    input="Please order my usual coffee",
    conversation=new_conversation.id,
    extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
)

print(f"Response output: {new_response.output_text}")

import { setTimeout } from "timers/promises";

const openaiClient = project.getOpenAIClient();

// Create a conversation with the agent with memory tool enabled
const conversation = await openaiClient.conversations.create();
console.log(`Created conversation (id: ${conversation.id})`);

// Create an agent response to initial user message
const response = await openaiClient.responses.create(
  {
    conversation: conversation.id,
    input: "I prefer dark roast coffee",
  },
  {
    body: {
      agent: { name: agent.name, type: "agent_reference" },
    },
  },
);

console.log(`Response output: ${response.output_text}`);

// After inactivity, memories are extracted and stored
console.log("Waiting for memories to be stored...");
await setTimeout(65_000);

// Create a new conversation to demonstrate cross-session recall
const newConversation = await openaiClient.conversations.create();
console.log(`Created new conversation (id: ${newConversation.id})`);

// Create an agent response with stored memories
const newResponse = await openaiClient.responses.create(
  {
    conversation: newConversation.id,
    input: "Please order my usual coffee",
  },
  {
    body: {
      agent: { name: agent.name, type: "agent_reference" },
    },
  },
);

console.log(`Response output: ${newResponse.output_text}`);

curl -X POST "${FOUNDRY_PROJECT_ENDPOINT}/openai/v1/conversations" \
    -H "Authorization: Bearer ${ACCESS_TOKEN}" \
    -H "Content-Type: application/json" \
    -d '{}'

# Copy the "id" field from the previous response
curl -X POST "${FOUNDRY_PROJECT_ENDPOINT}/openai/v1/responses" \
    -H "Authorization: Bearer ${ACCESS_TOKEN}" \
    -H "Content-Type: application/json" \
    -d '{
      "input": "I prefer dark roast coffee",
      "conversation": "{conversation-id}",
      "agent_reference": {
        "type": "agent_reference",
        "name": "MyAgent"
      }
    }'

Použití pamětí prostřednictvím rozhraní API

S úložištěm paměti můžete pracovat přímo pomocí rozhraní API úložiště paměti. Začněte tím, že do úložiště paměti přidáte vzpomínky z obsahu konverzace a pak vyhledáte relevantní vzpomínky, abyste zajistili kontext pro interakce agentů.

Přidání pamětí do úložiště paměti

Přidejte vzpomínky tím, že do úložiště paměti poskytnete obsah konverzace. Systém předzpracuje a postprocesuje data, včetně extrakce paměti a konsolidace, za účelem optimalizace paměti agenta. Tato dlouhotrvající operace může trvat přibližně jednu minutu.

Určete, jak segmentovat paměť mezi uživateli zadáním parametru scope . Paměť můžete nastavit na konkrétního koncového uživatele, tým nebo jiný identifikátor.

Úložiště paměti můžete aktualizovat obsahem z několika konverzačních tahů, nebo provést aktualizaci po každém tahu a řetězit aktualizace pomocí ID předchozí operace aktualizace.

# Set scope to associate the memories with
scope = "user_123"

user_message = {
  "role": "user",
  "content": "I prefer dark roast coffee and usually drink it in the morning",
   "type": "message"
}

update_poller = project_client.beta.memory_stores.begin_update_memories(
    name=memory_store_name,
    scope=scope,
    items=[user_message], # Pass conversation items that you want to add to memory
    update_delay=0, # Trigger update immediately without waiting for inactivity
)

# Wait for the update operation to complete, but can also fire and forget
update_result = update_poller.result()
print(f"Updated with {len(update_result.memory_operations)} memory operations")
for operation in update_result.memory_operations:
    print(
        f"  - Operation: {operation.kind}, Memory ID: {operation.memory_item.memory_id}, Content: {operation.memory_item.content}"
    )

# Extend the previous update with another update and more messages
new_message = {
    "role":"user", 
    "content":"I also like cappuccinos in the afternoon", 
    "type":"message"}

new_update_poller = project_client.beta.memory_stores.begin_update_memories(
    name=memory_store_name,
    scope=scope,
    items=[new_message],
    previous_update_id=update_poller.update_id, # Extend from previous update ID
    update_delay=0, # Trigger update immediately without waiting for inactivity
)
new_update_result = new_update_poller.result()
for operation in new_update_result.memory_operations:
    print(
        f"  - Operation: {operation.kind}, Memory ID: {operation.memory_item.memory_id}, Content: {operation.memory_item.content}"
    )

const scope = "user_123";

const userMessage: Record<string, unknown> = {
  type: "message",
  role: "user",
  content: [
    {
      type: "input_text",
      text: "I prefer dark roast coffee and usually drink it in the morning",
    },
  ],
};

console.log("\nSubmitting memory update request...");
const updatePoller = project.beta.memoryStores.updateMemories(
  memoryStoreName,
  scope,
  {
    items: [userMessage],
    updateDelayInSecs: 0,
  },
);

const updateResult = await updatePoller.pollUntilDone();
console.log(
  `Updated with ${updateResult.memory_operations.length} ` +
    `memory operation(s)`,
);
for (const operation of updateResult.memory_operations) {
  console.log(
    `  - Operation: ${operation.kind}, ` +
      `Memory ID: ${operation.memory_item.memory_id}, ` +
      `Content: ${operation.memory_item.content}`,
  );
}

// Extend the previous update with another message
const newMessage = {
  role: "user",
  content: "I also like cappuccinos in the afternoon",
  type: "message",
};

const newUpdatePoller = project.beta.memoryStores.updateMemories(
  memoryStoreName,
  scope,
  {
    items: [newMessage],
    updateDelayInSecs: 0,
  },
);

const newUpdateResult = await newUpdatePoller.pollUntilDone();
console.log(
  `Updated with ${newUpdateResult.memory_operations.length} ` +
    `memory operation(s)`,
);
for (const operation of newUpdateResult.memory_operations) {
  console.log(
    `  - Operation: ${operation.kind}, ` +
      `Memory ID: ${operation.memory_item.memory_id}, ` +
      `Content: ${operation.memory_item.content}`,
  );
}

curl -X POST "${FOUNDRY_PROJECT_ENDPOINT}/memory_stores/my_memory_store:update_memories?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "scope": "user_123",
    "items": [
      {
        "type": "message",
        "role": "user",
        "content": [
          {
            "type": "input_text",
            "text": "I prefer dark roast coffee and usually drink it in the morning"
          }
        ]
      }
    ],
    "update_delay": 0
  }'

# Get add memory status by polling the update_id
# Use the "update_id" from previous response
UPDATE_ID=<your_update_id>
curl -X GET "${FOUNDRY_PROJECT_ENDPOINT}/memory_stores/my_memory_store/updates/${UPDATE_ID}?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}"

Hledání vzpomínek v úložišti paměti

Prohledávejte vzpomínky za účelem načtení relevantního kontextu pro interakce agentů. Zadejte název a obor úložiště paměti, abyste hledání zúžili.

from azure.ai.projects.models import MemorySearchOptions

# Search memories by a query
query_message = {"role": "user", "content": "What are my coffee preferences?", "type": "message"}

search_response = project_client.beta.memory_stores.search_memories(
    name=memory_store_name,
    scope=scope,
    items=[query_message],
    options=MemorySearchOptions(max_memories=5)
)
print(f"Found {len(search_response.memories)} memories")
for memory in search_response.memories:
    print(f"  - Memory ID: {memory.memory_item.memory_id}, Content: {memory.memory_item.content}")

const queryMessage: Record<string, unknown> = {
  type: "message",
  role: "user",
  content: [
    { type: "input_text", text: "What are my coffee preferences?" },
  ],
};

console.log("\nSearching memories for stored preferences...");
const searchResponse =
  await project.beta.memoryStores.searchMemories(
    memoryStoreName,
    scope,
    {
      items: [queryMessage],
      options: { max_memories: 5 },
    },
  );

console.log(`Found ${searchResponse.memories.length} memory item(s)`);
for (const memory of searchResponse.memories) {
  console.log(
    `  - Memory ID: ${memory.memory_item.memory_id}, ` +
      `Content: ${memory.memory_item.content}`,
  );
}

curl -X POST "${FOUNDRY_PROJECT_ENDPOINT}/memory_stores/my_memory_store:search_memories?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "scope": "user_123",
    "items": [
      {
        "type": "message",
        "role": "user",
        "content": [
          {
            "type": "input_text",
            "text": "What are my coffee preferences?"
          }
        ]
      }
    ],
    "options": {
      "max_memories": 5
    }
  }'

Načtení statických nebo kontextových pamětí

Paměti profilů uživatelů se často nedají načíst na základě sémantické podobnosti se zprávou uživatele. Doporučujeme vložit statické vzpomínky na začátek každé konverzace a použít kontextové vzpomínky k vygenerování každé odpovědi agenta.

  • Chcete-li načíst statické vzpomínky, zavolejte search_memories s scope, ale bez items nebo previous_search_id. Tím se vrátí paměti profilu uživatele přidružené k oboru.

  • Pokud chcete načíst kontextové vzpomínky, zavolejte search_memories s nastaveným items na nejnovější zprávy. Může vracet jak vzpomínky z uživatelského profilu, tak ze souhrnu chatu, které jsou pro dané položky nejrelevantnější.

Další informace o souhrnných pamětích profilů uživatelů a chatu najdete v tématu Typy paměti.

Odstranění pamětí

Výstraha

Před odstraněním úložiště paměti zvažte dopad na závislé agenty. Agenti s připojenými úložišti paměti můžou ztratit přístup k historickému kontextu.

Vzpomínky jsou uspořádané podle rozsahu v úložišti paměti. Pokud chcete odebrat uživatelská data, můžete odstranit vzpomínky pro určitý obor nebo můžete odstranit celé úložiště paměti, abyste odebrali všechny paměti napříč všemi obory.

Odstranění pamětí podle oboru

Odeberte všechny vzpomínky přidružené k určitému uživatelskému nebo skupinovému rozsahu při zachování struktury úložiště paměti. Tato operace slouží ke zpracování žádostí o odstranění uživatelských dat nebo resetování paměti pro konkrétní uživatele.

# Delete memories for a specific scope
project_client.beta.memory_stores.delete_scope(
    name=memory_store_name,
    scope="user_123"
)

print(f"Deleted memories for scope: user_123")

console.log("\nDeleting memories for scope...");
await project.beta.memoryStores.deleteScope(memoryStoreName, scope);

curl -X POST "${FOUNDRY_PROJECT_ENDPOINT}/memory_stores/my_memory_store:delete_scope?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "scope": "user_123"
  }'

Odstranění úložiště paměti

Odstraňte celé úložiště paměti a všechny přidružené paměti ve všech rozsazích. Tato operace je nevratná.

# Delete the entire memory store
delete_response = project_client.beta.memory_stores.delete(memory_store_name)
print(f"Deleted memory store: {delete_response.deleted}")

console.log("Deleting memory store...");
await project.beta.memoryStores.delete(memoryStoreName);

curl -X DELETE "${FOUNDRY_PROJECT_ENDPOINT}/memory_stores/my_memory_store?api-version=${API_VERSION}" \
  -H "Authorization: Bearer ${ACCESS_TOKEN}"

Osvědčené postupy

  • Implementace řízení přístupu pro jednotlivé uživatele: Vyhněte se tomu, aby agenti měli přístup ke vzpomínkám sdíleným napříč všemi uživateli. scope Pomocí vlastnosti rozdělte úložiště paměti podle uživatele. Při sdílení scope mezi uživateli použijte user_profile_details pokyn systému paměti, aby neukládaly osobní údaje.

  • Namapujte obor na ověřeného uživatele: Když v nástroji pro vyhledávání paměti zadáte obor, nastavte scope={{$userId}} mapování na uživatele z ověřovacího tokenu ({tid}_{oid}). Tím zajistíte, že vyhledávání v paměti automaticky zaměří na správného uživatele.

  • Minimalizace a ochrana citlivých dat: Ukládejte jenom to, co je potřeba pro váš případ použití. Pokud musíte ukládat citlivá data, jako jsou osobní údaje, zdravotní údaje nebo důvěrné obchodní vstupy, odstraňte nebo upravte jiný obsah, který by mohl být použit ke sledování jednotlivce.

  • Podpora ochrany osobních údajů a dodržování předpisů: Poskytněte uživatelům transparentnost, včetně možností přístupu k jejich datům a jejich odstranění. Zaznamenávejte všechna odstranění do auditní stopy, která detekuje manipulaci. Ujistěte se, že systém dodržuje místní požadavky na dodržování předpisů a regulační standardy.

  • Segmentace dat a izolace paměti: V systémech s více agenty se paměť segmentuje logicky a operativně. Umožňuje zákazníkům definovat, izolovat, kontrolovat a odstraňovat svou paměťovou stopu.

  • Monitorování využití paměti: Sledujte využití tokenů a operace paměti, abyste porozuměli nákladům a optimalizovali výkon.

Řešení problémů

Problém Příčina Řešení
Požadavky selhávají kvůli chybě ověřování nebo autorizace. Vaše identita nebo spravovaná identita projektu nemá požadované role. Ověřte role v autorizaci a oprávněních. Pro volání REST vygenerujte nový přístupový token a zkuste to znovu.
Vzpomínky se po konverzaci nezobrazují. Aktualizace paměti jsou debouncované nebo se stále zpracovávají. Zvyšte dobu čekání nebo zavolejte aktualizační rozhraní API s update_delay nastaveným na 0 k okamžitému spuštění zpracování.
Hledání v paměti nevrací žádné výsledky. Hodnota scope neodpovídá rozsahu použitému při uložení paměti. Pro aktualizaci a vyhledávání použijte stejný obor. Pokud přiřadíte obor uživatelům, použijte stabilní identifikátor uživatele.
Odpověď agenta nepoužívá uloženou paměť. Agent není nakonfigurovaný pomocí nástroje pro vyhledávání paměti nebo je nesprávný název úložiště paměti. Ověřte, že definice agenta memory_search_preview obsahuje nástroj a odkazuje na správný název úložiště paměti.

Související obsah

  • Last updated on