如何使用插件

Runtime AI Chatbot Integrator 提供兩項主要功能：文字對文字聊天和文字轉語音（TTS）。兩項功能的工作流程相似：

註冊您的 API 提供者令牌
配置功能特定設定
發送請求並處理回應

註冊提供者令牌

在發送任何請求之前，請使用 RegisterProviderToken 函數註冊您的 API 提供者令牌。

備註

Ollama 在本地運行，不需要 API 令牌。您可以跳過此步驟。

Blueprint
C++

在 Blueprint 中註冊提供者令牌

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

// Register other providers as needed
UAIChatbotCredentialsManager::RegisterProviderToken(
    EAIChatbotIntegratorOrgs::Anthropic, 
    TEXT("sk-ant-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
);

UAIChatbotCredentialsManager::RegisterProviderToken(
    EAIChatbotIntegratorOrgs::DeepSeek, 
    TEXT("sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
);

etc

文字對文字聊天功能

此插件為每個提供者支援兩種聊天請求模式：

非串流聊天請求

在單次呼叫中擷取完整回應。

Blueprint
C++

發送 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++

發送 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++

發送 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?")
});

UAIChatbotIntegratorClaude::SendChatRequestNative(
    Settings, 
    FOnClaudeChatCompletionResponseNative::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++

發送 Gemini 聊天請求

// Example of sending a non-streaming chat request to Gemini
FChatbotIntegrator_GeminiSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_GeminiMessage{
    EChatbotIntegrator_GeminiRole::USER, 
    TEXT("What is the capital of France?")
});

UAIChatbotIntegratorGemini::SendChatRequestNative(
    Settings, 
    FOnGeminiChatCompletionResponseNative::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++

發送 Grok 聊天請求

// Example of sending a non-streaming chat request to Grok
FChatbotIntegrator_GrokSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_GrokMessage{
    EChatbotIntegrator_GrokRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
});
Settings.Messages.Add(FChatbotIntegrator_GrokMessage{
    EChatbotIntegrator_GrokRole::USER, 
    TEXT("What is the capital of France?")
});

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

Blueprint
C++

發送 Ollama 聊天請求

// Example of sending a non-streaming chat request to Ollama
FChatbotIntegrator_OllamaSettings Settings;
Settings.Model = TEXT("gemma3");
Settings.BaseUrl = TEXT("http://localhost:11434");
Settings.Messages.Add(FChatbotIntegrator_OllamaMessage{
    EChatbotIntegrator_OllamaRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
});
Settings.Messages.Add(FChatbotIntegrator_OllamaMessage{
    EChatbotIntegrator_OllamaRole::USER, 
    TEXT("What is the capital of France?")
});

UAIChatbotIntegratorOllama::SendChatRequestNative(
    Settings, 
    FOnOllamaChatCompletionResponseNative::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++

傳送 OpenAI 串流聊天請求

// Example of sending a streaming chat request to OpenAI
FChatbotIntegrator_OpenAIStreamingSettings 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& ChunkContent, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat chunk: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *ChunkContent, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Blueprint
C++

發送 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 reasoning: %s, content: %s, Error: %d: %s"), 
                *ReasoningChunk, *ContentChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Blueprint
C++

發送 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& ChunkContent, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat chunk: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *ChunkContent, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Blueprint
C++

發送 Gemini 串流聊天請求

// Example of sending a streaming chat request to Gemini
FChatbotIntegrator_GeminiSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_GeminiMessage{
    EChatbotIntegrator_GeminiRole::USER, 
    TEXT("What is the capital of France?")
});

UAIChatbotIntegratorGeminiStream::SendStreamingChatRequestNative(
    Settings, 
    FOnGeminiChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& ChunkContent, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat chunk: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *ChunkContent, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Blueprint
C++

發送 Grok 串流聊天請求

// Example of sending a streaming chat request to Grok
FChatbotIntegrator_GrokSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_GrokMessage{
    EChatbotIntegrator_GrokRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
});
Settings.Messages.Add(FChatbotIntegrator_GrokMessage{
    EChatbotIntegrator_GrokRole::USER, 
    TEXT("What is the capital of France?")
});

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

Blueprint
C++

發送 Ollama 串流聊天請求

// Example of sending a streaming chat request to Ollama
FChatbotIntegrator_OllamaSettings Settings;
Settings.Model = TEXT("gemma3");
Settings.BaseUrl = TEXT("http://localhost:11434");
Settings.Messages.Add(FChatbotIntegrator_OllamaMessage{
    EChatbotIntegrator_OllamaRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
});
Settings.Messages.Add(FChatbotIntegrator_OllamaMessage{
    EChatbotIntegrator_OllamaRole::USER, 
    TEXT("What is the capital of France?")
});

UAIChatbotIntegratorOllamaStream::SendStreamingChatRequestNative(
    Settings, 
    FOnOllamaChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& ChunkContent, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat chunk: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *ChunkContent, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

文字轉語音 (TTS) 功能

使用領先的 TTS 供應商，將文字轉換為高品質的語音音訊。該外掛會回傳原始音訊資料 (TArray<uint8>)，您可以根據專案需求進行處理。

雖然以下範例示範了使用 Runtime Audio Importer 外掛進行音訊播放的處理流程（請參閱音訊匯入文件），但 Runtime AI Chatbot Integrator 的設計具有高度靈活性。該外掛僅回傳原始音訊資料，讓您可以完全自由地根據特定使用案例進行處理，可能包括音訊播放、儲存為檔案、進一步的音訊處理、傳輸到其他系統、自訂視覺化等等。

非串流 TTS 請求

非串流 TTS 請求會在整個文字處理完成後，於單一回應中回傳完整的音訊資料。此方法適用於較短的文字，在這種情況下等待完整音訊並非問題。

OpenAI TTS
ElevenLabs TTS
Google Cloud TTS
Azure TTS

藍圖
C++

傳送 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, 
	FOnOpenAITTSResponseNative::CreateWeakLambda(
		this, 
		[this](const TArray<uint8>& AudioData, const FChatbotIntegratorErrorStatus& ErrorStatus)
		{
			if (!ErrorStatus.bIsError)
			{
				// Process the audio data using Runtime Audio Importer plugin
				UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());

				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"));
						// Handle ImportedSoundWave playback
					}
					Importer->RemoveFromRoot();
				});
				RuntimeAudioImporter->ImportAudioFromBuffer(AudioData, ERuntimeAudioFormat::Mp3);
			}
		}
	)
);

Blueprint
C++

發送 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");
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)
			{
				UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());
				// Process audio data as needed
			}
		}
	)
);

Blueprint
C++

發送 Google Cloud TTS 請求

// Example of getting voices and then sending a TTS request to Google Cloud
// First, get available voices
UAIChatbotIntegratorGoogleCloudVoices::GetVoicesNative(
    TEXT("en-US"), // Optional language filter
    FOnGoogleCloudVoicesResponseNative::CreateWeakLambda(
        this, 
        [this](const TArray<FChatbotIntegrator_GoogleCloudVoiceInfo>& Voices, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            if (!ErrorStatus.bIsError && Voices.Num() > 0)
            {
                // Use the first available voice
                const FChatbotIntegrator_GoogleCloudVoiceInfo& FirstVoice = Voices[0];
                UE_LOG(LogTemp, Log, TEXT("Using voice: %s"), *FirstVoice.Name);

                // Now send TTS request with the selected voice
                FChatbotIntegrator_GoogleCloudTTSSettings TTSSettings;
                TTSSettings.Text = TEXT("Hello, this is a test of text-to-speech functionality.");
                TTSSettings.LanguageCode = FirstVoice.LanguageCodes.Num() > 0 ? FirstVoice.LanguageCodes[0] : TEXT("en-US");
                TTSSettings.VoiceName = FirstVoice.Name;
                TTSSettings.AudioEncoding = EChatbotIntegrator_GoogleCloudAudioEncoding::MP3;

                UAIChatbotIntegratorGoogleCloudTTS::SendTTSRequestNative(
                    TTSSettings, 
                    FOnGoogleCloudTTSResponseNative::CreateWeakLambda(
                        this, 
                        [this](const TArray<uint8>& AudioData, const FChatbotIntegratorErrorStatus& TTSErrorStatus)
                        {
                            if (!TTSErrorStatus.bIsError)
                            {
                                UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());
                                
                                // Process the audio data 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"));
                                        // Handle ImportedSoundWave playback
                                    }
                                    Importer->RemoveFromRoot();
                                });
                                RuntimeAudioImporter->ImportAudioFromBuffer(AudioData, ERuntimeAudioFormat::Mp3);
                            }
                            else
                            {
                                UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *TTSErrorStatus.ErrorMessage);
                            }
                        }
                    )
                );
            }
            else
            {
                UE_LOG(LogTemp, Error, TEXT("Failed to get voices: %s"), *ErrorStatus.ErrorMessage);
            }
        }
    )
);

Blueprint
C++

發送 Azure TTS 請求

// Example of getting voices and then sending a TTS request to Azure
// First, get available voices
UAIChatbotIntegratorAzureGetVoices::GetVoicesNative(
    EChatbotIntegrator_AzureRegion::EAST_US,
    FOnAzureVoiceListResponseNative::CreateWeakLambda(
        this, 
        [this](const TArray<FChatbotIntegrator_AzureVoiceInfo>& Voices, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            if (!ErrorStatus.bIsError && Voices.Num() > 0)
            {
                // Use the first available voice
                const FChatbotIntegrator_AzureVoiceInfo& FirstVoice = Voices[0];
                UE_LOG(LogTemp, Log, TEXT("Using voice: %s (%s)"), *FirstVoice.DisplayName, *FirstVoice.ShortName);

                // Now send TTS request with the selected voice
                FChatbotIntegrator_AzureTTSSettings TTSSettings;
                TTSSettings.Text = TEXT("Hello, this is a test of text-to-speech functionality.");
                TTSSettings.VoiceShortName = FirstVoice.ShortName;
                TTSSettings.LanguageCode = FirstVoice.Locale;
                TTSSettings.Region = EChatbotIntegrator_AzureRegion::EAST_US;
                TTSSettings.OutputFormat = EChatbotIntegrator_AzureTTSFormat::AUDIO_16KHZ_32KBITRATE_MONO_MP3;

                UAIChatbotIntegratorAzureTTS::SendTTSRequestNative(
                    TTSSettings, 
                    FOnAzureTTSResponseNative::CreateWeakLambda(
                        this, 
                        [this](const TArray<uint8>& AudioData, const FChatbotIntegratorErrorStatus& TTSErrorStatus)
                        {
                            if (!TTSErrorStatus.bIsError)
                            {
                                UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());
                                
                                // Process the audio data 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"));
                                        // Handle ImportedSoundWave playback
                                    }
                                    Importer->RemoveFromRoot();
                                });
                                RuntimeAudioImporter->ImportAudioFromBuffer(AudioData, ERuntimeAudioFormat::Mp3);
                            }
                            else
                            {
                                UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *TTSErrorStatus.ErrorMessage);
                            }
                        }
                    )
                );
            }
            else
            {
                UE_LOG(LogTemp, Error, TEXT("Failed to get voices: %s"), *ErrorStatus.ErrorMessage);
            }
        }
    )
);

串流 TTS 請求

串流 TTS 會在生成音訊區塊的同時即時傳送，讓您能夠增量處理資料，而無需等待整個音訊合成完畢。這能顯著減少較長文字的感知延遲，並實現即時應用。ElevenLabs 串流 TTS 也支援進階的區塊串流功能，適用於動態文字生成的場景。

OpenAI Streaming TTS
ElevenLabs Streaming TTS

Blueprint
C++

傳送 OpenAI 串流 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.");
    TTSSettings.Voice = EChatbotIntegrator_OpenAIStreamingTTSVoice::ALLOY;
    
    UAIChatbotIntegratorOpenAIStreamTTS::SendStreamingTTSRequestNative(TTSSettings, FOnOpenAIStreamingTTSNative::CreateWeakLambda(this, [this](const TArray<uint8>& AudioData, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
    {
        if (!ErrorStatus.bIsError)
        {
            UE_LOG(LogTemp, Log, TEXT("Received TTS audio chunk: %d bytes"), AudioData.Num());
            StreamingSoundWave->AppendAudioDataFromRAW(AudioData, ERuntimeRAWAudioFormat::Int16, 24000, 1);
        }
    }));
}

ElevenLabs Streaming TTS 支援標準串流和進階分塊串流模式，為不同使用情境提供靈活性。

標準串流模式

標準串流模式會處理預先定義的文字，並在生成音訊區塊時即時傳送。

Blueprint
C++

發送 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.");
    TTSSettings.Model = EChatbotIntegrator_ElevenLabsTTSModel::ELEVEN_TURBO_V2_5;
    TTSSettings.OutputFormat = EChatbotIntegrator_ElevenLabsTTSFormat::MP3_22050_32;
    TTSSettings.VoiceID = TEXT("YOUR_VOICE_ID");
    TTSSettings.bEnableChunkedStreaming = false; // Standard streaming mode
    
    UAIChatbotIntegratorElevenLabsStreamTTS::SendStreamingTTSRequestNative(GetWorld(), TTSSettings, FOnElevenLabsStreamingTTSNative::CreateWeakLambda(this, [this](const TArray<uint8>& AudioData, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
    {
        if (!ErrorStatus.bIsError)
        {
            UE_LOG(LogTemp, Log, TEXT("Received TTS audio chunk: %d bytes"), AudioData.Num());
            StreamingSoundWave->AppendAudioDataFromEncoded(AudioData, ERuntimeAudioFormat::Mp3);
        }
    }));
}

區塊串流模式

區塊串流模式允許您在合成過程中動態附加文字，非常適合文字是逐步生成的即時應用（例如，AI 聊天回應在生成時同步合成）。若要啟用此模式，請在您的 TTS 設定中將 bEnableChunkedStreaming 設為 true。

Blueprint
C++

初始設定： 透過在 TTS 設定中啟用區塊串流模式並建立初始請求來設定區塊串流。請求函數會傳回一個非同步動作物件，該物件提供了管理區塊串流工作階段的方法：

傳送 ElevenLabs 區塊串流 TTS 請求

附加文字以進行合成： 在傳回的非同步動作物件上使用此函數，以在進行中的區塊串流工作階段中動態新增文字。bContinuousMode 參數控制文字的處理方式：

附加文字以進行合成

當 bContinuousMode 為 true 時：文字會在內部緩衝，直到偵測到完整的句子邊界（句號、驚嘆號、問號）。系統會自動提取完整的句子進行合成，同時將不完整的文字保留在緩衝區中。當文字以片段或不完整的單詞形式到達，且無法確定句子是否完成時，請使用此模式。
當 bContinuousMode 為 false 時：文字會立即處理，無需緩衝或句子邊界分析。每次呼叫都會導致立即的區塊處理和合成。當您擁有預先形成的完整句子或短語，不需要邊界偵測時，請使用此模式。

刷新連續緩衝區： 強制處理非同步動作物件上任何已緩衝的連續文字，即使未偵測到句子邊界。當您知道一段時間內不會再有新文字到達時，此功能非常有用：

刷新連續緩衝區

設定連續刷新逾時： 設定在指定逾時時間內沒有新文字到達時，自動刷新非同步動作物件上的連續緩衝區：

設定連續刷新逾時

設為 0 以停用自動刷新。對於即時應用，建議值為 1-3 秒。

完成區塊串流： 關閉非同步動作物件上的區塊串流工作階段，並將當前合成標記為最終狀態。當您完成文字新增後，請務必呼叫此函數：

完成區塊串流

UPROPERTY()
UAIChatbotIntegratorElevenLabsStreamTTS* ChunkedTTSRequest;

UPROPERTY()
UStreamingSoundWave* StreamingSoundWave;

UPROPERTY()
bool bIsPlaying = false;

UFUNCTION(BlueprintCallable)
void StartChunkedStreamingTTS()
{
    // 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(""); // Start with empty text in chunked mode
    TTSSettings.Model = EChatbotIntegrator_ElevenLabsTTSModel::ELEVEN_TURBO_V2_5;
    TTSSettings.OutputFormat = EChatbotIntegrator_ElevenLabsTTSFormat::MP3_22050_32;
    TTSSettings.VoiceID = TEXT("YOUR_VOICE_ID");
    TTSSettings.bEnableChunkedStreaming = true; // Enable chunked streaming mode
    
    // Store the returned async action object to call chunked streaming functions on it
    ChunkedTTSRequest = UAIChatbotIntegratorElevenLabsStreamTTS::SendStreamingTTSRequestNative(
        GetWorld(), 
        TTSSettings, 
        FOnElevenLabsStreamingTTSNative::CreateWeakLambda(this, [this](const TArray<uint8>& AudioData, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            if (!ErrorStatus.bIsError && AudioData.Num() > 0)
            {
                UE_LOG(LogTemp, Log, TEXT("Received TTS audio chunk: %d bytes"), AudioData.Num());
                StreamingSoundWave->AppendAudioDataFromEncoded(AudioData, ERuntimeAudioFormat::Mp3);
            }
            
            if (IsFinalChunk)
            {
                UE_LOG(LogTemp, Log, TEXT("Chunked streaming session completed"));
                ChunkedTTSRequest = nullptr;
            }
        })
    );
    
    // Now you can append text dynamically as it becomes available
    // For example, from an AI chat response stream:
    AppendTextToTTS(TEXT("Hello, this is the first part of the message. "));
}

UFUNCTION(BlueprintCallable)
void AppendTextToTTS(const FString& AdditionalText)
{
    // Call AppendTextForSynthesis on the returned async action object
    if (ChunkedTTSRequest)
    {
        // Use continuous mode (true) when text is being generated word-by-word
        // and you want to wait for complete sentences before processing
        bool bContinuousMode = true;
        
        bool bSuccess = ChunkedTTSRequest->AppendTextForSynthesis(AdditionalText, bContinuousMode);
        if (bSuccess)
        {
            UE_LOG(LogTemp, Log, TEXT("Successfully appended text: %s"), *AdditionalText);
        }
    }
}

// Configure continuous text buffering with custom timeout
UFUNCTION(BlueprintCallable)
void SetupAdvancedChunkedStreaming()
{
    // Call SetContinuousFlushTimeout on the async action object
    if (ChunkedTTSRequest)
    {
        // Set automatic flush timeout to 1.5 seconds
        // Text will be automatically processed if no new text arrives within this timeframe
        ChunkedTTSRequest->SetContinuousFlushTimeout(1.5f);
    }
}

// Example of handling real-time AI chat response synthesis
UFUNCTION(BlueprintCallable)
void HandleAIChatResponseForTTS(const FString& ChatChunk, bool IsStreamFinalChunk)
{
    if (ChunkedTTSRequest)
    {
        if (!IsStreamFinalChunk)
        {
            // Append each chat chunk in continuous mode
            // The system will automatically extract complete sentences for synthesis
            ChunkedTTSRequest->AppendTextForSynthesis(ChatChunk, true);
        }
        else
        {
            // Add the final chunk
            ChunkedTTSRequest->AppendTextForSynthesis(ChatChunk, true);
            
            // Flush any remaining buffered text and finish the session
            ChunkedTTSRequest->FlushContinuousBuffer();
            ChunkedTTSRequest->FinishChunkedStreaming();
        }
    }
}

// Example of immediate chunk processing (bypassing sentence boundary detection)
UFUNCTION(BlueprintCallable)
void AppendImmediateText(const FString& Text)
{
    // Call AppendTextForSynthesis with continuous mode = false on the async action object
    if (ChunkedTTSRequest)
    {
        // Use continuous mode = false for immediate processing
        // Useful when you have complete sentences or phrases ready
        ChunkedTTSRequest->AppendTextForSynthesis(Text, false);
    }
}

UFUNCTION(BlueprintCallable)
void FinishChunkedTTS()
{
    // Call FlushContinuousBuffer and FinishChunkedStreaming on the async action object
    if (ChunkedTTSRequest)
    {
        // Flush any remaining buffered text
        ChunkedTTSRequest->FlushContinuousBuffer();
        
        // Mark the session as finished
        ChunkedTTSRequest->FinishChunkedStreaming();
    }
}

ElevenLabs 區塊串流的主要功能：

連續模式：當 bContinuousMode 設為 true 時，文字會先緩衝，直到偵測到完整的句子邊界，再進行合成處理
即時模式：當 bContinuousMode 設為 false 時，文字會立即以獨立區塊的形式處理，不進行緩衝
自動刷新：可設定的逾時機制，在指定時間內沒有新輸入時，會處理已緩衝的文字
句子邊界偵測：偵測句子結尾（.、!、?），並從緩衝文字中提取完整的句子
即時整合：支援增量文字輸入，內容會隨著時間以片段方式送達
彈性文字分塊：提供多種策略（句子優先、句子嚴格、基於大小），以優化合成處理

取得可用的語音

部分 TTS 提供者提供語音列表 API，可用程式化方式探索可用的語音。

Google Cloud 語音
Azure Voices

藍圖
C++

取得 Google Cloud 語音

// 範例程式碼

// Example of getting available voices from Google Cloud
UAIChatbotIntegratorGoogleCloudVoices::GetVoicesNative(
    TEXT("en-US"), // Optional language filter
    FOnGoogleCloudVoicesResponseNative::CreateWeakLambda(
        this, 
        [this](const TArray<FChatbotIntegrator_GoogleCloudVoiceInfo>& Voices, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            if (!ErrorStatus.bIsError)
            {
                for (const auto& Voice : Voices)
                {
                    UE_LOG(LogTemp, Log, TEXT("Voice: %s (%s)"), *Voice.Name, *Voice.SSMLGender);
                }
            }
        }
    )
);

Blueprint
C++

取得 Azure 語音

// Example of getting available voices from Azure
UAIChatbotIntegratorAzureGetVoices::GetVoicesNative(
    EChatbotIntegrator_AzureRegion::EAST_US,
    FOnAzureVoiceListResponseNative::CreateWeakLambda(
        this, 
        [this](const TArray<FChatbotIntegrator_AzureVoiceInfo>& Voices, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            if (!ErrorStatus.bIsError)
            {
                for (const auto& Voice : Voices)
                {
                    UE_LOG(LogTemp, Log, TEXT("Voice: %s (%s)"), *Voice.DisplayName, *Voice.Gender);
                }
            }
        }
    )
);

列出 Ollama 模型

您可以使用 ListOllamaModels 函數查詢本機 Ollama 實例中的所有可用模型。這對於動態填充 UI 中的模型選擇器非常有用。GetModelNames 輔助函數可從結果中提取名稱字串，以方便使用。

藍圖
C++

列出 Ollama 模型

// Example of listing locally available Ollama models
UAIChatbotIntegratorOllamaModelList::ListModelsNative(
    TEXT("http://localhost:11434"),
    FOnOllamaListModelsResponseNative::CreateWeakLambda(
        this,
        [this](const TArray<FOllamaModelInfo>& Models, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            if (!ErrorStatus.bIsError)
            {
                for (const FOllamaModelInfo& Model : Models)
                {
                    UE_LOG(LogTemp, Log, TEXT("Model: %s | Family: %s | Parameters: %s | Quantization: %s | Size: %lld bytes"),
                        *Model.Name, *Model.Family, *Model.ParameterSize, *Model.QuantizationLevel, Model.Size);
                }

                // Convenience helper to get just the name strings, e.g. for a UI dropdown
                TArray<FString> ModelNames = UAIChatbotIntegratorOllamaModelList::GetModelNames(Models);
            }
            else
            {
                UE_LOG(LogTemp, Error, TEXT("Failed to list Ollama models: %s"), *ErrorStatus.ErrorMessage);
            }
        }
    )
);

錯誤處理

在發送任何請求時，透過在回呼中檢查 ErrorStatus 來處理潛在的錯誤至關重要。ErrorStatus 提供了請求過程中可能發生的任何問題的相關資訊。

藍圖
C++

錯誤處理

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

取消請求

該插件允許您在文字轉文字和 TTS 請求進行中時取消它們。這在您想要中斷長時間運行的請求或動態更改對話流程時非常有用。

Blueprint
C++

取消請求

// 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();

最佳實踐

始終透過在回呼中檢查 ErrorStatus 來處理潛在錯誤
注意每個提供者的 API 速率限制和成本
對長篇或互動式對話使用串流模式
考慮取消不再需要的請求以有效管理資源
對較長文字使用串流 TTS 以減少感知延遲
對於音訊處理，Runtime Audio Importer 外掛提供了一個便利的解決方案，但您可以根據專案需求實作自訂處理
使用推理模型（DeepSeek Reasoner、Grok）時，請適當地處理推理和內容輸出
在實作 TTS 功能之前，使用語音列表 API 探索可用的語音
對於 ElevenLabs 區塊串流：當文字是增量生成時（如 AI 回應）使用連續模式，對預先形成的文字區塊使用即時模式
為連續模式設定適當的刷新逾時，以在回應性和自然語音流暢度之間取得平衡
根據應用程式的即時需求選擇最佳區塊大小和發送延遲
對於 Ollama：使用 ListOllamaModels 動態探索可用模型，而非硬編碼模型名稱

故障排除

驗證每個提供者的 API 憑證是否正確
檢查您的網路連線
確保您使用的任何音訊處理庫（例如 Runtime Audio Importer）在處理 TTS 功能時已正確安裝
驗證您在處理 TTS 回應資料時使用了正確的音訊格式
對於串流 TTS，請確保您正確處理音訊區塊
對於推理模型，請確保您同時處理推理和內容輸出
查閱特定提供者的文件以了解模型可用性和功能
對於 ElevenLabs 區塊串流：完成時確保呼叫 FinishChunkedStreaming 以正確關閉會話
對於連續模式問題：檢查文字中的句子邊界是否被正確偵測
對於即時應用程式：根據您的延遲需求調整區塊發送延遲和刷新逾時
對於 Ollama：在發送請求前，確保 Ollama 伺服器正在執行且可透過設定的 BaseUrl 存取

註冊提供者令牌​

文字對文字聊天功能​

非串流聊天請求​

串流聊天請求​

文字轉語音 (TTS) 功能​

非串流 TTS 請求​

串流 TTS 請求​

標準串流模式​

區塊串流模式​

取得可用的語音​

列出 Ollama 模型​

錯誤處理​

取消請求​

最佳實踐​

故障排除​

註冊提供者令牌

文字對文字聊天功能

非串流聊天請求

串流聊天請求

文字轉語音 (TTS) 功能

非串流 TTS 請求

串流 TTS 請求

標準串流模式

區塊串流模式

取得可用的語音

列出 Ollama 模型

錯誤處理

取消請求

最佳實踐

故障排除