Rychlý start: Poskytnutí trvalé paměti hostovaného agenta

Důležité

Položky označené jako náhled v tomto článku jsou aktuálně ve verzi Preview. Tato verze Preview se poskytuje bez smlouvy o úrovni služeb a Microsoft ji nedoporučuje pro produkční úlohy. Některé funkce nemusí být podporované nebo můžou mít omezené možnosti. Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

V tomto rychlém startu dáte hostovanému agentovi trvalou sémantickou paměť zálohovanou úložištěm paměti Foundry. Bez paměti začíná každá konverzace úplně od začátku. S úložištěm paměti si agent uchovává stabilní fakta o uživateli, jako je jméno nebo dietní preference, a připomíná je v pozdějších relacích.

Dokončíte dvě části:

  • Zřiďte úložiště paměti a připojte ho k agentovi. V rámci postupu Azure Developer CLI se po azd provision spustí integrovaný háček pro zřizování. V případě Pythonu vytvoříte úložiště přímo pomocí sady SDK. Úložiště používá chatovací model a embeddingový model k extrakci a indexaci vzpomínek z uživatelských profilů.
  • Nasaďte hostovaného agenta , který čte a zapisuje úložiště prostřednictvím FoundryMemoryProvider. Poskytovatel před každým voláním modelu načte relevantní informace z paměti a po každé interakci aktualizuje úložiště o nové skutečnosti.

Kód agenta, poskytovatel paměti a ověřování pocházejí z ukázkového příkladu paměti Foundry, takže se můžete soustředit na pracovní postup, nikoli na implementaci.

Pokud používáte programovacího agenta, jako je GitHub Copilot, může Microsoft Foundry Skill pomoct zřídit úložiště paměti, připojit ho k hostovaným agentům a otestovat chování odvolání.

Předpoklady

Tento rychlý start vychází ze sady nástrojů hostovaného agenta. Nejprve dokončete předpoklady v rychlém startu pro hostovaného agenta, které zahrnují předplatné Azure, role projektu, Python, Azure Developer CLI (azd) a rozšíření microsoft.foundry.

V tomto postupu použijete Azure Developer CLI k vytvoření základní struktury ukázky, zprovoznění úložiště paměti pomocí přibaleného hooku postprovision, místnímu spuštění agenta a jeho nasazení.

Pomocí sady Python SDK v této cestě vytvoříte úložiště paměti s kódem AIProjectClient.beta.memory_stores.create(...)hostovaného agenta , nahrajete kód hostovaného agenta jako novou verzi, dočasně do něj směrujete provoz a ověříte, že se stejný přihlášený uživatel zapamatuje napříč samostatnými voláními.

Nainstalujte balíčky Python použité v této cestě:

pip install "azure-ai-projects>=2.3.0" python-dotenv

Pomocí sady .NET SDK v této cestě vytvořte úložiště paměti s kódem AIProjectClient.MemoryStores.CreateMemoryStore(...)hostovaného agenta , nahrajte kód hostovaného agenta jako novou verzi, dočasně do něj směrujte provoz a ověřte, že se stejný přihlášený uživatel zapamatuje napříč samostatnými voláními.

Potřebujete také sadu SDK pro .NET 10 nebo novější.

Také potřebujete nasazení modelu pro vektorizaci v projektu Foundry, například text-embedding-3-small. Úložiště paměti ho používá k indexování pamětí. Chatovací model agenta, například gpt-4o, může být totožný s nasazením, které už používáte pro hostované agenty.

Vaše identita potřebuje roli uživatele Foundry v rozsahu projektu Foundry v rámci předpokladů pro hostovaného agenta a také roli uživatele Cognitive Services OpenAI ve stejném rozsahu. Úložiště pro paměť využívá přístup k datové rovině projektu Foundry a nasazení modelu pro embeddingy. Bez role OpenAI selže zápis paměti s chybou 401 a úložiště zůstane prázdné.

Důležité

Nedávno byly přejmenovány role Foundry RBAC. Foundry User, Foundry Owner, Foundry Account Owner a Foundry Project Manager se dříve nazývaly Uživatel Azure AI, Vlastník Azure AI, Vlastník účtu Azure AI a Správce projektů Azure AI. Během zavádění přejmenování se stále můžou zobrazovat předchozí názvy na některých místech. ID rolí a základní oprávnění se při přejmenování nezmění.

Krok 1: Inicializace hostovaného agenta

Inicializujte hostovaného agenta z ukázky paměti Foundry. Inicializace zkopíruje ukázkové soubory, včetně skriptu zřizování úložiště paměti a zřizovacího háku, do nového adresáře služby v části src/. Spusťte tyto příkazy v prázdném adresáři.

mkdir my-memory-agent
cd my-memory-agent
azd ai agent init -t "https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/agent-framework/responses/13-foundry-memory/azure.yaml"

Podle pokynů vyberte své předplatné, projekt a nasazení modelu. Pokud projekt Foundry nemáte, azd ai agent init provede vás vytvořením projektu.

Krok 2: Povolte zřizování pomocí jednoho příkazu

Ukázka obsahuje postprovision háček, který vytvoří úložiště paměti a připojí ho k agentu automaticky při každém spuštění azd provision. Zaregistrujte hook na nejvyšší úrovni souboru azure.yaml, který vygeneroval azd ai agent init.

Otevřete azure.yaml a přidejte následující blok nejvyšší úrovně. Nahraďte <agent-name> složkou služby, kterou vytvořila inicializace v adresáři src/:

hooks:
  postprovision:
    posix:
      shell: sh
      run: ./src/<agent-name>/hooks/postprovision.sh
    windows:
      shell: pwsh
      run: ./src/<agent-name>/hooks/postprovision.ps1

Hook je samoumísťovací a idempotentní. Spustí se správně bez ohledu na to, ze kterého adresáře jej azd spustí, a opětovné spuštění ponechá existující úložiště beze změny.

Poznámka:

Zaregistrujte postprovision na nejvyšší úrovni v azure.yaml. Háky s vymezeným oborem služeb podporují pouze balíček a nasazují životní cyklus, nikoli zřizování.

Krok 3: Zřízení úložiště paměti a Azure prostředků

  1. Nasměrujte háček na nasazení modelu vkládání, které využívá sémantickou paměť úložiště:

    azd env set AZURE_AI_EMBEDDING_MODEL_DEPLOYMENT_NAME "text-embedding-3-small"

  2. Poskytování:

    azd provision

azd provision vytvoří nebo znovu použije váš projekt Foundry a nasazení chatovacího modelu. Pak háček postprovision :

  • Vytvoří úložiště paměti s povolenou funkcí profilu uživatele a ověří ho ve službě.
  • Nastaví MEMORY_STORE_NAME tak, aby agent četl z daného úložiště a zapisoval do něj. Hook uloží název do vašeho prostředí azd při místním spuštění a do prostředí služby v azure.yaml, aby ho azd deploy odeslal do kontejneru.

Cesta k rozhraní příkazového řádku nezobrazuje samostatný create memory store příkaz, protože sada háku spouští logiku vytváření, která je pro vás součástí azd provision.

Hook ve výchozím nastavení nastaví název obchodu na agent_framework_memory. Pokud chcete použít jiný název, nastavte ho před zřízením:

azd env set MEMORY_STORE_NAME "<your-store-name>"

Krok 4: Místní spuštění agenta

  1. Spusťte agenta:

    azd ai agent run

    Tento příkaz vytvoří virtuální prostředí, nainstaluje závislosti a obsluhuje agenta na http://localhost:8088. Hook už nastavuje MEMORY_STORE_NAME ve vašem prostředí azd, takže nepotřebujete žádnou další konfiguraci. Balíčky ve verzi Preview můžou během instalace vytvářet upozornění pip. Tato upozornění nejsou blokující.

  2. V samostatném terminálu řekněte agentovi fakt o sobě:

    azd ai agent invoke --local "Hi! My name is Linda and I'm vegetarian. Please remember that."

  3. Zahajte novou relaci a potvrďte, že si agent vybaví daný fakt z úložiště, nikoli z historie konverzace:

    azd ai agent invoke --local --new-session "Do you remember my name and any dietary preference I told you earlier?"

    Agent ve své odpovědi uvede vaše jméno a preferenci, čímž prokáže, že je načetl z paměťového úložiště.

Krok 5: Nasazení do služby agenta Foundry

Nasaďte zdrojový kód agenta. azd zabalí zdroj jako soubor ZIP a nahraje ho do Foundry, který řeší závislosti a sestavuje hostovaného agenta vzdáleně. Hook postprovision již zapisuje MEMORY_STORE_NAME do azure.yaml, takže nasazený agent čte stejné úložiště:

azd deploy

Po dokončení příkazu se ve výstupu zobrazí odkazy na dětské hřiště agenta a koncový bod agenta. Ověřte paměť mezi relacemi u nasazeného agenta. Uložte fakt:

azd ai agent invoke --new-session "Hi! My name is Marco and I'm allergic to peanuts. Please remember this about me."

Pak si ho vzpomeňte v nové relaci:

azd ai agent invoke --new-session "What's my name, and is there any food I should avoid?"

Nasazený agent uvede zapamatované jméno a alergii.

Krok 1: Vytvoření nebo volba projektu Foundry

  1. Otevřete portál Foundry a vytvořte projekt Foundry nebo vyberte existující.

  2. V projektu nasaďte:

    • Model podporující chat, například gpt-5.4-mini.
    • Vložený model, například text-embedding-3-small.

  3. Zkopírujte koncový bod projektu z Přehled a názvy nasazení z Sestavení>Nasazení.

Krok 2: Stažení ukázky paměti Foundry

Naklonujte úložiště ukázek Foundry:

git clone https://github.com/microsoft-foundry/foundry-samples.git

Vytvořte pracovní složku pro skripty nasazení. V této složce vytvořte .env soubor s těmito hodnotami:

FOUNDRY_PROJECT_ENDPOINT=<your-project-endpoint>
AZURE_AI_MODEL_DEPLOYMENT_NAME=<your-chat-model-deployment-name>
AZURE_AI_EMBEDDING_MODEL_DEPLOYMENT_NAME=<your-embedding-model-deployment-name>
FOUNDRY_HOSTED_AGENT_NAME=memory-agent
MEMORY_STORE_NAME=agent_framework_memory
FOUNDRY_SAMPLE_PATH=<full-path-to-foundry-samples/samples/python/hosted-agents/agent-framework/responses/13-foundry-memory/src/agent-framework-agent-foundry-memory-responses>

Krok 3: Zřízení úložiště paměti pomocí Python

Tento skript je bezpečný pro opětovné spuštění. Nejprve volá get(...), aby ověřila, zda paměťové úložiště již existuje. Volá se jenom create(...) v případě, že se úložiště nenašlo.

Vytvořte soubor s názvem provision_memory_store.py ve stejné pracovní složce jako .env:

import asyncio
import os

from azure.ai.projects.aio import AIProjectClient
from azure.ai.projects.models import (
    MemoryStoreDefaultDefinition,
    MemoryStoreDefaultOptions,
)
from azure.core.exceptions import ResourceNotFoundError
from azure.identity.aio import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()


async def main() -> None:
    endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
    memory_store_name = os.environ["MEMORY_STORE_NAME"]
    chat_model = os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"]
    embedding_model = os.environ["AZURE_AI_EMBEDDING_MODEL_DEPLOYMENT_NAME"]

    async with (
        DefaultAzureCredential() as credential,
        AIProjectClient(
            endpoint=endpoint,
            credential=credential,
            allow_preview=True,
        ) as project,
    ):
        try:
            existing = await project.beta.memory_stores.get(name=memory_store_name)
            print(
                f"Memory store '{existing.name}' already exists "
                f"(id={existing.id}); leaving as-is."
            )
            return
        except ResourceNotFoundError:
            pass

        definition = MemoryStoreDefaultDefinition(
            chat_model=chat_model,
            embedding_model=embedding_model,
            options=MemoryStoreDefaultOptions(
                chat_summary_enabled=False,
                user_profile_enabled=True,
                user_profile_details=(
                    "Avoid irrelevant or sensitive data, such as age, "
                    "financials, precise location, and credentials"
                ),
            ),
        )

        created = await project.beta.memory_stores.create(
            name=memory_store_name,
            description="Memory store for the hosted-agent memory quickstart",
            definition=definition,
        )
        print(f"Created memory store '{created.name}' (id={created.id}).")


asyncio.run(main())

Spusťte skript:

python provision_memory_store.py

Krok 4: Nasazení hostovaného agenta s Python

Vytvořte soubor s názvem deploy_memory_agent.py ve stejné pracovní složce jako .env:

import os
import tempfile
import time
import zipfile
from pathlib import Path

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    AgentEndpointConfig,
    CodeConfiguration,
    CodeDependencyResolution,
    FixedRatioVersionSelectionRule,
    HostedAgentDefinition,
    ProtocolConfiguration,
    ProtocolVersionRecord,
    ResponsesProtocolConfiguration,
    VersionSelector,
)
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
model_name = os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"]
agent_name = os.environ.get("FOUNDRY_HOSTED_AGENT_NAME", "memory-agent")
memory_store_name = os.environ["MEMORY_STORE_NAME"]
sample_path = Path(os.environ["FOUNDRY_SAMPLE_PATH"]).resolve()


def create_code_zip(source_dir: Path) -> Path:
    zip_path = Path(tempfile.gettempdir()) / f"{agent_name}.zip"
    excluded = {".git", ".venv", "__pycache__", ".env"}

    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
        for path in source_dir.rglob("*"):
            if not path.is_file():
                continue
            if any(part in excluded for part in path.parts):
                continue
            zip_file.write(path, path.relative_to(source_dir))

    return zip_path


def wait_for_active_version(project_client: AIProjectClient, version: str) -> None:
    for attempt in range(60):
        time.sleep(10)
        details = project_client.agents.get_version(
            agent_name=agent_name,
            agent_version=version,
        )
        status = details["status"]
        print(f"Provisioning status: {status} (attempt {attempt + 1}/60)")

        if status == "active":
            return

        if status == "failed":
            raise RuntimeError(f"Hosted agent provisioning failed: {dict(details)}")

    raise RuntimeError("Timed out waiting for the hosted agent version to become active.")


code_zip_path = create_code_zip(sample_path)

with (
    code_zip_path.open("rb") as code_stream,
    DefaultAzureCredential() as credential,
    AIProjectClient(
        endpoint=endpoint,
        credential=credential,
        allow_preview=True,
    ) as project_client,
):
    original_agent_endpoint = None
    created = None

    try:
        created = project_client.agents.create_version_from_code(
            agent_name=agent_name,
            description="Hosted agent with persistent Foundry memory.",
            definition=HostedAgentDefinition(
                cpu="0.5",
                memory="1Gi",
                code_configuration=CodeConfiguration(
                    runtime="python_3_13",
                    entry_point=["python", "main.py"],
                    dependency_resolution=CodeDependencyResolution.REMOTE_BUILD,
                ),
                environment_variables={
                    "FOUNDRY_PROJECT_ENDPOINT": endpoint,
                    "AZURE_AI_MODEL_DEPLOYMENT_NAME": model_name,
                    "MEMORY_STORE_NAME": memory_store_name,
                },
                protocol_versions=[
                    ProtocolVersionRecord(protocol="responses", version="2.0.0")
                ],
            ),
            code=code_stream,
        )

        print(f"Created hosted agent version {created.version}")
        wait_for_active_version(project_client, created.version)

        original_agent_endpoint = project_client.agents.get(
            agent_name=agent_name
        ).agent_endpoint

        project_client.agents.update_details(
            agent_name=agent_name,
            agent_endpoint=AgentEndpointConfig(
                version_selector=VersionSelector(
                    version_selection_rules=[
                        FixedRatioVersionSelectionRule(
                            agent_version=created.version,
                            traffic_percentage=100,
                        ),
                    ]
                ),
                protocol_configuration=ProtocolConfiguration(
                    responses=ResponsesProtocolConfiguration()
                ),
            ),
        )

        with project_client.get_openai_client(agent_name=agent_name) as openai_client:
            first_response = openai_client.responses.create(
                input="Hi! My name is Linda and I'm vegetarian. Please remember that.",
            )
            print(first_response.output_text)

            time.sleep(10)

            second_response = openai_client.responses.create(
                input=(
                    "Do you remember my name and any dietary preference I told "
                    "you earlier?"
                ),
            )
            print(second_response.output_text)
    finally:
        if original_agent_endpoint is not None:
            project_client.agents.update_details(
                agent_name=agent_name,
                agent_endpoint=original_agent_endpoint,
            )

        if created is not None:
            project_client.agents.delete_version(
                agent_name=agent_name,
                agent_version=created.version,
                force=True,
            )

Spusťte skript:

python deploy_memory_agent.py

Tento skript nahraje ukázku paměti jako novou verzi hostovaného agenta, odkazuje hostovaného agenta na tuto verzi dočasně, dočasně ji vyvolá dvakrát jako stejný přihlášený uživatel a obnoví konfiguraci předchozího koncového bodu po dokončení.

Krok 5: Ověření zachování paměti

První volání ukládá informaci do paměťového úložiště. Druhé volání si v samostatném požadavku vyžádá zapamatovanou informaci. Pokud je úložiště paměti správně nakonfigurované, měla by odpověď zmínit stejný název a dietní předvolbu, kterou jste zadali v prvním požadavku.

Krok 1: Vytvoření nebo volba projektu Foundry

  1. Otevřete portál Foundry a vytvořte projekt Foundry nebo vyberte existující.

  2. V projektu nasaďte:

    • Model podporující chat, například gpt-4o.
    • Vložený model, například text-embedding-3-small.

  3. Zkopírujte koncový bod projektu z Přehled a názvy nasazení z Sestavení>Nasazení.

Krok 2: Stažení ukázky paměti Foundry

Naklonujte úložiště ukázek Foundry:

git clone https://github.com/microsoft-foundry/foundry-samples.git

Ukázku hostovaného agenta pro C# najdete v samples/csharp/hosted-agents/agent-framework/foundry-memory-rag/src/foundry-memory-rag. V dalších krocích se tato složka nasadí jako hostovaná verze agenta. Ukázka načte svou konfiguraci z těchto proměnných prostředí, které kód nasazení nastaví v kontejneru:

Proměnné Description
FOUNDRY_PROJECT_ENDPOINT Koncový bod projektu Foundry
AZURE_AI_MODEL_DEPLOYMENT_NAME Název nasazení modelu chatu
AZURE_AI_EMBEDDING_DEPLOYMENT_NAME Vložení názvu nasazení modelu
AZURE_AI_MEMORY_STORE_ID Název úložiště paměti. Výchozí hodnota je foundry-memory-rag-store.

Krok 3: Zřízení úložiště paměti pomocí jazyka C#

Vytvořte konzolovou aplikaci .NET a nainstalujte balíčky. Rozhraní API pro úložiště paměti jsou ve verzi Preview, proto nainstalujte balíček předběžné verze Azure.AI.Projects:

dotnet new console --name provision-memory-store
cd provision-memory-store
dotnet add package Azure.AI.Projects --prerelease
dotnet add package Azure.Identity

Tento kód je bezpečný pro opětovné spuštění. Nejprve zavolá GetMemoryStore(...), aby ověřil, zda úložiště již existuje, a CreateMemoryStore(...) zavolá pouze tehdy, pokud úložiště nenajde. Nahraďte Program.cs následujícím kódem a nastavte chatModel, endpoint a embeddingModel podle hodnot svého projektu:

using System.ClientModel;
using Azure.AI.Projects;
using Azure.AI.Projects.Memory;
using Azure.Identity;

#pragma warning disable AAIP001

var endpoint = "https://<account>.services.ai.azure.com/api/projects/<project>";
var chatModel = "gpt-4o";
var embeddingModel = "text-embedding-3-small";
var memoryStoreName = "foundry-memory-rag-store";

AIProjectClient projectClient = new(new Uri(endpoint), new DefaultAzureCredential());

try
{
    MemoryStore existing = projectClient.MemoryStores.GetMemoryStore(memoryStoreName);
    Console.WriteLine($"Memory store '{existing.Name}' already exists (id={existing.Id}); leaving as-is.");
}
catch (ClientResultException ex) when (ex.Status == 404)
{
    MemoryStore created = projectClient.MemoryStores.CreateMemoryStore(
        memoryStoreName,
        new MemoryStoreDefaultDefinition(chatModel, embeddingModel)
        {
            Options = new MemoryStoreDefaultOptions(isUserProfileEnabled: true, isChatSummaryEnabled: false)
            {
                UserProfileDetails =
                    "Avoid irrelevant or sensitive data, such as age, financials, precise location, and credentials",
            },
        },
        description: "Memory store for the hosted-agent memory quickstart");
    Console.WriteLine($"Created memory store '{created.Name}' (id={created.Id}).");
}

Spuštění aplikace:

dotnet run

Krok 4: Nasazení hostovaného agenta pomocí jazyka C#

Vytvořte druhou konzolovou aplikaci pro kód nasazení:

dotnet new console --name deploy-memory-agent
cd deploy-memory-agent
dotnet add package Azure.AI.Projects --prerelease
dotnet add package Azure.AI.Extensions.OpenAI
dotnet add package Azure.Identity

Nahraďte Program.csstávající kód následujícím kódem. Nastavte endpoint, embeddingModel, chatModel a samplePath na své hodnoty. samplePath je úplná cesta ke foundry-memory-rag zdrojové složce, kterou jste naklonovali v kroku 2:

using Azure.AI.Extensions.OpenAI;
using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;
using OpenAI.Responses;

#pragma warning disable AAIP001, OPENAI001

var endpoint = "https://<account>.services.ai.azure.com/api/projects/<project>";
var chatModel = "gpt-4o";
var embeddingModel = "text-embedding-3-small";
var agentName = "memory-agent";
var memoryStoreName = "foundry-memory-rag-store";
var samplePath =
    @"<path-to-foundry-samples>\samples\csharp\hosted-agents\agent-framework\foundry-memory-rag\src\foundry-memory-rag";

AIProjectClient projectClient = new(new Uri(endpoint), new DefaultAzureCredential());
var agentsClient = projectClient.AgentAdministrationClient;

HostedAgentDefinition definition = new(cpu: "0.5", memory: "1Gi")
{
    Versions = { new ProtocolVersionRecord(ProjectsAgentProtocol.Responses, "2.0.0") },
    CodeConfiguration = new(
        runtime: "dotnet_10",
        entryPoint: ["dotnet", "foundry-memory-rag.dll"],
        dependencyResolution: CodeDependencyResolution.RemoteBuild),
};
definition.EnvironmentVariables.Add("FOUNDRY_PROJECT_ENDPOINT", endpoint);
definition.EnvironmentVariables.Add("AZURE_AI_MODEL_DEPLOYMENT_NAME", chatModel);
definition.EnvironmentVariables.Add("AZURE_AI_EMBEDDING_DEPLOYMENT_NAME", embeddingModel);
definition.EnvironmentVariables.Add("AZURE_AI_MEMORY_STORE_ID", memoryStoreName);

ProjectsAgentVersion? created = null;
AgentEndpointConfiguration? originalEndpoint = null;
try
{
    created = agentsClient.CreateAgentVersionFromCode(
        agentName, samplePath, new AgentVersionFromCodeMetadata(definition));
    Console.WriteLine($"Created hosted agent version {created.Version}");

    for (var attempt = 1; attempt <= 60; attempt++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(10));
        created = agentsClient.GetAgentVersion(agentName, created.Version);
        Console.WriteLine($"Provisioning status: {created.Status} (attempt {attempt}/60)");
        if (created.Status == AgentVersionStatus.Active) break;
        if (created.Status == AgentVersionStatus.Failed)
            throw new InvalidOperationException("Hosted agent provisioning failed.");
    }

    ProjectsAgentRecord agent = agentsClient.GetAgent(agentName);
    originalEndpoint = agent.AgentEndpoint;
    agentsClient.PatchAgent(agentName, new PatchAgentOptions
    {
        AgentEndpoint = new AgentEndpointConfiguration
        {
            VersionSelector = new([new FixedRatioVersionSelectionRule(created.Version, 100)]),
            ProtocolConfiguration = new() { Responses = new ResponsesProtocolConfiguration() },
        },
    });

    ProjectResponsesClient responsesClient = projectClient.ProjectOpenAIClient
        .GetProjectResponsesClientForAgentEndpoint(agentName);

    ResponseResult first = responsesClient.CreateResponse(
        "Hi! My name is Linda and I'm vegetarian. Please remember that.");
    Console.WriteLine(first.GetOutputText());

    Thread.Sleep(TimeSpan.FromSeconds(10));

    ResponseResult second = responsesClient.CreateResponse(
        "Do you remember my name and any dietary preference I told you earlier?");
    Console.WriteLine(second.GetOutputText());
}
finally
{
    if (originalEndpoint is not null)
        agentsClient.PatchAgent(agentName, new PatchAgentOptions { AgentEndpoint = originalEndpoint });
    if (created is not null)
        agentsClient.DeleteAgentVersion(agentName, created.Version, force: true);
}

Spuštění aplikace:

dotnet run

Tento kód nahraje ukázku paměti jako novou verzi hostovaného agenta, dočasně odkazuje hostovaného agenta na tuto verzi, dočasně ho vyvolá dvakrát jako stejný přihlášený uživatel a obnoví konfiguraci předchozího koncového bodu po dokončení.

Krok 5: Ověření zachování paměti

První volání ukládá informaci do paměťového úložiště. Druhé volání si v samostatném požadavku vyžádá zapamatovanou informaci. Pokud je úložiště paměti správně nakonfigurované, odpověď zmíní stejný název a dietní předvolbu, kterou jste zadali v prvním požadavku. Extrakce paměti je asynchronní, takže mezi dvěma voláními úložiště povolte několik sekund indexování paměti.

Vyčistěte zdroje

Až skončíte, odstraňte prostředky, aby vám přestaly být účtovány poplatky.

K odstranění úložiště paměti použijte příkaz AIProjectClient. Spusťte tento skript v prostředí Python, ve kterém jsou nainstalované balíčky azure-ai-projects a azure-identity (například spusťte pip install "azure-ai-projects>=2.3.0"):

import asyncio
from azure.identity.aio import DefaultAzureCredential
from azure.ai.projects.aio import AIProjectClient

async def delete():
    async with (
        DefaultAzureCredential() as credential,
        AIProjectClient(
            endpoint="https://<account>.services.ai.azure.com/api/projects/<project>",
            credential=credential,
            allow_preview=True,
        ) as project,
    ):
        await project.beta.memory_stores.delete("agent_framework_memory")

asyncio.run(delete())

Odstraňte agenta a jeho prostředky Azure:

Warning

Pokud aktuální azd prostředí vytvořilo projekt Foundry, azd down trvale odstraní skupinu prostředků projektu a vše v ní. Pokud jste během inicializace vybrali existující projekt, azd down ponechá projekt, jeho skupinu prostředků, hostovaného agenta a další prostředky rychlého startu. Pokud chcete odstranit prostředky, které už nepotřebujete z existujícího projektu, odstraňte je samostatně.

azd down

Pokud chcete odstranit úložiště paměti, použijte stejný vzor skriptu s názvem úložiště paměti:

import asyncio
import os

from azure.ai.projects.aio import AIProjectClient
from azure.identity.aio import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()


async def delete() -> None:
    async with (
        DefaultAzureCredential() as credential,
        AIProjectClient(
            endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
            credential=credential,
            allow_preview=True,
        ) as project,
    ):
        await project.beta.memory_stores.delete(os.environ["MEMORY_STORE_NAME"])


asyncio.run(delete())

Pokud jste pro účely tohoto rychlého startu vytvořili vyhrazenou skupinu prostředků nebo projekt, odstraňte ji z portálu Azure po tom, co už nepotřebujete nasazení chatu, vložení nasazení nebo hostovaného agenta.

Kód nasazení už odstraní verzi hostovaného agenta a po dokončení obnoví předchozí konfiguraci koncového bodu. Pokud chcete odstranit úložiště paměti, přidejte tento kód do konzolové aplikace, která má Azure.AI.Projects nainstalované (předběžné verze) a Azure.Identity balíčky:

using Azure.AI.Projects;
using Azure.Identity;

#pragma warning disable AAIP001

var endpoint = "https://<account>.services.ai.azure.com/api/projects/<project>";
var memoryStoreName = "foundry-memory-rag-store";

AIProjectClient projectClient = new(new Uri(endpoint), new DefaultAzureCredential());
projectClient.MemoryStores.DeleteMemoryStore(memoryStoreName);
Console.WriteLine($"Deleted memory store '{memoryStoreName}'.");

Pokud jste pro účely tohoto rychlého startu vytvořili vyhrazenou skupinu prostředků nebo projekt, odstraňte ji z portálu Azure po tom, co už nepotřebujete nasazení chatu, vložení nasazení nebo hostovaného agenta.

Troubleshooting

Problém Řešení
Nasazený agent nemá žádnou paměť nebo MEMORY_STORE_NAME je prázdný. Potvrďte, že se postprovision hook spustil při azd provision a že je u azure.yaml nastavena hodnota MEMORY_STORE_NAME. Znovu spusťte azd provision, aby se hook spustil znovu.
Zápisy do paměti selžou s chybou 401 a úložiště zůstane prázdné. Ověřte, že volající už má přístup Foundry User v rozsahu projektu Foundry, a ve stejném rozsahu přiřaďte roli Cognitive Services OpenAI User vaší identitě i identitě modulu runtime nasazeného agenta.
azd provision selže s chybou oprávnění Ověřte, že vaše identita obsahuje role projektu uvedené v části Požadavky.
project.beta.memory_stores.create(...) selže s chybou Authentication to the Azure OpenAI resource failed Ověřte, že vaše identita už má v oboru projektu Foundry přístup uživatele Foundry a také má v daném oboru roli uživatele OpenAI služeb Cognitive Services . Ověřte také, že AZURE_AI_EMBEDDING_MODEL_DEPLOYMENT_NAME odkazuje na platné nasazení modelu pro vektorizaci.
Nasazení v Pythonu je úspěšné, ale druhé volání si uloženou informaci nevybaví. Počkejte několik sekund před druhým voláním, aby úložiště paměti dokončilo indexování, a pak skript spusťte znovu.
Agent si neodpomene fakt, který jste sdíleli. Nechte několik sekund po uložení faktu před dotazem, takže úložiště dokončí indexování paměti.
Agent nemůže po nasazení číst ani zapisovat vzpomínky. Ověřte, že hook postprovision vytvořil úložiště pro stejný projekt, do kterého je agent nasazen.

Co jste se naučili

V tomto rychlém průvodci vám:

  • Vytvořili jste úložiště paměti Foundry s funkcí profilu uživatele.
  • Nasadili jsme hostovaného agenta, který čte a zapisuje do úložiště prostřednictvím FoundryMemoryProvider rozhraní příkazového řádku pro vývojáře Azure, sady Python SDK nebo sady .NET SDK.
  • Bylo ověřeno, že si agent pamatuje informace o uživateli napříč samostatnými relacemi, a to buď lokálně pomocí Azure Developer CLI, nebo vzdáleně pomocí sady SDK pro Python nebo .NET po nasazení.

Další krok

Vyhodnocení hostovaného agenta

Související obsah

  • Poslední aktualizace v