Historia czatów

Obiekt historii czatu służy do obsługi rekordu wiadomości w sesji czatu. Służy do przechowywania komunikatów od różnych autorów, takich jak użytkownicy, asystenci, narzędzia lub system. Podstawowym mechanizmem wysyłania i odbierania wiadomości obiekt historii czatów jest niezbędny do utrzymania kontekstu i ciągłości konwersacji.

Tworzenie obiektu historii czatów

Obiekt historii czatów jest listą pod maską, dzięki czemu można łatwo tworzyć i dodawać wiadomości.

using Microsoft.SemanticKernel.ChatCompletion;

// Create a chat history object
ChatHistory chatHistory = [];

chatHistory.AddSystemMessage("You are a helpful assistant.");
chatHistory.AddUserMessage("What's available to order?");
chatHistory.AddAssistantMessage("We have pizza, pasta, and salad available to order. What would you like to order?");
chatHistory.AddUserMessage("I'd like to have the first option, please.");

# Create a chat history object
chat_history = ChatHistory()

chat_history.add_system_message("You are a helpful assistant.")
chat_history.add_user_message("What's available to order?")
chat_history.add_assistant_message("We have pizza, pasta, and salad available to order. What would you like to order?")
chat_history.add_user_message("I'd like to have the first option, please.")

import com.microsoft.semantickernel.services.chatcompletion.ChatHistory;

// Create a chat history object
ChatHistory chatHistory = new ChatHistory();

chatHistory.addSystemMessage("You are a helpful assistant.");
chatHistory.addUserMessage("What's available to order?");
chatHistory.addAssistantMessage("We have pizza, pasta, and salad available to order. What would you like to order?");
chatHistory.addUserMessage("I'd like to have the first option, please.");

Dodawanie bogatszych wiadomości do historii czatów

Najprostszym sposobem dodawania wiadomości do obiektu historii czatów jest użycie powyższych metod. Można jednak również ręcznie dodać komunikaty, tworząc nowy ChatMessage obiekt. Dzięki temu można podać dodatkowe informacje, takie jak nazwy i zawartość obrazów.

using Microsoft.SemanticKernel.ChatCompletion;

// Add system message
chatHistory.Add(
    new() {
        Role = AuthorRole.System,
        Content = "You are a helpful assistant"
    }
);

// Add user message with an image
chatHistory.Add(
    new() {
        Role = AuthorRole.User,
        AuthorName = "Laimonis Dumins",
        Items = [
            new TextContent { Text = "What available on this menu" },
            new ImageContent { Uri = new Uri("https://example.com/menu.jpg") }
        ]
    }
);

// Add assistant message
chatHistory.Add(
    new() {
        Role = AuthorRole.Assistant,
        AuthorName = "Restaurant Assistant",
        Content = "We have pizza, pasta, and salad available to order. What would you like to order?"
    }
);

// Add additional message from a different user
chatHistory.Add(
    new() {
        Role = AuthorRole.User,
        AuthorName = "Ema Vargova",
        Content = "I'd like to have the first option, please."
    }
);

from semantic_kernel.contents.chat_history import ChatHistory
from semantic_kernel.contents import ChatMessageContent, TextContent, ImageContent
from semantic_kernel.contents.utils.author_role import AuthorRole

# Add system message
chat_history.add_message(
    ChatMessage(
        role=AuthorRole.System,
        content="You are a helpful assistant"
    )
)

# Add user message with an image
chat_history.add_message(
    ChatMessageContent(
        role=AuthorRole.USER,
        name="Laimonis Dumins",
        items=[
            TextContent(text="What available on this menu"),
            ImageContent(uri="https://example.com/menu.jpg")
        ]
    )
)

# Add assistant message
chat_history.add_message(
    ChatMessageContent(
        role=AuthorRole.ASSISTANT,
        name="Restaurant Assistant",
        content="We have pizza, pasta, and salad available to order. What would you like to order?"
    )
)

# Add additional message from a different user
chat_history.add_message(
    ChatMessageContent(
        role=AuthorRole.USER,
        name="Ema Vargova",
        content="I'd like to have the first option, please."
    )
)

import com.microsoft.semantickernel.services.chatcompletion.message.ChatMessageImageContent;
import com.microsoft.semantickernel.services.chatcompletion.message.ChatMessageTextContent;

// Add system message
chatHistory.addSystemMessage(
    "You are a helpful assistant"
);

// Add user message with an image
chatHistory.addUserMessage(
    "What available on this menu"
);

chatHistory.addMessage(
    ChatMessageImageContent.builder()
            .withImageUrl("https://example.com/menu.jpg")
            .build()
);

// Add assistant message
chatHistory.addAssistantMessage(
    "We have pizza, pasta, and salad available to order. What would you like to order?"
);

// Add additional message from a different user
chatHistory.addUserMessage(
    "I'd like to have the first option, please."
);

Symulowanie wywołań funkcji

Oprócz ról użytkownika, asystenta i systemu można również dodawać komunikaty z roli narzędzia w celu symulowania wywołań funkcji. Jest to przydatne w przypadku nauczania sztucznej inteligencji sposobu używania wtyczek i udostępniania dodatkowego kontekstu konwersacji.

Aby na przykład wstrzyknąć informacje o bieżącym użytkowniku w historii czatu bez konieczności podawania informacji przez użytkownika lub proszenia o nieużytkowania czasu w usłudze LLM, możesz użyć roli narzędzia, aby przekazać informacje bezpośrednio.

Poniżej przedstawiono przykład sposobu, w jaki możemy zapewnić alergie użytkownika asystentowi, symulując wywołanie funkcji do User wtyczki.

Napiwek

Symulowane wywołania funkcji są szczególnie przydatne w przypadku podawania szczegółowych informacji o bieżących użytkownikach. Dzisiejsze moduły LLM zostały przeszkolone, aby były szczególnie wrażliwe na informacje o użytkowniku. Nawet jeśli podasz szczegóły użytkownika w komunikacie systemowym, usługa LLM może nadal go zignorować. Jeśli podasz go za pośrednictwem komunikatu użytkownika lub komunikatu narzędzia, narzędzie LLM będzie bardziej prawdopodobne, aby go użyć.

// Add a simulated function call from the assistant
chatHistory.Add(
    new() {
        Role = AuthorRole.Assistant,
        Items = [
            new FunctionCallContent(
                functionName: "get_user_allergies",
                pluginName: "User",
                id: "0001",
                arguments: new () { {"username", "laimonisdumins"} }
            ),
            new FunctionCallContent(
                functionName: "get_user_allergies",
                pluginName: "User",
                id: "0002",
                arguments: new () { {"username", "emavargova"} }
            )
        ]
    }
);

// Add a simulated function results from the tool role
chatHistory.Add(
    new() {
        Role = AuthorRole.Tool,
        Items = [
            new FunctionResultContent(
                functionName: "get_user_allergies",
                pluginName: "User",
                id: "0001",
                result: "{ \"allergies\": [\"peanuts\", \"gluten\"] }"
            )
        ]
    }
);
chatHistory.Add(
    new() {
        Role = AuthorRole.Tool,
        Items = [
            new FunctionResultContent(
                functionName: "get_user_allergies",
                pluginName: "User",
                id: "0002",
                result: "{ \"allergies\": [\"dairy\", \"soy\"] }"
            )
        ]
    }
);

from semantic_kernel.contents import ChatMessageContent, FunctionCallContent, FunctionResultContent

# Add a simulated function call from the assistant
chat_history.add_message(
    ChatMessageContent(
        role=AuthorRole.ASSISTANT,
        items=[
            FunctionCallContent(
                name="get_user_allergies-User",
                id="0001",
                arguments=str({"username": "laimonisdumins"})
            ),
            FunctionCallContent(
                name="get_user_allergies-User",
                id="0002",
                arguments=str({"username": "emavargova"})
            )
        ]
    )
)

# Add a simulated function results from the tool role
chat_history.add_message(
    ChatMessageContent(
        role=AuthorRole.TOOL,
        items=[
            FunctionResultContent(
                name="get_user_allergies-User",
                id="0001",
                result="{ \"allergies\": [\"peanuts\", \"gluten\"] }"
            )
        ]
    )
)
chat_history.add_message(
    ChatMessageContent(
        role=AuthorRole.TOOL,
        items=[
            FunctionResultContent(
                name="get_user_allergies-User",
                id="0002",
                result="{ \"allergies\": [\"dairy\", \"gluten\"] }"
            )
        ]
    )
)

This functionality is not supported in the current version of Semantic Kernel for Java. 

Ważne

Podczas symulowania wyników narzędzia należy zawsze podać id wywołanie funkcji odpowiadające wynikowi. Jest to ważne, aby sztuczna inteligencja zrozumiała kontekst wyniku. Niektóre moduły LLM, takie jak OpenAI, zgłaszają błąd, jeśli id brakuje elementu lub jeśli id nie odpowiada wywołaniu funkcji.

Inspekcja obiektu historii czatów

Za każdym razem, gdy przekażesz obiekt historii czatu do usługi uzupełniania czatów z włączoną funkcją automatyczną, obiekt historii czatu będzie manipulowany tak, aby zawierał wywołania funkcji i wyniki. Pozwala to uniknąć konieczności ręcznego dodawania tych wiadomości do obiektu historii czatów, a także umożliwia sprawdzenie obiektu historii czatów w celu wyświetlenia wywołań funkcji i wyników.

Musisz jednak dodać końcowe wiadomości do obiektu historii czatu. Poniżej przedstawiono przykładowy sposób sprawdzania obiektu historii czatów w celu wyświetlenia wywołań funkcji i wyników.

using Microsoft.SemanticKernel.ChatCompletion;

ChatHistory chatHistory = [
    new() {
        Role = AuthorRole.User,
        Content = "Please order me a pizza"
    }
];

// Get the current length of the chat history object
int currentChatHistoryLength = chatHistory.Count;

// Get the chat message content
ChatMessageContent results = await chatCompletionService.GetChatMessageContentAsync(
    chatHistory,
    kernel: kernel
);

// Get the new messages added to the chat history object
for (int i = currentChatHistoryLength; i < chatHistory.Count; i++)
{
    Console.WriteLine(chatHistory[i]);
}

// Print the final message
Console.WriteLine(results);

// Add the final message to the chat history object
chatHistory.Add(results);

from semantic_kernel.contents import ChatMessageContent

chat_history = ChatHistory([
    ChatMessageContent(
        role=AuthorRole.USER,
        content="Please order me a pizza"
    )
])

# Get the current length of the chat history object
current_chat_history_length = len(chat_history)

# Get the chat message content
results = await chat_completion.get_chat_message_content(
    chat_history=history,
    settings=execution_settings,
    kernel=kernel,
)

# Get the new messages added to the chat history object
for i in range(current_chat_history_length, len(chat_history)):
    print(chat_history[i])

# Print the final message
print(results)

# Add the final message to the chat history object
chat_history.add_message(results)

import com.microsoft.semantickernel.services.chatcompletion.ChatHistory;

ChatHistory chatHistory = new ChatHistory();
chatHistory.addUserMessage("Please order me a pizza");

// Get the chat message content
List<ChatMessageContent> results = chatCompletionService.getChatMessageContentsAsync(
    chatHistory,
    kernel,
    null
).block();

results.forEach(result -> System.out.println(result.getContent());

// Get the new messages added to the chat history object. By default, 
// the ChatCompletionService returns new messages only. 
chatHistory.addAll(results);

Następne kroki

Teraz, gdy wiesz już, jak utworzyć obiekt historii czatów i zarządzać nim, możesz dowiedzieć się więcej na temat wywoływania funkcji w temacie Wywoływanie funkcji.

Dowiedz się, jak działa wywoływanie funkcji