Partilhar via

Como transmitir respostas do agente. (Experimental)

  • Artigo

Aviso

O Semantic Kernel Agent Framework é experimental, ainda está em desenvolvimento e está sujeito a alterações.

O que é uma resposta transmitida?

Uma resposta transmitida entrega o conteúdo da mensagem em pequenos blocos incrementais. Essa abordagem melhora a experiência do usuário, permitindo que ele visualize e se envolva 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 envolvidos durante todo o processo de comunicação.

Referências de streaming:

Streaming no kernel semântico

Os Serviços de IA que suportam 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 dentro do Agent Framework para fins semelhantes. Isso garante consistência e eficiência em ambos os sistemas ao lidar com informações de streaming.

Os agentes estão atualmente indisponíveis em Java.

Invocação do agente de streaming

O Agent Framework suporta respostas transmitidas ao usar o Chat do Agente ou ao invocar diretamente um Agente de Conclusão de Chat ou um Agente Assistente de IA Aberto. 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 acompanhar a conversa. Isso garante interação em tempo real e um registro confiável do fluxo da conversa.

Resposta transmitida do Chat Completion Agent

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 incrementalmente, 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)...
}

Os agentes estão atualmente indisponíveis em Java.

Resposta transmitida do Open AI Assistant Agent

Ao invocar uma resposta transmitida de um Open AI Assistant Agent, um Histórico de Chat opcional pode ser fornecido para capturar as mensagens completas para análise adicional, se necessário. Como o assistente mantém o estado de conversação como um thread remoto, a captura dessas mensagens nem sempre é necessária. 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)...

Os agentes estão atualmente indisponíveis em Java.

Streaming com o Agent Chat

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 progride. Isso permite maior flexibilidade no manuseio 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

Os agentes estão atualmente indisponíveis em Java.