ChatHistory Serialization & Deserialization with GroupChatOrchestration

[hellodhana]

I am migrating from AgentGroupChat to GroupChatOrchestration. We use teams chatbot for our Multiagent orchestration and we serialize and deserialize messages between every user conversation. Earlier we used serialize/deserialize functionality from ChatHistory to do this.

How to do this with GroupChatOrchestration and InProcessRuntime? What is recommended approach to persist context between multi turn conversation?

[TaoChenOSU]

Hi @hellodhana,

Thank you for your question!

I am assuming you want to invoke the group chat orchestration with some context. This is possible by sending a list of messages to invoke the orchestration. And to save the conversation, you need to overwrite the GroupChatManager to save the messages from the agents to your storage. Please refer to this guide on how to create a custom group chat manager: https://learn.microsoft.com/en-us/semantic-kernel/frameworks/agent/agent-orchestration/group-chat?pivots=programming-language-python#customize-the-group-chat-manager

Please note that in the new orchestrations, the agents do not share a single chat history as agents may perform internal processing before responding to a request thus the internal processing steps (tool calling) aren't shared.

Feel free to reach out if you need further assistance.

[Graph2133]

Hi @TaoChenOSU , @hellodhana !

I would like to follow up on the conversation because serialization/deserialization of ChatHistory and chat continuation in SemanticKernel Orchestration are likely common tasks, but they are not thoroughly documented. Hopefully, this might be helpful to others.

After doing some investigation, it appears that extending GroupChatOrchestration<TInput, TOutput> and overriding StartAsync would provide a cleaner and more maintainable solution compared to injecting chat history directly into GroupChatManager (which is primarily responsible for agent selection and flow control). The GroupChatOrchestration used in the examples is also extending GroupChatOrchestration<TInput, TOutput>, but its class structure seems to be more of a simplified example for demonstration purposes.

First, you need to define your own orchestration class:

    public class YOURChatOrchestration(GroupChatManager manager, ChatHistory chatHistory, params Agent[] members) : GroupChatOrchestration<string, string>(manager, members)
    {
        protected override ValueTask StartAsync(IAgentRuntime runtime, TopicId topic, IEnumerable<ChatMessageContent> input, AgentType? entryAgent)
        {

            if (!entryAgent.HasValue)
            {
                throw new ArgumentException("Entry agent is not defined.", nameof(entryAgent));
            }  

            chatHistory.AddRange(input); // This will be an input from InvokeAsync

            return runtime.SendMessageAsync(chatHistory.AsInputTaskMessage(), entryAgent.Value);
        }
    }

The key here is AsInputTaskMessage from namespace Microsoft.SemanticKernel.Agents.Orchestration.Extensions and extending constructor with ChatHistory.

Then the idea is to fill chat history from previous conversations because you will have to create a new instance of YOURChatOrchestration per each user request anyway. Everything else (including population of chat history, registration of callbacks etc.) will be the same as in GroupChatManger docs.

       var history = new ChatHistory() // Here you can populate your history from previous chats or other data sources
        var orchestration = new YOURChatOrchestration(manager, history, [list_of_your_agents])
        var runtime = new InProcessRuntime();
        await runtime.StartAsync();
        
        // Then just invoke orchestration with last user message
        var orchestractionResult = await orchestration.InvokeAsync(userMessage, runtime);
     ......

It’s a much simpler solution than extending GroupChatManager, though it may not fit your specific use case. You also mentioned InProcessRuntime. I was expecting it to provide some kind of storage that could be reused across follow-up conversations, but unfortunately, that’s not the case. It would be great to have some built-in functionality to automatically populate the chat history before a orchestration (runtime) starts.

Good luch with your chat app 😊