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

Runtime AI Chatbot Integrator दो मुख्य कार्यक्षमताएं प्रदान करता है: टेक्स्ट-टू-टेक्स्ट चैट और टेक्स्ट-टू-स्पीच (टीटीएस)। दोनों सुविधाएं एक समान वर्कफ़्लो का पालन करती हैं:

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

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

किसी भी अनुरोध को भेजने से पहले, 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++

ग्रोक चैट अनुरोध भेजें

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

Send OpenAI Streaming Chat Request

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

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

// 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>) लौटाता है जिसे आप अपनी परियोजना की आवश्यकताओं के अनुसार प्रोसेस कर सकते हैं।

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

नॉन-स्ट्रीमिंग 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++

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

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

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 अनुरोध

स्टैंडर्ड स्ट्रीमिंग मोड

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

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

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

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

सर्वोत्तम अभ्यास

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