Freigeben über

Streamen von Agentantworten (Experimentell)

  • Artikel

Warnung

Das semantische Kernel-Agent-Framework ist experimentell, befindet sich noch in der Entwicklung und unterliegt Änderungen.

Was ist eine gestreamte Antwort?

Eine gestreamte Antwort liefert den Nachrichteninhalt in kleinen, inkrementellen Blöcken. Mit diesem Ansatz wird die Benutzererfahrung verbessert, indem sie es ihnen ermöglichen, die Nachricht während der Entfaltung anzuzeigen und zu interagieren, anstatt auf die gesamte Antwort auf das Laden zu warten. Benutzer können sofort mit der Verarbeitung von Informationen beginnen und das Gefühl der Reaktionsfähigkeit und Interaktivität verbessern. Dadurch werden Verzögerungen minimiert und die Benutzer während des gesamten Kommunikationsprozesses stärker eingebunden.

Streamingverweise:

Streaming im semantischen Kernel

KI-Dienste , die Streaming im semantischen Kernel unterstützen, verwenden unterschiedliche Inhaltstypen im Vergleich zu denen, die für vollgeformte Nachrichten verwendet werden. Diese Inhaltstypen sind speziell darauf ausgelegt, die inkrementelle Art von Streamingdaten zu behandeln. Dieselben Inhaltstypen werden auch im Agent Framework für ähnliche Zwecke verwendet. Dies sorgt für Konsistenz und Effizienz in beiden Systemen beim Umgang mit Streaminginformationen.

Agents sind derzeit in Java nicht verfügbar.

Aufruf des Streaming-Agents

Das Agent Framework unterstützt gestreamte Antworten bei Verwendung des Agent-Chats oder beim direkten Aufrufen eines Chat-Vervollständigungs-Agents oder open AI Assistant Agent. In beiden Modus liefert das Framework asynchron Antworten, während sie gestreamt werden. Neben der gestreamten Antwort wird ein konsistenter, nicht gestreamter Verlauf beibehalten, um die Unterhaltung nachzuverfolgen. Dadurch wird sowohl die Echtzeitinteraktion als auch eine zuverlässige Aufzeichnung des Unterhaltungsflusses sichergestellt.

Gestreamte Antwort vom Chat-Vervollständigungs-Agent

Wenn Sie eine gestreamte Antwort von einem Chat-Vervollständigungs-Agent aufrufen, wird der Chatverlauf aktualisiert, nachdem die vollständige Antwort empfangen wurde. Obwohl die Antwort inkrementell gestreamt wird, zeichnet der Verlauf nur die vollständige Nachricht auf. Dadurch wird sichergestellt, dass der Chatverlauf vollständig gebildete Antworten auf Konsistenz widerspiegelt.

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

Agents sind derzeit in Java nicht verfügbar.

Gestreamte Antwort von Open AI Assistant Agent

Wenn Sie eine gestreamte Antwort von einem Open AI Assistant Agent aufrufen, kann ein optionaler Chatverlauf bereitgestellt werden, um die vollständigen Nachrichten bei Bedarf zur weiteren Analyse zu erfassen. Da der Assistent den Unterhaltungsstatus als Remotethread verwaltet, ist das Erfassen dieser Nachrichten nicht immer erforderlich. Die Entscheidung, die vollständige Antwort zu speichern und zu analysieren, hängt von den spezifischen Anforderungen der Interaktion ab.

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

Agents sind derzeit in Java nicht verfügbar.

Streaming mit Agent-Chat

Bei Verwendung des Agent-Chats wird der vollständige Unterhaltungsverlauf immer beibehalten und kann direkt über die Agent-Chatinstanz aufgerufen werden. Daher liegt der Hauptunterschied zwischen gestreamten und nicht gestreamten Aufrufen in der Übermittlungsmethode und dem resultierenden Inhaltstyp. In beiden Fällen können Benutzer weiterhin auf den vollständigen Verlauf zugreifen, aber gestreamte Antworten bieten Echtzeitaktualisierungen, während die Unterhaltung voranschreitet. Dies ermöglicht eine größere Flexibilität bei der Behandlung von Interaktionen, je nach den Anforderungen der Anwendung.

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

Agents sind derzeit in Java nicht verfügbar.