Microsoft Agent Framework Multi-Turn-Unterhaltungen und Threading (prozessübergreifend)

// 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);

Das Microsoft Agent Framework bietet integrierte Unterstützung für die Verwaltung von Multi-Turn-Konversationen mit KI-Agenten. Dies umfasst die Aufrechterhaltung des Kontexts über mehrere Interaktionen hinweg. Verschiedene Agenttypen und zugrunde liegende Dienste, die zum Erstellen von Agents verwendet werden, unterstützen möglicherweise unterschiedliche Threadingtypen, und das Agent-Framework abstrahiert diese Unterschiede, was entwicklern eine konsistente Schnittstelle bietet.

Wenn Sie z. B. einen ChatAgent auf einem Foundry-Agent basierenden Agent verwenden, wird der Unterhaltungsverlauf im Dienst beibehalten. Wenn Sie einen ChatAgent, der auf einem Chatabschluss mit gpt-4 basiert, verwenden, befindet sich der Unterhaltungsverlauf im Arbeitsspeicher und wird vom Agenten verwaltet.

Die Unterschiede zwischen den zugrunde liegenden Threadingmodellen werden über den AgentThread Typ abstrahiert.

Agent/AgentThread-Beziehung

AIAgent Instanzen sind zustandslos, und dieselbe Agentinstanz kann mit mehreren AgentThread Instanzen verwendet werden.

Nicht alle Agents unterstützen jedoch alle Threadtypen. Wenn Sie z. B. einen ChatClientAgent mit dem Antwortdienst verwenden, funktionieren AgentThread-Instanzen, die von diesem Agenten erstellt wurden, nicht mit einem ChatClientAgent-Dienst, der den Foundry-Agenten verwendet. Dies liegt daran, dass diese Dienste das Speichern des Unterhaltungsverlaufs im Dienst unterstützen und nur AgentThread einen Verweis auf diesen vom Dienst verwalteten Thread haben.

Es gilt daher als unsicher, eine AgentThread Instanz zu verwenden, die von einem Agent mit einer anderen Agentinstanz erstellt wurde, es sei denn, Sie sind sich des zugrunde liegenden Threadingmodells und deren Auswirkungen bewusst.

Threadingunterstützung nach Dienst/Protokoll

AgentThread-Erstellung

AgentThread Instanzen können auf zwei Arten erstellt werden:

1. Durch Aufrufen get_new_thread() des Agents.
2. Indem Sie den Agenten ausführen und AgentThread nicht bereitstellen. In diesem Fall erstellt der Agent einen Throwaway AgentThread mit einem zugrunde liegenden Thread, der nur für die Dauer der Ausführung verwendet wird.

Einige zugrunde liegende Threads können dauerhaft in einem zugrunde liegenden Dienst erstellt werden, bei dem der Dienst dies erfordert, z. B. Azure AI-Agents oder OpenAI-Antworten. Jede Bereinigung oder Löschung dieser Threads liegt in der Verantwortung des Benutzers.

# 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?")

AgentThread-Speicher

AgentThread Instanzen können serialisiert und zur späteren Verwendung gespeichert werden. Dies ermöglicht die Erhaltung des Unterhaltungskontexts über verschiedene Sitzungen oder Dienstanrufe hinweg.

In Fällen, in denen der Unterhaltungsverlauf in einem Dienst gespeichert wird, enthält die serialisierte AgentThread Datei eine ID des Threads im Dienst. In Fällen, in denen der Gesprächsverlauf im Arbeitsspeicher verwaltet wird, enthält die serialisierte AgentThread die Nachrichten selbst.

# 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)

Benutzerdefinierte Nachrichtenspeicher

Für In-Memory-Threads können Sie eine benutzerdefinierte Nachrichtenspeicherimplementierung bereitstellen, um zu steuern, wie Nachrichten gespeichert und abgerufen werden:

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

Agent/AgentThread-Beziehung

Agents sind zustandslos und die gleiche Agentinstanz kann mit mehreren AgentThread Instanzen verwendet werden.

Nicht alle Agents unterstützen jedoch alle Threadtypen. Wenn Sie z.B. einen ChatAgent mit dem OpenAI-Antwortdienst verwenden, werden die Instanzen store=True, AgentThread, die von diesen Agenten genutzt werden, nicht mit einem ChatAgent Azure AI-Agentendienst funktionieren, da die thread_ids nicht kompatibel sind.

Es gilt daher als unsicher, eine AgentThread Instanz zu verwenden, die von einem Agent mit einer anderen Agentinstanz erstellt wurde, es sei denn, Sie sind sich des zugrunde liegenden Threadingmodells und deren Auswirkungen bewusst.

Praktisches Multi-Turn-Beispiel

Hier ist ein vollständiges Beispiel, in dem gezeigt wird, wie Sie den Kontext über mehrere Interaktionen hinweg verwalten:

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