Jak korzystać z wtyczki

Runtime AI Chatbot Integrator oferuje dwie główne funkcjonalności: czat Tekst-do-Tekstu oraz Tekst-na-Mowę (TTS). Obie funkcje działają według podobnego schematu:

Zarejestruj token dostawcy API
Skonfiguruj ustawienia specyficzne dla funkcji
Wysyłaj żądania i przetwarzaj odpowiedzi

Rejestracja tokena dostawcy

Przed wysłaniem jakichkolwiek żądań, zarejestruj token dostawcy API za pomocą funkcji RegisterProviderToken.

Blueprint
C++

// Register an OpenAI provider token, as an example
UAIChatbotCredentialsManager::RegisterProviderToken(
    EAIChatbotIntegratorOrgs::OpenAI, 
    TEXT("sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
);

Funkcjonalność czatu tekst-tekst

Wtyczka obsługuje dwa tryby żądań czatu dla każdego dostawcy:

Niestrumieniowe żądania czatu

Pobierz pełną odpowiedź w jednym wywołaniu.

OpenAI
DeepSeek
Claude

Blueprint
C++

Wyślij żądanie czatu OpenAI

// Example of sending a non-streaming chat request to OpenAI
FChatbotIntegrator_OpenAISettings Settings;
Settings.Messages.Add(FChatbotIntegrator_OpenAIMessage(
    EChatbotIntegrator_OpenAIRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_OpenAIMessage(
    EChatbotIntegrator_OpenAIRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorOpenAI::SendChatRequestNative(
    Settings, 
    FOnOpenAIChatCompletionResponseNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Chat completion response: %s, Error: %d: %s"), 
                *Response, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Blueprint
C++

Wyślij żądanie czatu DeepSeek

// Example of sending a non-streaming chat request to DeepSeek
FChatbotIntegrator_DeepSeekSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_DeepSeekMessage(
    EChatbotIntegrator_DeepSeekRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_DeepSeekMessage(
    EChatbotIntegrator_DeepSeekRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorDeepSeek::SendChatRequestNative(
    Settings, 
    FOnDeepSeekChatCompletionResponseNative::CreateWeakLambda(
        this, 
        [this](const FString& Reasoning, const FString& Content, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Chat completion reasoning: %s, Content: %s, Error: %d: %s"), 
                *Reasoning, *Content, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Blueprint
C++

Wyślij żądanie czatu Claude

// Example of sending a non-streaming chat request to Claude
FChatbotIntegrator_ClaudeSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_ClaudeMessage(
    EChatbotIntegrator_ClaudeRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_ClaudeMessage(
    EChatbotIntegrator_ClaudeRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorClaudeStream::SendStreamingChatRequestNative(
    Settings, 
    FOnClaudeChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat completion response: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *Response, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Żądania Czatu w Strumieniu

Otrzymuj fragmenty odpowiedzi w czasie rzeczywistym dla bardziej dynamicznej interakcji.

OpenAI
DeepSeek
Claude

Blueprint
C++

Wyślij Żądanie Czatu w Strumieniu OpenAI

// Example of sending a streaming chat request to OpenAI
FChatbotIntegrator_OpenAISettings Settings;
Settings.Messages.Add(FChatbotIntegrator_OpenAIMessage(
    EChatbotIntegrator_OpenAIRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_OpenAIMessage(
    EChatbotIntegrator_OpenAIRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorOpenAIStream::SendStreamingChatRequestNative(
    Settings, 
    FOnOpenAIChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat completion response: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *Response, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Blueprint
C++

Wyślij żądanie czatu strumieniowego DeepSeek

// Example of sending a streaming chat request to DeepSeek
FChatbotIntegrator_DeepSeekSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_DeepSeekMessage(
    EChatbotIntegrator_DeepSeekRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_DeepSeekMessage(
    EChatbotIntegrator_DeepSeekRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorDeepSeekStream::SendStreamingChatRequestNative(
    Settings, 
    FOnDeepSeekChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& ReasoningChunk, const FString& ContentChunk, 
               bool IsReasoningFinalChunk, bool IsContentFinalChunk, 
               const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat completion reasoning chunk: %s, Content chunk: %s, IsReasoningFinalChunk: %d, IsContentFinalChunk: %d, Error: %d: %s"), 
                *ReasoningChunk, *ContentChunk, IsReasoningFinalChunk, IsContentFinalChunk, 
                ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Blueprint
C++

Wyślij żądanie czatu strumieniowego Claude

// Example of sending a streaming chat request to Claude
FChatbotIntegrator_ClaudeSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_ClaudeMessage(
    EChatbotIntegrator_ClaudeRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_ClaudeMessage(
    EChatbotIntegrator_ClaudeRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorClaudeStream::SendStreamingChatRequestNative(
    Settings, 
    FOnClaudeChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat completion response: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *Response, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Funkcjonalność Text-to-Speech (TTS)

Konwertuj tekst na wysokiej jakości dźwięk mowy, korzystając z wiodących dostawców TTS. Wtyczka zwraca surowe dane audio (TArray<uint8>), które możesz przetworzyć zgodnie z potrzebami swojego projektu.

Podczas gdy poniższe przykłady demonstrują przetwarzanie audio do odtwarzania przy użyciu wtyczki Runtime Audio Importer (zobacz dokumentację importowania audio), Runtime AI Chatbot Integrator jest zaprojektowany tak, aby był elastyczny. Wtyczka po prostu zwraca surowe dane audio, dając Ci pełną swobodę w ich przetwarzaniu dla konkretnego przypadku użycia, co może obejmować odtwarzanie dźwięku, zapisywanie do pliku, dalsze przetwarzanie audio, przesyłanie do innych systemów, niestandardowe wizualizacje i wiele więcej.

Niestrumieniowe żądania TTS

Niestrumieniowe żądania TTS zwracają kompletne dane audio w jednej odpowiedzi po całkowitym przetworzeniu tekstu. To podejście jest odpowiednie dla krótszych tekstów, gdzie oczekiwanie na kompletny dźwięk nie stanowi problemu.

OpenAI TTS
ElevenLabs TTS

Blueprint
C++

Wyślij żądanie OpenAI TTS

// Example of sending a TTS request to OpenAI
FChatbotIntegrator_OpenAITTSSettings TTSSettings;
TTSSettings.Input = TEXT("Hello, this is a test of text-to-speech functionality.");
TTSSettings.Voice = EChatbotIntegrator_OpenAITTSVoice::NOVA;
TTSSettings.Speed = 1.0f;
TTSSettings.ResponseFormat = EChatbotIntegrator_OpenAITTSFormat::MP3;

UAIChatbotIntegratorOpenAITTS::SendTTSRequestNative(
	TTSSettings, 
	FOnElevenLabsTTSResponseNative::CreateWeakLambda(
		this, 
		[this](const TArray<uint8>& AudioData, const FChatbotIntegratorErrorStatus& ErrorStatus)
		{
			if (!ErrorStatus.bIsError)
			{
				// Process the audio data using Runtime Audio Importer plugin
				// Example: Import the audio data as a sound wave
				UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());

				// Audio data can be imported using Runtime Audio Importer plugin
				URuntimeAudioImporterLibrary* RuntimeAudioImporter = URuntimeAudioImporterLibrary::CreateRuntimeAudioImporter();
				RuntimeAudioImporter->AddToRoot();
				RuntimeAudioImporter->OnResultNative.AddWeakLambda(this, [this](URuntimeAudioImporterLibrary* Importer, UImportedSoundWave* ImportedSoundWave, ERuntimeImportStatus Status)
				{
					if (Status == ERuntimeImportStatus::SuccessfulImport)
					{
						UE_LOG(LogTemp, Warning, TEXT("Successfully imported audio with sound wave %s"), *ImportedSoundWave->GetName());
						// Here you can handle ImportedSoundWave playback, like "UGameplayStatics::PlaySound2D(GetWorld(), ImportedSoundWave);"
					}
					else
					{
						UE_LOG(LogTemp, Error, TEXT("Failed to import audio"));
					}

					Importer->RemoveFromRoot();
				});
				RuntimeAudioImporter->ImportAudioFromBuffer(AudioData, ERuntimeAudioFormat::Mp3);
			}
			else
			{
				UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *ErrorStatus.ErrorMessage);
			}
		}
	)
);

Blueprint
C++

Wyślij żądanie ElevenLabs TTS

// Example of sending a TTS request to ElevenLabs
FChatbotIntegrator_ElevenLabsTTSSettings TTSSettings;
TTSSettings.Text = TEXT("Hello, this is a test of text-to-speech functionality.");
TTSSettings.VoiceID = TEXT("your-voice-id"); // Replace with actual voice ID
TTSSettings.Model = EChatbotIntegrator_ElevenLabsTTSModel::ELEVEN_TURBO_V2;
TTSSettings.OutputFormat = EChatbotIntegrator_ElevenLabsTTSFormat::MP3_44100_128;

UAIChatbotIntegratorElevenLabsTTS::SendTTSRequestNative(
	TTSSettings, 
	FOnElevenLabsTTSResponseNative::CreateWeakLambda(
		this, 
		[this](const TArray<uint8>& AudioData, const FChatbotIntegratorErrorStatus& ErrorStatus)
		{
			if (!ErrorStatus.bIsError)
			{
				// Process the audio data using Runtime Audio Importer plugin
				// Example: Import the audio data as a sound wave
				UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());

				// Audio data can be imported using Runtime Audio Importer plugin
				URuntimeAudioImporterLibrary* RuntimeAudioImporter = URuntimeAudioImporterLibrary::CreateRuntimeAudioImporter();
				RuntimeAudioImporter->AddToRoot();
				RuntimeAudioImporter->OnResultNative.AddWeakLambda(this, [this](URuntimeAudioImporterLibrary* Importer, UImportedSoundWave* ImportedSoundWave, ERuntimeImportStatus Status)
				{
					if (Status == ERuntimeImportStatus::SuccessfulImport)
					{
						UE_LOG(LogTemp, Warning, TEXT("Successfully imported audio with sound wave %s"), *ImportedSoundWave->GetName());
						// Here you can handle ImportedSoundWave playback, like "UGameplayStatics::PlaySound2D(GetWorld(), ImportedSoundWave);"
					}
					else
					{
						UE_LOG(LogTemp, Error, TEXT("Failed to import audio"));
					}

					Importer->RemoveFromRoot();
				});
				RuntimeAudioImporter->ImportAudioFromBuffer(AudioData, ERuntimeAudioFormat::Mp3);
			}
			else
			{
				UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *ErrorStatus.ErrorMessage);
			}
		}
	)
);

Żądania TTS w trybie strumieniowym

Streaming TTS dostarcza fragmenty audio w miarę ich generowania, pozwalając na przetwarzanie danych przyrostowo zamiast czekać na syntezę całego audio. Znacząco redukuje to postrzegane opóźnienie dla dłuższych tekstów i umożliwia aplikacje działające w czasie rzeczywistym.

OpenAI Streaming TTS
ElevenLabs Streaming TTS

Blueprint
C++

Wyślij żądanie OpenAI Streaming TTS

UPROPERTY()
UStreamingSoundWave* StreamingSoundWave;

UPROPERTY()
bool bIsPlaying = false;

UFUNCTION(BlueprintCallable)
void StartStreamingTTS()
{
    // Create a sound wave for streaming if not already created
    if (!StreamingSoundWave)
    {
        StreamingSoundWave = UStreamingSoundWave::CreateStreamingSoundWave();
        StreamingSoundWave->OnPopulateAudioStateNative.AddWeakLambda(this, [this]()
        {
            if (!bIsPlaying)
            {
                bIsPlaying = true;
                UGameplayStatics::PlaySound2D(GetWorld(), StreamingSoundWave);
            }
        });
    }

    FChatbotIntegrator_OpenAIStreamingTTSSettings TTSSettings;
    TTSSettings.Text = TEXT("Streaming synthesis output begins with a steady flow of data. This data is processed in real-time to ensure consistency. As the process continues, information is streamed without interruption. The output adapts seamlessly to changing inputs. Each piece of data is instantly integrated into the stream. Real-time processing allows for immediate adjustments. This constant flow ensures that the synthesis output is dynamic. As new data comes in, the output evolves accordingly. The system is designed to maintain a continuous output stream. This uninterrupted flow is what drives the efficiency of streaming synthesis.");
    TTSSettings.Voice = EChatbotIntegrator_OpenAIStreamingTTSVoice::ALLOY;
    
    UAIChatbotIntegratorOpenAIStreamTTS::SendStreamingTTSRequestNative(TTSSettings, FOnOpenAIStreamingTTSNative::CreateWeakLambda(this, [this](const TArray<uint8>& AudioData, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
    {
        if (!ErrorStatus.bIsError)
        {
            // Process the audio data using Runtime Audio Importer plugin
            // Example: Stream audio data into a sound wave
            UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());
            StreamingSoundWave->AppendAudioDataFromRAW(AudioData, ERuntimeRAWAudioFormat::Int16, 24000, 1);
        }
        else
        {
            UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *ErrorStatus.ErrorMessage);
        }
    }));
}

Blueprint
C++

Wyślij żądanie ElevenLabs Streaming TTS

UPROPERTY()
UStreamingSoundWave* StreamingSoundWave;

UPROPERTY()
bool bIsPlaying = false;

UFUNCTION(BlueprintCallable)
void StartStreamingTTS()
{
    // Create a sound wave for streaming if not already created
    if (!StreamingSoundWave)
    {
        StreamingSoundWave = UStreamingSoundWave::CreateStreamingSoundWave();
        StreamingSoundWave->OnPopulateAudioStateNative.AddWeakLambda(this, [this]()
        {
            if (!bIsPlaying)
            {
                bIsPlaying = true;
                UGameplayStatics::PlaySound2D(GetWorld(), StreamingSoundWave);
            }
        });
    }

    FChatbotIntegrator_ElevenLabsStreamingTTSSettings TTSSettings;
    TTSSettings.Text = TEXT("Streaming synthesis output begins with a steady flow of data. This data is processed in real-time to ensure consistency. As the process continues, information is streamed without interruption. The output adapts seamlessly to changing inputs. Each piece of data is instantly integrated into the stream. Real-time processing allows for immediate adjustments. This constant flow ensures that the synthesis output is dynamic. As new data comes in, the output evolves accordingly. The system is designed to maintain a continuous output stream. This uninterrupted flow is what drives the efficiency of streaming synthesis.");
    TTSSettings.Model = EChatbotIntegrator_ElevenLabsTTSModel::ELEVEN_TURBO_V2_5;
    TTSSettings.OutputFormat = EChatbotIntegrator_ElevenLabsTTSFormat::MP3_22050_32;
    TTSSettings.VoiceID = TEXT("YOUR_VOICE_ID");
    
    UAIChatbotIntegratorElevenLabsStreamTTS::SendStreamingTTSRequestNative(GetWorld(), TTSSettings, FOnElevenLabsStreamingTTSNative::CreateWeakLambda(this, [this](const TArray<uint8>& AudioData, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
    {
        if (!ErrorStatus.bIsError)
        {
            // Process the audio data using Runtime Audio Importer plugin
            // Example: Stream audio data into a sound wave
            UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());
            StreamingSoundWave->AppendAudioDataFromEncoded(AudioData, ERuntimeAudioFormat::Mp3);
        }
        else
        {
            UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *ErrorStatus.ErrorMessage);
        }
    }));
}

Obsługa błędów

Podczas wysyłania jakichkolwiek żądań, kluczowe jest obsługiwanie potencjalnych błędów poprzez sprawdzanie ErrorStatus w twoim wywołaniu zwrotnym. ErrorStatus dostarcza informacji o wszelkich problemach, które mogą wystąpić podczas żądania.

Blueprint
C++

Obsługa błędów

// Example of error handling in a request
UAIChatbotIntegratorOpenAI::SendChatRequestNative(
    Settings, 
    FOnOpenAIChatCompletionResponseNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            if (ErrorStatus.bIsError)
            {
                // Handle the error
                UE_LOG(LogTemp, Error, TEXT("Chat request failed: %s"), *ErrorStatus.ErrorMessage);
            }
            else 
            {
                // Process the successful response
                UE_LOG(LogTemp, Log, TEXT("Received response: %s"), *Response);
            }
        }
    )
);

Anulowanie żądań

Wtyczka pozwala na anulowanie zarówno żądań tekst-na-tekst, jak i TTS, gdy są one w trakcie przetwarzania. Może to być przydatne, gdy chcesz przerwać długotrwałe żądanie lub dynamicznie zmienić przebieg rozmowy.

Blueprint
C++

Anuluj żądanie

// Example of cancelling requests
UAIChatbotIntegratorOpenAI* ChatRequest = UAIChatbotIntegratorOpenAI::SendChatRequestNative(
    ChatSettings, 
    ChatResponseCallback
);

// Cancel the chat request at any time
ChatRequest->Cancel();

// TTS requests can be cancelled similarly
UAIChatbotIntegratorOpenAITTS* TTSRequest = UAIChatbotIntegratorOpenAITTS::SendTTSRequestNative(
    TTSSettings, 
    TTSResponseCallback
);

// Cancel the TTS request
TTSRequest->Cancel();

Najlepsze praktyki

Zawsze obsługuj potencjalne błędy, sprawdzając ErrorStatus w swoim callbacku
Zwracaj uwagę na limity szybkości API i koszty
Używaj trybu strumieniowania dla długich lub interaktywnych konwersacji
Rozważ anulowanie żądań, które nie są już potrzebne, aby efektywnie zarządzać zasobami
Używaj strumieniowego TTS dla dłuższych tekstów, aby zmniejszyć postrzegane opóźnienie
Do przetwarzania audio, wtyczka Runtime Audio Importer oferuje wygodne rozwiązanie, ale możesz zaimplementować własne przetwarzanie w oparciu o potrzeby projektu

Rozwiązywanie problemów

Sprawdź, czy Twoje dane uwierzytelniające API są poprawne
Sprawdź swoje połączenie internetowe
Upewnij się, że wszystkie używane biblioteki do przetwarzania audio (takie jak Runtime Audio Importer) są poprawnie zainstalowane podczas pracy z funkcjami TTS
Sprawdź, czy używasz poprawnego formatu audio podczas przetwarzania danych odpowiedzi TTS
W przypadku strumieniowego TTS upewnij się, że poprawnie obsługujesz fragmenty audio

Rejestracja tokena dostawcy​

Funkcjonalność czatu tekst-tekst​

Niestrumieniowe żądania czatu​

Żądania Czatu w Strumieniu​

Funkcjonalność Text-to-Speech (TTS)​

Niestrumieniowe żądania TTS​

Żądania TTS w trybie strumieniowym​

Obsługa błędów​

Anulowanie żądań​

Najlepsze praktyki​

Rozwiązywanie problemów​

Rejestracja tokena dostawcy

Funkcjonalność czatu tekst-tekst

Niestrumieniowe żądania czatu

Żądania Czatu w Strumieniu

Funkcjonalność Text-to-Speech (TTS)

Niestrumieniowe żądania TTS

Żądania TTS w trybie strumieniowym

Obsługa błędów

Anulowanie żądań

Najlepsze praktyki

Rozwiązywanie problemów