Konwersacje wielokrotne i wątki w programie Microsoft Agent Framework

// Create a new thread.
AgentThread thread = agent.GetNewThread();
// Run the agent with the thread.
var response = await agent.RunAsync("Hello, how are you?", thread);

// Run an agent with a temporary thread.
response = await agent.RunAsync("Hello, how are you?");

// Create a new thread.
AgentThread thread = agent.GetNewThread();
// Run the agent with the thread.
var response = await agent.RunAsync("Hello, how are you?", thread);

// Serialize the thread for storage.
JsonElement serializedThread = await thread.SerializeAsync();
// Deserialize the thread state after loading from storage.
AgentThread resumedThread = await agent.DeserializeThreadAsync(serializedThread);

// Run the agent with the resumed thread.
var response = await agent.RunAsync("Hello, how are you?", resumedThread);

Platforma Microsoft Agent Framework zapewnia wbudowaną obsługę zarządzania konwersacjami wieloełowymi za pomocą agentów sztucznej inteligencji. Obejmuje to utrzymywanie kontekstu w wielu interakcjach. Różne typy agentów i podstawowe usługi używane do tworzenia agentów mogą obsługiwać różne typy wątków, a Struktura Agentów abstrahuje te różnice, zapewniając spójny interfejs dla deweloperów.

Na przykład w przypadku korzystania z ChatAgent opartego na agencie Foundry, historia konwersacji jest utrwalana w usłudze. Podczas korzystania z elementu opartego ChatAgent na zakończeniu czatu za pomocą biblioteki gpt-4 historia konwersacji jest w pamięci i zarządzana przez agenta.

Różnice między bazowymi modelami wątków są abstrahowane za pośrednictwem typu AgentThread.

Relacja Agent/AgentThread

AIAgent instancje są bezstanowe, a ta sama instancja agenta może być używana z wieloma AgentThread instancjami.

Nie wszyscy agenci obsługują jednak wszystkie typy wątków. Jeśli na przykład używasz elementu ChatClientAgent w ramach usługi odpowiedzi, wystąpienia AgentThread utworzone przez tego agenta nie będą działać w połączeniu z ChatClientAgent, korzystając z usługi agenta Foundry. Dzieje się tak, ponieważ obie usługi obsługują zapisywanie historii konwersacji w usłudze, a AgentThread ma jedynie odniesienie do tego wątku zarządzanego przez usługę.

Dlatego uważa się za niebezpieczne użycie AgentThread wystąpienia, które zostało utworzone przez jednego agenta z innym wystąpieniem agenta, o ile nie znasz podstawowego modelu wątkowania i jego konsekwencji.

Obsługa wielowątkowości przez usługę/protokół

Tworzenie AgentThread

AgentThread wystąpienia można tworzyć na dwa sposoby:

1. Wywołując get_new_thread() agenta.
2. Uruchamiając agenta i nie podając elementu AgentThread. W takim przypadku agent utworzy jednorazowy AgentThread z bazowym wątkiem, który będzie używany tylko przez czas wykonywania.

Niektóre podstawowe wątki mogą być trwale tworzone w usłudze bazowej, jeśli usługa tego wymaga, np. Agentów AI Azure lub odpowiedzi OpenAI. Wszelkie czyszczenie lub usuwanie tych wątków jest obowiązkiem użytkownika.

# Create a new thread.
thread = agent.get_new_thread()
# Run the agent with the thread.
response = await agent.run("Hello, how are you?", thread=thread)

# Run an agent with a temporary thread.
response = await agent.run("Hello, how are you?")

Przechowywanie AgentThread

AgentThread wystąpienia mogą być serializowane i przechowywane do późniejszego użycia. Umożliwia to zachowanie kontekstu konwersacji podczas różnych sesji lub połączeń z usługą.

W przypadku, gdy historia konwersacji jest przechowywana w usłudze, serializowany AgentThread będzie zawierać identyfikator wątku w usłudze. W przypadku, gdy historia konwersacji jest zarządzana w pamięci, serializowana AgentThread będzie zawierać same wiadomości.

# Create a new thread.
thread = agent.get_new_thread()
# Run the agent with the thread.
response = await agent.run("Hello, how are you?", thread=thread)

# Serialize the thread for storage.
serialized_thread = await thread.serialize()
# Deserialize the thread state after loading from storage.
resumed_thread = await agent.deserialize_thread(serialized_thread)

# Run the agent with the resumed thread.
response = await agent.run("Hello, how are you?", thread=resumed_thread)

Niestandardowe magazyny komunikatów

W przypadku wątków w pamięci można udostępnić niestandardową implementację magazynu komunikatów w celu kontrolowania sposobu przechowywania i pobierania komunikatów:

from agent_framework import AgentThread, ChatMessageStore, ChatAgent
from agent_framework.azure import AzureAIAgentClient
from azure.identity.aio import AzureCliCredential

class CustomStore(ChatMessageStore):
    # Implement custom storage logic here
    pass

# You can also provide a custom message store factory when creating the agent
def custom_message_store_factory():
    return CustomStore()  # or your custom implementation

async with AzureCliCredential() as credential:
    agent = ChatAgent(
        chat_client=AzureAIAgentClient(async_credential=credential),
        instructions="You are a helpful assistant",
        chat_message_store_factory=custom_message_store_factory
    )
    # Or let the agent create one automatically
    thread = agent.get_new_thread()
    # thread.message_store is not a instance of CustomStore

Relacja Agent/AgentThread

Agents są bezstanowe, a to samo wystąpienie agenta może być używane z wieloma AgentThread wystąpieniami.

Nie wszyscy agenci obsługują jednak wszystkie typy wątków. Jeśli na przykład korzystasz z ChatAgent z usługi OpenAI Responses i używasz wystąpień store=True oraz AgentThread, nie będą one działały z użyciem ChatAgent z usługi Azure AI Agent, ponieważ identyfikatory wątków nie są zgodne.

Dlatego uważa się za niebezpieczne użycie AgentThread wystąpienia, które zostało utworzone przez jednego agenta z innym wystąpieniem agenta, o ile nie znasz podstawowego modelu wątkowania i jego konsekwencji.

Praktyczny przykład z wieloma zakrętami

Oto kompletny przykład pokazujący sposób utrzymania kontekstu w wielu interakcjach:

from agent_framework import ChatAgent
from agent_framework.azure import AzureAIAgentClient
from azure.identity.aio import AzureCliCredential

async def multi_turn_example():
    async with (
        AzureCliCredential() as credential,
        ChatAgent(
            chat_client=AzureAIAgentClient(async_credential=credential),
            instructions="You are a helpful assistant"
        ) as agent
    ):
        # Create a thread for persistent conversation
        thread = agent.get_new_thread()

        # First interaction
        response1 = await agent.run("My name is Alice", thread=thread)
        print(f"Agent: {response1.text}")

        # Second interaction - agent remembers the name
        response2 = await agent.run("What's my name?", thread=thread)
        print(f"Agent: {response2.text}")  # Should mention "Alice"

        # Serialize thread for storage
        serialized = await thread.serialize()

        # Later, deserialize and continue conversation
        new_thread = await agent.deserialize_thread(serialized)
        response3 = await agent.run("What did we talk about?", thread=new_thread)
        print(f"Agent: {response3.text}")  # Should remember previous context