प्लगइन का उपयोग कैसे करें

रनटाइम एआई चैटबॉट इंटीग्रेटर दो मुख्य कार्यक्षमताएँ प्रदान करता है: टेक्स्ट-टू-टेक्स्ट चैट और टेक्स्ट-टू-स्पीच (TTS)। दोनों सुविधाएँ एक समान वर्कफ़्लो का पालन करती हैं:

अपने एपीआई प्रदाता टोकन को पंजीकृत करें
सुविधा-विशिष्ट सेटिंग्स कॉन्फ़िगर करें
अनुरोध भेजें और प्रतिक्रियाओं को संसाधित करें

प्रदाता टोकन पंजीकृत करें

किसी भी अनुरोध को भेजने से पहले, RegisterProviderToken फ़ंक्शन का उपयोग करके अपने एपीआई प्रदाता टोकन को पंजीकृत करें।

Blueprint
C++

ब्लूप्रिंट में प्रदाता टोकन पंजीकृत करें

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

पाठ-से-पाठ चैट कार्यक्षमता

प्लगइन प्रत्येक प्रदाता के लिए दो चैट अनुरोध मोड का समर्थन करता है:

गैर-स्ट्रीमिंग चैट अनुरोध

एक ही कॉल में पूर्ण प्रतिक्रिया प्राप्त करें।

OpenAI
DeepSeek
Claude
Gemini
Grok

Blueprint
C++

Send OpenAI Chat Request

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

डीपसीक चैट अनुरोध भेजें

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

क्लॉड चैट अनुरोध भेजें

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

Send Gemini Chat Request

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

स्ट्रीमिंग चैट अनुरोध

अधिक गतिशील इंटरैक्शन के लिए रीयल-टाइम में प्रतिक्रिया चंक प्राप्त करें।

OpenAI
DeepSeek
Claude
Gemini
Grok

Blueprint
C++

सेंड ओपनएआई स्ट्रीमिंग चैट रिक्वेस्ट

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

Send DeepSeek Streaming Chat Request

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

क्लॉड स्ट्रीमिंग चैट अनुरोध भेजें

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

Send Gemini Streaming Chat Request

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

टेक्स्ट-टू-स्पीच (TTS) कार्यक्षमता

अग्रणी TTS प्रदाताओं का उपयोग करके टेक्स्ट को उच्च-गुणवत्ता वाले स्पीच ऑडियो में बदलें। यह प्लगइन कच्चे ऑडियो डेटा (TArray<uint8>) लौटाता है जिसे आप अपनी परियोजना की आवश्यकताओं के अनुसार प्रोसेस कर सकते हैं।

हालांकि नीचे दिए गए उदाहरण रनटाइम ऑडियो इम्पोर्टर प्लगइन का उपयोग करके प्लेबैक के लिए ऑडियो प्रोसेसिंग प्रदर्शित करते हैं (देखें ऑडियो इम्पोर्टिंग डॉक्यूमेंटेशन), रनटाइम AI चैटबॉट इंटीग्रेटर लचीला होने के लिए डिज़ाइन किया गया है। प्लगइन केवल कच्चा ऑडियो डेटा लौटाता है, जो आपको आपके विशिष्ट उपयोग के मामले के लिए इसे कैसे प्रोसेस करते हैं, इसमें पूरी स्वतंत्रता देता है, जिसमें ऑडियो प्लेबैक, फ़ाइल में सहेजना, आगे की ऑडियो प्रोसेसिंग, अन्य सिस्टम को ट्रांसमिट करना, कस्टम विज़ुअलाइज़ेशन, और बहुत कुछ शामिल हो सकता है।

नॉन-स्ट्रीमिंग TTS अनुरोध

नॉन-स्ट्रीमिंग TTS अनुरोध पूरे टेक्स्ट के प्रोसेस हो जाने के बाद एक ही प्रतिक्रिया में संपूर्ण ऑडियो डेटा लौटाते हैं। यह दृष्टिकोण छोटे टेक्स्ट के लिए उपयुक्त है जहां संपूर्ण ऑडियो के लिए प्रतीक्षा करना समस्याग्रस्त नहीं है।

OpenAI TTS
ElevenLabs TTS
Google Cloud TTS
Azure TTS

Blueprint
C++

Send OpenAI TTS Request

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

Send ElevenLabs TTS Request

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

Send Google Cloud TTS Request

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

Send Azure TTS Request

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

Send OpenAI 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_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++

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

चंक्ड स्ट्रीमिंग मोड

चंक्ड स्ट्रीमिंग मोड आपको संश्लेषण के दौरान टेक्स्ट को गतिशील रूप से जोड़ने की अनुमति देता है, जो रीयल-टाइम अनुप्रयोगों के लिए एकदम सही है जहां टेक्स्ट वृद्धिशील रूप से उत्पन्न होता है (उदाहरण के लिए, एआई चैट प्रतिक्रियाएं जैसे ही उन्हें उत्पन्न किया जाता है उनका संश्लेषण किया जा रहा हो)। इस मोड को सक्षम करने के लिए, अपनी TTS सेटिंग्स में bEnableChunkedStreaming को true पर सेट करें।

Blueprint
C++

प्रारंभिक सेटअप: अपनी TTS सेटिंग्स में चंक्ड स्ट्रीमिंग मोड को सक्षम करके और प्रारंभिक अनुरोध बनाकर चंक्ड स्ट्रीमिंग सेट करें:

Send ElevenLabs Chunked Streaming TTS Request

संश्लेषण के लिए टेक्स्ट जोड़ें: सक्रिय चंक्ड स्ट्रीमिंग सत्र के दौरान गतिशील रूप से टेक्स्ट जोड़ने के लिए इस नोड का उपयोग करें। bContinuousMode पैरामीटर नियंत्रित करता है कि टेक्स्ट को कैसे संसाधित किया जाता है:

Append Text For Synthesis

जब bContinuousMode true हो: टेक्स्ट को आंतरिक रूप से तब तक बफर किया जाता है जब तक पूर्ण वाक्य सीमाओं (पूर्ण विराम, विस्मयादिबोधक चिह्न, प्रश्न चिह्न) का पता नहीं चल जाता। सिस्टम स्वचालित रूप से संश्लेषण के लिए पूर्ण वाक्यों को निकालता है जबकि अधूरे टेक्स्ट को बफर में रखता है। इसका उपयोग तब करें जब टेक्स्ट टुकड़ों या आंशिक शब्दों में आता हो जहां वाक्य पूर्णता अनिश्चित हो।
जब bContinuousMode false हो: टेक्स्ट को बफरिंग या वाक्य सीमा विश्लेषण के बिना तुरंत संसाधित किया जाता है। प्रत्येक कॉल के परिणामस्वरूप तत्काल चंक प्रसंस्करण और संश्लेषण होता है। इसका उपयोग तब करें जब आपके पास पूर्व-निर्मित पूर्ण वाक्य या वाक्यांश हों जिन्हें सीमा पहचान की आवश्यकता नहीं होती।

निरंतर बफर फ्लश करें: किसी भी बफर किए गए निरंतर टेक्स्ट के प्रसंस्करण को बलपूर्वक करता है, भले ही कोई वाक्य सीमा का पता नहीं चला हो। तब उपयोगी होता है जब आप जानते हैं कि कुछ देर के लिए और कोई टेक्स्ट नहीं आएगा:

Flush Continuous Buffer

निरंतर फ्लश टाइमआउट सेट करें: निर्दिष्ट टाइमआउट के भीतर कोई नया टेक्स्ट न आने पर निरंतर बफर के स्वचालित फ्लशिंग को कॉन्फ़िगर करता है:

Set Continuous Flush Timeout

स्वचालित फ्लशिंग को अक्षम करने के लिए 0 पर सेट करें। रीयल-टाइम अनुप्रयोगों के लिए अनुशंसित मान 1-3 सेकंड हैं।

चंक्ड स्ट्रीमिंग समाप्त करें: चंक्ड स्ट्रीमिंग सत्र को बंद करता है और वर्तमान संश्लेषण को अंतिम के रूप में चिह्नित करता है। जब आप टेक्स्ट जोड़ना समाप्त कर लें तो हमेशा इसे कॉल करें:

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

इलेवनलैब्स चंक्ड स्ट्रीमिंग की प्रमुख विशेषताएं:

निरंतर मोड: जब bContinuousMode true होता है, तो पाठ को तब तक बफर किया जाता है जब तक पूर्ण वाक्य सीमाओं का पता नहीं चल जाता, फिर संश्लेषण के लिए संसाधित किया जाता है
तत्काल मोड: जब bContinuousMode false होता है, तो पाठ को बिना बफर किए अलग-अलग चंक के रूप में तुरंत संसाधित किया जाता है
स्वचालित फ्लश: कॉन्फ़िगर करने योग्य टाइमआउट बफर किए गए पाठ को संसाधित करता है जब निर्दिष्ट समय सीमा के भीतर कोई नया इनपुट नहीं आता है
वाक्य सीमा पहचान: वाक्य समाप्ति (., !, ?) का पता लगाता है और बफर किए गए पाठ से पूर्ण वाक्य निकालता है
रियल-टाइम एकीकरण: वृद्धिशील पाठ इनपुट का समर्थन करता है जहां सामग्री समय के साथ टुकड़ों में आती है
लचीला पाठ चंकिंग: संश्लेषण प्रसंस्करण को अनुकूलित करने के लिए कई रणनीतियाँ उपलब्ध (वाक्य प्राथमिकता, वाक्य सख्त, आकार आधारित)

उपलब्ध आवाज़ें प्राप्त करना

कुछ TTS प्रदाता उपलब्ध आवाज़ों को प्रोग्रामेटिक रूप से खोजने के लिए वॉइस लिस्टिंग API प्रदान करते हैं।

Google Cloud Voices
Azure Voices

Blueprint
C++

Get Google Cloud Voices

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

Get Azure Voices

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

त्रुटि प्रबंधन

किसी भी अनुरोध को भेजते समय, अपने कॉलबैक में ErrorStatus की जाँच करके संभावित त्रुटियों को संभालना महत्वपूर्ण है। ErrorStatus अनुरोध के दौरान होने वाली किसी भी समस्या के बारे में जानकारी प्रदान करता है।

Blueprint
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++

Cancel Request

// 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 प्रतिक्रियाएँ) और पूर्व-निर्मित पाठ चंक्स के लिए तत्काल मोड का उपयोग करें
प्रतिक्रियात्मकता और प्राकृतिक भाषण प्रवाह के बीच संतुलन बनाने के लिए निरंतर मोड के लिए उपयुक्त फ्लश टाइमआउट कॉन्फ़िगर करें
अपनी एप्लिकेशन की वास्तविक-समय आवश्यकताओं के आधार पर इष्टतम चंक आकार और भेजने में देरी चुनें

समस्या निवारण

सत्यापित करें कि प्रत्येक प्रदाता के लिए आपके API क्रेडेंशियल सही हैं
अपने इंटरनेट कनेक्शन की जाँच करें
सुनिश्चित करें कि TTS सुविधाओं के साथ काम करते समय आपके द्वारा उपयोग की जाने वाली कोई भी ऑडियो प्रसंस्करण लाइब्रेरी (जैसे Runtime Audio Importer) ठीक से स्थापित है
सत्यापित करें कि TTS प्रतिक्रिया डेटा को प्रसंस्करण करते समय आप सही ऑडियो प्रारूप का उपयोग कर रहे हैं
स्ट्रीमिंग TTS के लिए, सुनिश्चित करें कि आप ऑडियो चंक्स को सही ढंग से संभाल रहे हैं
तर्क मॉडल के लिए, सुनिश्चित करें कि आप तर्क और सामग्री दोनों आउटपुट को प्रसंस्करण कर रहे हैं
मॉडल उपलब्धता और क्षमताओं के लिए प्रदाता-विशिष्ट प्रलेखन की जाँच करें
ElevenLabs चंक्ड स्ट्रीमिंग के लिए: सत्र को ठीक से बंद करने के लिए सुनिश्चित करें कि आप FinishChunkedStreaming को कॉल करते हैं जब काम पूरा हो जाए
निरंतर मोड समस्याओं के लिए: जाँच करें कि आपके पाठ में वाक्य सीमाएँ ठीक से पहचानी गई हैं
वास्तविक-समय अनुप्रयोगों के लिए: अपनी विलंबता आवश्यकताओं के आधार पर चंक भेजने में देरी और फ्लश टाइमआउट समायोजित करें

प्रदाता टोकन पंजीकृत करें​

पाठ-से-पाठ चैट कार्यक्षमता​

गैर-स्ट्रीमिंग चैट अनुरोध​

स्ट्रीमिंग चैट अनुरोध​

टेक्स्ट-टू-स्पीच (TTS) कार्यक्षमता​

नॉन-स्ट्रीमिंग TTS अनुरोध​

स्ट्रीमिंग TTS अनुरोध​

मानक स्ट्रीमिंग मोड​

चंक्ड स्ट्रीमिंग मोड​

उपलब्ध आवाज़ें प्राप्त करना​

त्रुटि प्रबंधन​

अनुरोध रद्द करना​

सर्वोत्तम प्रथाएँ​

समस्या निवारण​

प्रदाता टोकन पंजीकृत करें

पाठ-से-पाठ चैट कार्यक्षमता

गैर-स्ट्रीमिंग चैट अनुरोध

स्ट्रीमिंग चैट अनुरोध

टेक्स्ट-टू-स्पीच (TTS) कार्यक्षमता

नॉन-स्ट्रीमिंग TTS अनुरोध

स्ट्रीमिंग TTS अनुरोध

मानक स्ट्रीमिंग मोड

चंक्ड स्ट्रीमिंग मोड

उपलब्ध आवाज़ें प्राप्त करना

त्रुटि प्रबंधन

अनुरोध रद्द करना

सर्वोत्तम प्रथाएँ

समस्या निवारण