Udostępnij przez

Zapisywanie i wznawianie konwersacji agentowych

W tym samouczku przedstawiono sposób utrwalania konwersacji agenta (AgentThread) w magazynie i ponownego załadowania go później.

W przypadku hostowania agenta w usłudze, a nawet w aplikacji klienckiej, często chcesz zachować stan konwersacji między wieloma żądaniami lub sesjami. Utrwalając element AgentThread, można zapisać kontekst konwersacji i załadować go ponownie później.

Wymagania wstępne

Aby uzyskać wymagania wstępne i zainstalować pakiety NuGet, zobacz krok Tworzenie i uruchamianie prostego agenta w tym samouczku.

Utrwalanie i wznawianie konwersacji

Utwórz agenta i uzyskaj nowy wątek, który będzie utrzymywać stan konwersacji.

using System;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using OpenAI;

AIAgent agent = new AzureOpenAIClient(
    new Uri("https://<myresource>.openai.azure.com"),
    new AzureCliCredential())
     .GetChatClient("gpt-4o-mini")
     .CreateAIAgent(instructions: "You are a helpful assistant.", name: "Assistant");

AgentThread thread = agent.GetNewThread();

Uruchom agenta, przekazując wątek do agenta, aby AgentThread uwzględnił tę wymianę.

// Run the agent and append the exchange to the thread
Console.WriteLine(await agent.RunAsync("Tell me a short pirate joke.", thread));

Wywołaj metodę Serialize w wątku, aby serializować ją do elementu JsonElement. Następnie można go przekonwertować na ciąg znaków i zapisać w bazie danych, magazynie obiektów blob lub pliku.

using System.IO;
using System.Text.Json;

// Serialize the thread state
string serializedJson = thread.Serialize(JsonSerializerOptions.Web).GetRawText();

// Example: save to a local file (replace with DB or blob storage in production)
string filePath = Path.Combine(Path.GetTempPath(), "agent_thread.json");
await File.WriteAllTextAsync(filePath, serializedJson);

Załaduj utrwalone dane JSON z magazynu i utwórz ponownie wystąpienie AgentThread z niego. Wątek musi zostać zdeserializowany przy użyciu wystąpienia agenta. Powinien to być ten sam typ agenta, który został użyty do utworzenia oryginalnego wątku. Jest to spowodowane tym, że agenci mogą mieć własne typy wątków i mogą tworzyć wątki z dodatkowymi funkcjami specyficznymi dla tego typu agenta.

// Read persisted JSON
string loadedJson = await File.ReadAllTextAsync(filePath);
JsonElement reloaded = JsonSerializer.Deserialize<JsonElement>(loadedJson, JsonSerializerOptions.Web);

// Deserialize the thread into an AgentThread tied to the same agent type
AgentThread resumedThread = agent.DeserializeThread(reloaded, JsonSerializerOptions.Web);

Aby kontynuować konwersację, użyj wznowionego wątku.

// Continue the conversation with resumed thread
Console.WriteLine(await agent.RunAsync("Now tell that joke in the voice of a pirate.", resumedThread));

W tym samouczku przedstawiono sposób utrwalania konwersacji agenta (AgentThread) w magazynie i ponownego załadowania go później.

W przypadku hostowania agenta w usłudze, a nawet w aplikacji klienckiej, często chcesz zachować stan konwersacji między wieloma żądaniami lub sesjami. Utrwalając element AgentThread, można zapisać kontekst konwersacji i załadować go ponownie później.

Wymagania wstępne

Aby uzyskać wymagania wstępne i zainstalować pakiety języka Python, zobacz krok Tworzenie i uruchamianie prostego agenta w tym samouczku.

Utrwalanie i wznawianie konwersacji

Utwórz agenta i uzyskaj nowy wątek, który będzie utrzymywać stan konwersacji.

from azure.identity import AzureCliCredential
from agent_framework import ChatAgent
from agent_framework.azure import AzureOpenAIChatClient

agent = ChatAgent(
    chat_client=AzureOpenAIChatClient(
        endpoint="https://<myresource>.openai.azure.com",
        credential=AzureCliCredential(),
        ai_model_id="gpt-4o-mini"
    ),
    name="Assistant",
    instructions="You are a helpful assistant."
)

thread = agent.get_new_thread()

Uruchom agenta, przekazując wątek do agenta, aby AgentThread uwzględnił tę wymianę.

# Run the agent and append the exchange to the thread
response = await agent.run("Tell me a short pirate joke.", thread=thread)
print(response.text)

Wywołaj metodę serialize na wątku, aby go zserializować do słownika. Następnie można go przekonwertować na format JSON do przechowywania, a następnie zapisać w bazie danych, w magazynie blobów lub w pliku.

import json
import tempfile
import os

# Serialize the thread state
serialized_thread = await thread.serialize()
serialized_json = json.dumps(serialized_thread)

# Example: save to a local file (replace with DB or blob storage in production)
temp_dir = tempfile.gettempdir()
file_path = os.path.join(temp_dir, "agent_thread.json")
with open(file_path, "w") as f:
    f.write(serialized_json)

Załaduj utrwalone dane JSON z magazynu i utwórz ponownie wystąpienie AgentThread z niego. Wątek musi zostać zdeserializowany przy użyciu wystąpienia agenta. Powinien to być ten sam typ agenta, który został użyty do utworzenia oryginalnego wątku. Jest to spowodowane tym, że agenci mogą mieć własne typy wątków i mogą tworzyć wątki z dodatkowymi funkcjami specyficznymi dla tego typu agenta.

# Read persisted JSON
with open(file_path, "r") as f:
    loaded_json = f.read()

reloaded_data = json.loads(loaded_json)

# Deserialize the thread into an AgentThread tied to the same agent type
resumed_thread = await agent.deserialize_thread(reloaded_data)

Aby kontynuować konwersację, użyj wznowionego wątku.

# Continue the conversation with resumed thread
response = await agent.run("Now tell that joke in the voice of a pirate.", thread=resumed_thread)
print(response.text)

Dalsze kroki

Przechowywanie historii czatów stron trzecich

  • Last updated on