Compartilhar via

Como transmitir respostas do agente

  • Artigo

Aviso

O Framework de Agente de Kernel Semântico está em versão prévia e está sujeito a alterações.

O que é uma resposta transmitida?

Uma resposta transmitida entrega o conteúdo da mensagem em partes pequenas e incrementais. Essa abordagem aprimora a experiência do usuário, permitindo que ele visualize e interaja com a mensagem à medida que ela se desenrola, em vez de esperar que toda a resposta seja carregada. Os usuários podem começar a processar informações imediatamente, melhorando a sensação de capacidade de resposta e interatividade. Como resultado, minimiza atrasos e mantém os usuários mais engajados durante todo o processo de comunicação.

Referências de streaming:

Streaming no kernel semântico

Os Serviços de IA que dão suporte ao streaming no Kernel Semântico usam tipos de conteúdo diferentes em comparação com aqueles usados para mensagens totalmente formadas. Esses tipos de conteúdo são projetados especificamente para lidar com a natureza incremental dos dados de streaming. Os mesmos tipos de conteúdo também são utilizados no Agent Framework para fins semelhantes. Isso garante consistência e eficiência em ambos os sistemas ao lidar com informações de streaming.

No momento, os agentes não estão disponíveis em Java.

Invocação do agente de streaming

O Agent Framework oferece suporte a respostas transmitidas ao usar o Agent Chat ou ao invocar diretamente um Chat Completion Agent ou um Open AI Assistant Agent. Em ambos os modos, a estrutura fornece respostas de forma assíncrona à medida que são transmitidas. Juntamente com a resposta transmitida, um histórico consistente e não transmitido é mantido para rastrear a conversa. Isso garante interação em tempo real e um registro confiável do fluxo da conversa.

Resposta transmitida do Agente de conclusão de bate-papo

Ao invocar uma resposta transmitida de um agente de conclusão de chat, o histórico de chat é atualizado após o recebimento da resposta completa. Embora a resposta seja transmitida de forma incremental, o histórico registra apenas a mensagem completa. Isso garante que o Histórico de bate-papo reflita respostas totalmente formadas para consistência.

// 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)...
}

No momento, os agentes não estão disponíveis em Java.

Resposta transmitida do Open AI Assistant Agent

Ao invocar uma resposta transmitida de um agente do Open AI Assistant, um histórico de bate-papo opcional pode ser fornecido para capturar as mensagens completas para análise posterior, se necessário. Como o assistente mantém o estado da conversa como um thread remoto, nem sempre é necessário capturar essas mensagens. A decisão de armazenar e analisar a resposta completa depende dos requisitos específicos da interação.

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

No momento, os agentes não estão disponíveis em Java.

Transmissão com o bate-papo do agente

Ao usar o Agent Chat, o histórico completo de conversas é sempre preservado e pode ser acessado diretamente por meio da instância do Agent Chat. Portanto, a principal diferença entre invocações transmitidas e não transmitidas está no método de entrega e no tipo de conteúdo resultante. Em ambos os casos, os usuários ainda podem acessar o histórico completo, mas as respostas transmitidas fornecem atualizações em tempo real à medida que a conversa avança. Isso permite maior flexibilidade no tratamento de interações, dependendo das necessidades do aplicativo.

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

No momento, os agentes não estão disponíveis em Java.