Compartir a través de

Cómo transmitir respuestas del agente. (Experimental)

  • Artículo

Advertencia

El marco del agente de kernel semántico es experimental, todavía en desarrollo y está sujeto a cambios.

¿Qué es una respuesta transmitida?

Una respuesta transmitida entrega el contenido del mensaje en fragmentos pequeños e incrementales. Este enfoque mejora la experiencia del usuario al permitirle ver y interactuar con el mensaje a medida que se desarrolla, en lugar de esperar a que se cargue toda la respuesta. Los usuarios pueden comenzar a procesar la información inmediatamente, mejorando la sensación de capacidad de respuesta e interactividad. Como resultado, minimiza los retrasos y mantiene a los usuarios más comprometidos durante el proceso de comunicación.

Referencias de streaming:

Streaming en kernel semántico

Los servicios de IA que admiten streaming en kernel semántico usan tipos de contenido diferentes en comparación con los usados para los mensajes totalmente formados. Estos tipos de contenido están diseñados específicamente para controlar la naturaleza incremental de los datos de streaming. Los mismos tipos de contenido también se usan dentro del marco del agente para fines similares. Esto garantiza la coherencia y la eficacia en ambos sistemas cuando se trabaja con la información de streaming.

Los agentes no están disponibles actualmente en Java.

Invocación del agente de streaming

Agent Framework admite respuestas transmitidas al usar chat del agente o al invocar directamente un agente de finalización de chat o open AI Assistant Agent. En cualquier modo, el marco entrega respuestas de forma asincrónica a medida que se transmiten. Junto con la respuesta transmitida, se mantiene un historial coherente y no transmitido para realizar un seguimiento de la conversación. Esto garantiza la interacción en tiempo real y un registro confiable del flujo de la conversación.

Respuesta transmitida del agente de finalización de chat

Al invocar una respuesta transmitida desde un agente de finalización de chat, el historial de chat se actualiza después de recibir la respuesta completa. Aunque la respuesta se transmite de forma incremental, el historial registra solo el mensaje completo. Esto garantiza que el historial de chat refleje las respuestas totalmente formadas para la coherencia.

// Define agent
ChatCompletionAgent agent = ...;

// Create a ChatHistory object to maintain the conversation state.
ChatHistory chat = [];

// Add a user message to the conversation
chat.Add(new ChatMessageContent(AuthorRole.User, "<user input>"));

// Generate the streamed agent response(s)
await foreach (StreamingChatMessageContent response in agent.InvokeStreamingAsync(chat))
{
  // Process streamed response(s)...
}

# Define agent
agent = ChatCompletionAgent(...)

# Create a ChatHistory object to maintain the conversation state.
chat = ChatHistory()

# Add a user message to the conversation
chat.add_message(ChatMessageContent(AuthorRole.USER, "<user input>"))

# Generate the streamed agent response(s)
async for response in agent.invoke_stream(chat)
{
  # Process streamed response(s)...
}

Los agentes no están disponibles actualmente en Java.

Respuesta transmitida del agente open AI Assistant

Al invocar una respuesta transmitida desde un agente de Open AI Assistant, se puede proporcionar un historial de chat opcional para capturar los mensajes completos para su análisis posterior si es necesario. Dado que el asistente mantiene el estado de la conversación como un subproceso remoto, capturar estos mensajes no siempre es necesario. La decisión de almacenar y analizar la respuesta completa depende de los requisitos específicos de la interacción.

// Define agent
OpenAIAssistantAgent agent = ...;

// Create a thread for the agent conversation.
string threadId = await agent.CreateThreadAsync();

// Add a user message to the conversation
chat.Add(threadId, new ChatMessageContent(AuthorRole.User, "<user input>"));

// Generate the streamed agent response(s)
await foreach (StreamingChatMessageContent response in agent.InvokeStreamingAsync(threadId))
{
  // Process streamed response(s)...
}

// Delete the thread when it is no longer needed
await agent.DeleteThreadAsync(threadId);

# Define agent
agent = OpenAIAssistantAgent(...)

# Create a thread for the agent conversation.
thread_id = await agent.create_thread()

# Add user message to the conversation
await agent.add_chat_message(ChatMessageContent(role=AuthorRole.USER, content="<user input>"))

# Generate the streamed agent response(s)
async for response in agent.invoke_stream(thread_id=thread_id):
  # Process streamed response(s)...

Los agentes no están disponibles actualmente en Java.

Streaming con chat de agente

Cuando se usa El chat del agente, siempre se conserva el historial de conversaciones completo y se puede acceder directamente a través de la instancia de Chat del agente. Por lo tanto, la diferencia clave entre las invocaciones transmitidas y no transmitidas se encuentra en el método de entrega y el tipo de contenido resultante. En ambos casos, los usuarios todavía pueden acceder al historial completo, pero las respuestas transmitidas proporcionan actualizaciones en tiempo real a medida que avanza la conversación. Esto permite una mayor flexibilidad para controlar las interacciones, en función de las necesidades de la aplicación.

// Define agents
ChatCompletionAgent agent1 = ...;
OpenAIAssistantAgent agent2 = ...;

// Create chat with participating agents.
AgentGroupChat chat =
  new(agent1, agent2)
  {
    // Override default execution settings
    ExecutionSettings =
    {
        TerminationStrategy = { MaximumIterations = 10 }
    }
  };

// Invoke agents
string lastAgent = string.Empty;
await foreach (StreamingChatMessageContent response in chat.InvokeStreamingAsync())
{
    if (!lastAgent.Equals(response.AuthorName, StringComparison.Ordinal))
    {
        // Process begining of agent response
        lastAgent = response.AuthorName;
    }

    // Process streamed content...
} 

# Define agents
agent1 = ChatCompletionAgent(...)
agent2 = OpenAIAssistantAgent(...)

# Create chat with participating agents
chat = AgentGroupChat(
  agents=[agent1, agent2],
  termination_strategy=DefaultTerminationStrategy(maximum_iterations=10),
)

# Invoke agents
last_agent = None
async for response in chat.invoke_stream():
    if message.content is not None:
        if last_agent != response.name:
            # Process beginning of agent response
            last_agent = message.name
        # Process streamed content

Los agentes no están disponibles actualmente en Java.