Compartir a través de

Conversaciones y subprocesos de múltiples turnos en el Microsoft Agent Framework

El Microsoft Agent Framework ofrece soporte integrado para gestionar conversaciones de varios turnos con agentes de IA. Esto incluye el mantenimiento del contexto en varias interacciones. Los distintos tipos de agente y los servicios subyacentes que se usan para compilar agentes pueden admitir diferentes tipos de subprocesos y el marco del agente abstrae estas diferencias, lo que proporciona una interfaz coherente para los desarrolladores.

Por ejemplo, cuando se utiliza un ChatClientAgent basado en un agente de fundición, el historial de conversaciones se conserva en el servicio. Mientras que, cuando se usa chatClientAgent en función de la finalización del chat con gpt-4.1, el historial de conversaciones está en memoria y lo administra el agente.

El AgentThread tipo es la abstracción que representa un hilo de conversación con un agente. AIAgent Las instancias no tienen estado y la misma instancia del agente se puede usar con varias AgentThread instancias. Por lo tanto, todo el estado se conserva en el AgentThread. Un AgentThread puede representar el historial de chat más cualquier otro estado que el agente necesite conservar en varias interacciones. El historial de chats se puede almacenar en el propio subproceso o de forma remota, con la AgentThread única referencia al historial de chat remoto. El AgentThread estado también puede incluir recuerdos o referencias a memorias almacenadas de forma remota.

Sugerencia

Para obtener más información sobre el historial de chat y la memoria en el marco del agente, consulte Historial y memoria del chat del agente.

Creación de AgentThread

AgentThread Las instancias se pueden crear de dos maneras:

  1. Llamando al agente con GetNewThread.
  2. Al ejecutar el agente y no proporcionar un AgentThread. En este caso, el agente creará un objeto desechable AgentThread con un subproceso subyacente que solo se usará durante la duración de la ejecución.

Algunos subprocesos subyacentes pueden crearse de forma persistente en un servicio subyacente, donde el servicio requiere esto, por ejemplo, Agentes de Foundry o Respuestas de OpenAI. Cualquier limpieza o eliminación de estos subprocesos es responsabilidad del usuario.

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

Almacenamiento de AgentThread

AgentThread Las instancias se pueden serializar y almacenar para su uso posterior. Esto permite la conservación del contexto de conversación en diferentes sesiones o llamadas de servicio.

En los casos en los que el historial de conversaciones se almacena en un servicio, el dato serializado AgentThread contendrá un identificador del hilo en el servicio. En los casos en los que el historial de conversaciones se administra en memoria, el serializado AgentThread contendrá los propios mensajes.

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

El Microsoft Agent Framework ofrece soporte integrado para gestionar conversaciones de varios turnos con agentes de IA. Esto incluye el mantenimiento del contexto en varias interacciones. Los distintos tipos de agente y los servicios subyacentes que se usan para compilar agentes pueden admitir diferentes tipos de subprocesos y Agent Framework abstrae estas diferencias, lo que proporciona una interfaz coherente para los desarrolladores.

Por ejemplo, cuando se usa un ChatAgent basado en un agente Foundry, el historial de conversaciones se conserva en el servicio. Al usar una ChatAgent basada en la finalización del chat con gpt-4, el historial de conversaciones se mantiene en memoria y es gestionado por el agente.

Las diferencias entre los modelos de subprocesos subyacentes se abstraen a través del AgentThread tipo .

Relación Agent/AgentThread

AIAgent Las instancias no tienen estado y la misma instancia del agente se puede usar con varias AgentThread instancias.

No todos los agentes admiten todos los tipos de subprocesos, sin embargo. Por ejemplo, si usa un ChatClientAgent con el servicio de respuestas, las instancias de AgentThread creadas por este agente no funcionarán con un ChatClientAgent utilizando el servicio Foundry Agent. Esto se debe a que ambos servicios admiten guardar el historial de conversaciones en el servicio, y el AgentThread únicamente tiene una referencia a este subproceso administrado del servicio.

Por lo tanto, se considera inseguro utilizar una instancia de AgentThread creada por un agente con una instancia de otro agente diferente, a menos que conozca el modelo de hilos subyacente y sus implicaciones.

Compatibilidad con subprocesos por servicio o protocolo

Service Compatibilidad con subprocesos
Agentes de fundición Subprocesos persistentes gestionados por un servicio
Respuestas de OpenAI Subprocesos persistentes administrados por el servicio O subprocesos en memoria
OpenAI ChatCompletion Subprocesos en memoria
Asistentes de OpenAI Subprocesos administrados por el servicio
A2A Subprocesos administrados por el servicio

Creación de AgentThread

AgentThread Las instancias se pueden crear de dos maneras:

  1. Llamando al agente con get_new_thread().
  2. Al ejecutar el agente y no proporcionar un AgentThread. En este caso, el agente creará un objeto desechable AgentThread con un subproceso subyacente que solo se usará durante la duración de la ejecución.

Algunos subprocesos subyacentes pueden crearse de forma persistente en un servicio subyacente, donde el servicio requiere esto, por ejemplo, agentes de Azure AI o respuestas de OpenAI. Cualquier limpieza o eliminación de estos subprocesos es responsabilidad del usuario.

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

Almacenamiento de AgentThread

AgentThread Las instancias se pueden serializar y almacenar para su uso posterior. Esto permite la conservación del contexto de conversación en diferentes sesiones o llamadas de servicio.

En los casos en los que el historial de conversaciones se almacena en un servicio, el dato serializado AgentThread contendrá un identificador del hilo en el servicio. En los casos en los que el historial de conversaciones se administra en memoria, el serializado AgentThread contendrá los propios mensajes.

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

Almacenes de mensajes personalizados

En el caso de los subprocesos en memoria, puede proporcionar una implementación de almacén de mensajes personalizada para controlar cómo se almacenan y recuperan los mensajes:

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

Relación Agent/AgentThread

Agents son sin estado y la misma instancia del agente se puede usar con varias AgentThread instancias.

No todos los agentes admiten todos los tipos de subprocesos, sin embargo. Por ejemplo, si usa un ChatAgent con el servicio de respuestas de OpenAI y las instancias store=True, AgentThread utilizadas por este agente, no funcionarán con un ChatAgent con el servicio de agente de Azure AI, ya que los thread_ids no son compatibles.

Por lo tanto, se considera inseguro utilizar una instancia de AgentThread creada por un agente con una instancia de otro agente diferente, a menos que conozca el modelo de hilos subyacente y sus implicaciones.

Ejemplo práctico de varios turnos

Este es un ejemplo completo que muestra cómo mantener el contexto en varias interacciones:

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

Pasos siguientes

Memoria del agente

  • Last updated on