Partager via

Comment diffuser en continu les réponses de l’agent. (Expérimental)

  • Article

Avertissement

L’infrastructure de l’agent de noyau sémantique est expérimentale, toujours en cours de développement et est susceptible de changer.

Qu’est-ce qu’une réponse diffusée en continu ?

Une réponse diffusée remet le contenu du message en petits blocs incrémentiels. Cette approche améliore l’expérience utilisateur en leur permettant d’afficher et d’interagir avec le message au fur et à mesure qu’il se déroule, plutôt que d’attendre la totalité de la réponse à charger. Les utilisateurs peuvent commencer à traiter immédiatement les informations, ce qui améliore le sens de la réactivité et de l’interactivité. Par conséquent, il réduit les retards et maintient les utilisateurs plus engagés tout au long du processus de communication.

Références de streaming :

Diffusion en continu dans le noyau sémantique

Les services IA qui prennent en charge la diffusion en continu dans le noyau sémantique utilisent différents types de contenu par rapport à ceux utilisés pour les messages entièrement formés. Ces types de contenu sont spécifiquement conçus pour gérer la nature incrémentielle des données de streaming. Les mêmes types de contenu sont également utilisés dans l’Infrastructure de l’agent à des fins similaires. Cela garantit la cohérence et l’efficacité entre les deux systèmes lors de la gestion des informations de diffusion en continu.

Les agents sont actuellement indisponibles en Java.

Appel de l’agent de streaming

Agent Framework prend en charge les réponses diffusées en continu lors de l’utilisation de la conversation de l’agent ou lors de l’appel direct d’un agent d’achèvement de conversation ou de l’agent d’assistant Open AI. Dans les deux modes, l’infrastructure fournit des réponses de manière asynchrone à mesure qu’elles sont diffusées en continu. Parallèlement à la réponse diffusée, un historique cohérent et non diffusé en continu est conservé pour suivre la conversation. Cela garantit une interaction en temps réel et un enregistrement fiable du flux de la conversation.

Réponse diffusée en continu de l’agent de saisie semi-automatique de conversation

Lors de l’appel d’une réponse diffusée à partir d’un agent d’achèvement de conversation, l’historique des conversations est mis à jour une fois la réponse complète reçue. Bien que la réponse soit diffusée de manière incrémentielle, l’historique enregistre uniquement le message complet. Cela garantit que l’historique des conversations reflète les réponses entièrement formées à des fins de cohérence.

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

Les agents sont actuellement indisponibles en Java.

Réponse diffusée en continu de l’agent Assistant Open AI

Lors de l’appel d’une réponse diffusée à partir d’un agent d’Assistant Open AI, un historique de conversation facultatif peut être fourni pour capturer les messages complets pour une analyse plus approfondie si nécessaire. Étant donné que l’Assistant conserve l’état de la conversation en tant que thread distant, la capture de ces messages n’est pas toujours nécessaire. La décision de stocker et d’analyser la réponse complète dépend des exigences spécifiques de l’interaction.

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

Les agents sont actuellement indisponibles en Java.

Diffusion en continu avec conversation de l’agent

Lors de l’utilisation de la conversation d’agent, l’historique complet des conversations est toujours conservé et est accessible directement via l’instance de conversation de l’agent. Par conséquent, la différence clé entre les appels diffusés en continu et les appels non diffusés réside dans la méthode de remise et le type de contenu résultant. Dans les deux cas, les utilisateurs peuvent toujours accéder à l’historique complet, mais les réponses diffusées en continu fournissent des mises à jour en temps réel à mesure que la conversation progresse. Cela permet une plus grande flexibilité dans la gestion des interactions, en fonction des besoins de l’application.

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

Les agents sont actuellement indisponibles en Java.