Eklentiyi kullanma

Runtime AI Chatbot Integrator iki ana işlevsellik sağlar: Metinden Metne sohbet ve Metinden Sese (TTS). Her iki özellik de benzer bir iş akışı izler:

API sağlayıcı token'ınızı kaydedin
Özelliğe özgü ayarları yapılandırın
İstekleri gönderin ve yanıtları işleyin

Sağlayıcı Token'ını Kaydet

Herhangi bir istek göndermeden önce, API sağlayıcı token'ınızı RegisterProviderToken işlevini kullanarak kaydedin.

Blueprint
C++

Blueprint'te Sağlayıcı Token'ını Kaydet

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

Metinden Metine Sohbet İşlevselliği

Eklenti, her sağlayıcı için iki sohbet isteği modunu destekler:

Akışsız Sohbet İstekleri

Tam yanıtı tek bir çağrıda alın.

OpenAI
DeepSeek
Claude
Gemini
Grok

Blueprint
C++

OpenAI Sohbet İsteği Gönder

// 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 Sohbet İsteği Gönder

// 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 Sohbet İsteği Gönder

// 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 Sohbet İsteği Gönder

// 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 Sohbet İsteği Gönder

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

Akış Sohbet İstekleri

Daha dinamik bir etkileşim için yanıt parçalarını gerçek zamanlı olarak alın.

OpenAI
DeepSeek
Claude
Gemini
Grok

Blueprint
C++

OpenAI Akış Sohbet İsteği Gönder

// 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 Akışlı Sohbet İsteği Gönder

// 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 Akış Sohbet İsteği Gönder

// 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 Akış Sohbet İsteği Gönder

// 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 Akış Sohbet İsteği Gönder

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

Metinden Sese (TTS) İşlevselliği

Önde gelen TTS sağlayıcılarını kullanarak metni yüksek kaliteli konuşma sesine dönüştürün. Eklenti, projenizin ihtiyaçlarına göre işleyebileceğiniz ham ses verilerini (TArray<uint8>) döndürür.

Aşağıdaki örnekler, Runtime Audio Importer eklentisi kullanılarak ses işleme ve oynatmayı gösterse de (bkz. ses içe aktarma belgeleri), Runtime AI Chatbot Integrator esnek olacak şekilde tasarlanmıştır. Eklenti yalnızca ham ses verisini döndürür ve bu veriyi ses oynatma, dosyaya kaydetme, ileri ses işleme, diğer sistemlere iletme, özel görselleştirmeler ve daha fazlası gibi özel kullanım durumunuz için nasıl işleyeceğiniz konusunda size tam özgürlük tanır.

Akışsız TTS İstekleri

Akışsız TTS istekleri, tüm metin işlendikten sonra tam ses verisini tek bir yanıt olarak döndürür. Bu yaklaşım, tam sesin beklenmesinin sorun oluşturmadığı daha kısa metinler için uygundur.

OpenAI TTS
ElevenLabs TTS
Google Cloud TTS
Azure TTS

Blueprint
C++

OpenAI TTS İsteği Gönder

// 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 İsteği Gönder

// 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 İsteği Gönder

// 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 İsteği Gönder

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

Akış TTS İstekleri

Akış TTS, ses parçalarını oluşturuldukları gibi teslim eder, bu da tüm sesin sentezlenmesini beklemek yerine verileri artımlı olarak işlemenize olanak tanır. Bu, daha uzun metinler için algılanan gecikmeyi önemli ölçüde azaltır ve gerçek zamanlı uygulamalara olanak sağlar. ElevenLabs Akış TTS ayrıca dinamik metin oluşturma senaryoları için gelişmiş parçalı akış işlevlerini destekler.

OpenAI Streaming TTS
ElevenLabs Streaming TTS

Blueprint
C++

OpenAI Akış TTS İsteği Gönder

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, hem standart akış hem de gelişmiş parçalı akış modlarını destekler ve farklı kullanım durumları için esneklik sunar.

Standart Akış Modu

Standart akış modu, önceden tanımlanmış metni işler ve ses parçalarını oluşturuldukça iletir.

Blueprint
C++

Send ElevenLabs Streaming TTS Request

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

Parçalı Akış Modu

Parçalı akış modu, sentez sırasında metni dinamik olarak eklemenize olanak tanır, artımlı olarak üretilen metinler için (örneğin, AI sohbet yanıtları üretildikçe sentezlenirken) gerçek zamanlı uygulamalar için mükemmeldir. Bu modu etkinleştirmek için, TTS ayarlarınızda bEnableChunkedStreaming değerini true olarak ayarlayın.

Blueprint
C++

Başlangıç Kurulumu: TTS ayarlarınızda parçalı akış modunu etkinleştirerek ve ilk isteği oluşturarak parçalı akışı kurun:

Send ElevenLabs Chunked Streaming TTS Request

Sentez İçin Metin Ekle: Aktif bir parçalı akış oturumu sırasında dinamik olarak metin eklemek için bu düğümü kullanın. bContinuousMode parametresi, metnin nasıl işlendiğini kontrol eder:

Append Text For Synthesis

bContinuousMode true olduğunda: Metin, tam cümle sınırları (noktalar, ünlem işaretleri, soru işaretleri) algılanana kadar dahili olarak tamponlanır. Sistem, tamamlanmamış metni tamponda tutarken, otomatik olarak tam cümleleri sentez için çıkarır. Metin parçalar halinde veya cümle tamamlanması belirsiz olan kısmi kelimeler halinde geldiğinde bunu kullanın.
bContinuousMode false olduğunda: Metin, tamponlama veya cümle sınırı analizi olmadan hemen işlenir. Her çağrı, anlık parça işleme ve sentez ile sonuçlanır. Önceden oluşturulmuş tam cümlelere veya sınır tespiti gerektirmeyen ifadelere sahip olduğunuzda bunu kullanın.

Sürekli Tamponu Boşalt: Herhangi bir cümle sınırı algılanmasa bile, tamponlanmış sürekli metnin işlenmesini zorlar. Bir süre daha metin gelmeyeceğini bildiğinizde kullanışlıdır:

Flush Continuous Buffer

Sürekli Boşaltma Zaman Aşımını Ayarla: Belirtilen zaman aşımı içinde yeni metin gelmediğinde sürekli tamponun otomatik olarak boşaltılmasını yapılandırır:

Set Continuous Flush Timeout

Otomatik boşaltmayı devre dışı bırakmak için 0 olarak ayarlayın. Gerçek zamanlı uygulamalar için önerilen değerler 1-3 saniyedir.

Parçalı Akışı Bitir: Parçalı akış oturumunu kapatır ve mevcut sentezi nihai olarak işaretler. Metin eklemeyi bitirdiğinizde her zaman bunu çağırın:

Finish Chunked Streaming

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
    
    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)
{
    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()
{
    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)
{
    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()
{
    if (ChunkedTTSRequest)
    {
        // Flush any remaining buffered text
        ChunkedTTSRequest->FlushContinuousBuffer();
        
        // Mark the session as finished
        ChunkedTTSRequest->FinishChunkedStreaming();
    }
}

ElevenLabs Parçalı Akışın Temel Özellikleri:

Sürekli Mod: bContinuousMode true olduğunda, metin tam cümle sınırları algılanana kadar tamponlanır, ardından sentez için işlenir
Anında Mod: bContinuousMode false olduğunda, metin ayrı parçalar halinde tamponlama olmadan anında işlenir
Otomatik Temizleme: Yapılandırılabilir zaman aşımı, belirtilen süre içinde yeni girdi gelmediğinde tamponlanmış metni işler
Cümle Sınırı Algılama: Cümle sonlarını (., !, ?) algılar ve tamponlanmış metinden tam cümleleri çıkarır
Gerçek Zamanlı Entegrasyon: İçeriğin zaman içinde parçalar halinde geldiği artımlı metin girişini destekler
Esnek Metin Parçalama: Sentez işlemini optimize etmek için birden fazla strateji mevcuttur (Cümle Önceliği, Cümle Kesin, Boyuta Dayalı)

Mevcut Sesleri Alma

Bazı TTS sağlayıcıları, mevcut sesleri programlı olarak keşfetmek için ses listeleme API'leri sunar.

Google Cloud Voices
Azure Sesleri

Blueprint
C++

Google Cloud Seslerini Al

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

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

Hata Yönetimi

Herhangi bir istek gönderirken, geri çağırmanızda potansiyel hataları ele almak için ErrorStatus'u kontrol etmek çok önemlidir. ErrorStatus, istek sırasında oluşabilecek herhangi bir sorun hakkında bilgi sağlar.

Blueprint
C++

Hata Yönetimi

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

İstekleri İptal Etme

Eklenti, hem metinden-metne hem de TTS isteklerini devam ederken iptal etmenize olanak tanır. Bu, uzun süren bir isteği kesmek veya konuşma akışını dinamik olarak değiştirmek istediğinizde kullanışlı olabilir.

Blueprint
C++

İsteği İptal Et

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

En İyi Uygulamalar

Callback'lerinizde ErrorStatus'u kontrol ederek potansiyel hataları her zaman ele alın
Her sağlayıcı için API oran limitlerinin ve maliyetlerinin farkında olun
Uzun formlu veya etkileşimli konuşmalar için streaming modunu kullanın
Kaynakları verimli yönetmek için artık gerekli olmayan istekleri iptal etmeyi düşünün
Algılanan gecikmeyi azaltmak için daha uzun metinlerde streaming TTS kullanın
Ses işleme için, Runtime Audio Importer eklentisi kullanışlı bir çözüm sunar, ancak proje ihtiyaçlarınıza göre özel işleme uygulayabilirsiniz
Akıl yürütme modellerini (DeepSeek Reasoner, Grok) kullanırken, hem akıl yürütme hem de içerik çıktılarını uygun şekilde ele alın
TTS özelliklerini uygulamadan önce, ses listeleme API'larını kullanarak mevcut sesleri keşfedin
ElevenLabs chunked streaming için: Metin artımlı olarak oluşturulduğunda (AI yanıtları gibi) sürekli modu, önceden oluşturulmuş metin parçaları için anında modu kullanın
Sürekli mod için, duyarlılık ile doğal konuşma akışı arasında denge kurmak amacıyla uygun flush zaman aşımlarını yapılandırın
Uygulamanızın gerçek zamanlı gereksinimlerine göre optimal parça boyutlarını ve gönderme gecikmelerini seçin

Sorun Giderme

Her sağlayıcı için API kimlik bilgilerinizin doğru olduğunu doğrulayın
İnternet bağlantınızı kontrol edin
TTS özellikleriyle çalışırken kullandığınız ses işleme kütüphanelerinin (Runtime Audio Importer gibi) düzgün şekilde kurulduğundan emin olun
TTS yanıt verilerini işlerken doğru ses formatını kullandığınızı doğrulayın
Streaming TTS için, ses parçalarını doğru şekilde ele aldığınızdan emin olun
Akıl yürütme modelleri için, hem akıl yürütme hem de içerik çıktılarını işlediğinizden emin olun
Model kullanılabilirliği ve yetenekleri için sağlayıcıya özgü belgeleri kontrol edin
ElevenLabs chunked streaming için: Oturumu düzgün şekilde kapatmak için işiniz bittiğinde FinishChunkedStreaming'i çağırdığınızdan emin olun
Sürekli mod sorunları için: Metninizdeki cümle sınırlarının doğru şekilde tespit edildiğini kontrol edin
Gerçek zamanlı uygulamalar için: Gecikme gereksinimlerinize göre parça gönderme gecikmelerini ve flush zaman aşımlarını ayarlayın

Sağlayıcı Token'ını Kaydet​

Metinden Metine Sohbet İşlevselliği​

Akışsız Sohbet İstekleri​

Akış Sohbet İstekleri​

Metinden Sese (TTS) İşlevselliği​

Akışsız TTS İstekleri​

Akış TTS İstekleri​

Standart Akış Modu​

Parçalı Akış Modu​

Mevcut Sesleri Alma​

Hata Yönetimi​

İstekleri İptal Etme​

En İyi Uygulamalar​

Sorun Giderme​

Sağlayıcı Token'ını Kaydet

Metinden Metine Sohbet İşlevselliği

Akışsız Sohbet İstekleri

Akış Sohbet İstekleri

Metinden Sese (TTS) İşlevselliği

Akışsız TTS İstekleri

Akış TTS İstekleri

Standart Akış Modu

Parçalı Akış Modu

Mevcut Sesleri Alma

Hata Yönetimi

İstekleri İptal Etme

En İyi Uygulamalar

Sorun Giderme